Xenharmonic Wiki

Module:Mediants: Difference between revisions

← Older edit
Ganaram inukshuk (talk | contribs)
autopatrolled, emailconfirmed
6,211 edits
No edit summary
Ganaram inukshuk (talk | contribs)
autopatrolled, emailconfirmed
6,211 edits
update code to be documentation
 
(10 intermediate revisions by 2 users not shown)
Line 1: Line 1:
local mos = require("Module:MOS") -- For testing
-- This module follows [[User:Ganaram inukshuk/Provisional style guide for Lua]]
local utils = require("Module:Utils") -- For testing
local rat  = require("Module:Rational")
local utils = require("Module:Utils")
 
local p = {}
local p = {}


-- Module for finding mediants, either by search depth or by search function.
-- Mediants consists of code used to find a tree of mediants, starting from a
-- set of starting ratios (default 1/1 and 1/0). Search can be by int limit,
-- depth, or a custom search function.
-- Ratios produced this way are a table consisting of the numerator and
-- denominator, which allows for non-simplified ratios to be represented.
 
--------------------------------------------------------------------------------
------------------------------ UTILITY FUNCTIONS -------------------------------
--------------------------------------------------------------------------------
 
-- Given a table of depths, return the deepest depth
function p.deepest_depth(depths)
local deepest = nil
for _, value in ipairs(depths) do
if not deepest or value > deepest then
deepest = value
end
end
return deepest
end
 
-- Given a ratio, return its simplified form.
function p.simplify_ratio(ratio)
local gcd = utils._gcd(ratio[1], ratio[2])
return { ratio[1] / gcd, ratio[2] / gcd }
end
 
-- Sort ratios in ascending order. Comparison function is built-in.
function p.sort_ratios(ratios)
table.sort(ratios, function(ratio_1, ratio_2)
return ratio_1[1] / ratio_1[2] < ratio_2[1] / ratio_2[2]
end
)
end
 
--------------------------------------------------------------------------------
----------------------------- CONVERTER FUNCTIONS ------------------------------
--------------------------------------------------------------------------------
 
-- 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


-- TODO: Add int-limit search
-- Given a table of ratios, each a table of two numbers, return an array of
-- ratios in the form as defined by module:Rational.
function p.to_rationals(ratios)
local rats = {}
for i = 1, #ratios do
table.insert(rats, p.to_rational(ratios[i]))
end
return rats
end


--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
Line 13: Line 70:
-- Search functions determine whether a mediant meets a specific criteria for
-- Search functions determine whether a mediant meets a specific criteria for
-- being added to a set of mediants, be it based on something about the mediant,
-- being added to a set of mediants, be it based on something about the mediant,
-- its search depth, or both.
-- its search depth, the ratios that produced the mediant, or any combination
-- thereof.
-- NOTE: some search criteria, such as prime limit, are considered unsuitable,
-- NOTE: some search criteria, such as prime limit, are considered unsuitable,
-- since mediants not within a prime limit are used to find ratios within a
-- since mediants not within a prime limit are used to find ratios within a
Line 22: Line 80:
-- A search function has two params: a table containing the mediant and the
-- A search function has two params: a table containing the mediant and the
-- depth it was found at, and a search param.
-- depth it was found at, and a search param.
-- Mediant data, the first param, is of the form:
-- Mediant data is a table that contains the mediant, the search depth it was
-- { ["mediant"] = { p, q }, ["depth"] = d }, where, p, q, d are integers.
-- 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
-- The search params can be a single numeric value, or a table of values for
-- finer control.
-- finer control.


-- Int limit search determines whether a ratio is within an int limit. Does not
-- Int limit search determines whether a ratio is within an int limit. Only uses
-- use depth. Meant for use with searching for JI ratios.
-- information about the mediant. Meant for use with searching for JI ratios.
function p.int_limit_search(mediant_data, int_limit)
function p.int_limit_search(mediant_data, int_limit)
local mediant = mediant_data["mediant"]
local mediant = mediant_data["mediant"]
Line 34: Line 92:
end
end


-- Depth search determines whether a ratio is within a target depth. Does not
-- Depth search determines whether a ratio is within a target depth. Only uses
-- use the mediant itself. Meant for use with searching for step ratios.
-- the depth it was found at. Meant for use with searching for step ratios.
function p.depth_search(mediant_data, search_depth)
function p.depth_search(mediant_data, search_depth)
local depth = mediant_data["depth"]
local depth = mediant_data["depth"]
Line 79: Line 137:
table.insert(new_depths, depth_1)
table.insert(new_depths, depth_1)
local mediant_data = { ["mediant"] = mediant, ["depth"] = new_depth }
local mediant_data = { ["mediant"] = mediant, ["depth"] = new_depth, ["ratio_1"] = ratio_1, ["ratio_2"] = ratio_2 }
if search_func(mediant_data, search_args) then
if search_func(mediant_data, search_args) then
table.insert(new_ratios, mediant)
table.insert(new_ratios, mediant)
Line 113: Line 171:
-- it's a common enough operation.
-- it's a common enough operation.


-- Find mediants by depth, how many times mediants are found in a set of ratios.
-- Find mediants by depth of its search tree.
function p.find_mediants(init_ratios, depth)
function p.find_mediants(init_ratios, depth)
local init_ratios = init_ratios or {{1,1}, {1,0}}
local init_ratios = init_ratios or {{1,1}, {1,0}}
Line 124: Line 182:
end
end


-- Find mediants by depth, how many times mediants are found in a set of ratios.
-- Find mediants by depth of its search tree. Does not return depths.
-- Does not return depths.
function p.find_only_mediants(init_ratios, depth)
function p.find_only_mediants(init_ratios, depth)
local init_ratios = init_ratios or {{1,1}, {1,0}}
local init_ratios = init_ratios or {{1,1}, {1,0}}
Line 144: Line 201:
-- alone function under the reasoning that it's a common enough operation.
-- 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)
function p.find_mediants_by_int_limit(init_ratios, int_limit)
local init_ratios = init_ratios or {{1,1}, {1,0}}
local init_ratios = init_ratios or {{1,1}, {1,0}}
Line 154: Line 212:
end
end


-- Find mediants within an int limit. Does not return depth.
function p.find_only_mediants_by_int_limit(init_ratios, int_limit)
function p.find_only_mediants_by_int_limit(init_ratios, int_limit)
local init_ratios = init_ratios or {{1,1}, {1,0}}
local init_ratios = init_ratios or {{1,1}, {1,0}}
Line 169: Line 228:


function p.tester()
function p.tester()
 
--return p.find_only_mediants_by_int_limit()
local ratios = {{4,3}, {5,1}, {3,2}}
return p.find_only_mediants_by_int_limit({{1,1},{3,1}})
p.sort_ratios(ratios)
return p.to_rationals(ratios)
end
end


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