Module:Utils

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

This module primarily serves as a library for other modules and has no corresponding template.

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

For pairs of functions with names that differ by a single leading underscore (for example, gcd and _gcd), the function with an underscore is meant to be called by other modules, and the function without an underscore can be used with #invoke.

Introspection summary for Module:Utils
Functions provided (8) Line Function Params 5 eval_num_arg (input, def_value) 25 log (invokable) (frame) 30 _log (x, b) 39 round (invokable) (frame) 44 _round (x, prec) 56 is_prime (n) 72 prime_factorization (invokable) (frame) 77 _prime_factorization (n)	Lua modules required (1) Variable Module Functions used getArgs Module:Arguments getArgs

No function descriptions were provided. The Lua code may have further information.

Functions

trim(s)

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

_yesno(frame)

Wrapper function for Module: Yesno, for use with templates. (Module: Yesno does not have a corresponding template.)

_clamp(value, min_value, max_value)

Returns value such that it is between min_value and max_value.

table_contains(tbl, value, compare_func) *

Checks whether table tbl contains value and returns true (if found) or false if not found. Passing compare_func is optional; By default, value is a numeric value or a string; to check for other values, such as ratios defined by Module: Rational, a comparison function compare_func must be passed in.

index_of(array, value, compare_func) *

Returns the first index with the given value (or nil if not found). Passing compare_func is optional. By default, value is a numeric value or a string; to check for other values, such as ratios defined by Module:Rational, a comparison function compare_func must be passed in.

value_provided(s) *

Checks whether s is a non-empty string.

eval_num_arg(input, def_value) *

Evaluates input as a number, fraction notation supported but not other expressions; uses def_value on error.

log(x, b)

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

log2(x)

Returns the base-2 logarithm of x.

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 [1, 1, …, 1]. 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
			-- check for fraction notation
			if input:match('/') == '/' then
				local denominator = 1
				input, denominator = input:match("^%s*(.-)[/?](.-)%s*$")
				result = tonumber(input)/tonumber(denominator)
			else
				input = input:match("^%s*(.-)%s*$")
				result = tonumber(input)
			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 prec significant figures
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 6
	prec = p.eval_num_arg(prec, 6)
	return string.format(string.format("%%.%dg", prec), x)
end

-- cached list of primes for is_prime
local primes = {}

-- returns true if integer n is prime; cannot be used with {{#invoke:}}
function p.is_prime(n)
  local cached = primes[n]
  if cached ~= nil then
    return cached
  end
  for i = 2, math.sqrt(n) do
    if n % i == 0 then
      primes[n] = false
      return false
    end
  end
  primes[n] = true
  return true 
end

-- returns prime factorisation of integer n > 2 (with wiki markup for exponents)
function p.prime_factorization(frame)
	local args = getArgs(frame)
	return p._prime_factorization(args[1])
end

function p._prime_factorization(n)
  local factors, powers = {}, {}
  local new_number = n
  for i = 2, n do
    if p.is_prime(i) then
      if new_number % i == 0 then
        factors[#factors + 1] = i
        powers[#factors] = 0
      end
      while new_number % i == 0 do 
        powers[#factors] = powers[#factors] + 1
        new_number = new_number / i
      end
      powers[#factors] = factors[#factors] .. "<sup>" .. powers[#factors] .. "</sup>"
    end
    if new_number == 1 then
      break
    end
  end
  return table.concat(powers, " × ")
end

return p