Modulo:Math: differenze tra le versioni

Versione delle 02:17, 1 dic 2020

Versione attuale delle 02:22, 1 dic 2020

(Una versione intermedia di un altro utente non mostrate)

Riga 1:

--[[

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)