Difference between revisions of "Module:Math/sandbox"

From blackwiki
Jump to navigation Jump to search
m (82 revisions imported)
 
(79 intermediate revisions by 9 users not shown)
Line 1: Line 1:
 
--[[
 
--[[
+
 
 
This module provides a number of basic mathematical operations.
 
This module provides a number of basic mathematical operations.
+
 
 
]]
 
]]
local z = {}
+
 
+
local yesno, getArgs -- lazily initialized
-- Generate random number
+
 
function z.random( frame )
+
local p = {} -- Holds functions to be returned from #invoke, and functions to make available to other Lua modules.
    first = tonumber(frame.args[1]) -- if it doesn't exist it's NaN, if not a number it's nil
+
local wrap = {} -- Holds wrapper functions that process arguments from #invoke. These act as intemediary between functions meant for #invoke and functions meant for Lua.
    second = tonumber(frame.args[2])
+
 
+
--[[
    if first then -- if NaN or nil, will skip down to final return
+
Helper functions used to avoid redundant code.
        if first <= second then -- could match if both nil, but already checked that first is a number in last line
+
]]
            return math.random(first, second)
+
 
        end
+
local function err(msg)
        return math.random(first)
+
-- Generates wikitext error messages.
    end 
+
return mw.ustring.format('<strong class="error">Formatting error: %s</strong>', msg)
    return math.random()
+
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' 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 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) 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 ret
 +
end
 +
 
 +
local function fold(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 arguments
 +
if count == 0 then 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, count
 +
end
 +
 
 +
--[[
 +
Fold arguments by selectively choosing values (func should return when to choose the current "dominant" value).
 +
]]
 +
local function binary_fold(func, ...)
 +
local value = fold((function(a, b) if func(a, b) then return a else return b end end), ...)
 +
return value
 +
end
 +
 
 +
--[[
 +
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))
 +
-- 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 then
 +
if first <= second then -- math.random doesn't allow the first number to be greater than the second.
 +
return math.random(first, second)
 +
end
 +
elseif first then
 +
return math.random(first)
 +
else
 +
return math.random()
 +
end
 
end
 
end
+
 
 
--[[
 
--[[
 
order
 
order
+
 
 
Determine order of magnitude of a number
 
Determine order of magnitude of a number
+
 
 
Usage:
 
Usage:
    {{#invoke: Math | order | value }}
+
{{#invoke: Math | order | value }}
 
]]
 
]]
function z.order(frame)
+
 
    local input_string = (frame.args[1] or frame.args.x or '0');
+
function wrap.order(args)
    local input_number;
+
local input_string = (args[1] or args.x or '0');
+
local input_number = p._cleanNumber(input_string);
    input_number = z._cleanNumber( frame, input_string );
+
if input_number == nil then
    if input_number == nil then
+
return err('order of magnitude input appears non-numeric')
        return '<strong class="error">Formatting error: Order of magnitude input appears non-numeric</strong>'
+
else
    else
+
return p._order(input_number)
        return z._order( input_number )
+
end     
    end     
 
 
end
 
end
function z._order(x)
+
 
    if x == 0 then return 0 end
+
function p._order(x)
    return math.floor(math.log10(math.abs(x)))
+
if x == 0 then return 0 end
 +
return math.floor(math.log10(math.abs(x)))
 
end
 
end
+
 
 
--[[
 
--[[
 
precision
 
precision
+
 
 
Detemines the precision of a number using the string representation
 
Detemines the precision of a number using the string representation
+
 
 
Usage:
 
Usage:
    {{ #invoke: Math | precision | value }}
+
{{ #invoke: Math | precision | value }}
 
]]
 
]]
function z.precision( frame )
+
 
    local input_string = (frame.args[1] or frame.args.x or '0');
+
function wrap.precision(args)
    local trap_fraction = frame.args.check_fraction or false;
+
local input_string = (args[1] or args.x or '0');
    local input_number;
+
local trap_fraction = args.check_fraction;
+
local input_number;
    if type( trap_fraction ) == 'string' then
+
 
        trap_fraction = trap_fraction:lower();
+
if not yesno then
        if trap_fraction == 'false' or trap_fraction == '0' or
+
yesno = require('Module:Yesno')
                trap_fraction == 'no' or trap_fraction == '' then
+
end
            trap_fraction = false;
+
if yesno(trap_fraction, true) then -- Returns true for all input except nil, false, "no", "n", "0" and a few others. See [[Module:Yesno]].
        else
+
local pos = string.find(input_string, '/', 1, true);
            trap_fraction = true;
+
if pos ~= nil then
        end
+
if string.find(input_string, '/', pos + 1, true) == nil then
    end
+
local denominator = string.sub(input_string, pos+1, -1);
+
local denom_value = tonumber(denominator);
    if trap_fraction then
+
if denom_value ~= nil then
        local pos = string.find( input_string, '/', 1, true );
+
return math.log10(denom_value);
        if pos ~= nil then
+
end
            if string.find( input_string, '/', pos + 1, true ) == nil then
+
end                         
                local denominator = string.sub( input_string, pos+1, -1 );
+
end
                local denom_value = tonumber( denominator );
+
end     
                if denom_value ~= nil then
+
 
                    return math.log10(denom_value);
+
input_number, input_string = p._cleanNumber(input_string);
                end
+
if input_string == nil then
            end                         
+
return err('precision input appears non-numeric')
        end
+
else
    end     
+
return p._precision(input_string)
+
end     
    input_number, input_string = z._cleanNumber( frame, input_string );
 
    if input_string == nil then
 
        return '<strong class="error">Formatting error: Precision input appears non-numeric</strong>'
 
    else
 
        return z._precision( input_string )
 
    end     
 
 
end
 
end
function z._precision( x )  
+
 
    x = string.upper( x )
+
function p._precision(x)
+
if type(x) == 'number' then
    local decimal = string.find( x, '.', 1, true )
+
x = tostring(x)
    local exponent_pos = string.find( x, 'E', 1, true )
+
end
    local result = 0;
+
x = string.upper(x)
+
 
    if exponent_pos ~= nil then
+
local decimal = x:find('%.')
        local exponent = string.sub( x, exponent_pos + 1 )
+
local exponent_pos = x:find('E')
        x = string.sub( x, 1, exponent_pos - 1 )
+
local result = 0;
        result = result - tonumber( exponent )
+
 
    end     
+
if exponent_pos ~= nil then
+
local exponent = string.sub(x, exponent_pos + 1)
    if decimal ~= nil then
+
x = string.sub(x, 1, exponent_pos - 1)
        result = result + string.len( x ) - decimal
+
result = result - tonumber(exponent)
        return result
+
end     
    end
+
 
+
if decimal ~= nil then
    local pos = string.len( x );
+
result = result + string.len(x) - decimal
    while x:byte(pos) == string.byte('0') do
+
return result
        pos = pos - 1
+
end
        result = result - 1
+
 
        if pos <= 0 then
+
local pos = string.len(x);
            return 0
+
while x:byte(pos) == string.byte('0') do
        end
+
pos = pos - 1
    end
+
result = result - 1
+
if pos <= 0 then
    return result
+
return 0
 +
end
 +
end
 +
 
 +
return result
 
end
 
end
+
 
 +
 
 
--[[
 
--[[
 
max
 
max
+
 
 
Finds the maximum argument
 
Finds the maximum argument
+
 
 +
Usage:
 +
{{#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))
 +
end
 +
 
 +
function p._max(...)
 +
local max_value = binary_fold((function(a, b) return a > b end), ...)
 +
if max_value then
 +
return max_value
 +
end
 +
end
 +
 
 +
--[[
 +
median
 +
 
 +
Find the median of set of numbers
 +
 
 
Usage:
 
Usage:
    {{#invoke:Math| max | value1 | value2 | ... }}
+
{{#invoke:Math | median | number1 | number2 | ...}}
 
OR
 
OR
    {{#invoke:Math| max }}
+
{{#invoke:Math | median }}
 
When used with no arguments, it takes its input from the parent
 
frame.  Note, any values that do not evaluate to numbers are ignored.
 
 
]]
 
]]
function z.max( frame )
+
 
    local args = frame.args;
+
function wrap.median(args)
+
return p._median(unpackNumberArgs(args))
    if args[1] == nil then
+
end
        local parent = frame:getParent();
+
 
        args = parent.args;
+
function p._median(...)
    end
+
local vals = makeArgArray(...)
    local max_value = nil;
+
local count = #vals
+
table.sort(vals)
    local i = 1;
+
    while args[i] ~= nil do
+
if p._mod(count, 2) == 0 then
        local val = z._cleanNumber( frame, args[i] );
+
return (vals[count/2] + vals[count/2+1])/2
        if val ~= nil then
+
else
            if max_value == nil or val > max_value then
+
return vals[count/2+1]
                max_value = val;
+
end
            end
 
        end       
 
        i = i + 1;
 
    end
 
 
    return max_value
 
 
end
 
end
+
 
 
--[[
 
--[[
 
min  
 
min  
+
 
 
Finds the minimum argument
 
Finds the minimum argument
+
 
 
Usage:
 
Usage:
    {{#invoke:Math| min | value1 | value2 | ... }}
+
{{#invoke:Math| min | value1 | value2 | ... }}
 
OR
 
OR
    {{#invoke:Math| min }}
+
{{#invoke:Math| min }}
+
 
 
When used with no arguments, it takes its input from the parent
 
When used with no arguments, it takes its input from the parent
 
frame.  Note, any values that do not evaluate to numbers are ignored.
 
frame.  Note, any values that do not evaluate to numbers are ignored.
 
]]
 
]]
function z.min( frame )
+
 
    local args = frame.args;
+
function wrap.min(args)
+
return p._min(unpackNumberArgs(args))
    if args[1] == nil then
+
end
        local parent = frame:getParent();
+
 
        args = parent.args;
+
function p._min(...)
    end
+
local min_value = binary_fold((function(a, b) return a < b end), ...)
    local min_value = nil;
+
if min_value then
+
return min_value
    local i = 1;
+
end
    while args[i] ~= nil do
+
end
        local val = z._cleanNumber( frame, args[i] );
+
 
        if val ~= nil then
+
--[[
            if min_value == nil or val < min_value then
+
sum
                min_value = val;
+
 
            end
+
Finds the sum
        end      
+
 
        i = i + 1;
+
Usage:
    end
+
{{#invoke:Math| sum | value1 | value2 | ... }}
+
OR
    return min_value
+
{{#invoke:Math| sum }}
 +
 
 +
Note, any values that do not evaluate to numbers are ignored.
 +
]]
 +
 
 +
function wrap.sum(args)
 +
return p._sum(unpackNumberArgs(args))
 +
end
 +
 
 +
function p._sum(...)
 +
local sums, count = fold((function(a, b) return a + b end), ...)
 +
if not sums then
 +
return 0
 +
else
 +
return sums
 +
end
 
end
 
end
+
 
 
--[[
 
--[[
 
average  
 
average  
+
 
 
Finds the average
 
Finds the average
+
 
 
Usage:
 
Usage:
    {{#invoke:Math| average | value1 | value2 | ... }}
+
{{#invoke:Math| average | value1 | value2 | ... }}
 
OR
 
OR
    {{#invoke:Math| average }}
+
{{#invoke:Math| average }}
+
 
When used with no arguments, it takes its input from the parent
+
Note, any values that do not evaluate to numbers are ignored.
frame.  Note, any values that do not evaluate to numbers are ignored.
 
 
]]
 
]]
function z.average( frame )
+
 
    local args = frame.args;
+
function wrap.average(args)
    if args[1] == nil then
+
return p._average(unpackNumberArgs(args))
        local parent = frame:getParent();
+
end
        args = parent.args;
+
 
    end
+
function p._average(...)
    local sum = 0;
+
local sum, count = fold((function(a, b) return a + b end), ...)
    local count = 0;
+
if not sum then
+
return 0
    local i = 1;
+
else
    while args[i] ~= nil do
+
return sum / count
        local val = z._cleanNumber( frame, args[i] );
+
end
        if val ~= nil then
 
            sum = sum + val
 
            count = count + 1
 
        end       
 
        i = i + 1;
 
    end
 
 
    return (count == 0 and 0 or sum/count)
 
 
end
 
end
+
 
 
--[[
 
--[[
 
round
 
round
+
 
 
Rounds a number to specified precision
 
Rounds a number to specified precision
+
 
 +
Usage:
 +
{{#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
 +
 
 +
--[[
 +
log10
 +
 
 +
returns the log (base 10) of a number
 +
 
 +
Usage:
 +
{{#invoke:Math | log10 | x }}
 +
]]
 +
 
 +
function wrap.log10(args)
 +
return math.log10(args[1])
 +
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 ret
 +
end
 +
 
 +
--[[
 +
gcd
 +
 
 +
Calculates the greatest common divisor of multiple numbers
 +
 
 
Usage:
 
Usage:
    {{#invoke:Math | round | value | precision }}
+
{{#invoke:Math | gcd | value 1 | value 2 | value 3 | ... }}
 
 
--]]
 
--]]
function z.round(frame)
+
 
    local value, precision;
+
function wrap.gcd(args)
+
return p._gcd(unpackNumberArgs(args))
    value = z._cleanNumber( frame, frame.args[1] or frame.args.value or 0 );
 
    precision = z._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   
 
 
end
 
end
function z._round( value, precision )
+
 
    local rescale = math.pow( 10, precision );
+
function p._gcd(...)
    return math.floor( value * rescale + 0.5 ) / rescale;
+
local function findGcd(a, b)
 +
local r = b
 +
local oldr = a
 +
while r ~= 0 do
 +
local quotient = math.floor(oldr / r)
 +
oldr, r = r, oldr - quotient * r
 +
end
 +
if oldr < 0 then
 +
oldr = oldr * -1
 +
end
 +
return oldr
 +
end
 +
local result, count = fold(findGcd, ...)
 +
return result
 
end
 
end
+
 
 
--[[
 
--[[
 
precision_format
 
precision_format
+
 
 
Rounds a number to the specified precision and formats according to rules  
 
Rounds a number to the specified precision and formats according to rules  
 
originally used for {{template:Rnd}}.  Output is a string.
 
originally used for {{template:Rnd}}.  Output is a string.
+
 
 
Usage:
 
Usage:
    {{#invoke: Math | precision_format | number | precision }}
+
{{#invoke: Math | precision_format | number | precision }}
 
]]
 
]]
function z.precision_format( frame )
+
 
    -- For access to Mediawiki built-in formatter.
+
function wrap.precision_format(args)
    local lang = mw.getContentLanguage();
+
local value_string = args[1] or 0
+
local precision = args[2] or 0
    local value_string, value, precision;
+
return p._precision_format(value_string, precision)
    value, value_string = z._cleanNumber( frame, frame.args[1] or 0 );
+
end
    precision = z._cleanNumber( frame, frame.args[2] or 0 );
+
 
+
function p._precision_format(value_string, precision)
    -- Check for non-numeric input
+
-- For access to Mediawiki built-in formatter.
    if value == nil or precision == nil then
+
local lang = mw.getContentLanguage();
        return '<strong class="error">Formatting error: invalid input when rounding</strong>'
+
 
    end
+
local value
+
value, value_string = p._cleanNumber(value_string)
    local current_precision = z._precision( value );
+
precision = p._cleanNumber(precision)
+
 
    local order = z._order( value );
+
-- Check for non-numeric input
+
if value == nil or precision == nil then
    -- Due to round-off effects it is neccesary to limit the returned precision under
+
return err('invalid input when rounding')
    -- some circumstances because the terminal digits will be inaccurately reported.
+
end
    if order + precision >= 14 then
+
 
        orig_precision = z._precision( value_string );
+
local current_precision = p._precision(value)
        if order + orig_precision >= 14 then
+
local order = p._order(value)
            precision = 13 - order;         
+
 
        end         
+
-- Due to round-off effects it is neccesary to limit the returned precision under
    end
+
-- some circumstances because the terminal digits will be inaccurately reported.
+
if order + precision >= 14 then
    -- If rounding off, truncate extra digits
+
orig_precision = p._precision(value_string)
    if precision < current_precision then
+
if order + orig_precision >= 14 then
        value = z._round( value, precision );
+
precision = 13 - order;         
        current_precision = z._precision( value );
+
end         
    end     
+
end
+
 
    local formatted_num = lang:formatNum( math.abs(value) );
+
-- If rounding off, truncate extra digits
    local sign;
+
if precision < current_precision then
+
value = p._round(value, precision)
    -- Use proper unary minus sign rather than ASCII default
+
current_precision = p._precision(value)
    if value < 0 then
+
end     
        sign = '−';
+
 
    else
+
local formatted_num = lang:formatNum(math.abs(value))
        sign = '';
+
local sign
    end     
+
 
+
-- Use proper unary minus sign rather than ASCII default
    -- Handle cases requiring scientific notation
+
if value < 0 then
    if string.find( formatted_num, 'E', 1, true ) ~= nil or math.abs(order) >= 9 then
+
sign = '−'
        value = value * math.pow( 10, -order );
+
else
        current_precision = current_precision + order;
+
sign = ''
        precision = precision + order;
+
end     
        formatted_num = lang:formatNum( math.abs(value) );
+
 
    else
+
-- Handle cases requiring scientific notation
        order = 0;         
+
if string.find(formatted_num, 'E', 1, true) ~= nil or math.abs(order) >= 9 then
    end
+
value = value * math.pow(10, -order)
    formatted_num = sign .. formatted_num;
+
current_precision = current_precision + order
+
precision = precision + order
    -- Pad with zeros, if needed     
+
formatted_num = lang:formatNum(math.abs(value))
    if current_precision < precision then
+
else
        local padding;
+
order = 0;         
        if current_precision <= 0 then
+
end
            if precision > 0 then
+
formatted_num = sign .. formatted_num
                local zero_sep = lang:formatNum( 1.1 );
+
 
                formatted_num = formatted_num .. zero_sep:sub(2,2);
+
-- Pad with zeros, if needed     
+
if current_precision < precision then
                padding = precision;
+
local padding
                if padding > 20 then
+
if current_precision <= 0 then
                    padding = 20;
+
if precision > 0 then
                end
+
local zero_sep = lang:formatNum(1.1)
+
formatted_num = formatted_num .. zero_sep:sub(2,2)
                formatted_num = formatted_num .. string.rep( '0', padding );
+
 
            end             
+
padding = precision
        else                   
+
if padding > 20 then
            padding = precision - current_precision
+
padding = 20
            if padding > 20 then
+
end
                padding = 20;
+
 
            end
+
formatted_num = formatted_num .. string.rep('0', padding)
            formatted_num = formatted_num .. string.rep( '0', padding );
+
end             
        end
+
else                   
    end
+
padding = precision - current_precision
+
if padding > 20 then
    -- Add exponential notation, if necessary.
+
padding = 20
    if order ~= 0 then
+
end
        -- Use proper unary minus sign rather than ASCII default
+
formatted_num = formatted_num .. string.rep('0', padding)
        if order < 0 then
+
end
            order = '−' .. lang:formatNum( math.abs(order) );
+
end
        else
+
 
            order = lang:formatNum( order );
+
-- Add exponential notation, if necessary.
        end     
+
if order ~= 0 then
+
-- Use proper unary minus sign rather than ASCII default
        formatted_num = formatted_num .. '<span style="margin:0 .15em 0 .25em">×</span>10<sup>' .. order .. '</sup>'
+
if order < 0 then
    end
+
order = '−' .. lang:formatNum(math.abs(order))
+
else
    return formatted_num;
+
order = lang:formatNum(order)
 +
end     
 +
 
 +
formatted_num = formatted_num .. '<span style="margin:0 .15em 0 .25em">×</span>10<sup>' .. order .. '</sup>'
 +
end
 +
 
 +
return formatted_num
 
end
 
end
+
 
 
--[[
 
--[[
 
Helper function that interprets the input numerically.  If the  
 
Helper function that interprets the input numerically.  If the  
Line 356: Line 536:
 
a parser functions expression.
 
a parser functions expression.
 
]]
 
]]
+
 
function z._cleanNumber( frame, number_string )
+
function p._cleanNumber(number_string)
    if number_string == nil or number_string:len() == 0 then
+
if type(number_string) == 'number' then
        return nil, nil;
+
-- We were passed a number, so we don't need to do any processing.
    end  
+
return number_string, tostring(number_string)
+
elseif type(number_string) ~= 'string' or not number_string:find('%S') then
    -- Attempt basic conversion
+
-- We were passed a non-string or a blank string, so exit.
    local number = tonumber( number_string )
+
return nil, nil;
+
end
    -- If failed, attempt to evaluate input as an expression
+
 
    if number == nil then      
+
-- Attempt basic conversion
        local attempt = frame:preprocess( '{{#expr: ' .. number_string .. '}}' );
+
local number = tonumber(number_string)
        attempt = tonumber( attempt );
+
 
        if attempt ~= nil then
+
-- If failed, attempt to evaluate input as an expression
            number = attempt;
+
if number == nil then
            number_string = tostring( number );
+
local success, result = pcall(mw.ext.ParserFunctions.expr, number_string)
        else
+
if success then
            number = nil;
+
number = tonumber(result)
            number_string = nil;
+
number_string = tostring(number)
        end
+
else
    else
+
number = nil
    -- String is valid but may contain padding, clean it.
+
number_string = nil
        number_string = number_string:match( "^%s*(.-)%s*$" );
+
end
    end
+
else
+
number_string = number_string:match("^%s*(.-)%s*$") -- String is valid but may contain padding, clean it.
    return number, number_string;
+
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)
 +
end
 +
end
 +
 
 +
return number, number_string
 
end
 
end
   
+
 
return z
+
--[[
 +
Wrapper function that does basic argument processing. This ensures that all functions from #invoke can use either the current
 +
frame 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 then
 +
getArgs = require('Module:Arguments').getArgs
 +
end
 +
return wrap[k](getArgs(frame)) -- Argument processing is left to Module:Arguments. Whitespace is trimmed and blank arguments are removed.
 +
end
 +
end }
 +
 
 +
return setmetatable(p, mt)

Latest revision as of 07:55, 27 September 2020

Documentation for this module may be created at Module:Math/sandbox/doc

--[[

This module provides a number of basic mathematical operations.

]]

local yesno, getArgs -- lazily initialized

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' 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 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) 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 ret
end

local function fold(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 arguments
	if count == 0 then 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, count
end

--[[
Fold arguments by selectively choosing values (func should return when to choose the current "dominant" value).
]]
local function binary_fold(func, ...)
	local value = fold((function(a, b) if func(a, b) then return a else return b end end), ...)
	return value
end

--[[
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))
	-- 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 then
		if first <= second then -- math.random doesn't allow the first number to be greater than the second.
			return math.random(first, second)
		end
	elseif first then
		return math.random(first)
	else
		return math.random()
	end
end

--[[
order

Determine order of magnitude of a number

Usage:
{{#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 then
		return err('order of magnitude input appears non-numeric')
	else
		return p._order(input_number)
	end    
end

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

--[[
precision

Detemines the precision of a number using the string representation

Usage:
{{ #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 then
		yesno = require('Module:Yesno')
	end
	if 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 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 = p._cleanNumber(input_string);
	if input_string == nil then
		return err('precision input appears non-numeric')
	else
		return p._precision(input_string)
	end    
end

function p._precision(x)
	if type(x) == 'number' then
		x = tostring(x)
	end
	x = string.upper(x)

	local decimal = x:find('%.')
	local exponent_pos = x:find('E')
	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
end


--[[
max

Finds the maximum argument

Usage:
{{#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))
end

function p._max(...)
	local max_value = binary_fold((function(a, b) return a > b end), ...)
	if max_value then
		return max_value
	end
end

--[[
median

Find the median of set of numbers

Usage:
{{#invoke:Math | median | number1 | number2 | ...}}
OR
{{#invoke:Math | median }}
]]

function wrap.median(args)
	return p._median(unpackNumberArgs(args))
end

function p._median(...)
	local vals = makeArgArray(...)	
	local count = #vals
	table.sort(vals)
	
	if p._mod(count, 2) == 0 then
		return (vals[count/2] + vals[count/2+1])/2
	else
		return vals[count/2+1]
	end
end

--[[
min 

Finds the minimum argument

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

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

function wrap.min(args)
	return p._min(unpackNumberArgs(args))
end

function p._min(...)
	local min_value = binary_fold((function(a, b) return a < b end), ...)
	if min_value then
		return min_value
	end
end

--[[
sum 

Finds the sum

Usage:
{{#invoke:Math| sum | value1 | value2 | ... }}
OR
{{#invoke:Math| sum }}

Note, any values that do not evaluate to numbers are ignored.
]]

function wrap.sum(args)
	return p._sum(unpackNumberArgs(args))
end

function p._sum(...)
	local sums, count = fold((function(a, b) return a + b end), ...)
	if not sums then
		return 0
	else
		return sums
	end
end

--[[
average 

Finds the average

Usage:
{{#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))
end

function p._average(...)
	local sum, count = fold((function(a, b) return a + b end), ...)
	if not sum then
		return 0
	else
		return sum / count
	end
end

--[[
round

Rounds a number to specified precision

Usage:
{{#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

--[[
log10

returns the log (base 10) of a number

Usage:
{{#invoke:Math | log10 | x }}
]]

function wrap.log10(args)
	return math.log10(args[1])
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 ret
end

--[[
gcd

Calculates the greatest common divisor of multiple numbers

Usage:
{{#invoke:Math | gcd | value 1 | value 2 | value 3 | ... }}
--]]

function wrap.gcd(args)
	return p._gcd(unpackNumberArgs(args))
end

function p._gcd(...)
	local function findGcd(a, b)
		local r = b
		local oldr = a
		while r ~= 0 do
			local quotient = math.floor(oldr / r)
			oldr, r = r, oldr - quotient * r
		end
		if oldr < 0 then
			oldr = oldr * -1
		end
		return oldr
	end
	local result, count = fold(findGcd, ...)
	return result
end

--[[
precision_format

Rounds 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 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 = 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 then
		orig_precision = p._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

	-- 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

	-- 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<sup>' .. order .. '</sup>'
	end

	return formatted_num
end

--[[
Helper function that interprets the input numerically.  If the 
input does not appear to be a number, attempts evaluating it as
a 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 conversion
	local number = tonumber(number_string)

	-- If failed, attempt to evaluate input as an expression
	if number == nil then
		local success, result = pcall(mw.ext.ParserFunctions.expr, number_string)
		if success then
			number = tonumber(result)
			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("^%+(.*)$") 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_string
end

--[[
Wrapper function that does basic argument processing. This ensures that all functions from #invoke can use either the current
frame 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 then
			getArgs = require('Module:Arguments').getArgs
		end
		return wrap[k](getArgs(frame))  -- Argument processing is left to Module:Arguments. Whitespace is trimmed and blank arguments are removed.
	end
end }

return setmetatable(p, mt)