Module:Utils: Difference between revisions
In prime_factorization: evaluate the input at the public level |
merge changes from dev |
||
| Line 1: | Line 1: | ||
local | local get_args = require("Module:Arguments").getArgs | ||
local p = {} | local p = {} | ||
-- check if a table contains x | -- check if a table contains x | ||
function p.table_contains(tbl, x) | function p.table_contains(tbl, x) | ||
for i = 1, #tbl do | |||
if x == tbl[i] then | |||
return true | |||
end | |||
end | |||
return false | |||
end | end | ||
| Line 25: | Line 25: | ||
function p.eval_num_arg(input, def_value) | function p.eval_num_arg(input, def_value) | ||
local result = input | local result = input | ||
if type(input) ~= | if type(input) ~= "number" then | ||
result = def_value | result = def_value | ||
if type(input) == | if type(input) == "string" then | ||
-- check for fraction notation | -- check for fraction notation | ||
if input:match( | if input:match("/") == "/" then | ||
local | local numerator, denominator = input:match("^%s*([0-9]+)[/?]([0-9]+)%s*$") | ||
result = (tonumber(numerator) or def_value) / (tonumber(denominator) or 1) | |||
result = (tonumber( | |||
else | else | ||
input = input:match("^%s*(.-)%s*$") | input = input:match("^%s*(.-)%s*$") | ||
| Line 44: | Line 43: | ||
-- return logarithm base b of x | -- return logarithm base b of x | ||
function p.log(frame) | function p.log(frame) | ||
local args = | local args = get_args(frame) | ||
return p._log(args[1], args[2]) | return p._log(args[1], args[2]) | ||
end | end | ||
local LN_2 = math.log(2) | |||
-- return logarithm base 2 of x | |||
function p.log2(x) | |||
return math.log(x) / LN_2 | |||
end | |||
function p._log(x, b) | function p._log(x, b) | ||
| Line 53: | Line 58: | ||
-- b defaults to 2 ("octave") | -- b defaults to 2 ("octave") | ||
b = p.eval_num_arg(b, 2) | b = p.eval_num_arg(b, 2) | ||
return math.log(x)/math.log(b) | return math.log(x) / math.log(b) | ||
end | end | ||
-- return greatest common divisor of a and b | -- return greatest common divisor of a and b | ||
function p.gcd(frame) | function p.gcd(frame) | ||
local args = | local args = get_args(frame) | ||
return p._gcd(args[1], args[2]) | return p._gcd(args[1], args[2]) | ||
end | end | ||
| Line 66: | Line 71: | ||
return p._gcd(b, a % b) | return p._gcd(b, a % b) | ||
else | else | ||
return math.abs (a) | return math.abs(a) | ||
end | end | ||
end | end | ||
| Line 72: | Line 77: | ||
-- return x rounded to places decimal places | -- return x rounded to places decimal places | ||
function p.round_dec(frame) | function p.round_dec(frame) | ||
local args = | local args = get_args(frame) | ||
return p._round_dec(args[1], args[2]) | return p._round_dec(args[1], args[2]) | ||
end | end | ||
| Line 81: | Line 86: | ||
-- places defaults to 0 | -- places defaults to 0 | ||
places = p.eval_num_arg(places, 0) | places = p.eval_num_arg(places, 0) | ||
return math.floor (x * 10^places + 0.5)/10^places | return math.floor(x * 10 ^ places + 0.5) / 10 ^ places | ||
end | end | ||
-- return x rounded to a precision of prec significant figures | -- return x rounded to a precision of prec significant figures | ||
function p.round(frame) | function p.round(frame) | ||
local args = | local args = get_args(frame) | ||
return p._round(args[1], args[2]) | return p._round(args[1], args[2]) | ||
end | end | ||
function p._round(x, prec) | function p._round(x, prec) | ||
| Line 103: | Line 108: | ||
-- cached list of primes for is_prime | -- cached list of primes for is_prime | ||
local | local primes_cache = { | ||
[0] = false, | [0] = false, | ||
[1] = false | [1] = false, | ||
} | } | ||
-- returns true if integer n is prime; cannot be used with {{#invoke:}} | -- returns true if integer n is prime; cannot be used with {{#invoke:}} | ||
function p.is_prime(n) | function p.is_prime(n) | ||
local cached = | local cached = primes_cache[n] | ||
if cached ~= nil then | if cached ~= nil then | ||
return cached | return cached | ||
| Line 116: | Line 121: | ||
for i = 2, math.sqrt(n) do | for i = 2, math.sqrt(n) do | ||
if n % i == 0 then | if n % i == 0 then | ||
primes_cache[n] = false | |||
return false | return false | ||
end | end | ||
end | end | ||
primes_cache[n] = true | |||
return true | return true | ||
end | end | ||
| Line 147: | Line 152: | ||
-- returns prime factorization of integer n > 2 (with wiki markup for exponents) | -- returns prime factorization of integer n > 2 (with wiki markup for exponents) | ||
function p.prime_factorization(frame) | function p.prime_factorization(frame) | ||
local args = | local args = get_args(frame) | ||
return p._prime_factorization(p.eval_num_arg(args[1], 12)) -- default to 12 | return p._prime_factorization(p.eval_num_arg(args[1], 12)) -- default to 12 | ||
end | end | ||
| Line 162: | Line 167: | ||
factors[#factors + 1] = i | factors[#factors + 1] = i | ||
powers[#factors] = 0 | powers[#factors] = 0 | ||
while new_number % i == 0 do | while new_number % i == 0 do | ||
powers[#factors] = powers[#factors] + 1 | powers[#factors] = powers[#factors] + 1 | ||
new_number = new_number / i | new_number = new_number / i | ||
| Line 182: | Line 187: | ||
-- returns signum(x); cannot be used with {{#invoke:}} | -- returns signum(x); cannot be used with {{#invoke:}} | ||
function p.signum(x) | function p.signum(x) | ||
if type(x) ~= | if type(x) ~= "number" then | ||
return 0 | return 0 | ||
end | end | ||
if x > 0 then return 1 end | if x > 0 then | ||
if x < 0 then return -1 end | return 1 | ||
end | |||
if x < 0 then | |||
return -1 | |||
end | |||
return 0 | return 0 | ||
end | end | ||
| Line 225: | Line 234: | ||
return d | return d | ||
end | end | ||
-- stylua: ignore | |||
p.primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, | |||
101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, | |||
211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271} | |||
-- get monzo of n/d | -- get monzo of n/d | ||
-- e.g. for 3/2: {[2] = -1, [3] = 1} | -- e.g. for 3/2: {[2] = -1, [3] = 1} | ||
function p.get_monzo(n, d) | function p.get_monzo(n, d) | ||
local n_pf = p.prime_factorization_raw(n) | local n_pf = p.prime_factorization_raw(n) | ||
local d_pf = p.prime_factorization_raw(d) | local d_pf = p.prime_factorization_raw(d) | ||
local result = {} | local result = {} | ||
for i=1,#primes do | for i = 1, #p.primes do | ||
local t = (n_pf[primes[i]] or 0) - (d_pf[primes[i]] or 0) | local t = (n_pf[p.primes[i]] or 0) - (d_pf[p.primes[i]] or 0) | ||
if t ~= 0 then | if t ~= 0 then | ||
result[primes[i]] = t | result[p.primes[i]] = t | ||
end | end | ||
end | end | ||