NAME

Set::IntRange - Sets of Integers

PURPOSE

Easy manipulation of sets of integers (arbitrary intervals)

SYNOPSIS

METHODS

Version
    $version = $Set::IntRange::VERSION;

new
    $set = Set::IntRange->new($lower,$upper);
    $set = $any_set->new($lower,$upper);

Resize
    $set->Resize($lower,$upper);

Size
    ($lower,$upper) = $set->Size();

Empty
    $set->Empty();

Fill
    $set->Fill();

Flip
    $set->Flip();

Interval_Empty
    $set->Interval_Empty($lower,$upper);
    $set->Empty_Interval($lower,$upper); # (deprecated)

Interval_Fill
    $set->Interval_Fill($lower,$upper);
    $set->Fill_Interval($lower,$upper);  # (deprecated)

Interval_Flip
    $set->Interval_Flip($lower,$upper);
    $set->Flip_Interval($lower,$upper);  # (deprecated)

Interval_Scan_inc
    while (($min,$max) = $set->Interval_Scan_inc($start))

Interval_Scan_dec
    while (($min,$max) = $set->Interval_Scan_dec($start))

Bit_Off
    $set->Bit_Off($index);
    $set->Delete($index);                # (deprecated)

Bit_On
    $set->Bit_On($index);
    $set->Insert($index);                # (deprecated)

bit_flip
    $bit = $set->bit_flip($index);
    if ($set->bit_flip($index))
    $bit = $set->flip($index);           # (deprecated)
    if ($set->flip($index))              # (deprecated)

bit_test
    $bit = $set->bit_test($index);
    if ($set->bit_test($index))
    $bit = $set->contains($index);
    if ($set->contains($index))
    $bit = $set->in($index);             # (deprecated)
    if ($set->in($index))                # (deprecated)

Norm
    $norm = $set->Norm();

Min
    $min = $set->Min();

Max
    $max = $set->Max();

Union
    $set1->Union($set2,$set3);           # in-place is possible!

Intersection
    $set1->Intersection($set2,$set3);    # in-place is possible!

Difference
    $set1->Difference($set2,$set3);      # in-place is possible!

ExclusiveOr
    $set1->ExclusiveOr($set2,$set3);     # in-place is possible!

Complement
    $set1->Complement($set2);            # in-place is possible!

is_empty
    if ($set->is_empty())

is_full
    if ($set->is_full())

equal
    if ($set1->equal($set2))

subset
    if ($set1->subset($set2))
    if ($set1->inclusion($set2))         # (deprecated)

Lexicompare
    $cmp = $set1->Lexicompare($set2);    # unsigned

Compare
    $cmp = $set1->Compare($set2);        # signed

Copy
    $set1->Copy($set2);

Shadow
    $other_set = $some_set->Shadow();

Clone
    $twin_set = $some_set->Clone();

to_Enum
    $string = $set->to_Enum();           # e.g., "-8..-5,-1..2,4,6..9"

from_Enum
    eval { $set->from_Enum($string); };

to_Hex
    $string = $set->to_Hex();            # e.g., "0007AF1E"

from_Hex
    eval { $set->from_Hex($string); };

BitVector
    $set->BitVector->any_Bit_Vector_method();

OVERLOADED OPERATORS

    # "$index" is a number or a Perl scalar variable containing a
    # number which represents the set containing only that element:

Emptyness
    if ($set) # if not empty
    if (! $set) # if empty
    unless ($set) # if empty

Equality
    if ($set1 == $set2)
    if ($set1 != $set2)
    if ($set == $index)
    if ($set != $index)

Lexical Comparison
    $cmp = $set1 cmp $set2;
    if ($set1 lt $set2)
    if ($set1 le $set2)
    if ($set1 gt $set2)
    if ($set1 ge $set2)
    if ($set1 eq $set2)
    if ($set1 ne $set2)
    $cmp = $set cmp $index;
    if ($set lt $index)
    if ($set le $index)
    if ($set gt $index)
    if ($set ge $index)
    if ($set eq $index)
    if ($set ne $index)

String Conversion
    $string = "$set";
    print "\$set = '$set'\n";

Union
    $set1 = $set2 + $set3;
    $set1 += $set2;
    $set1 = $set2 | $set3;
    $set1 |= $set2;
    $set1 = $set2 + $index;
    $set += $index;
    $set1 = $set2 | $index;
    $set |= $index;

Intersection
    $set1 = $set2 * $set3;
    $set1 *= $set2;
    $set1 = $set2 & $set3;
    $set1 &= $set2;
    $set1 = $set2 * $index;
    $set *= $index;
    $set1 = $set2 & $index;
    $set &= $index;

Difference
    $set1 = $set2 - $set3;
    $set1 -= $set2;
    $set1 = $set2 - $set1;
    $set1 = $set2 - $index;
    $set1 = $index - $set2;
    $set -= $index;

ExclusiveOr
    $set1 = $set2 ^ $set3;
    $set1 ^= $set2;
    $set1 = $set2 ^ $index;
    $set ^= $index;

Complement
    $set1 = -$set2;
    $set1 = ~$set2;
    $set = -$set;
    $set = ~$set;

Subset Relationship
    if ($set1 <= $set2)

True Subset Relationship
    if ($set1 < $set2)

Superset Relationship
    if ($set1 >= $set2)

True Superset Relationship
    if ($set1 > $set2)

Norm
    $norm = abs($set);

DESCRIPTION

This class lets you dynamically create sets of arbitrary intervals of integers and perform all the basic operations for sets on them (for a list of available methods and operators, see above).

See Bit::Vector(3) for more details!

SEE ALSO

Bit::Vector(3), Math::MatrixBool(3), Math::MatrixReal(3), DFA::Kleene(3), Math::Kleene(3), Graph::Kruskal(3).

VERSION

This man page documents "Set::IntRange" version 5.2.

AUTHOR

Steffen Beyer <STBEY@cpan.org>.

COPYRIGHT

Copyright (c) 1995 - 2009 by Steffen Beyer. All rights reserved.

LICENSE

This package is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

DISCLAIMER

This package is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.