View source for Sets - collections of unique elements

[[Category: Analytica User Guide]]
[[Category: Set Functions]]

<breadcrumbs>Analytica User Guide > More Array Functions > {{PAGENAME}}</breadcrumbs>

__TOC__

In mathematics, a set is a collection of unique elements. A set itself may be treated as a self-contained entity, such that you might represent an array of sets. In such applications, you do not wish for the elements of the set to be treated as an array dimension, or to interact with array abstraction; instead, you want the set to be treated as a single atomic entity, to which operations such as set intersection and set union might be applied. Thus, a simple list representation would not be suitable, since the list itself would act as an implicit dimension, and hence would interact with array abstraction.

'''Representation of a set:''' A natural way to represent a set in Analytica is as a reference to a list of elements. References operations are covered in a more general context in [[References and Data Structures]], but in the context of sets, you can simple view the reference operator, [[Using_References#Reference_Operator:_.5CA|\L]], as an operator that takes a list of elements, «L», and returns a set, and the dereference operator, [[Using_References#Dereference_Operator:_.23R|#S]], as an operator returns a list of elements from a set.

'''Literal sets:''' The following syntax is used to write an explicit set of literal elements:
:<code>\(['a','b','c','d'])</code>
You cannot omit the round parentheses, i.e., <code>\['a','b','c','d']</code>, because square brackets following a reference operator are used to specify the indexes consumed by the reference.

'''Creating sets from an array:''' Given a 2-D array, <code>A</code>, indexed by <code>I</code> and <code>J</code>, the expression [[Using_References#.5C.5BI.2C_J.5DA|\[I]A]] returns a 1-D array of sets indexed by <code>J</code>. For each element of <code>J</code>, the vector indexed by <code>I</code> becomes a set. At this point, duplicate elements have not been removed, so it isn’t a strict set yet; however, it is now ready to be treated as a set by the set functions described in this section.

:<code>Variable Array_s :=</code>
:{| class="wikitable"
!
! colspan="3" |Index_b &#9654;
|-
!Index_a: &#9660;
!1
!2
!3
|-
!a
|7
| -3
|1
|-
!b
| -4
| -1
|6
|-
!c
|5
|0
| -2
|}

:<code>\[Index_a]Array_s &rarr;</code>
:{| class="wikitable"
!
! colspan="3" |Index_b &#9654;
|-
!1
!2
!3
|-
| \([7, -4, 5])
| \([-3, -1, 0])
| \([1, 6, -2])
|}

'''Display of sets:''' In a result table, each set displays as «ref». :

[[File:Chapter12_4.png]]

Double clicking on «ref» displays the elements of the set in a new result window.

'''Null values in sets:''' Set functions, like most other array functions, ignore [[Null]] values by default. This makes it possible to pad an array with [[Null]] values to hold the elements of a set, when the number of elements is less than the length of the array. However, it also means that set cannot contain the [[Null]] value by default. When you want to include [[Null]] as an actual element, and not just as a value to be ignored, the various set functions provide an optional boolean parameter to indicate this intent.

==SetContains(set, element)==
Returns 1 (<code>true</code>) when element is in set. See also [[SetContains]]().

'''Example:''' 
:<code>SetContains(\(['a', 'b', 'c', 'd']), 5) &rarr; 0</code>
:<code>SetContains(\Sequence(1, 100, 7), 85 ) &rarr; 1</code>

==SetDifference(originalSet, ''remove1, remove2, ..., resultIndex, keepNull'')==
Returns the set that results when the elements in the sets «remove1», «remove2», ..., as well as any duplicate elements, are removed from «originalSet». When «resultIndex» is unspecified or false, the result is a reference to a list of elements. When an index is specified in the «resultIndex» parameter, the result is a 1-D array indexed by the «resultIndex». When «keepNull» is unspecified or null, then any [[Null]] value in «originalSet» are ignored (and won’t be in the result). When «keepNull» is true, [[Null]] is treated as a legitimate element. See also [[SetDifference]]().

'''Example:''' 
:<code>Var S := \(0 .. 10);</code>
:<code>Var S2 := \Sequence(0, 10, 2);</code>
:<code>Var S3 := \Sequence(0, 10, 3);</code>
:<code>#SetDifference(S, S2, S3) &rarr; [1, 5, 7]</code>
:<code>Index I := 1 .. 5;</code>

:<code>SetDifference(S, S2, S3, resultIndex: I) &rarr;</code>
:{| class="wikitable"
! colspan="5" | .I &#9654;
|-
|1
|2
|3
|4
|5
|-
| 1
| 5
| 7
| «null»
| «null»
|}

Set difference can be used to remove duplicates from a list:
:<code>Var L := [Null, 'a', 'b', 'c', 'd', 'b', 'c', 'd'];</code>
:<code>#SetDifference(\L) &rarr; ['a', 'b', 'c', 'd']</code>
:<code>#SetDifference(\L, keepNull: true) &rarr; [«null», 'a', 'b', 'c', 'd']</code>

==SetIntersection(sets, ''i, resultIndex, keepNull'')==
Returns the set intersection of «sets». The «sets» parameter should be an array of sets indexed by «i», or «i» can be omitted and «sets» specified as a list of sets. When «resultIndex» is omitted, the result is a set (a reference to a list) containing the elements common to all «sets». [[Null]] values are ignored (and not included in the result) unless «keepNull» is specified as true, in which case [[Null]] is treated like any other element. See also [[SetIntersection]]().

'''Example:''' 
:<code>Var S1 := \(['a', 'b', 'c', null,'d']);</code> 
:<code>Var S2 := \(['b', 'c', null, 'e']);</code> 
:<code>SetIntersection([S1, S2]) &rarr; \(['b', 'c'])</code> 
:<code>SetIntersection([S1, S2], keepNull: true) &rarr; \(['b', 'c', «null»])</code> 
:<code>#SetIntersection([\('a' .. 'p'),\('k' .. 'z')]) &rarr; ['k', 'l', 'm', 'n', 'o', 'p'] </code>

The following example finds all numbers under 10,000 divisible by the first 5 prime numbers:
:<code>Index n := [2, 3, 5, 7,11];</code>
:<code>Var sets := (for j := n do \Sequence(j, 10K, j));</code>
:<code>#SetIntersection(sets, n) &rarr; [2310, 4620, 6930, 9240]</code>

==SetsAreEqual(sets, ''i, ignoreNull'')==
Tests whether all «sets» in the parameter «sets» have the same elements. The parameter sets should be an array indexed by index «i», or index «i» can be omitted and sets can be a list of sets. [[Null]] values are ignored unless «ignoreNull» is specified as false. The presence of duplicates does not impact equality determination. See also [[SetsAreEqual]]().

'''Example:''' 
:<code>Var L1 := ['a', 'b', 'c', null];</code>
:<code>Var L2 := ['b', 'c', 'a'];</code>
:<code>Var L3 := ['c', 'b', 'a', 'b'];</code>
:<code>SetsAreEqual([\L1, \L2, \L3]) &rarr; 1</code>
:<code>SetsAreEqual([\L1, \L2, \L3], ignoreNull: false) &rarr; 0</code>

==SetUnion(sets, ''i, resultIndex, keepNull'')==
Returns a collection of all elements appearing in any set appearing in the parameter «sets». The parameter sets is an array of sets (references to lists or to 1-D arrays) which is indexed by «i», or it may be a list of sets when «i» is omitted. When «resultIndex» is omitted, the result is a reference the list of elements. When an index is provided to the «resultIndex» parameter, the result is a 1-D array indexed by «resultIndex». <code>Null</code> values are ignored (and not included in the result) unless «keepNull» is specified as true. See also [[SetUnion]]().

'''Example:''' 
:<code>#SetUnion([\('a' .. 'd'), \('c' .. 'f')]) &rarr; ['a', 'b', 'c', 'd', 'e', 'f']</code>
:<code>Index m := Sequence(1-Jan-2011, 1-May-2011, dateUnit: 'M');</code>
:<code>Index d := [0, 14];</code>
:<code>#SetUnion(SetUnion(\[d](m + d), d), m) &rarr;</code>
:<code>[1-Jan-2011, 15-Jan-2011, 1-Feb-2011, 15-Feb-2011, 1-Mar-2011, 15-Mar-2011, 1-Apr-2011, 15-Apr-2011, 1-May-2011, 15-May-2011]</code>

==See Also==
* [[SetContains]]
* [[SetDifference]]
* [[SetIntersection]]
* [[SetsAreEqual]]
* [[SetUnion]]
* [[Subset]]
* [[Logical Operators]]
* [[Using_References#Reference_Operator:_.5CA|Reference Operator: \A]]
* [[Using_References#Dereference_Operator:_.23R| Dereference Operator: #R]]


<footer>Fourier Transform / {{PAGENAME}} / Other array functions</footer>