Module:MOS: Difference between revisions

-- Module for working with mosses in lua code; this serves as a "library" for

 

-- Following style guide: https://en.xen.wiki/w/User:Ganaram_inukshuk/Provisional_style_guide_for_Lua#Lua_style

-- Functionality includes:

-- - Creating/parsing mosses from string representations (scalesigs, xL ys)

-- - Creating scalesigs (string representations) of mosses

--  steps (EG, for 7\12, this is 7) or as a string (EG, 7\12 as a string).

------------------------------- HELPER FUNCTIONS -------------------------------

 

 

-- Create a new mos. (Contains the number of large and small steps, and equave.)

-- Parse a mos from its scalesig.

local nL, ns, equave = unparsed:match("^(%d+)[Ll]%s*(%d+)[Ss]%s*(.*)$")

------------------------------- STRING FUNCTIONS -------------------------------

-- Scalesig is "xL ys", or "xL ys<p/q>" for nonoctave scales.

-- Option to use nbsp is provided using the second param; default is no nbsp

local use_nbsp = (use_nbsp == nil and true or use_nbsp)

local suffix = ""

if not rat.eq(mos.equave, 2) then

suffix = "⟨" .. rat.as_ratio(mos.equave):lower() .. "⟩"

-- Option to use nbsp is provided using the second param; default is no nbsp

local use_nbsp = (use_nbsp == nil and true or use_nbsp)

local suffix = ""

if not rat.eq(mos.equave, 2) then

suffix = (use_nbsp and "&nbsp;" or " ") .. string.format("(%s-equivalent)", rat.as_ratio(mos.equave):lower())

return "" .. mos.nL .. "L" .. (use_nbsp and "&nbsp;" or " ") .. mos.ns .. "s" .. suffix

-- Find the parent mos of a mos. May return invalid mosses (nL 0s), meant

-- to represent equal divisions of the octave (or arbitrary equave).

function p.parent_mos(mos)

function p.root_mos(mos)

function p.child_mosses(mos)

function p.sister_mos(mos)

function p.neutralized_mos(mos)

function p.interleaved_mosses(mos)

-- Ordering here is based on the number of bright gens going DOWN PER PERIOD:

function p.mode_from_mos(mos, bright_gens_down)

-- List all unique rotations for a mode. Order of modes is by rotation.

-- (where p divides s with remainder = 0), then there will be p modes. It's also

-- possible to have only one mode, but this can only happen if there is only one

-- step size, meaning it's a unary scale (only one step size).

if not p.find_item_in_table(rotations, current_mode) then

-- shift it to the right. Helper function for mode_from_mos().

--------------- INTERVAL FUNCTIONS FOR PERFECTABLE INTERVALS -------------------

------------------ (IE, GENERATORS AND PERIOD INTERVALS) -----------------------

-- Compute the bright gen as a vector of L's and s's.

-- Bright gen has two sizes: perfect (large) and diminished (small). The size

-- given by this function is the large size.

-- Compute the dark gen as a vector of L's and s's.

-- Dark gen has two sizes: augmented (large) and perfect (small). The size given

-- by this function is the small size and is equal to the period complement of the

-- bright gen.

-- Compute the period as a vector of L's and s's. Period intervals only have one size: perfect.

-- Equave intervals only have one size: perfect. Equave and period intervals are

-- the same for single-period mosses.

------------------ INTERVAL FUNCTIONS FOR SIMPLE INTERVALS ---------------------

-- Compute the unison as a vector of L's and s's.

-- Compute the vector for a single chroma. It's a large step minus a small step.

-- Compute the vector for an augmented step. It's a large step plus a chroma.

-- Compute the vector for a single large step.

-- Compute the vector for a single small step.

-- Compute the vector for a diminished step. It's a small step minus a chroma.

-- Compute an arbitrary mos interval as a vector of L's and s's.

-- The step_count param is the number of mossteps in the interval. EG, in 5L 2s,

-- the large 2-mosstep is "LL", so the corresponding vector has L=2, s=0.

-- Mossteps larger than the equave (eg, the minor 9th in non-xen music theory)

-- The size_offset denotes whether the interval is the large size (0) or the

-- small size (-1). This can exceed the range of [-1, 0] to represent intervals

-- raised/lowered by multiple chromas (augmented, diminished, etc).

-- Note that for period intervals (eg, the root and equave), there is only one

-- size (0 = perfect), so -1 is diminished and 1 is augmented.

-- E.G., a perfect 4-diastep (perf. 5th) is 4 steps. Since it's the large size,

-- the offset is 0, but to get the diminished 5th, the offset should be -1.

-- Given a mos, compute the number of steps in its equave (L's plus s's).

-- If the number of chromas from a small (EG minor) interval is desired, then

-- using the param size_offset can be used: 0 for chromas from large size, -1

-- for chromas from small size. This can exceed the range [-1, 0] if needed.

-- E.G., a diminished 2-diastep (dim. 3rd) has the vector {0,2}. It's reached by

-- either lowering the major 2-step by 2 chromas, or lowering the minor 2-step

-- by 1 chroma.

----------------------- INTERVAL ARITHMETIC FUNCTIONS --------------------------

-- Repeatedly add the same interval to itself.

function p.mos_to_et(mos, step_ratio, suffix)

function p.mos_to_et_suffix(mos)

function p.mos_to_et_as_string(mos, step_ratio, suffix)

local et_mos = p.mos_to_et(mos, step_ratio, suffix)

function p.bright_gen_to_et_steps_as_string(mos, step_ratio, suffix)

return p.interval_to_et_steps_as_string(p.bright_gen(mos), mos, step_ratio, suffix)

function p.dark_gen_to_et_steps_as_string(mos, step_ratio, suffix)

return p.interval_to_et_steps_as_string(p.dark_gen(mos), mos, step_ratio, suffix)

function p.period_to_et_steps_as_string(mos, step_ratio, suffix)

return p.interval_to_et_steps_as_string(p.period(mos), mos, step_ratio, suffix)

-- as a string "{steps}\{division}{suffix}".

function p.reduced_period_to_et_steps_as_string(mos, suffix)

return p.interval_to_et_steps_as_string({["L"] = 1, ["s"] = 1}, p.root_mos(mos), {1,0}, suffix)

function p.equave_to_et_steps_as_string(mos, step_ratio, suffix)

return p.interval_to_et_steps_as_string(p.equave(mos), mos, step_ratio, suffix)

function p.interval_to_et_steps_as_string(interval, mos, step_ratio, suffix)

local mos_et = p.mos_to_et(mos, step_ratio, suffix)

local input_mos = p.new(4,4)

--return p.mos_to_et(p.new(5,2), {2,1})

return p.neutralized_mos(input_mos)