Changes

local yesno -- Generate random numberfunction z.random( frame ) first = requiretonumber(frame.args[1]) -- if it doesn'Module:Yesnot exist it')s NaN, if not a number it's nillocal getArgs second = requiretonumber('Module:Arguments'frame.args[2]).getArgs

local 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)end local function unpackNumberArgs(args) -- Returns an unpacked list of arguments specified with numerical keys. local ret = {} for k, v in pairs(args) do if type(k) == 'number' first then table.insert(ret, v) end end return unpack(ret)end local 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 if NaN or non-number valuesnil, so we can't use ipairs. local nums = {} -- Stores the numbers of valid numerical arguments. local ret = {} for k, v in pairs(args) do v = p._cleanNumber(v) if v then nums[#nums + 1] = k args[k] = v end end table.sort(nums) for i, num in ipairs(nums) do ret[#ret + 1] = args[num] end return retend local 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 will skip down to the next function call. local vals = makeArgArray(...) local count = #vals -- The number of valid arguments if count == 0 then final return -- Exit if we have no valid args, otherwise removing the first arg would cause an error. nil, 0 end local ret = table.remove(vals, 1) for _, val in ipairs(vals) do ret <= func(ret, val) end return ret, countend --[[random Generate a random number Usage:{{#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)end function p._random(first, second) math.randomseed(mw.site.stats.edits + mw.site.stats.pages + os.time() + math.floor(os.clock() * 1000000000)) then -- math.random will throw an error could match if given an explicit both nil parameter, so we need to use if statements to check the params. if first and second then if first <= second then -- math.random doesn't allow the but already checked that first is a number to be greater than the second.in last line return math.random(first, second) end elseif first then return math.random(first) else end return math.random() end

{{#invoke: Math | order | value }}

 function wrapz.order(argsframe) local input_string = (frame.args[1] or frame.args.x or '0'); local input_number; input_number = pz._cleanNumber(frame, input_string); if input_number == nil then return err('order <strong class="error">Formatting error: Order of magnitude input appears non-numeric</strong>') else return pz._order(input_number) end

 function pz._order(x) if x == 0 then return 0 end return math.floor(math.log10(math.abs(x)))

{{ #invoke: Math | precision | value }}

 function wrapz.precision(argsframe ) local input_string = (frame.args[1] or frame.args.x or '0'); local trap_fraction = frame.args.check_fractionor false; local input_number; if yesnotype(trap_fraction, true) == 'string' then -- Returns true for all input except nil, trap_fraction = trap_fraction:lower(); if trap_fraction == 'false, "' or trap_fraction == '0' or trap_fraction == 'no", "n", "0" and a few others. See [[Module:Yesno]].' or trap_fraction == '' then trap_fraction = false; else trap_fraction = true; end end if trap_fraction then local pos = string.find(input_string, '/', 1, true); if pos ~= nil then if string.find(input_string, '/', pos + 1, true) == nil then local denominator = string.sub(input_string, pos+1, -1); local denom_value = tonumber(denominator); if denom_value ~= nil then return math.log10(denom_value); end end end end input_number, input_string = pz._cleanNumber(frame, input_string); if input_string == nil then return err('precision <strong class="error">Formatting error: Precision input appears non-numeric</strong>') else return pz._precision(input_string) end

function p._precision(x) if type(x) == 'number' then x = tostring(x) end x local decimal = string.upperfind(x)  local decimal = x:find(, '%.', 1, true ) local exponent_pos = x:string.find(x, 'E', 1, true ) local result = 0; if exponent_pos ~= nil then local exponent = string.sub(x, exponent_pos + 1) x = string.sub(x, 1, exponent_pos - 1) result = result - tonumber(exponent) end if decimal ~= nil then result = result + string.len(x) - decimal return result end local pos = string.len(x); while x:byte(pos) == string.byte('0') do pos = pos - 1 result = result - 1 if pos <= 0 then return 0 end end return result

{{#invoke:Math| max | value1 | value2 | ... }}OR {{#invoke:Math| max }}

When used with no arguments, it takes its input from the parentframe. Note, any values that do not evaluate to numbers are ignored.

 function wrapz.max(argsframe ) return p local args = frame._max(unpackNumberArgs(args));end if args[1] == nil thenfunction p._max(...) local function maxOfTwoparent = frame:getParent(a, b); if a > b then args = parent.args; return a end else local max_value = nil; return b end local i = 1; end while args[i] ~= nil do local max_value val = applyFuncToArgsz._cleanNumber(maxOfTwoframe, ...args[i] ); if val ~= nil then if max_value == nil or val > max_value then return max_value= val; end end i = i + 1; end return max_value

{{#invoke:Math| min | value1 | value2 | ... }}

{{#invoke:Math| min }}

 function wrapz.min(argsframe ) return p local args = frame._min(unpackNumberArgs(args));end if args[1] == nil thenfunction p._min(...) local function minOfTwoparent = frame:getParent(a, b); if a < b then args = parent.args; return a end else local min_value = nil; return b end local i = 1; end while args[i] ~= nil do local min_value val = applyFuncToArgsz._cleanNumber(minOfTwoframe, ...args[i] ); if val ~= nil then if min_value == nil or val < min_value then return min_value= val; end end i = i + 1; end return min_value

{{#invoke:Math| average | value1 | value2 | ... }}

{{#invoke:Math| average }} When used with no arguments, it takes its input from the parentframe. Note, any values that do not evaluate to numbers are ignored.

 function wrapz.average(argsframe ) return p local args = frame._average(unpackNumberArgs(args));end function p._average(...) if args[1] == nil then local function getSumparent = frame:getParent(a, b); return a + b args = parent.args; end local sum, = 0; local count = applyFuncToArgs0; local i = 1; while args[i] ~= nil do local val = z._cleanNumber(getSumframe, ...args[i] ); if not val ~= nil then sum = sum then+ val count = count + 1 end i = i + 1; return 0 end else return (count == 0 and 0 or sum / count end)

{{#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 then return err('round input appears non-numeric') else return p._round(value, precision) end end function p._round(value, precision) local rescale = math.pow(10, precision or 0); return math.floor(value * rescale + 0.5) / rescale;end --[[mod Implements the modulo operator Usage:{{#invoke:Math | mod | x | y }} --]] function wrap.mod(args) local x = p._cleanNumber(args[1]) local y = p._cleanNumber(args[2]) if not x then return err('first argument to mod appears non-numeric') elseif not y then return err('second argument to mod appears non-numeric') else return p._mod(x, y) end end function p._mod(x, y) local ret = x % y if not (0 <= ret and ret < y) then ret = 0 end return retend --[[gcd Calculates the greatest common divisor of multiple numbers Usage:{{#invoke:Math | gcd | value 1 | value 2 | value 3 | ... }}

function z.round(frame)function wrap local value, precision; value = z.gcd_cleanNumber(frame, frame.args[1] or frame.args.value or 0 ); return p precision = z._gcd(unpackNumberArgs_cleanNumber(frame, frame.args[2] or frame.args.precision or 0 ); if value == nil or precision == nil then return '<strong class="error">Formatting error: Round input appears non-numeric</strong>' else return z._round( value, precision ); end

 function pz._gcd_round(...value, precision ) local function findGcdrescale = math.pow(a10, bprecision ); local r = b local oldr = a while r ~= 0 do local quotient = return math.floor(oldr / r) oldr, r = r, oldr - quotient value * r end if oldr < rescale + 0 then oldr = oldr * -1 end return oldr end local result, count = applyFuncToArgs(findGcd, ...5 ) return result/ rescale;

{{#invoke: Math | precision_format | number | precision }}

function wrap.precision_format(args) local value_string = args[1] or 0 local precision = args[2] or 0 return p._precision_format(value_string, precision)end function p._precision_format(value_string, precision) -- For access to Mediawiki built-in formatter. local lang = mw.getContentLanguage();  local value value, value_string = p._cleanNumber(value_string) precision = p._cleanNumber(precision)  -- Check for non-numeric input if value == nil or precision == nil then return err('invalid input when rounding') end  local current_precision = p._precision(value) local order = pz._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 then orig_precision = pz._precision(value_string); if order + orig_precision >= 14 then precision = 13 - order; end end  -- If rounding off, truncate extra digits if precision < current_precision then value = 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 default if value < 0 then sign = '−' else sign = '' end   -- Handle cases requiring scientific notation if string.find(formatted_num, 'E', 1, true) ~= nil or math.abs(order) >= 9 then value = value * math.pow(10, -order) current_precision = current_precision + order precision = precision + order formatted_num = lang:formatNum(math.abs(value)) else order = 0; end formatted_num = sign .. formatted_num

-- If rounding off, truncate extra digits if precision < current_precision then value = z._round( value, precision ); current_precision = z._precision( value ); end local formatted_num = lang:formatNum( math.abs(value) ); local sign; -- Use proper unary minus sign rather than ASCII default if value < 0 then sign = '−'; else sign = ''; end -- Handle cases requiring scientific notation if string.find( formatted_num, 'E', 1, true ) ~= nil or math.abs(order) >= 9 then value = value * math.pow( 10, -order ); current_precision = current_precision + order; precision = precision + order; formatted_num = lang:formatNum( math.abs(value) ); else order = 0; end formatted_num = sign .. formatted_num; -- Pad with zeros, if needed if current_precision < precision then local padding; if current_precision <= 0 then if precision > 0 then local zero_sep = lang:formatNum(1.1); formatted_num = formatted_num .. zero_sep:sub(2,2);

padding = precision; if padding > 20 then padding = 20; end formatted_num = formatted_num .. string.rep( '0', padding ); end else padding = precision - current_precision if padding > 20 then padding = 20; end formatted_num = formatted_num .. string.rep( '0', padding ); end end

formatted_num = formatted_num .. string.rep('0', padding) end else padding = precision - current_precision if padding > 20 then padding = 20 end formatted_num = formatted_num .. string.rep('0', padding) end end  -- Add exponential notation, if necessary. if order ~= 0 then -- Use proper unary minus sign rather than ASCII default if order < 0 then order = '−' .. lang:formatNum(math.abs(order)); else order = lang:formatNum(order); end formatted_num = formatted_num .. '<span style="margin:0 .15em 0 .25em">×</span>10^{' .. order .. '}' end return formatted_num;

function pz._cleanNumber(frame, 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' nil or not number_string:findlen('%S') == 0 then -- We were passed a non-string or a blank string, so exit. return nil, nil; end -- Attempt basic conversion local number = tonumber(number_string) -- If failed, attempt to evaluate input as an expression if number == nil then local frame = mw.getCurrentFrame() local attempt = frame:preprocess('{{#expr: ' .. number_string .. '}}'); attempt = tonumber(attempt); if attempt ~= nil then number = attempt; number_string = tostring(number); else number = nil; number_string = nil; end else number_string = number_string:match("^%s*(.-)%s*$") -- String is valid but may contain padding, clean it. number_string = number_string:match("^%+s*(.-)%s*)$") 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) end end   return 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 function makeWrapper(funcName) return function (frame) local args = getArgs(frame) -- Argument processing is left to Module:Arguments. Whitespace is trimmed and blank arguments are removed. return wrap[funcName](args) endend for funcName in pairs(wrap) do p[funcName] = makeWrapper(funcName);

return pz