Module:MOS intervals
Jump to navigation
Jump to search
Documentation for this module may be created at Module:MOS intervals/doc
local mos = require('Module:MOS')
local rat = require('Module:Rational')
local ord = require('Module:Ordinal')
local utils = require('Module:Utils')
local et = require('Module:ET')
local p = {}
-- Helper function that turns a mosstep into a step count as a string
-- EG, the 3-mosstep of "LLsLsLs" becomes "2L + s"
function p.mos_interval_to_step_count_string(step_pattern, mossteps)
local L_count = 0
local s_count = 0
for i = 1, mossteps do
local step = string.sub(step_pattern, i, i)
if step == "L" then
L_count = L_count + 1
elseif step == "s" then
s_count = s_count + 1
end
end
-- There are 9 combinations to write xL + ys, based on whether x and y are
-- 0, 1, or greater than 1
local return_string = ""
if L_count == 0 and s_count == 0 then
return_string = "0"
elseif L_count == 0 and s_count == 1 then
return_string = "s"
elseif L_count == 0 and s_count > 1 then
return_string = s_count .. "s"
elseif L_count == 1 and s_count == 0 then
return_string = "L"
elseif L_count == 1 and s_count == 1 then
return_string = "L + s"
elseif L_count == 1 and s_count > 1 then
return_string = "L + " .. s_count .. "s"
elseif L_count > 1 and s_count == 0 then
return_string = L_count .. "L"
elseif L_count > 1 and s_count == 1 then
return_string = L_count .. "L + s"
else
return_string = L_count .. "L + " .. s_count .. "s"
end
return return_string
end
-- Helper function
-- Produces the cent range of a mosstep
function p.mos_interval_to_cent_range(step_pattern, mossteps, input_mos)
local step_pattern = step_pattern or "LLsLLLs"
local mossteps = mossteps or 1
local input_mos = input_mos or mos.new(5, 5, 2)
local L_count = 0
local s_count = 0
for i = 1, mossteps do
local step = string.sub(step_pattern, i, i)
if step == "L" then
L_count = L_count + 1
elseif step == "s" then
s_count = s_count + 1
end
end
-- The range of a small step is from 0 to 1 step of the equalized mos
-- The range of a large step is from 1 step of equalized to 1 step of collapsed
-- These ranges do not apply if the mosstep interval is for a period; instead
-- it's a fixed value.
local equave_in_cents = rat.cents(input_mos.equave)
local s_size_min = 0
local s_size_max = equave_in_cents / (input_mos.nL + input_mos.ns)
local L_size_min = s_size_max
local L_size_max = equave_in_cents / input_mos.nL
local mossteps_per_period = (input_mos.nL + input_mos.ns) / utils._gcd(input_mos.nL, input_mos.ns)
local is_period = mossteps % mossteps_per_period == 0
local result = ""
if not is_period then
local min_cents = L_count * L_size_min + s_count * s_size_max
local max_cents = L_count * L_size_max + s_count * s_size_min
result = string.format("%.1f¢ to %.1f¢", math.min(min_cents, max_cents), math.max(min_cents, max_cents))
else
local period_in_cents = equave_in_cents / utils._gcd(input_mos.nL, input_mos.ns)
local number_of_periods = mossteps / mossteps_per_period
result = string.format("%.1f¢", period_in_cents * number_of_periods)
end
return result
end
-- Helper function
-- Extracts the prefix from the mos module, without the dash and without any text after that
-- May need to revisit to clean up code since this splits text at the "-"
function p.get_mos_prefix(scale_sig)
local unparsed = mos.tamnams_prefix[scale_sig]
local parsed = {}
if unparsed == nil then
return "mos"
else
for entry in string.gmatch(unparsed, '([^-]+)') do
local trimmed = entry:gsub("^%s*(.-)%s*$", "%1")
table.insert(parsed, trimmed) -- Add to array
end
return parsed[1]
end
end
function p.mos_intervals(input_mos, mos_prefix)
-- Default param for input mos is 5L 2s
local input_mos = input_mos or mos.new(5, 2, 2)
local mos_prefix = mos_prefix or "dia"
-- Get the scale sig
local scale_sig = mos.as_string(input_mos)
-- Get the brightest and darkest modes for the mos
local brightest_mode = mos.brightest_mode(input_mos)
local darkest_mode = string.reverse(brightest_mode)
-- Get the number of steps per period and equave
local steps_per_equave = (input_mos.nL + input_mos.ns)
local steps_per_period = steps_per_equave / utils._gcd(input_mos.nL, input_mos.ns)
-- Get the step counts for the bright and dark generators
local bright_gen = mos.bright_gen(input_mos)
local steps_per_bright_gen = bright_gen['L'] + bright_gen['s']
local steps_per_dark_gen = steps_per_period - steps_per_bright_gen
-- Create the table, starting with the headers
local result = '{| class="wikitable"\n'
result = result .. '|+Intervals of ' .. scale_sig .. '\n'
result = result .. '! colspan="2" |Intervals (with relation to root)\n'
result = result .. '! colspan="2" |Size\n'
result = result .. '! rowspan="2" |Abbrev.\n'
result = result .. '|-\n'
result = result .. '!Generic\n'
result = result .. '!Specific\n'
result = result .. '!L\'s and s\'s\n'
result = result .. '!Range in cents\n'
-- First row is the unison
result = result .. "|-\n"
result = result .. "|'''0-" .. mos_prefix .. "step (root)'''\n"
result = result .. "|Perfect 0-" .. mos_prefix .. "step\n"
result = result .. "|0\n"
result = result .. string.format("| %.1f¢\n", 0)
result = result .. string.format("| P0ms\n")
-- Successive rows are the mossteps, starting at the 1-mosstep
-- Name the interval according to whether it's major/minor or
-- perf/aug/dim; for nL ns mosses, it's only major/minor for any
-- non-period intervals.
local is_nL_ns = input_mos.nL == input_mos.ns
for i = 1, steps_per_equave - 1 do
if i % steps_per_period == steps_per_bright_gen and not is_nL_ns then
-- If i corresponds to the bright generator, then the large size is
-- perfect and the small size is diminished. Add two rows.
result = result .. "|-\n"
result = result .. '|rowspan="2"' .. "|'''" .. i .. "-" .. mos_prefix .. "step'''\n"
result = result .. "|Diminished " .. i .. "-" .. mos_prefix .. "step\n"
result = result .. "|" .. p.mos_interval_to_step_count_string(darkest_mode, i) .. "\n"
result = result .. string.format("| %s\n", p.mos_interval_to_cent_range(darkest_mode, i, input_mos))
result = result .. string.format("| d%ims\n", i)
result = result .. "|-\n"
result = result .. "|Perfect " .. i .. "-" .. mos_prefix .. "step\n"
result = result .. "|" .. p.mos_interval_to_step_count_string(brightest_mode, i) .. "\n"
result = result .. string.format("| %s\n", p.mos_interval_to_cent_range(brightest_mode, i, input_mos))
result = result .. string.format("| P%ims\n", i)
elseif i % steps_per_period == steps_per_dark_gen and not is_nL_ns then
-- If i corresponds to the dark generator, then the large size is
-- augmented and the small size is perfect. Add two rows.
result = result .. "|-\n"
result = result .. '|rowspan="2"' .. "|'''" .. i .. "-" .. mos_prefix .. "step'''\n"
result = result .. "|Perfect " .. i .. "-" .. mos_prefix .. "step\n"
result = result .. "|" .. p.mos_interval_to_step_count_string(darkest_mode, i) .. "\n"
result = result .. string.format("| %s\n", p.mos_interval_to_cent_range(darkest_mode, i, input_mos))
result = result .. string.format("| P%ims\n", i)
result = result .. "|-\n"
result = result .. "|Augmented " .. i .. "-" .. mos_prefix .. "step\n"
result = result .. "|" .. p.mos_interval_to_step_count_string(brightest_mode, i) .. "\n"
result = result .. string.format("| %s\n", p.mos_interval_to_cent_range(brightest_mode, i, input_mos))
result = result .. string.format("| A%ims\n", i)
elseif i % steps_per_period == 0 and i ~= mossteps_per_equave then
-- If i corresponds to the period, then the large and small sizes are
-- the same and they're perfect. This also applies to the equave. Add one row.
result = result .. "|-\n"
result = result .. "|'''" .. i .. "-" .. mos_prefix .. "step (period)'''\n"
result = result .. "|Perfect " .. i .. "-" .. mos_prefix .. "step\n"
result = result .. "|" .. p.mos_interval_to_step_count_string(darkest_mode, i) .. "\n"
result = result .. string.format("| %s\n", p.mos_interval_to_cent_range(darkest_mode, i, input_mos))
result = result .. string.format("| P%ims\n", i)
else
-- For any other interval, and for generators for nL ns mosses, the
-- large size is major and the small size is minor. Add two rows.
result = result .. "|-\n"
result = result .. '|rowspan="2"' .. "|" .. i .. "-" .. mos_prefix .. "step\n"
result = result .. "|Minor " .. i .. "-" .. mos_prefix .. "step\n"
result = result .. "|" .. p.mos_interval_to_step_count_string(darkest_mode, i) .. "\n"
result = result .. string.format("| %s\n", p.mos_interval_to_cent_range(darkest_mode, i, input_mos))
result = result .. string.format("| m%ims\n", i)
result = result .. "|-\n"
result = result .. "|Major " .. i .. "-" .. mos_prefix .. "step\n"
result = result .. "|" .. p.mos_interval_to_step_count_string(brightest_mode, i) .. "\n"
result = result .. string.format("| %s\n", p.mos_interval_to_cent_range(brightest_mode, i, input_mos))
result = result .. string.format("| M%ims\n", i)
end
end
-- Add the last row of the table, which is either the equave or octave
local equave_name = ""
if rat.eq(input_mos.equave, 2) then
result = result .. "|-\n"
result = result .. "|'''" .. steps_per_equave .. "-" .. mos_prefix .. "step (octave)'''\n"
result = result .. "|Perfect " .. steps_per_equave .. "-" .. mos_prefix .. "step'''\n"
result = result .. "|" .. p.mos_interval_to_step_count_string(darkest_mode, steps_per_equave) .. "\n"
result = result .. string.format("| %.1f¢\n", 1200)
result = result .. string.format("| P%ims\n", steps_per_equave)
else
result = result .. "|-\n"
result = result .. "|'''" .. steps_per_equave .. "-" .. mos_prefix .. "step (equave)'''\n"
result = result .. "|Perfect " .. steps_per_equave .. "-" .. mos_prefix .. "step'''\n"
result = result .. "|" .. p.mos_interval_to_step_count_string(darkest_mode, steps_per_equave) .. "\n"
result = result .. string.format("| %.1f¢\n", rat.cents(input_mos.equave))
result = result .. string.format("| P%ims\n", steps_per_equave)
end
result = result .. "|}"
return result
end
function p.mos_intervals_frame(frame)
-- Get input mos
local input_mos = mos.parse(frame.args['Scale Signature'])
-- Default param for mos prefix
-- If "NONE" is given, no prefix will be used
-- If left blank, try to find the appropriate mos prefix, or else defualt to "mos"
-- If not left blank, use the prefix passed in instead
local scale_sig = mos.as_string(input_mos)
local mos_prefix = p.get_mos_prefix(scale_sig)
if frame.args['MOS Prefix'] == "NONE" then
mos_prefix = ""
elseif string.len(frame.args['MOS Prefix']) > 0 then
mos_prefix = frame.args['MOS Prefix']
end
local result = p.mos_intervals(input_mos, mos_prefix)
return result
end
return p