Module:Format

 Documentation[créer] [purger]

La documentation de ce module est générée par le modèle {{Documentation module}}.
Les éditeurs peuvent travailler dans le bac à sable (créer).
Voir les statistiques d'appel depuis le wikicode sur l'outil wstat et les appels depuis d'autres modules.

-- Module dédié au formatage de texte

local fun = {}

-- Mise en forme des nombres avec unité
-- Basé sur Modèle:Unité, mais sans limitation de nombre d'arguments
function fun.unite(frame)
    local pframe = frame:getParent()
    local arguments = pframe.args
    return frame:preprocess(fun.do_unite(arguments))
end

-- Réalisation de la fonction précédente
function fun.do_unite(arguments)
    result = ""
    
    -- Formatage de la valeur principale
    if(arguments[1] ~= nil) then
        result = "{{formatnum:" .. arguments[1] .. "}}"
    end
    
    -- Formatage de la puissance de 10 éventuelle
    if(arguments.e ~= nil) then
        result = result .. fun.do_x10{arguments.e}
    end
    
    -- Parcours des unités et exposants
    index = 2
    while(arguments[index] ~= nil) do
        if (index == 2) then
            -- Première unité : espace insécable
            result = result .. " "
        else
            -- Unités suivantes : point médian
            result = result .. "⋅"
        end
        
        -- Affichage de l'unité
        result = result .. arguments[index]
        
        -- Exposant éventuel
        if(arguments[index+1] ~= nil) then
            result = result .. fun.do_expo{arguments[index+1]}
        end
        
        index = index + 2
    end
    
    -- Non-retour à la ligne
    result = "<span class=\"nowrap\">" .. result .. "</span>"
    
    return result
end

-- Mise en forme des exposants
-- Basé sur Modèle:Exp
function fun.expo(frame)
    local pframe = frame:getParent()
    local arguments = pframe.args
    return fun.do_expo(arguments)    
end

-- Réalisation de la fonction précédente
function fun.do_expo(arguments)
    result = ""
    if(arguments[1] ~= nil) then
        result = result .. arguments[1]
    end
    result = "<sup>" .. result .. "</sup>"
    
    return result
end

-- Mise en forme des puissances de 10
-- Basé sur Modèle:x10
function fun.x10(frame)
    local pframe = frame:getParent()
    local arguments = pframe.args
    return fun.do_x10(arguments)    
end

-- Réalisation de la fonction précédente
function fun.do_x10(arguments)
    result = "×10" .. fun.do_expo{arguments[1]}
    return result
end

-- Affichage d'une valeur en parsecs
-- Basé sur Modèle:Parsec
function fun.parsec(frame)
    local pframe = frame:getParent()
    local arguments = pframe.args
    return frame:preprocess(fun.do_parsec(arguments))    
end

-- Réalisation de la fonction précédente
function fun.do_parsec(arguments)
    result = ""
        
    -- Unités disponibles
    units = {
        pc = {"[[parsec|pc]]", [false] = {1, ""}, [true] = {1, ""}},
        kpc = {"[[Kiloparsec|kpc]]", [false] = {1000, ""}, [true] = {0.001, "millions d'"}},
        mpc = {"[[Mégaparsec|Mpc]]", [false] = {1, "millions d'"}, [true] = {0.001, "milliards d'"}},
        gpc = {"[[Gigaparsec|Gpc]]", [false] = {1, "milliards d'"}, [true] = {1, "milliards d'"}}
    }
    
    -- Valeur principale
    resultVal = (arguments[1] or "")
    
    -- Unité utilisée
    unitData = (units[arguments[2]] or units.pc)
    
    if(arguments.marge ~= nil or arguments.sup ~= nil) then
        if(arguments.marge ~= nil) then
            if(tonumber(arguments.marge) ~= nil) then
                resultMarge = "<small>&plusmn;" .. arguments.marge .. "</small>"
            else
                resultMarge = arguments.marge
            end
            resultVal = resultVal .. resultMarge
        end
        
        if(arguments.sup ~= nil) then
            resultVal = resultVal .. " à&nbsp;" .. arguments.sup
        end
    else
        result = result .. "environ&nbsp;"
    end
    -- Affichage de la valeur
    result = result .. fun.do_unite{resultVal,unitData[1]} .. " "
    
    -- Affichage de la conversion en années-lumière
    numVal = tonumber(arguments[1])
    if(numVal ~= nil) then
        bigVal = (numVal*3.2616 >= 1000)
        coeff = unitData[bigVal][1]
        result = result .. "({{formatnum:" .. fun.do_chiffresSignificatifs{numVal*coeff*3.2616,3} .. "}}&nbsp;"
        if(arguments.sup ~= nil and tonumber(arguments.sup) ~= nil) then
            result = result .. "à&nbsp;{{formatnum:" .. fun.do_chiffresSignificatifs{tonumber(arguments.sup)*coeff*3.2616,3} .. "}}&nbsp;"
        end
        result = result .. unitData[bigVal][2] .. "[[Année-lumière|a.l.]])" ;
    end
    
    return result
end

-- Affichage d'un nombre avec chiffres significatifs
function fun.chiffresSignificatifs(frame)
    local pframe = frame:getParent()
    local arguments = pframe.args
    return fun.do_chiffresSignificatifs(arguments)  
end

function fun.do_chiffresSignificatifs(arguments)
    result = ""
    value, digits = tonumber(arguments[1]), tonumber(arguments[2])
    if(value ~= nil and digits ~= nil) then
        logVal = math.ceil(math.log10(value))
        mult = 10^(digits-logVal)
        rounded = math.floor(value*mult+0.5)/mult
        result = string.format("%." .. tostring(math.max(digit-logVal,0)) .. "f", rounded)
    end
    return result
end

return fun