Module:Math - Revision history

TheWaffleLord: Protected "Module:Math": Important page ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

2023-09-15T03:33:52Z

Protected "Module:Math": Important page ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))

← Older revision	Revision as of 03:33, 15 September 2023
(No difference)

imported>Primefac: typo fix

2021-03-11T22:23:48Z

typo fix

← Older revision		Revision as of 22:23, 11 March 2021
Line 540:		Line 540:

	Usage:		Usage:
	{{#invoke:~~PassMath~~ \| divide \| x \| y \| round= \| precision= }}		{{#invoke:Math \| divide \| x \| y \| round= \| precision= }}

	--]]		--]]

imported>Primefac: update from sandbox following merge with Module:PassMath (FPER)

2021-03-11T18:09:12Z

update from sandbox following merge with Module:PassMath (FPER)

← Older revision		Revision as of 18:09, 11 March 2021
Line 532:		Line 532:

	return formatted_num		return formatted_num
			end

			--[[
			divide

			Implements the division operator

			Usage:
			{{#invoke:PassMath \| divide \| x \| y \| round= \| precision= }}

			--]]
			function wrap.divide(args)
			local x = args[1]
			local y = args[2]
			local round = args.round
			local precision = args.precision
			if not yesno then
			yesno = require('Module:Yesno')
			end
			return p._divide(x, y, yesno(round), precision)
			end

			function p._divide(x, y, round, precision)
			if y == nil or y == "" then
			return err("Empty divisor")
			elseif not tonumber(y) then
			if type(y) == 'string' and string.sub(y, 1, 1) == '<' then
			return y
			else
			return err("Not a number: " .. y)
			end
			elseif x == nil or x == "" then
			return err("Empty dividend")
			elseif not tonumber(x) then
			if type(x) == 'string' and string.sub(x, 1, 1) == '<' then
			return x
			else
			return err("Not a number: " .. x)
			end
			else
			local z = x / y
			if round then
			return p._round(z, 0)
			elseif precision then
			return p._round(z, precision)
			else
			return z
			end
			end
	end		end

imported>Johnuniq: clean whitespace; remove unintended global orig_precision which gives errors when used with a module that invokes Module:No globals such as 1994–95 Yemeni League

2019-09-14T01:55:35Z

clean whitespace; remove unintended global orig_precision which gives errors when used with a module that invokes Module:No globals such as 1994–95 Yemeni League

← Older revision		Revision as of 01:55, 14 September 2019
Line 52:		Line 52:
	-- Use a function on all supplied arguments, and return the result. The function must accept two numbers as parameters,		-- 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.		-- and must return a number as an output. This number is then supplied as input to the next function call.
	local vals = makeArgArray(...)		local vals = makeArgArray(...)
	local count = #vals -- The number of valid arguments		local count = #vals -- The number of valid arguments
	if count == 0 then return		if count == 0 then return
	-- Exit if we have no valid args, otherwise removing the first arg would cause an error.		-- Exit if we have no valid args, otherwise removing the first arg would cause an error.
	nil, 0		nil, 0
	end		end
	local ret = table.remove(vals, 1)		local ret = table.remove(vals, 1)
	for _, val in ipairs(vals) do		for _, val in ipairs(vals) do
Line 120:		Line 120:
	else		else
	return p._order(input_number)		return p._order(input_number)
	end		end
	end		end

Line 154:		Line 154:
	return math.log10(denom_value);		return math.log10(denom_value);
	end		end
	end		end
	end		end
	end		end

	input_number, input_string = p._cleanNumber(input_string);		input_number, input_string = p._cleanNumber(input_string);
Line 163:		Line 163:
	else		else
	return p._precision(input_string)		return p._precision(input_string)
	end		end
	end		end

Line 180:		Line 180:
	x = string.sub(x, 1, exponent_pos - 1)		x = string.sub(x, 1, exponent_pos - 1)
	result = result - tonumber(exponent)		result = result - tonumber(exponent)
	end		end

	if decimal ~= nil then		if decimal ~= nil then
Line 238:		Line 238:

	function p._median(...)		function p._median(...)
	local vals = makeArgArray(...)		local vals = makeArgArray(...)
	local count = #vals		local count = #vals
	table.sort(vals)		table.sort(vals)

	if count == 0 then		if count == 0 then
	return 0		return 0
	end		end

	if p._mod(count, 2) == 0 then		if p._mod(count, 2) == 0 then
	return (vals[count/2] + vals[count/2+1])/2		return (vals[count/2] + vals[count/2+1])/2
Line 254:		Line 254:

	--[[		--[[
	min		min

	Finds the minimum argument		Finds the minimum argument
Line 279:		Line 279:

	--[[		--[[
	sum		sum

	Finds the sum		Finds the sum
Line 305:		Line 305:

	--[[		--[[
	average		average

	Finds the average		Finds the average
Line 347:		Line 347:
	else		else
	return p._round(value, precision)		return p._round(value, precision)
	end		end
	end		end

Line 387:		Line 387:
	else		else
	return p._mod(x, y)		return p._mod(x, y)
	end		end
	end		end

Line 431:		Line 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.

Line 463:		Line 463:
	-- 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 =~~ p._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

Line 473:		Line 472:
	value = p._round(value, precision)		value = p._round(value, precision)
	current_precision = p._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))
Line 483:		Line 482:
	else		else
	sign = ''		sign = ''
	end		end

	-- Handle cases requiring scientific notation		-- Handle cases requiring scientific notation
Line 492:		Line 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
Line 510:		Line 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
Line 527:		Line 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>'
Line 536:		Line 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.

imported>Primefac: fix calculation

2018-09-30T23:27:34Z

fix calculation

← Older revision		Revision as of 23:27, 30 September 2018
Line 249:		Line 249:
	return (vals[count/2] + vals[count/2+1])/2		return (vals[count/2] + vals[count/2+1])/2
	else		else
	return vals[count/2+1]		return vals[math.ceil(count/2)]
	end		end
	end		end

imported>Primefac: error handling for count

2018-09-30T23:23:35Z

error handling for count

← Older revision		Revision as of 23:23, 30 September 2018
Line 241:		Line 241:
	local count = #vals		local count = #vals
	table.sort(vals)		table.sort(vals)

			if count == 0 then
			return 0
			end

	if p._mod(count, 2) == 0 then		if p._mod(count, 2) == 0 then

imported>Primefac: better median handling

2018-09-30T23:21:27Z

better median handling

← Older revision		Revision as of 23:21, 30 September 2018
Line 234:		Line 234:

	function wrap.median(args)		function wrap.median(args)
	return p._median(args)		return p._median(unpackNumberArgs(args))
	end		end

	function p._median(~~args~~)		function p._median(...)
	local vals = {}		local vals = makeArgArray(...)
	~~local count = 0~~		local count = #vals
	~~for k,v in pairs~~(~~args) do~~		table.sort(vals)
	~~if v == string~~.~~match(v,'(%d+)') then~~
	~~table~~.~~insert(vals,v~~)		if p._mod(count, 2) == 0 then
	count = ~~count+1~~
	~~end~~
	~~end~~
	table.sort(vals~~,function(a,b~~) ~~return tonumber(a) < tonumber(b) end) -- force number sort~~
	if ~~count/2 == math~~.~~ceil~~(count/2) then
	return (vals[count/2] + vals[count/2+1])/2		return (vals[count/2] + vals[count/2+1])/2
	else		else
	return vals[~~math.ceil(~~count/2)];		return vals[count/2+1]
	end		end
	end		end

imported>Primefac: implementing pseudo-TPER to add "median" - see Special:PermaLink/861908321#Module:Average

2018-09-30T22:14:07Z

implementing pseudo-TPER to add "median" - see Special:PermaLink/861908321#Module:Average

@@ Line 219: / Line 219: @@
 	if max_value then
 		return max_value
 	end
 end

imported>Primefac: fix typo

2018-09-30T21:54:56Z

fix typo

← Older revision		Revision as of 21:54, 30 September 2018
Line 330:		Line 330:

	Usage:		Usage:
	{{#invoke:Math \| ~~log~~ \| x }}		{{#invoke:Math \| log10 \| x }}
	]]		]]

imported>Primefac: add "sum" per merge with Module:Sum

2018-09-30T21:27:53Z

add "sum" per merge with Module:Sum

@@ Line 244: / Line 244: @@
 	if min_value then
 		return min_value
 	end
 end