NAME

Set::Scalar - basic set operations

SYNOPSIS

use Set::Scalar;
$s = Set::Scalar->new;
$s->insert('a', 'b');
$s->delete('b');
$t = Set::Scalar->new('x', 'y', $z);

DESCRIPTION

Creating

$s = Set::Scalar->new;
$s = Set::Scalar->new(@members); 

$t = $s->clone;

Modifying

$s->insert(@members);
$s->delete(@members);
$s->invert(@members); # insert if hasn't, delete if has

Displaying

print $s, "\n";

The display format of a set is the members of the set separated by spaces and enclosed in parentheses ().

You can even display recursive sets.

Querying

@members  = $s->members;
@elements = $s->elements; # alias for members

$size = $s->size;

if ($s->member($member)) { ...

$s->element  # alias for member
$s->has      # alias for member
$s->contains # alias for member

$s->is_null
$s->is_universal

$s->null	 # the null set
$s->universe # the universe of the set

Deriving

$u = $s->union($t);
$i = $s->intersection($t);
$d = $s->difference($t);
$e = $s->symmetric_difference($t);
$v = $s->unique($t);
$c = $s->complement;

These methods have operator overloads:

$u = $s + $t; # union
$i = $s * $t; # intersection
$d = $s - $t; # difference
$e = $s % $t; # symmetric_difference
$v = $s / $t; # unique
$c = -$s;     # complement

Both the symmetric_difference and unique are symmetric on all their arguments. For two sets they are identical but for more than two sets beware: symmetric_difference returns true for elements that are in an odd number (1, 3, 5, ...) of sets, unique returns true for elements that are in one set.

Some examples of the various set differences:

set or difference                   value

$a                                  (a b c d e)
$b                                  (c d e f g)
$c                                  (e f g h i)

$a->difference($b)                  (a b)
$a->symmetric_difference($b)        (a b f g)
$a->unique($b)                      (a b f g)

$b->difference($a)                  (f g)
$b->symmetric_difference($a)        (a b f g)
$b->unique($a)                      (a b f g)

$a->difference($b, $c)              (a b)
$a->symmetric_difference($b, $c)    (a b e h i)
$a->unique($b, $c)                  (a b h i)

Comparing

$eq = $s->is_equal($t);
$dj = $s->is_disjoint($t);
$pi = $s->is_properly_intersecting($t);
$ps = $s->is_proper_subset($t);
$pS = $s->is_proper_superset($t);
$is = $s->is_subset($t);
$iS = $s->is_superset($t);

$cmp = $s->compare($t);

The compare method returns a string from the following list: "equal", "disjoint", "proper subset", "proper superset", "proper intersect", and in future (once I get around implementing it), "disjoint universes".

These methods have operator overloads:

$eq = $s == $t; # is_equal
$dj = $s != $t; # is_disjoint
# No operator overload for is_properly_intersecting.
$ps = $s < $t;  # is_proper_subset
$pS = $s > $t;  # is_proper_superset
$is = $s <= $t; # is_subset
$iS = $s >= $t; # is_superset

$cmp = $s <=> $t;

AUTHOR

Jarkko Hietaniemi <jhi@iki.fi>