home *** CD-ROM | disk | FTP | other *** search
/ CD Actual Thematic 7: Programming / CDAT7.iso / Share / Editores / Perl5 / perl / lib / site / Set / IntegerRange.pm < prev   
Encoding:
Perl POD Document  |  1997-08-10  |  33.8 KB  |  1,529 lines
  1.  
  2. #  Copyright (c) 1996, 1997 by Steffen Beyer. All rights reserved.
  3. #  This package is free software; you can redistribute it and/or
  4. #  modify it under the same terms as Perl itself.
  5.  
  6. package Set::IntegerRange;
  7.  
  8. use strict;
  9. use vars qw(@ISA @EXPORT @EXPORT_OK $VERSION);
  10.  
  11. require Exporter;
  12.  
  13. @ISA = qw(Exporter);
  14.  
  15. @EXPORT = qw();
  16.  
  17. @EXPORT_OK = qw();
  18.  
  19. $VERSION = '4.2';
  20.  
  21. use Carp;
  22.  
  23. use Bit::Vector;
  24.  
  25. use overload
  26.       '""' => '_string',
  27.      'neg' => '_complement',
  28.        '~' => '_complement',
  29.     'bool' => '_boolean',
  30.        '!' => '_not_boolean',
  31.      'abs' => '_norm',
  32.        '+' => '_union',
  33.        '|' => '_union',                  # alternative for '+'
  34.        '-' => '_difference',
  35.        '*' => '_intersection',
  36.        '&' => '_intersection',           # alternative for '*'
  37.        '^' => '_exclusive_or',
  38.       '+=' => '_assign_union',
  39.       '|=' => '_assign_union',           # alternative for '+='
  40.       '-=' => '_assign_difference',
  41.       '*=' => '_assign_intersection',
  42.       '&=' => '_assign_intersection',    # alternative for '*='
  43.       '^=' => '_assign_exclusive_or',
  44.       '==' => '_equal',
  45.       '!=' => '_not_equal',
  46.        '<' => '_true_sub_set',
  47.       '<=' => '_sub_set',
  48.        '>' => '_true_super_set',
  49.       '>=' => '_super_set',
  50.      'cmp' => '_compare',                # also enables lt, le, gt, ge, eq, ne
  51.        '=' => '_clone',
  52. 'fallback' =>   undef;
  53.  
  54. sub new
  55. {
  56.     croak "Usage: \$set = Set::IntegerRange->new(\$lower,\$upper);"
  57.       if (@_ != 3);
  58.  
  59.     my $proto = shift;
  60.     my $class = ref($proto) || $proto || 'Set::IntegerRange';
  61.     my $lower = shift;
  62.     my $upper = shift;
  63.     my $object;
  64.     my $set;
  65.  
  66.     if ($lower <= $upper)
  67.     {
  68.         $set = Bit::Vector->new($upper-$lower+1);
  69.         if ((defined $set) && ref($set) && (${$set} != 0))
  70.         {
  71.             $object = [ $set, $lower, $upper ];
  72.             bless($object, $class);
  73.             return($object);
  74.         }
  75.         else
  76.         {
  77.             croak
  78.   "Set::IntegerRange::new(): unable to create new 'Set::IntegerRange' object";
  79.         }
  80.     }
  81.     else
  82.     {
  83.         croak
  84.   "Set::IntegerRange::new(): lower > upper boundary";
  85.     }
  86. }
  87.  
  88. sub Resize
  89. {
  90.     croak "Usage: \$set->Resize(\$lower,\$upper);"
  91.       if (@_ != 3);
  92.  
  93.     my($object,$new_lower,$new_upper) = @_;
  94.     my($old_lower,$old_upper) = ($object->[1],$object->[2]);
  95.     my($diff);
  96.  
  97.     if ($new_lower <= $new_upper)
  98.     {
  99.         $diff = $new_lower - $old_lower;
  100.         if ($diff == 0)
  101.         {
  102.             $object->[0]->Resize($new_upper-$new_lower+1);
  103.         }
  104.         else
  105.         {
  106.             if ($diff > 0)
  107.             {
  108.                 $object->[0]->Move_Right($diff);
  109.                 $object->[0]->Resize($new_upper-$new_lower+1);
  110.             }
  111.             else
  112.             {
  113.                 $object->[0]->Resize($new_upper-$new_lower+1);
  114.                 $object->[0]->Move_Left(-$diff);
  115.             }
  116.         }
  117.         ($object->[1],$object->[2]) = ($new_lower,$new_upper);
  118.     }
  119.     else
  120.     {
  121.         croak "Set::IntegerRange::Resize(): lower > upper boundary";
  122.     }
  123. }
  124.  
  125. sub Size
  126. {
  127.     croak "Usage: (\$lower,\$upper) = \$set->Size();"
  128.       if (@_ != 1);
  129.  
  130.     my($object) = @_;
  131.  
  132.     return( $object->[1], $object->[2] );
  133. }
  134.  
  135. sub BitVector
  136. {
  137.     croak "Usage: \$set->BitVector->any_Bit_Vector_method();"
  138.       if (@_ != 1);
  139.  
  140.     my($object) = @_;
  141.  
  142.     return( $object->[0] );
  143. }
  144.  
  145. sub Empty
  146. {
  147.     croak "Usage: \$set->Empty();"
  148.       if (@_ != 1);
  149.  
  150.     my($object) = @_;
  151.  
  152.     $object->[0]->Empty();
  153. }
  154.  
  155. sub Fill
  156. {
  157.     croak "Usage: \$set->Fill();"
  158.       if (@_ != 1);
  159.  
  160.     my($object) = @_;
  161.  
  162.     $object->[0]->Fill();
  163. }
  164.  
  165. sub Flip
  166. {
  167.     croak "Usage: \$set->Flip();"
  168.       if (@_ != 1);
  169.  
  170.     my($object) = @_;
  171.  
  172.     $object->[0]->Flip();
  173. }
  174.  
  175. sub Interval_Empty
  176. {
  177.     croak "Usage: \$set->Interval_Empty(\$min,\$max);"
  178.       if (@_ != 3);
  179.  
  180.     my($object,$min,$max) = @_;
  181.     my($lower,$upper) = ($object->[1],$object->[2]);
  182.  
  183.     croak "Set::IntegerRange::Interval_Empty(): minimum index out of range"
  184.       if (($min < $lower) || ($min > $upper));
  185.  
  186.     croak "Set::IntegerRange::Interval_Empty(): maximum index out of range"
  187.       if (($max < $lower) || ($max > $upper));
  188.  
  189.     croak "Set::IntegerRange::Interval_Empty(): minimum > maximum index"
  190.       if ($min > $max);
  191.  
  192.     $object->[0]->Interval_Empty($min-$lower,$max-$lower);
  193. }
  194.  
  195. sub Interval_Fill
  196. {
  197.     croak "Usage: \$set->Interval_Fill(\$min,\$max);"
  198.       if (@_ != 3);
  199.  
  200.     my($object,$min,$max) = @_;
  201.     my($lower,$upper) = ($object->[1],$object->[2]);
  202.  
  203.     croak "Set::IntegerRange::Interval_Fill(): minimum index out of range"
  204.       if (($min < $lower) || ($min > $upper));
  205.  
  206.     croak "Set::IntegerRange::Interval_Fill(): maximum index out of range"
  207.       if (($max < $lower) || ($max > $upper));
  208.  
  209.     croak "Set::IntegerRange::Interval_Fill(): minimum > maximum index"
  210.       if ($min > $max);
  211.  
  212.     $object->[0]->Interval_Fill($min-$lower,$max-$lower);
  213. }
  214.  
  215. sub Interval_Flip
  216. {
  217.     croak "Usage: \$set->Interval_Flip(\$min,\$max);"
  218.       if (@_ != 3);
  219.  
  220.     my($object,$min,$max) = @_;
  221.     my($lower,$upper) = ($object->[1],$object->[2]);
  222.  
  223.     croak "Set::IntegerRange::Interval_Flip(): minimum index out of range"
  224.       if (($min < $lower) || ($min > $upper));
  225.  
  226.     croak "Set::IntegerRange::Interval_Flip(): maximum index out of range"
  227.       if (($max < $lower) || ($max > $upper));
  228.  
  229.     croak "Set::IntegerRange::Interval_Flip(): minimum > maximum index"
  230.       if ($min > $max);
  231.  
  232.     $object->[0]->Interval_Flip($min-$lower,$max-$lower);
  233. }
  234.  
  235. sub Interval_Scan_inc
  236. {
  237.     croak "Usage: (\$min,\$max) = \$set->Interval_Scan_inc(\$start);"
  238.       if (@_ != 2);
  239.  
  240.     my($object,$start) = @_;
  241.     my($lower,$upper) = ($object->[1],$object->[2]);
  242.     my($min,$max);
  243.  
  244.     croak "Set::IntegerRange::Interval_Scan_inc(): start index out of range"
  245.       if (($start < $lower) || ($start > $upper));
  246.  
  247.     if (($min,$max) = $object->[0]->Interval_Scan_inc($start-$lower))
  248.     {
  249.         $min += $lower;
  250.         $max += $lower;
  251.         return($min,$max);
  252.     }
  253.     else
  254.     {
  255.         return();
  256.     }
  257. }
  258.  
  259. sub Interval_Scan_dec
  260. {
  261.     croak "Usage: (\$min,\$max) = \$set->Interval_Scan_dec(\$start);"
  262.       if (@_ != 2);
  263.  
  264.     my($object,$start) = @_;
  265.     my($lower,$upper) = ($object->[1],$object->[2]);
  266.     my($min,$max);
  267.  
  268.     croak "Set::IntegerRange::Interval_Scan_dec(): start index out of range"
  269.       if (($start < $lower) || ($start > $upper));
  270.  
  271.     if (($min,$max) = $object->[0]->Interval_Scan_dec($start-$lower))
  272.     {
  273.         $min += $lower;
  274.         $max += $lower;
  275.         return($min,$max);
  276.     }
  277.     else
  278.     {
  279.         return();
  280.     }
  281. }
  282.  
  283. sub Bit_Off
  284. {
  285.     croak "Usage: \$set->Bit_Off(\$index);"
  286.       if (@_ != 2);
  287.  
  288.     my($object,$index) = @_;
  289.     my($lower,$upper) = ($object->[1],$object->[2]);
  290.  
  291.     if (($index >= $lower) && ($index <= $upper))
  292.     {
  293.         $object->[0]->Bit_Off($index-$lower);
  294.     }
  295.     else
  296.     {
  297.         croak "Set::IntegerRange::Bit_Off(): index out of range";
  298.     }
  299. }
  300.  
  301. sub Bit_On
  302. {
  303.     croak "Usage: \$set->Bit_On(\$index);"
  304.       if (@_ != 2);
  305.  
  306.     my($object,$index) = @_;
  307.     my($lower,$upper) = ($object->[1],$object->[2]);
  308.  
  309.     if (($index >= $lower) && ($index <= $upper))
  310.     {
  311.         $object->[0]->Bit_On($index-$lower);
  312.     }
  313.     else
  314.     {
  315.         croak "Set::IntegerRange::Bit_On(): index out of range";
  316.     }
  317. }
  318.  
  319. sub bit_flip
  320. {
  321.     croak "Usage: if (\$set->bit_flip(\$index))"
  322.       if (@_ != 2);
  323.  
  324.     my($object,$index) = @_;
  325.     my($lower,$upper) = ($object->[1],$object->[2]);
  326.  
  327.     if (($index >= $lower) && ($index <= $upper))
  328.     {
  329.         return( $object->[0]->bit_flip($index-$lower) );
  330.     }
  331.     else
  332.     {
  333.         croak "Set::IntegerRange::bit_flip(): index out of range";
  334.     }
  335. }
  336.  
  337. sub bit_test
  338. {
  339.     croak "Usage: if (\$set->bit_test(\$index))"
  340.       if (@_ != 2);
  341.  
  342.     my($object,$index) = @_;
  343.     my($lower,$upper) = ($object->[1],$object->[2]);
  344.  
  345.     if (($index >= $lower) && ($index <= $upper))
  346.     {
  347.         return( $object->[0]->bit_test($index-$lower) );
  348.     }
  349.     else
  350.     {
  351.         croak "Set::IntegerRange::bit_test(): index out of range";
  352.     }
  353. }
  354.  
  355. sub Norm
  356. {
  357.     croak "Usage: \$norm = \$set->Norm();"
  358.       if (@_ != 1);
  359.  
  360.     my($object) = @_;
  361.  
  362.     return( $object->[0]->Norm() );
  363. }
  364.  
  365. sub Min
  366. {
  367.     croak "Usage: \$min = \$set->Min();"
  368.       if (@_ != 1);
  369.  
  370.     my($object) = @_;
  371.     my($lower,$upper) = ($object->[1],$object->[2]);
  372.     my($result);
  373.  
  374.     $result = $object->[0]->Min();
  375.     return( (($result >= 0) && ($result <= ($upper-$lower))) ?
  376.             ($result+$lower) : $result );
  377. }
  378.  
  379. sub Max
  380. {
  381.     croak "Usage: \$max = \$set->Max();"
  382.       if (@_ != 1);
  383.  
  384.     my($object) = @_;
  385.     my($lower,$upper) = ($object->[1],$object->[2]);
  386.     my($result);
  387.  
  388.     $result = $object->[0]->Max();
  389.     return( (($result >= 0) && ($result <= ($upper-$lower))) ?
  390.             ($result+$lower) : $result );
  391. }
  392.  
  393. sub Union
  394. {
  395.     croak "Usage: \$set1->Union(\$set2,\$set3);"
  396.       if (@_ != 3);
  397.  
  398.     my($set1,$set2,$set3) = @_;
  399.     my($lower1,$upper1) = ($set1->[1],$set1->[2]);
  400.     my($lower2,$upper2) = ($set2->[1],$set2->[2]);
  401.     my($lower3,$upper3) = ($set3->[1],$set3->[2]);
  402.  
  403.     if (($lower1 == $lower2) && ($lower1 == $lower3) &&
  404.         ($upper1 == $upper2) && ($upper1 == $upper3))
  405.     {
  406.         $set1->[0]->Union($set2->[0],$set3->[0]);
  407.     }
  408.     else
  409.     {
  410.         croak "Set::IntegerRange::Union(): set size mismatch";
  411.     }
  412. }
  413.  
  414. sub Intersection
  415. {
  416.     croak "Usage: \$set1->Intersection(\$set2,\$set3);"
  417.       if (@_ != 3);
  418.  
  419.     my($set1,$set2,$set3) = @_;
  420.     my($lower1,$upper1) = ($set1->[1],$set1->[2]);
  421.     my($lower2,$upper2) = ($set2->[1],$set2->[2]);
  422.     my($lower3,$upper3) = ($set3->[1],$set3->[2]);
  423.  
  424.     if (($lower1 == $lower2) && ($lower1 == $lower3) &&
  425.         ($upper1 == $upper2) && ($upper1 == $upper3))
  426.     {
  427.         $set1->[0]->Intersection($set2->[0],$set3->[0]);
  428.     }
  429.     else
  430.     {
  431.         croak "Set::IntegerRange::Intersection(): set size mismatch";
  432.     }
  433. }
  434.  
  435. sub Difference
  436. {
  437.     croak "Usage: \$set1->Difference(\$set2,\$set3);"
  438.       if (@_ != 3);
  439.  
  440.     my($set1,$set2,$set3) = @_;
  441.     my($lower1,$upper1) = ($set1->[1],$set1->[2]);
  442.     my($lower2,$upper2) = ($set2->[1],$set2->[2]);
  443.     my($lower3,$upper3) = ($set3->[1],$set3->[2]);
  444.  
  445.     if (($lower1 == $lower2) && ($lower1 == $lower3) &&
  446.         ($upper1 == $upper2) && ($upper1 == $upper3))
  447.     {
  448.         $set1->[0]->Difference($set2->[0],$set3->[0]);
  449.     }
  450.     else
  451.     {
  452.         croak "Set::IntegerRange::Difference(): set size mismatch";
  453.     }
  454. }
  455.  
  456. sub ExclusiveOr
  457. {
  458.     croak "Usage: \$set1->ExclusiveOr(\$set2,\$set3);"
  459.       if (@_ != 3);
  460.  
  461.     my($set1,$set2,$set3) = @_;
  462.     my($lower1,$upper1) = ($set1->[1],$set1->[2]);
  463.     my($lower2,$upper2) = ($set2->[1],$set2->[2]);
  464.     my($lower3,$upper3) = ($set3->[1],$set3->[2]);
  465.  
  466.     if (($lower1 == $lower2) && ($lower1 == $lower3) &&
  467.         ($upper1 == $upper2) && ($upper1 == $upper3))
  468.     {
  469.         $set1->[0]->ExclusiveOr($set2->[0],$set3->[0]);
  470.     }
  471.     else
  472.     {
  473.         croak "Set::IntegerRange::ExclusiveOr(): set size mismatch";
  474.     }
  475. }
  476.  
  477. sub Complement
  478. {
  479.     croak "Usage: \$set1->Complement(\$set2);"
  480.       if (@_ != 2);
  481.  
  482.     my($set1,$set2) = @_;
  483.     my($lower1,$upper1) = ($set1->[1],$set1->[2]);
  484.     my($lower2,$upper2) = ($set2->[1],$set2->[2]);
  485.  
  486.     if (($lower1 == $lower2) && ($upper1 == $upper2))
  487.     {
  488.         $set1->[0]->Complement($set2->[0]);
  489.     }
  490.     else
  491.     {
  492.         croak "Set::IntegerRange::Complement(): set size mismatch";
  493.     }
  494. }
  495.  
  496. sub is_empty
  497. {
  498.     croak "Usage: if (\$set->is_empty())"
  499.       if (@_ != 1);
  500.  
  501.     my($object) = @_;
  502.  
  503.     return( $object->[0]->is_empty() );
  504. }
  505.  
  506. sub is_full
  507. {
  508.     croak "Usage: if (\$set->is_full())"
  509.       if (@_ != 1);
  510.  
  511.     my($object) = @_;
  512.  
  513.     return( $object->[0]->is_full() );
  514. }
  515.  
  516. sub equal
  517. {
  518.     croak "Usage: if (\$set1->equal(\$set2))"
  519.       if (@_ != 2);
  520.  
  521.     my($set1,$set2) = @_;
  522.     my($lower1,$upper1) = ($set1->[1],$set1->[2]);
  523.     my($lower2,$upper2) = ($set2->[1],$set2->[2]);
  524.  
  525.     if (($lower1 == $lower2) && ($upper1 == $upper2))
  526.     {
  527.         return( $set1->[0]->equal($set2->[0]) );
  528.     }
  529.     else
  530.     {
  531.         croak "Set::IntegerRange::equal(): set size mismatch";
  532.     }
  533. }
  534.  
  535. sub subset
  536. {
  537.     croak "Usage: if (\$set1->subset(\$set2))"
  538.       if (@_ != 2);
  539.  
  540.     my($set1,$set2) = @_;
  541.     my($lower1,$upper1) = ($set1->[1],$set1->[2]);
  542.     my($lower2,$upper2) = ($set2->[1],$set2->[2]);
  543.  
  544.     if (($lower1 == $lower2) && ($upper1 == $upper2))
  545.     {
  546.         return( $set1->[0]->subset($set2->[0]) );
  547.     }
  548.     else
  549.     {
  550.         croak "Set::IntegerRange::subset(): set size mismatch";
  551.     }
  552. }
  553.  
  554. sub lexorder
  555. {
  556.     croak "Usage: if (\$set1->lexorder(\$set2))"
  557.       if (@_ != 2);
  558.  
  559.     my($set1,$set2) = @_;
  560.     my($lower1,$upper1) = ($set1->[1],$set1->[2]);
  561.     my($lower2,$upper2) = ($set2->[1],$set2->[2]);
  562.  
  563.     if (($lower1 == $lower2) && ($upper1 == $upper2))
  564.     {
  565.         return( $set1->[0]->lexorder($set2->[0]) );
  566.     }
  567.     else
  568.     {
  569.         croak "Set::IntegerRange::lexorder(): set size mismatch";
  570.     }
  571. }
  572.  
  573. sub Compare
  574. {
  575.     croak "Usage: \$cmp = \$set1->Compare(\$set2);"
  576.       if (@_ != 2);
  577.  
  578.     my($set1,$set2) = @_;
  579.     my($lower1,$upper1) = ($set1->[1],$set1->[2]);
  580.     my($lower2,$upper2) = ($set2->[1],$set2->[2]);
  581.  
  582.     if (($lower1 == $lower2) && ($upper1 == $upper2))
  583.     {
  584.         return( $set1->[0]->Compare($set2->[0]) );
  585.     }
  586.     else
  587.     {
  588.         croak "Set::IntegerRange::Compare(): set size mismatch";
  589.     }
  590. }
  591.  
  592. sub Copy
  593. {
  594.     croak "Usage: \$set1->Copy(\$set2);"
  595.       if (@_ != 2);
  596.  
  597.     my($set1,$set2) = @_;
  598.     my($lower1,$upper1) = ($set1->[1],$set1->[2]);
  599.     my($lower2,$upper2) = ($set2->[1],$set2->[2]);
  600.  
  601.     if (($lower1 == $lower2) && ($upper1 == $upper2))
  602.     {
  603.         $set1->[0]->Copy($set2->[0]);
  604.     }
  605.     else
  606.     {
  607.         croak "Set::IntegerRange::Copy(): set size mismatch";
  608.     }
  609. }
  610.  
  611. sub Shadow
  612. {
  613.     croak "Usage: \$other_set = \$some_set->Shadow();"
  614.       if (@_ != 1);
  615.  
  616.     my($object) = @_;
  617.     my($result);
  618.  
  619.     $result = $object->new($object->[1],$object->[2]);
  620.     return($result);
  621. }
  622.  
  623. sub Clone
  624. {
  625.     croak "Usage: \$twin_set = \$some_set->Clone();"
  626.       if (@_ != 1);
  627.  
  628.     my($object) = @_;
  629.     my($result);
  630.  
  631.     $result = $object->new($object->[1],$object->[2]);
  632.     $result->Copy($object);
  633.     return($result);
  634. }
  635.  
  636. sub Delete
  637. {
  638.     Bit_Off(@_);
  639. }
  640.  
  641. sub Insert
  642. {
  643.     Bit_On(@_);
  644. }
  645.  
  646. sub flip
  647. {
  648.     return( bit_flip(@_) );
  649. }
  650.  
  651. sub contains
  652. {
  653.     return( bit_test(@_) );
  654. }
  655.  
  656. sub in
  657. {
  658.     return( bit_test(@_) );
  659. }
  660.  
  661. sub inclusion
  662. {
  663.     return( subset(@_) );
  664. }
  665.  
  666. sub Empty_Interval
  667. {
  668.     Interval_Empty(@_);
  669. }
  670.  
  671. sub Fill_Interval
  672. {
  673.     Interval_Fill(@_);
  674. }
  675.  
  676. sub Flip_Interval
  677. {
  678.     Interval_Flip(@_);
  679. }
  680.  
  681. sub to_ASCII
  682. {
  683.     croak "Usage: \$string = \$set->to_ASCII();"
  684.       if (@_ != 1);
  685.  
  686.     my($object) = @_;
  687.     my($lower) = $object->[1];
  688.     my($start,$string);
  689.     my($min,$max);
  690.  
  691.     $start = 0;
  692.     $string = '';
  693.     while (($start < $object->[0]->Size()) &&
  694.         (($min,$max) = $object->[0]->Interval_Scan_inc($start)))
  695.     {
  696.         $start = $max + 2;
  697.         $min += $lower;
  698.         $max += $lower;
  699.         if    ($min == $max)   { $string .= "${min},"; }
  700.         elsif ($min == $max-1) { $string .= "${min},${max},"; }
  701.         else                   { $string .= "${min}..${max},"; }
  702.     }
  703.     $string =~ s/,$//;
  704.     return($string);
  705. }
  706.  
  707. sub from_ASCII
  708. {
  709.     croak "Usage: \$set->from_ASCII(\$string);"
  710.       if (@_ != 2);
  711.  
  712.     my($object,$string) = @_;
  713.     my($lower,$upper) = ($object->[1],$object->[2]);
  714.     my(@intervals,$interval);
  715.     my($min,$max);
  716.  
  717.     croak "Set::IntegerRange::from_ASCII(): syntax error in input string"
  718.       unless ($string =~ /^ (?: [+-]? \d+ (?: \.\. [+-]? \d+ )? )
  719.                       (?: , (?: [+-]? \d+ (?: \.\. [+-]? \d+ )? ) )* $/x);
  720.  
  721.     $object->[0]->Empty();
  722.  
  723.     @intervals = split(/,/, $string);
  724.  
  725.     foreach $interval (@intervals)
  726.     {
  727.         if ($interval =~ /\.\./)
  728.         {
  729.             ($min,$max) = split(/\.\./, $interval);
  730.  
  731.             croak "Set::IntegerRange::from_ASCII(): minimum index out of range"
  732.               if (($min < $lower) || ($min > $upper));
  733.  
  734.             croak "Set::IntegerRange::from_ASCII(): maximum index out of range"
  735.               if (($max < $lower) || ($max > $upper));
  736.  
  737.             croak "Set::IntegerRange::from_ASCII(): minimum > maximum index"
  738.               if ($min > $max);
  739.  
  740.             $min -= $lower;
  741.             $max -= $lower;
  742.  
  743.             $object->[0]->Interval_Fill($min,$max);
  744.         }
  745.         else
  746.         {
  747.             croak "Set::IntegerRange::from_ASCII(): index out of range"
  748.               if (($interval < $lower) || ($interval > $upper));
  749.  
  750.             $interval -= $lower;
  751.  
  752.             $object->[0]->Bit_On($interval);
  753.         }
  754.     }
  755. }
  756.  
  757. sub to_String
  758. {
  759.     croak "Usage: \$string = \$set->to_String();"
  760.       if (@_ != 1);
  761.  
  762.     my($object) = @_;
  763.  
  764.     return( $object->[0]->to_String() );
  765. }
  766.  
  767. sub from_String
  768. {
  769.     croak "Usage: \$set->from_String(\$string);"
  770.       if (@_ != 2);
  771.  
  772.     my($object,$string) = @_;
  773.  
  774.     unless ($object->[0]->from_string($string))
  775.     {
  776.         croak "Set::IntegerRange::from_String(): syntax error in input string";
  777.     }
  778. }
  779.  
  780.                 ########################################
  781.                 #                                      #
  782.                 # define overloaded operators section: #
  783.                 #                                      #
  784.                 ########################################
  785.  
  786. sub _string
  787. {
  788.     my($object,$argument,$flag) = @_;
  789. #   my($name) = '""'; #&_trace($name,$object,$argument,$flag);
  790.  
  791.     return( $object->to_ASCII() );
  792. }
  793.  
  794. sub _complement
  795. {
  796.     my($object,$argument,$flag) = @_;
  797. #   my($name) = "'~'"; #&_trace($name,$object,$argument,$flag);
  798.     my($result);
  799.  
  800.     $result = $object->new($object->[1],$object->[2]);
  801.     $result->Complement($object);
  802.     return($result);
  803. }
  804.  
  805. sub _boolean
  806. {
  807.     my($object,$argument,$flag) = @_;
  808. #   my($name) = "bool"; #&_trace($name,$object,$argument,$flag);
  809.  
  810.     return( ! $object->is_empty() );
  811. }
  812.  
  813. sub _not_boolean
  814. {
  815.     my($object,$argument,$flag) = @_;
  816. #   my($name) = "'!'"; #&_trace($name,$object,$argument,$flag);
  817.  
  818.     return( $object->is_empty() );
  819. }
  820.  
  821. sub _norm
  822. {
  823.     my($object,$argument,$flag) = @_;
  824. #   my($name) = "abs"; #&_trace($name,$object,$argument,$flag);
  825.  
  826.     return( $object->Norm() );
  827. }
  828.  
  829. sub _union
  830. {
  831.     my($object,$argument,$flag) = @_;
  832.     my($name) = "'+'"; #&_trace($name,$object,$argument,$flag);
  833.     my($result);
  834.  
  835.     if ((defined $argument) && ref($argument) &&
  836.         (ref($argument) !~ /^SCALAR$|^ARRAY$|^HASH$|^CODE$|^REF$/))
  837.     {
  838.         if (defined $flag)
  839.         {
  840.             $result = $object->new($object->[1],$object->[2]);
  841.             $result->Union($object,$argument);
  842.             return($result);
  843.         }
  844.         else
  845.         {
  846.             $object->Union($object,$argument);
  847.             return($object);
  848.         }
  849.     }
  850.     elsif ((defined $argument) && !(ref($argument)))
  851.     {
  852.         if (defined $flag)
  853.         {
  854.             $result = $object->new($object->[1],$object->[2]);
  855.             $result->Copy($object);
  856.             $result->Bit_On($argument);
  857.             return($result);
  858.         }
  859.         else
  860.         {
  861.             $object->Bit_On($argument);
  862.             return($object);
  863.         }
  864.     }
  865.     else
  866.     {
  867.         croak "Set::IntegerRange $name: wrong argument type";
  868.     }
  869. }
  870.  
  871. sub _difference
  872. {
  873.     my($object,$argument,$flag) = @_;
  874.     my($name) = "'-'"; #&_trace($name,$object,$argument,$flag);
  875.     my($result);
  876.  
  877.     if ((defined $argument) && ref($argument) &&
  878.         (ref($argument) !~ /^SCALAR$|^ARRAY$|^HASH$|^CODE$|^REF$/))
  879.     {
  880.         if (defined $flag)
  881.         {
  882.             $result = $object->new($object->[1],$object->[2]);
  883.             if ($flag) { $result->Difference($argument,$object); }
  884.             else       { $result->Difference($object,$argument); }
  885.             return($result);
  886.         }
  887.         else
  888.         {
  889.             $object->Difference($object,$argument);
  890.             return($object);
  891.         }
  892.     }
  893.     elsif ((defined $argument) && !(ref($argument)))
  894.     {
  895.         if (defined $flag)
  896.         {
  897.             $result = $object->new($object->[1],$object->[2]);
  898.             if ($flag)
  899.             {
  900.                 unless ($object->bit_test($argument))
  901.                 { $result->Bit_On($argument); }
  902.             }
  903.             else
  904.             {
  905.                 $result->Copy($object);
  906.                 $result->Bit_Off($argument);
  907.             }
  908.             return($result);
  909.         }
  910.         else
  911.         {
  912.             $object->Bit_Off($argument);
  913.             return($object);
  914.         }
  915.     }
  916.     else
  917.     {
  918.         croak "Set::IntegerRange $name: wrong argument type";
  919.     }
  920. }
  921.  
  922. sub _intersection
  923. {
  924.     my($object,$argument,$flag) = @_;
  925.     my($name) = "'*'"; #&_trace($name,$object,$argument,$flag);
  926.     my($result);
  927.  
  928.     if ((defined $argument) && ref($argument) &&
  929.         (ref($argument) !~ /^SCALAR$|^ARRAY$|^HASH$|^CODE$|^REF$/))
  930.     {
  931.         if (defined $flag)
  932.         {
  933.             $result = $object->new($object->[1],$object->[2]);
  934.             $result->Intersection($object,$argument);
  935.             return($result);
  936.         }
  937.         else
  938.         {
  939.             $object->Intersection($object,$argument);
  940.             return($object);
  941.         }
  942.     }
  943.     elsif ((defined $argument) && !(ref($argument)))
  944.     {
  945.         if (defined $flag)
  946.         {
  947.             $result = $object->new($object->[1],$object->[2]);
  948.             if ($object->bit_test($argument))
  949.             { $result->Bit_On($argument); }
  950.             return($result);
  951.         }
  952.         else
  953.         {
  954.             $flag = $object->bit_test($argument);
  955.             $object->Empty();
  956.             if ($flag) { $object->Bit_On($argument); }
  957.             return($object);
  958.         }
  959.     }
  960.     else
  961.     {
  962.         croak "Set::IntegerRange $name: wrong argument type";
  963.     }
  964. }
  965.  
  966. sub _exclusive_or
  967. {
  968.     my($object,$argument,$flag) = @_;
  969.     my($name) = "'^'"; #&_trace($name,$object,$argument,$flag);
  970.     my($result);
  971.  
  972.     if ((defined $argument) && ref($argument) &&
  973.         (ref($argument) !~ /^SCALAR$|^ARRAY$|^HASH$|^CODE$|^REF$/))
  974.     {
  975.         if (defined $flag)
  976.         {
  977.             $result = $object->new($object->[1],$object->[2]);
  978.             $result->ExclusiveOr($object,$argument);
  979.             return($result);
  980.         }
  981.         else
  982.         {
  983.             $object->ExclusiveOr($object,$argument);
  984.             return($object);
  985.         }
  986.     }
  987.     elsif ((defined $argument) && !(ref($argument)))
  988.     {
  989.         if (defined $flag)
  990.         {
  991.             $result = $object->new($object->[1],$object->[2]);
  992.             $result->Copy($object);
  993.             $result->bit_flip($argument);
  994.             return($result);
  995.         }
  996.         else
  997.         {
  998.             $object->bit_flip($argument);
  999.             return($object);
  1000.         }
  1001.     }
  1002.     else
  1003.     {
  1004.         croak "Set::IntegerRange $name: wrong argument type";
  1005.     }
  1006. }
  1007.  
  1008. sub _assign_union
  1009. {
  1010.     my($object,$argument,$flag) = @_;
  1011. #   my($name) = "'+='"; #&_trace($name,$object,$argument,$flag);
  1012.  
  1013.     return( &_union($object,$argument,undef) );
  1014. }
  1015.  
  1016. sub _assign_difference
  1017. {
  1018.     my($object,$argument,$flag) = @_;
  1019. #   my($name) = "'-='"; #&_trace($name,$object,$argument,$flag);
  1020.  
  1021.     return( &_difference($object,$argument,undef) );
  1022. }
  1023.  
  1024. sub _assign_intersection
  1025. {
  1026.     my($object,$argument,$flag) = @_;
  1027. #   my($name) = "'*='"; #&_trace($name,$object,$argument,$flag);
  1028.  
  1029.     return( &_intersection($object,$argument,undef) );
  1030. }
  1031.  
  1032. sub _assign_exclusive_or
  1033. {
  1034.     my($object,$argument,$flag) = @_;
  1035. #   my($name) = "'^='"; #&_trace($name,$object,$argument,$flag);
  1036.  
  1037.     return( &_exclusive_or($object,$argument,undef) );
  1038. }
  1039.  
  1040. sub _equal
  1041. {
  1042.     my($object,$argument,$flag) = @_;
  1043.     my($name) = "'=='"; #&_trace($name,$object,$argument,$flag);
  1044.     my($result);
  1045.  
  1046.     if ((defined $argument) && ref($argument) &&
  1047.         (ref($argument) !~ /^SCALAR$|^ARRAY$|^HASH$|^CODE$|^REF$/))
  1048.     {
  1049.         $result = $argument;
  1050.     }
  1051.     elsif ((defined $argument) && !(ref($argument)))
  1052.     {
  1053.         $result = $object->new($object->[1],$object->[2]);
  1054.         $result->Bit_On($argument);
  1055.     }
  1056.     else
  1057.     {
  1058.         croak "Set::IntegerRange $name: wrong argument type";
  1059.     }
  1060.     return( $object->equal($result) );
  1061. }
  1062.  
  1063. sub _not_equal
  1064. {
  1065.     my($object,$argument,$flag) = @_;
  1066.     my($name) = "'!='"; #&_trace($name,$object,$argument,$flag);
  1067.     my($result);
  1068.  
  1069.     if ((defined $argument) && ref($argument) &&
  1070.         (ref($argument) !~ /^SCALAR$|^ARRAY$|^HASH$|^CODE$|^REF$/))
  1071.     {
  1072.         $result = $argument;
  1073.     }
  1074.     elsif ((defined $argument) && !(ref($argument)))
  1075.     {
  1076.         $result = $object->new($object->[1],$object->[2]);
  1077.         $result->Bit_On($argument);
  1078.     }
  1079.     else
  1080.     {
  1081.         croak "Set::IntegerRange $name: wrong argument type";
  1082.     }
  1083.     return( !($object->equal($result)) );
  1084. }
  1085.  
  1086. sub _true_sub_set
  1087. {
  1088.     my($object,$argument,$flag) = @_;
  1089.     my($name) = "'<'"; #&_trace($name,$object,$argument,$flag);
  1090.     my($result);
  1091.  
  1092.     if ((defined $argument) && ref($argument) &&
  1093.         (ref($argument) !~ /^SCALAR$|^ARRAY$|^HASH$|^CODE$|^REF$/))
  1094.     {
  1095.         $result = $argument;
  1096.     }
  1097.     elsif ((defined $argument) && !(ref($argument)))
  1098.     {
  1099.         $result = $object->new($object->[1],$object->[2]);
  1100.         $result->Bit_On($argument);
  1101.     }
  1102.     else
  1103.     {
  1104.         croak "Set::IntegerRange $name: wrong argument type";
  1105.     }
  1106.     if ((defined $flag) && $flag)
  1107.     {
  1108.         return( !($result->equal($object)) &&
  1109.                  ($result->subset($object)) );
  1110.     }
  1111.     else
  1112.     {
  1113.         return( !($object->equal($result)) &&
  1114.                  ($object->subset($result)) );
  1115.     }
  1116. }
  1117.  
  1118. sub _sub_set
  1119. {
  1120.     my($object,$argument,$flag) = @_;
  1121.     my($name) = "'<='"; #&_trace($name,$object,$argument,$flag);
  1122.     my($result);
  1123.  
  1124.     if ((defined $argument) && ref($argument) &&
  1125.         (ref($argument) !~ /^SCALAR$|^ARRAY$|^HASH$|^CODE$|^REF$/))
  1126.     {
  1127.         $result = $argument;
  1128.     }
  1129.     elsif ((defined $argument) && !(ref($argument)))
  1130.     {
  1131.         $result = $object->new($object->[1],$object->[2]);
  1132.         $result->Bit_On($argument);
  1133.     }
  1134.     else
  1135.     {
  1136.         croak "Set::IntegerRange $name: wrong argument type";
  1137.     }
  1138.     if ((defined $flag) && $flag)
  1139.     {
  1140.         return( $result->subset($object) );
  1141.     }
  1142.     else
  1143.     {
  1144.         return( $object->subset($result) );
  1145.     }
  1146. }
  1147.  
  1148. sub _true_super_set
  1149. {
  1150.     my($object,$argument,$flag) = @_;
  1151.     my($name) = "'>'"; #&_trace($name,$object,$argument,$flag);
  1152.     my($result);
  1153.  
  1154.     if ((defined $argument) && ref($argument) &&
  1155.         (ref($argument) !~ /^SCALAR$|^ARRAY$|^HASH$|^CODE$|^REF$/))
  1156.     {
  1157.         $result = $argument;
  1158.     }
  1159.     elsif ((defined $argument) && !(ref($argument)))
  1160.     {
  1161.         $result = $object->new($object->[1],$object->[2]);
  1162.         $result->Bit_On($argument);
  1163.     }
  1164.     else
  1165.     {
  1166.         croak "Set::IntegerRange $name: wrong argument type";
  1167.     }
  1168.     if ((defined $flag) && $flag)
  1169.     {
  1170.         return( !($object->equal($result)) &&
  1171.                  ($object->subset($result)) );
  1172.     }
  1173.     else
  1174.     {
  1175.         return( !($result->equal($object)) &&
  1176.                  ($result->subset($object)) );
  1177.     }
  1178. }
  1179.  
  1180. sub _super_set
  1181. {
  1182.     my($object,$argument,$flag) = @_;
  1183.     my($name) = "'>='"; #&_trace($name,$object,$argument,$flag);
  1184.     my($result);
  1185.  
  1186.     if ((defined $argument) && ref($argument) &&
  1187.         (ref($argument) !~ /^SCALAR$|^ARRAY$|^HASH$|^CODE$|^REF$/))
  1188.     {
  1189.         $result = $argument;
  1190.     }
  1191.     elsif ((defined $argument) && !(ref($argument)))
  1192.     {
  1193.         $result = $object->new($object->[1],$object->[2]);
  1194.         $result->Bit_On($argument);
  1195.     }
  1196.     else
  1197.     {
  1198.         croak "Set::IntegerRange $name: wrong argument type";
  1199.     }
  1200.     if ((defined $flag) && $flag)
  1201.     {
  1202.         return( $object->subset($result) );
  1203.     }
  1204.     else
  1205.     {
  1206.         return( $result->subset($object) );
  1207.     }
  1208. }
  1209.  
  1210. sub _compare
  1211. {
  1212.     my($object,$argument,$flag) = @_;
  1213.     my($name) = "cmp"; #&_trace($name,$object,$argument,$flag);
  1214.     my($result);
  1215.  
  1216.     if ((defined $argument) && ref($argument) &&
  1217.         (ref($argument) !~ /^SCALAR$|^ARRAY$|^HASH$|^CODE$|^REF$/))
  1218.     {
  1219.         $result = $argument;
  1220.     }
  1221.     elsif ((defined $argument) && !(ref($argument)))
  1222.     {
  1223.         $result = $object->new($object->[1],$object->[2]);
  1224.         $result->Bit_On($argument);
  1225.     }
  1226.     else
  1227.     {
  1228.         croak "Set::IntegerRange $name: wrong argument type";
  1229.     }
  1230.     if ((defined $flag) && $flag)
  1231.     {
  1232.         return( $result->Compare($object) );
  1233.     }
  1234.     else
  1235.     {
  1236.         return( $object->Compare($result) );
  1237.     }
  1238. }
  1239.  
  1240. sub _clone
  1241. {
  1242.     my($object,$argument,$flag) = @_;
  1243. #   my($name) = "'='"; #&_trace($name,$object,$argument,$flag);
  1244.     my($result);
  1245.  
  1246.     $result = $object->new($object->[1],$object->[2]);
  1247.     $result->Copy($object);
  1248.     return($result);
  1249. }
  1250.  
  1251. sub _trace
  1252. {
  1253.     my($text,$object,$argument,$flag) = @_;
  1254.  
  1255.     unless (defined $object)   { $object   = 'undef'; };
  1256.     unless (defined $argument) { $argument = 'undef'; };
  1257.     unless (defined $flag)     { $flag     = 'undef'; };
  1258.     if (ref($object))   { $object   = ref($object);   }
  1259.     if (ref($argument)) { $argument = ref($argument); }
  1260.     print "$text: \$obj='$object' \$arg='$argument' \$flag='$flag'\n";
  1261. }
  1262.  
  1263. 1;
  1264.  
  1265. __END__
  1266.  
  1267. =head1 NAME
  1268.  
  1269. Set::IntegerRange - Sets of Integers
  1270.  
  1271. Easy manipulation of sets of integers (arbitrary intervals)
  1272.  
  1273. =head1 SYNOPSIS
  1274.  
  1275. =head2 METHODS
  1276.  
  1277.   Version
  1278.       $version = $Set::IntegerRange::VERSION;
  1279.  
  1280.   new
  1281.       $set = new Set::IntegerRange($lower,$upper);
  1282.       $set = Set::IntegerRange->new($lower,$upper);
  1283.       $set = $any_set->new($lower,$upper);
  1284.  
  1285.   Resize
  1286.       $set->Resize($lower,$upper);
  1287.  
  1288.   Size
  1289.       ($lower,$upper) = $set->Size();
  1290.  
  1291.   Empty
  1292.       $set->Empty();
  1293.  
  1294.   Fill
  1295.       $set->Fill();
  1296.  
  1297.   Flip
  1298.       $set->Flip();
  1299.  
  1300.   Interval_Empty
  1301.       $set->Interval_Empty($lower,$upper);
  1302.       $set->Empty_Interval($lower,$upper); # (deprecated)
  1303.  
  1304.   Interval_Fill
  1305.       $set->Interval_Fill($lower,$upper);
  1306.       $set->Fill_Interval($lower,$upper);  # (deprecated)
  1307.  
  1308.   Interval_Flip
  1309.       $set->Interval_Flip($lower,$upper);
  1310.       $set->Flip_Interval($lower,$upper);  # (deprecated)
  1311.  
  1312.   Interval_Scan_inc
  1313.       while (($min,$max) = $set->Interval_Scan_inc($start))
  1314.  
  1315.   Interval_Scan_dec
  1316.       while (($min,$max) = $set->Interval_Scan_dec($start))
  1317.  
  1318.   Bit_Off
  1319.       $set->Bit_Off($index);
  1320.       $set->Delete($index);                # (deprecated)
  1321.  
  1322.   Bit_On
  1323.       $set->Bit_On($index);
  1324.       $set->Insert($index);                # (deprecated)
  1325.  
  1326.   bit_flip
  1327.       $bit = $set->bit_flip($index);
  1328.       if ($set->bit_flip($index))
  1329.       $bit = $set->flip($index);           # (deprecated)
  1330.       if ($set->flip($index))              # (deprecated)
  1331.  
  1332.   bit_test
  1333.       $bit = $set->bit_test($index);
  1334.       if ($set->bit_test($index))
  1335.       $bit = $set->contains($index);
  1336.       if ($set->contains($index))
  1337.       $bit = $set->in($index);             # (deprecated)
  1338.       if ($set->in($index))                # (deprecated)
  1339.  
  1340.   Norm
  1341.       $norm = $set->Norm();
  1342.  
  1343.   Min
  1344.       $min = $set->Min();
  1345.  
  1346.   Max
  1347.       $max = $set->Max();
  1348.  
  1349.   Union
  1350.       $set1->Union($set2,$set3);           # in-place is possible!
  1351.  
  1352.   Intersection
  1353.       $set1->Intersection($set2,$set3);    # in-place is possible!
  1354.  
  1355.   Difference
  1356.       $set1->Difference($set2,$set3);      # in-place is possible!
  1357.  
  1358.   ExclusiveOr
  1359.       $set1->ExclusiveOr($set2,$set3);     # in-place is possible!
  1360.  
  1361.   Complement
  1362.       $set1->Complement($set2);            # in-place is possible!
  1363.  
  1364.   is_empty
  1365.       if ($set->is_empty())
  1366.  
  1367.   is_full
  1368.       if ($set->is_full())
  1369.  
  1370.   equal
  1371.       if ($set1->equal($set2))
  1372.  
  1373.   subset
  1374.       if ($set1->subset($set2))
  1375.       if ($set1->inclusion($set2))         # (deprecated)
  1376.  
  1377.   lexorder
  1378.       if ($set1->lexorder($set2))
  1379.  
  1380.   Compare
  1381.       $cmp = $set1->Compare($set2);
  1382.  
  1383.   Copy
  1384.       $set1->Copy($set2);
  1385.  
  1386.   Shadow
  1387.       $other_set = $some_set->Shadow();
  1388.  
  1389.   Clone
  1390.       $twin_set = $some_set->Clone();
  1391.  
  1392.   to_ASCII
  1393.       $string = $set->to_ASCII();          # e.g., "-8..-5,-1..2,4,6..9"
  1394.  
  1395.   from_ASCII
  1396.       eval { $set->from_ASCII($string); };
  1397.  
  1398.   to_String
  1399.       $string = $set->to_String();         # e.g., "0007AF1E"
  1400.  
  1401.   from_String
  1402.       eval { $set->from_String($string); };
  1403.  
  1404.   BitVector
  1405.       $set->BitVector->any_Bit_Vector_method();
  1406.  
  1407. =head2 OVERLOADED OPERATORS
  1408.  
  1409.       # "$index" is a number or a Perl scalar variable containing a
  1410.       # number which represents the set containing only that element:
  1411.  
  1412.   Emptyness
  1413.       if ($set) # if not empty
  1414.       if (! $set) # if empty
  1415.       unless ($set) # if empty
  1416.  
  1417.   Equality
  1418.       if ($set1 == $set2)
  1419.       if ($set1 != $set2)
  1420.       if ($set == $index)
  1421.       if ($set != $index)
  1422.  
  1423.   Lexical Comparison
  1424.       $cmp = $set1 cmp $set2;
  1425.       if ($set1 lt $set2)
  1426.       if ($set1 le $set2)
  1427.       if ($set1 gt $set2)
  1428.       if ($set1 ge $set2)
  1429.       if ($set1 eq $set2)
  1430.       if ($set1 ne $set2)
  1431.       $cmp = $set cmp $index;
  1432.       if ($set lt $index)
  1433.       if ($set le $index)
  1434.       if ($set gt $index)
  1435.       if ($set ge $index)
  1436.       if ($set eq $index)
  1437.       if ($set ne $index)
  1438.  
  1439.   String Conversion
  1440.       $string = "$set";
  1441.       print "\$set = '$set'\n";
  1442.  
  1443.   Union
  1444.       $set1 = $set2 + $set3;
  1445.       $set1 += $set2;
  1446.       $set1 = $set2 | $set3;
  1447.       $set1 |= $set2;
  1448.       $set1 = $set2 + $index;
  1449.       $set += $index;
  1450.       $set1 = $set2 | $index;
  1451.       $set |= $index;
  1452.  
  1453.   Intersection
  1454.       $set1 = $set2 * $set3;
  1455.       $set1 *= $set2;
  1456.       $set1 = $set2 & $set3;
  1457.       $set1 &= $set2;
  1458.       $set1 = $set2 * $index;
  1459.       $set *= $index;
  1460.       $set1 = $set2 & $index;
  1461.       $set &= $index;
  1462.  
  1463.   Difference
  1464.       $set1 = $set2 - $set3;
  1465.       $set1 -= $set2;
  1466.       $set1 = $set2 - $set1;
  1467.       $set1 = $set2 - $index;
  1468.       $set1 = $index - $set2;
  1469.       $set -= $index;
  1470.  
  1471.   ExclusiveOr
  1472.       $set1 = $set2 ^ $set3;
  1473.       $set1 ^= $set2;
  1474.       $set1 = $set2 ^ $index;
  1475.       $set ^= $index;
  1476.  
  1477.   Complement
  1478.       $set1 = -$set2;
  1479.       $set1 = ~$set2;
  1480.       $set = -$set;
  1481.       $set = ~$set;
  1482.  
  1483.   Subset Relationship
  1484.       if ($set1 <= $set2)
  1485.  
  1486.   True Subset Relationship
  1487.       if ($set1 < $set2)
  1488.  
  1489.   Superset Relationship
  1490.       if ($set1 >= $set2)
  1491.  
  1492.   True Superset Relationship
  1493.       if ($set1 > $set2)
  1494.  
  1495.   Norm
  1496.       $norm = abs($set);
  1497.  
  1498. =head1 DESCRIPTION
  1499.  
  1500. This class lets you dynamically create sets of arbitrary intervals of
  1501. integers and perform all the basic operations for sets on them (for a
  1502. list of available methods and operators, see above).
  1503.  
  1504. See L<Bit::Vector(3)> for more details!
  1505.  
  1506. =head1 SEE ALSO
  1507.  
  1508. Bit::Vector(3), Set::IntegerFast(3), Math::MatrixBool(3),
  1509. Math::MatrixReal(3), DFA::Kleene(3), Math::Kleene(3),
  1510. Graph::Kruskal(3).
  1511.  
  1512. =head1 VERSION
  1513.  
  1514. This man page documents "Set::IntegerRange" version 4.2.
  1515.  
  1516. =head1 AUTHOR
  1517.  
  1518. Steffen Beyer <sb@sdm.de>.
  1519.  
  1520. =head1 COPYRIGHT
  1521.  
  1522. Copyright (c) 1996, 1997 by Steffen Beyer. All rights reserved.
  1523.  
  1524. =head1 LICENSE
  1525.  
  1526. This package is free software; you can redistribute it and/or
  1527. modify it under the same terms as Perl itself.
  1528.  
  1529.