Module:Math

--[[This module provides a number of basic mathematical operations.]]local yesno, getArgs -- lazily initializedlocal p = {} -- Holds functions to be returned from #invoke, and functions to make available to other Lua modules.local wrap = {} -- Holds wrapper functions that process arguments from #invoke. These act as intemediary between functions meant for #invoke and functions meant for Lua.--[[Helper functions used to avoid redundant code.]]local function err(msg)-- Generates wikitext error messages.return mw.ustring.format('<strong class="error">Formatting error: %s</strong>', msg)endlocal function unpackNumberArgs(args)-- Returns an unpacked list of arguments specified with numerical keys.local ret = {}for k, v in pairs(args) doif type(k) == 'number' thentable.insert(ret, v)endendreturn unpack(ret)endlocal function makeArgArray(...)-- Makes an array of arguments from a list of arguments that might include nils.local args = {...} -- Table of arguments. It might contain nils or non-number values, so we can't use ipairs.local nums = {} -- Stores the numbers of valid numerical arguments.local ret = {}for k, v in pairs(args) dov = p._cleanNumber(v)if v thennums[#nums + 1] = kargs[k] = vendendtable.sort(nums)for i, num in ipairs(nums) doret[#ret + 1] = args[num]endreturn retendlocal function applyFuncToArgs(func, ...)-- Use a function on all supplied arguments, and return the result. The function must accept two numbers as parameters,-- and must return a number as an output. This number is then supplied as input to the next function call.local vals = makeArgArray(...)local count = #vals -- The number of valid argumentsif count == 0 then return-- Exit if we have no valid args, otherwise removing the first arg would cause an error.nil, 0end local ret = table.remove(vals, 1)for _, val in ipairs(vals) doret = func(ret, val)endreturn ret, countend--[[randomGenerate a random numberUsage:{{#invoke: Math | random }}{{#invoke: Math | random | maximum value }}{{#invoke: Math | random | minimum value | maximum value }}]]function wrap.random(args)local first = p._cleanNumber(args[1])local second = p._cleanNumber(args[2])return p._random(first, second)endfunction p._random(first, second)math.randomseed(mw.site.stats.edits + mw.site.stats.pages + os.time() + math.floor(os.clock() * 1000000000))-- math.random will throw an error if given an explicit nil parameter, so we need to use if statements to check the params.if first and second thenif first <= second then -- math.random doesn't allow the first number to be greater than the second.return math.random(first, second)endelseif first thenreturn math.random(first)elsereturn math.random()endend--[[orderDetermine order of magnitude of a numberUsage:{{#invoke: Math | order | value }}]]function wrap.order(args)local input_string = (args[1] or args.x or '0');local input_number = p._cleanNumber(input_string);if input_number == nil thenreturn err('order of magnitude input appears non-numeric')elsereturn p._order(input_number)end    endfunction p._order(x)if x == 0 then return 0 endreturn math.floor(math.log10(math.abs(x)))end--[[precisionDetemines the precision of a number using the string representationUsage:{{ #invoke: Math | precision | value }}]]function wrap.precision(args)local input_string = (args[1] or args.x or '0');local trap_fraction = args.check_fraction;local input_number;if not yesno thenyesno = require('Module:Yesno')endif yesno(trap_fraction, true) then -- Returns true for all input except nil, false, "no", "n", "0" and a few others. See [[Module:Yesno]].local pos = string.find(input_string, '/', 1, true);if pos ~= nil thenif string.find(input_string, '/', pos + 1, true) == nil thenlocal denominator = string.sub(input_string, pos+1, -1);local denom_value = tonumber(denominator);if denom_value ~= nil thenreturn math.log10(denom_value);endend                        endend    input_number, input_string = p._cleanNumber(input_string);if input_string == nil thenreturn err('precision input appears non-numeric')elsereturn p._precision(input_string)end    endfunction p._precision(x)if type(x) == 'number' thenx = tostring(x)endx = string.upper(x)local decimal = x:find('%.')local exponent_pos = x:find('E')local result = 0;if exponent_pos ~= nil thenlocal exponent = string.sub(x, exponent_pos + 1)x = string.sub(x, 1, exponent_pos - 1)result = result - tonumber(exponent)end    if decimal ~= nil thenresult = result + string.len(x) - decimalreturn resultendlocal pos = string.len(x);while x:byte(pos) == string.byte('0') dopos = pos - 1result = result - 1if pos <= 0 thenreturn 0endendreturn resultend--[[maxFinds the maximum argumentUsage:{{#invoke:Math| max | value1 | value2 | ... }}Note, any values that do not evaluate to numbers are ignored.]]function wrap.max(args)return p._max(unpackNumberArgs(args))endfunction p._max(...)local function maxOfTwo(a, b)if a > b thenreturn aelsereturn bendendlocal max_value = applyFuncToArgs(maxOfTwo, ...)if max_value thenreturn max_valueendend--[[min Finds the minimum argumentUsage:{{#invoke:Math| min | value1 | value2 | ... }}OR{{#invoke:Math| min }}When used with no arguments, it takes its input from the parentframe.  Note, any values that do not evaluate to numbers are ignored.]]function wrap.min(args)return p._min(unpackNumberArgs(args))endfunction p._min(...)local function minOfTwo(a, b)if a < b thenreturn aelsereturn bendendlocal min_value = applyFuncToArgs(minOfTwo, ...)if min_value thenreturn min_valueendend--[[average Finds the averageUsage:{{#invoke:Math| average | value1 | value2 | ... }}OR{{#invoke:Math| average }}Note, any values that do not evaluate to numbers are ignored.]]function wrap.average(args)return p._average(unpackNumberArgs(args))endfunction p._average(...)local function getSum(a, b)return a + bendlocal sum, count = applyFuncToArgs(getSum, ...)if not sum thenreturn 0elsereturn sum / countendend--[[roundRounds a number to specified precisionUsage:{{#invoke:Math | round | value | precision }}--]]function wrap.round(args)local value = p._cleanNumber(args[1] or args.value or 0)local precision = p._cleanNumber(args[2] or args.precision or 0)if value == nil or precision == nil thenreturn err('round input appears non-numeric')elsereturn p._round(value, precision)end    endfunction p._round(value, precision)local rescale = math.pow(10, precision or 0);return math.floor(value * rescale + 0.5) / rescale;end--[[modImplements the modulo operatorUsage:{{#invoke:Math | mod | x | y }}--]]function wrap.mod(args)local x = p._cleanNumber(args[1])local y = p._cleanNumber(args[2])if not x thenreturn err('first argument to mod appears non-numeric')elseif not y thenreturn err('second argument to mod appears non-numeric')elsereturn p._mod(x, y)end    endfunction p._mod(x, y)local ret = x % yif not (0 <= ret and ret < y) thenret = 0endreturn retend--[[gcdCalculates the greatest common divisor of multiple numbersUsage:{{#invoke:Math | gcd | value 1 | value 2 | value 3 | ... }}--]]function wrap.gcd(args)return p._gcd(unpackNumberArgs(args))endfunction p._gcd(...)local function findGcd(a, b)local r = blocal oldr = awhile r ~= 0 dolocal quotient = math.floor(oldr / r)oldr, r = r, oldr - quotient * rendif oldr < 0 thenoldr = oldr * -1endreturn oldrendlocal result, count = applyFuncToArgs(findGcd, ...)return resultend--[[precision_formatRounds a number to the specified precision and formats according to rules originally used for {{template:Rnd}}.  Output is a string.Usage:{{#invoke: Math | precision_format | number | precision }}]]function wrap.precision_format(args)local value_string = args[1] or 0local precision = args[2] or 0return p._precision_format(value_string, precision)endfunction p._precision_format(value_string, precision)-- For access to Mediawiki built-in formatter.local lang = mw.getContentLanguage();local valuevalue, value_string = p._cleanNumber(value_string)precision = p._cleanNumber(precision)-- Check for non-numeric inputif value == nil or precision == nil thenreturn err('invalid input when rounding')endlocal current_precision = p._precision(value)local order = p._order(value)-- Due to round-off effects it is neccesary to limit the returned precision under-- some circumstances because the terminal digits will be inaccurately reported.if order + precision >= 14 thenorig_precision = p._precision(value_string)if order + orig_precision >= 14 thenprecision = 13 - order;        end        end-- If rounding off, truncate extra digitsif precision < current_precision thenvalue = p._round(value, precision)current_precision = p._precision(value)end    local formatted_num = lang:formatNum(math.abs(value))local sign-- Use proper unary minus sign rather than ASCII defaultif value < 0 thensign = '−'elsesign = ''end    -- Handle cases requiring scientific notationif string.find(formatted_num, 'E', 1, true) ~= nil or math.abs(order) >= 9 thenvalue = value * math.pow(10, -order)current_precision = current_precision + orderprecision = precision + orderformatted_num = lang:formatNum(math.abs(value))elseorder = 0;        endformatted_num = sign .. formatted_num-- Pad with zeros, if needed    if current_precision < precision thenlocal paddingif current_precision <= 0 thenif precision > 0 thenlocal zero_sep = lang:formatNum(1.1)formatted_num = formatted_num .. zero_sep:sub(2,2)padding = precisionif padding > 20 thenpadding = 20endformatted_num = formatted_num .. string.rep('0', padding)end            else                   padding = precision - current_precisionif padding > 20 thenpadding = 20endformatted_num = formatted_num .. string.rep('0', padding)endend-- Add exponential notation, if necessary.if order ~= 0 then-- Use proper unary minus sign rather than ASCII defaultif order < 0 thenorder = '−' .. lang:formatNum(math.abs(order))elseorder = lang:formatNum(order)end    formatted_num = formatted_num .. '<span style="margin:0 .15em 0 .25em">×</span>10<sup>' .. order .. '</sup>'endreturn formatted_numend--[[Helper function that interprets the input numerically.  If the input does not appear to be a number, attempts evaluating it asa parser functions expression.]]function p._cleanNumber(number_string)if type(number_string) == 'number' then-- We were passed a number, so we don't need to do any processing.return number_string, tostring(number_string)elseif type(number_string) ~= 'string' or not number_string:find('%S') then-- We were passed a non-string or a blank string, so exit.return nil, nil;end-- Attempt basic conversionlocal number = tonumber(number_string)-- If failed, attempt to evaluate input as an expressionif number == nil thenlocal success, result = pcall(mw.ext.ParserFunctions.expr, number_string)if success thennumber = tonumber(result)number_string = tostring(number)elsenumber = nilnumber_string = nilendelsenumber_string = number_string:match("^%s*(.-)%s*$") -- String is valid but may contain padding, clean it.number_string = number_string:match("^%+(.*)$") or number_string -- Trim any leading + signs.if number_string:find('^%-?0[xX]') then-- Number is using 0xnnn notation to indicate base 16; use the number that Lua detected instead.number_string = tostring(number)endendreturn number, number_stringend--[[Wrapper function that does basic argument processing. This ensures that all functions from #invoke can use either the currentframe or the parent frame, and it also trims whitespace for all arguments and removes blank arguments.]]local mt = { __index = function(t, k)return function(frame)if not getArgs thengetArgs = require('Module:Arguments').getArgsendreturn wrap[k](getArgs(frame))  -- Argument processing is left to Module:Arguments. Whitespace is trimmed and blank arguments are removed.endend }return setmetatable(p, mt)