Module:Format
La documentation pour ce module peut être créée à Module:Format/doc
-- Module dédié au formatage de texte
local fun = {}
-- Mise en forme des nombres
-- Mime le comportement du mot magique formatnum, sans paramètre R
function fun.formatnum(frame)
return fun.do_formatnum(frame:getParent().args)
end
function fun.do_formatnum(arguments)
local number = arguments[1]
-- Retourne une chaîne vide si le paramètre est absent ou vide
if not number or number == "" then
return ""
end
-- Si la string n'est pas une représentation valide d'un nombre, on la retourne telle quelle
if not tonumber(number) then
return number
end
-- Extraction des parties du nombre
local start, _, minus, intPart, point, fracPart = number:find("^([^0-9.]?)0*(%d*)(%.?)(%d*)$")
-- Le parsage échoue avec par exemple les notations scientifiques : "1e+16"
if not start then
return number
end
local result = ""
-- Signe moins
result = result .. minus
-- Partie entière
if #intPart > 0 then
local index = #intPart
for digit in intPart:gfind("%d") do
result = result .. digit
-- Espace insécable tous les trois chiffres
if index % 3 == 1 and index > 1 then
result = result .. "\194\160"
end
index = index - 1
end
else
-- Ajout d'un zéro si la partie décimale est vide
result = result .. "0"
end
-- Virgule
if point ~= "" then
result = result .. ","
end
-- Partie fractionnaire
result = result .. fracPart
return result
end
-- Mise en forme des nombres avec unité
-- Basé sur Modèle:Unité, mais sans limitation de nombre d'arguments
function fun.unite(frame)
return fun.do_unite(frame:getParent().args)
end
-- Réalisation de la fonction précédente
function fun.do_unite(arguments)
local result = ""
-- Formatage de la valeur principale
if arguments[1] ~= nil then
result = fun.do_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
local 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)
return fun.do_expo(frame:getParent().args)
end
-- Réalisation de la fonction précédente
function fun.do_expo(arguments)
local 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)
return fun.do_x10(frame:getParent().args)
end
-- Réalisation de la fonction précédente
function fun.do_x10(arguments)
local 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)
return fun.do_parsec(frame:getParent().args)
end
-- Réalisation de la fonction précédente
function fun.do_parsec(arguments)
local result = ""
-- Unités disponibles
local units = {
pc = {"[[parsec|pc]]", [false] = {1, ""}, [true] = {1, ""}},
kpc = {"[[Kiloparsec|kpc]]", [false] = {1000, ""}, [true] = {0.001, "million"}},
mpc = {"[[Mégaparsec|Mpc]]", [false] = {1, "million"}, [true] = {0.001, "milliard"}},
gpc = {"[[Gigaparsec|Gpc]]", [false] = {1, "milliard"}, [true] = {1, "milliard"}}
}
-- Valeur principale
local resultVal = fun.do_formatnum{(arguments[1] or "")}
-- Unité utilisée
local unitData = (units[arguments[2]] or units.pc)
if arguments.marge ~= nil or arguments.sup ~= nil then
-- Marge éventuelle
if arguments.marge ~= nil then
local resultMarge = "" ;
if tonumber(arguments.marge) ~= nil then
resultMarge = "<small>±" .. arguments.marge .. "</small>"
else
resultMarge = arguments.marge
end
resultVal = resultVal .. resultMarge
end
-- Deuxième valeur éventuelle
if arguments.sup ~= nil then
resultVal = resultVal .. " à " .. arguments.sup
end
else
-- "Environ" si c'est une valeur brute seule
result = result .. "environ "
end
-- Affichage de la valeur
result = result .. fun.do_unite{resultVal,unitData[1]} .. " "
-- Affichage de la conversion en années-lumière
local numVal = tonumber(arguments[1])
if numVal ~= nil then
-- On utilise un autre ordre de grandeur si la valeur est trop grande
local isBigVal = (numVal*3.2616 >= 1000)
-- Valeur en années-lumière
local alVal = numVal*unitData[isBigVal][1]*3.2616
-- Première valeur
result = result .. "(∼" .. fun.do_formatnum{fun.do_chiffresSignificatifs{alVal,3}} .. " "
if arguments.sup ~= nil and tonumber(arguments.sup) ~= nil then
-- Deuxième valeur éventuelle
alVal = tonumber(arguments.sup)*unitData[isBigVal][1]*3.2616
result = result .. "à " .. fun.do_formatnum{fun.do_chiffresSignificatifs{alVal,3}} .. " "
end
-- La dernière valeur affichée (alVal) entraîne-t-elle un pluriel ?
local unitFull = ""
if unitData[isBigVal][2] ~= "" then -- Il faut avoir un mot à mettre au pluriel
if alVal >= 1.995 then
unitFull = "s"
end
unitFull = unitData[isBigVal][2] .. unitFull .. " d'"
end
-- Affichage de l'unité
result = result .. unitFull .. "[[Année-lumière|a.l.]])" ;
end
return result
end
-- Affichage d'un nombre avec chiffres significatifs
function fun.chiffresSignificatifs(frame)
return fun.do_chiffresSignificatifs(frame:getParent().args)
end
-- Réalisation de la fonction précédente
-- Attention, renvoie une chaîne
-- Usage : fun.do_chiffresSignificatifs{valeur, nb de chiffres significatifs}
function fun.do_chiffresSignificatifs(arguments)
local result = ""
local value, digits = tonumber(arguments[1]), tonumber(arguments[2])
if value ~= nil and digits ~= nil then
local logVal = math.ceil(math.log10(value))
local mult = 10^(digits-logVal)
local rounded = math.floor(value*mult+0.5)/mult
result = string.format("%." .. tostring(math.max(digits-logVal,0)) .. "f", rounded)
end
return result
end
-- Ajoute des hyperliens aux mots séparés par des virgules, comme ceux des propriétés Wikidata
function fun.ajouterLiens(frame)
local arguments = frame:getParent().args
local mots = mw.text.split(arguments[2], ",")
local liens = table.concat(mots, "]], [[")
if liens ~= nil and liens ~= "" then
return "[[" .. liens .. "]]"
else
return ""
end
end
return fun