Module:Mediants - Revision history

Ganaram inukshuk: update code to be documentation

2025-10-24T07:23:30Z

update code to be documentation

← Older revision		Revision as of 07:23, 24 October 2025
Line 1:		Line 1:
			-- This module follows [[User:Ganaram inukshuk/Provisional style guide for Lua]]
	local rat = require("Module:Rational")		local rat = require("Module:Rational")
	local utils = require("Module:Utils")		local utils = require("Module:Utils")

	local p = {}		local p = {}

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

	--------------------------------------------------------------------------------		--------------------------------------------------------------------------------
Line 32:		Line 40:
	)		)
	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		-- Given a single ratio, as a table of two numbers, convert to rational and

Ganaram inukshuk: add sort function and convert-to-rational functions

2025-10-05T02:05:44Z

add sort function and convert-to-rational functions

← Older revision		Revision as of 02:05, 5 October 2025
Line 1:		Line 1:
			local rat = require("Module:Rational")
	local utils = require("Module:Utils")		local utils = require("Module:Utils")
	local p = {}		local p = {}

	~~-- TODO:~~
	~~-- - Add a convert-to-rational function.~~
	~~-- - Add sort function~~

	--------------------------------------------------------------------------------		--------------------------------------------------------------------------------
Line 22:		Line 19:
	end		end

	-- Given a ratio, return its simplified form		-- Given a ratio, return its simplified form.
	function p.simplify_ratio(ratio)		function p.simplify_ratio(ratio)
	local gcd = utils._gcd(ratio[1], ratio[2])		local gcd = utils._gcd(ratio[1], ratio[2])
Line 28:		Line 25:
	end		end

	-- Sort ratios in ascending order (~~TODO~~)		-- 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

	-- ~~Comparison~~ function for ~~use with Lua's sort function~~ (~~TODO~~)		-- 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 rats
			end

	--------------------------------------------------------------------------------		--------------------------------------------------------------------------------
Line 196:		Line 213:

	function p.tester()		function p.tester()
	return p.find_only_mediants_by_int_limit()		--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

Ganaram inukshuk: todo

2025-10-04T21:10:39Z

todo

← Older revision		Revision as of 21:10, 4 October 2025
Line 4:		Line 4:
	-- TODO:		-- TODO:
	-- - Add a convert-to-rational function.		-- - Add a convert-to-rational function.
			-- - Add sort function

	--------------------------------------------------------------------------------		--------------------------------------------------------------------------------
Line 26:		Line 27:
	return { ratio[1] / gcd, ratio[2] / gcd }		return { ratio[1] / gcd, ratio[2] / gcd }
	end		end

			-- Sort ratios in ascending order (TODO)

			-- Comparison function for use with Lua's sort function (TODO)

	--------------------------------------------------------------------------------		--------------------------------------------------------------------------------

Ganaram inukshuk: add simplify function

2025-10-04T20:52:48Z

add simplify function

← Older revision		Revision as of 20:52, 4 October 2025
Line 1:		Line 1:
			local utils = require("Module:Utils")
	local p = {}		local p = {}

Line 18:		Line 19:

	return deepest		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		end

Ganaram inukshuk: Add deepest_depth function

2025-10-04T06:39:17Z

Add deepest_depth function

@@ Line 2: / Line 2: @@
 -- TODO:
 -- - Add a convert-to-rational function.
 --------------------------------------------------------------------------------

Ganaram inukshuk: todo

2025-10-03T09:36:43Z

todo

← Older revision		Revision as of 09:36, 3 October 2025
Line 2:		Line 2:

	-- TODO:		-- TODO:
	-- Add a convert-to-rational function.		-- - Redefine mediant-search functions to return the deepest depth. Meant for
			-- use with making tables. (Instead of ratios and depths, it's ratios, depths,
			-- and deepest_depth.) Existing function calls will work the same as before,
			-- and modules making a table can use this accordingly. ALT IMPLEMENTATION:
			-- a helper function that returns the deepest depth, when a table of depths is
			-- passed in.
			-- - Add a convert-to-rational function.

	--------------------------------------------------------------------------------		--------------------------------------------------------------------------------

ArrowHead294 at 12:59, 19 May 2025

2025-05-19T12:59:24Z

← Older revision		Revision as of 12:59, 19 May 2025
Line 1:		Line 1:
	local p = {}		local p = {}

	~~-- Module for finding mediants, either by search depth, int limit, or by a~~
	~~-- custom search function. Note that ratios produced by this module are NOT the~~
	~~-- same as that defined by Module:Rational and will require conversion to that~~
	~~-- form. This is because some situations, such as with step ratios, don't need~~
	~~-- the factorization process that Module:Rational uses.~~

	-- TODO:		-- TODO:

Ganaram inukshuk: Cleanup

2024-09-18T08:43:42Z

Cleanup

← Older revision		Revision as of 08:43, 18 September 2024
Line 1:		Line 1:
	~~local mos = require("Module:MOS") -- For testing~~
	~~local utils = require("Module:Utils") -- For testing~~
	local p = {}		local p = {}

Line 176:		Line 174:

	function p.tester()		function p.tester()
			return p.find_only_mediants_by_int_limit()

	return p.find_only_mediants_by_int_limit(~~{{1,1},{3,1}}~~)
	end		end

	return p		return p

Ganaram inukshuk: Comments, todo

2024-09-18T08:01:28Z

Comments, todo

← Older revision		Revision as of 08:01, 18 September 2024
Line 4:		Line 4:

	-- Module for finding mediants, either by search depth, int limit, or by a		-- Module for finding mediants, either by search depth, int limit, or by a
	-- custom search function.		-- custom search function. Note that ratios produced by this module are NOT the
			-- same as that defined by Module:Rational and will require conversion to that
			-- form. This is because some situations, such as with step ratios, don't need
			-- the factorization process that Module:Rational uses.

			-- TODO:
			-- Add a convert-to-rational function.

	--------------------------------------------------------------------------------		--------------------------------------------------------------------------------

Ganaram inukshuk: Updated todo

2024-09-17T08:42:30Z

Updated todo

← Older revision		Revision as of 08:42, 17 September 2024
Line 3:		Line 3:
	local p = {}		local p = {}

	-- Module for finding mediants, either by search depth or by ~~search function.~~		-- Module for finding mediants, either by search depth, int limit, or by a
			-- custom search function.
	-- ~~TODO: Add int-limit~~ search

	--------------------------------------------------------------------------------		--------------------------------------------------------------------------------
Line 13:		Line 12:
	-- 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 27:		Line 27:
	-- 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 34:
	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 113:		Line 113:
	-- 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 124:
	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 143:
	-- 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 154:
	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}}