Module:MOS: Difference between revisions

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

-- Functionality includes:

-- - Creating/parsing mosses

-- - Finding equal tunings for mosses

local rat = require('Module:Rational')

local utils = require('Module:Utils')

local et = require('Module:ET')

-------------------------------- BASE FUNCTIONS --------------------------------

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

-- Pasre a mos from its scalesig.

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

equave = equave:match('^%((.*)-equivalent%)$') or equave:match('^⟨(.*)⟩$') or equave:match('^<(.*)>$') or '2/1' -- Assumes this is a rational ratio written a/b

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

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

function p.as_string(mos)

local suffix = ''

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

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

function p.as_long_string(mos)

local suffix = ''

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

suffix = string.format(" (%s-equivalent)", rat.as_ratio(mos.equave):lower())

return '' .. mos.nL .. 'L ' .. mos.ns .. 's' .. suffix

if interval['L'] == 0 then

elseif interval['L'] == 1 then

L_string = string.format("%dL", interval['L'])

if math.abs(interval['s']) == 0 then

L_string = ""

elseif math.abs(interval['s']) == 1 then

L_string = "s"

L_string = string.format("%ds", math.abs(interval['s']))

if L_string == "" and s_string == "" then

elseif L_string ~= "" and s_string == "" then  

return L_string .. (interval['s'] > 0 and " + " or " - ") .. s_string

nL = utils._round_dec(nL/d)

ns = utils._round_dec(ns/d)

local result = ''

             result = result .. 's'

             result = result .. 'L'

-- Find the darkest true-mos mode of a mos.

-- It's the reverse of the brightest mode.

nL = utils._round_dec(nL/d)

ns = utils._round_dec(ns/d)

local result = ''

             result = 's' .. result -- !esreveR

             result = 'L' .. result -- !esreveR

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

-- brightest mode, 1 is 2nd brightest, etc...

function p.mode_from_mos(mos, bright_gens_going_down)

return p.rotate_mode(p.brightest_mode(mos), bright_gens_going_down * p.bright_gen_step_count(mos))

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

local shift_amt = shift_amt == nil and 1 or shift_amt % #mode_string -- Defualt is 1

for i = 1, #mode_string + 1 do

local interval = p.interval_from_step_sequence(string.sub(mode_string, 0, steps))

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

nL = utils._round_dec(nL/d)

ns = utils._round_dec(ns/d)

local result = {['L'] = 0, ['s'] = 0}  

     local distance_here = math.abs(nL*current_s - ns*current_L)/math.sqrt(nL^2 + ns^2)

     result['L'] = current_L

     result['s'] = current_s

-- 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. It's the period complement of the bright

-- gen.

-- Period intervals only have one size: perfect.

['L'] = mos.nL / gcd,

['s'] = mos.ns / gcd

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

-- the same for single-period mosses.

['L'] = mos.nL,

['s'] = mos.ns

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

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

return { ['L'] = 0, ['s'] = 0 }

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

return { ['L'] = 1, ['s'] = -1 }

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

return { ['L'] = 2, ['s'] = -1 }

-- Compute the vector for a single large step.

return { ['L'] = 1, ['s'] = 0 }

-- Compute the vector for a single small step.

return { ['L'] = 0, ['s'] = 1 }

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

return { ['L'] = -1, ['s'] = 2 }

return { ['L'] = i, ['s'] = j }

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

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

-- - L: large step.

-- - s: small step.

-- - c: a chroma; the difference between a large and small step.

-- - A: an augmented step; a large step plus a chroma.

-- - d: a diminished step, or diesis; a small step minus a chroma.

return interval['L'] + interval['s']

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

return interval['L'] + interval['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.

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

return interval['L'] - base_interval['L'] - size_offset

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

['L'] = interval_1['L'] + interval_2['L'],

['s'] = interval_1['s'] + interval_2['s']

['L'] = interval_1['L'] - interval_2['L'],

['s'] = interval_1['s'] - interval_2['s']

-- Repeatedly add the same interval to itself.

['L'] = interval['L'] * amt,

['s'] = interval['s'] * amt

interval_1['L'] == interval_2['L'] and

interval_1['s'] == interval_2['s']

-- interval to add to produce the period.

function p.mos_to_et(mos, step_ratio)

return et.new(et_size, mos.equave, rat.as_ratio(mos.equave))

-- Given a mos and a step ratio, return the number of et-steps for its dark

-- generator.

-- corresponds to.

function p.interval_to_et_steps(interval, step_ratio)

return interval['L'] * step_ratio[1] + interval['s'] * step_ratio[2]

-- Given an interval vector and step ratio, convert it to cents. This requires

-- info about the mos itself.

--local interval = p.dark_gen(p.new(5,2))

--return p.interval_chroma_count(interval, p.new(5,2), -1)

--return p.equave_reduce({['L']=-3,['s']=-1},p.new(5,2))

--return p.interval_from_mos(p.new(5,2), 4, 1)

--return p.interval_from_step_sequence("LLLdLLc")

--return p.mode_from_mos(p.new(5,2), -90673)

--return p.mode_to_step_matrix(p.brightest_mode(p.new(5,4)))

--return p.mode_rotations("LssLLssL")

--return p.mode_rotations_to_step_matrices("LLsLsAs")

--return p.mode_from_mos(p.new(5,2),1)

local string_return = ""

for i = 1, 7 do

string_return = string_return .. p.mode_from_mos(p.new(5,2), i-1) .. "\n"