Module:MOS notation - Revision history

ArrowHead294: Sort dependencies

2025-05-19T13:26:13Z

Sort dependencies

← Older revision		Revision as of 13:26, 19 May 2025
Line 1:		Line 1:
	~~-- This is a helper module that contains commonly used functions for:~~		local p = {}
	~~-- - MOS gamut~~
	local mos = require("Module:MOS")		local mos = require("Module:MOS")
			local ord = require("Module:Ordinal")
	local rat = require("Module:Rational")		local rat = require("Module:Rational")
	~~local ord = require("Module:Ordinal")~~
	local utils = require("Module:Utils")		local utils = require("Module:Utils")
	~~local p = {}~~

	-- ----------------------------------------------------------------------------		-- ----------------------------------------------------------------------------

Ganaram inukshuk: only mos gamut uses mosnot

2024-08-25T10:53:11Z

only mos gamut uses mosnot

← Older revision		Revision as of 10:53, 25 August 2024
Line 1:		Line 1:
	-- This is a helper module that contains commonly used functions for:		-- This is a helper module that contains commonly used functions for:
	~~-- - MOS degrees~~
	-- - MOS gamut		-- - MOS gamut
	local mos = require("Module:MOS")		local mos = require("Module:MOS")

ArrowHead294 at 18:19, 8 August 2024

2024-08-08T18:19:00Z

← Older revision		Revision as of 18:19, 8 August 2024
Line 2:		Line 2:
	-- - MOS degrees		-- - MOS degrees
	-- - MOS gamut		-- - MOS gamut
	local mos = require('Module:MOS')		local mos = require("Module:MOS")
	local rat = require('Module:Rational')		local rat = require("Module:Rational")
	local ord = require('Module:Ordinal')		local ord = require("Module:Ordinal")
	local utils = require('Module:Utils')		local utils = require("Module:Utils")
	local p = {}		local p = {}

Line 24:		Line 24:

	local parsed = {}		local parsed = {}
	for entry in string.gmatch(unparsed, '([^;]+)') do		for entry in string.gmatch(unparsed, "([^;]+)") do
	local trimmed = entry:gsub("^%s(.-)%s$", "%1")		local trimmed = entry:gsub("^%s(.-)%s$", "%1")
	table.insert(parsed, trimmed) -- Add to array		table.insert(parsed, trimmed) -- Add to array
	end		end

	local notation = { ['Naturals'] = parsed[1], ['Sharp'] = parsed[2], ['Flat'] = parsed[3] }		local notation = { ["Naturals"] = parsed[1], ["Sharp"] = parsed[2], ["Flat"] = parsed[3] }
	if #parsed == 3 then		if #parsed == 3 then
	return notation		return notation
Line 42:		Line 42:

	local parsed = {}		local parsed = {}
	for entry in string.gmatch(unparsed, '([^/]+)') do		for entry in string.gmatch(unparsed, "([^/]+)") do
	local trimmed = entry:gsub("^%s(.-)%s$", "%1")		local trimmed = entry:gsub("^%s(.-)%s$", "%1")
	table.insert(parsed, trimmed) -- Add to array		table.insert(parsed, trimmed) -- Add to array
Line 73:		Line 73:

	local parsed = {}		local parsed = {}
	for entry in string.gmatch(step_ratio_unparsed, '([^,]+)') do		for entry in string.gmatch(step_ratio_unparsed, "([^,]+)") do
	local trimmed = entry:gsub("^%s(.-)%s$", "%1")		local trimmed = entry:gsub("^%s(.-)%s$", "%1")
	table.insert(parsed, trimmed) -- Add to array		table.insert(parsed, trimmed) -- Add to array
Line 114:		Line 114:

	-- Get the mossteps and quality from the encoded mosstep		-- Get the mossteps and quality from the encoded mosstep
	local mossteps = encoded_mosstep['Mossteps']		local mossteps = encoded_mosstep["Mossteps"]
	local quality = encoded_mosstep['Quality']		local quality = encoded_mosstep["Quality"]

	-- Notation options currently include:		-- Notation options currently include:
Line 247:		Line 247:
	-- Get the size of the generator in mossteps		-- Get the size of the generator in mossteps
	local gen = mos.bright_gen(input_mos)		local gen = mos.bright_gen(input_mos)
	local gen_in_mossteps = gen['L'] + gen['s']		local gen_in_mossteps = gen["L"] + gen["s"]

	-- If the genchain is descending (ie, going_up is false), switch to		-- If the genchain is descending (ie, going_up is false), switch to
Line 288:		Line 288:
	-- Get the final note name		-- Get the final note name
	local note_name = {}		local note_name = {}
	note_name['Mossteps'] = index + root_offest -- Mossteps needed to reach a note		note_name["Mossteps"] = index + root_offest -- Mossteps needed to reach a note
	note_name['Chromas'] = accidentals_to_add -- How many chromas		note_name["Chromas"] = accidentals_to_add -- How many chromas

	-- Add the note name		-- Add the note name
Line 348:		Line 348:
	-- Get the number of mossteps for the generators		-- Get the number of mossteps for the generators
	local bright_gen = mos.bright_gen(input_mos)		local bright_gen = mos.bright_gen(input_mos)
	local mossteps_per_bright_gen = bright_gen['L'] + bright_gen['s']		local mossteps_per_bright_gen = bright_gen["L"] + bright_gen["s"]
	local mossteps_per_dark_gen = mossteps_per_period - mossteps_per_bright_gen		local mossteps_per_dark_gen = mossteps_per_period - mossteps_per_bright_gen

Line 398:		Line 398:

	-- Put together the name		-- Put together the name
	local degree = { ['Mossteps'] = mossteps, ['Quality'] = quality }		local degree = { ["Mossteps"] = mossteps, ["Quality"] = quality }
	table.insert(chain_for_period, degree)		table.insert(chain_for_period, degree)
	end		end

Ganaram inukshuk: Renaming/reorganizing functions for sake of documentation, keys are now capitalized (mossteps, quality, and chromas); will momentarily break modules mos gamut and mos degrees v2

2023-10-22T07:18:54Z

Renaming/reorganizing functions for sake of documentation, keys are now capitalized (mossteps, quality, and chromas); will momentarily break modules mos gamut and mos degrees v2

Show changes

Ganaram inukshuk: Clarified comments, renamed params; genchain_length_per_period -> chain_length_per_period, refers to the number of elements in the resulting chain rather than generators stacked from the root

2023-10-15T21:01:33Z

Clarified comments, renamed params; genchain_length_per_period -> chain_length_per_period, refers to the number of elements in the resulting chain rather than generators stacked from the root

← Older revision		Revision as of 21:01, 15 October 2023
Line 96:		Line 96:
	-- Parameters:		-- Parameters:
	-- - input_mos - the mos itself represented as a data structure from Module:MOS		-- - input_mos - the mos itself represented as a data structure from Module:MOS
	-- - ~~genchain_init_per_period~~ - ~~how many named pitches per period are there without accidentals added?~~		-- - upd_gens_per_period - This is either the value u or d for the UDP of up\|dp, and is
	-- This is either the value u or d for the UDP of up\|dp.		-- used to calculate the number of initial notes that don't have accidentals.
	-- - ~~genchain_length_per_period~~ - ~~how many~~ generators ~~should the genchain extend~~ after the root?		-- Note that this is per period, so it's necessary to "simplify" the UDP like a fraction.
			-- - chain_length_per_period - the number of notes in the resulting chain. NOTE: if working
			-- in terms of "generators stacked after the root", add 1 to that value.
	-- - going_up - bool; whether the genchain is going up or down; true for up, false for down		-- - going_up - bool; whether the genchain is going up or down; true for up, false for down
	function p.mos_nomacc_chain(input_mos, ~~genchain_init_per_period~~, ~~genchain_length_per_period~~, going_up)		function p.mos_nomacc_chain(input_mos, upd_gens_per_period, chain_length_per_period, going_up)
	-- Default parameters for testing		-- Default parameters for testing
	--[[		--[[
	local input_mos = input_mos or mos.new(5, 2, 2)		local input_mos = input_mos or mos.new(5, 2, 2)
	local ~~genchain_init_per_period~~ = ~~genchain_init_per_period~~ or 5		local upd_gens_per_period = upd_gens_per_period or 5
	local ~~genchain_length_per_period~~ = ~~genchain_length_per_period~~ or 14		local chain_length_per_period = chain_length_per_period or 14
	local note_symbols = note_symbols or "CDEFGAB"		local note_symbols = note_symbols or "CDEFGAB"
	local chroma_symbol = chroma_symbol or "#"		local chroma_symbol = chroma_symbol or "#"
Line 155:		Line 157:
	-- Create the genchain		-- Create the genchain
	local genchain = { }		local genchain = { }
	for j = 1, ~~genchain_length_per_period~~ do		for j = 1, chain_length_per_period do

	-- Convert the accumulator into an index		-- Convert the accumulator into an index
Line 162:		Line 164:
	-- Add accidentals		-- Add accidentals
	-- This is negative if the genchain is descending		-- This is negative if the genchain is descending
	-- The ~~genchain_init_per_period~~ refers to the value u (or d for descending chains) in		-- The upd_gens_per_period refers to the value u (or d for descending chains) in
	-- the UDP of up\|dp. The first u notes reached by stacking up that many generators from the		-- the UDP of up\|dp. The first u notes reached by stacking up that many generators from the
	-- root don't have accidentals, but the number of notes that don't have accidentals		-- root don't have accidentals, but the number of notes that don't have accidentals
	-- is actually u+1, since the root doesn't have accidentals either.		-- is actually u+1, since the root doesn't have accidentals either.
	local accidentals_to_add = 0		local accidentals_to_add = 0
	if j > ~~genchain_init_per_period~~ + 1 then		if j > upd_gens_per_period + 1 then
	accidentals_to_add = math.ceil((j - ~~genchain_init_per_period~~ - 1) / mossteps_per_period)		accidentals_to_add = math.ceil((j - upd_gens_per_period - 1) / mossteps_per_period)
	end		end
	if not going_up then		if not going_up then
Line 193:		Line 195:
	end		end

	-- Helper function that ~~converts~~ a scale degree given as a quantity of mossteps		-- Helper function that decodes a scale degree given as a quantity of mossteps
	-- and a numeric quality (0=perf, 1=maj, -1=min, 2=aug, -2=dim, etc) into a		-- and a numeric quality (0=perf, 1=maj, -1=min, 2=aug, -2=dim, etc) into a
	-- scale degree		-- scale degree
Line 290:		Line 292:
	-- The following name rules are followed, and numeric values described above are used:		-- The following name rules are followed, and numeric values described above are used:
	-- - If an interval is the period (including the unison and equave), then the quality is perfect.		-- - If an interval is the period (including the unison and equave), then the quality is perfect.
	-- - ~~If an interval class is the bright gen~~, ~~then the qualities~~ are ~~perfect~~ (large size) and ~~diminished~~ (small size).		-- - For all other intervals, there are two sizes of major (large size) and minor (small size).
	-- - ~~If an interval class is~~ the dark ~~gen~~, ~~then~~ the ~~qualities~~ are augmented ~~(large size)~~ and perfect ~~(small size)~~.		-- - For bright generators of non-nL-ns mosses, the sizes are perfect and diminished instead.
	-- - ~~For all other intervals and for generators~~ of an nL ns ~~mos, then~~ the ~~qualities are~~ major ~~(large size)~~ and minor ~~(small size)~~.		-- - For dark generators of non-nL-ns mosses, the sizes are augmented and perfect instead.
	-- - Alterations ~~indicate~~ raising ~~the~~ large ~~size~~ or lowering ~~the~~ small ~~size~~ by a chroma~~, and are also denoted numerically~~.		-- - Generators of nL ns mosses use the terms major and minor instead.
	-- - ~~Intervals whose large~~ and ~~small sizes feature~~ already-~~augmented/diminished intervals will have the proper values to denote~~ 2x-augmented and 2x-diminished intervals.		-- - Alterations denote raising a large interval by a chroma, or lowering a small interval by a chroma.
	-- ~~For example, a dark gen has a large size~~ of ~~augmented~~, ~~so altering it by adding a chroma makes it 2x~~-~~augmented.~~		-- Since non-nL-ns mosses have augmented dark gen and diminished bright gen already, alterations
	function p.mos_degree_chain(input_mos, ~~genchain_length_per_period~~, going_up)		-- for those are 2x-augmented and 2x-diminished intervals; these are encoded accoringly.
			-- Params are as follows:
			-- - input_mos: the input mos itself
			-- - chain_length_per_period: the number of degrees in the resulting chain.
			-- NOTE: if working in terms of "generators stacked after the root", add 1 to that value.
			-- - going_up - whether the chain is built on stacking up or down; true for up, false for down
			function p.mos_degree_chain(input_mos, chain_length_per_period, going_up)
	-- Default parameters for testing		-- Default parameters for testing
	--[[		--[[
	local input_mos = input_mos or mos.new(5, 2, 2)		local input_mos = input_mos or mos.new(5, 2, 2)
	local ~~genchain_length_per_period~~ = ~~genchain_length_per_period~~ or 10		local chain_length_per_period = chain_length_per_period or 10
	local going_up = false		local going_up = false
	]]--		]]--
Line 318:		Line 326:
	local chain_for_period = {}		local chain_for_period = {}

	for i = 1, ~~genchain_length_per_period~~ do		for i = 1, chain_length_per_period do

	-- Calculate mossteps		-- Calculate mossteps

Ganaram inukshuk: Fixed bug with generating degree name for multi-diminished mosdegrees (rep took in a negative value)

2023-10-15T04:13:25Z

Fixed bug with generating degree name for multi-diminished mosdegrees (rep took in a negative value)

← Older revision		Revision as of 04:13, 15 October 2023
Line 268:		Line 268:
	degree_name = "d" .. degree_name		degree_name = "d" .. degree_name
	elseif quality < -2 then		elseif quality < -2 then
	degree_name = string.rep("d", quality - 1) .. degree_name		degree_name = string.rep("d", math.abs(quality) - 1) .. degree_name
	end		end
	end		end

Ganaram inukshuk: Fixed issue with hyphens appearing in abbreviated mosdegree names

2023-10-15T03:48:26Z

Fixed issue with hyphens appearing in abbreviated mosdegree names

← Older revision		Revision as of 03:48, 15 October 2023
Line 243:		Line 243:
	else		else
	if notation == "mosstep" then		if notation == "mosstep" then
	degree_name = mossteps ~~.. "-"~~ .. prefix .. "s"		degree_name = mossteps .. prefix .. "s"
	elseif notation == "mosdegree" then		elseif notation == "mosdegree" then
	degree_name = mossteps ~~.. "-"~~ .. prefix .. "d"		degree_name = mossteps .. prefix .. "d"
	elseif notation == "ordinal" then		elseif notation == "ordinal" then
	-- Add a dash between the prefix and ordinal, if a prefix is given		-- Add a dash between the prefix and ordinal, if a prefix is given

Ganaram inukshuk: Accidental counts in existing templates are displaying incorrect values, accidentals_to_add code calculation code corrected (hopefully), with comments clarifying the code

2023-10-15T02:29:40Z

Accidental counts in existing templates are displaying incorrect values, accidentals_to_add code calculation code corrected (hopefully), with comments clarifying the code

← Older revision		Revision as of 02:29, 15 October 2023
Line 105:		Line 105:
	local input_mos = input_mos or mos.new(5, 2, 2)		local input_mos = input_mos or mos.new(5, 2, 2)
	local genchain_init_per_period = genchain_init_per_period or 5		local genchain_init_per_period = genchain_init_per_period or 5
	local genchain_length_per_period = genchain_length_per_period or 10		local genchain_length_per_period = genchain_length_per_period or 14
	local note_symbols = note_symbols or "CDEFGAB"		local note_symbols = note_symbols or "CDEFGAB"
	local chroma_symbol = chroma_symbol or "#"		local chroma_symbol = chroma_symbol or "#"
Line 162:		Line 162:
	-- Add accidentals		-- Add accidentals
	-- This is negative if the genchain is descending		-- This is negative if the genchain is descending
			-- The genchain_init_per_period refers to the value u (or d for descending chains) in
			-- the UDP of up\|dp. The first u notes reached by stacking up that many generators from the
			-- root don't have accidentals, but the number of notes that don't have accidentals
			-- is actually u+1, since the root doesn't have accidentals either.
	local accidentals_to_add = 0		local accidentals_to_add = 0
	if j > genchain_init_per_period + 1 then		if j > genchain_init_per_period + 1 then
	accidentals_to_add = math.ceil((j - genchain_init_per_period + 1) / mossteps_per_period)		accidentals_to_add = math.ceil((j - genchain_init_per_period - 1) / mossteps_per_period)
	end		end
	if not going_up then		if not going_up then

Ganaram inukshuk: Fixed issue (hopefully) with nominal-accidental function producing a longer chain than the degree function, despite passing the same chain lengths

2023-10-15T02:11:04Z

Fixed issue (hopefully) with nominal-accidental function producing a longer chain than the degree function, despite passing the same chain lengths

← Older revision		Revision as of 02:11, 15 October 2023
Line 152:		Line 152:
	--local genchain = { root }		--local genchain = { root }
	local root_offest = (i - 1) * mossteps_per_period -- To make sure that, across all periods, every note has a unique index		local root_offest = (i - 1) * mossteps_per_period -- To make sure that, across all periods, every note has a unique index
	~~local root = { ['mossteps'] = root_offest, ['chromas'] = 0 }~~
	~~local genchain = { root }~~

	-- Create ~~the rest of~~ the genchain		-- Create the genchain
			local genchain = { }
	for j = 1, genchain_length_per_period do		for j = 1, genchain_length_per_period do
	~~-- Increment the index by the generator~~
	~~accumulator = accumulator + gen_in_mossteps~~

	-- Convert the accumulator into an index		-- Convert the accumulator into an index
	local index = accumulator % mossteps_per_period		local index = accumulator % mossteps_per_period
Line 166:		Line 163:
	-- This is negative if the genchain is descending		-- This is negative if the genchain is descending
	local accidentals_to_add = 0		local accidentals_to_add = 0
	if j > genchain_init_per_period then		if j > genchain_init_per_period + 1 then
	accidentals_to_add = math.ceil((j - genchain_init_per_period) / mossteps_per_period)		accidentals_to_add = math.ceil((j - genchain_init_per_period + 1) / mossteps_per_period)
	end		end
	if not going_up then		if not going_up then
Line 180:		Line 177:
	-- Add the note name		-- Add the note name
	table.insert(genchain, note_name)		table.insert(genchain, note_name)

			-- Increment the index by the generator
			accumulator = accumulator + gen_in_mossteps
	end		end

Ganaram inukshuk: Quickly added support for abbreviations for mosstep-quality-to-degree function; default is no abbreviations to avoid breaking existing templates

2023-10-14T19:19:22Z

Quickly added support for abbreviations for mosstep-quality-to-degree function; default is no abbreviations to avoid breaking existing templates

@@ Line 193: / Line 193: @@
 -- scale degree
 -- To be used in conjunction with the degrees function
--- TODO: add options to change naming and enumeration scheme; options include:
+-- For notation: options include mosstep, mosdegree, and ordinal (not recommended except for maybe 5L 2s)
--- - Abbreviations (Major/Minor vs Maj/Min vs M/m)
+-- For wording: options include abbreviated or not abbreviated (type in nothing for this option)
-function p.mosstep_and_quality_to_degree(mossteps, quality, prefix, notation)
+function p.mosstep_and_quality_to_degree(mossteps, quality, prefix, notation, wording)
 	-- Notation options currently include:
@@ Line 204: / Line 204: @@
 	local prefix = prefix or "mos"				-- Default prefix is mos
 	local notation = notation or "mosdegree"	-- Default notation is mosdegree
 	local degree_name = ""
 	if notation == "mosstep" then
-		degree_name = mossteps .. "-" .. prefix .. "step"
+	if wording ~= "abbreviated" then
-	elseif notation == "mosdegree" then
+		if notation == "mosstep" then
-		degree_name = mossteps .. "-" .. prefix .. "degree"
+			degree_name = mossteps .. "-" .. prefix .. "step"
-	elseif notation == "ordinal" then
+		elseif notation == "mosdegree" then
-		-- Add a dash between the prefix and ordinal, if a prefix is given
+			degree_name = mossteps .. "-" .. prefix .. "degree"
-		if prefix == "" then
+		elseif notation == "ordinal" then
-			degree_name = ord._ordinal(mossteps + 1)
+			-- Add a dash between the prefix and ordinal, if a prefix is given
-		else
+			if prefix == "" then
-			degree_name = prefix .. "-" .. ord._ordinal(mossteps + 1)
+				degree_name = ord._ordinal(mossteps + 1)
 		end
 	end