Xenharmonic Wiki

Module:Infobox MOS: Difference between revisions

← Older edit
Ganaram inukshuk (talk | contribs)
autopatrolled, emailconfirmed
6,211 edits
m Updated todo
ArrowHead294 (talk | contribs)
15,213 edits
m No need to use NBSP on ones that aren't displayed
 
(98 intermediate revisions by 4 users not shown)
Line 1: Line 1:
local p = {}
local p = {}
local utils = require('Module:Utils')
local rat = require('Module:Rational')
local mos = require('Module:MOS')
local et = require('Module:ET')
--local xp = require('Module:Xenpaper') -- No xenpaper links for now
local infobox = require('Module:Infobox')
local kbvis = require('Module:Keyboard vis')
local tip = require('Module:Template input parse')


-- TODO:
local getArgs = require("Module:Arguments").getArgs
-- Debug other names section
local ib = require("Module:Infobox")
-- Add back xenpaper links?
local kbvis = require("Module:Keyboard vis")
local mos = require("Module:MOS")
local tamnams = require("Module:TAMNAMS")
local tip = require("Module:Template input parse")
local xp = require("Module:Xenpaper")
local yesno = require("Module:Yesno")
 
-- TODO: REWRITE. REFACTOR. AGAIN.
 
-- TODO: bugfix tamnams lookup breaking for mosses with 5 steps or less; interim
-- fix currently implemented shows smaller mosses as descending from itself.


-- Helper function
-- Helper function
Line 19: Line 21:
function p.concatenate_tables(t1, t2)
function p.concatenate_tables(t1, t2)
for i=1, #t2 do
for i=1, #t2 do
t1[#t1+1] = t2[i]
t1[#t1 + 1] = t2[i]
end
end
end
-- Helper function
-- Annotates a section header with the equave as superscript text.
function p.annotate_section_header(input_mos, section_header)
local et_suffix = mos.et_suffix(input_mos)
return (et_suffix == "edo"
and string.format('<div style=\"margin-top: 0.6em;\"><b>%s</b></div>', section_header)
or  string.format('<div style=\"margin-top: 0.6em;\"><b>%s</b><sup><abbr title=\"In steps of %s\">(%s)</sup></div>', section_header, et_suffix, et_suffix)
)
end
end


Line 35: Line 47:
end
end
return {{vis}}
return {{["Header"] = vis}}
end
end


-- Helper function
-- Helper function
-- Adds categories
-- Adds categories
function p.categorize(tuning)
function p.categorize(input_mos)
local tuning = tuning or "5L 2s"
local input_mos = input_mos or mos.new(5, 2)
local input_mos = mos.parse(tuning)
-- Add to category of abstact mosses
-- Add to category of abstact mosses
local categories = "[[Category:Abstract MOS patterns]]"
local categories = " [[Category:Abstract MOS patterns]]"
-- Add notecount category if the notecount is greater than 3
-- Add notecount category if the notecount is greater than 3
local notecount = input_mos.nL + input_mos.ns
local notecount = input_mos.nL + input_mos.ns
if notecount > 3 then
if notecount > 3 then
categories = categories .. string.format('[[Category:%d-tone scales]]', notecount)
categories = categories .. string.format(" [[Category:%d-tone scales]]", notecount)
end
end
-- If the mos is octave-equivalent, add appropriate tamnams-named categories
-- If the mos is octave-equivalent, add appropriate tamnams-named categories
-- Otherwise, add to nonoctave category
-- Otherwise, add to nonoctave category
if rat.eq(input_mos.equave, rat.new(2)) then
if mos.is_octave_equivalent(input_mos) then
-- Caveats:
-- Caveats:
-- - Only octave-equivalent mos names are used as categories.
-- - Only octave-equivalent mos names are used as categories.
Line 61: Line 72:
-- - Mosses whose notecounts > 10 and periods < 5 are categorized under
-- - Mosses whose notecounts > 10 and periods < 5 are categorized under
--  the closest tamnams-named ancestor.
--  the closest tamnams-named ancestor.
local ancestor_mos = mos.find_ancestor(input_mos)
local ancestor_mos = tamnams.find_ancestor(input_mos)
local tamnams_name = mos.tamnams_name[mos.as_string(ancestor_mos)]
local tamnams_name = tamnams.lookup_name(ancestor_mos)
if tamnams_name == "arch(a)eotonic" then
tamnams_name = "archaeotonic"
end
if tamnams_name ~= nil then
if tamnams_name ~= nil then
categories = categories .. string.format('[[Category:%s]]', tamnams_name)
categories = categories .. string.format(" [[Category:%s]]", tamnams_name)
end
end
else
else
categories = categories .. '[[Category:Nonoctave]]'
categories = categories .. " [[Category:Nonoctave]]"
end
end
Line 81: Line 88:
-- Creates adjacent links for mos, found by +/-1 large or +/- small steps
-- Creates adjacent links for mos, found by +/-1 large or +/- small steps
function p.adjacent_links(input_mos)
function p.adjacent_links(input_mos)
local input_mos = input_mos or mos.new(5, 2)
local input_mos = input_mos or mos.new(1, 1)
local equave_as_long_string = ""
local adjacent_mosses = {
local equave_as_string = ""
mos.new(input_mos.nL - 1, input_mos.ns - 1, input_mos.equave), -- UL
if not rat.eq(input_mos.equave, 2) then
mos.new(input_mos.nL    , input_mos.ns - 1, input_mos.equave), -- U
equave_as_long_string = string.format(" (%s-equivalent)", rat.as_ratio(input_mos.equave))
mos.new(input_mos.nL + 1, input_mos.ns - 1, input_mos.equave), -- UR
equave_as_string = string.format("⟨%s⟩", rat.as_ratio(input_mos.equave))
mos.new(input_mos.nL - 1, input_mos.ns    , input_mos.equave), -- L
end
mos.new(input_mos.nL + 1, input_mos.ns    , input_mos.equave), -- R
mos.new(input_mos.nL - 1, input_mos.ns + 1, input_mos.equave), -- DL
mos.new(input_mos.nL    , input_mos.ns + 1, input_mos.equave), -- D
mos.new(input_mos.nL + 1, input_mos.ns + 1, input_mos.equave), -- DR
}
local adjacent_links = {
local adjacent_links = {
string.format("[[%dL %ds%s | ↖%dL %ds%s]]", input_mos.nL-1, input_mos.ns-1, equave_as_long_string, input_mos.nL-1, input_mos.ns-1, equave_as_string),
mos.is_valid(adjacent_mosses[1]) and string.format("[[%s|&#x2196;&nbsp;%s]]", mos.as_long_string(adjacent_mosses[1], false), mos.as_string(adjacent_mosses[1]), true) or "",
string.format("[[%dL %ds%s | ↑%dL %ds%s]]", input_mos.nL  , input_mos.ns-1, equave_as_long_string, input_mos.nL  , input_mos.ns-1, equave_as_string),
mos.is_valid(adjacent_mosses[2]) and string.format("[[%s|&#x2191;&nbsp;%s]]", mos.as_long_string(adjacent_mosses[2], false), mos.as_string(adjacent_mosses[2]), true) or "",
string.format("[[%dL %ds%s | %dL %ds%s↗]]", input_mos.nL+1, input_mos.ns-1, equave_as_long_string, input_mos.nL+1, input_mos.ns-1, equave_as_string),
mos.is_valid(adjacent_mosses[3]) and string.format("[[%s|%s&nbsp;&#x2197;]]", mos.as_long_string(adjacent_mosses[3], false), mos.as_string(adjacent_mosses[3]), true) or "",
string.format("[[%dL %ds%s | ←%dL %ds%s]]", input_mos.nL-1, input_mos.ns  , equave_as_long_string, input_mos.nL-1, input_mos.ns  , equave_as_string),
mos.is_valid(adjacent_mosses[4]) and string.format("[[%s|&#x2190;&nbsp;%s]]", mos.as_long_string(adjacent_mosses[4], false), mos.as_string(adjacent_mosses[4]), true) or "",
string.format("[[%dL %ds%s | %dL %ds%s→]]", input_mos.nL+1, input_mos.ns  , equave_as_long_string, input_mos.nL+1, input_mos.ns  , equave_as_string),
mos.is_valid(adjacent_mosses[5]) and string.format("[[%s|%s&nbsp;&#x2192;]]", mos.as_long_string(adjacent_mosses[5], false), mos.as_string(adjacent_mosses[5]), true) or "",
string.format("[[%dL %ds%s | ↙%dL %ds%s]]", input_mos.nL-1, input_mos.ns+1, equave_as_long_string, input_mos.nL-1, input_mos.ns+1, equave_as_string),
mos.is_valid(adjacent_mosses[6]) and string.format("[[%s|&#x2199;&nbsp;%s]]", mos.as_long_string(adjacent_mosses[6], false), mos.as_string(adjacent_mosses[6]), true) or "",
string.format("[[%dL %ds%s | ↓%dL %ds%s]]", input_mos.nL  , input_mos.ns+1, equave_as_long_string, input_mos.nL  , input_mos.ns+1, equave_as_string),
mos.is_valid(adjacent_mosses[7]) and string.format("[[%s|&#x2193;&nbsp;%s]]", mos.as_long_string(adjacent_mosses[7], false), mos.as_string(adjacent_mosses[7]), true) or "",
string.format("[[%dL %ds%s | %dL %ds%s↘]]", input_mos.nL+1, input_mos.ns+1, equave_as_long_string, input_mos.nL+1, input_mos.ns+1, equave_as_string),
mos.is_valid(adjacent_mosses[8]) and string.format("[[%s|%s&nbsp;&#x2198;]]", mos.as_long_string(adjacent_mosses[8], false), mos.as_string(adjacent_mosses[8]), true) or ""
}
}
-- Links that contain either "0L" or "0s" when the parent's L/s-count is 1
-- refer to degenerate mosses (either 0L or 0s), whose links should be made
-- blank instead.
for i = 1, #adjacent_links do
local number_of_periods = utils._gcd(input_mos.nL, input_mos.ns)
local is_null_large = string.find(adjacent_links[i], "0L") and input_mos.nL == 1
local is_null_small = string.find(adjacent_links[i], "0s") and input_mos.ns == 1
if is_null_large or is_null_small then
adjacent_links[i] = ""
end
end
return adjacent_links
return adjacent_links
end
end


-- TODO: Cleanup and adopt mos functions
-- Helper function
-- Helper function
-- Produces section entries for scale sturcture
-- Produces section entries for scale sturcture
Line 124: Line 123:
local input_mos = input_mos or mos.new(5, 2)
local input_mos = input_mos or mos.new(5, 2)
local equave_as_string = rat.as_ratio(input_mos.equave)
local equave_as_string = mos.equave_as_string(input_mos)
local equave_in_cents = rat.cents(input_mos.equave)
local equave_in_cents = mos.equave_to_cents(input_mos)
local number_of_periods = utils._gcd(input_mos.nL, input_mos.ns)
local number_of_periods = mos.period_count(input_mos)
local period_as_string = ""
local period_as_string = ""
if number_of_periods == 1 then
if number_of_periods == 1 then
period_as_string = equave_as_string
period_as_string = equave_as_string
else
else
local ed = et.new(number_of_periods, input_mos.equave)
period_as_string = mos.reduced_period_to_et_string(input_mos, "")
period_as_string = et.backslash_display(ed, 1)
end
end
local period_in_cents = equave_in_cents / number_of_periods
local period_in_cents = equave_in_cents / number_of_periods
local step_pattern = string.format("...%d steps...", input_mos.nL+input_mos.ns)
local step_pattern = string.format("...%d steps...", input_mos.nL + input_mos.ns)
if input_mos.nL + input_mos.ns <= 40 then
if input_mos.nL + input_mos.ns <= 40 then
local brightest_mode = mos.brightest_mode(input_mos)
local brightest_mode = mos.brightest_mode(input_mos)
step_pattern = string.format('<abbr title="Brightest mode">%s</abbr><br><abbr title="Darkest mode">%s</abbr>', brightest_mode, string.reverse(brightest_mode))
step_pattern = string.format("<abbr title=\"Brightest mode\">%s</abbr><br /><abbr title=\"Darkest mode\">%s</abbr>", brightest_mode, string.reverse(brightest_mode))
end
end
local section_header = "Scale structure"
local section_header = "Scale structure"
local section_entries = {
local section_entries = {
{string.format("<b>%s</b>", section_header)},
{ ["Header"] = string.format("<div style=\"margin-top: 0.6em;\"><b>%s</b></div>", section_header)},
{"[[Step pattern]]", step_pattern},
{ ["Header"] = "[[Step pattern]]", ["Data"] = step_pattern},
{"[[Equave]]", string.format("%s (%.1f¢)", equave_as_string, equave_in_cents)},
{ ["Header"] = "[[Equave]]"     , ["Data"] = string.format("%s (%.1f{{c}})", equave_as_string, equave_in_cents) },
{"[[Period]]", string.format("%s (%.1f¢)", period_as_string, period_in_cents)}
{ ["Header"] = "[[Period]]"     , ["Data"] = string.format("%s (%.1f{{c}})", period_as_string, period_in_cents) }
}
}


Line 159: Line 157:
-- a larger array.
-- a larger array.
function p.generator_sizes(input_mos)
function p.generator_sizes(input_mos)
local input_mos = input_mos or mos.new(5, 2)
local input_mos = input_mos or mos.new(5, 2,3)
local number_of_periods = utils._gcd(input_mos.nL, input_mos.ns)
local bright_gen = mos.bright_gen(input_mos)
local dark_gen = {
['L'] = input_mos.nL / number_of_periods - bright_gen['L'],
['s'] = input_mos.ns / number_of_periods - bright_gen['s']
}
local equalized_ed = et.new(input_mos.nL + input_mos.ns, input_mos.equave, "")
local collapsed_ed = et.new(input_mos.nL, input_mos.equave, "")
local bright_min_in_steps = et.backslash_display(equalized_ed, bright_gen['L'] + bright_gen['s'])
local bright_max_in_steps = et.backslash_display(collapsed_ed, bright_gen['L'])
local dark_min_in_steps  = et.backslash_display(collapsed_ed, dark_gen['L'])
local dark_max_in_steps  = et.backslash_display(equalized_ed, dark_gen['L'] + dark_gen['s'])
local bright_min_in_cents = et.cents(equalized_ed, bright_gen['L'] + bright_gen['s'])
local bright_max_in_cents = et.cents(collapsed_ed, bright_gen['L'])
local dark_min_in_cents  = et.cents(collapsed_ed, dark_gen['L'])
local dark_max_in_cents  = et.cents(equalized_ed, dark_gen['L'] + dark_gen['s'])
local section_header = "Generator size"
local equave_annotation = ""
if rat.eq(input_mos.equave, 3) then
equave_annotation = '<sup><abbr title="In steps of edt">(edt)</sup>'
elseif rat.eq(input_mos.equave, rat.new(3,2)) then
equave_annotation = '<sup><abbr title="In steps of edf">(edf)</sup>'
elseif not rat.eq(input_mos.equave, 2) then
local equave_as_ratio = rat.as_ratio(input_mos.equave)
equave_annotation = string.format('<sup><abbr title="In steps of ed%s">(ed%s)</sup>', equave_as_ratio, equave_as_ratio)
end
local section_entries = {
{string.format("<b>%s</b>%s", section_header, equave_annotation)},
{"[[Bright]]", string.format("%s to %s (%.1f¢ to %.1f¢)", bright_min_in_steps, bright_max_in_steps, bright_min_in_cents, bright_max_in_cents)},
{"[[Dark]]", string.format("%s to %s (%.1f¢ to %.1f¢)", dark_min_in_steps, dark_max_in_steps, dark_min_in_cents, dark_max_in_cents)},
}
return section_entries
end
 
-- Helper function
-- Produces ranges small and large steps (currently unused)
-- Section is returned as a jagged array and return value must be merged into
-- a larger array.
function p.step_sizes(input_mos)
local input_mos = input_mos or mos.new(5, 2)
local equalized_ed = et.new(input_mos.nL + input_mos.ns, input_mos.equave, "")
local collapsed_ed = et.new(input_mos.nL, input_mos.equave, "")
-- Large and small steps
local bright_min_in_steps = mos.bright_gen_to_et_string(input_mos, {1, 1}, "")
-- The small step lower bound is basically zero (when collapsed).
local bright_max_in_steps = mos.bright_gen_to_et_string(input_mos, {1, 0}, "")
-- The upper bound for a small step and the lower bound for a large step
local dark_min_in_steps  = mos.dark_gen_to_et_string  (input_mos, {1, 0}, "")
-- are the same.
local dark_max_in_steps  = mos.dark_gen_to_et_string  (input_mos, {1, 1}, "")
-- The upper bound of a large step is when the step ratio is collapsed.
local small_step_min_in_steps = et.backslash_display(collapsed_ed, 0)
local large_step_min_in_steps = et.backslash_display(equalized_ed, 1)
local large_step_max_in_steps = et.backslash_display(collapsed_ed, 1)
local small_step_min_in_cents = et.cents(collapsed_ed, 0)
local bright_min_in_cents = mos.bright_gen_to_cents(input_mos, {1, 1})
local large_step_min_in_cents = et.cents(equalized_ed, 1)
local bright_max_in_cents = mos.bright_gen_to_cents(input_mos, {1, 0})
local large_step_max_in_cents = et.cents(collapsed_ed, 1)
local dark_min_in_cents = mos.dark_gen_to_cents(input_mos, {1, 0})
local dark_max_in_cents = mos.dark_gen_to_cents(input_mos, {1, 1})
local section_header = "Step size"
local equave_annotation = ""
if rat.eq(input_mos.equave, 3) then
equave_annotation = '<sup><abbr title="In steps of edt">(edt)</sup>'
elseif rat.eq(input_mos.equave, rat.new(3,2)) then
equave_annotation = '<sup><abbr title="In steps of edf">(edf)</sup>'
elseif not rat.eq(input_mos.equave, 2) then
local equave_as_ratio = rat.as_ratio(input_mos.equave)
equave_annotation = string.format('<sup><abbr title="In steps of ed%s">(ed%s)</sup>', equave_as_ratio, equave_as_ratio)
end
local section_header = p.annotate_section_header(input_mos, "Generator size")
local section_entries = {
local section_entries = {
{string.format("<b>%s</b>%s", section_header, equave_annotation)},
{ ["Header"] = section_header},
{"[[Step pattern | Large]]", string.format("%s to %s (%.1f¢ to %.1f¢)", large_step_min_in_steps, large_step_max_in_steps, large_step_min_in_cents, large_step_max_in_cents)},
{ ["Header"] = "[[Bright]]", ["Data"] = string.format("%s to %s (%.1f{{c}} to %.1f{{c}})", bright_min_in_steps, bright_max_in_steps, bright_min_in_cents, bright_max_in_cents) },
{"[[Step pattern | Small]]", string.format("%s to %s (%.1f¢ to %.1f¢)", small_step_min_in_steps, large_step_min_in_steps, small_step_min_in_cents, large_step_min_in_cents)}
{ ["Header"] = "[[Dark]]" , ["Data"] = string.format("%s to %s (%.1f{{c}} to %.1f{{c}})", dark_min_in_steps, dark_max_in_steps, dark_min_in_cents, dark_max_in_cents) },
}
}
return section_entries
return section_entries
end
-- Helper function for a helper function
-- Determines what mos the given mos descends from
-- as well as what step ratio that produces this scale
-- Mosses within the "named range" passed here will return itself
function p.find_mos_ancestor(input_mos)
local input_mos = input_mos or mos.new(5, 2)
local z = input_mos.nL
local w = input_mos.ns
local generations = 0
-- For an ancestral mos zU wv and descendant xL ys, how many steps of size
-- L and s can fit inside U and v? (basically the chunking operation)
local lg_chunk = { nL = 1, ns = 0 }
local sm_chunk = { nL = 0, ns = 1 }
while (z ~= w) and (z + w > 10) do
local m1 = math.max(z, w)
local m2 = math.min(z, w)
-- For use with updating ancestor mos chunks
local z_prev = z
-- Count how many generations
generations = generations + 1
-- Update step ratios
z = m2
w = m1 - m2
-- Update large chunk
local prev_lg_chunk = { nL = lg_chunk.nL, ns = lg_chunk.ns }
lg_chunk.nL = lg_chunk.nL + sm_chunk.nL
lg_chunk.ns = lg_chunk.ns + sm_chunk.ns
-- Update small chunk
if z ~= z_prev then
sm_chunk = prev_lg_chunk
end
end
return mos.new(z, w, input_mos.equave), lg_chunk, sm_chunk, generations
end
end


Line 302: Line 192:
-- a larger array.
-- a larger array.
function p.tamnams_information(input_mos)
function p.tamnams_information(input_mos)
local input_mos = input_mos or mos.new(5, 2)
local input_mos = input_mos or mos.new(6,6,3)
local scalesig = string.format("%dL %ds", input_mos.nL, input_mos.ns)
local notecount = input_mos.nL + input_mos.ns
local number_of_periods = utils._gcd(input_mos.nL, input_mos.ns)
local tamnams_name = mos.tamnams_name[scalesig]
-- If a mos is octave-equivalent and has 10 or fewer steps, then it has a
local tamnams_prefix = mos.tamnams_prefix[scalesig]
-- tamnams name/prefix/abbrev.
local tamnams_abbrev = mos.tamnams_abbrev[scalesig]
-- If a mos is octave-equivalent, has more than 10 steps, and is not a root
-- mos nL ns, then:
local is_octave_equivalent = rat.eq(input_mos.equave, 2)
-- - If it has 5 periods or less, then its closest ancestor has a tamnams
local is_within_named_range = tamnams_name ~= nil and notecount <= 10
--  name.
-- - If it has more than 5 periods, then it relates to a root mos nL ns that
--  has more than 10 steps (ancestor therefore has no tamnams name).
-- If a mos is not octave-equivalent, then it may have a tamnams name (if
-- step count is 5 or less; currently unsupported) or not.
local is_octave_equivalent   = mos.is_octave_equivalent(input_mos)
local has_tamnams_name      = tamnams.lookup_name(input_mos) ~= nil
local is_within_named_range  = mos.step_count(input_mos) <= 10
local is_within_period_count = mos.period_count(input_mos) <= 5
local is_root_mos = input_mos.nL == input_mos.ns
local is_root_mos = input_mos.nL == input_mos.ns
local section_header = "TAMNAMS information"
local section_header = "TAMNAMS information"
local section_entries = nil
local section_entries = nil
if is_octave_equivalent then
if is_octave_equivalent and has_tamnams_name then
if is_within_named_range then
section_entries = {
-- Mos has a tamnams name
{ ["Header"] = string.format("<div style=\"margin-top: 0.6em;\"><b>%s</b></div>", section_header) },
section_entries = {
{ ["Header"] = "[[TAMNAMS#Mos_pattern_names | Name]]"   , ["Data"] = tamnams.lookup_name  (input_mos) },
{string.format("<b>%s</b>", section_header)},
{ ["Header"] = "[[TAMNAMS#Mos_pattern_names | Prefix]]" , ["Data"] = tamnams.lookup_prefix(input_mos) .. "-" },
{"[[TAMNAMS#Mos_pattern_names | Name]]", tamnams_name},
{ ["Header"] = "[[TAMNAMS#Mos_pattern_names | Abbrev.]]" , ["Data"] = tamnams.lookup_abbrev(input_mos) }
{"[[TAMNAMS#Mos_pattern_names | Prefix]]", tamnams_prefix},
}
{"[[TAMNAMS#Mos_pattern_names | Abbrev.]]", tamnams_abbrev}
elseif is_octave_equivalent and not has_tamnams_name and not is_root_mos and not is_within_named_range then
}
-- Lookup closest named ancestor mos
elseif not is_within_named_range and notecount > 10 and not is_root_mos then
local ancestor_mos, ratio_1, ratio_2, generations = tamnams.find_ancestor_info(input_mos)
-- Mos is a non-root mos and has a tamnams-named ancestor
local ancestor_mos, lg_chunk, sm_chunk, generations = p.find_mos_ancestor(input_mos)
-- Link to ancestor mos
local ancestor_scalesig = mos.as_string(ancestor_mos)
local ancestor_link = mos.as_link(ancestor_mos)
local ancestor_long_scalesig = mos.as_long_string(ancestor_mos)
local ancestor_name = mos.tamnams_name[ancestor_scalesig]
-- Lookup step ratio range
local step_ratio_range = string.format("%s:%s to %s:%s", ratio_1[1], ratio_1[2], ratio_2[1], ratio_2[2])
local ancestor_entry = string.format("[[%s | %s]]", ancestor_long_scalesig, ancestor_scalesig)
local range_name = tamnams.lookup_step_ratio_range(ratio_1, ratio_2)
if ancestor_name ~= nil then
local step_ratio_range_entry = range_name == nil and step_ratio_range or string.format("%s (%s)", step_ratio_range, range_name)
ancestor_entry = ancestor_entry .. string.format(" (%s)", ancestor_name)
end
local ancestor_name = tamnams.lookup_name(ancestor_mos)
local ancestor_entry = ancestor_name == nil and ancestor_link or string.format("%s (%s)", ancestor_link, ancestor_name)
section_entries = {
{string.format("<b>%s</b>", section_header)},
section_entries = {
{"Descends from", ancestor_entry}
{ ["Header"] = string.format("<div style=\"margin-top: 0.6em;\"><b>%s</b></div>", section_header) },
}
{ ["Header"] = "Related to"  , ["Data"] = ancestor_entry },
end
{ ["Header"] = "With tunings", ["Data"] = step_ratio_range_entry }
}
end
end
Line 352: Line 247:
-- Adds a section for scale names
-- Adds a section for scale names
function p.other_names(other_names)
function p.other_names(other_names)
local other_names = other_names or { "p-chromatic", "hard diatonic" }
local other_names = other_names or {"p-chromatic", "hard diatonic"}
local section_header = "Other names"
local section_header = "Other names"
Line 363: Line 258:
scale_names = scale_names .. other_names[i]
scale_names = scale_names .. other_names[i]
if i ~= #other_names then
if i ~= #other_names then
scale_names = scale_names .. "<br>"
scale_names = scale_names .. "<br />"
end
end
end
end
local section_entries = {
local section_entries = {
{string.format("<b>%s</b>", section_header)},
{ ["Header"] = string.format("<div style=\"margin-top: 0.6em;\"><b>%s</b></div>", section_header)},
{"Name(s)", scale_names}
{ ["Header"] = "Name(s)", ["Data"] = scale_names}
}  
}  
return section_entries
return section_entries
Line 382: Line 277:
local input_mos = input_mos or mos.new(5, 2)
local input_mos = input_mos or mos.new(5, 2)
local parent_mos = mos.new(math.min(input_mos.nL, input_mos.ns), math.abs(input_mos.nL-input_mos.ns), input_mos.equave)
-- Produce the mos's relatives
local sister_mos = mos.new(input_mos.ns, input_mos.nL, input_mos.equave)
local parent_mos, sister_mos, soft_child_mos, hard_child_mos, neutral_mos, soft_flought_mos, hard_flought_mos
local soft_child_mos = mos.new(input_mos.nL+input_mos.ns, input_mos.nL, input_mos.equave)
parent_mos = mos.parent(input_mos)
local hard_child_mos = mos.new(input_mos.nL, input_mos.nL+input_mos.ns, input_mos.equave)
sister_mos = mos.sister(input_mos)
soft_child_mos, hard_child_mos = mos.children(input_mos)
neutral_mos = mos.neutralized(input_mos)
soft_flought_mos, hard_flought_mos = mos.interleaved(input_mos)
local parent_scalesig = string.format("[[%s | %s]]", mos.as_long_string(parent_mos    ), mos.as_string(parent_mos   ))
-- Produce links to those relatives; parent and sister links have extra
local sister_scalesig = string.format("[[%s | %s]]", mos.as_long_string(sister_mos    ), mos.as_string(sister_mos   ))
-- checks to make sure they're valid mosses:
local soft_scalesig   = string.format("[[%s | %s]]", mos.as_long_string(soft_child_mos), mos.as_string(soft_child_mos))
-- - If the input mos is a root mos (nL ns), then it has no parent
local hard_scalesig   = string.format("[[%s | %s]]", mos.as_long_string(hard_child_mos), mos.as_string(hard_child_mos))
-- - If the input mos is a root mos, then it's its own sister
local is_nL_ns = input_mos.nL == input_mos.ns
local number_of_periods = utils._gcd(input_mos.nL, input_mos.ns)
local parent_scalesig       = is_nL_ns and "none" or mos.as_link(parent_mos)
local is_nL_ns = input_mos.nL == number_of_periods and input_mos.ns == number_of_periods
local sister_scalesig       = is_nL_ns and (mos.as_string(input_mos) .. " (self)") or mos.as_link(sister_mos)
if is_nL_ns then
local soft_scalesig         = mos.as_link(soft_child_mos)
parent_scalesig = "none"
local hard_scalesig         = mos.as_link(hard_child_mos)
sister_scalesig = sister_scalesig .. " (self)"
local neutral_scalesig      = mos.as_link(neutral_mos)
end
local soft_flought_scalesig = mos.as_link(soft_flought_mos)
local hard_flought_scalesig = mos.as_link(hard_flought_mos)
local section_header = "Related MOS scales"
local section_header = "Related MOS scales"
local section_entries = {
local section_entries = {
{string.format("<b>%s</b>", section_header)},
{ ["Header"] = string.format("<div style=\"margin-top: 0.6em;\"><b>%s</b></div>", section_header)},
{"[[Operations_on_MOSes#Parent_MOS | Parent]]", parent_scalesig},
{ ["Header"] = "[[Operations_on_MOSes#Parent_MOS | Parent]]"         , ["Data"] = parent_scalesig },
{"[[Operations_on_MOSes#Sister_MOS | Sister]]", sister_scalesig},
{ ["Header"] = "[[Operations_on_MOSes#Sister_MOS | Sister]]"         , ["Data"] = sister_scalesig },
{"[[Operations_on_MOSes#Daughter_MOS | Daughters]]", soft_scalesig .. "<br>" .. hard_scalesig}
{ ["Header"] = "[[Operations_on_MOSes#Daughter_MOS | Daughters]]"   , ["Data"] = soft_scalesig .. ", " .. hard_scalesig },
{ ["Header"] = "[[Operations_on_MOSes#Neutralization | Neutralized]]", ["Data"] = neutral_scalesig},
{ ["Header"] = "[[Flought_scale | 2-Flought]]"                      , ["Data"] = soft_flought_scalesig .. ", " .. hard_flought_scalesig }
}
}
Line 412: Line 313:
-- Helper function
-- Helper function
-- Produces simple equal tunings
-- Produces simple equal tunings
-- Includes xenpaper links
function p.equal_tunings(input_mos)
function p.equal_tunings(input_mos)
local input_mos = input_mos or mos.new(5, 2)
local input_mos = input_mos or mos.new(5, 2)
local bright_gen = mos.bright_gen(input_mos)
local bright_gen = mos.bright_gen(input_mos)
local mos_as_vector = {
['L'] = input_mos.nL,
['s'] = input_mos.ns
}
local step_ratios = {
local step_ratios = {
{ 1, 1 },
{ 1, 1 },
Line 434: Line 329:
}
}
local step_ratio_names = {
local section_header = p.annotate_section_header(input_mos, "Equal tunings")
"Equalized",
local section_entries = {{ ["Header"] = section_header }}
"Supersoft",
"Soft",
"Semisoft",
"Basic",
"Semihard",
"Hard",
"Superhard",
"Collapsed"
}
local section_header = "Equal tunings"
local equave_annotation = ""
if rat.eq(input_mos.equave, 3) then
equave_annotation = '<sup><abbr title="In steps of edt">(edt)</sup>'
elseif rat.eq(input_mos.equave, rat.new(3,2)) then
equave_annotation = '<sup><abbr title="In steps of edf">(edf)</sup>'
elseif not rat.eq(input_mos.equave, 2) then
local equave_as_ratio = rat.as_ratio(input_mos.equave)
equave_annotation = string.format('<sup><abbr title="In steps of ed%s">(ed%s)</sup>', equave_as_ratio, equave_as_ratio)
end
local section_entries = {
{string.format("<b>%s</b>%s", section_header, equave_annotation)},
}
for i = 1, #step_ratios do
for i = 1, #step_ratios do
local step_ratio = step_ratios[i]
local step_ratio = step_ratios[i]
local ed_size = mos_as_vector['L'] * step_ratio[1] + mos_as_vector['s'] * step_ratio[2]
local ed_as_string = mos.et_string(input_mos, step_ratio)
local gen_size = bright_gen['L'] * step_ratio[1] + bright_gen['s'] * step_ratio[2]
local ed = et.new(ed_size, input_mos.equave)
local gen_in_steps = mos.bright_gen_to_et_string(input_mos, step_ratio, "")
local ed_as_string = et.as_string(ed)
local gen_in_cents = mos.bright_gen_to_cents(input_mos, step_ratio)
local ed_no_prefix = et.new(ed_size, input_mos.equave, "")
local step_ratio_name = tamnams.lookup_step_ratio(step_ratio)
local ed_as_string_no_prefix = et.as_string(ed_no_prefix)
step_ratio_name = step_ratio_name:gsub("^%l", string.upper)
local gen_in_steps = et.backslash_display(ed_no_prefix, gen_size)
local xenpaper_link = xp.mosstep_pattern_to_xenpaper_link(mos.brightest_mode(input_mos), step_ratios[i], input_mos.equave)
local gen_in_cents = et.cents(ed, gen_size)
local caption = string.format("[[%s]] [%s (<span style=\"white-space: nowrap;\">L:s = %d:%d</span>)]", step_ratio_name, xenpaper_link, step_ratio[1], step_ratio[2])
local text = string.format("[[%s|%s]] (%.1f{{c}})", ed_as_string, gen_in_steps, gen_in_cents)
local caption = string.format("[[%s]] (L:s = %d:%d)", step_ratio_names[i], step_ratio[1], step_ratio[2])
table.insert(section_entries, { ["Header"] = caption, ["Data"] = text })
local text = string.format("[[%s | %s]] (%.1f¢)", ed_as_string, gen_in_steps, gen_in_cents)
table.insert(section_entries, { caption, text })
end
end


Line 485: Line 354:


-- New "main" function
-- New "main" function
function p._infobox_mos(tuning, other_names_unparsed)
function p._infobox_mos(input_mos)
local tuning = tuning or "5L 2s"
local input_mos = input_mos or mos.new(4, 5, 3)
local other_names_unparsed = other_names_unparsed or ""
local other_names_unparsed = ""
local tuning_parsed = mos.parse(tuning)
local other_names_parsed = tip.parse_entries(other_names_unparsed) or tip.parse_entries(other_names_unparsed, ",")
local other_names_parsed = tip.parse_entries(other_names_unparsed) or tip.parse_entries(other_names_unparsed, ',')
local sections = {}
local sections = {}
-- Keyboard visualization
-- Keyboard visualization
local kb_vis = p.kb_vis(tuning_parsed)
local kb_vis = p.kb_vis(input_mos)
p.concatenate_tables(sections, kb_vis)
p.concatenate_tables(sections, kb_vis)
-- Scale structure section
-- Scale structure section
local scale_structure = p.scale_structure(tuning_parsed)
local scale_structure = p.scale_structure(input_mos)
p.concatenate_tables(sections, scale_structure)
p.concatenate_tables(sections, scale_structure)
Line 507: Line 375:
-- Generator sizes section
-- Generator sizes section
local gen_sizes = p.generator_sizes(tuning_parsed)
local gen_sizes = p.generator_sizes(input_mos)
p.concatenate_tables(sections, gen_sizes)
p.concatenate_tables(sections, gen_sizes)
-- Tamnams info section, if applicable
-- Tamnams info section, if applicable
local tamnams_info = p.tamnams_information(tuning_parsed)
local tamnams_info = p.tamnams_information(input_mos)
if tamnams_info ~= nil then
if tamnams_info ~= nil then
p.concatenate_tables(sections, tamnams_info)
p.concatenate_tables(sections, tamnams_info)
Line 523: Line 391:
-- Related scales section
-- Related scales section
local related_scales = p.related_scales(tuning_parsed)
local related_scales = p.related_scales(input_mos)
p.concatenate_tables(sections, related_scales)
p.concatenate_tables(sections, related_scales)
-- Equal tunings section
-- Equal tunings section
local equal_tunings = p.equal_tunings(tuning_parsed)
local equal_tunings = p.equal_tunings(input_mos)
p.concatenate_tables(sections, equal_tunings)
p.concatenate_tables(sections, equal_tunings)


-- Adjacent links
-- Adjacent links
local adjacent_links = p.adjacent_links(tuning_parsed)
local adjacent_links = p.adjacent_links(input_mos)
local args = {
["Adjacent Links"] = adjacent_links,
["Title"] = mos.as_long_string(input_mos),
["Rows"] = sections,
["name"] = "Infobox MOS"
}
return infobox.build_multilink(tuning, sections, adjacent_links)
return ib._infobox(args)
--return sections
--return sections
end
end
Line 539: Line 414:
-- Wrapper function
-- Wrapper function
function p.infobox_MOS(frame)
function p.infobox_MOS(frame)
local args = getArgs(frame)
local tuning = frame.args['Tuning']
-- "Scale Signature" is preferred; "Tuning" is supported for legacy purposes
local other_names = frame.args['Other names'] or nil
local unparsed = args["Tuning"] or args["Scale Signature"]
local debug_mode = tonumber(frame.args['debug']) == 1
local input_mos = mos.parse(unparsed)
local other_names = args["othernames"] or nil
local debug_mode = yesno(args["debug"], false)
local wtext = yesno(frame.args["wtext"] or args["wtext"])
local result = p._infobox_mos(tuning, other_names)
local result = p._infobox_mos(input_mos)
if not debug_mode then
if not debug_mode then
result = result .. p.categorize(tuning)
result = result .. p.categorize(input_mos)
end
end
return result
if wtext then
 
result = "<syntaxhighlight lang=\"wikitext\">" .. result .. "</syntaxhighlight>"
end
end
 
function p.tester()
 
local prev_link = "5L 1s"
local next_link = "5L 3s"
local entries = {
{"Scale structure"},
{"Brightest mode", "LLLsLLs"},
{"Period (cents)", "2\1 (1200¢)"},
{"Bright generator range", "4\7 (685.7¢) to 3\5 (720¢)"},
{"Dark generator range", "2\5 (480¢) to 3\7 (514.3¢)"},
 
{"TAMNAMS information"},
{"Name", "diatonic"},
{"Prefix", "dia-"},
{"Abbrev.", "dia."},
 
{"Related scales"},
{"Parent MOS", "2L 3s"},
{"Sister MOS", "2L 5s"},
{"Daughter MOSes", "7L 5s, 5L 7s"},
 
{"Equal tunings"},
{"Supersoft (L:s = 4:3)", "15\\26 (692.3¢)"},
{"Soft (L:s = 3:2)", "11\\19 (694.7¢)"},
{"Semisoft (L:s = 5:3)", "18\\31 (696.8¢)"},
{"Basic (L:s = 2:1)", "7\\12 (700¢)"},
{"Semihard (L:s = 5:2)", "17\\29 (703.4¢)"},
{"Hard (L:s = 3:1)", "10\\17 (705.9¢)"},
{"Superhard (L:s = 4:1)", "13\\22 (709.1¢)"},
}
return infobox.build_multilink("5L 2s (2/1-equivalent)", entries)
return frame:preprocess(result)
end
end


return p
return p
Retrieved from "https://en.xen.wiki/w/Module:Infobox_MOS"