Edición de «Módulo:Math»

Ir a la navegación Ir a la búsqueda

Advertencia: no has iniciado sesión. Tu dirección IP se hará pública si haces cualquier edición. Si inicias sesión o creas una cuenta, tus ediciones se atribuirán a tu nombre de usuario, además de otros beneficios.

Puedes deshacer la edición. Antes de deshacer la edición, comprueba la siguiente comparación para verificar que realmente es lo que quieres hacer, y entonces guarda los cambios para así efectuar la reversión.

Revisión actual Tu texto
Línea 1: Línea 1:
 
--[[
 
--[[
  
−
This module provides a number of basic mathematical operations.
+
Este módulo proporciona una serie de operaciones matemáticas básicas.
  
 
]]
 
]]
 +
local z = {}
  
−
local yesno, getArgs -- lazily initialized
+
-- Genera un número aleatorio
−
 
+
function z.random(frame)
−
local p = {} -- Holds functions to be returned from #invoke, and functions to make available to other Lua modules.
+
    local first = tonumber(frame.args[1])
−
local wrap = {} -- Holds wrapper functions that process arguments from #invoke. These act as intemediary between functions meant for #invoke and functions meant for Lua.
+
    local second = tonumber(frame.args[2])
−
 
+
    local seed = tonumber(frame.args.seed)
−
--[[
+
    if seed then
−
Helper functions used to avoid redundant code.
+
        math.randomseed(seed * os.time())   -- inicialización pseudoaleatoria
−
]]
+
    end
−
 
+
    if first and second then
−
local function err(msg)
+
        if first < second then
−
-- Generates wikitext error messages.
+
            return math.random(first,second)   -- entero entre [first,second]
−
return mw.ustring.format('<strong class="error">Formatting error: %s</strong>', msg)
+
        else
−
end
+
            return math.random(second,first)
−
 
+
        end
−
local function unpackNumberArgs(args)
+
    elseif first then
−
-- Returns an unpacked list of arguments specified with numerical keys.
+
        if first > 0 then
−
local ret = {}
+
            return math.random(first)    -- entero entre [1,first]
−
for k, v in pairs(args) do
+
        else
−
if type(k) == 'number' then
+
            return math.random(first,-1)
−
table.insert(ret, v)
+
        end
−
end
+
    else
−
end
+
        return math.random()    -- número real entre [0,1)
−
return unpack(ret)
+
    end
−
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
  
Línea 107: Línea 34:
 
order
 
order
  
−
Determine order of magnitude of a number
+
Determina el orden y la magnitud de los números
  
−
Usage:
+
Uso:
−
{{#invoke: Math | order | value }}
+
    {{#invoke: Math | order | <valor> }}
 
]]
 
]]
−
 
+
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"><small>Error de formato: El orden de magnitud debe ser numérico</small></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
  
Línea 131: Línea 58:
 
precision
 
precision
  
−
Detemines the precision of a number using the string representation
+
Detemina la precisión de un número usando la representación de cadena
  
−
Usage:
+
Usar:
−
{{ #invoke: Math | precision | value }}
+
    {{ #invoke: Math | precision | <valor> }}
 
]]
 
]]
−
 
+
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"><small>Error de formato: El valor de precisión ha de ser numérico</small></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
−
 
  
 
--[[
 
--[[
 
max
 
max
  
−
Finds the maximum argument
+
Busca el argumento máximo
  
−
Usage:
+
Uso:
−
{{#invoke:Math| max | value1 | value2 | ... }}
+
    {{#invoke:Math| max | <valor1> | <valor2> | ... }}
 +
o
 +
    {{#invoke:Math| max }}
  
−
Note, any values that do not evaluate to numbers are ignored.
+
Cuando se utiliza sin argumentos, toma su entrada del marco superior.
 +
Tenga en cuenta que todos los valores que no se evalúan como números son ignorados.
 
]]
 
]]
−
 
+
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;
−
end
+
    while args[i] ~= nil do
−
 
+
        local val = z._cleanNumber( frame, args[i] );
−
--[[
+
        if val ~= nil then
−
median
+
            if max_value == nil or val > max_value then
−
 
+
                max_value = val;
−
Find the median of set of numbers
+
            end
−
 
+
        end      
−
Usage:
+
        i = i + 1;
−
{{#invoke:Math | median | number1 | number2 | ...}}
+
    end
−
OR
+
 
−
{{#invoke:Math | median }}
+
    return max_value
−
]]
 
−
 
 
−
function wrap.median(args)
 
−
return p._median(unpackNumberArgs(args))
 
−
end
 
−
 
 
−
function p._median(...)
 
−
local vals = makeArgArray(...)
 
−
local count = #vals
 
−
table.sort(vals)
 
−
 
 
−
if count == 0 then
 
−
return 0
 
−
end
 
−
 
 
−
if p._mod(count, 2) == 0 then
 
−
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 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
 
end
  
 
--[[
 
--[[
−
sum
+
min
  
−
Finds the sum
+
Busca el argumento mínimo
  
−
Usage:
+
Uso:
−
{{#invoke:Math| sum | value1 | value2 | ... }}
+
    {{#invoke:Math| min | <valor1> | <valor2> | ... }}
−
OR
+
o
−
{{#invoke:Math| sum }}
+
    {{#invoke:Math| min }}
  
−
Note, any values that do not evaluate to numbers are ignored.
+
Cuando se utiliza sin argumentos, toma su entrada del marco superior.  
 +
Tenga en cuenta que todos los valores que no se evalúan como números son ignorados
 
]]
 
]]
−
 
+
function z.min( frame )
−
function wrap.sum(args)
+
    local args = frame.args;
−
return p._sum(unpackNumberArgs(args))
+
   
 +
    if args[1] == nil then
 +
        local parent = frame:getParent();
 +
        args = parent.args;
 +
    end
 +
    local min_value = nil;
 +
   
 +
    local i = 1;
 +
    while args[i] ~= nil do
 +
        local val = z._cleanNumber( 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
 
end
 
end
  
−
function p._sum(...)
+
-- Función que cuenta el número de parámetros informados
−
local sums, count = fold((function(a, b) return a + b end), ...)
+
function z.cuenta( frame )
−
if not sums then
+
    local resultado = 0;
−
return 0
+
    local Argumentos = frame.args;
−
else
+
   
−
return sums
+
    if Argumentos[1] == nil then
−
end
+
        local parent = frame:getParent();
 +
        Argumentos = parent.args;
 +
    end  
 +
   
 +
    local i = 1;
 +
    while Argumentos[i] ~= nil do
 +
      if Argumentos[i] ~= '' then
 +
    resultado = resultado + 1
 +
  end
 +
 
 +
  i = i + 1;
 +
    end
 +
 
 +
    return resultado
 
end
 
end
  
−
--[[
+
-- Función que suma los parámetros
−
average
+
function z.suma( frame )
−
 
+
    local resultado = 0;
−
Finds the average
+
    local Argumentos = frame.args;
−
 
+
   
−
Usage:
+
    if Argumentos[1] == nil then
−
{{#invoke:Math| average | value1 | value2 | ... }}
+
        local parent = frame:getParent();
−
OR
+
        Argumentos = parent.args;
−
{{#invoke:Math| average }}
+
    end  
−
 
+
   
−
Note, any values that do not evaluate to numbers are ignored.
+
    local i = 1;
−
]]
+
    while Argumentos[i] ~= nil do
−
 
+
      if Argumentos[i] ~= '' then
−
function wrap.average(args)
+
    resultado = resultado + Argumentos[i]
−
return p._average(unpackNumberArgs(args))
+
  end
−
end
+
 
−
 
+
  i = i + 1;
−
function p._average(...)
+
    end
−
local sum, count = fold((function(a, b) return a + b end), ...)
+
 
−
if not sum then
+
    return resultado
−
return 0
 
−
else
 
−
return sum / count
 
−
end
 
 
end
 
end
  
Línea 333: Línea 247:
 
round
 
round
  
−
Rounds a number to specified precision
+
Redondea un número a la precisión especificada
−
 
 
−
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 }}
 
  
 +
Uso:
 +
    {{#invoke:Math | round | <valor> | <precisión> }}
 +
   
 
--]]
 
--]]
−
 
+
function z.round(frame)
−
function wrap.mod(args)
+
    local value, precision;
−
local x = p._cleanNumber(args[1])
+
   
−
local y = p._cleanNumber(args[2])
+
    value = z._cleanNumber( frame, frame.args[1] or frame.args.value or 0 );
−
if not x then
+
    precision = z._cleanNumber( frame, frame.args[2] or frame.args.precision or 0 );
−
return err('first argument to mod appears non-numeric')
+
   
−
elseif not y then
+
    if value == nil or precision == nil then
−
return err('second argument to mod appears non-numeric')
+
        return '<strong class="error"><small>Error de formato: Los valores han de ser numéricos</small></strong>'
−
else
+
    else
−
return p._mod(x, y)
+
        return z._round( value, precision );
−
end
+
    end  
 
end
 
end
−
 
+
function z._round( value, precision )
−
function p._mod(x, y)
+
    local rescale = math.pow( 10, precision );
−
local ret = x % y
+
    return math.floor( value * rescale + 0.5 ) / rescale;
−
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
 
end
  
Línea 431: Línea 273:
 
precision_format
 
precision_format
  
−
Rounds a number to the specified precision and formats according to rules
+
Redondea un número a la precisión especificada y le da formato de acuerdo con las normas
−
originally used for {{template:Rnd}}. Output is a string.
+
originalmente utilizado para {{Plantilla: Rnd}}. La salida es una cadena.
−
 
+
Uso:
−
Usage:
+
    {{#invoke: Math | precision_format | <número> | <precisión> }}
−
{{#invoke: Math | precision_format | number | precision }}
 
 
]]
 
]]
 +
function z.precision_format( frame )
 +
    -- Para acceder a Mediawiki incorporando formateador.
 +
    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 );
 +
   
 +
    -- Comprueba una entrada no numérica
 +
    if value == nil or precision == nil then
 +
        return '<strong class="error"><small>Error de formato: Datos no válidos para redondear</small></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
+
    -- Debido a los efectos de redondeo, es necesario limitar la precisión devuelta bajo
−
return p._precision_format(value_string, precision)
+
    -- algunas circunstancias, debido a que sobre los dígitos terminales se informó incorrectamente.
−
end
+
    if order + precision >= 14 then
−
 
+
        orig_precision = z._precision( value_string );
−
function p._precision_format(value_string, precision)
+
        if order + orig_precision >= 14 then
−
-- For access to Mediawiki built-in formatter.
+
            precision = 13 - order;       
−
local lang = mw.getContentLanguage();
+
        end       
 +
    end
  
−
local value
+
    -- Si el redondeo, trunca dígitos adicionales
−
value, value_string = p._cleanNumber(value_string)
+
    if precision < current_precision then
−
precision = p._cleanNumber(precision)
+
        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 * 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 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);
  
−
-- Check for non-numeric input
+
                padding = precision;
−
if value == nil or precision == nil then
+
                if padding > 20 then
−
return err('invalid input when rounding')
+
                    padding = 20;
−
end
+
                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
  
−
local current_precision = p._precision(value)
+
    -- Añade notación exponencial, si es necesario
−
local order = p._order(value)
+
    if order ~= 0 then
−
 
+
        -- Utiliza el signo menos unario apropiado antes que el ASCII por defecto
−
-- Due to round-off effects it is neccesary to limit the returned precision under
+
        if order < 0 then
−
-- some circumstances because the terminal digits will be inaccurately reported.
+
            order = '−' .. lang:formatNum( math.abs(order) );
−
if order + precision >= 14 then
+
        else
−
if order + p._precision(value_string) >= 14 then
+
            order = lang:formatNum( order );
−
precision = 13 - order;
+
        end  
−
end
+
       
−
end
+
        formatted_num = formatted_num .. '<span style="margin:0 .15em 0 .25em">×</span>10<sup>' .. order .. '</sup>'
−
 
+
    end
−
-- If rounding off, truncate extra digits
+
   
−
if precision < current_precision then
+
    return formatted_num;
−
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
  
 
--[[
 
--[[
−
Helper function that interprets the input numerically. If the
+
Función de ayuda que interpreta la entrada numérica.  
−
input does not appear to be a number, attempts evaluating it as
+
Si la entrada no es un número, lo intenta evaluar como
−
a parser functions expression.
+
un «parser function» (Analizador sintáctico).
 
]]
 
]]
  
−
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.
+
    -- Intenta la conversión básica
−
return nil, nil;
+
    local number = tonumber( number_string )
−
end
+
   
−
 
+
    -- Si falla, trata de evaluar la entrada como expresión
−
-- 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
+
    -- La cadena es válida pero puede contener relleno, límpiela.
−
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)
 

Ten en cuenta que todas las contribuciones a Diccionario Interactivo Ceán Bermúdez se consideran publicadas bajo la <a href="https://creativecommons.org/licenses/by-sa/3.0/" target="_blank">Creative Commons Attribution-ShareAlike License</a> (véase MyWiki:Derechos de autor para más información). Si no deseas que las modifiquen sin limitaciones y las distribuyan libremente, no las publiques aquí.
Al mismo tiempo, asumimos que eres el autor de lo que escribiste, o lo copiaste de una fuente en el dominio público o con licencia libre. ¡No uses textos con copyright sin permiso!

Cancelar Ayuda de edición (se abre en una ventana nueva)

Plantilla usada en esta página:

Obtenido de «https://ceanbermudez.es/wiki/Módulo:Math»