Editing Module:Math

From MINR.ORG WIKI

Warning: You are not logged in. Your IP address will be publicly visible if you make any edits. If you log in or create an account, your edits will be attributed to your username, along with other benefits.

The edit can be undone. Please check the comparison below to verify that this is what you want to do, and then save the changes below to finish undoing the edit.
Latest revision Your text
Line 4: Line 4:
  
 
]]
 
]]
 +
local z = {}
  
−
local yesno, getArgs -- lazily initialized
+
-- Generate random number
 +
function z.random( frame )
 +
    first = tonumber(frame.args[1]) -- if it doesn't exist it's NaN, if not a number it's nil
 +
    second = tonumber(frame.args[2])
  
−
local p = {} -- Holds functions to be returned from #invoke, and functions to make available to other Lua modules.
+
    if first then -- if NaN or nil, will skip down to final return
−
local wrap = {} -- Holds wrapper functions that process arguments from #invoke. These act as intemediary between functions meant for #invoke and functions meant for Lua.
+
        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
−
Helper functions used to avoid redundant code.
+
        return math.random(first)
−
]]
+
    end 
−
 
+
    return math.random()
−
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
 
end
  
Line 110: Line 26:
  
 
Usage:
 
Usage:
−
{{#invoke: Math | order | value }}
+
    {{#invoke: Math | order | value }}
 
]]
 
]]
−
 
+
function z.order(frame)
−
function wrap.order(args)
+
    local input_string = (frame.args[1] or frame.args.x or '0');
−
local input_string = (args[1] or args.x or '0');
+
    local input_number;
−
local input_number = p._cleanNumber(input_string);
+
   
−
if input_number == nil then
+
    input_number = z._cleanNumber( frame, input_string );
−
return err('order of magnitude input appears non-numeric')
+
    if input_number == nil then
−
else
+
        return '<strong class="error">Formatting error: Order of magnitude input appears non-numeric</strong>'
−
return p._order(input_number)
+
    else
−
end     
+
        return z._order( input_number )
 +
    end     
 
end
 
end
−
 
+
function z._order(x)
−
function p._order(x)
+
    if x == 0 then return 0 end
−
if x == 0 then return 0 end
+
    return math.floor(math.log10(math.abs(x)))
−
return math.floor(math.log10(math.abs(x)))
 
 
end
 
end
  
Line 134: Line 50:
  
 
Usage:
 
Usage:
−
{{ #invoke: Math | precision | value }}
+
    {{ #invoke: Math | precision | value }}
 
]]
 
]]
−
 
+
function z.precision( frame )
−
function wrap.precision(args)
+
    local input_string = (frame.args[1] or frame.args.x or '0');
−
local input_string = (args[1] or args.x or '0');
+
    local trap_fraction = frame.args.check_fraction or false;
−
local trap_fraction = args.check_fraction;
+
    local input_number;
−
local input_number;
+
   
−
 
+
    if type( trap_fraction ) == 'string' then
−
if not yesno then
+
        trap_fraction = trap_fraction:lower();
−
yesno = require('Module:Yesno')
+
        if trap_fraction == 'false' or trap_fraction == '0' or
−
end
+
                trap_fraction == 'no' or trap_fraction == '' then
−
if yesno(trap_fraction, true) then -- Returns true for all input except nil, false, "no", "n", "0" and a few others. See [[Module:Yesno]].
+
            trap_fraction = false;
−
local pos = string.find(input_string, '/', 1, true);
+
        else
−
if pos ~= nil then
+
            trap_fraction = true;
−
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);
+
   
−
if denom_value ~= nil then
+
    if trap_fraction then
−
return math.log10(denom_value);
+
        local pos = string.find( input_string, '/', 1, true );
−
end
+
        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 );
−
 
+
                if denom_value ~= nil then
−
input_number, input_string = p._cleanNumber(input_string);
+
                    return math.log10(denom_value);
−
if input_string == nil then
+
                end
−
return err('precision input appears non-numeric')
+
            end                         
−
else
+
        end
−
return p._precision(input_string)
+
    end     
−
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)
+
    local decimal = string.find( x, '.', 1, true )
−
if type(x) == 'number' then
+
    local exponent_pos = string.find( x, 'E', 1, true )
−
x = tostring(x)
+
    local result = 0;
−
end
+
   
−
x = string.upper(x)
+
    if exponent_pos ~= nil then
−
 
+
        local exponent = string.sub( x, exponent_pos + 1 )
−
local decimal = x:find('%.')
+
        x = string.sub( x, 1, exponent_pos - 1 )
−
local exponent_pos = x:find('E')
+
        result = result - tonumber( exponent )
−
local result = 0;
+
    end     
−
 
+
   
−
if exponent_pos ~= nil then
+
    if decimal ~= nil then
−
local exponent = string.sub(x, exponent_pos + 1)
+
        result = result + string.len( x ) - decimal
−
x = string.sub(x, 1, exponent_pos - 1)
+
        return result
−
result = result - tonumber(exponent)
+
    end
−
end     
+
       
−
 
+
    local pos = string.len( x );
−
if decimal ~= nil then
+
    while x:byte(pos) == string.byte('0') do
−
result = result + string.len(x) - decimal
+
        pos = pos - 1
−
return result
+
        result = result - 1
−
end
+
        if pos <= 0 then
−
 
+
            return 0
−
local pos = string.len(x);
+
        end
−
while x:byte(pos) == string.byte('0') do
+
    end
−
pos = pos - 1
+
   
−
result = result - 1
+
    return result
−
if pos <= 0 then
 
−
return 0
 
−
end
 
−
end
 
−
 
 
−
return result
 
 
end
 
end
−
 
  
 
--[[
 
--[[
Line 206: Line 123:
  
 
Usage:
 
Usage:
−
{{#invoke:Math| max | value1 | value2 | ... }}
+
    {{#invoke:Math| max | value1 | value2 | ... }}
 +
OR
 +
    {{#invoke:Math| max }}
  
−
Note, any values that do not evaluate to numbers are ignored.
+
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 )
−
function wrap.max(args)
+
    local args = frame.args;
−
return p._max(unpackNumberArgs(args))
+
   
−
end
+
    if args[1] == nil then
−
 
+
        local parent = frame:getParent();
−
function p._max(...)
+
        args = parent.args;
−
local max_value = binary_fold((function(a, b) return a > b end), ...)
+
    end
−
if max_value then
+
    local max_value = nil;
−
return max_value
+
   
−
end
+
    local i = 1;
 +
    while args[i] ~= nil do
 +
        local val = z._cleanNumber( frame, args[i] );
 +
        if val ~= nil then
 +
            if max_value == nil or val > max_value then
 +
                max_value = val;
 +
            end
 +
        end      
 +
        i = i + 1;
 +
    end
 +
 
 +
    return max_value
 
end
 
end
  
Line 228: Line 159:
  
 
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 )
−
function wrap.min(args)
+
    local args = frame.args;
−
return p._min(unpackNumberArgs(args))
+
   
−
end
+
    if args[1] == nil then
−
 
+
        local parent = frame:getParent();
−
function p._min(...)
+
        args = parent.args;
−
local min_value = binary_fold((function(a, b) return a < b end), ...)
+
    end
−
if min_value then
+
    local min_value = nil;
−
return min_value
+
   
−
end
+
    local i = 1;
−
end
+
    while args[i] ~= nil do
−
 
+
        local val = z._cleanNumber( frame, args[i] );
−
--[[
+
        if val ~= nil then
−
average
+
            if min_value == nil or val < min_value then
−
 
+
                min_value = val;
−
Finds the average
+
            end
−
 
+
        end       
−
Usage:
+
        i = i + 1;
−
{{#invoke:Math| average | value1 | value2 | ... }}
+
    end
−
OR
+
 
−
{{#invoke:Math| average }}
+
    return min_value
−
 
 
−
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
 
end
  
Line 279: Line 195:
  
 
Usage:
 
Usage:
−
{{#invoke:Math | round | value | precision }}
+
    {{#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 ret
 
−
end
 
−
 
 
−
--[[
 
−
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.gcd(args)
+
    local value, precision;
−
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 )
−
function p._gcd(...)
+
    local rescale = math.pow( 10, precision );
−
local function findGcd(a, b)
+
    return math.floor( value * rescale + 0.5 ) / rescale;
−
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
  
Line 365: Line 222:
  
 
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.
 +
    local lang = mw.getContentLanguage();
 +
   
 +
    local value_string, value, precision;
 +
    value, value_string = z._cleanNumber( frame, frame.args[1] or 0 );
 +
    precision = z._cleanNumber( frame, frame.args[2] or 0 );
 +
   
 +
    -- Check for non-numeric input
 +
    if value == nil or precision == nil then
 +
        return '<strong class="error">Formatting error: invalid input when rounding</strong>'
 +
    end
 +
   
 +
    local current_precision = z._precision( value );
  
−
function wrap.precision_format(args)
+
    local order = z._order( value );
−
local value_string = args[1] or 0
+
   
−
local precision = args[2] or 0
+
    -- Due to round-off effects it is neccesary to limit the returned precision under
−
return p._precision_format(value_string, precision)
+
    -- some circumstances because the terminal digits will be inaccurately reported.
−
end
+
    if order + precision >= 14 then
 +
        orig_precision = z._precision( value_string );
 +
        if order + orig_precision >= 14 then
 +
            precision = 13 - order;       
 +
        end       
 +
    end
  
−
function p._precision_format(value_string, precision)
+
    -- If rounding off, truncate extra digits
−
-- For access to Mediawiki built-in formatter.
+
    if precision < current_precision then
−
local lang = mw.getContentLanguage();
+
        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);
  
−
local value
+
                padding = precision;
−
value, value_string = p._cleanNumber(value_string)
+
                if padding > 20 then
−
precision = p._cleanNumber(precision)
+
                    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
  
−
-- Check for non-numeric input
+
    -- Add exponential notation, if necessary.
−
if value == nil or precision == nil then
+
    if order ~= 0 then
−
return err('invalid input when rounding')
+
        -- Use proper unary minus sign rather than ASCII default
−
end
+
        if order < 0 then
−
 
+
            order = '−' .. lang:formatNum( math.abs(order) );
−
local current_precision = p._precision(value)
+
        else
−
local order = p._order(value)
+
            order = lang:formatNum( order );
−
 
+
        end     
−
-- Due to round-off effects it is neccesary to limit the returned precision under
+
       
−
-- some circumstances because the terminal digits will be inaccurately reported.
+
        formatted_num = formatted_num .. '<span style="margin:0 .15em 0 .25em">×</span>10<sup>' .. order .. '</sup>'
−
if order + precision >= 14 then
+
    end
−
orig_precision = p._precision(value_string)
+
   
−
if order + orig_precision >= 14 then
+
    return formatted_num;
−
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
 
end
  
Line 471: Line 322:
 
]]
 
]]
  
−
function p._cleanNumber(number_string)
+
function z._cleanNumber( frame, number_string )
−
if type(number_string) == 'number' then
+
    if number_string == nil or number_string:len() == 0 then
−
-- We were passed a number, so we don't need to do any processing.
+
        return nil, nil;
−
return number_string, tostring(number_string)
+
    end  
−
elseif type(number_string) ~= 'string' or not number_string:find('%S') then
+
   
−
-- We were passed a non-string or a blank string, so exit.
+
    -- Attempt basic conversion
−
return nil, nil;
+
    local number = tonumber( number_string )
−
end
+
   
−
 
+
    -- If failed, attempt to evaluate input as an expression
−
-- Attempt basic conversion
+
    if number == nil then      
−
local number = tonumber(number_string)
+
        local attempt = frame:preprocess( '{{#expr: ' .. number_string .. '}}' );
−
 
+
        attempt = tonumber( attempt );
−
-- If failed, attempt to evaluate input as an expression
+
        if attempt ~= nil then
−
if number == nil then
+
            number = attempt;
−
local success, result = pcall(mw.ext.ParserFunctions.expr, number_string)
+
            number_string = tostring( number );
−
if success then
+
        else
−
number = tonumber(result)
+
            number = nil;
−
number_string = tostring(number)
+
            number_string = nil;
−
else
+
        end
−
number = nil
+
    else
−
number_string = nil
+
    -- String is valid but may contain padding, clean it.
−
end
+
        number_string = number_string:match( "^%s*(.-)%s*$" );
−
else
+
    end
−
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.
+
    return number, number_string;
−
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)
 

Please note that all contributions to MINR.ORG WIKI may be edited, altered, or removed by other contributors. If you do not want your writing to be edited mercilessly, then do not submit it here.
You are also promising us that you wrote this yourself, or copied it from a public domain or similar free resource (see MINR.ORG WIKI:Copyrights for details). Do not submit copyrighted work without permission!

Cancel Editing help (opens in new window)
Retrieved from "https://wiki.minr.org/Module:Math"