Module:Math/sandbox

 --[[

 This module provides a number of basic mathematical operations.

 ]]

 localyesno,getArgs-- lazily initialized

 localp={}-- Holds functions to be returned from #invoke, and functions to make available to other Lua modules.
 localwrap={}-- 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.
 ]]

 localfunctionerr(msg)
 -- Generates wikitext error messages.
 returnmw.ustring.format('<strong class="error">Formatting error: %s</strong>',msg)
 end

 localfunctionunpackNumberArgs(args)
 -- Returns an unpacked list of arguments specified with numerical keys.
 localret={}
 fork,vinpairs(args)do
 iftype(k)=='number'then
 table.insert(ret,v)
 end
 end
 returnunpack(ret)
 end

 localfunctionmakeArgArray(...)
 -- Makes an array of arguments from a list of arguments that might include nils.
 localargs={...}-- Table of arguments. It might contain nils or non-number values, so we can't use ipairs.
 localnums={}-- Stores the numbers of valid numerical arguments.
 localret={}
 fork,vinpairs(args)do
 v=p._cleanNumber(v)
 ifvthen
 nums[#nums+1]=k
 args[k]=v
 end
 end
 table.sort(nums)
 fori,numinipairs(nums)do
 ret[#ret+1]=args[num]
 end
 returnret
 end

 localfunctionfold(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.
 localvals=makeArgArray(...)
 localcount=#vals-- The number of valid arguments
 ifcount==0thenreturn
 -- Exit if we have no valid args, otherwise removing the first arg would cause an error.
 nil,0
 end
 localret=table.remove(vals,1)
 for_,valinipairs(vals)do
 ret=func(ret,val)
 end
 returnret,count
 end

 --[[
 Fold arguments by selectively choosing values (func should return when to choose the current "dominant" value).
 ]]
 localfunctionbinary_fold(func,...)
 localvalue=fold((function(a,b)iffunc(a,b)thenreturnaelsereturnbendend),...)
 returnvalue
 end

 --[[
 random

 Generate a random number

 Usage:
 {{#invoke: Math | random }}
 {{#invoke: Math | random | maximum value }}
 {{#invoke: Math | random | minimum value | maximum value }}
 ]]

 functionwrap.random(args)
 localfirst=p._cleanNumber(args[1])
 localsecond=p._cleanNumber(args[2])
 returnp._random(first,second)
 end

 functionp._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.
 iffirstandsecondthen
 iffirst<=secondthen-- math.random doesn't allow the first number to be greater than the second.
 returnmath.random(first,second)
 end
 elseiffirstthen
 returnmath.random(first)
 else
 returnmath.random()
 end
 end

 --[[
 order

 Determine order of magnitude of a number

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

 functionwrap.order(args)
 localinput_string=(args[1]orargs.xor'0');
 localinput_number=p._cleanNumber(input_string);
 ifinput_number==nilthen
 returnerr('order of magnitude input appears non-numeric')
 else
 returnp._order(input_number)
 end
 end

 functionp._order(x)
 ifx==0thenreturn0end
 returnmath.floor(math.log10(math.abs(x)))
 end

 --[[
 precision

 Detemines the precision of a number using the string representation

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

 functionwrap.precision(args)
 localinput_string=(args[1]orargs.xor'0');
 localtrap_fraction=args.check_fraction;
 localinput_number;

 ifnotyesnothen
 yesno=require('Module:Yesno')
 end
 ifyesno(trap_fraction,true)then-- Returns true for all input except nil, false, "no", "n", "0" and a few others. See [[Module:Yesno]].
 localpos=string.find(input_string,'/',1,true);
 ifpos~=nilthen
 ifstring.find(input_string,'/',pos+1,true)==nilthen
 localdenominator=string.sub(input_string,pos+1,-1);
 localdenom_value=tonumber(denominator);
 ifdenom_value~=nilthen
 returnmath.log10(denom_value);
 end
 end
 end
 end

 input_number,input_string=p._cleanNumber(input_string);
 ifinput_string==nilthen
 returnerr('precision input appears non-numeric')
 else
 returnp._precision(input_string)
 end
 end

 functionp._precision(x)
 iftype(x)=='number'then
 x=tostring(x)
 end
 x=string.upper(x)

 localdecimal=x:find('%.')
 localexponent_pos=x:find('E')
 localresult=0;

 ifexponent_pos~=nilthen
 localexponent=string.sub(x,exponent_pos+1)
 x=string.sub(x,1,exponent_pos-1)
 result=result-tonumber(exponent)
 end

 ifdecimal~=nilthen
 result=result+string.len(x)-decimal
 returnresult
 end

 localpos=string.len(x);
 whilex:byte(pos)==string.byte('0')do
 pos=pos-1
 result=result-1
 ifpos<=0then
 return0
 end
 end

 returnresult
 end


 --[[
 max

 Finds the maximum argument

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

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

 functionwrap.max(args)
 returnp._max(unpackNumberArgs(args))
 end

 functionp._max(...)
 localmax_value=binary_fold((function(a,b)returna>bend),...)
 ifmax_valuethen
 returnmax_value
 end
 end

 --[[
 median

 Find the median of set of numbers

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

 functionwrap.median(args)
 returnp._median(unpackNumberArgs(args))
 end

 functionp._median(...)
 localvals=makeArgArray(...)
 localcount=#vals
 table.sort(vals)

 ifcount==0then
 return0
 end

 ifp._mod(count,2)==0then
 return(vals[count/2]+vals[count/2+1])/2
 else
 returnvals[math.ceil(count/2)]
 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.
 ]]

 functionwrap.min(args)
 returnp._min(unpackNumberArgs(args))
 end

 functionp._min(...)
 localmin_value=binary_fold((function(a,b)returna<bend),...)
 ifmin_valuethen
 returnmin_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.
 ]]

 functionwrap.sum(args)
 returnp._sum(unpackNumberArgs(args))
 end

 functionp._sum(...)
 localsums,count=fold((function(a,b)returna+bend),...)
 ifnotsumsthen
 return0
 else
 returnsums
 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.
 ]]

 functionwrap.average(args)
 returnp._average(unpackNumberArgs(args))
 end

 functionp._average(...)
 localsum,count=fold((function(a,b)returna+bend),...)
 ifnotsumthen
 return0
 else
 returnsum/count
 end
 end

 --[[
 round

 Rounds a number to specified precision

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

 --]]

 functionwrap.round(args)
 localvalue=p._cleanNumber(args[1]orargs.valueor0)
 localprecision=p._cleanNumber(args[2]orargs.precisionor0)
 ifvalue==nilorprecision==nilthen
 returnerr('round input appears non-numeric')
 else
 returnp._round(value,precision)
 end
 end

 functionp._round(value,precision)
 localrescale=math.pow(10,precisionor0);
 returnmath.floor(value*rescale+0.5)/rescale;
 end

 --[[
 log10

 returns the log (base 10) of a number

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

 functionwrap.log10(args)
 returnmath.log10(args[1])
 end

 --[[
 mod

 Implements the modulo operator

 Usage:
 {{#invoke:Math | mod | x | y }}

 --]]

 functionwrap.mod(args)
 localx=p._cleanNumber(args[1])
 localy=p._cleanNumber(args[2])
 ifnotxthen
 returnerr('first argument to mod appears non-numeric')
 elseifnotythen
 returnerr('second argument to mod appears non-numeric')
 else
 returnp._mod(x,y)
 end
 end

 functionp._mod(x,y)
 localret=x%y
 ifnot(0<=retandret<y)then
 ret=0
 end
 returnret
 end

 --[[
 gcd

 Calculates the greatest common divisor of multiple numbers

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

 functionwrap.gcd(args)
 returnp._gcd(unpackNumberArgs(args))
 end

 functionp._gcd(...)
 localfunctionfindGcd(a,b)
 localr=b
 localoldr=a
 whiler~=0do
 localquotient=math.floor(oldr/r)
 oldr,r=r,oldr-quotient*r
 end
 ifoldr<0then
 oldr=oldr*-1
 end
 returnoldr
 end
 localresult,count=fold(findGcd,...)
 returnresult
 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 }}
 ]]

 functionwrap.precision_format(args)
 localvalue_string=args[1]or0
 localprecision=args[2]or0
 returnp._precision_format(value_string,precision)
 end

 functionp._precision_format(value_string,precision)
 -- For access to Mediawiki built-in formatter.
 locallang=mw.getContentLanguage();

 localvalue
 value,value_string=p._cleanNumber(value_string)
 precision=p._cleanNumber(precision)

 -- Check for non-numeric input
 ifvalue==nilorprecision==nilthen
 returnerr('invalid input when rounding')
 end

 localcurrent_precision=p._precision(value)
 localorder=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.
 iforder+precision>=14then
 iforder+p._precision(value_string)>=14then
 precision=13-order;
 end
 end

 -- If rounding off, truncate extra digits
 ifprecision<current_precisionthen
 value=p._round(value,precision)
 current_precision=p._precision(value)
 end

 localformatted_num
 localsign

 iforder<-4then
 formatted_num=lang:formatNum(math.abs(value),{noCommafy=true})
 else
 formatted_num=lang:formatNum(math.abs(value))
 end

 -- Use proper unary minus sign rather than ASCII default
 ifvalue<0then
 sign='−'
 else
 sign=''
 end

 -- Handle cases requiring scientific notation
 ifstring.find(formatted_num,'E',1,true)~=nilormath.abs(order)>=9then
 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
 ifcurrent_precision<precisionthen
 localpadding
 ifcurrent_precision<=0then
 ifprecision>0then
 localzero_sep=lang:formatNum(1.1)
 formatted_num=formatted_num..zero_sep:sub(2,2)

 padding=precision
 ifpadding>20then
 padding=20
 end

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

 -- Add exponential notation, if necessary.
 iforder~=0then
 -- Use proper unary minus sign rather than ASCII default
 iforder<0then
 order='−'..lang:formatNum(math.abs(order))
 else
 order=lang:formatNum(order)
 end

 formatted_num=formatted_num..'<span style="margin:0 .15em 0 .25em"&g×ばつ</span>10<sup>'..order..'</sup>'
 end

 returnformatted_num
 end

 --[[
 divide

 Implements the division operator

 Usage:
 {{#invoke:Math | divide | x | y | round= | precision= }}

 --]]
 functionwrap.divide(args)
 localx=args[1]
 localy=args[2]
 localround=args.round
 localprecision=args.precision
 ifnotyesnothen
 yesno=require('Module:Yesno')
 end
 returnp._divide(x,y,yesno(round),precision)
 end

 functionp._divide(x,y,round,precision)
 ify==nilory==""then
 returnerr("Empty divisor")
 elseifnottonumber(y)then
 iftype(y)=='string'andstring.sub(y,1,1)=='<'then
 returny
 else
 returnerr("Not a number: "..y)
 end
 elseifx==nilorx==""then
 returnerr("Empty dividend")
 elseifnottonumber(x)then
 iftype(x)=='string'andstring.sub(x,1,1)=='<'then
 returnx
 else
 returnerr("Not a number: "..x)
 end
 else
 localz=x/y
 ifroundthen
 returnp._round(z,0)
 elseifprecisionthen
 returnp._round(z,precision)
 else
 returnz
 end
 end
 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.
 ]]

 functionp._cleanNumber(number_string)
 iftype(number_string)=='number'then
 -- We were passed a number, so we don't need to do any processing.
 returnnumber_string,tostring(number_string)
 elseiftype(number_string)~='string'ornotnumber_string:find('%S')then
 -- We were passed a non-string or a blank string, so exit.
 returnnil,nil;
 end

 -- Attempt basic conversion
 localnumber=tonumber(number_string)

 -- If failed, attempt to evaluate input as an expression
 ifnumber==nilthen
 localsuccess,result=pcall(mw.ext.ParserFunctions.expr,number_string)
 ifsuccessthen
 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("^%+(.*)$")ornumber_string-- Trim any leading + signs.
 ifnumber_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

 returnnumber,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.
 ]]

 localmt={__index=function(t,k)
 returnfunction(frame)
 ifnotgetArgsthen
 getArgs=require('Module:Arguments').getArgs
 end
 returnwrap[k](getArgs(frame))-- Argument processing is left to Module:Arguments. Whitespace is trimmed and blank arguments are removed.
 end
 end}

 returnsetmetatable(p,mt)