forked from gorgonia/gorgonia
-
Notifications
You must be signed in to change notification settings - Fork 0
/
node_set.go
172 lines (150 loc) · 3.93 KB
/
node_set.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
// Generated by: main
// TypeWriter: set
// Directive: +gen on *Node
package gorgonia
// Set is a modification of https://github.com/deckarep/golang-set
// The MIT License (MIT)
// Copyright (c) 2013 Ralph Caraveo (deckarep@gmail.com)
// NodeSet is the primary type that represents a set
type NodeSet map[*Node]struct{}
// NewNodeSet creates and returns a reference to an empty set.
func NewNodeSet(a ...*Node) NodeSet {
s := make(NodeSet)
for _, i := range a {
s.Add(i)
}
return s
}
// ToSlice returns the elements of the current set as a slice
func (set NodeSet) ToSlice() Nodes {
var s Nodes
for v := range set {
s = append(s, v)
}
return s
}
// Add adds an item to the current set if it doesn't already exist in the set.
func (set NodeSet) Add(i *Node) bool {
_, found := set[i]
set[i] = struct{}{}
return !found //False if it existed already
}
// Contains determines if a given item is already in the set.
func (set NodeSet) Contains(i *Node) bool {
_, found := set[i]
return found
}
// ContainsAll determines if the given items are all in the set
func (set NodeSet) ContainsAll(i ...*Node) bool {
for _, v := range i {
if !set.Contains(v) {
return false
}
}
return true
}
// IsSubset determines if every item in the other set is in this set.
func (set NodeSet) IsSubset(other NodeSet) bool {
for elem := range set {
if !other.Contains(elem) {
return false
}
}
return true
}
// IsSuperset determines if every item of this set is in the other set.
func (set NodeSet) IsSuperset(other NodeSet) bool {
return other.IsSubset(set)
}
// Union returns a new set with all items in both sets.
func (set NodeSet) Union(other NodeSet) NodeSet {
unionedSet := NewNodeSet()
for elem := range set {
unionedSet.Add(elem)
}
for elem := range other {
unionedSet.Add(elem)
}
return unionedSet
}
// Intersect returns a new set with items that exist only in both sets.
func (set NodeSet) Intersect(other NodeSet) NodeSet {
intersection := NewNodeSet()
// loop over smaller set
if set.Cardinality() < other.Cardinality() {
for elem := range set {
if other.Contains(elem) {
intersection.Add(elem)
}
}
} else {
for elem := range other {
if set.Contains(elem) {
intersection.Add(elem)
}
}
}
return intersection
}
// Difference returns a new set with items in the current set but not in the other set
func (set NodeSet) Difference(other NodeSet) NodeSet {
differencedSet := NewNodeSet()
for elem := range set {
if !other.Contains(elem) {
differencedSet.Add(elem)
}
}
return differencedSet
}
// SymmetricDifference returns a new set with items in the current set or the other set but not in both.
func (set NodeSet) SymmetricDifference(other NodeSet) NodeSet {
aDiff := set.Difference(other)
bDiff := other.Difference(set)
return aDiff.Union(bDiff)
}
// Clear clears the entire set to be the empty set.
func (set *NodeSet) Clear() {
*set = make(NodeSet)
}
// Remove allows the removal of a single item in the set.
func (set NodeSet) Remove(i *Node) {
delete(set, i)
}
// Cardinality returns how many items are currently in the set.
func (set NodeSet) Cardinality() int {
return len(set)
}
// Iter returns a channel of type *Node that you can range over.
func (set NodeSet) Iter() <-chan *Node {
ch := make(chan *Node)
go func() {
for elem := range set {
ch <- elem
}
close(ch)
}()
return ch
}
// Equal determines if two sets are equal to each other.
// If they both are the same size and have the same items they are considered equal.
// Order of items is not relevant for sets to be equal.
func (set NodeSet) Equal(other NodeSet) bool {
if set.Cardinality() != other.Cardinality() {
return false
}
for elem := range set {
if !other.Contains(elem) {
return false
}
}
return true
}
// Clone returns a clone of the set.
// Does NOT clone the underlying elements.
func (set NodeSet) Clone() NodeSet {
clonedSet := NewNodeSet()
for elem := range set {
clonedSet.Add(elem)
}
return clonedSet
}