Xenharmonic Wiki

Module:Ups and downs notation: Difference between revisions

← Older edit
CompactStar (talk | contribs)
autopatrolled
5,084 edits
No edit summary
ArrowHead294 (talk | contribs)
15,213 edits
mNo edit summary
 
(90 intermediate revisions by 5 users not shown)
Line 1: Line 1:
local ET = require("Module:ET")
local u = require("Module:Utils")
local p = {}
local p = {}


local ET = require("Module:ET")
local utils = require("Module:Utils")
local yesno = require("Module:Yesno")


local function table_contains(tbl, x)
-- Returns a table of note names
    found = false
    for _, v in pairs(tbl) do
        if v == x then
            found = true
        end
    end
    return found
end
 
 
-- Returns a nested table of note names
-- e.g. for 12edo, intended result would be something like:
-- e.g. for 12edo, intended result would be something like:
-- {
-- {
-- 0 = {"C"},
-- [0] = {"D"},
-- 1 = {"Db"},
-- [1] = {"D#", "Eb"},
-- 2 = {"D"},
-- [2] = {"E"},
-- 3 = {"Eb"},
-- [3] = {"F"},
-- 4 = {"E"},
-- [4] = {"F#", "Gb"},
-- 5 = {"F"},
-- [5] = {"G"},
-- 6 = {"F#", "Gb"},
-- [6] = {"G#", "Ab"},
-- 7 = {"G"},
-- [7] = {"A"},
--  8 = {"Ab"},
--  [8] = {"A#", Bb"},
--  9 = {"A"},
--  [9] = {"B"},
--  10 = {"Bb"},
--  [10] = {"C"},
--  11 = {"B"},
--  [11] = {"C#", "Db"},
--  12 = {"C"}
--  [12] = {"D"}
-- }
-- }


function p.get_note_names_table(et)
local function round(x)
-- rounds half-integers towards 0.
return x >= 0 and math.ceil(x - 0.5) or math.floor(x + 0.5)
end
 
function p.get_note_names_table(et, fifth)
local note_names = {}
local note_names = {}
local i = 0
for i = 0, et.size do
while i < et.size do
note_names[i] = {}
note_names[i] = {}
end
end
 
local fifth = u.round(math.log(3/2)/math.log(2) * et.size)
fifth = fifth or math.floor(math.log(3 / 2) / math.log(2) * et.size + 0.5)
local fourth = u.round(math.log(4/3)/math.log(2) * et.size)
local fourth = et.size - fifth -- 4/3 = [2 -1>
local chroma = (fifth * 7) % et.size
local chroma = (fifth * 7) % et.size -- 2187/2048 = [-11 7>
local is_mavila = fifth / et.size < 4 / 7
local major_note_idx = {
if is_mavila then
0,  
chroma = et.size - chroma
end
 
local diatonic_note_idx = {
0,
(fifth * 2) % et.size,
(fifth * 2) % et.size,
(fifth * 4) % et.size,
(fifth * -3) % et.size,
fourth,
fourth,
fifth,
fifth,
(fifth * 3) % et.size,
(fifth * 3) % et.size,
(fifth * 5) % et.size,
(fifth * -2) % et.size,
tuning.size
et.size,
}
}
 
-- Add major scale notes
-- Add D dorian scale notes
table.insert(note_names[major_note_idx[1]], "C")
table.insert(note_names[diatonic_note_idx[1]], "D")
table.insert(note_names[major_note_idx[2]], "D")
table.insert(note_names[diatonic_note_idx[2]], "E")
table.insert(note_names[major_note_idx[3]], "E")
table.insert(note_names[diatonic_note_idx[3]], "F")
table.insert(note_names[major_note_idx[4]], "F")
table.insert(note_names[diatonic_note_idx[4]], "G")
table.insert(note_names[major_note_idx[5]], "G")
table.insert(note_names[diatonic_note_idx[5]], "A")
table.insert(note_names[major_note_idx[6]], "A")
table.insert(note_names[diatonic_note_idx[6]], "B")
    table.insert(note_names[major_note_idx[7]], "B")
table.insert(note_names[diatonic_note_idx[7]], "C")
    table.insert(note_names[major_note_idx[8]], "C")
table.insert(note_names[diatonic_note_idx[8]], "D")
 
-- temporary
local last_diatonic_note = 0
mw.logObject(note_names)
 
-- Add sharp/up notes
-- Add sharp/up notes
i = 0
for i = 0, et.size - 1 do
local last_major_note = 0
if utils.table_contains(diatonic_note_idx, i) then
while i < et.size do
last_diatonic_note = i
if table_contains(major_note_idx, i) then
last_major_note = i
else
else
local num_sharps = math.floor((i - last_major_note) / chroma)
local num_double_sharps = 0
local num_ups = (i - last_major_note) % chroma
local num_sharps = round((i - last_diatonic_note) / chroma)
local name = interval_names[last_major_note]
if num_sharps > 1 then
local j = 0
num_double_sharps = math.floor(num_sharps / 2)
while j < num_sharps do
num_sharps = num_sharps % 2
name = name + "#"
end
end
j = 0
local num_ups = (i - last_diatonic_note) % chroma
while j < num_ups do
local num_downs = 0
name = "^" + name
if chroma == 0 then
num_double_sharps = 0
num_sharps = 0
num_ups = (i - last_diatonic_note)
end
if num_ups > chroma / 2 then
num_downs = chroma - num_ups
num_ups = 0
end
local last_diatonic_names = note_names[last_diatonic_note]
for j = 1, #last_diatonic_names do
if num_downs >= 3 then
table.insert(
note_names[i],
"v<sup>"
.. num_downs
.. "</sup>"
.. last_diatonic_names[j]
.. string.rep("♯", num_sharps)
.. string.rep("𝄪", num_double_sharps)
)
elseif num_downs > 0 then
table.insert(
note_names[i],
string.rep("v", num_downs)
.. last_diatonic_names[j]
.. string.rep("♯", num_sharps)
.. string.rep("𝄪", num_double_sharps)
)
elseif num_ups >= 3 then
table.insert(
note_names[i],
"^<sup>"
.. num_ups
.. "</sup>"
.. last_diatonic_names[j]
.. string.rep("♯", num_sharps)
.. string.rep("𝄪", num_double_sharps)
)
else
table.insert(
note_names[i],
string.rep("^", num_ups)
.. last_diatonic_names[j]
.. string.rep("♯", num_sharps)
.. string.rep("𝄪", num_double_sharps)
)
end
end
end
table.insert(note_names[i], name)
end
end
i = i + 1
end
end
last_diatonic_note = et.size


-- Add flat/down notes
-- Add flat/down notes
i = et.size - 1
for i = et.size - 1, 0, -1 do
local last_major_note = tuning.size - 1
if utils.table_contains(diatonic_note_idx, i) then
while i >= 0 do
last_diatonic_note = i
if table_contains(major_note_idx, i) then
last_major_note = i
else
else
local num_flats = math.floor((last_major_note - i) / chroma)
local num_flats = round((last_diatonic_note - i) / chroma)
local num_downs = (last_major_note - i) % chroma
local num_downs = (last_diatonic_note - i) % chroma
local name = interval_names[last_major_note]
local num_ups = 0
local j = 0
if chroma == 0 then
while j < num_flats do
num_flats = 0
name = name + "b"
num_downs = (last_diatonic_note - i)
end
end
j = 0
if num_downs > chroma / 2 then
while j < num_downs do
num_ups = chroma - num_downs
name = "v" + name
num_downs = 0
end
local last_diatonic_names = note_names[last_diatonic_note]
for j = 1, #last_diatonic_names do
if num_ups >= 3 then
table.insert(
note_names[i],
"^<sup>" .. num_ups .. "</sup>" .. last_diatonic_names[j] .. string.rep("♭", num_flats)
)
elseif num_ups > 0 then
table.insert(
note_names[i],
string.rep("^", num_ups) .. last_diatonic_names[j] .. string.rep("♭", num_flats)
)
elseif num_downs >= 3 then
table.insert(
note_names[i],
"v<sup>" .. num_downs .. "</sup>" .. last_diatonic_names[j] .. string.rep("♭", num_flats)
)
else
table.insert(
note_names[i],
string.rep("v", num_downs) .. last_diatonic_names[j] .. string.rep("♭", num_flats)
)
end
end
end
table.insert(note_names[i], name)
end
end
i = i - 1
end
end
 
return note_names
return note_names
end
end


function p.ups_and_downs_note_name(frame)
function p.ups_and_downs_note_name(frame)
local et = ET.parse(frame.args['tuning']) or ET.parse('12edo')
local et = ET.parse(frame.args["tuning"]) or ET.parse("12edo")
local step = tonumber(frame.args['step'])
local debugg = yesno(frame.args["debug"])
local tbl = p.get_note_names_table(et)[step]
local fifth = tonumber(frame.args["fifth"])
local result = ''
local step = tonumber(frame.args["step"])
local i = 0
local result = table.concat(p.get_note_names_table(et, fifth)[step], ", "):sub(0, -1)
while i < #tbl do
result = result + tbl[i] + ','
if debugg == true then
result = "<syntaxhighlight lang=\"wikitext\">" .. result .. "</syntaxhighlight>"
end
end
return result
-- result = result:slice(0, result.len() - 1)
return frame:preprocess(result)
-- return result
end
end


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