Module:MOS degrees: Difference between revisions

local mosnot = require('Module:MOS notation')

-- Version 2 of the mos degrees moudle (by ganaraminukshuk)

-- Current TODO list:

-- - Optional note names column

 

-- Parses entries from a semicolon-delimited string and returns them in an array

-- TODO: Separate this and related functions (parse_pair and parse_kv_pairs) into its own module, as they're included

-- in various modules at this point, such as: scale tree, mos mdoes

local trimmed = entry:gsub("^%s*(.-)%s*$", "%1")

table.insert(parsed, trimmed) -- Add to array

 

-- A pair must be two elements or it will be returned as an empty array

for entry in string.gmatch(unparsed, '([^:]+)') do

table.insert(parsed, trimmed) -- Add to array

 

-- Helper function

function p.parse_step_ratio(unparsed)

-- Takes in a step pattern and a quantity of mossteps and calculates the number

-- of large and small steps in that interval (or substring), returned as an

-- It's an associative array b/c that's how the brightgen function in the mos

for i = 1, mossteps do

 

 

-- Takes in a mosstep (as an assoc. array containing the number of L's and s's),

-- and a step ratio (as 2-element array containing the sizes of L and s) and

 

-- Extracts the prefix from the mos module, without the dash and without any text after that

function p.get_mos_prefix(scale_sig)

local unparsed = mos.tamnams_prefix[scale_sig]

if unparsed == nil then

return "mos"

for entry in string.gmatch(unparsed, '([^-]+)') do

local trimmed = entry:gsub("^%s*(.-)%s*$", "%1")

table.insert(parsed, trimmed) -- Add to array

return parsed[1]

-- Helper function

-- Calculates note names and stores it in an associative array

function p.get_note_names(input_mos, udp, note_symbols, chroma_plus_symbol, chroma_minus_symbol, number_of_alterations)

-- Default parameters for input mos and step ratio (5L 2s and 2:1 step ratio)

local udp = {5,1} or udp

local chroma_plus_symbol = chroma_plus_symbol or "#"

local chroma_minus_symbol = chroma_minus_symbol or "b"

local number_of_alterations = number_of_alterations or 1

-- Get the number of generators going up and down from the UDP

local generators_up = udp[1]

local generators_down = udp[2]

local gens_up_per_period = generators_up / periods_per_equave

-- Create an empty asoociative array

local note_names = {}

-- Add the notes to the array

for j = 1, periods_per_equave do

for i = 1, #ascending_genchain[j] do

local note = ascending_genchain[j][i]

local note_symbol = string.sub(note_symbols, note['mossteps'] + 1, note['mossteps'] + 1)

local chroma_count = note['chromas']

-- Convert the encoded degree into text

local degree_encoded = ascending_degchain[j][i]

local degree_decoded = mosnot.mosstep_and_quality_to_degree(degree_encoded['mossteps'], degree_encoded['quality'], "m", "mosdegree", "abbreviated")

-- Add to note names

note_names[degree_decoded] = note_name

for i = 1, #descending_genchain[j] do

-- Convert the notationally agnostic form into a form that uses given notation

local note = descending_genchain[j][i]

local note_symbol = string.sub(note_symbols, note['mossteps'] + 1, note['mossteps'] + 1)

local chroma_count = note['chromas'] * -1

local note_name = note_symbol .. string.rep(chroma_minus_symbol, chroma_count)

-- Convert the encoded degree into text

local degree_encoded = descending_degchain[j][i]

-- For the descending chain, any mossteps that correspond to the root of

-- a period should correspond instead to the root one period up (EG, if

-- the root refers to the unison, it should be the degree one octave up)

local mossteps_transposed = degree_encoded['mossteps']

if mossteps_transposed % mossteps_per_period == 0 then

mossteps_transposed = mossteps_transposed + mossteps_per_period

local degree_decoded = mosnot.mosstep_and_quality_to_degree(mossteps_transposed, degree_encoded['quality'], "m", "mosdegree", "abbreviated")

note_names[degree_decoded] = note_name

return note_names

-- Helper function; generate the step vectors for every interval required for the table

function p.get_mosstep_vectors(input_mos, number_of_alterations)

-- Default params

local input_mos = input_mos or mos.new(5, 2)

local number_of_alterations = number_of_alterations or 0

-- Get the brightest mode

local brightest_mode = mos.brightest_mode(input_mos)

local mossteps_per_equave = (input_mos.nL + input_mos.ns)

local mossteps_per_period = mossteps_per_equave / utils._gcd(input_mos.nL, input_mos.ns)

-- Add intervals and their alterations, using the large interval size as the zero point for alterations

local mosstep_vectors = {}

for i = 1, mossteps_per_equave + 1 do

local mossteps = i - 1

-- With the unison, don't go down (only up), and with the equave, don't go up (only down).

-- Unison; the min number of alterations is 0

min_alterations = 0

max_alterations = number_of_alterations

elseif mossteps == mossteps_per_equave then

-- Equave; the max number of alterations is 0

min_alterations = -number_of_alterations

max_alterations = 0

elseif mossteps % mossteps_per_period == 0 then

-- Non-unison non-equave periods; the max and min have the "distance" from the zero point

min_alterations = -number_of_alterations

max_alterations = number_of_alterations

-- All other intervals; the min's distance is one more than the max's distance

min_alterations = -number_of_alterations - 1

max_alterations = number_of_alterations

-- Get the current mosstep vector based on the brightest mode

local current_mosstep_vector = p.mosstep_pattern_to_vector(brightest_mode, mossteps)

for j = min_alterations, max_alterations do

-- j is the number of chromas to add or subtract from the base vector

-- Since a chroma is defined as (L-s), add j large steps and subtract j small steps from the current mosstep vector

local L_count = current_mosstep_vector['L'] + j

local s_count = current_mosstep_vector['s'] - j

local current_mosstep_vector = { ['L'] = L_count, ['s'] = s_count }

table.insert(mosstep_vectors, current_mosstep_vector)

return mosstep_vectors

-- Helper function; generate the mosdegree names and their abbreviations for the mos

function p.get_mosdegree_names_and_abbrevs(input_mos, mos_prefix, number_of_alterations)

-- Default params

local input_mos = input_mos or mos.new(5, 2)

local number_of_alterations = number_of_alterations or 0

local mos_prefix = mos_prefix or "mos"

local mossteps_per_equave = (input_mos.nL + input_mos.ns)

local mossteps_per_period = mossteps_per_equave / utils._gcd(input_mos.nL, input_mos.ns)

-- Get the step counts for the bright and dark generators

local mossteps_per_bright_gen = bright_gen['L'] + bright_gen['s']

local mossteps_per_dark_gen = mossteps_per_period - mossteps_per_bright_gen

-- Main loop

-- Interval qualities depend on whether the intervals are generators or if there is only one size.

-- - If the interval class is a non-unison non-equave period, there are extensions before and after and there is only one size (perfect).

-- - If the interval class is a non-generator interval, or is the generator for an nL ns mos, there are extensions before and after and the sizes are major and minor.

local mosdegree_names = {}

local mosdegree_abbrevs = {}

for i = 1, mossteps_per_equave + 1 do

-- For calculating mossteps

-- Operation for pre-alterations (diminshed degrees)

for j = number_of_alterations, 1, -1 do

-- Calculate the main degree name and abbreviation

local degree_name = string.format("Perfect %d-%sstep", mossteps, mos_prefix)

local abbrev_name = string.format("P%dmd", mossteps)

-- Main operation

table.insert(mosdegree_names, degree_name)

table.insert(mosdegree_abbrevs, abbrev_name)

-- Operation for post-alterations (augmented degrees)

if number_of_alterations > 0 and mossteps ~= mossteps_per_equave then

local aug_degree = ""

if j == 1 then aug_degree = string.format("Augmented %d-%sstep", mossteps, mos_prefix)

else aug_degree = string.format("%d× Augmented %d-%sstep", j, mossteps, mos_prefix)

end

-- Format abbreviation as repetitions of the letter "A", followed by the mosdegree

local aug_abbrev = string.rep("A", j) .. string.format("%dmd", mossteps)

-- Insert

end

else

-- For intervals with two sizes

-- Operation for pre-alterations (diminshed degrees)

for j = number_of_alterations, 1, -1 do

-- The number of diminishings depends on whether the interval class is the bright gen; if so,

-- then one interval will already be diminished so intervals below that already start at 2xdim.

-- Diminished degree is formatted as "Diminished degree"; more than 1 augmentation is "2× Diminished", "3× Diminished", and so on

if dim_amount == 1 then dim_degree = string.format("Diminished %d-%sstep", mossteps, mos_prefix)

else dim_degree = string.format("%d× Diminished %d-%sstep", dim_amount, mossteps, mos_prefix)

-- Format abbreviation as repetitions of the letter "d", followed by the mosdegree

local dim_abbrev = string.rep("d", dim_amount) .. string.format("%dmd", mossteps)

-- Insert

-- Calculate the small and large names and abbreviations

local small_degree_label = "Minor"

-- Bright gen: diminished (small) and perfect (large)

-- Dark gen: perfect (small) and augmentd (large)

-- Main operation

local small_degree_name = string.format("%s %d-%sstep", small_degree_label, mossteps, mos_prefix)

local large_abbrev_name = string.format("%s%dmd", large_degree_abbrev, mossteps)

table.insert(mosdegree_abbrevs, large_abbrev_name)

-- Operation for post-alterations (augmented degrees)

for j = 1, number_of_alterations do

-- The number of augmentings depends on whether the interval class is the dark gen; if so,

-- then one interval will already be augmented so intervals above that already start at 2xaug.

if is_dark_gen then aug_amount = 1 + j

-- Augmented degree is formatted as "Augmented degree"; more than 1 augmentation is "2× Augmented", "3× Augmented", and so on

if aug_amount == 1 then aug_degree = string.format("Augmented %d-%sstep", mossteps, mos_prefix)

local aug_abbrev = string.rep("A", aug_amount) .. string.format("%dmd", mossteps)

table.insert(mosdegree_names, aug_degree)

table.insert(mosdegree_abbrevs, aug_abbrev)

end

return mosdegree_names, mosdegree_abbrevs

-- Separate function for testing; the main "frame" function will call this

function p.mos_degrees(input_mos, step_ratios, mos_prefix, show_abbreviations, number_of_alterations, ji_ratios, udp, notation)

-- Default params

local input_mos = input_mos or mos.new(5, 2)

local step_ratios = step_ratios or {{2,1}, {3,1}, {3,2}}

local mos_prefix = mos_prefix or "mos"

local ji_ratios = ji_ratios or {["P0md"]="1/1"}

--local udp = udp or {5,1} -- This is calculated later in the code

local scale_sig = mos.as_string(input_mos)

-- Get the brightest and darkest modes for the mos

local brightest_mode = mos.brightest_mode(input_mos)

local darkest_mode = string.reverse(brightest_mode)

-- Get the number of mossteps per period and equave, and periods per equave

local mossteps_per_equave = (input_mos.nL + input_mos.ns)

-- Get the step counts for the bright and dark generators

 

 

-- Precalculate the ets for each step ratio

-- Each et is used to calculate a scale degree's cent value

table.insert(ets_for_mos, et_for_mos)

-- Precalculate default comments for JI ratios; there's only two entries here

local default_ji_comments = {}

default_ji_comments[string.format("P%dmd", mossteps_per_equave)] = string.format("%s (exact)", rat.as_ratio(input_mos.equave))

local udp = udp or udp_default

-- Then, using the UDP, get the notation

-- The default notation is either standard notation (for 5L 2s) or diamond-mos (most other mosses)

-- If notation is passed in, use that instead

-- If no notation is passed in, notation will not be displayed

local note_names = {}

local show_note_names = false

local root_note = ""

if notation == "Default" then

note_names = p.get_note_names(input_mos, udp, "CDEFGAB", "#", "b", number_of_alterations)

root_note = "C"

local default_nominals = string.sub("JKLMNOPQRSTUVWXYZ", 1, mossteps_per_equave)

note_names = p.get_note_names(input_mos, udp, default_nominals, "&", "@", number_of_alterations)

root_note = "J"

elseif string.len(notation) > 0 then

local notation_parsed = mosnot.parse_notation(notation)

note_names = p.get_note_names(input_mos, udp, notation_parsed['Naturals'], notation_parsed["Sharp"], notation_parsed["Flat"], number_of_alterations)

root_note = string.sub(notation_parsed['Naturals'], 1, 1)

show_note_names = true

-- Create the table, starting with the headers

local result = '{| class="wikitable sortable"\n'

-- First row

result = result .. string.format("|+ Scale degree of %s\n", scale_sig)

result = result .. '! rowspan="2" class="unsortable" | Scale degree\n'

-- Add column for abbreviations

-- Abbreviations do not use a mos-prefix or mos-name

if show_abbrevs then

result = result .. '! rowspan="2" class="unsortable" | Abbrev.\n'

if show_note_names then

result = result .. string.format('! rowspan="2" class="unsortable" | On %s\n', root_note)

-- Add column headers for up to 5 different step ratios

-- Step ratio names, for reference

local tamnams_step_ratios = {

local step_ratio_key = step_ratio_simplified[1] .. ":" .. step_ratio_simplified[2]

local step_ratio_name = tamnams_step_ratios[step_ratio_key]

-- Add the step ratio name if there is one

result = result .. '! colspan="2" |' .. et_as_string .. " (L:s = " .. step_ratio_key .. ")\n"

result = result .. '! colspan="2" |' .. et_as_string .. " (" .. step_ratio_name .. ", L:s = " .. step_ratio_key .. ")\n"

-- Add JI ratio column header

-- Second row

-- Add in successive rows, containing the degree name, abbreviation (if applicable),

-- note names (if applicable), step size (in steps and cents), and JI ratio

for i = 1, #degree_names do

-- Add degree name

-- Make the text bold if the interval is a perfect interval

local degree_name = degree_names[i]

if string.find(degree_name, "Perfect") then

result = result .. string.format("| '''%s'''\n", degree_names[i])

result = result .. string.format("| %s\n", degree_names[i])

-- Add abbrev if allowed

local degree_abbrev = degree_abbrevs[i]

if show_abbrevs then

result = result .. string.format("| %s\n", degree_abbrev)

-- Add note names if allowed

-- Use the degree_abbrev as the key when accessing key-value pairs

if show_note_names then

result = result .. string.format("| %s\n", note_names[degree_abbrev])

-- Add mossteps and cent values

for j = 1, #ets_for_mos do

result = result .. string.format("| %s\n", etsteps)

result = result .. string.format("| %s\n", cents)

-- Add JI ratios if any

local ji_comment_entry = ""

result = result .. "|\n"

result = result .. string.format("| %s\n", default_ji_comment)

-- Entered comments but no default comments

result = result .. string.format("| %s\n", entered_ji_comment)

result = result .. string.format("| %s, %s\n", default_ji_comment, entered_ji_comment)