「モジュール:MOS」の版間の差分

-- This module follows [[User:Ganaram inukshuk/Provisional style guide for Lua]]

local et    = require("Module:ET")

local rat  = require("Module:Rational")

local utils = require("Module:Utils")

local p = {}

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

-- Create a new mos as a table containing the counts for large and small steps,

-- plus the equave.

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

local nL, ns, equave = unparsed:match("^(%d+)[Ll].-(%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/LINK FUNCTIONS -----------------------------

-- Scalesig is "xL ys <p/q>" for valid mosses, omitting <p/q> for 2/1 scales.

-- Option to use nbsp is provided using the second param; default is nbsp.

function p.as_string(mos, use_nbsp)

if p.is_valid(mos) then

local suffix = ""

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

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

function p.as_long_string(mos, use_nbsp)

if p.is_valid(mos) then

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

 

return string.format("[[%s|%s]]", link, text)

 

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

if interval["L"] == 0 then

elseif interval["L"] == 1 then

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

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

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

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

if interval["L"] == 0 and interval["s"] == 0 then

elseif interval["L"] == 0 and interval["s"] ~= 0 then  

elseif interval["L"] ~= 0 and interval["s"] == 0 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 DOWN PER PERIOD:

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

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

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

-- (where s mod p = 0), then there will be p modes. If the mode has one step

-- type, then there is only one mode.

if not utils.table_contains(rotations, current_mode) then

-- shift it to the right. Helper function for mode_by_brightness().

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

for i = 0, #mode_string do

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

--------------- FUNCTIONS FOR GENERATOR AND PERIOD INTERVALS -------------------

-- Compute the bright gen as a vector of L's and s's. Since all mosstep

-- intervals (excluding the root and period) have two sizes, this returns the

-- large/perfect 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. Since all mosstep

-- intervals (excluding the root and period) have two sizes, this returns the

-- small/perfect size.

-- Period intervals as mossteps only appear as one size.

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

["s"] = mos.ns / gcd

-- Equaves as mossteps only appear as one size. For a single-period mos, this

-- is the same as p.period().

["L"] = mos.nL,

["s"] = mos.ns

------------------- FUNCTIONS FOR SINGLE-STEP INTERVALS ------------------------

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

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

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

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

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

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

-- Return the vector for a single large step.

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

-- Return the vector for a single small step.

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

-- Return 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. Params:

-- - step_count: the number of steps subtended by the mosstep.

-- - size_offset: denotes whether to return the large size (0) or the small

--   size (-1) (or if this is a period interval, the diminished size). Values

--   other than 0 or 1 represent alterations by multiple chromas, such as

--   augmented (1) or diminished (-2).

-- - 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"]

-- TODO: deprecate this since "equave_step_count" is redundant and longer than

-- "step count".

return interval["L"] + interval["s"]

-- size_offset denotes whether to count chromas from the large size; changing

-- this to -1 counts chromas from the small size. Like size_offset for

-- interval_from_mos, this can be used to denote altered mossteps (augmented,

-- diminished, etc).

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

--------------- INTERVAL ARITHMETIC AND MANIPULATION 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"]

-- Stack an interval, or 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. For single-period mosses, the period

-- complement is the same as the equave complement.

return "edo"

--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(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_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_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" ..