Module:MOS degrees: Difference between revisions

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

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

-- This is based more off of the mos intervals module and older, non-tempalte tables that feature JI ratios,

-- and doesn't depend on genchains (except for note names) to calculate cent values or degree names.

 

-- 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

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

 

-- Helper function

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

-- associative array containing the large and small step counts.

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

function p.mosstep_pattern_to_vector(mosstep_pattern, mossteps)

local large_step_count = 0

local small_step_count = 0

for i = 1, mossteps do

local step = string.sub(mosstep_pattern, i, i)

if step == "L" then

large_step_count = large_step_count + 1

elseif step == "s" then

end

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

-- Convert the encoded degree into text

-- 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")

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)

-- Get the number of mossteps per period and equave

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

-- Consecutive alterations are always one chroma apart

-- With a perfect non-generator interval, alterations are added by going down and up the same amount

-- With all other intervals, since there are two sizes and the large interval size is treated as the zero point,

-- alterations are instead by going down n+1 chromas, then going up n chromas

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

local min_alterations = 0

if mossteps == 0 then

-- Unison; the min number of alterations is 0

min_alterations = 0

min_alterations = -number_of_alterations - 1

-- 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.

-- Cases for which there are alterations either below or above the main interval sizes, but not both:

-- - If the interval class is the unison, there are no extensions before it and there is only one size (perfect).

-- Cases for which there are alterations above and below the main interval sizes:

-- - 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.

-- - If the interval class is the bright generator, there are extensions before and after and the sizes are perfect (large) and diminished (small).

-- - If the interval class is the dark generator, there are extensions before and after and the sizes are augmented (large) and perfect (small).

local mosdegree_names = {}

for i = 1, mossteps_per_equave + 1 do

local mossteps = i - 1

-- For bright and dark gens

local is_nL_ns = input_mos.nL == input_mos.ns

local is_bright_gen = mossteps % mossteps_per_period == mossteps_per_bright_gen and not is_nL_ns

local is_dark_gen = mossteps % mossteps_per_period == mossteps_per_dark_gen and not is_nL_ns

if mossteps % mossteps_per_period == 0 then

-- For perfect intervals

-- Operation for pre-alterations (diminshed degrees)

if number_of_alterations > 0 and mossteps ~= 0 then

for j = number_of_alterations, 1, -1 do

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

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

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

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

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

-- Insert

-- 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)

for j = 1, number_of_alterations do

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

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

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

-- Operation for pre-alterations (diminshed degrees)

if number_of_alterations > 0 and mossteps ~= 0 then

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

if is_bright_gen then dim_amount = 1 + j

else dim_amount = j

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

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

table.insert(mosdegree_names, dim_degree)

table.insert(mosdegree_abbrevs, dim_abbrev)

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

small_degree_label = "Perfect"

large_degree_abbrev = "A"

-- Main operation

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

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

table.insert(mosdegree_abbrevs, aug_abbrev)

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, show_notation)

-- Default params; all parameters are already parsed

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

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

local notation = notation or mosnot.parse_notation("CDEFGAB; #; b")

-- Get the scale sig

local scale_sig = mos.as_string(input_mos)

-- 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

local bright_gen = mos.bright_gen(input_mos)

-- Get the step counts as a vector (or associative array, rather)

local input_mos_step_vector = {['L'] = input_mos.nL, ['s'] = input_mos.ns}

-- What's the equave in cents?

 

-- How many decimal places to round to? (hardcoded)

 

-- Precalculate the ets for each step ratio

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

local ets_for_mos = {}

for i = 1, #step_ratios do

local etsteps = p.interval_to_etsteps(input_mos_step_vector, step_ratios[i])

local et_for_mos = et.new(etsteps, input_mos.equave)

end

-- Precalculate degree names, degree abbreviations, and mosstep vectors

local degree_names, degree_abbrevs = p.get_mosdegree_names_and_abbrevs(input_mos, mos_prefix, number_of_alterations)

local mosstep_vectors = p.get_mosstep_vectors(input_mos, number_of_alterations)

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

local default_ji_comments = {}

default_ji_comments["P0md"] = "1/1 (exact)"

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

-- 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 root_note = ""

if show_notation then

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

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

-- 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_notation 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

result = result .. '! Rowspan="2" class="unsortable" | Approx. JI Ratios\n'

-- Add headers for the steps and cents up to 5 times

for i = 1, #step_ratios do

result = result .. '! Steps\n'

result = result .. '! Cents\n'

-- 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

-- Start new row

result = result .. "|-\n"

-- Add degree name

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

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_notation 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)