Calc includes several commands which interpret vectors as *sets* of
objects. A set is a collection of objects; any given object can appear
only once in the set. Calc stores sets as vectors of objects in
sorted order. Objects in a Calc set can be any of the usual things,
such as numbers, variables, or formulas. Two set elements are considered
equal if they are identical, except that numerically equal numbers like
the integer 4 and the float 4.0 are considered equal even though they
are not “identical.” Variables are treated like plain symbols without
attached values by the set operations; subtracting the set ‘`[b]`’
from ‘`[a, b]`’ always yields the set ‘`[a]`’ even though if
the variables ‘`a`’ and ‘`b`’ both equaled 17, you might
expect the answer ‘`[]`’.

If a set contains interval forms, then it is assumed to be a set of real numbers. In this case, all set operations require the elements of the set to be only things that are allowed in intervals: Real numbers, plus and minus infinity, HMS forms, and date forms. If there are variables or other non-real objects present in a real set, all set operations on it will be left in unevaluated form.

If the input to a set operation is a plain number or interval form
`a`, it is treated like the one-element vector ‘`[ a]`’.
The result is always a vector, except that if the set consists of a
single interval, the interval itself is returned instead.

See Logical Operations, for the `in`

function which tests if
a certain value is a member of a given set. To test if the set ‘`A`’
is a subset of the set ‘`B`’, use ‘`vdiff(A, B) = []`’.

The `V +` (`calc-remove-duplicates`

) [`rdup`

] command
converts an arbitrary vector into set notation. It works by sorting
the vector as if by `V S`, then removing duplicates. (For example,
`[a, 5, 4, a, 4.0]` is sorted to ‘`[4, 4.0, 5, a, a]`’ and then
reduced to ‘`[4, 5, a]`’). Overlapping intervals are merged as
necessary. You rarely need to use `V +` explicitly, since all the
other set-based commands apply `V +` to their inputs before using
them.

The `V V` (`calc-set-union`

) [`vunion`

] command computes
the union of two sets. An object is in the union of two sets if and
only if it is in either (or both) of the input sets. (You could
accomplish the same thing by concatenating the sets with `|`,
then using `V +`.)

The `V ^` (`calc-set-intersect`

) [`vint`

] command computes
the intersection of two sets. An object is in the intersection if
and only if it is in both of the input sets. Thus if the input
sets are disjoint, i.e., if they share no common elements, the result
will be the empty vector ‘`[]`’. Note that the characters `V`
and `^` were chosen to be close to the conventional mathematical
notation for set
union
and
intersection.

The `V -` (`calc-set-difference`

) [`vdiff`

] command computes
the difference between two sets. An object is in the difference
‘`A - B`’ if and only if it is in ‘`A`’ but not in ‘`B`’.
Thus subtracting ‘`[y,z]`’ from a set will remove the elements
‘`y`’ and ‘`z`’ if they are present. You can also think of this
as a general *set complement* operator; if ‘`A`’ is the set of
all possible values, then ‘`A - B`’ is the “complement” of ‘`B`’.
Obviously this is only practical if the set of all possible values in
your problem is small enough to list in a Calc vector (or simple
enough to express in a few intervals).

The `V X` (`calc-set-xor`

) [`vxor`

] command computes
the “exclusive-or,” or “symmetric difference” of two sets.
An object is in the symmetric difference of two sets if and only
if it is in one, but *not* both, of the sets. Objects that
occur in both sets “cancel out.”

The `V ~` (`calc-set-complement`

) [`vcompl`

] command
computes the complement of a set with respect to the real numbers.
Thus ‘`vcompl(x)`’ is equivalent to ‘`vdiff([-inf .. inf], x)`’.
For example, ‘`vcompl([2, (3 .. 4]])`’ evaluates to
‘`[[-inf .. 2), (2 .. 3], (4 .. inf]]`’.

The `V F` (`calc-set-floor`

) [`vfloor`

] command
reinterprets a set as a set of integers. Any non-integer values,
and intervals that do not enclose any integers, are removed. Open
intervals are converted to equivalent closed intervals. Successive
integers are converted into intervals of integers. For example, the
complement of the set ‘`[2, 6, 7, 8]`’ is messy, but if you wanted
the complement with respect to the set of integers you could type
`V ~ V F` to get ‘`[[-inf .. 1], [3 .. 5], [9 .. inf]]`’.

The `V E` (`calc-set-enumerate`

) [`venum`

] command
converts a set of integers into an explicit vector. Intervals in
the set are expanded out to lists of all integers encompassed by
the intervals. This only works for finite sets (i.e., sets which
do not involve ‘`-inf`’ or ‘`inf`’).

The `V :` (`calc-set-span`

) [`vspan`

] command converts any
set of reals into an interval form that encompasses all its elements.
The lower limit will be the smallest element in the set; the upper
limit will be the largest element. For an empty set, ‘`vspan([])`’
returns the empty interval ‘`[0 .. 0)`’.

The `V #` (`calc-set-cardinality`

) [`vcard`

] command counts
the number of integers in a set. The result is the length of the vector
that would be produced by `V E`, although the computation is much
more efficient than actually producing that vector.

Another representation for sets that may be more appropriate in some
cases is binary numbers. If you are dealing with sets of integers
in the range 0 to 49, you can use a 50-bit binary number where a
particular bit is 1 if the corresponding element is in the set.
See Binary Number Functions, for a list of commands that operate on
binary numbers. Note that many of the above set operations have
direct equivalents in binary arithmetic: `b o` (`calc-or`

),
`b a` (`calc-and`

), `b d` (`calc-diff`

),
`b x` (`calc-xor`

), and `b n` (`calc-not`

),
respectively. You can use whatever representation for sets is most
convenient to you.

The `b u` (`calc-unpack-bits`

) [`vunpack`

] command
converts an integer that represents a set in binary into a set
in vector/interval notation. For example, ‘`vunpack(67)`’
returns ‘`[[0 .. 1], 6]`’. If the input is negative, the set
it represents is semi-infinite: ‘`vunpack(-4) = [2 .. inf)`’.
Use `V E` afterwards to expand intervals to individual
values if you wish. Note that this command uses the `b`
(binary) prefix key.

The `b p` (`calc-pack-bits`

) [`vpack`

] command
converts the other way, from a vector or interval representing
a set of nonnegative integers into a binary integer describing
the same set. The set may include positive infinity, but must
not include any negative numbers. The input is interpreted as a
set of integers in the sense of `V F` (`vfloor`

). Beware
that a simple input like ‘`[100]`’ can result in a huge integer
representation
(‘`2^100`’, a 31-digit integer, in this case).