Cambios

Este módulo proporciona una serie de operaciones matemáticas básicasThis 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. -- Genera un número aleatorio[[Helper functions used to avoid redundant code.]] local function zerr(msg) -- Generates wikitext error messages.random return mw.ustring.format('<strong class="error">Formatting error: %s</strong>', msg)end local function unpackNumberArgs(frameargs) -- Returns an unpacked list of arguments specified with numerical keys. local first ret = {} for k, v in pairs(args) do if type(k) == tonumber'number' then table.insert(frameret, 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) local second for i, num in ipairs(nums) do ret[#ret + 1] = tonumber(frame.args[2num] end return retend 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 seed vals = tonumbermakeArgArray(frame.args.seed.) local count = #vals -- The number of valid arguments if seed count == 0 thenreturn math -- Exit if we have no valid args, otherwise removing the first arg would cause an error. nil, 0 end local ret = table.randomseedremove(seed * os.timevals, 1) for _, val in ipairs(vals)do ret = func(ret, val) end return ret, countend -- inicialización pseudoaleatoria[[ endFold 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 first and second func(a, b) thenreturn a else return b end end), ...) return valueend --[[random if 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 then= p._cleanNumber(args[2]) return mathp.random_random(first,second) -- entero entre [end function p._random(first,second]) else math.randomseed(mw.site.stats.edits + mw.site.stats.pages + os.time() + math.floor(os.clock() * 1000000000)) return -- math.random(secondwill throw an error if given an explicit nil parameter,first)so we need to use if statements to check the params. end elseif if first and second then if first > 0 <= second then-- math.random doesn't allow the first number to be greater than the second. return math.random(first, second) -- entero entre [1, end elseif first]then else return math.random(first,-1) end else return math.random() -- número real entre [0,1) end

UsoUsage: {{#invoke: Math | order | <valor> value }}

 function zwrap.order(frameargs) local input_string = (frame.args[1] or frame.args.x or '0'); local input_number; input_number = zp._cleanNumber( frame, input_string ); if input_number == nil then return err('<strong class="error"><small>Error de formato: El orden de magnitud debe ser numérico</small></strong>order of magnitude input appears non-numeric') else return zp._order( input_number ) end

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

UsarUsage: {{ #invoke: Math | precision | <valor> value }}

 function zwrap.precision( frame args) local input_string = (frame.args[1] or frame.args.x or '0'); local trap_fraction = frame.args.check_fraction or false; local input_number; if type( trap_fraction ) == 'string' not yesno then trap_fraction yesno = trap_fraction:lowerrequire(); if trap_fraction == 'falseModule:Yesno' or trap_fraction == '0' or trap_fraction == 'no' or trap_fraction == '' then trap_fraction = false;) else trap_fraction = true; end 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 = zp._cleanNumber( frame, input_string ); if input_string == nil then return err('<strong class="error"><small>Error de formato: El valor de precisión ha de ser numérico</small></strong>precision input appears non-numeric') else return zp._precision( input_string ) end

function p._precision(x) if type(x) == 'number' then x = tostring(x) end x = string.upper(x)  local decimal = string.x:find( x, '%.', 1, true ) local exponent_pos = string.x: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

UsoUsage: {{#invoke:Math| max | <valor1> value1 | <valor2> value2 | ... }}o {{#invoke:Math| max }}

Cuando se utiliza sin argumentosNote, toma su entrada del marco superior. Tenga en cuenta que todos los valores que no se evalúan como números son ignoradosany values that do not evaluate to numbers are ignored.

 function zwrap.max( frame args) return p._max(unpackNumberArgs(args))end function p._max(...) local args max_value = framebinary_fold((function(a, b) return a > b end), ...args;) if max_value then return max_value endend if args--[[1median Find the median of set of numbers Usage:{{#invoke:Math | median | number1 | number2 | ...}}OR{{#invoke:Math | median }}]] == nil then local parent = frame:getParentfunction wrap.median(args); args = parent return p._median(unpackNumberArgs(args;)) end local max_value = nil; function p._median(...) local i vals = 1;makeArgArray(...) while args[i] ~ local count = nil do#vals local val = z table._cleanNumbersort( frame, args[i] vals); if val ~count == nil 0 then return 0 end  if max_value p._mod(count, 2) == nil or val > max_value 0 then max_value = val; return (vals[count/2] + vals[count/2+1])/2 else return vals[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 parentframe. Note, any values that do not evaluate to numbers are ignored.]] function wrap.min(args) return p._min(unpackNumberArgs(args))end i function p._min(...) local min_value = i + 1; binary_fold((function(a, b) return a < b end), ...) if min_value then return max_valuemin_value end

UsoUsage: {{#invoke:Math| min sum | <valor1> value1 | <valor2> value2 | ... }}oOR {{#invoke:Math| min sum }}

Cuando se utiliza sin argumentosNote, toma su entrada del marco superiorany values that do not evaluate to numbers are ignored. Tenga en cuenta que todos los valores que no se evalúan como números son ignorados

 function zwrap.minsum( frame args) local args = frame return p.args; if args[1] == nil then local parent = frame:getParent_sum(); args = parent.args; end local min_value = nil; local i = 1; while args[i] ~= nil do local val = z._cleanNumberunpackNumberArgs( frame, args[i] ); if val ~= nil then if min_value == nil or val < min_value then min_value = val; end end i = i + 1; end return min_value)

-- Función que cuenta el número de parámetros informadosfunction zp.cuenta_sum( frame ...) local resultado sums, count = 0; local Argumentos = frame.args; if Argumentos[1] == nil then local parent = frame:getParentfold((function(a, b); Argumentos = parentreturn a + b end), ...args;) end local i = 1; while Argumentos[i] ~= nil do if Argumentos[i] ~= '' not sums then resultado = resultado + 1 return 0 end else return sums i = i + 1; end return resultado

-- Función que suma los parámetros[[average Finds the average Usage:function z{{#invoke:Math| average | value1 | value2 | ...suma( frame )}}OR{{#invoke:Math| average }} local resultado = 0; local Argumentos = frameNote, any values that do not evaluate to numbers are ignored.args; ]] if Argumentos[1] == nil then local parent = frame:getParentfunction wrap.average(args); Argumentos = parent return p._average(unpackNumberArgs(args;)) end function p._average(...) local i sum, count = 1;fold((function(a, b) return a + b end), ...) while Argumentos[i] ~= nil do if Argumentos[i] ~= '' not sum then resultado = resultado + Argumentos[i] return 0 end else return sum / count i = i + 1; end return resultado

Redondea un número Rounds a la precisión especificadanumber 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) endend 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 zwrap.roundmod(frameargs) local value, precision; value x = zp._cleanNumber( frame, frame.args[1] or frame.args.value or 0 ); precision local y = zp._cleanNumber( frame, frame.args[2] or frame.args.precision or 0 ); if not x then return err('first argument to mod appears non-numeric') if value == nil or precision == nil elseif not y then return err('<strong class="error"><small>Error de formato: Los valores han de ser numéricos</small></strong>second argument to mod appears non-numeric') else return zp._round_mod( valuex, precision y); end

 function zp._round_mod( valuex, precision y) local rescale ret = x % y if not (0 <= ret and ret < y) then ret = math0 end return retend --[[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(...pow) local function findGcd( 10a, precision b); return local r = b local oldr = a while r ~= 0 do local quotient = math.floor( value oldr / r) oldr, r = r, oldr - quotient * rescale + r end if oldr < 0then oldr = oldr * -1 end return oldr end local result, count = fold(findGcd, ...5 ) / rescale; return result

Redondea un número Rounds a la precisión especificada y le da formato de acuerdo con las normasnumber to the specified precision and formats according to rulesoriginalmente utilizado para originally used for {{Plantillatemplate: Rnd}}. La salida es una cadena Output is a string.UsoUsage: {{#invoke: Math | precision_format | <número> number | <precisión> precision }}

function wrap.precision_format(args) local order value_string = zargs[1] or 0 local precision = args[2] or 0 return p._order_precision_format( value value_string, precision); end  -- Debido a los efectos de redondeofunction p._precision_format(value_string, es necesario limitar la precisión devuelta bajoprecision) -- algunas circunstancias, debido a que sobre los dígitos terminales se informó incorrectamenteFor access to Mediawiki built-in formatter. if order + precision > local lang = 14 then orig_precision = zmw._precisiongetContentLanguage( value_string ); if order + orig_precision >= 14 then precision = 13 - order; end end

-- Si el redondeo, trunca dígitos adicionales 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; -- Utiliza el signo menos unario apropiado antes que el ASCII por defecto if value < 0 then sign = '−'; else sign = ''; end -- Manejar los casos que requieren la notación científica if string.find( formatted_num, 'E', 1, true ) ~= nil or math.abs(order) >= 9 then value value_string = value * mathp.pow_cleanNumber( 10, -order value_string); current_precision = current_precision + order; precision = precision + order; formatted_num = lang:formatNum( mathp.abs_cleanNumber(value) ); else order = 0; end formatted_num = sign .. formatted_num; -- Pad con ceros si es necesario 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; -- Check for non-numeric input if padding > 20 then padding value == 20; end formatted_num nil or precision = formatted_num .. string.rep( '0', padding ); end else padding = precision - current_precision if padding > 20 nil then padding = 20; end formatted_num = formatted_num .. string.rep return err( '0invalid input when rounding', padding ); end 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 if order + p._precision(value_string) >= 14 then precision = 13 - order; end end  -- Añade notación exponencialIf rounding off, si es necesariotruncate 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 -- Utiliza el signo menos unario apropiado antes que el Use proper unary minus sign rather than ASCII por defectodefault 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;

Función de ayuda que interpreta la entrada numéricaHelper function that interprets the input numerically. If theSi la entrada no es un númeroinput does not appear to be a number, lo intenta evaluar comoattempts evaluating it asun «parser function» (Analizador sintáctico)a parser functions expression.

function zp._cleanNumber( frame, number_string ) if type(number_string ) == nil '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:lenfind('%S') == 0 then -- We were passed a non-string or a blank string, so exit. return nil, nil; end -- Intenta la conversión básicaAttempt basic conversion local number = tonumber( number_string ) -- Si fallaIf failed, trata de evaluar la entrada como expresiónattempt to evaluate input as an expression if number == nil then local attempt success, result = frame:preprocesspcall( '{{#expr: ' mw.ext.ParserFunctions. expr, number_string .. '}}' ); attempt = tonumber( attempt ); if attempt ~= nil success then number = attempt;tonumber(result) number_string = tostring( number ); else number = nil; number_string = nil; end else -- La cadena es válida pero puede contener relleno, límpiela. 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;

--[[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 mt = { __index = function(t, k) return zfunction(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. endend } return setmetatable(p, mt)