Module:Limits - Revision history

ArrowHead294 at 12:52, 19 May 2025

2025-05-19T12:52:47Z

← Older revision		Revision as of 12:52, 19 May 2025
Line 3:		Line 3:
	local ET = require("Module:ET")		local ET = require("Module:ET")
	local rat = require("Module:Rational")		local rat = require("Module:Rational")
	~~local p = {}~~

	-- returns a table of all positive q-equave-limit ratios if the equave is provided		-- returns a table of all positive q-equave-limit ratios if the equave is provided

ArrowHead294 at 12:52, 19 May 2025

2025-05-19T12:52:36Z

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

			local ET = require("Module:ET")
	local rat = require("Module:Rational")		local rat = require("Module:Rational")
	~~local ET = require("Module:ET")~~
	local p = {}		local p = {}

FloraC: Disable equave reduction when the equave isn't the octave

2025-03-05T14:03:25Z

Disable equave reduction when the equave isn't the octave

← Older revision		Revision as of 14:03, 5 March 2025
Line 3:		Line 3:
	local p = {}		local p = {}

	-- returns a table of all positive ratios n/m with n and m <= q modulo powers of equave		-- returns a table of all positive q-equave-limit ratios if the equave is provided
			-- n/m with n and m <= q modulo powers of equave
			-- otherwise q-integer-limit ratios
	-- previous: already computed ratios for q - 1		-- previous: already computed ratios for q - 1
	function p.limit_modulo_equave(q, equave, previous)		function p.limit_modulo_equave(q, equave, previous)
	~~equave = equave or 2~~
	local ratios = {}		local ratios = {}
	if previous then		if previous then
	for n = 1, q do		for n = 1, q do
	local a = rat.new(n, q)		local a = rat.new(n, q)
	a = rat.modulo_mul(a, equave)		local b = rat.new(q, n)
			if equave then
			a = rat.modulo_mul(a, equave)
			b = rat.modulo_mul(b, equave)
			end
	local a_key = rat.as_ratio(a)		local a_key = rat.as_ratio(a)

	~~local b = rat.new(q, n)~~
	~~b = rat.modulo_mul(b, equave)~~
	local b_key = rat.as_ratio(b)		local b_key = rat.as_ratio(b)

Line 29:		Line 31:
	for m = 1, q do		for m = 1, q do
	local a = rat.new(n, m)		local a = rat.new(n, m)
	a = rat.modulo_mul(a, equave)		if equave then
			a = rat.modulo_mul(a, equave)
			end
	local key = rat.as_ratio(a)		local key = rat.as_ratio(a)
	ratios[key] = a		ratios[key] = a
Line 55:		Line 59:
	end		end

	-- check additive consistency for a set of ratios ~~(modulo powers of equave)~~		-- check additive consistency for a set of ratios of an equal tuning
	-- of an equal tuning:		-- approx(ab) = approx(a) + approx(b) for all a, b: a, b, ab in ratios
	-- approx(a*b) = approx(a) + approx(b) for all a, b: a, b, ab in ratios		-- `use_equave`: whether check consistency modulo powers of the tuning's formal equave
			-- - we don't allow arbitrary equaves here
			-- - since consistency only makes sense if the equave is pure
	-- `distinct`: whether distinct ratios are required to be mapped to distinct approximations		-- `distinct`: whether distinct ratios are required to be mapped to distinct approximations
	-- `previous`: already computed ratios for the previous iteraton		-- `previous`: already computed ratios for the previous iteraton
	function p.additively_consistent(et, ratios, distinct, previous)		function p.additively_consistent(et, ratios, use_equave, distinct, previous)
	distinct = distinct or false		distinct = distinct or false
	previous = previous or {}		previous = previous or {}

			-- distinction check
			-- approx_set stores ratios and their directly approximated number of steps as keys
			-- we find the number of steps for every ratio and check if this number is taken
			-- if it's taken, we compare the ratio in question with the stored one
			-- if they're unequal, it means different ratios are mapped to the same step
			-- therefore distinction isn't satisfied
			-- otherwise, we add the ratio and step number to approx_set
			-- we do this to previous and new ratios alike
	if distinct then		if distinct then
	local approx_set = {}		local approx_set = {}
	for a_key, a in pairs(previous) do		for a_key, a in pairs(previous) do
	local a_approx = ET.approximate(et, rat.as_float(a)) % et.size		local a_approx = use_equave and ET.approximate(et, rat.as_float(a)) % et.size
			or ET.approximate(et, rat.as_float(a))
	if approx_set[a_approx] then		if approx_set[a_approx] then
	if not rat.eq(rat.modulo_mul(rat.div(a, approx_set[a_approx]), et.equave), 1) then		if use_equave and not rat.eq(rat.modulo_mul(rat.div(a, approx_set[a_approx]), et.equave), 1)
			or not rat.eq(a, approx_set[a_approx]) then
	mw.log(a_key .. " -> " .. a_approx .. ": conflict!")		mw.log(a_key .. " -> " .. a_approx .. ": conflict!")
	return false		return false
Line 77:		Line 94:
	end		end
	for a_key, a in pairs(ratios) do		for a_key, a in pairs(ratios) do
	local a_approx = ET.approximate(et, rat.as_float(a)) % et.size		local a_approx = use_equave and ET.approximate(et, rat.as_float(a)) % et.size
			or ET.approximate(et, rat.as_float(a))
	if approx_set[a_approx] then		if approx_set[a_approx] then
	if not rat.eq(rat.modulo_mul(rat.div(a, approx_set[a_approx]), et.equave), 1) then		if use_equave and not rat.eq(rat.modulo_mul(rat.div(a, approx_set[a_approx]), et.equave), 1)
			or not rat.eq(a, approx_set[a_approx]) then
	mw.log(a_key .. " -> " .. a_approx .. ": conflict!")		mw.log(a_key .. " -> " .. a_approx .. ": conflict!")
	return false		return false
Line 110:		Line 129:
	local c_approx = ET.approximate(et, rat.as_float(c))		local c_approx = ET.approximate(et, rat.as_float(c))

	c = rat.modulo_mul(c, et.equave)		if use_equave then
			c = rat.modulo_mul(c, et.equave)
			end
	local c_key = rat.as_ratio(c)		local c_key = rat.as_ratio(c)
	if previous[c_key] or ratios[c_key] then		if previous[c_key] or ratios[c_key] then
Line 126:		Line 147:
	local c = rat.mul(a, b)		local c = rat.mul(a, b)
	local c_approx = ET.approximate(et, rat.as_float(c))		local c_approx = ET.approximate(et, rat.as_float(c))

	c = rat.modulo_mul(c, et.equave)		if use_equave then
			c = rat.modulo_mul(c, et.equave)
			end
	local c_key = rat.as_ratio(c)		local c_key = rat.as_ratio(c)
	if previous[c_key] or ratios[c_key] then		if previous[c_key] or ratios[c_key] then
Line 157:		Line 180:
	end		end

			-- use the equave iff the tuning is an edo
			local use_equave = rat.eq (et.equave, rat.new (2, 1))
	max_n = max_n or 1 / 0		max_n = max_n or 1 / 0
	distinct = distinct or false		distinct = distinct or false
Line 166:		Line 191:
	return last_n		return last_n
	end		end
	local ratios = p.limit_modulo_equave(n, et.equave, previous)		local ratios = p.limit_modulo_equave(n, use_equave and et.equave or nil, previous)
	for key, _ in pairs(ratios) do		for key, _ in pairs(ratios) do
	mw.log("step " .. n .. ": " .. key)		mw.log("step " .. n .. ": " .. key)
	end		end
	if next(ratios) ~= nil then		if next(ratios) ~= nil then
	local consistent = p.additively_consistent(et, ratios, distinct, previous)		local consistent = p.additively_consistent(et, ratios, use_equave, distinct, previous)
	if not consistent then		if not consistent then
	mw.log("Not consistent at step " .. n .. ", returning " .. last_n)		mw.log("Not consistent at step " .. n .. ", returning " .. last_n)

FloraC: Improve documentation and request answers

2025-03-05T10:44:59Z

Improve documentation and request answers

← Older revision		Revision as of 10:44, 5 March 2025
Line 3:		Line 3:
	local p = {}		local p = {}

	-- ~~compute~~ all positive ratios n/m with n and m <= q modulo powers of equave		-- returns a table of all positive ratios n/m with n and m <= q modulo powers of equave
	-- previous: already computed ratios for q - 1		-- previous: already computed ratios for q - 1
	function p.limit_modulo_equave(q, equave, previous)		function p.limit_modulo_equave(q, equave, previous)
Line 38:		Line 38:
	end		end

	-- ~~compute~~ q-integer-limit		-- returns a table of all q-integer-limit ratios
	-- if a function `norm` and a number `max_norm` are provided, the output will be additionally restricted		-- if a function `norm` and a number `max_norm` are provided, the output will be additionally restricted
	function p.integer_limit(q, norm, max_norm)		function p.integer_limit(q, norm, max_norm)
Line 55:		Line 55:
	end		end

	-- check additive consistency for a set of ratios (modulo powers of equave):		-- check additive consistency for a set of ratios (modulo powers of equave)
			-- of an equal tuning:
	-- approx(a*b) = approx(a) + approx(b) for all a, b: a, b, ab in ratios		-- approx(a*b) = approx(a) + approx(b) for all a, b: a, b, ab in ratios
	-- `distinct`: whether distinct ratios are required to be mapped to distinct approximations		-- `distinct`: whether distinct ratios are required to be mapped to distinct approximations
Line 87:		Line 88:
	end		end
	end		end

			-- ???
	if type(distinct) == "number" then		if type(distinct) == "number" then
	return true		return true
	end		end

	local previous_ordered = {}		local previous_ordered = {}
	for _, a in pairs(previous) do		for _, a in pairs(previous) do
Line 138:		Line 142:
	end		end

	-- find additive consistency limit		-- find additive consistency limit of an equal tuning
	~~-- returns nil when at least `max_n`~~
	-- `distinct`: whether distinct ratios are required to be mapped to distinct approximations		-- `distinct`: whether distinct ratios are required to be mapped to distinct approximations
	-- - if an integer, it is the regular consistency limit already known		-- - if an integer, it is the regular consistency limit already known (why?)
			-- `max_n`: returns nil if the result is equal to or greater than this
	function p.consistency_limit(et, distinct, max_n)		function p.consistency_limit(et, distinct, max_n)

FloraC: Distinct consistency of 0edo should be 1

2024-12-18T08:48:53Z

Distinct consistency of 0edo should be 1

← Older revision		Revision as of 08:48, 18 December 2024
Line 4:		Line 4:

	-- compute all positive ratios n/m with n and m <= q modulo powers of equave		-- compute all positive ratios n/m with n and m <= q modulo powers of equave
	-- previous: already computed ratios for q-1		-- previous: already computed ratios for q - 1
	function p.limit_modulo_equave(q, equave, previous)		function p.limit_modulo_equave(q, equave, previous)
	equave = equave or 2		equave = equave or 2
Line 38:		Line 38:
	end		end

	-- compute q-integer limit		-- compute q-integer-limit
	-- if a function `norm` and a number `max_norm` are provided, the output will be additionally restricted		-- if a function `norm` and a number `max_norm` are provided, the output will be additionally restricted
	function p.integer_limit(q, norm, max_norm)		function p.integer_limit(q, norm, max_norm)
Line 56:		Line 56:

	-- check additive consistency for a set of ratios (modulo powers of equave):		-- check additive consistency for a set of ratios (modulo powers of equave):
	-- approx(a*b) = approx(a) + approx(b) ~~forall~~ a, b: a, b, ab in ratios		-- approx(a*b) = approx(a) + approx(b) for all a, b: a, b, ab in ratios
	-- `distinct`: whether distinct ratios are required to be mapped to distinct approximations		-- `distinct`: whether distinct ratios are required to be mapped to distinct approximations
	-- `previous`: already computed ratios for the previous iteraton		-- `previous`: already computed ratios for the previous iteraton
Line 143:		Line 143:
	-- - if an integer, it is the regular consistency limit already known		-- - if an integer, it is the regular consistency limit already known
	function p.consistency_limit(et, distinct, max_n)		function p.consistency_limit(et, distinct, max_n)

			-- 0edo, the answer is known already
	if et.size == 0 then		if et.size == 0 then
	~~-- the answer is known already~~		if distinct then
	return "∞"		return "1"
			else
			return "∞"
			end
	end		end

	max_n = max_n or 1 / 0		max_n = max_n or 1 / 0
	distinct = distinct or false		distinct = distinct or false

Sintel: merge changes from dev

2024-04-01T20:18:26Z

merge changes from dev

Show changes

Plumtree: Distinct consistency limit: bugfix

2022-10-13T15:06:44Z

Distinct consistency limit: bugfix

← Older revision		Revision as of 15:06, 13 October 2022
Line 67:		Line 67:
	local a_approx = ET.approximate(et, rat.as_float(a)) % et.size		local a_approx = ET.approximate(et, rat.as_float(a)) % et.size
	if approx_set[a_approx] then		if approx_set[a_approx] then
	return false		if not rat.eq(rat.modulo_mul(rat.div(a, approx_set[a_approx]), et.equave), 1) then
			mw.log(a_key .. ' -> ' .. a_approx .. ': conflict!')
			return false
			end
	end		end
	approx_set[a_approx] = ~~true~~		approx_set[a_approx] = a
			mw.log(a_key .. ' -> ' .. a_approx)
	end		end
	for a_key, a in pairs(ratios) do		for a_key, a in pairs(ratios) do
	local a_approx = ET.approximate(et, rat.as_float(a)) % et.size		local a_approx = ET.approximate(et, rat.as_float(a)) % et.size
	if approx_set[a_approx] then		if approx_set[a_approx] then
	return false		if not rat.eq(rat.modulo_mul(rat.div(a, approx_set[a_approx]), et.equave), 1) then
			mw.log(a_key .. ' -> ' .. a_approx .. ': conflict!')
			return false
			end
	end		end
	approx_set[a_approx] = ~~true~~		approx_set[a_approx] = a
			mw.log(a_key .. ' -> ' .. a_approx)
	end		end
	end		end
Line 155:		Line 163:
	local consistent = p.additively_consistent(et, ratios, distinct, previous)		local consistent = p.additively_consistent(et, ratios, distinct, previous)
	if not consistent then		if not consistent then
			mw.log('Not consistent at step ' .. n .. ', returning ' .. last_n)
	return last_n		return last_n
	end		end

Plumtree: integer_limit() implemented

2022-10-10T14:10:40Z

integer_limit() implemented

@@ Line 30: / Line 30: @@
 				local a = rat.new(n, m)
 				a = rat.modulo_mul(a, equave)
 				local key = rat.as_ratio(a)
 				ratios[key] = a

Plumtree: Distinct consistency limit optimisation

2022-10-05T21:44:34Z

Distinct consistency limit optimisation

← Older revision		Revision as of 21:44, 5 October 2022
Line 61:		Line 61:
	approx_set[a_approx] = true		approx_set[a_approx] = true
	end		end
			end
			if type(distinct) == 'number' then
			return true
	end		end
	local previous_ordered = {}		local previous_ordered = {}
Line 113:		Line 116:
	-- returns nil when at least `max_n`		-- returns nil when at least `max_n`
	-- `distinct`: whether distinct ratios are required to be mapped to distinct approximations		-- `distinct`: whether distinct ratios are required to be mapped to distinct approximations
			-- - if an integer, it is the regular consistency limit already known
	function p.consistency_limit(et, distinct, max_n)		function p.consistency_limit(et, distinct, max_n)
	if et.size == 0 then		if et.size == 0 then
Line 124:		Line 128:
	local previous = {}		local previous = {}
	while true do		while true do
			if type(distinct) == 'number' and n > distinct then
			return last_n
			end
	local ratios = p.limit_modulo_equave(n, et.equave, previous)		local ratios = p.limit_modulo_equave(n, et.equave, previous)
	for key, ratio in pairs(ratios) do		for key, ratio in pairs(ratios) do

Plumtree: Refactoring

2022-10-03T19:33:04Z

Refactoring

← Older revision		Revision as of 19:33, 3 October 2022
Line 1:		Line 1:
	local rat = require('Module:Rational')		local rat = require('Module:Rational')
			local ET = require('Module:ET')
	local p = {}		local p = {}

Line 41:		Line 42:
	-- `distinct`: whether distinct ratios are required to be mapped to distinct approximations		-- `distinct`: whether distinct ratios are required to be mapped to distinct approximations
	-- `previous`: already computed ratios for the previous iteraton		-- `previous`: already computed ratios for the previous iteraton
	function p.additively_consistent(~~equave, size~~, ratios, distinct, previous)		function p.additively_consistent(et, ratios, distinct, previous)
	distinct = distinct or false		distinct = distinct or false
	previous = previous or {}		previous = previous or {}
	~~local function approximate(a)~~
	~~return math.floor(size * math.log(rat.as_float(a)) / math.log(rat.as_float(equave)) + 0.5)~~
	~~end~~
	if distinct then		if distinct then
	local approx_set = {}		local approx_set = {}
	for a_key, a in pairs(previous) do		for a_key, a in pairs(previous) do
	local a_approx = approximate(a) % size		local a_approx = ET.approximate(et, rat.as_float(a)) % et.size
	if approx_set[a_approx] then		if approx_set[a_approx] then
	return false		return false
Line 57:		Line 55:
	end		end
	for a_key, a in pairs(ratios) do		for a_key, a in pairs(ratios) do
	local a_approx = approximate(a) % size		local a_approx = ET.approximate(et, rat.as_float(a)) % et.size
	if approx_set[a_approx] then		if approx_set[a_approx] then
	return false		return false
Line 73:		Line 71:
	end		end
	for i, a in ipairs(ratios_ordered) do		for i, a in ipairs(ratios_ordered) do
	local a_approx = approximate(a)		local a_approx = ET.approximate(et, rat.as_float(a))
	for j, b in ipairs(previous_ordered) do		for j, b in ipairs(previous_ordered) do
	local b_approx = approximate(b)		local b_approx = ET.approximate(et, rat.as_float(b))

	local c = rat.mul(a, b)		local c = rat.mul(a, b)
	local c_approx = approximate(c)		local c_approx = ET.approximate(et, rat.as_float(c))

	c = rat.modulo_mul(c, equave)		c = rat.modulo_mul(c, et.equave)
	local c_key = rat.as_ratio(c)		local c_key = rat.as_ratio(c)
	if previous[c_key] or ratios[c_key] then		if previous[c_key] or ratios[c_key] then
Line 92:		Line 90:
	for j, b in ipairs(ratios_ordered) do		for j, b in ipairs(ratios_ordered) do
	if i <= j then		if i <= j then
	local b_approx = approximate(b)		local b_approx = ET.approximate(et, rat.as_float(b))

	local c = rat.mul(a, b)		local c = rat.mul(a, b)
	local c_approx = approximate(c)		local c_approx = ET.approximate(et, rat.as_float(c))

	c = rat.modulo_mul(c, equave)		c = rat.modulo_mul(c, et.equave)
	local c_key = rat.as_ratio(c)		local c_key = rat.as_ratio(c)
	if previous[c_key] or ratios[c_key] then		if previous[c_key] or ratios[c_key] then
Line 115:		Line 113:
	-- returns nil when at least `max_n`		-- returns nil when at least `max_n`
	-- `distinct`: whether distinct ratios are required to be mapped to distinct approximations		-- `distinct`: whether distinct ratios are required to be mapped to distinct approximations
	function p.consistency_limit(~~size, equave~~, distinct, max_n)		function p.consistency_limit(et, distinct, max_n)
	if size == 0 then		if et.size == 0 then
	-- the answer is known already		-- the answer is known already
	return '∞'		return '∞'
	end		end
	max_n = max_n or 1/0		max_n = max_n or 1/0
	~~equave = equave or 2~~
	distinct = distinct or false		distinct = distinct or false
	local n = 1		local n = 1
Line 127:		Line 124:
	local previous = {}		local previous = {}
	while true do		while true do
	local ratios = p.limit_modulo_equave(n, equave, previous)		local ratios = p.limit_modulo_equave(n, et.equave, previous)
	for key, ratio in pairs(ratios) do		for key, ratio in pairs(ratios) do
	mw.log('step ' .. n .. ': ' .. key)		mw.log('step ' .. n .. ': ' .. key)
	end		end
	if next(ratios) ~= nil then		if next(ratios) ~= nil then
	local consistent = p.additively_consistent(~~equave, size~~, ratios, distinct, previous)		local consistent = p.additively_consistent(et, ratios, distinct, previous)
	if not consistent then		if not consistent then
	return last_n		return last_n