Xenharmonic Wiki

Module:Mediants: Difference between revisions

Ganaram inukshuk (talk | contribs)
autopatrolled, emailconfirmed
6,211 edits
Created page with "local mos = require("Module:MOS") local p = {} function p.find_mediants_by_depth(start_ratio_1, start_ratio_2, depth) local start_ratio_1 = start_ratio_1 or {1, 1} local st..."
 
Ganaram inukshuk (talk | contribs)
autopatrolled, emailconfirmed
6,211 edits
update code to be documentation
 
(21 intermediate revisions by 2 users not shown)
Line 1: Line 1:
local mos = require("Module:MOS")
-- This module follows [[User:Ganaram inukshuk/Provisional style guide for Lua]]
local rat  = require("Module:Rational")
local utils = require("Module:Utils")
 
local p = {}
local p = {}


function p.find_mediants_by_depth(start_ratio_1, start_ratio_2, depth)
-- Mediants consists of code used to find a tree of mediants, starting from a
local start_ratio_1 = start_ratio_1 or {1, 1}
-- set of starting ratios (default 1/1 and 1/0). Search can be by int limit,
local start_ratio_2 = start_ratio_2 or {1, 0}
-- depth, or a custom search function.
local depth = depth or 5
-- Ratios produced this way are a table consisting of the numerator and
-- denominator, which allows for non-simplified ratios to be represented.
local ratios = { start_ratio_1, start_ratio_2 }
 
--------------------------------------------------------------------------------
for i = 1, depth do
------------------------------ UTILITY FUNCTIONS -------------------------------
local new_ratios = {}
--------------------------------------------------------------------------------
 
for j = 1, #ratios - 1 do
-- Given a table of depths, return the deepest depth
local ratio_1 = ratios[j]
function p.deepest_depth(depths)
local ratio_2 = ratios[j+1]
local deepest = nil
local mediant = { ratio_1[1] + ratio_2[1], ratio_1[2] + ratio_2[2] }
for _, value in ipairs(depths) do
table.insert(new_ratios, ratio_1)
if not deepest or value > deepest then
table.insert(new_ratios, mediant)
deepest = value
end
end
table.insert(new_ratios, ratios[#ratios])
ratios = new_ratios
end
end
return ratios
return deepest
end
end


function p.int_limit_filter(ratios, ratio_1, ratio_2, int_limit)
-- Given a ratio, return its simplified form.
local mediant = { ratio_1[1] + ratio_2[1], ratio_1[2] + ratio_2[2] }
function p.simplify_ratio(ratio)
local new_ratio_added = false
local gcd = utils._gcd(ratio[1], ratio[2])
return { ratio[1] / gcd, ratio[2] / gcd }
local int_max = math.max(mediant[1], mediant[2])
end


if int_max <= int_limit then
-- Sort ratios in ascending order. Comparison function is built-in.
new_ratio_added = true
function p.sort_ratios(ratios)
table.insert(ratios, mediant)
table.sort(ratios, function(ratio_1, ratio_2)
end
return ratio_1[1] / ratio_1[2] < ratio_2[1] / ratio_2[2]
end
return new_ratio_added
)
end
end


function p.num_den_sum_filter(ratios, ratio_1, ratio_2, max_sum)
--------------------------------------------------------------------------------
local mediant = { ratio_1[1] + ratio_2[1], ratio_1[2] + ratio_2[2] }
----------------------------- CONVERTER FUNCTIONS ------------------------------
local new_ratio_added = false
--------------------------------------------------------------------------------
 
local num_den_sum = mediant[1] + mediant[2]
-- Converts ratios into the form defined by [[Module:Rational]], a table
-- consisting of its prime factorization.
 
-- Given a single ratio, as a table of two numbers, convert to rational and
-- return it.
function p.to_rational(ratio)
return rat.new(ratio[1], ratio[2])
end


if num_den_sum <= max_sum then
-- Given a table of ratios, each a table of two numbers, return an array of
new_ratio_added = true
-- ratios in the form as defined by module:Rational.
table.insert(ratios, mediant)
function p.to_rationals(ratios)
local rats = {}
for i = 1, #ratios do
table.insert(rats, p.to_rational(ratios[i]))
end
end
return rats
return new_ratio_added
end
end


function p.generator_increment_filter(ratios, ratio_1, ratio_2, increment)
--------------------------------------------------------------------------------
local mediant = { ratio_1[1] + ratio_2[1], ratio_1[2] + ratio_2[2] }
------------------------------- SEARCH FUNCTIONS -------------------------------
local new_ratio_added = false
--------------------------------------------------------------------------------
local input_mos = mos.new(5,2)
 
-- Search functions determine whether a mediant meets a specific criteria for
local g1 = mos.bright_gen_to_cents(input_mos, ratio_1)
-- being added to a set of mediants, be it based on something about the mediant,
local g2 = mos.bright_gen_to_cents(input_mos, ratio_2)
-- its search depth, the ratios that produced the mediant, or any combination
local gm = mos.bright_gen_to_cents(input_mos, mediant)
-- thereof.
-- NOTE: some search criteria, such as prime limit, are considered unsuitable,
local inc1 = math.abs(g1 - gm)
-- since mediants not within a prime limit are used to find ratios within a
local inc2 = math.abs(gm - g2)
-- prime limit, it will likely prevent desired ratios from being found at all.
-- For this reason, these functions are meant for broad search, and finer
-- filtering must be done afterwards.
 
-- A search function has two params: a table containing the mediant and the
-- depth it was found at, and a search param.
-- Mediant data is a table that contains the mediant, the search depth it was
-- found at, and the two ratios that were used to find the mediant.
-- The search params can be a single numeric value, or a table of values for
-- finer control.
 
-- Int limit search determines whether a ratio is within an int limit. Only uses
-- information about the mediant. Meant for use with searching for JI ratios.
function p.int_limit_search(mediant_data, int_limit)
local mediant = mediant_data["mediant"]
return math.max(mediant[1], mediant[2]) <= int_limit
end


if inc1 >= increment or inc2 >= increment then
-- Depth search determines whether a ratio is within a target depth. Only uses
new_ratio_added = true
-- the depth it was found at. Meant for use with searching for step ratios.
table.insert(ratios, mediant)
function p.depth_search(mediant_data, search_depth)
end
local depth = mediant_data["depth"]
return depth <= search_depth
return new_ratio_added
end
end


function p.find_mediants_by_filter(start_ratio_1, start_ratio_2, filter, filter_arg)
--------------------------------------------------------------------------------
local start_ratio_1 = start_ratio_1 or {1, 1}
---------------------------- GENERAL SEARCH FUNCTION ---------------------------
local start_ratio_2 = start_ratio_2 or {1, 0}
--------------------------------------------------------------------------------
 
-- General search function searches for mediants using a filter function. A
-- custom filter function can be passed in to "filter" out mediants. Ratios
-- are added using a while loop, which exits if a loop iteration adds no new
-- ratios.
 
-- Find mediants by filter, where the filter function and its args are passed in
-- as part of the function call.
function p.find_mediants_by_search_func(init_ratios, search_func, search_args)
local init_ratios = init_ratios or {{1,1}, {1,0}}
local ratios = { start_ratio_1, start_ratio_2 }
local ratios = {}
local depths = {}
for i = 1, #init_ratios do
table.insert(ratios, init_ratios[i])
table.insert(depths, 0)
end
local new_ratios_added = true
local new_ratios_added = true
Line 84: Line 124:
new_ratios_added = false
new_ratios_added = false
local new_ratios = {}
local new_ratios = {}
local new_depths = {}
for i = 1, #ratios-1 do
for i = 1, #ratios-1 do
local ratio_1 = ratios[i]
local ratio_1 = ratios[i]
local ratio_2 = ratios[i+1]
local ratio_2 = ratios[i+1]
local mediant = { ratio_1[1] + ratio_2[1], ratio_1[2] + ratio_2[2] }
table.insert(new_ratios, ratio_1)
table.insert(new_ratios, ratio_1)
new_ratios_added = filter(new_ratios, ratio_1, ratio_2, filter_arg)
local depth_1 = depths[i]
local depth_2 = depths[i+1]
local new_depth = math.max(depth_1, depth_2) + 1
table.insert(new_depths, depth_1)
local mediant_data = { ["mediant"] = mediant, ["depth"] = new_depth, ["ratio_1"] = ratio_1, ["ratio_2"] = ratio_2 }
if search_func(mediant_data, search_args) then
table.insert(new_ratios, mediant)
table.insert(new_depths, new_depth)
new_ratios_added = true
end
end
end
table.insert(new_ratios, ratios[#ratios])
table.insert(new_depths, depths[#depths])
table.insert(new_ratios, ratios[#ratios])
ratios = new_ratios
ratios = new_ratios
depths = new_depths
end
end
return ratios, depths
end
-- Find mediants by filter, where the filter function and its args are passed in
-- as part of the function call. Only returns mediants, not depths.
function p.find_only_mediants_by_search_func(init_ratios, search_func, search_args)
local init_ratios = init_ratios or {{1,1}, {1,0}}
local ratios, depths
ratios, depths = p.find_mediants_by_search_func(init_ratios, search_func, search_args)
return ratios
return ratios
end
end


function p.tester()
--------------------------------------------------------------------------------
local func = p.int_limit_filter
------------------------- DEPTH-BASED SEARCH FUNCTION --------------------------
--------------------------------------------------------------------------------
 
-- Depth-based search finds mediants by building a tree of mediants up to a
-- specified depth. This is made a standalone function under the reasoning that
-- it's a common enough operation.
 
-- Find mediants by depth of its search tree.
function p.find_mediants(init_ratios, depth)
local init_ratios = init_ratios or {{1,1}, {1,0}}
local depth = depth or 5
 
local ratios, depths
ratios, depths = p.find_mediants_by_search_func(init_ratios, p.depth_search, depth)
return ratios, depths
end
 
-- Find mediants by depth of its search tree. Does not return depths.
function p.find_only_mediants(init_ratios, depth)
local init_ratios = init_ratios or {{1,1}, {1,0}}
local depth = depth or 5
 
local ratios, depths
ratios, depths = p.find_mediants_by_search_func(init_ratios, p.depth_search, depth)
return ratios
end
 
--------------------------------------------------------------------------------
---------------------- INT-LIMIT-BASED SEARCH FUNCTION -------------------------
--------------------------------------------------------------------------------
 
-- Int limit search finds mediants up to an integer limit, not permitting ratios
-- whose numerator or denominator exceeds the int limit. This is made a stand-
-- alone function under the reasoning that it's a common enough operation.
 
-- Find mediants within an int limit.
function p.find_mediants_by_int_limit(init_ratios, int_limit)
local init_ratios = init_ratios or {{1,1}, {1,0}}
local int_limit = int_limit or 50
local ratios, depths
ratios, depths = p.find_mediants_by_search_func(init_ratios, p.int_limit_search, int_limit)
return ratios, depths
end
 
-- Find mediants within an int limit. Does not return depth.
function p.find_only_mediants_by_int_limit(init_ratios, int_limit)
local init_ratios = init_ratios or {{1,1}, {1,0}}
local int_limit = int_limit or 50
local ratios = p.find_mediants_by_filter({1,1}, {1,0}, func, 12)
local ratios, depths
local generators = {}
ratios, depths = p.find_mediants_by_search_func(init_ratios, p.int_limit_search, int_limit)
for i = 1, #ratios do
local input_mos = mos.new(5,2)
local gen = mos.bright_gen_to_cents(input_mos, ratios[i])
local new_string = string.format("%s:%s\t%s", ratios[i][1], ratios[i][2], gen)
table.insert(generators, string.format("%s:%s\t%s", ratios[i][1], ratios[i][2], gen))
end
return generators
return ratios
end
 
--------------------------------------------------------------------------------
----------------------------------- TESTER -------------------------------------
--------------------------------------------------------------------------------
 
function p.tester()
--return p.find_only_mediants_by_int_limit()
local ratios = {{4,3}, {5,1}, {3,2}}
p.sort_ratios(ratios)
return p.to_rationals(ratios)
end
end


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