モジュール:Utility/Scale - 版の履歴

Mntone: ticks算出のロジックを再改善

2021-09-02T03:33:51Z

ticks算出のロジックを再改善

@@ 17行目: / 17行目: @@
 local eps = 2.2204460492503131e-16
 function math.isSame(a, b)
 	local diff = math.abs(a - b)
@@ 26行目: / 25行目: @@
 	else
 		return diff <= eps * aa
 	end
 end
@@ 206行目: / 163行目: @@
 		local r0 = math.floor(start / step + 0.5)
 		local r1 = math.floor(stop  / step + 0.5)
-		if math.isSameOrLess(r0 * step, start) then
+		local r0s = r0 * step
 			r0 = r0 + 1
 		end
-		if math.isSameOrGreater(r1 * step, stop) then
+		if r1s > stop  or math.isSame(r1s, stop) then
 			r1 = r1 - 1
 		end
@@ 221行目: / 180行目: @@
 		local r0 = math.floor(start * step + 0.5)
 		local r1 = math.floor(stop  * step + 0.5)
-		if math.isSameOrLess(r0 / step, start) then
+		local r0s = r0 / step
 			r0 = r0 + 1
 		end
-		if math.isSameOrGreater(r1 / step, stop) then
+		if r1s > stop  or math.isSame(r1s, stop) then
 			r1 = r1 - 1
 		end

Mntone: ticks算出のロジックを改善（LogScaleでdomainとticksに重複する値が発生する不具合の修正）

2021-09-02T02:26:44Z

ticks算出のロジックを改善（LogScaleでdomainとticksに重複する値が発生する不具合の修正）

@@ 14行目: / 14行目: @@
 function math.log10(x)
 	return math.log(x) * log10e
 end
@@ 149行目: / 204行目: @@
 	local ticks = {}
 	if step > 0 then
-		local r0 = math.floor(start / step)
+		local r0 = math.floor(start / step + 0.5)
-		local r1 = math.ceil (stop  / step)
+		local r1 = math.floor(stop  / step + 0.5)
-		if r0 * step <= start then
+		if math.isSameOrLess(r0 * step, start) then
 			r0 = r0 + 1
 		end
-		if r1 * step >= stop then
+		if math.isSameOrGreater(r1 * step, stop) then
 			r1 = r1 - 1
 		end
@@ 164行目: / 219行目: @@
 		step = -step
-		local r0 = math.ceil (start * step)
+		local r0 = math.floor(start * step + 0.5)
-		local r1 = math.floor(stop  * step)
+		local r1 = math.floor(stop  * step + 0.5)
-		if r0 / step <= start then
+		if math.isSameOrLess(r0 / step, start) then
 			r0 = r0 + 1
 		end
-		if r1 / step >= stop then
+		if math.isSameOrGreater(r1 / step, stop) then
 			r1 = r1 - 1
 		end

Mntone: typenameが正しく指定されていなかった問題の修正

2021-09-02T00:43:42Z

typenameが正しく指定されていなかった問題の修正

← 古い版		2021年9月2日 (木) 09:43時点における版
198行目:		198行目:

	-- [Constructor]		-- [Constructor]
	function __Scale__Continuous.__new(domain, transform, untransform)		function __Scale__Continuous.__new(typename, domain, transform, untransform)
	local obj = {		local obj = {
	typename = ~~__Scale__ContinuousType~~,		typename = typename,
	domain = domain,		domain = domain,
	range = { 0, 100 },		range = { 0, 100 },
320行目:		320行目:
	-- [Constructor]		-- [Constructor]
	function __Scale__Linear.new()		function __Scale__Linear.new()
	local obj = __Scale__Continuous.__new(unit, identity, identity)		local obj = __Scale__Continuous.__new(__Scale__LinearType, unit, identity, identity)
	return setmetatable(obj, { __index = __Scale__Linear })		return setmetatable(obj, { __index = __Scale__Linear })
	end		end
456行目:		456行目:
	-- [Constructor]		-- [Constructor]
	function __Scale__Log.new()		function __Scale__Log.new()
	local obj = __Scale__Continuous.__new(logUnit, math.log, math.exp)		local obj = __Scale__Continuous.__new(__Scale__LogType, logUnit, math.log, math.exp)
	obj.__base___rescale = obj._rescale		obj.__base___rescale = obj._rescale
	obj.base = 10		obj.base = 10

Mntone: LogScaleの追加

2021-09-02T00:34:29Z

LogScaleの追加

差分を表示

Mntone: ticksを取得するための関数を追加

2021-08-20T22:10:04Z

ticksを取得するための関数を追加

@@ 2行目: / 2行目: @@
 local table       = require('Module:TableExtensions')
 function math.isNaN(v)
 	--return tostring(v) == '-nan'
@@ 124行目: / 129行目: @@
 		return -(10 ^ -power) / nice
 	end
 end
@@ 247行目: / 305行目: @@
 	local obj = __Scale__Continuous.__new(identity, identity)
 	return setmetatable(obj, { __index = __Scale__Linear })
 end

Mntone: 関数名を table.mapValue から table.MapValues に変更による改変

2021-08-20T21:44:20Z

関数名を table.mapValue から table.MapValues に変更による改変

← 古い版		2021年8月21日 (土) 06:44時点における版
163行目:		163行目:
	end		end

	self.domain = table.~~mapValue~~(newDomain, asNumber)		self.domain = table.mapValues(newDomain, asNumber)
	self:_rescale()		self:_rescale()
	return self		return self
213行目:		213行目:
	if not self._output then		if not self._output then
	self._output = self._piecewise(		self._output = self._piecewise(
	table.~~mapValue~~(self.domain, self._transform),		table.mapValues(self.domain, self._transform),
	self.range,		self.range,
	self._interpolate)		self._interpolate)
228行目:		228行目:
	self._input = self._piecewise(		self._input = self._piecewise(
	self.range,		self.range,
	table.~~mapValue~~(self.domain, self._transform),		table.mapValues(self.domain, self._transform),
	interpolateValue)		interpolateValue)
	end		end

Mntone: clampの設定に対応

2021-08-20T09:20:40Z

clampの設定に対応

← 古い版		2021年8月20日 (金) 18:20時点における版
176行目:		176行目:

	self.range = table.map(newRange, asNumber)		self.range = table.map(newRange, asNumber)
			self:_rescale()
			return self
			end

			-- [Property] Set clamp
			function __Scale__Continuous:setClamp(newClamp)
			libraryUtil.checkType('setClamp', 1, newClamp, 'boolean')

			self._clamp = newClamp or identity
	self:_rescale()		self:_rescale()
	return self		return self
184行目:		193行目:
	local n = math.min(#self.domain, #self.range)		local n = math.min(#self.domain, #self.range)
	if self._clamp ~= identity then		if self._clamp ~= identity then
	self._clamp = clamper(self.domain[0], self.domain[n ~~- 1~~])		self._clamp = clamper(self.domain[1], self.domain[n])
	end		end
	if n > 2 then		if n > 2 then
261行目:		270行目:
	self.domain[i0] = start		self.domain[i0] = start
	self.domain[i1] = stop		self.domain[i1] = stop
			self:_rescale()
	break		break
	elseif step > 0 then		elseif step > 0 then

Mntone: ページの作成:「local libraryUtil = require('libraryUtil') local table = require('Module:TableExtensions') function math.isNaN(v) --return tostring(v) == '-nan' return v ~= v en…」

2021-08-20T08:38:58Z

ページの作成:「local libraryUtil = require('libraryUtil') local table = require('Module:TableExtensions') function math.isNaN(v) --return tostring(v) == '-nan' return v ~= v en…」

新規ページ

local libraryUtil = require('libraryUtil')
local table = require('Module:TableExtensions')

function math.isNaN(v)
--return tostring(v) == '-nan'
return v ~= v
end
local log10e = 1 / math.log(10)
function math.log10(x)
return math.log(x) * log10e
end

-- ============
-- Define utils
-- ============
local unit = { 0, 1 }
local function identity(num)
return num
end

-- function: asNumber - as number if possible
local function asNumber(value)
local typename = type(value)
if typename == 'number' then
return value
elseif typename == 'string' then
return tonumber(value)
else
error('The "value" type must be "number" or "string".')
end
end

-- function: constant
local function constant(num)
return function()
return num
end
end

-- function: normalize
local function normalize(a, b)
b = b - a
if math.isNaN(b) then
return constant(b)
elseif b == 0 then
return constant(0.5)
else
return function(x)
return (x - a) / b
end
end
end

-- function: interpolateValue
local function interpolateValue(a, b)
return function(t)
return a + (b - a) * t
end
end

-- function: clamper - generate clamp function
local function clamper(a, b)
if a > b then
a, b = b, a
end
return function(x)
return math.max(a, math.min(b, x))
end
end

-- function: bimap
local function bimap(domain, range, interpolate)
local d1 = domain[1]
local d2 = domain[2]
local r1 = range[1]
local r2 = range[2]
if d2 < d1 then
d1 = normalize(d2, d1)
r1 = interpolate(r2, r1)
else
d1 = normalize(d1, d2)
r1 = interpolate(r1, r2)
end
return function(x)
return r1(d1(x))
end
end

-- function: tickIncrement
local e10 = math.sqrt(50)
local e5 = math.sqrt(10)
local e2h = math.sqrt(5)
local e2 = math.sqrt(2)
local function tickIncrement(start, stop, count)
local step = (stop - start) / math.max(0, count)
local power = math.floor(math.log10(step))
local error = step / (10 ^ power)
local nice
if power >= 0 then
if error >= e10 then
nice = 10
elseif error >= e5 then
nice = 5
elseif error >= e2h then
nice = 2.5
elseif error >= e2 then
nice = 2
else
nice = 1
end
return nice * (10 ^ power)
else
if error >= e10 then
nice = 10
elseif error >= e5 then
nice = 5
elseif error >= e2h then
nice = 2.5
elseif error >= e2 then
nice = 2
else
nice = 1
end
return -(10 ^ -power) / nice
end
end

-- ================
-- namespace: scale
-- ================
local scale = {}

-- ================
-- type: Continuous
-- ================
local __Scale__ContinuousType = 'continuous'
local __Scale__Continuous = {
__typename = __Scale__ContinuousType,
}

-- [Constructor]
function __Scale__Continuous.__new(transform, untransform)
local obj = {
typename = __Scale__ContinuousType,
domain = unit,
range = { 0, 100 },
_clamp = identity,
_piecewise = bimap,
_interpolate = interpolateValue,
_transform = transform,
_untransform = untransform,
_input = nil,
_output = nil,
}
return setmetatable(obj, { __index = __Scale__Continuous })
end

-- [Property] Set domain
function __Scale__Continuous:setDomain(newDomain)
libraryUtil.checkType('setDomain', 1, newDomain, 'table')
if #newDomain < 2 then
error('The "domain" table size must be at least 2.')
end

self.domain = table.mapValue(newDomain, asNumber)
self:_rescale()
return self
end

-- [Property] Set range
function __Scale__Continuous:setRange(newRange)
libraryUtil.checkType('setRange', 1, newRange, 'table')
if #newRange < 2 then
error('The "range" table size must be at least 2.')
end

self.range = table.map(newRange, asNumber)
self:_rescale()
return self
end

-- [Function] Rescale
function __Scale__Continuous:_rescale()
local n = math.min(#self.domain, #self.range)
if self._clamp ~= identity then
self._clamp = clamper(self.domain[0], self.domain[n - 1])
end
if n > 2 then
error('The multiple values of the domain aren\'t currently supported.')
else
self._piecewise = bimap
end
self._input = nil
self._output = nil
end

-- [Function] Scale
function __Scale__Continuous:scale(x)
libraryUtil.checkType('scale', 1, x, 'number')

if math.isNaN(x) then
return nil
else
if not self._output then
self._output = self._piecewise(
table.mapValue(self.domain, self._transform),
self.range,
self._interpolate)
end
return self._output(self._transform(self._clamp(x)))
end
end

-- [Function] Invert
function __Scale__Continuous:invert(y)
libraryUtil.checkType('invert', 1, y, 'number')

if not self._input then
self._input = self._piecewise(
self.range,
table.mapValue(self.domain, self._transform),
interpolateValue)
end
return self._clamp(self._untransform(self._input(y)))
end

-- =============================
-- type: LinearScale: Continuous
-- =============================
local __Scale__LinearType = 'linear'
local __Scale__Linear = {
__typename = __Scale__LinearType,
}
setmetatable(__Scale__Linear, { __index = __Scale__Continuous })

-- [Constructor]
function __Scale__Linear.new()
local obj = __Scale__Continuous.__new(identity, identity)
return setmetatable(obj, { __index = __Scale__Linear })
end

-- [Function] Nice
function __Scale__Linear:nice(count)
libraryUtil.checkType('nice', 1, count, 'number', true)
count = count or 10

local i0 = 1
local i1 = #self.domain
local start = self.domain[i0]
local stop = self.domain[i1]
if start > stop then
start, stop = stop, start
i0, i1 = i1, i0
end

local prestep, step
local maxIter = 5
while maxIter > 0 do
step = tickIncrement(start, stop, count)
if step == prestep then
self.domain[i0] = start
self.domain[i1] = stop
break
elseif step > 0 then
start = math.floor(start / step) * step
stop = math.ceil (stop / step) * step
elseif step < 0 then
start = math.ceil (start * step) / step
stop = math.floor(stop * step) / step
else
break
end

prestep = step
maxIter = maxIter - 1
end
return self
end

-- [Export]
scale.LinearScale = __Scale__Linear

return scale