IntRange(3p)

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.