"Module:Math" səhifəsinin versiyaları arasındakı fərqlər

Şəki Ensiklopediyası saytından
Jump to navigation Jump to search
(Səhifəni '--This module provides a number of basic mathematical operations. local z = {} -- Generate random number function z.random( frame ) first = tonumber(frame.arg...' ilə yarat)
 
 
Sətir 4: Sətir 4:
  
 
]]
 
]]
local z = {}
 
  
-- Generate random number
+
local yesno, getArgs -- lazily initialized
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])
 
  
    if first then -- if NaN or nil, will skip down to final return
+
local p = {} -- Holds functions to be returned from #invoke, and functions to make available to other Lua modules.
        if first <= second then -- could match if both nil, but already checked that first is a number in last line
+
local wrap = {} -- Holds wrapper functions that process arguments from #invoke. These act as intemediary between functions meant for #invoke and functions meant for Lua.
            return math.random(first, second)
+
 
        end
+
--[[
        return math.random(first)
+
Helper functions used to avoid redundant code.
    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
  
Sətir 26: Sətir 110:
  
 
Usage:
 
Usage:
    {{#invoke: Math | order | value }}
+
{{#invoke: Math | order | value }}
 
]]
 
]]
function z.order(frame)
+
 
    local input_string = (frame.args[1] or frame.args.x or '0');
+
function wrap.order(args)
    local input_number;
+
local input_string = (args[1] or args.x or '0');
   
+
local input_number = p._cleanNumber(input_string);
    input_number = z._cleanNumber( frame, input_string );
+
if input_number == nil then
    if input_number == nil then
+
return err('order of magnitude input appears non-numeric')
        return '<strong class="error">Məlumat formatı səhvi: onluq dərəcəni təyin edərkən rəqəm olmayan giriş dəyəri</strong>'
+
else
    else
+
return p._order(input_number)
        return z._order( input_number )
+
end
    end  
 
 
end
 
end
function z._order(x)
+
 
    if x == 0 then return 0 end
+
function p._order(x)
    return math.floor(math.log10(math.abs(x)))
+
if x == 0 then return 0 end
 +
return math.floor(math.log10(math.abs(x)))
 
end
 
end
  
Sətir 50: Sətir 134:
  
 
Usage:
 
Usage:
    {{ #invoke: Math | precision | value }}
+
{{ #invoke: Math | precision | value }}
 
]]
 
]]
function z.precision( frame )
+
 
    local input_string = (frame.args[1] or frame.args.x or '0');
+
function wrap.precision(args)
    local trap_fraction = frame.args.check_fraction or false;
+
local input_string = (args[1] or args.x or '0');
    local input_number;
+
local trap_fraction = args.check_fraction;
   
+
local input_number;
    if type( trap_fraction ) == 'string' then
+
 
        trap_fraction = trap_fraction:lower();
+
if not yesno then
        if trap_fraction == 'false' or trap_fraction == '0' or
+
yesno = require('Module:Yesno')
                trap_fraction == 'no' or trap_fraction == '' then
+
end
            trap_fraction = false;
+
if yesno(trap_fraction, true) then -- Returns true for all input except nil, false, "no", "n", "0" and a few others. See [[Module:Yesno]].
        else
+
local pos = string.find(input_string, '/', 1, true);
            trap_fraction = true;
+
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);
   
+
local denom_value = tonumber(denominator);
    if trap_fraction then
+
if denom_value ~= nil then
        local pos = string.find( input_string, '/', 1, true );
+
return math.log10(denom_value);
        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 );
+
end
                if denom_value ~= nil then
+
 
                    return math.log10(denom_value);
+
input_number, input_string = p._cleanNumber(input_string);
                end
+
if input_string == nil then
            end                      
+
return err('precision input appears non-numeric')
        end
+
else
    end  
+
return p._precision(input_string)
   
+
end
    input_number, input_string = z._cleanNumber( frame, input_string );
 
    if input_string == nil then
 
        return '<strong class="error">Məlumat formatında səhv: kəsrli hissəni müəyyən edərkən rəqəm olmayan giriş dəyəri</strong>'
 
    else
 
        return z._precision( input_string )
 
    end  
 
 
end
 
end
function z._precision( x )   
 
    x = string.upper( x )
 
  
    local decimal = string.find( x, '[.,]', 1 )
+
function p._precision(x)
    local exponent_pos = string.find( x, 'E', 1, true )
+
if type(x) == 'number' then
    local result = 0;
+
x = tostring(x)
   
+
end
    if exponent_pos ~= nil then
+
x = string.upper(x)
        local exponent = string.sub( x, exponent_pos + 1 )
+
 
        x = string.sub( x, 1, exponent_pos - 1 )
+
local decimal = x:find('%.')
        result = result - tonumber( exponent )
+
local exponent_pos = x:find('E')
    end  
+
local result = 0;
   
+
 
    if decimal ~= nil then
+
if exponent_pos ~= nil then
        result = result + string.len( x ) - decimal
+
local exponent = string.sub(x, exponent_pos + 1)
        return result
+
x = string.sub(x, 1, exponent_pos - 1)
    end
+
result = result - tonumber(exponent)
       
+
end
    local pos = string.len( x );
+
 
    while x:byte(pos) == string.byte('0') do
+
if decimal ~= nil then
        pos = pos - 1
+
result = result + string.len(x) - decimal
        result = result - 1
+
return result
        if pos <= 0 then
+
end
            return 0
+
 
        end
+
local pos = string.len(x);
    end
+
while x:byte(pos) == string.byte('0') do
   
+
pos = pos - 1
    return result
+
result = result - 1
 +
if pos <= 0 then
 +
return 0
 +
end
 +
end
 +
 
 +
return result
 
end
 
end
 +
  
 
--[[
 
--[[
Sətir 123: Sətir 206:
  
 
Usage:
 
Usage:
    {{#invoke:Math| max | value1 | value2 | ... }}
+
{{#invoke:Math| max | value1 | value2 | ... }}
 +
 
 +
Note, any values that do not evaluate to numbers are ignored.
 +
]]
 +
 
 +
function wrap.max(args)
 +
return p._max(unpackNumberArgs(args))
 +
end
 +
 
 +
function p._max(...)
 +
local max_value = binary_fold((function(a, b) return a > b end), ...)
 +
if max_value then
 +
return max_value
 +
end
 +
end
 +
 
 +
--[[
 +
median
 +
 
 +
Find the median of set of numbers
 +
 
 +
Usage:
 +
{{#invoke:Math | median | number1 | number2 | ...}}
 
OR
 
OR
    {{#invoke:Math| max }}
+
{{#invoke:Math | median }}
 +
]]
 +
 
 +
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
 
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.max( frame )
+
 
    local args = frame.args;
+
function wrap.min(args)
   
+
return p._min(unpackNumberArgs(args))
    if args[1] == nil then
+
end
        local parent = frame:getParent();
+
 
        args = parent.args;
+
function p._min(...)
    end
+
local min_value = binary_fold((function(a, b) return a < b end), ...)
    local max_value = nil;
+
if min_value then
   
+
return min_value
    local i = 1;
+
end
    while args[i] ~= nil do
+
end
        local val = z._cleanNumber( frame, args[i] );
+
 
        if val ~= nil then
+
--[[
            if max_value == nil or val > max_value then
+
sum
                max_value = val;
+
 
            end
+
Finds the sum
        end      
+
 
        i = i + 1;
+
Usage:
    end
+
{{#invoke:Math| sum | value1 | value2 | ... }}
 
+
OR
    return max_value
+
{{#invoke:Math| sum }}
 +
 
 +
Note, any values that do not evaluate to numbers are ignored.
 +
]]
 +
 
 +
function wrap.sum(args)
 +
return p._sum(unpackNumberArgs(args))
 +
end
 +
 
 +
function p._sum(...)
 +
local sums, count = fold((function(a, b) return a + b end), ...)
 +
if not sums then
 +
return 0
 +
else
 +
return sums
 +
end
 
end
 
end
  
 
--[[
 
--[[
min
+
average
  
Finds the minimum argument
+
Finds the average
  
 
Usage:
 
Usage:
    {{#invoke:Math| min | value1 | value2 | ... }}
+
{{#invoke:Math| average | value1 | value2 | ... }}
 
OR
 
OR
    {{#invoke:Math| min }}
+
{{#invoke:Math| average }}
  
When used with no arguments, it takes its input from the parent
+
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 )
+
 
    local args = frame.args;
+
function wrap.average(args)
   
+
return p._average(unpackNumberArgs(args))
    if args[1] == nil then
+
end
        local parent = frame:getParent();
+
 
        args = parent.args;
+
function p._average(...)
    end
+
local sum, count = fold((function(a, b) return a + b end), ...)
    local min_value = nil;
+
if not sum then
   
+
return 0
    local i = 1;
+
else
    while args[i] ~= nil do
+
return sum / count
        local val = z._cleanNumber( frame, args[i] );
+
end
        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
  
Sətir 195: Sətir 336:
  
 
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
 +
 
 +
--[[
 +
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 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)
+
 
    local value, precision;
+
function wrap.gcd(args)
   
+
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">Məlumat formatında səhv: Tam ədədə yuvarlaqlaşdırarkən rəqəm olmayan giriş dəyəri</strong>'
 
    else
 
        return z._round( value, precision );
 
    end   
 
 
end
 
end
function z._round( value, precision )
+
 
    local rescale = math.pow( 10, precision );
+
function p._gcd(...)
    return math.floor( value * rescale + 0.5 ) / rescale;
+
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
  
Sətir 218: Sətir 431:
 
precision_format
 
precision_format
  
Rounds a number to the specified precision and formats according to rules  
+
Rounds a number to the specified precision and formats according to rules
 
originally used for {{template:Rnd}}.  Output is a string.
 
originally used for {{template:Rnd}}.  Output is a string.
  
Sətir 225: Sətir 438:
 
]]
 
]]
  
function z.precision_format(args)
+
function wrap.precision_format(args)
 
local value_string = args[1] or 0
 
local value_string = args[1] or 0
 
local precision = args[2] or 0
 
local precision = args[2] or 0
return z._precision_format(value_string, precision)
+
return p._precision_format(value_string, precision)
 
end
 
end
  
function z._precision_format(value_string, precision)
+
function p._precision_format(value_string, precision)
 
-- For access to Mediawiki built-in formatter.
 
-- For access to Mediawiki built-in formatter.
 
local lang = mw.getContentLanguage();
 
local lang = mw.getContentLanguage();
  
 
local value
 
local value
value, value_string = z._cleanNumber(value_string)
+
value, value_string = p._cleanNumber(value_string)
precision = z._cleanNumber(precision)
+
precision = p._cleanNumber(precision)
  
 
-- Check for non-numeric input
 
-- Check for non-numeric input
 
if value == nil or precision == nil then
 
if value == nil or precision == nil then
return '<strong class="error">Məlumat formatında səhv: müəyyən bir doğruluqda yuvarlaqlaşdırarkən rəqəm olayan giriş dəyəri</strong>'
+
return err('invalid input when rounding')
 
end
 
end
  
local current_precision = z._precision(value)
+
local current_precision = p._precision(value)
+
local order = p._order(value)
local order = z._order(value)
 
  
 
-- Due to round-off effects it is neccesary to limit the returned precision under
 
-- Due to round-off effects it is neccesary to limit the returned precision under
 
-- some circumstances because the terminal digits will be inaccurately reported.
 
-- some circumstances because the terminal digits will be inaccurately reported.
 
if order + precision >= 14 then
 
if order + precision >= 14 then
orig_precision = z._precision(value_string)
+
if order + p._precision(value_string) >= 14 then
if order + orig_precision >= 14 then
+
precision = 13 - order;
precision = 13 - order;      
+
end
end      
 
 
end
 
end
  
 
-- If rounding off, truncate extra digits
 
-- If rounding off, truncate extra digits
 
if precision < current_precision then
 
if precision < current_precision then
value = z._round(value, precision)
+
value = p._round(value, precision)
current_precision = z._precision(value)
+
current_precision = p._precision(value)
end  
+
end
  
 
local formatted_num = lang:formatNum(math.abs(value))
 
local formatted_num = lang:formatNum(math.abs(value))
Sətir 271: Sətir 482:
 
else
 
else
 
sign = ''
 
sign = ''
end  
+
end
  
 
-- Handle cases requiring scientific notation
 
-- Handle cases requiring scientific notation
Sətir 280: Sətir 491:
 
formatted_num = lang:formatNum(math.abs(value))
 
formatted_num = lang:formatNum(math.abs(value))
 
else
 
else
order = 0;      
+
order = 0;
 
end
 
end
 
formatted_num = sign .. formatted_num
 
formatted_num = sign .. formatted_num
  
-- Pad with zeros, if needed  
+
-- Pad with zeros, if needed
 
if current_precision < precision then
 
if current_precision < precision then
 
local padding
 
local padding
Sətir 298: Sətir 509:
  
 
formatted_num = formatted_num .. string.rep('0', padding)
 
formatted_num = formatted_num .. string.rep('0', padding)
end          
+
end
else                  
+
else
 
padding = precision - current_precision
 
padding = precision - current_precision
 
if padding > 20 then
 
if padding > 20 then
Sətir 315: Sətir 526:
 
else
 
else
 
order = lang:formatNum(order)
 
order = lang:formatNum(order)
end  
+
end
  
 
formatted_num = formatted_num .. '<span style="margin:0 .15em 0 .25em">×</span>10<sup>' .. order .. '</sup>'
 
formatted_num = formatted_num .. '<span style="margin:0 .15em 0 .25em">×</span>10<sup>' .. order .. '</sup>'
Sətir 324: Sətir 535:
  
 
--[[
 
--[[
Helper function that interprets the input numerically.  If the  
+
Helper function that interprets the input numerically.  If the
 
input does not appear to be a number, attempts evaluating it as
 
input does not appear to be a number, attempts evaluating it as
 
a parser functions expression.
 
a parser functions expression.
 
]]
 
]]
  
function z._cleanNumber( frame, number_string )
+
function p._cleanNumber(number_string)
    if number_string == nil or number_string:len() == 0 then
+
if type(number_string) == 'number' then
        return nil, nil;
+
-- We were passed a number, so we don't need to do any processing.
    end   
+
return number_string, tostring(number_string)
   
+
elseif type(number_string) ~= 'string' or not number_string:find('%S') then
    -- Attempt basic conversion
+
-- We were passed a non-string or a blank string, so exit.
    local number = tonumber( number_string )
+
return nil, nil;
   
+
end
    -- If failed, attempt to evaluate input as an expression
+
 
    if number == nil then       
+
-- Attempt basic conversion
        local attempt = frame:callParserFunction( '#expr', number_string );
+
local number = tonumber(number_string)
        attempt = tonumber( attempt );
 
        if attempt ~= nil then
 
            number = attempt;
 
            number_string = tostring( number );
 
        else
 
            number = nil;
 
            number_string = nil;
 
        end
 
    else
 
    -- String is valid but may contain padding, clean it.
 
        number_string = mw.text.trim(number_string)
 
    end
 
   
 
    return number, number_string;
 
end
 
  
local function roman(i)
+
-- If failed, attempt to evaluate input as an expression
    local w, t, val, let = {}, {
+
if number == nil then
        {1000, "M"},
+
local success, result = pcall(mw.ext.ParserFunctions.expr, number_string)
        {900, "CM"},
+
if success then
        {500, "D"},
+
number = tonumber(result)
        {400, "CD"},
+
number_string = tostring(number)
        {100, "C"},
+
else
        {90, "XC"},
+
number = nil
        {50, "L"},
+
number_string = nil
        {40, "XL"},
 
        {10, "X"},
 
        {9, "IX"},
 
        {5, "V"},
 
        {4, "IV"},
 
        {1, "I"}
 
    }
 
    for n, v in ipairs(t) do
 
        val, let = unpack(v)
 
        w[n]=string.rep(let,i/val)
 
        i=i % val
 
    end
 
    return table.concat(w)
 
end
 
 
function z.Roman(frame) -- Преобразует числа от 1 до 4999999 в римские
 
local function try_tonumber(a)
 
    return math.floor(tonumber(a) or error('\''.. a ..'\' не является числом.'));
 
end
 
local str =  frame.args[1] or '';
 
if str == '' then -- boş parametr
 
return str;
 
end
 
local r, N = pcall(try_tonumber, str); -- попытка преобразовать в число
 
if r then
 
    if N<1 or N>=5e6 then
 
return frame.args[2] or 'N/A'
 
 
end
 
end
    local R=N%5000
 
    N=(N-R)/1000
 
    return (N>0 and table.concat{'<span style="text-decoration:overline;">',roman(N),'</span>'} or '')..roman(R)
 
 
else
 
else
return '<strong class="error">' .. N .. '</strong>'; -- вывод ошибки
+
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
 
end
 +
 +
return number, number_string
 
end
 
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.
 
]]
 
]]
function z.Azerbaijani(frame)
 
local str = frame.args[1] or '';
 
if str == '' then
 
return '';
 
end
 
local number = tonumber( str, 10 )
 
 
local lang = mw.getLanguage( 'az' )
 
 
local zero = 'sıfır'
 
local ones = { 'bir', 'iki', 'üç', 'dörd', 'beş', 'altı',
 
'yeddi', 'səkkiz', 'doqquz', 'on', 'on bir', 'on iki',
 
'on üç', 'on dörd', 'on beş', 'on altı', 'on yeddi',
 
'on səkkiz', 'on doqquz' }
 
local tens = { '', 'iyirmi', 'otuz', 'qırx', 'əlli',
 
'altmış', 'yetmiş', 'səksən', 'doxsan' }
 
local hundreds = { 'yüz', 'iki yüz', 'üç yüz', 'dörd yüz', 'beş yüz',
 
'altı yüz', 'yeddi yüz', 'səkkiz yüz', 'doqquz yüz' }
 
 
local unitsPlural = {
 
{ '', '', '' },
 
{ 'min', 'minlərlə', 'min' },
 
{ 'milyon', 'milyon', 'milyonlarla' },
 
{ 'milyard', 'milyard', 'milyardlarla' },
 
{ 'trilyon', 'trilyon', 'trilyonlarla' },
 
}
 
 
local out = ''
 
local outMinus = ''
 
 
if ( number < 0 ) then
 
outMinus = 'mənfi'
 
number = math.abs( number )
 
end
 
 
local tripletPos = 0
 
while ( number > 0 ) do
 
local triplet = number % 1000
 
number = math.floor( number / 1000 )
 
  
tripletPos = tripletPos + 1
+
local mt = { __index = function(t, k)
if ( tripletPos > 5 ) then
+
return function(frame)
return ''
+
if not getArgs then
 +
getArgs = require('Module:Arguments').getArgs
 
end
 
end
 
+
return wrap[k](getArgs(frame)) -- Argument processing is left to Module:Arguments. Whitespace is trimmed and blank arguments are removed.
local tripletStr = ''
 
local tripletUnit = ''
 
if ( triplet > 0 ) then
 
local unitPlural = unitsPlural[ tripletPos ]
 
tripletUnit = lang:plural( triplet, unitPlural[1], unitPlural[2], unitPlural[3] )
 
end
 
 
 
if ( triplet >= 100 ) then
 
tripletStr = hundreds[ math.floor( triplet / 100 ) ]
 
triplet = triplet % 100
 
end
 
 
 
if ( triplet >= 20 ) then
 
tripletStr = tripletStr .. ' ' .. tens[ math.floor( triplet / 10 ) ]
 
triplet = triplet % 10
 
end
 
 
 
if ( triplet >= 1 ) then
 
tripletStr = tripletStr .. ' ' .. ones[ triplet ]
 
end
 
 
-- две тысячи
 
if ( tripletPos == 2 ) then
 
tripletStr = mw.ustring.gsub( tripletStr, 'один$', 'одна' )
 
tripletStr = mw.ustring.gsub( tripletStr, 'два$', 'две' )
 
end
 
 
out = tripletStr .. ' ' .. tripletUnit .. ' ' .. out
 
 
end
 
end
 +
end }
  
if ( out == '' ) then
+
return setmetatable(p, mt)
out = zero
 
end
 
 
 
out = outMinus .. out
 
out = mw.ustring.gsub( out, ' +', ' ' )
 
out = mw.text.trim ( out )
 
return out
 
end
 
 
 
return z
 

Səhifəsinin 01:10, 12 oktyabr 2019 tarixinə olan son halı

Documentation for this module may be created at Module:Math/doc

--[[

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)
	if x == 0 then return 0 end
	return math.floor(math.log10(math.abs(x)))
end

--[[
precision

Detemines the precision of a number using the string representation

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

function wrap.precision(args)
	local input_string = (args[1] or args.x or '0');
	local trap_fraction = args.check_fraction;
	local input_number;

	if not yesno then
		yesno = require('Module:Yesno')
	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 = p._cleanNumber(input_string);
	if input_string == nil then
		return err('precision input appears non-numeric')
	else
		return p._precision(input_string)
	end
end

function p._precision(x)
	if type(x) == 'number' then
		x = tostring(x)
	end
	x = string.upper(x)

	local decimal = x:find('%.')
	local exponent_pos = x:find('E')
	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
end


--[[
max

Finds the maximum argument

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

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

function wrap.max(args)
	return p._max(unpackNumberArgs(args))
end

function p._max(...)
	local max_value = binary_fold((function(a, b) return a > b end), ...)
	if max_value then
		return max_value
	end
end

--[[
median

Find the median of set of numbers

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

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

--[[
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.
]]

function wrap.sum(args)
	return p._sum(unpackNumberArgs(args))
end

function p._sum(...)
	local sums, count = fold((function(a, b) return a + b end), ...)
	if not sums then
		return 0
	else
		return sums
	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.
]]

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

--[[
round

Rounds a number 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)
	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 }}

--]]

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 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

--[[
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 }}
]]

function wrap.precision_format(args)
	local value_string = args[1] or 0
	local precision = args[2] or 0
	return p._precision_format(value_string, precision)
end

function p._precision_format(value_string, precision)
	-- For access to Mediawiki built-in formatter.
	local lang = mw.getContentLanguage();

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

	-- Check for non-numeric input
	if value == nil or precision == nil then
		return err('invalid input when rounding')
	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

	-- 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

--[[
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.
]]

function p._cleanNumber(number_string)
	if type(number_string) == '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:find('%S') then
		-- We were passed a non-string or a blank string, so exit.
		return nil, nil;
	end

	-- Attempt basic conversion
	local number = tonumber(number_string)

	-- If failed, attempt to evaluate input as an expression
	if number == nil then
		local success, result = pcall(mw.ext.ParserFunctions.expr, number_string)
		if success then
			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("^%+(.*)$") 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
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.
]]

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)