@@ 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 = {}
--- 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.
-function p.find_mediants_by_depth(init_ratios, depth)
+--------------------------------------------------------------------------------
-	local init_ratios = init_ratios or {{1,1}, {1,0}}
+------------------------------ UTILITY FUNCTIONS -------------------------------
-	local depth = depth or 5
+--------------------------------------------------------------------------------
-	local ratios = {}
+-- Given a table of depths, return the deepest depth
-	local depths = {}
+function p.deepest_depth(depths)
-	for i = 1, #init_ratios do
+	local deepest = nil
-		table.insert(ratios, init_ratios[i])
+	for _, value in ipairs(depths) do
-		table.insert(depths, 0)
+		if not deepest or value > deepest then
+			deepest = value
+		end
 	end
-	for i = 1, depth do
+	return deepest
-		local new_ratios = {}
+end
-		local new_depths = {}
+-- Given a ratio, return its simplified form.
-		for j = 1, #ratios - 1 do
+function p.simplify_ratio(ratio)
-			local ratio_1 = ratios[j]
+	local gcd = utils._gcd(ratio[1], ratio[2])
-			local ratio_2 = ratios[j+1]
+	return { ratio[1] / gcd, ratio[2] / gcd }
-			local mediant = { ratio_1[1] + ratio_2[1], ratio_1[2] + ratio_2[2] }
+end
-			table.insert(new_ratios, ratio_1)
-			table.insert(new_ratios, mediant)
+-- Sort ratios in ascending order. Comparison function is built-in.
+function p.sort_ratios(ratios)
-			local depth_1 = depths[j]
+	table.sort(ratios, function(ratio_1, ratio_2)
-			local depth_2 = depths[j+1]
+		return ratio_1[1] / ratio_1[2] < ratio_2[1] / ratio_2[2]
-			table.insert(new_depths, depth_1)
-			table.insert(new_depths, math.max(depth_1, depth_2) + 1)
 		end
-		table.insert(new_ratios, ratios[#ratios])
+	)
-		table.insert(new_depths, depths[#depths])
+end
-		ratios = new_ratios
+--------------------------------------------------------------------------------
-		depths = new_depths
+----------------------------- 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
+-- 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 ratios, depths
+	return rats
 end
--- Filter functions calculate whether a mediant is allowed to be added to the
+--------------------------------------------------------------------------------
--- running set of mediants, and are passed to the find-mediants-by-filter
+------------------------------- SEARCH FUNCTIONS -------------------------------
--- function as a parameter, followed by its arg(s).
+--------------------------------------------------------------------------------
-function p.int_limit_filter(ratio_1, ratio_2, int_limit)
-	local mediant = { ratio_1[1] + ratio_2[1], ratio_1[2] + ratio_2[2] }
+-- Search functions determine whether a mediant meets a specific criteria for
-	local int_max = math.max(mediant[1], mediant[2])
+-- being added to a set of mediants, be it based on something about the mediant,
+-- its search depth, the ratios that produced the mediant, or any combination
+-- thereof.
+-- 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
+-- 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.
-	return int_max <= int_limit
+-- 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
-function p.find_mediants_by_filter(init_ratios, filter, filter_arg)
+-- Depth search determines whether a ratio is within a target depth. Only uses
+-- the depth it was found at. Meant for use with searching for step ratios.
+function p.depth_search(mediant_data, search_depth)
+	local depth = mediant_data["depth"]
+	return depth <= search_depth
+end
+--------------------------------------------------------------------------------
+---------------------------- GENERAL SEARCH FUNCTION ---------------------------
+--------------------------------------------------------------------------------
+-- 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}}
@@ Line 70: / Line 129: @@
 			local ratio_1 = ratios[i]
 			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)
-			if filter(ratio_1, ratio_2, filter_arg) then
+			local depth_1 = depths[i]
-				local mediant = { ratio_1[1] + ratio_2[1], ratio_1[2] + ratio_2[2] }
+			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
@@ Line 87: / Line 153: @@
 end
-function p.tester()
+-- Find mediants by filter, where the filter function and its args are passed in
-	local func = p.int_limit_filter
+-- 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
+end
+--------------------------------------------------------------------------------
+------------------------- 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, depths = p.find_mediants_by_filter({{1,1}, {1,0}}, func, 12)
+	local ratios, depths
-	ratios = p.find_mediants_by_depth({{1,1}, {1,0}}, 6)
+	ratios, depths = p.find_mediants_by_search_func(init_ratios, p.int_limit_search, int_limit)
-	local generators = {}
-	for i = 1, #ratios do
-		local input_mos = mos.new(5,2)
-		local gen = mos.bright_gen_to_cents(input_mos, ratios[i])
-		local gcd = utils._gcd(ratios[i][1], ratios[i][2])
-		local edo = (ratios[i][1] * 5 + ratios[i][2] * 2)/gcd
-		local new_string = string.format("%s:%s\t%sedo\t%.3f", ratios[i][1]/gcd, ratios[i][2]/gcd, edo, gen)
-		table.insert(generators, new_string)
-	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
 return p

Module:Mediants: Difference between revisions