File Coverage

blib/lib/Math/MatrixBool.pm

Criterion	Covered	Total	%
statement	164	446	36.7
branch	41	198	20.7
condition	19	208	9.1
subroutine	24	70	34.2
pod	0	38	0.0
total	248	960	25.8

#  Copyright (c) 1995 - 2009 by Steffen Beyer.
#  All rights reserved.
#  This package is free software; you can redistribute it and/or
#  modify it under the same terms as Perl itself.

package Math::MatrixBool;

use strict;
use vars qw(@ISA @EXPORT @EXPORT_OK $VERSION);

require Exporter;

@ISA = qw(Exporter);

@EXPORT = qw();

@EXPORT_OK = qw();

$VERSION = '5.8';

use Carp;

use Bit::Vector 7.1;

use overload
     'neg' => '_complement',
       '~' => '_transpose',
    'bool' => '_boolean',
       '!' => '_not_boolean',
      '""' => '_string',
     'abs' => '_number_of_elements',
       '+' => '_addition',
       '*' => '_multiplication',
       '|' => '_union',
       '-' => '_difference',
       '&' => '_intersection',
       '^' => '_exclusive_or',
      '+=' => '_assign_addition',
      '*=' => '_assign_multiplication',
      '|=' => '_assign_union',
      '-=' => '_assign_difference',
      '&=' => '_assign_intersection',
      '^=' => '_assign_exclusive_or',
      '==' => '_equal',
      '!=' => '_not_equal',
       '<' => '_true_sub_set',
      '<=' => '_sub_set',
       '>' => '_true_super_set',
      '>=' => '_super_set',
     'cmp' => '_compare',
       '=' => '_clone',
'fallback' =>   undef;

sub new
{
    croak "Usage: \$new_matrix = Math::MatrixBool->new(\$rows,\$columns);"
      if (@_ != 3);

    my $proto = shift;
    my $class = ref($proto) || $proto || 'Math::MatrixBool';
    my $rows = shift;
    my $cols = shift;
    my $object;
    my $matrix;

    croak "Math::MatrixBool::new(): number of rows must be > 0"
      if ($rows <= 0);

    croak "Math::MatrixBool::new(): number of columns must be > 0"
      if ($cols <= 0);

    $matrix = Bit::Vector->new($rows * $cols);
    if ((defined $matrix) && ref($matrix) && (${$matrix} != 0))
    {
        $object = [ $matrix, $rows, $cols ];
        bless($object, $class);
        return($object);
    }
    else
    {
        croak
  "Math::MatrixBool::new(): unable to create new 'Math::MatrixBool' object";
    }
}

sub new_from_string
{
    croak "Usage: \$new_matrix = Math::MatrixBool->new_from_string(\$string);"
      if (@_ != 2);

    my $proto  = shift;
    my $class  = ref($proto) || $proto || 'Math::MatrixBool';
    my $string = shift;
    my($line,$values);
    my($rows,$cols);
    my($row,$col);
    my($warn);
    my($object);

    $warn = 0;
    $rows = 0;
    $cols = 0;
    $values = [ ];
    while ($string =~ m!^\s* \[ \s+ ( (?: (?: 0|1 ) \s+ )+ ) \] \s*? \n !x)
    {
        $line = $1;
        $string = $';
        $values->[$rows] = [ ];
        @{$values->[$rows]} = split(' ', $line);
        $col = @{$values->[$rows]};
        if ($col != $cols)
        {
            unless ($cols == 0) { $warn = 1; }
            if ($col > $cols) { $cols = $col; }
        }
        $rows++;
    }
    if ($string !~ m!^\s*$!)
    {
        croak "Math::MatrixBool::new_from_string(): syntax error in input string";
    }
    if ($rows == 0)
    {
        croak "Math::MatrixBool::new_from_string(): empty input string";
    }
    if ($warn)
    {
        warn "Math::MatrixBool::new_from_string(): missing elements will be set to zero!\n";
    }
    $object = Math::MatrixBool::new($class,$rows,$cols);
    for ( $row = 0; $row < $rows; $row++ )
    {
        for ( $col = 0; $col < @{$values->[$row]}; $col++ )
        {
            if ($values->[$row][$col] != 0)
            {
                $object->[0]->Bit_On( $row * $cols + $col );
            }
        }
    }
    return($object);
}

sub Dim  #  Returns dimensions of a matrix
{
    croak "Usage: (\$rows,\$columns) = \$matrix->Dim();"
      if (@_ != 1);

    my($matrix) = @_;

    return( $matrix->[1], $matrix->[2] );
}

sub Empty
{
    croak "Usage: \$matrix->Empty();"
      if (@_ != 1);

    my($object) = @_;

    $object->[0]->Empty();
}

sub Fill
{
    croak "Usage: \$matrix->Fill();"
      if (@_ != 1);

    my($object) = @_;

    $object->[0]->Fill();
}

sub Flip
{
    croak "Usage: \$matrix->Flip();"
      if (@_ != 1);

    my($object) = @_;

    $object->[0]->Flip();
}

sub Zero
{
    croak "Usage: \$matrix->Zero();"
      if (@_ != 1);

    my($object) = @_;

    $object->[0]->Empty();
}

sub One  #  Fills main diagonal
{
    croak "Usage: \$matrix->One();"
      if (@_ != 1);

    my($object) = @_;
    my($rows,$cols) = ($object->[1],$object->[2]);
    my($i,$k);

    $object->[0]->Empty();
    $k = ($rows <= $cols) ? $rows : $cols;
    for ( $i = 0; $i < $k; $i++ )
    {
        $object->[0]->Bit_On( $i * $cols + $i );
    }
}

sub Bit_On
{
    croak "Usage: \$matrix->Bit_On(\$row,\$column);"
      if (@_ != 3);

    my($object,$row,$col) = @_;
    my($rows,$cols) = ($object->[1],$object->[2]);

    croak "Math::MatrixBool::Bit_On(): row index out of range"
      if (($row < 1) || ($row > $rows));
    croak "Math::MatrixBool::Bit_On(): column index out of range"
      if (($col < 1) || ($col > $cols));

    $object->[0]->Bit_On( --$row * $cols + --$col );
}

sub Insert
{
    Bit_On(@_);
}

sub Bit_Off
{
    croak "Usage: \$matrix->Bit_Off(\$row,\$column);"
      if (@_ != 3);

    my($object,$row,$col) = @_;
    my($rows,$cols) = ($object->[1],$object->[2]);

    croak "Math::MatrixBool::Bit_Off(): row index out of range"
      if (($row < 1) || ($row > $rows));
    croak "Math::MatrixBool::Bit_Off(): column index out of range"
      if (($col < 1) || ($col > $cols));

    $object->[0]->Bit_Off( --$row * $cols + --$col );
}

sub Delete
{
    Bit_Off(@_);
}

sub bit_flip
{
    croak "Usage: \$boolean = \$matrix->bit_flip(\$row,\$column);"
      if (@_ != 3);

    my($object,$row,$col) = @_;
    my($rows,$cols) = ($object->[1],$object->[2]);

    croak "Math::MatrixBool::bit_flip(): row index out of range"
      if (($row < 1) || ($row > $rows));
    croak "Math::MatrixBool::bit_flip(): column index out of range"
      if (($col < 1) || ($col > $cols));

    return( $object->[0]->bit_flip( --$row * $cols + --$col ) );
}

sub flip
{
    return( bit_flip(@_) );
}

sub bit_test
{
    croak "Usage: \$boolean = \$matrix->bit_test(\$row,\$column);"
      if (@_ != 3);

    my($object,$row,$col) = @_;
    my($rows,$cols) = ($object->[1],$object->[2]);

    croak "Math::MatrixBool::bit_test(): row index out of range"
      if (($row < 1) || ($row > $rows));
    croak "Math::MatrixBool::bit_test(): column index out of range"
      if (($col < 1) || ($col > $cols));

    return( $object->[0]->bit_test( --$row * $cols + --$col ) );
}

sub contains
{
    return( bit_test(@_) );
}

sub in
{
    return( bit_test(@_) );
}

sub Number_of_elements  #  returns the number of elements which are set
{
    croak "Usage: \$elements = \$matrix->Number_of_elements();"
      if (@_ != 1);

    my($object) = @_;

    return( $object->[0]->Norm() );
}

sub Norm_max  #  Maximum of sums of each row
{
    croak "Usage: \$norm_max = \$matrix->Norm_max();"
      if (@_ != 1);

    my($object) = @_;
    my($rows,$cols) = ($object->[1],$object->[2]);
    my($max,$sum,$i,$j);

    $max = 0;
    for ( $i = 0; $i < $rows; $i++ )
    {
        $sum = 0;
        for ( $j = 0; $j < $cols; $j++ )
        {
            $sum ^= $object->[0]->bit_test( $i * $cols + $j );
            # in general, this is $sum += abs( $matrix[$i][$j] );
        }
        if ($sum > $max) { $max = $sum; }
    }
    return($max);
}

sub Norm_one  #  Maximum of sums of each column
{
    croak "Usage: \$norm_one = \$matrix->Norm_one();"
      if (@_ != 1);

    my($object) = @_;
    my($rows,$cols) = ($object->[1],$object->[2]);
    my($max,$sum,$i,$j);

    $max = 0;
    for ( $j = 0; $j < $cols; $j++ )
    {
        $sum = 0;
        for ( $i = 0; $i < $rows; $i++ )
        {
            $sum ^= $object->[0]->bit_test( $i * $cols + $j );
            # in general, this is $sum += abs( $matrix[$i][$j] );
        }
        if ($sum > $max) { $max = $sum; }
    }
    return($max);
}

sub Addition
{
    croak "Usage: \$matrix1->Addition(\$matrix2,\$matrix3);"
      if (@_ != 3);

    my($matrix1,$matrix2,$matrix3) = @_;
    my($rows1,$cols1) = ($matrix1->[1],$matrix1->[2]);
    my($rows2,$cols2) = ($matrix2->[1],$matrix2->[2]);
    my($rows3,$cols3) = ($matrix3->[1],$matrix3->[2]);

    if (($rows1 == $rows2) && ($rows1 == $rows3) &&
        ($cols1 == $cols2) && ($cols1 == $cols3))
    {
        $matrix1->[0]->ExclusiveOr($matrix2->[0],$matrix3->[0]);
    }
    else
    {
        croak "Math::MatrixBool::Addition(): matrix size mismatch";
    }
}

sub Multiplication
{
    croak "Usage: \$product_matrix = \$matrix1->Multiplication(\$matrix2);"
      if (@_ != 2);

    my($matrix1,$matrix2) = @_;
    my($rows1,$cols1) = ($matrix1->[1],$matrix1->[2]);
    my($rows2,$cols2) = ($matrix2->[1],$matrix2->[2]);
    my($result);

    if ($cols1 == $rows2)
    {
        $result = $matrix1->new($rows1,$cols2);
        $result->[0]->Multiplication($rows1,$cols2,
                       $matrix1->[0],$rows1,$cols1,
                       $matrix2->[0],$rows2,$cols2);
    }
    else
    {
        croak "Math::MatrixBool::Multiplication(): matrix size mismatch";
    }
    return($result);
}

sub Product
{
    croak "Usage: \$product_matrix = \$matrix1->Product(\$matrix2);"
      if (@_ != 2);

    my($matrix1,$matrix2) = @_;
    my($rows1,$cols1) = ($matrix1->[1],$matrix1->[2]);
    my($rows2,$cols2) = ($matrix2->[1],$matrix2->[2]);
    my($result);

    if ($cols1 == $rows2)
    {
        $result = $matrix1->new($rows1,$cols2);
        $result->[0]->Product($rows1,$cols2,
                $matrix1->[0],$rows1,$cols1,
                $matrix2->[0],$rows2,$cols2);
    }
    else
    {
        croak "Math::MatrixBool::Product(): matrix size mismatch";
    }
    return($result);
}

sub Kleene
{
    croak "Usage: \$closure = \$matrix->Kleene();"
      if (@_ != 1);

    my($matrix) = @_;
    my($rows,$cols) = ($matrix->[1],$matrix->[2]);
    my($result);

    croak "Math::MatrixBool::Kleene(): not a square matrix"
      if ($rows != $cols);

    $result = $matrix->new($rows,$cols);
    $result->Copy($matrix);
    $result->[0]->Closure($rows,$cols);

    return($result);
}

sub Union
{
    croak "Usage: \$matrix1->Union(\$matrix2,\$matrix3);"
      if (@_ != 3);

    my($matrix1,$matrix2,$matrix3) = @_;
    my($rows1,$cols1) = ($matrix1->[1],$matrix1->[2]);
    my($rows2,$cols2) = ($matrix2->[1],$matrix2->[2]);
    my($rows3,$cols3) = ($matrix3->[1],$matrix3->[2]);

    if (($rows1 == $rows2) && ($rows1 == $rows3) &&
        ($cols1 == $cols2) && ($cols1 == $cols3))
    {
        $matrix1->[0]->Union($matrix2->[0],$matrix3->[0]);
    }
    else
    {
        croak "Math::MatrixBool::Union(): matrix size mismatch";
    }
}

sub Intersection
{
    croak "Usage: \$matrix1->Intersection(\$matrix2,\$matrix3);"
      if (@_ != 3);

    my($matrix1,$matrix2,$matrix3) = @_;
    my($rows1,$cols1) = ($matrix1->[1],$matrix1->[2]);
    my($rows2,$cols2) = ($matrix2->[1],$matrix2->[2]);
    my($rows3,$cols3) = ($matrix3->[1],$matrix3->[2]);

    if (($rows1 == $rows2) && ($rows1 == $rows3) &&
        ($cols1 == $cols2) && ($cols1 == $cols3))
    {
        $matrix1->[0]->Intersection($matrix2->[0],$matrix3->[0]);
    }
    else
    {
        croak "Math::MatrixBool::Intersection(): matrix size mismatch";
    }
}

sub Difference
{
    croak "Usage: \$matrix1->Difference(\$matrix2,\$matrix3);"
      if (@_ != 3);

    my($matrix1,$matrix2,$matrix3) = @_;
    my($rows1,$cols1) = ($matrix1->[1],$matrix1->[2]);
    my($rows2,$cols2) = ($matrix2->[1],$matrix2->[2]);
    my($rows3,$cols3) = ($matrix3->[1],$matrix3->[2]);

    if (($rows1 == $rows2) && ($rows1 == $rows3) &&
        ($cols1 == $cols2) && ($cols1 == $cols3))
    {
        $matrix1->[0]->Difference($matrix2->[0],$matrix3->[0]);
    }
    else
    {
        croak "Math::MatrixBool::Difference(): matrix size mismatch";
    }
}

sub ExclusiveOr
{
    croak "Usage: \$matrix1->ExclusiveOr(\$matrix2,\$matrix3);"
      if (@_ != 3);

    my($matrix1,$matrix2,$matrix3) = @_;
    my($rows1,$cols1) = ($matrix1->[1],$matrix1->[2]);
    my($rows2,$cols2) = ($matrix2->[1],$matrix2->[2]);
    my($rows3,$cols3) = ($matrix3->[1],$matrix3->[2]);

    if (($rows1 == $rows2) && ($rows1 == $rows3) &&
        ($cols1 == $cols2) && ($cols1 == $cols3))
    {
        $matrix1->[0]->ExclusiveOr($matrix2->[0],$matrix3->[0]);
    }
    else
    {
        croak "Math::MatrixBool::ExclusiveOr(): matrix size mismatch";
    }
}

sub Complement
{
    croak "Usage: \$matrix1->Complement(\$matrix2);"
      if (@_ != 2);

    my($matrix1,$matrix2) = @_;
    my($rows1,$cols1) = ($matrix1->[1],$matrix1->[2]);
    my($rows2,$cols2) = ($matrix2->[1],$matrix2->[2]);

    if (($rows1 == $rows2) && ($cols1 == $cols2))
    {
        $matrix1->[0]->Complement($matrix2->[0]);
    }
    else
    {
        croak "Math::MatrixBool::Complement(): matrix size mismatch";
    }
}

sub Transpose
{
    croak "Usage: \$matrix1->Transpose(\$matrix2);"
      if (@_ != 2);

    my($matrix1,$matrix2) = @_;
    my($rows1,$cols1) = ($matrix1->[1],$matrix1->[2]);
    my($rows2,$cols2) = ($matrix2->[1],$matrix2->[2]);

    if (($rows1 == $cols2) && ($cols1 == $rows2))
    {
        $matrix1->[0]->Transpose($rows1,$cols1,$matrix2->[0],$rows2,$cols2);
    }
    else
    {
        croak "Math::MatrixBool::Transpose(): matrix size mismatch";
    }
}

sub equal
{
    croak "Usage: \$boolean = \$matrix1->equal(\$matrix2);"
      if (@_ != 2);

    my($matrix1,$matrix2) = @_;
    my($rows1,$cols1) = ($matrix1->[1],$matrix1->[2]);
    my($rows2,$cols2) = ($matrix2->[1],$matrix2->[2]);

    if (($rows1 == $rows2) && ($cols1 == $cols2))
    {
        return( $matrix1->[0]->equal($matrix2->[0]) );
    }
    else
    {
        croak "Math::MatrixBool::equal(): matrix size mismatch";
    }
}

sub subset
{
    croak "Usage: \$boolean = \$matrix1->subset(\$matrix2);"
      if (@_ != 2);

    my($matrix1,$matrix2) = @_;
    my($rows1,$cols1) = ($matrix1->[1],$matrix1->[2]);
    my($rows2,$cols2) = ($matrix2->[1],$matrix2->[2]);

    if (($rows1 == $rows2) && ($cols1 == $cols2))
    {
        return( $matrix1->[0]->subset($matrix2->[0]) );
    }
    else
    {
        croak "Math::MatrixBool::subset(): matrix size mismatch";
    }
}

sub inclusion
{
    return( subset(@_) );
}

sub lexorder
{
    croak "Usage: \$boolean = \$matrix1->lexorder(\$matrix2);"
      if (@_ != 2);

    my($matrix1,$matrix2) = @_;
    my($rows1,$cols1) = ($matrix1->[1],$matrix1->[2]);
    my($rows2,$cols2) = ($matrix2->[1],$matrix2->[2]);

    if (($rows1 == $rows2) && ($cols1 == $cols2))
    {
        return( $matrix1->[0]->lexorder($matrix2->[0]) );
    }
    else
    {
        croak "Math::MatrixBool::lexorder(): matrix size mismatch";
    }
}

sub Compare
{
    croak "Usage: \$result = \$matrix1->Compare(\$matrix2);"
      if (@_ != 2);

    my($matrix1,$matrix2) = @_;
    my($rows1,$cols1) = ($matrix1->[1],$matrix1->[2]);
    my($rows2,$cols2) = ($matrix2->[1],$matrix2->[2]);

    if (($rows1 == $rows2) && ($cols1 == $cols2))
    {
        return( $matrix1->[0]->Compare($matrix2->[0]) );
    }
    else
    {
        croak "Math::MatrixBool::Compare(): matrix size mismatch";
    }
}

sub Copy
{
    croak "Usage: \$matrix1->Copy(\$matrix2);"
      if (@_ != 2);

    my($matrix1,$matrix2) = @_;
    my($rows1,$cols1) = ($matrix1->[1],$matrix1->[2]);
    my($rows2,$cols2) = ($matrix2->[1],$matrix2->[2]);

    if (($rows1 == $rows2) && ($cols1 == $cols2))
    {
        $matrix1->[0]->Copy($matrix2->[0]);
    }
    else
    {
        croak "Math::MatrixBool::Copy(): matrix size mismatch";
    }
}

sub Shadow
{
    croak "Usage: \$other_matrix = \$some_matrix->Shadow();"
      if (@_ != 1);

    my($matrix) = @_;
    my($result);

    $result = $matrix->new($matrix->[1],$matrix->[2]);
    return($result);
}

sub Clone
{
    croak "Usage: \$twin_matrix = \$some_matrix->Clone();"
      if (@_ != 1);

    my($matrix) = @_;
    my($result);

    $result = $matrix->new($matrix->[1],$matrix->[2]);
    $result->Copy($matrix);
    return($result);
}

                ########################################
                #                                      #
                # define overloaded operators section: #
                #                                      #
                ########################################

sub _complement
{
    my($object,$argument,$flag) = @_;
#   my($name) = "neg"; #&_trace($name,$object,$argument,$flag);
    my($result);

    $result = $object->new($object->[1],$object->[2]);
    $result->Complement($object);
    return($result);
}

sub _transpose
{
    my($object,$argument,$flag) = @_;
#   my($name) = "'~'"; #&_trace($name,$object,$argument,$flag);
    my($result);

    $result = $object->new($object->[2],$object->[1]);
    $result->Transpose($object);
    return($result);
}

sub _boolean
{
    my($object,$argument,$flag) = @_;
#   my($name) = "bool"; #&_trace($name,$object,$argument,$flag);

    return( $object->[0]->Min() < $object->[1] * $object->[2] );
}

sub _not_boolean
{
    my($object,$argument,$flag) = @_;
#   my($name) = "'!'"; #&_trace($name,$object,$argument,$flag);

    return( !($object->[0]->Min() < $object->[1] * $object->[2]) );
}

sub _string
{
    my($object,$argument,$flag) = @_;
#   my($name) = '""'; #&_trace($name,$object,$argument,$flag);
    my($rows,$cols) = ($object->[1],$object->[2]);
    my($i,$j,$s);

    $s = '';
    for ( $i = 1; $i <= $rows; $i++ )
    {
        $s .= "[ ";
        for ( $j = 1; $j <= $cols; $j++ )
        {
            if ($object->bit_test($i,$j)) { $s .= "1 "; } else { $s .= "0 "; }
        }
        $s .= "]\n";
    }
    return($s);
}

sub _number_of_elements
{
    my($object,$argument,$flag) = @_;
#   my($name) = "abs"; #&_trace($name,$object,$argument,$flag);

    return( $object->Number_of_elements() );
}

sub _addition
{
    my($object,$argument,$flag) = @_;
    my($name) = "'+'"; #&_trace($name,$object,$argument,$flag);
    my($result);

    if ((defined $argument) && ref($argument) && (ref($argument) !~ /^[A-Z]+$/))
    {
        if (defined $flag)
        {
            $result = $object->new($object->[1],$object->[2]);
            $result->ExclusiveOr($object,$argument);
            return($result);
        }
        else
        {
            $object->ExclusiveOr($object,$argument);
            return($object);
        }
    }
    else
    {
        croak "Math::MatrixBool $name: wrong argument type";
    }
}

sub _multiplication
{
    my($object,$argument,$flag) = @_;
    my($name) = "'*'"; #&_trace($name,$object,$argument,$flag);
    my($result);

    if ((defined $argument) && ref($argument) && (ref($argument) !~ /^[A-Z]+$/))
    {
        if ((defined $flag) && $flag)
        {
            return( Multiplication($argument,$object) );
        }
        else
        {
            return( Multiplication($object,$argument) );
        }
    }
    else
    {
        croak "Math::MatrixBool $name: wrong argument type";
    }
}

sub _union
{
    my($object,$argument,$flag) = @_;
    my($name) = "'|'"; #&_trace($name,$object,$argument,$flag);
    my($result);

    if ((defined $argument) && ref($argument) && (ref($argument) !~ /^[A-Z]+$/))
    {
        if (defined $flag)
        {
            $result = $object->new($object->[1],$object->[2]);
            $result->Union($object,$argument);
            return($result);
        }
        else
        {
            $object->Union($object,$argument);
            return($object);
        }
    }
    else
    {
        croak "Math::MatrixBool $name: wrong argument type";
    }
}

sub _difference
{
    my($object,$argument,$flag) = @_;
    my($name) = "'-'"; #&_trace($name,$object,$argument,$flag);
    my($result);

    if ((defined $argument) && ref($argument) && (ref($argument) !~ /^[A-Z]+$/))
    {
        if (defined $flag)
        {
            $result = $object->new($object->[1],$object->[2]);
            if ($flag) { $result->Difference($argument,$object); }
            else       { $result->Difference($object,$argument); }
            return($result);
        }
        else
        {
            $object->Difference($object,$argument);
            return($object);
        }
    }
    else
    {
        croak "Math::MatrixBool $name: wrong argument type";
    }
}

sub _intersection
{
    my($object,$argument,$flag) = @_;
    my($name) = "'&'"; #&_trace($name,$object,$argument,$flag);
    my($result);

    if ((defined $argument) && ref($argument) && (ref($argument) !~ /^[A-Z]+$/))
    {
        if (defined $flag)
        {
            $result = $object->new($object->[1],$object->[2]);
            $result->Intersection($object,$argument);
            return($result);
        }
        else
        {
            $object->Intersection($object,$argument);
            return($object);
        }
    }
    else
    {
        croak "Math::MatrixBool $name: wrong argument type";
    }
}

sub _exclusive_or
{
    my($object,$argument,$flag) = @_;
    my($name) = "'^'"; #&_trace($name,$object,$argument,$flag);
    my($result);

    if ((defined $argument) && ref($argument) && (ref($argument) !~ /^[A-Z]+$/))
    {
        if (defined $flag)
        {
            $result = $object->new($object->[1],$object->[2]);
            $result->ExclusiveOr($object,$argument);
            return($result);
        }
        else
        {
            $object->ExclusiveOr($object,$argument);
            return($object);
        }
    }
    else
    {
        croak "Math::MatrixBool $name: wrong argument type";
    }
}

sub _assign_addition
{
    my($object,$argument,$flag) = @_;
#   my($name) = "'+='"; #&_trace($name,$object,$argument,$flag);

    return( &_addition($object,$argument,undef) );
}

sub _assign_multiplication
{
    my($object,$argument,$flag) = @_;
#   my($name) = "'*='"; #&_trace($name,$object,$argument,$flag);

    return( &_multiplication($object,$argument,undef) );
}

sub _assign_union
{
    my($object,$argument,$flag) = @_;
#   my($name) = "'|='"; #&_trace($name,$object,$argument,$flag);

    return( &_union($object,$argument,undef) );
}

sub _assign_difference
{
    my($object,$argument,$flag) = @_;
#   my($name) = "'-='"; #&_trace($name,$object,$argument,$flag);

    return( &_difference($object,$argument,undef) );
}

sub _assign_intersection
{
    my($object,$argument,$flag) = @_;
#   my($name) = "'&='"; #&_trace($name,$object,$argument,$flag);

    return( &_intersection($object,$argument,undef) );
}

sub _assign_exclusive_or
{
    my($object,$argument,$flag) = @_;
#   my($name) = "'^='"; #&_trace($name,$object,$argument,$flag);

    return( &_exclusive_or($object,$argument,undef) );
}

sub _equal
{
    my($object,$argument,$flag) = @_;
    my($name) = "'=='"; #&_trace($name,$object,$argument,$flag);

    if ((defined $argument) && ref($argument) && (ref($argument) !~ /^[A-Z]+$/))
    {
        return( $object->equal($argument) );
    }
    else
    {
        croak "Math::MatrixBool $name: wrong argument type";
    }
}

sub _not_equal
{
    my($object,$argument,$flag) = @_;
    my($name) = "'!='"; #&_trace($name,$object,$argument,$flag);

    if ((defined $argument) && ref($argument) && (ref($argument) !~ /^[A-Z]+$/))
    {
        return( !($object->equal($argument)) );
    }
    else
    {
        croak "Math::MatrixBool $name: wrong argument type";
    }
}

sub _true_sub_set
{
    my($object,$argument,$flag) = @_;
    my($name) = "'<'"; #&_trace($name,$object,$argument,$flag);

    if ((defined $argument) && ref($argument) && (ref($argument) !~ /^[A-Z]+$/))
    {
        if ((defined $flag) && $flag)
        {
            return( !($argument->equal($object)) &&
                     ($argument->subset($object)) );
        }
        else
        {
            return( !($object->equal($argument)) &&
                     ($object->subset($argument)) );
        }
    }
    else
    {
        croak "Math::MatrixBool $name: wrong argument type";
    }
}

sub _sub_set
{
    my($object,$argument,$flag) = @_;
    my($name) = "'<='"; #&_trace($name,$object,$argument,$flag);

    if ((defined $argument) && ref($argument) && (ref($argument) !~ /^[A-Z]+$/))
    {
        if ((defined $flag) && $flag)
        {
            return( $argument->subset($object) );
        }
        else
        {
            return( $object->subset($argument) );
        }
    }
    else
    {
        croak "Math::MatrixBool $name: wrong argument type";
    }
}

sub _true_super_set
{
    my($object,$argument,$flag) = @_;
    my($name) = "'>'"; #&_trace($name,$object,$argument,$flag);

    if ((defined $argument) && ref($argument) && (ref($argument) !~ /^[A-Z]+$/))
    {
        if ((defined $flag) && $flag)
        {
            return( !($object->equal($argument)) &&
                     ($object->subset($argument)) );
        }
        else
        {
            return( !($argument->equal($object)) &&
                     ($argument->subset($object)) );
        }
    }
    else
    {
        croak "Math::MatrixBool $name: wrong argument type";
    }
}

sub _super_set
{
    my($object,$argument,$flag) = @_;
    my($name) = "'>='"; #&_trace($name,$object,$argument,$flag);

    if ((defined $argument) && ref($argument) && (ref($argument) !~ /^[A-Z]+$/))
    {
        if ((defined $flag) && $flag)
        {
            return( $object->subset($argument) );
        }
        else
        {
            return( $argument->subset($object) );
        }
    }
    else
    {
        croak "Math::MatrixBool $name: wrong argument type";
    }
}

sub _compare
{
    my($object,$argument,$flag) = @_;
    my($name) = "cmp"; #&_trace($name,$object,$argument,$flag);

    if ((defined $argument) && ref($argument) && (ref($argument) !~ /^[A-Z]+$/))
    {
        if ((defined $flag) && $flag)
        {
            return( $argument->Compare($object) );
        }
        else
        {
            return( $object->Compare($argument) );
        }
    }
    else
    {
        croak "Math::MatrixBool $name: wrong argument type";
    }
}

sub _clone
{
    my($object,$argument,$flag) = @_;
#   my($name) = "'='"; #&_trace($name,$object,$argument,$flag);
    my($result);

    $result = $object->new($object->[1],$object->[2]);
    $result->Copy($object);
    return($result);
}

sub _trace
{
    my($text,$object,$argument,$flag) = @_;

    unless (defined $object)   { $object   = 'undef'; };
    unless (defined $argument) { $argument = 'undef'; };
    unless (defined $flag)     { $flag     = 'undef'; };
    if (ref($object))   { $object   = ref($object);   }
    if (ref($argument)) { $argument = ref($argument); }
    print "$text: \$obj='$object' \$arg='$argument' \$flag='$flag'\n";
}

1;

__END__