Module:Set - Revision history

Andrybak: Reverted to revision 994891575 by Awesome Aasim (talk)

2021-01-23T09:48:08Z

Reverted to revision 994891575 by Awesome Aasim (talk)

← Previous revision		Revision as of 09:48, 23 January 2021
Line 1:		Line 1:
	--[[		--[[
	------------------------------------------------------------------------------------		------------------------------------------------------------------------------------
	-- Set --		-- Set --

Cupper52: Test

2021-01-08T13:07:21Z

Test

← Previous revision		Revision as of 13:07, 8 January 2021
Line 1:		Line 1:
	--[[		--[[
	------------------------------------------------------------------------------------		------------------------------------------------------------------------------------
	-- Set --		-- Set --

Awesome Aasim: Reverted edits by Awesome Aasim (talk) to last version by Mr. Stradivarius

2020-12-18T02:11:17Z

Reverted edits by Awesome Aasim (talk) to last version by Mr. Stradivarius

← Previous revision		Revision as of 02:11, 18 December 2020
Line 1:		Line 1:
	require('Module:Module wikitext')._addText([[{{db-repost\|xfd=Wikipedia:Templates_for_discussion/Log/2020_June_22#Module:Set\|help=off}}]]);
	--[[		--[[
	------------------------------------------------------------------------------------		------------------------------------------------------------------------------------

Awesome Aasim: Requesting speedy deletion (CSD G4).

2020-12-18T02:09:58Z

Requesting speedy deletion (CSD G4).

← Previous revision		Revision as of 02:09, 18 December 2020
Line 1:		Line 1:
			require('Module:Module wikitext')._addText([[{{db-repost\|xfd=Wikipedia:Templates_for_discussion/Log/2020_June_22#Module:Set\|help=off}}]]);
	--[[		--[[
	------------------------------------------------------------------------------------		------------------------------------------------------------------------------------

Mr. Stradivarius: fix duplicate bugs in valueIntersection and valueComplement, as well as a bad variable name in valueIntersection that no-one had discovered up until now

2015-06-26T06:36:44Z

fix duplicate bugs in valueIntersection and valueComplement, as well as a bad variable name in valueIntersection that no-one had discovered up until now

← Previous revision		Revision as of 06:36, 26 June 2015
Line 15:		Line 15:

	local p = {}		local p = {}

			--[[
			------------------------------------------------------------------------------------
			-- Helper functions
			------------------------------------------------------------------------------------
			--]]

			-- Makes a set from a table's values. Returns an array of all values with
			-- duplicates removed.
			local function makeValueSet(t)
			local isNan = tableTools.isNan
			local ret, exists = {}, {}
			for k, v in pairs(t) do
			if isNan(v) then
			-- NaNs are always unique, and they can't be table keys, so don't
			-- check for existence.
		⚫	ret[#ret + 1] = v
			elseif not exists[v] then
			exists[v] = true
			ret[#ret + 1] = v
		⚫	end
			end
			return ret
			end

	--[[		--[[
Line 137:		Line 161:
	------------------------------------------------------------------------------------		------------------------------------------------------------------------------------
	--]]		--]]

	function p.valueIntersection(...)		function p.valueIntersection(...)
	local lim = select('#', ...)		local lim = select('#', ...)
Line 153:		Line 178:
	end		end
	tableTemp = t		tableTemp = t
			t = makeValueSet(t) -- Remove duplicates
	for k, v in pairs(t) do		for k, v in pairs(t) do
	-- NaNs are never equal to any other value, so they can't be in the intersection.		-- NaNs are never equal to any other value, so they can't be in the intersection.
Line 165:		Line 191:
	-- If all the tables are equal, then the intersection is that table (including NaNs).		-- If all the tables are equal, then the intersection is that table (including NaNs).
	-- All we need to do is convert it to an array and remove duplicate values.		-- All we need to do is convert it to an array and remove duplicate values.
	~~for~~ ~~k, v in pairs~~(tableTemp) do		return makeValueSet(tableTemp)
⚫	ret[#ret + 1] = v
⚫	end
	return p.removeDuplicates(ret)
	end		end
	for val, count in pairs(vals) do		for val, count in pairs(vals) do
Line 232:		Line 255:
	local t = select(i, ...)		local t = select(i, ...)
	checkType('valueComplement', i, t, 'table')		checkType('valueComplement', i, t, 'table')
			t = makeValueSet(t) -- Remove duplicates
	for k, v in pairs(t) do		for k, v in pairs(t) do
	if not isNan(v) then		if not isNan(v) then
Line 241:		Line 265:
	local tn = select(lim, ...)		local tn = select(lim, ...)
	checkType('valueComplement', lim, tn, 'table')		checkType('valueComplement', lim, tn, 'table')
			tn = makeValueSet(tn) -- Remove duplicates
	for k, v in pairs(tn) do		for k, v in pairs(tn) do
	if isNan(v) or exists[v] == nil then		if isNan(v) or exists[v] == nil then

Mr. Stradivarius: use the TableTools shallowClone function

2013-12-20T05:37:42Z

use the TableTools shallowClone function

← Previous revision		Revision as of 05:37, 20 December 2013
Line 199:		Line 199:
	local tn = select(lim, ...)		local tn = select(lim, ...)
	checkType('complement', lim, tn, 'table')		checkType('complement', lim, tn, 'table')
	local ret = p.shallowClone(tn)		local ret = tableTools.shallowClone(tn)
	-- Remove all the key/value pairs in t1, t2, ..., tn-1.		-- Remove all the key/value pairs in t1, t2, ..., tn-1.
	for i = 1, lim - 1 do		for i = 1, lim - 1 do

Mr. Stradivarius: get the isNan function

2013-12-20T05:36:48Z

get the isNan function

← Previous revision		Revision as of 05:36, 20 December 2013
Line 9:		Line 9:
	--]]		--]]

			-- Get necessary libraries and functions
	local libraryUtil = require('libraryUtil')		local libraryUtil = require('libraryUtil')
	local checkType = libraryUtil.checkType		local checkType = libraryUtil.checkType
			local tableTools = require('Module:TableTools')

	local p = {}		local p = {}
Line 74:		Line 76:
	error("too few arguments to 'valueUnion' (minimum is 2, received " .. lim .. ')', 2)		error("too few arguments to 'valueUnion' (minimum is 2, received " .. lim .. ')', 2)
	end		end
	local isNan = p.isNan		local isNan = tableTools.isNan
	local ret, exists = {}, {}		local ret, exists = {}, {}
	for i = 1, lim do		for i = 1, lim do
Line 140:		Line 142:
	error("too few arguments to 'valueIntersection' (minimum is 2, received " .. lim .. ')', 2)		error("too few arguments to 'valueIntersection' (minimum is 2, received " .. lim .. ')', 2)
	end		end
	local isNan = p.isNan		local isNan = tableTools.isNan
	local vals, ret = {}, {}		local vals, ret = {}, {}
	local isSameTable = true -- Tracks table equality.		local isSameTable = true -- Tracks table equality.
Line 225:		Line 227:
	error("too few arguments to 'valueComplement' (minimum is 2, received " .. lim .. ')', 2)		error("too few arguments to 'valueComplement' (minimum is 2, received " .. lim .. ')', 2)
	end		end
	local isNan = p.isNan		local isNan = tableTools.isNan
	local ret, exists = {}, {}		local ret, exists = {}, {}
	for i = 1, lim - 1 do		for i = 1, lim - 1 do

Mr. Stradivarius: get the checkType function from libraryUtil

2013-12-20T05:34:04Z

get the checkType function from libraryUtil

← Previous revision		Revision as of 05:34, 20 December 2013
Line 8:		Line 8:
	------------------------------------------------------------------------------------		------------------------------------------------------------------------------------
	--]]		--]]

			local libraryUtil = require('libraryUtil')
			local checkType = libraryUtil.checkType

	local p = {}		local p = {}

Mr. Stradivarius: add p table

2013-12-20T05:32:45Z

add p table

← Previous revision		Revision as of 05:32, 20 December 2013
Line 8:		Line 8:
	------------------------------------------------------------------------------------		------------------------------------------------------------------------------------
	--]]		--]]

			local p = {}

	--[[		--[[
Line 290:		Line 292:
	end		end
	--]]		--]]

			return p

Mr. Stradivarius: split functions from Module:TableTools - the set functions were taking up most of the space there

2013-12-20T05:23:06Z

split functions from Module:TableTools - the set functions were taking up most of the space there

New page

--[[
------------------------------------------------------------------------------------
-- Set --
-- --
-- This module includes a number of set operations for dealing with Lua tables. --
-- It currently has union, intersection and complement functions for both --
-- key/value pairs and for values only. --
------------------------------------------------------------------------------------
--]]

--[[
------------------------------------------------------------------------------------
-- union
--
-- This returns the union of the key/value pairs of n tables. If any of the tables
-- contain different values for the same table key, the table value is converted
-- to an array holding all of the different values.
------------------------------------------------------------------------------------
--]]
function p.union(...)
local lim = select('#', ...)
if lim < 2 then
error("too few arguments to 'union' (minimum is 2, received " .. lim .. ')', 2)
end
local ret, trackArrays = {}, {}
for i = 1, lim do
local t = select(i, ...)
checkType('union', i, t, 'table')
for k, v in pairs(t) do
local retKey = ret[k]
if retKey == nil then
ret[k] = v
elseif retKey ~= v then
if trackArrays[k] then
local array = ret[k]
local valExists
for _, arrayVal in ipairs(array) do
if arrayVal == v then
valExists = true
break
end
end
if not valExists then
array[#array + 1] = v
ret[k] = array
end
else
ret[k] = {ret[k], v}
trackArrays[k] = true
end
end
end
end
return ret
end

--[[
------------------------------------------------------------------------------------
-- valueUnion
--
-- This returns the union of the values of n tables, as an array. For example, for
-- the tables {1, 3, 4, 5, foo = 7} and {2, bar = 3, 5, 6}, union will return
-- {1, 2, 3, 4, 5, 6, 7}.
------------------------------------------------------------------------------------
--]]
function p.valueUnion(...)
local lim = select('#', ...)
if lim < 2 then
error("too few arguments to 'valueUnion' (minimum is 2, received " .. lim .. ')', 2)
end
local isNan = p.isNan
local ret, exists = {}, {}
for i = 1, lim do
local t = select(i, ...)
checkType('valueUnion', i, t, 'table')
for k, v in pairs(t) do
if isNan(v) then
ret[#ret + 1] = v
elseif not exists[v] then
ret[#ret + 1] = v
exists[v] = true
end
end
end
return ret
end

--[[
------------------------------------------------------------------------------------
-- intersection
--
-- This returns the intersection of the key/value pairs of n tables. Both the key
-- and the value must match to be included in the resulting table.
------------------------------------------------------------------------------------
--]]
function p.intersection(...)
local lim = select('#', ...)
if lim < 2 then
error("too few arguments to 'intersection' (minimum is 2, received " .. lim .. ')', 2)
end
local ret, track, pairCounts = {}, {}, {}
for i = 1, lim do
local t = select(i, ...)
checkType('intersection', i, t, 'table')
for k, v in pairs(t) do
local trackVal = track[k]
if trackVal == nil then
track[k] = v
pairCounts[k] = 1
elseif trackVal == v then
pairCounts[k] = pairCounts[k] + 1
end
end
end
for k, v in pairs(track) do
if pairCounts[k] == lim then
ret[k] = v
end
end
return ret
end

--[[
------------------------------------------------------------------------------------
-- valueIntersection
--
-- This returns the intersection of the values of n tables, as an array. For
-- example, for the tables {1, 3, 4, 5, foo = 7} and {2, bar = 3, 5, 6},
-- intersection will return {3, 5}.
------------------------------------------------------------------------------------
--]]
function p.valueIntersection(...)
local lim = select('#', ...)
if lim < 2 then
error("too few arguments to 'valueIntersection' (minimum is 2, received " .. lim .. ')', 2)
end
local isNan = p.isNan
local vals, ret = {}, {}
local isSameTable = true -- Tracks table equality.
local tableTemp -- Used to store the table from the previous loop so that we can check table equality.
for i = 1, lim do
local t = select(i, ...)
checkType('valueIntersection', i, t, 'table')
if tableTemp and t ~= tableTemp then
isSameTable = false
end
tableTemp = t
for k, v in pairs(t) do
-- NaNs are never equal to any other value, so they can't be in the intersection.
-- Which is lucky, as they also can't be table keys.
if not isNan(v) then
local valCount = vals[v] or 0
vals[v] = valCount + 1
end
end
end
if isSameTable then
-- If all the tables are equal, then the intersection is that table (including NaNs).
-- All we need to do is convert it to an array and remove duplicate values.
for k, v in pairs(tableTemp) do
ret[#ret + 1] = v
end
return p.removeDuplicates(ret)
end
for val, count in pairs(vals) do
if count == lim then
ret[#ret + 1] = val
end
end
return ret
end

--[[
------------------------------------------------------------------------------------
-- complement
--
-- This returns the relative complement of t1, t2, ..., in tn. The complement
-- is of key/value pairs. This is equivalent to all the key/value pairs that are in
-- tn but are not in t1, t2, ... tn-1.
------------------------------------------------------------------------------------
--]]
function p.complement(...)
local lim = select('#', ...)
if lim < 2 then
error("too few arguments to 'complement' (minimum is 2, received " .. lim .. ')', 2)
end
--[[
-- Now we know that we have at least two sets.
-- First, get all the key/value pairs in tn. We can't simply make ret equal to tn,
-- as that will affect the value of tn for the whole module.
--]]
local tn = select(lim, ...)
checkType('complement', lim, tn, 'table')
local ret = p.shallowClone(tn)
-- Remove all the key/value pairs in t1, t2, ..., tn-1.
for i = 1, lim - 1 do
local t = select(i, ...)
checkType('complement', i, t, 'table')
for k, v in pairs(t) do
if ret[k] == v then
ret[k] = nil
end
end
end
return ret
end

--[[
------------------------------------------------------------------------------------
-- valueComplement
--
-- This returns an array containing the relative complement of t1, t2, ..., in tn.
-- The complement is of values only. This is equivalent to all the values that are
-- in tn but are not in t1, t2, ... tn-1.
------------------------------------------------------------------------------------
--]]
function p.valueComplement(...)
local lim = select('#', ...)
if lim < 2 then
error("too few arguments to 'valueComplement' (minimum is 2, received " .. lim .. ')', 2)
end
local isNan = p.isNan
local ret, exists = {}, {}
for i = 1, lim - 1 do
local t = select(i, ...)
checkType('valueComplement', i, t, 'table')
for k, v in pairs(t) do
if not isNan(v) then
-- NaNs cannot be table keys, and they are also unique so cannot be equal to anything in tn.
exists[v] = true
end
end
end
local tn = select(lim, ...)
checkType('valueComplement', lim, tn, 'table')
for k, v in pairs(tn) do
if isNan(v) or exists[v] == nil then
ret[#ret + 1] = v
end
end
return ret
end

--[[
------------------------------------------------------------------------------------
-- symmDiff
--
-- This returns the symmetric difference of key/value pairs of t1, t2, ..., tn.
-- The symmetric difference of two tables consists of the key/value pairs
-- that appear in set 1 but not set 2, together with the key/value pairs that
-- appear in set 2 but not in set 1. This is the same as the union of the two
-- minus the intersection. If either of the tables contain different values for the
-- same table key, the table value is converted to an array holding all of the
-- different values.For more than two tables, this can get confusing - see the
-- "Symmetric difference" article for details.
------------------------------------------------------------------------------------
--]]

--[[ -- This is a rough work in progress.
function p.symmDiff(...)
local lim = select('#', ...)
if lim < 2 then
error("too few arguments to 'symmDiff' (minimum is 2, received " .. lim .. ')', 2)
end

local tremove = table.remove
local trackArrays = {}

local function symmDiffTwo(t1, t2)
local ret = {}
for k, v in pairs(t1) do
local t2val = t2[k]
if t2val == nil then
ret[k] = v
elseif trackArrays[k] then
local array = ret[k]
local valExists
for i, arrayVal in ipairs(array) do
if arrayVal == v then
valExists = true
break
end
end
if not valExists then
array[#array + 1] = v
end
elseif v ~= t2val then
ret[k] = {t2val, v}
trackArrays[k] = true
end
--]]