Module:MOS: Difference between revisions

Ganaram inukshuk (talk | contribs)
Removed ancestor function as it's now in the tamnams module
Ganaram inukshuk (talk | contribs)
mNo edit summary
 
(44 intermediate revisions by 2 users not shown)
Line 1: Line 1:
-- Module for working with mosses in lua code; this serves as a "library" for
-- This module follows [[User:Ganaram inukshuk/Provisional style guide for Lua]]
-- mos-related modules and thus does not have a corresponding template.
local et    = require("Module:ET")
-- Functionality includes:
local rat   = require("Module:Rational")
-- - Creating/parsing mosses
-- - Creating scalesigs (string representations) of mosses
-- - Finding certain modes of a mos
-- - Finding generators for a mos
-- - Producing vectors for simple mos intervals
-- - Interval arithmetic, in the form of adding vectors of L's and s's, and
--  period/equave-reducing intervals
-- - Finding equal tunings for mosses
local rat = require("Module:Rational")
local utils = require("Module:Utils")
local utils = require("Module:Utils")
local et = require("Module:ET")
 
local p = {}
local p = {}
-- Naming scheme for function names:
-- - Functions related to mosses don't have any special names.
-- - Functions related to a mos's modes generally end with "mode".
-- - Functions related to a mos's generators, equave, or period contain the
--  corresponding interval as part of its name.
-- - Functions related to intervals generally begin with "interval".
-- - Interval complement/reduce functions end with "complement" and "reduce".
-- - Functions that produce strings generally have the phrase "as string".
-- - Functions that "count" something generally end with "count".
-- - If a function requires an interval and mos as input, the interval(s) come
--  after the mos.
-- - Functions that have to do with equal tunings will have "et" in its name.


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
------------------------------- HELPER FUNCTIONS -------------------------------
----------------------------- MOS-CREATING FUNCTIONS ---------------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------


function p.find_item_in_table(table, item)
-- Create a new mos as a table containing the counts for large and small steps,
local item_found = false
-- plus the equave.
for i = 1, #table do
if table[i] == item then
item_found = true
break
end
end
return item_found
end
 
--------------------------------------------------------------------------------
-------------------------------- BASE FUNCTIONS --------------------------------
--------------------------------------------------------------------------------
 
-- Create a new mos. (Contains the number of large and small steps, and equave.)
function p.new(nL, ns, equave)
function p.new(nL, ns, equave)
local nL = nL or 5
local nL = nL or 5
Line 57: Line 20:
end
end


-- Pasre a mos from its scalesig.
-- Parse a mos from its scalesig "xL ys<p/q>" or "xL ys (p/q-equivalent)".
-- If no equave "p/q" is provided, it's assumed to be 2/1-equivalent.
function p.parse(unparsed)
function p.parse(unparsed)
local nL, ns, equave = unparsed:match("^(%d+)[Ll]%s*(%d+)[Ss]%s*(.*)$")
local nL, ns, equave = unparsed:match("^(%d+)[Ll].-(%d+)[Ss]%s*(.*)$")
nL = tonumber(nL)
nL = tonumber(nL)
ns = tonumber(ns)
ns = tonumber(ns)
Line 72: Line 36:


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
------------------------------- STRING FUNCTIONS -------------------------------
---------------------- VALIDATION AND CHECKING FUNCTIONS -----------------------
--------------------------------------------------------------------------------
 
-- Is the mos xL ys valid (x and y are greater than 0)?
function p.is_valid(mos)
return mos.nL > 0 and mos.ns > 0
end
 
-- Is the mos xL ys octave-equivalent?
function p.is_octave_equivalent(mos)
return rat.eq(mos.equave, rat.new(2))
end
 
-- Is the mos nL ns? (Root mos, with root in the sense of being the root of
-- the scale tree.)
function p.is_root_mos(mos)
return mos.nL == mos.ns
end
 
--------------------------------------------------------------------------------
---------------------------- STRING/LINK FUNCTIONS -----------------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------


-- Construct a string representation (scalesig) for a MOS structure.
-- Construct a string representation (scalesig) for a MOS structure.
-- Scalesig is "xL ys", or "xL ys<p/q>" for nonoctave scales.
-- Scalesig is "xL ys <p/q>" for valid mosses, omitting <p/q> for 2/1 scales.
function p.as_string(mos)
-- Degenerate mosses (nL 0s or 0L ns) produce a string for its corresponding
local suffix = ""
-- et (n-ed-p/q).
if not rat.eq(mos.equave, 2) then
-- Option to use nbsp is provided using the second param; default is nbsp.
suffix = "⟨" .. rat.as_ratio(mos.equave):lower() .. "⟩"
function p.as_string(mos, use_nbsp)
if p.is_valid(mos) then
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() .. "⟩"
end
return mos.nL .. "L" .. (use_nbsp and "&nbsp;" or " ") .. mos.ns .. "s" .. suffix
else
return math.max(mos.nL, mos.ns) .. p.et_suffix(mos)
end
end
return "" .. mos.nL .. "L " .. mos.ns .. "s" .. suffix
end
end


-- Construct a longer string representation for a MOS structure.
-- Construct a longer string representation for a MOS structure.
-- Scalesig is "xL ys", or "xL ys (p/q-equivalent)" for nonoctave scales.
-- Scalesig is "xL ys", or "xL ys (p/q-equivalent)" for nonoctave scales.
function p.as_long_string(mos)
-- Degenerate mosses (nL 0s or 0L ns) produce a string for its corresponding
local suffix = ""
-- et (n-ed-p/q).
if not rat.eq(mos.equave, 2) then
-- Option to use nbsp is provided using the second param; default is nbsp.
suffix = string.format(" (%s-equivalent)", rat.as_ratio(mos.equave):lower())
function p.as_long_string(mos, use_nbsp)
if p.is_valid(mos) then
local use_nbsp = (use_nbsp ~= nil and use_nbsp or true)
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())
end
return mos.nL .. "L" .. (use_nbsp and "&nbsp;" or " ") .. mos.ns .. "s" .. suffix
else
return math.max(mos.nL, mos.ns) .. p.et_suffix(mos)
end
end
end
return "" .. mos.nL .. "L " .. mos.ns .. "s" .. suffix
 
-- Construct the link to a mos. If the mos is a degenerate (nL 0s) mos, then it
-- will link to the corresponding equal-division page n-ed-p/q and display the
-- link text as an ed, rather than a mos.
function p.as_link(mos)
local link = p.as_long_string(mos)
local text = p.as_string(mos)
if link == text then
return string.format("[[%s]]", link)
else
return string.format("[[%s|%s]]", link, text)
end
end
 
-- Construct the link to a mos, where the displayed text is the long string
-- instead. Degenerate mosses link to the corresponding equal-division page.
function p.as_long_link(mos)
local link = p.as_long_string(mos)
return string.format("[[%s]]", link)
end
end


Line 129: Line 148:
return L_string .. (interval["s"] > 0 and " + " or " - ") .. s_string
return L_string .. (interval["s"] > 0 and " + " or " - ") .. s_string
end
end
end
-- Return the equave by itself as a string.
function p.equave_as_string(mos)
return rat.as_ratio(mos.equave)
end
-- Return the equave enclosed in brackets.
function p.equave_as_enclosed_string(mos)
return "⟨" .. rat.as_ratio(mos.equave) .. "⟩"
end
--------------------------------------------------------------------------------
----------------------- MOS RELATIVE/OPERATION FUNCTIONS -----------------------
--------------------------------------------------------------------------------
-- 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)
return p.new(math.min(mos.nL, mos.ns), math.abs(mos.nL-mos.ns), mos.equave)
end
-- Find the root of a mos nxL nys as nL ns.
function p.root(mos)
local num_periods = p.period_count(mos)
return p.new(num_periods, num_periods, mos.equave)
end
-- Find the two child mosses of a mos xL ys as (x+y)L xs and xL x+ys.
function p.children(mos)
return p.new(mos.nL+mos.ns, mos.nL, mos.equave), p.new(mos.nL, mos.nL+mos.ns, mos.equave)
end
-- Find the sister of a mos xL ys as yL xs.
function p.sister(mos)
return p.new(mos.ns, mos.nL, mos.equave)
end
-- Find the neutralized form of a mos. May return invalid mosses (nL 0s), meant
-- to represent equal divisions of the octave (or arbitrary equave).
function p.neutralized(mos)
if mos.nL > mos.ns then
return p.new(mos.nL-mos.ns, 2*mos.ns, mos.equave)
else
return p.new(2*mos.nL, mos.ns-mos.nL, mos.equave)
end
end
-- Find the two interleaved mosses of a mos xL ys as (2x+y)L ys and xL (x+2y)s.
function p.interleaved(mos)
return p.new(mos.nL*2+mos.ns, mos.ns, mos.equave), p.new(mos.nL, mos.ns*2+mos.nL, mos.equave)
end
end


Line 160: Line 230:
end
end


-- Find the darkest true-mos mode of a mos.
-- Find the darkest true-mos mode of a mos. It's the reverse of the brightest mode.
-- It's the reverse of the brightest mode.
function p.darkest_mode(mos)
function p.darkest_mode(mos)
local nL = mos.nL
local nL = mos.nL
Line 186: Line 255:


-- Given a mos, return a mode based on how it's ranked by modal brightness.
-- Given a mos, return a mode based on how it's ranked by modal brightness.
-- Ordering here is based on the number of bright gens going DOWN PER PERIOD:
-- Ordering here is based on the number of BRIGHT GENS DOWN PER PERIOD:
-- 0 is the brightest mode, 1 is 2nd brightest, etc...
-- 0 is the brightest mode, 1 is 2nd brightest, etc...
function p.mode_from_mos(mos, bright_gens_down)
-- To go by darkness, pass in p-d-1 for the 2nd arg, where p is the period count
-- and d is the number of DARK GENS UP PER PERIOD.
function p.mode_by_brightness(mos, bright_gens_down)
return p.rotate_mode(p.brightest_mode(mos), bright_gens_down * p.bright_gen_step_count(mos))
return p.rotate_mode(p.brightest_mode(mos), bright_gens_down * p.bright_gen_step_count(mos))
end
end
--------------------------------------------------------------------------------
--------------------------- MODE ROTATION FUNCTIONS ----------------------------
--------------------------------------------------------------------------------


-- Given a mos, list all modes in descending order of brightness.
-- Given a mos, list all modes in descending order of brightness.
Line 211: Line 278:
end
end


-- List all unique rotations for a mode. Order of modes is by rotation.
-- List all unique rotations for a mode, by order of leftward shifts. Order by
-- rotation will usually give a different order compared to order by brightness,
-- but this is expected if the order isn't by brightness (EG, modmosses).
-- Note: there will always be s/p modes, where s is the number of steps in the
-- Note: there will always be s/p modes, where s is the number of steps in the
-- entered mode, and p is the period of repetition. At most, there will be s
-- entered mode, and p is the period of repetition. At most, there will be s
-- modes, but if there is a substring of length p that repeats within the mode
-- modes, but if there is a substring of length p that repeats within the mode
-- (where p divides s with remainder = 0), then there will be p modes. It's also
-- (where s mod p = 0), then there will be p modes. If the mode has one step
-- possible to have only one mode, but this can only happen if there is only one
-- type, then there is only one mode.
-- step size, meaning it's a unary scale (only one step size).
function p.mode_rotations(mode_string)
function p.mode_rotations(mode_string)
local rotations = {}
local rotations = {}
local current_mode = mode_string
local current_mode = mode_string
for i = 1, #mode_string do
for i = 1, #mode_string do
if not p.find_item_in_table(rotations, current_mode) then
if not utils.table_contains(rotations, current_mode) then
table.insert(rotations, current_mode)
table.insert(rotations, current_mode)
end
end
Line 231: Line 299:


-- Rotate a mode by shifting the step sequence to the left. Negative values
-- Rotate a mode by shifting the step sequence to the left. Negative values
-- shift it to the right. Helper function for mode_from_mos().
-- shift it to the right. Helper function for mode_by_brightness().
function p.rotate_mode(mode_string, shift_amt)
function p.rotate_mode(mode_string, shift_amt)
local shift_amt = shift_amt == nil and 1 or shift_amt % #mode_string -- Default is 1
local shift_amt = shift_amt == nil and 1 or shift_amt % #mode_string -- Default is 1
Line 253: Line 321:
return matrix
return matrix
end
end
-- TODO?: replaces mode_to_step_matrices/mode_rotations_to_step_matrices with
-- one function called modes_to_step_matrices? Encompasses functionality of both
-- functions, but step patterns for either are generated into the same function,
-- where the modes as strings are passed in.


-- Given a mos, produce every step matrix for every mode. Modes are listed in
-- Given a mos, produce every step matrix for every mode. Modes are listed in
Line 276: Line 351:
return matrices
return matrices
end
-- Given an input mos, produce its modal union.
-- This is a listing of every interval's large and small sizes.
function p.modal_union(input_mos)
local brightest_mode = p.brightest_mode(input_mos)
local darkest_mode  = p.darkest_mode  (input_mos)
local interval_count = p.equave_step_count(input_mos) + 1
local modal_union = {}
for i = 1, interval_count do
local bright_step_seq = string.sub(brightest_mode, 1, i-1)
local dark_step_seq  = string.sub(darkest_mode  , 1, i-1)
local bright_interval = p.interval_from_step_sequence(bright_step_seq)
local dark_interval  = p.interval_from_step_sequence(dark_step_seq  )
if p.interval_eq(bright_interval, dark_interval) then
table.insert(modal_union, bright_interval)
else
table.insert(modal_union, dark_interval  )
table.insert(modal_union, bright_interval)
end
end
return modal_union
end
end


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
--------------- INTERVAL FUNCTIONS FOR PERFECTABLE INTERVALS -------------------
--------------- FUNCTIONS FOR GENERATOR AND PERIOD INTERVALS -------------------
------------------ (IE, GENERATORS AND PERIOD INTERVALS) -----------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------


-- Compute the bright gen as a vector of L's and s's.
-- Compute the bright gen as a vector of L's and s's. Since all mosstep
-- Bright gen has two sizes: perfect (large) and diminished (small). The size
-- intervals (excluding the root and period) have two sizes, this returns the
-- given by this function is the large size.
-- large/perfect size.
function p.bright_gen(mos)
function p.bright_gen(mos)
local nL = mos.nL
local nL = mos.nL
Line 316: Line 416:
end
end


-- Compute the dark gen as a vector of L's and s's.
-- Compute the dark gen as a vector of L's and s's. Since all mosstep
-- Dark gen has two sizes: augmented (large) and perfect (small). The size given
-- intervals (excluding the root and period) have two sizes, this returns the
-- by this function is the small size. It's the period complement of the bright
-- small/perfect size.
-- gen.
function p.dark_gen(mos)
function p.dark_gen(mos)
local bright_gen = p.bright_gen(mos)
local bright_gen = p.bright_gen(mos)
Line 326: Line 425:


-- Compute the period as a vector of L's and s's.
-- Compute the period as a vector of L's and s's.
-- Period intervals only have one size: perfect.
-- Period intervals as mossteps only appear as one size.
function p.period(mos)  
function p.period(mos)  
local gcd = utils._gcd(mos.nL, mos.ns)
local gcd = utils._gcd(mos.nL, mos.ns)
Line 336: Line 435:


-- Compute the equave as a vector of L's and s's.
-- Compute the equave as a vector of L's and s's.
-- Equave intervals only have one size: perfect. Equave and period intervals are
-- Equaves as mossteps only appear as one size. For a single-period mos, this
-- the same for single-period mosses.
-- is the same as p.period().
function p.equave(mos)  
function p.equave(mos)  
return {
return {
Line 346: Line 445:


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
------------------ INTERVAL FUNCTIONS FOR SIMPLE INTERVALS ---------------------
------------------- FUNCTIONS FOR SINGLE-STEP INTERVALS ------------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------


-- Compute the unison as a vector of L's and s's.
-- Return the unison as a vector of L's and s's.
-- The unison is denoted by moving up from the root by zero steps, and thus does
-- The unison is denoted by moving up from the root by zero steps, and thus does
-- not need a mos as input. It's basically a zero vector.
-- not need a mos as input. It's basically a zero vector.
Line 357: Line 456:
end
end


-- Compute the vector for a single chroma. It's a large step minus a small step.
-- Return the vector for a single chroma. It's a large step minus a small step.
-- Adding or subtracting any interval by this interval changes its "size".
-- Adding or subtracting any interval by this interval changes its "size".
function p.chroma()
function p.chroma()
Line 363: Line 462:
end
end


-- Compute the vector for an augmented step. It's a large step plus a chroma.
-- Return the vector for an augmented step. It's a large step plus a chroma.
function p.augmented_step()
function p.augmented_step()
return { ["L"] = 2, ["s"] = -1 }
return { ["L"] = 2, ["s"] = -1 }
end
end


-- Compute the vector for a single large step.
-- Return the vector for a single large step.
function p.large_step()
function p.large_step()
return { ["L"] = 1, ["s"] = 0 }
return { ["L"] = 1, ["s"] = 0 }
end
end


-- Compute the vector for a single small step.
-- Return the vector for a single small step.
function p.small_step()
function p.small_step()
return { ["L"] = 0, ["s"] = 1 }
return { ["L"] = 0, ["s"] = 1 }
end
end


-- Compute the vector for a diminished step. It's a small step minus a chroma.
-- Return the vector for a diminished step. It's a small step minus a chroma.
function p.diminished_step()
function p.diminished_step()
return { ["L"] = -1, ["s"] = 2 }
return { ["L"] = -1, ["s"] = 2 }
Line 392: Line 491:
end
end


-- Compute an arbitrary mos interval as a vector of L's and s's.
-- Compute an arbitrary mos interval as a vector of L's and s's. Params:
-- The step_count param is the number of mossteps in the interval. EG, in 5L 2s,
-- - step_count: the number of steps subtended by the mosstep.
-- the large 2-mosstep is "LL", so the corresponding vector has L=2, s=0.
-- - size_offset: denotes whether to return the large size (0) or the small
-- Mossteps larger than the equave (eg, the minor 9th in non-xen music theory)
--   size (-1) (or if this is a period interval, the diminished size). Values
-- are allowed.
--   other than 0 or 1 represent alterations by multiple chromas, such as
-- The size_offset denotes whether the interval is the large size (0) or the
--   augmented (1) or diminished (-2).
-- 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.
function p.interval_from_mos(mos, step_count, size_offset)
function p.interval_from_mos(mos, step_count, size_offset)
local size_offset = size_offset or 0 -- Optional param; defaults to large size
local size_offset = size_offset or 0 -- Optional param; defaults to large size
Line 420: Line 513:
-- and s's. This also serves as a helper function for p.interval_from_mos().
-- and s's. This also serves as a helper function for p.interval_from_mos().
-- Sequences of steps can be entered, where each step is one of five sizes:
-- Sequences of steps can be entered, where each step is one of five sizes:
-- - L: large step.
-- - L: large step.
-- - s: small step.
-- - s: small step.
-- - c: a chroma; the difference between a large and small step.
-- - c: a chroma; the difference between a large and small step.
-- - A: an augmented step; a large step plus a chroma.
-- - A: an augmented step; a large step plus a chroma.
-- - d: a diminished step, or diesis; a small step minus a chroma.
-- - d: a diminished step, or diesis; a small step minus a chroma.
function p.interval_from_step_sequence(step_sequence)
function p.interval_from_step_sequence(step_sequence)
local mossteps = #step_sequence
local mossteps = #step_sequence
Line 450: Line 543:
------------------------------- COUNT FUNCTIONS --------------------------------
------------------------------- COUNT FUNCTIONS --------------------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Given a mos, return the number of steps.
function p.step_count(mos)
return mos.nL + mos.ns
end


-- Given a mos, compute the number of steps in its bright gen (L's plus s's).
-- Given a mos, compute the number of steps in its bright gen (L's plus s's).
Line 467: Line 565:
end
end


-- Given a mos, compute the number of steps in its equave (L's plus s's).
-- TODO: deprecate this since "equave_step_count" is redundant and longer than
-- "step count".
function p.equave_step_count(mos)
function p.equave_step_count(mos)
return mos.nL + mos.ns
return mos.nL + mos.ns
Line 488: Line 587:
-- perfect size (for period/root/equave intervals). This requires the mos as
-- perfect size (for period/root/equave intervals). This requires the mos as
-- input.
-- input.
-- If the number of chromas from a small (EG minor) interval is desired, then
-- size_offset denotes whether to count chromas from the large size; changing
-- using the param size_offset can be used: 0 for chromas from large size, -1
-- this to -1 counts chromas from the small size. Like size_offset for
-- for chromas from small size. This can exceed the range [-1, 0] if needed.
-- interval_from_mos, this can be used to denote altered mossteps (augmented,
-- EG, a diminished 2-diastep (dim. 3rd) has the vector {0,2}. It's reached by
-- diminished, etc).
-- either lowering the major 2-step by 2 chromas, or lowering the minor 2-step
-- by 1 chroma.
function p.interval_chroma_count(interval, mos, size_offset)
function p.interval_chroma_count(interval, mos, size_offset)
local size_offset = size_offset or 0 -- Default of 0.
local size_offset = size_offset or 0 -- Default of 0.
Line 503: Line 600:


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
----------------------- INTERVAL ARITHMETIC FUNCTIONS --------------------------
--------------- INTERVAL ARITHMETIC AND MANIPULATION FUNCTIONS -----------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------


Line 522: Line 619:
end
end


-- Repeatedly add the same interval to itself.
-- Stack an interval, or repeatedly add the same interval to itself.
function p.interval_mul(interval, amt)
function p.interval_mul(interval, amt)
return {  
return {  
Line 536: Line 633:
interval_1["s"] == interval_2["s"]
interval_1["s"] == interval_2["s"]
end
end
--------------------------------------------------------------------------------
---------------------- INTERVAL MANIPULATION FUNCTIONS -------------------------
--------------------------------------------------------------------------------


-- Given an interval vector and a mos, find its period complement. This is the
-- Given an interval vector and a mos, find its period complement. This is the
-- interval to add to produce the period.
-- interval to add to produce the period. For single-period mosses, the period
-- complement is the same as the equave complement.
function p.period_complement(interval, mos)
function p.period_complement(interval, mos)
local sign = p.interval_step_count(interval) < 0 and -1 or 1
local sign = p.interval_step_count(interval) < 0 and -1 or 1
Line 558: Line 653:
-- Given an interval vector and a mos, period-reduce it. This works like
-- Given an interval vector and a mos, period-reduce it. This works like
-- modular arithmetic, so passing a negative interval returns a positive one.
-- modular arithmetic, so passing a negative interval returns a positive one.
-- For single-period mosses, period-reducing is the same as octave-reducing, or
-- equave-reducing (for nonoctave scales).
function p.period_reduce(interval, mos)
function p.period_reduce(interval, mos)
local step_count = p.interval_step_count(interval)
local step_count = p.interval_step_count(interval)
Line 595: Line 692:
-- ratios to be entered. (The rational module isn't suitable since it simplifies
-- ratios to be entered. (The rational module isn't suitable since it simplifies
-- ratios.)
-- ratios.)
function p.mos_to_et(mos, step_ratio, suffix)
function p.as_et(mos, step_ratio, suffix)
local suffix = suffix or nil
local suffix = suffix or nil
local et_size = mos.nL * step_ratio[1] + mos.ns * step_ratio[2]
local et_size = mos.nL * step_ratio[1] + mos.ns * step_ratio[2]
Line 607: Line 704:
end
end


-- Given a mos and a step ratio, return the number of et-steps for its dark
-- Given a mos and a step ratio, return the number of et-steps for its dark generator.
-- generator.
function p.dark_gen_to_et_steps(mos, step_ratio)
function p.dark_gen_to_et_steps(mos, step_ratio)
return p.interval_to_et_steps(p.dark_gen(mos), step_ratio)
return p.interval_to_et_steps(p.dark_gen(mos), step_ratio)
Line 623: Line 719:
end
end


-- Given an interval vector and step ratio, compute the number of et-steps it
-- Given an interval vector and step ratio, compute the number of et-steps it corresponds to.
-- corresponds to.
function p.interval_to_et_steps(interval, step_ratio)
function p.interval_to_et_steps(interval, step_ratio)
return interval["L"] * step_ratio[1] + interval["s"] * step_ratio[2]
return interval["L"] * step_ratio[1] + interval["s"] * step_ratio[2]
end
--------------------------------------------------------------------------------
------------------------ EQUAL-TUNING STRING FUNCTIONS -------------------------
--------------------------------------------------------------------------------
-- Given a mos, return its equal temperament suffix as a string (edo, edt, edf, or ed-p/q).
function p.et_suffix(mos)
if rat.eq(mos.equave, rat.new(2)) then
return "edo"
elseif rat.eq(mos.equave, rat.new(3)) then
return "edt"
elseif rat.eq(mos.equave, rat.new(3, 2)) then
return "edf"
else
return "ed" .. rat.as_ratio(mos.equave)
end
end
-- Given a mos and step ratio, return its equal temperament as a string "{steps}\{division}{suffix}".
function p.et_string(mos, step_ratio, suffix)
local suffix = suffix or nil
local et_mos = p.as_et(mos, step_ratio, suffix)
return et.as_string(et_mos)
end
-- Given a mos and step ratio, compute the number of et-steps for its bright gen
-- as a string "{steps}\{division}{suffix}".
function p.bright_gen_to_et_string(mos, step_ratio, suffix)
return p.interval_to_et_string(p.bright_gen(mos), mos, step_ratio, suffix)
end
-- Given a mos and step ratio, compute the number of et-steps for its dark gen,
-- as a string "{steps}\{division}{suffix}".
function p.dark_gen_to_et_string(mos, step_ratio, suffix)
return p.interval_to_et_string(p.dark_gen(mos), mos, step_ratio, suffix)
end
-- Given a mos and step ratio, compute the number of et-steps for its period,
-- as a string "{steps}\{division}{suffix}".
function p.period_to_et_string(mos, step_ratio, suffix)
return p.interval_to_et_string(p.period(mos), mos, step_ratio, suffix)
end
-- Given a mos, compute the number of et-steps for its period, reduced,
-- as a string "{steps}\{division}{suffix}". Does not reuqire a step ratio.
-- NOTE: no such function for returning only the number of steps is needed since
-- that's the same as period_count().
function p.reduced_period_to_et_string(mos, suffix)
return p.interval_to_et_string({["L"] = 1, ["s"] = 1}, p.root(mos), {1,0}, suffix)
end
-- Given a mos and step ratio, compute the number of et-steps for its equave,
-- as a string "{steps}\{division}{suffix}".
function p.equave_to_et_string(mos, step_ratio, suffix)
return p.interval_to_et_string(p.equave(mos), mos, step_ratio, suffix)
end
-- Given an interval vector and step ratio, compute the number of et-steps it
-- corresponds to, as a string "{steps}\{division}{suffix}". Requires info
-- about the mos itself.
function p.interval_to_et_string(interval, mos, step_ratio, suffix)
local suffix = suffix or nil
local mos_et = p.as_et(mos, step_ratio, suffix)
return et.backslash_display(mos_et, p.interval_to_et_steps(interval, step_ratio))
end
end


Line 662: Line 822:
end
end


-- Given an interval vector and step ratio, convert it to cents. This requires
-- Given an interval vector and step ratio, convert it to cents. This requires info about the mos itself.
-- info about the mos itself.
function p.interval_to_cents(interval, mos, step_ratio)
function p.interval_to_cents(interval, mos, step_ratio)
local interval_steps = p.interval_to_et_steps(interval, step_ratio)
local interval_steps = p.interval_to_et_steps(interval, step_ratio)
Line 676: Line 835:
-- Tester function
-- Tester function
function p.tester()
function p.tester()
return p.mos_to_et(p.new(5,2,rat.new(5,3)), {3, 1})
local input_mos = p.new(4,1,3)
local step_ratio = {2,1}
local interval_vector = {["L"] = 3, ["s"] = 1}
--return p.as_string(input_mos, false)
 
--return p.as_et(p.new(5,2), {2,1})
--[[
return  
p.mode_by_brightness(p.new(5,2), 0) .. " " .. p.mode_by_brightness(p.new(5,2), 6-6) .. "\n" ..
p.mode_by_brightness(p.new(5,2), 1) .. " " .. p.mode_by_brightness(p.new(5,2), 6-5) .. "\n" ..
p.mode_by_brightness(p.new(5,2), 2) .. " " .. p.mode_by_brightness(p.new(5,2), 6-4) .. "\n" ..
p.mode_by_brightness(p.new(5,2), 3) .. " " .. p.mode_by_brightness(p.new(5,2), 6-3) .. "\n" ..
p.mode_by_brightness(p.new(5,2), 4) .. " " .. p.mode_by_brightness(p.new(5,2), 6-2) .. "\n" ..
p.mode_by_brightness(p.new(5,2), 5) .. " " .. p.mode_by_brightness(p.new(5,2), 6-1) .. "\n" ..
p.mode_by_brightness(p.new(5,2), 6) .. " " .. p.mode_by_brightness(p.new(5,2), 6-0)
]]--
return
p.as_string(p.new(5,2))        .. "\n" ..
p.as_string(p.new(4,5,3))      .. "\n" ..
p.as_long_string(p.new(5,2))  .. "\n" ..
p.as_long_string(p.new(4,5,3)) .. "\n" ..
p.as_link(p.new(5,2))          .. "\n" ..
p.as_link(p.new(4,5,3))        .. "\n" ..
p.as_long_link(p.new(5,2))    .. "\n" ..
p.as_long_link(p.new(4,5,3))  .. "\n" ..
p.as_string(p.new(5,0))        .. "\n" ..
p.as_string(p.new(4,0,3))      .. "\n" ..
p.as_long_string(p.new(5,0))  .. "\n" ..
p.as_long_string(p.new(4,0,3)) .. "\n" ..
p.as_link(p.new(5,0))          .. "\n" ..
p.as_link(p.new(4,0,3))        .. "\n" ..
p.as_long_link(p.new(5,0))    .. "\n" ..
p.as_long_link(p.new(4,0,3))  .. "\n" ..
p.as_string(p.new(0,2))        .. "\n" ..
p.as_string(p.new(0,5,3))      .. "\n" ..
p.as_long_string(p.new(0,2))  .. "\n" ..
p.as_long_string(p.new(0,5,3)) .. "\n" ..
p.as_link(p.new(0,2))          .. "\n" ..
p.as_link(p.new(0,5,3))        .. "\n" ..
p.as_long_link(p.new(0,2))    .. "\n" ..
p.as_long_link(p.new(0,5,3))
end
end


return p
return p