Modulo:Gapnum

Dokumentasion ti modulo

[kitaen] [urnosen] [pakasaritaan] [purgaen]

Daytoy a modulo ket inus-usar babaen ti {{val}}.

Panagusar para kadagiti sabali a modulo

gaps

Ti annong ti gaps ket mabalin a naserbi para kadagiti panagpormat kadagiti sabali a modulo nga mabalin kadagiti panangiparang kadagiti dakkel abilang.

local gaps = require('Modulo:Gapnum').gaps

Ti panagusar ti annong ti gaps function, ti umuna nga argumento ket ti pormaten a bilang. Ti maikadua nga argumento ket mabalin a tabla nga agraman kadagiti tekla a mangibaga iti modulo no kasano a mangpormat. Dagiti tabla ti tekla a mabalin a mausar ket ti:

• gap - ti bilang nga agraman kadagiti yunit ti CSS (px, em, en, kdpy) a mangipalawag ti kadakkel ti baetan dagiti bilang. No blanko, ti modulo ket agusar iti 0.25em.
• prec - ti bilang a mangikeddeng ti presision iti parte ti desimal ti bilang. No ti presision ket basbassit ngem ti bilang dagiti digit, dagiti sobra a digiti ket maikatto nga awanan iti pannagipabukel; no ad-adu, mainayonto dagiti sero iti gibus tapno agpartuat iti kayat a presision. No blanko, ti modulo ket agusar iti -1, a ti kayatna asawen ket ti presision ket kapadanto ti naited a bilang; awan dagiti mainayon wenno maikkat a digit.

Laglagipen a ti maisubli nga insasao ket tabla. Ti kayatna a sawen daytoy ket adoadunto ti estilo ken teksto ti mabalin a mainayon iti pangbalkot ng aetiketa ti span, ngem balinna pay a kayat a sawen a ti tostring() ket mabalin a masapul no mausar kadagiti sabali a modulo.

local gaps = require('Modulo:Gapnum').gaps

function example()
	local n = 123456.78900011
	-- Example for just simple formatting of a number
	-- n_gaps will use the default, .25em gaps and no change in precision
	-- The result will have its gaps created with inline css
	-- But the result would look like:
	-- 123 456.789 000 11
	local n_gaps = gaps(n)

	-- Different gap size
	-- These will format n into the same groups as above
	-- But the spaces between the groups will be larger and smaller, respectively
	local n_big_gaps = gaps(n, {gap='1em'})
	local n_small_gaps = gaps(n, {gap='1px'})

	-- Different precision
	-- n_prec_5 will use the number 123456.78900
	-- The result would look like:
	-- 123 456.789 00
	local n_prec_5 = gaps(n, {prec=5})
	-- n_prec_10 will use the number 123456.7890001100
	-- The result would look like:
	-- 123 456.789 000 1100
	local n_prec_10 = gaps(n, {prec=10})

	-- Both different gaps and precision can be used:
	local n_big_5 = gaps(n, {gap='1em', prec=5})
	local n_small_10 = gaps(n, {gap='1px', prec=10})
end

groups

Ti annong ti groups ket mabalin a mausar kadagiti sabali a modulo tapno maisina ti maysa a bilang kadagitigrupo a kas ti aramiden ti gaps, ngem imbes a ti napormat a string, ti annong key mangisubli kadagiti tabla na dagiti elementoda ket dagiti naisina a grupo.

local groups = require('Modulo:Gapnum').groups

function example()
	-- This will return one table:
	-- {123,456}
	local n1 = groups(123456)

	-- This will return two tables, each assigned to a different variable:
	-- n2a will be:
	-- {1,234}
	-- n2b will be:
	-- {567,89}
	local n2a,n2b = groups(1234.56789)

	-- This will return two tables:
	-- An integer part is always returned, even if it is 0
	-- n3a will be:
	-- {0}
	-- n3b will be:
	-- {123,4567}
	local n3a,n3b = groups(0.1234567)

	-- Just like the other functions, a precision can be defined
	-- precision is simply the second parameter
	-- n4a will be:
	-- {123}
	-- n4b will be:
	-- {456,700,00}
	local n4a,n4b = groups(123.4567,8)
end

Ti dokumentasion dita ngato ket nailak-am manipud iti Modulo:Gapnum/dok. (urnosen | pakasaritaan)
Mabalin dagiti editor ti agipadas kadagiti panid ti pagipadasan (agpartuat | kapada) ken pangsubok a kaskaso (agpartuat) iti daytoy a modulo.
Pangngaasi nga ikabil dagiti kategoria iti subpanid ti /dok. Dagiti subpanid daytoy a modulo.

local p = {}

local getArgs

function p.main(frame)
	if not getArgs then
		getArgs = require('Modulo:Dagiti argumento').getArgs
	end

	local args = getArgs(frame, {wrappers = 'Plantilia:Gapnum'})
	local n = args[1]

	if not n then
		error('Nasken to parametro ti parametro 1')
	elseif not tonumber(n) and not tonumber(n, 36) then -- Validates any number with base ≤ 36
		error('Di maipagbaliwen ti "' .. args[1] .. '" iti bilang')
	end

	local gap = args.gap
	local precision = tonumber(args.prec)

	return p.gaps(n,{gap=gap,prec=precision})
end

-- Not named p._main so that it has a better function name when required by Module:Val
function p.gaps(n,tbl)
	local nstr = tostring(n)
	if not tbl then
		tbl = {}
	end
	local gap = tbl.gap or '.25em'

	local int_part, frac_part = p.groups(n,tbl.prec)

	local ret = mw.html.create('span')
							:css('white-space','nowrap')
							-- No gap necessary on first group
							:wikitext(table.remove(int_part,1))

	-- Build int part
	for _, v in ipairs(int_part) do
		ret:tag('span')
				:css('margin-left',gap)
				:wikitext(v)
	end

	if frac_part then
		-- The first group after the decimal shouldn't have a gap
		ret:wikitext('.' .. table.remove(frac_part,1))
		-- Build frac part
		for _, v in ipairs(frac_part) do
			ret:tag('span')
					:css('margin-left',gap)
					:wikitext(v)
		end
	end

	return ret
end

-- Creates tables where each element is a different group of the number
function p.groups(num,precision)
	local nstr = tostring(num)
	if not precision then
		precision = -1
	end

	local decimalloc = nstr:find('.', 1, true)
	local int_part, frac_part
	if decimalloc == nil then
		int_part = nstr
	else
		int_part = nstr:sub(1, decimalloc-1)
		frac_part = nstr:sub(decimalloc + 1)
	end
	-- only define ret_i as an empty table, let ret_d stay nil
	local ret_i,ret_d = {}
	-- Loop to handle most of the groupings; from right to left, so that if a group has less than 3 members, it will be the first group
	while int_part:len() > 3 do
		-- Insert in first spot, since we're moving backwards
		table.insert(ret_i,1,int_part:sub(-3))
		int_part = int_part:sub(1,-4)
	end
	-- handle any left over numbers
	if int_part:len() > 0 then
		table.insert(ret_i,1,int_part)
	end

	if precision ~= 0 and frac_part then
		ret_d = {}
		if precision == -1 then
			precision = frac_part:len()
		end
		-- Reduce the length of the string if required precision is less than actual precision
		-- OR
		-- Increase it (by adding 0s) if the required precision is more than actual
		local offset = precision - frac_part:len()
		if offset < 0 then
			frac_part = frac_part:sub(1,precision)
		elseif offset > 0 then
			frac_part = frac_part .. string.rep('0', offset)
		end

		-- Allow groups of 3 or 2 (3 first)
		for v in string.gmatch(frac_part,'%d%d%d?') do
			table.insert(ret_d,v)
		end
		-- Preference for groups of 4 instead of groups of 1 at the end
		if #frac_part % 3 == 1 then
			if frac_part:len() == 1 then
				ret_d = {frac_part}
			else
				local last_g = ret_d[#ret_d] or ''
				last_g = last_g..frac_part:sub(-1)
				ret_d[#ret_d] = last_g
			end
		end
	end

	return ret_i,ret_d
end

return p