Module:Utils

Module documentation[view] [edit] [history] [purge]

This module provides several mathematical functions which are likely to be used frequently on the Xenharmonic Wiki.

Namely, the functions in this module can be called from other modules by using require("Module:Utils") and calling the underscore-prefixed functions.

Functions

trim(s)

Removes leading and trailing whitespaces (but not interior ones) from a string.

_yesno(frame)

Allows Module:Yesno, which is not invokable directly, to be accessed by templates through Template:Yesno.

table_contains(tbl, x)*

Check if table contains x.

index_of(array, index)*

Return the first index with the given value (or nil if not found).

value_provided(s)*

Checks if s is a non-empty string.

wlink(a, b)

Provides a link to Wikipedia.

eval_num_arg(input, def_value)*

Checks if input is a number; on error, use def_value.

log(x, b)

Returns the logarithm base b of x. Parameter b defaults to base 2 (octave) if it is omitted.

gcd(a, b)

Returns the greatest common divisor of a and b.

round_dec(x, places)

Returns x rounded to a precision of places decimal places. Parameter places defaults to 0 if it is omitted.

round(x, prec)

Returns x rounded to a precision of prec significant figures. Parameter prec defaults to 6 if it is omitted.

is_prime(n)*

Returns true if the given integer n is a prime number.

prime_factorization(n)

Returns the prime factorization of the given integer n using the exponential form (in wikitext).

prime_factorization_raw(n)*

Returns a table encoding the prime factorization of n.

signum(x)*

Returns 1 for positive numbers, −1 for negative ones, and 0 for zero and non-integer inputs.

next_young_diagram(d)

Returns the next Young diagram of the same size; the first one is [N], the last one is . After the last one, nil is returned. The input table is modified.

* These functions are designed to be used by other modules only; they cannot be called with {{#invoke: }}.

---

local getArgs = require('Module:Arguments').getArgs
local p = {}

-- evaluate input on error use default; cannot be used with {{#invoke:}}
function p.eval_num_arg(input, def_value)
	local result = input
	if type(input) ~= 'number' then
		result = def_value
		if type(input) == 'string' then
			local denominator = 1
			input, denominator = input:match("^%s*(.-)[/?](.-)%s*$")
			if string.len(input) > 0 then
				result = tonumber(input/denominator)
			end
		end
	end
	return result
end

-- return logarithm base b of x
function p.log(frame)
	local args = getArgs(frame)
	return p._log(args[1], args[2])
end	

function p._log(x, b)
	-- x defaults to 0
	x = p.eval_num_arg(x, 0)
	-- b defaults to 2 ("octave")
	b = p.eval_num_arg(b, 2)
	return math.log(x)/math.log(b)
end

-- return x rounded to a precision of p decimal places
function p.round(frame)
	local args = getArgs(frame)
	return p._round(args[1], args[2])
end	

function p._round(x, prec)
	-- x defaults to 0
	x = p.eval_num_arg(x, 0)
	-- prec defaults to 3
	prec = p.eval_num_arg(prec, 3)
	return math.floor(x*10^prec+0.5)/10^prec
end

return p