Module:MOS degrees: Difference between revisions

local p = {}

-- Helper function

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

function p.parse_entries(unparsed)

local parsed = {}

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

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

function p.parse_pair(unparsed)

local parsed = {}

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

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

function p.parse_step_ratio(unparsed)

local parsed = {}

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

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

end

return mosstep_vector

end

-- calculates number of et-steps.

function p.interval_to_etsteps(mosstep_vector, step_ratios)

end

-- Helper function

end

end

end

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

-- Default notation is diamond-mos, unless it's 5L 2s, then it's standard notation

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

local note_symbols = note_symbols or "CDEFGAB"

local chroma_plus_symbol = chroma_plus_symbol or "#"

local chroma_minus_symbol = chroma_minus_symbol or "b"

-- Get the number of mossteps per period and equave

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

local note = ascending_genchain[j][i]

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

-- Convert the encoded degree into text

local degree_encoded = ascending_degchain[j][i]

-- Add to note names

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

local note = descending_genchain[j][i]

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

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

end

-- Add to note names

end

end

return note_names

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

-- Default params

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

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

table.insert(mosstep_vectors, current_mosstep_vector)

end

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

-- Default params

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

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

local bright_gen = mos.bright_gen(input_mos)

local mossteps_per_dark_gen = mossteps_per_period - mossteps_per_bright_gen

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

local dim_degree = ""

end

-- Calculate the main degree name and abbreviation

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

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

local aug_degree = ""

end

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

local dim_degree = ""

end

-- Calculate the small and large names and abbreviations

local small_degree_label = "Minor"

local large_degree_label = "Major"

-- Main operation

local small_abbrev_name = string.format("%s%dmd", small_degree_abbrev, mossteps)

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

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

local aug_degree = ""

end

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

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

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

local number_of_alterations = number_of_alterations or 1

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

-- Get the scale sig

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

local bright_gen = mos.bright_gen(input_mos)

local steps_per_dark_gen = mossteps_per_period - steps_per_bright_gen

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

-- What's the equave in cents?

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

local round = 1

-- Precalculate the ets for each step ratio

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

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

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

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

local note_names = {}

local root_note = ""

end

-- Create the table, starting with the headers

-- First row

-- Add column for abbreviations

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

if show_abbrevs then

end

-- Add column for note names

end

-- Step ratio names, for reference

local tamnams_step_ratios = {

}

-- Add the step ratio name if there is one

if step_ratio_name == nil then

else

end

end

-- Add JI ratio column header

-- Second row

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

for i = 1, #step_ratios do

end

for i = 1, #degree_names do

-- Start new row

-- Add degree name

local degree_name = degree_names[i]

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

else

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

-- Add note names if allowed

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

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

end

-- Add mossteps and cent values

-- Rounding is hardcoded to one decimal place

local round = 1

for j = 1, #ets_for_mos do

local cents = utils._round_dec(et.cents(ets_for_mos[j], etsteps), round)

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

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

end

-- Add JI ratios if any

local ji_comment_entry = ""

local default_ji_comment = default_ji_comments[degree_abbrev]

local entered_ji_comment = ji_ratios[degree_abbrev]

if default_ji_comment == nil and entered_ji_comment == nil then

-- No comments

function p.mos_degrees_frame(frame)

-- Default param for input mos is 5L 2s

-- Get the scale sig; for calculating the mos prefix

-- Get the step ratio

-- Default param for mos prefix

-- If not left blank, use the prefix passed in instead

local mos_prefix = "mos"

mos_prefix = ""

if string.len(mos_prefix_lookup) ~= 0 then

mos_prefix = mos_prefix_lookup

end

else

end

-- Get whether to display abbreviations

local show_abbreviations = 0

show_abbreviations = 1

end

-- Get the number of alterations

local number_of_alterations = 0

end

-- Get JI ratios

local ji_ratios_parsed = {}

-- If the comments can't be parsed, default to an empty table

end

end

return p