view release on metacpan or  search on metacpan

lib/Algorithm/CP/IZ/Int.pm  view on Meta::CPAN

use UNIVERSAL;

use overload '""' => \&stringify;
use overload 'bool' => sub { $_[0] };

use Algorithm::CP::IZ::ParamValidator qw(validate);

sub stringify {
    my $self = shift;
    my @list;


    my $cur = $self->min;
    my $max = $self->max;
    my $end;

    do {
	$end = Algorithm::CP::IZ::iz_getEndValue($$self, $cur);
	if ($end == $cur) {
	    push(@list, "$cur");
	}
	else {
	    push(@list, "$cur..$end");
	}

	$cur = Algorithm::CP::IZ::cs_getNextValue($$self, $end);

    } while ($end < $max);

    my $vals;
    if ($self->is_instantiated) {
	$vals = $list[0];
    }
    else {
	$vals = join("", "{" . join(", ", @list) . "}");
    }

    my $name = $self->name;
    if (defined($name)) {
	return $name . ": " . $vals;
    }
    else {
	return $vals;
    }
}

sub key {
    my $self = shift;

    # get pointer value dereferencing $self
    my $ret = $$self;

    return "$ret";
}

sub new {
    my $class = shift;
    my $ptr = shift;

    bless \$ptr, $class;
}

sub name {
    my $self = $_[0];
    my $key = $self->key;

    if (@_ == 1) {
	return $self->get_name;
    }

    $self->set_name($_[1]);
}

sub InArray {
    my $self = shift;
    my $int_array = shift;

    validate([$int_array], ["iA1"], "Usage: InArray([values]");

    my $parray = Algorithm::CP::IZ::alloc_int_array([map { int($_) } @$int_array]);
    my $ret = Algorithm::CP::IZ::cs_InArray($$self, $parray, scalar @$int_array);

    Algorithm::CP::IZ::free_array($parray);

    return $ret;
}

sub NotInArray {
    my $self = shift;
    my $int_array = shift;

    validate([$int_array], ["iA0"], "Usage: NotInArray([values]");

    my $parray = Algorithm::CP::IZ::alloc_int_array([map { int($_) } @$int_array]);
    my $ret = Algorithm::CP::IZ::cs_NotInArray($$self, $parray, scalar @$int_array);

    Algorithm::CP::IZ::free_array($parray);

    return $ret;
}

sub InInterval {
    my $self = shift;
    my ($min, $max) = @_;

    validate([scalar @_, $min, $max], [sub { shift == 2 }, "I", "I"],
	     "Usage: InInterval(min, max)");

    return Algorithm::CP::IZ::cs_InInterval($$self, int($min), int($max));
}

sub NotInInterval {
    my $self = shift;
    my ($min, $max) = @_;

    validate([scalar @_, $min, $max], [sub { shift == 2 }, "I", "I"],
	     "Usage: NotInInterval(min, max)");

    return Algorithm::CP::IZ::cs_NotInInterval($$self, int($min), int($max));
}

sub _invalidate {
    my $self = shift;

    bless $self, __PACKAGE__ . "::InvalidInt";
}

sub select_value {
    my $self = shift;
    my ($method, $value) = @_;

    validate([$method, $value], ["I", "I"],
	     "Usage: selectValue(method, value)");
    return Algorithm::CP::IZ::cs_selectValue($self, $method, $value);
}

sub DESTROY {
    my $self = shift;
}


1;

__END__

=head1 NAME

Algorithm::CP::IZ::Int - Domain variable for Algorithm::CP::IZ

=head1 SYNOPSIS

  use Algorithm::CP::IZ;

  my $iz = Algorithm::CP::IZ->new();

  # create instances of Algorithm::CP::IZ::Int
  # contains domain {0..9}
  my $v1 = $iz->create_int(1, 9);
  my $v2 = $iz->create_int(1, 9);

  # add constraint
  $iz->Add($v1, $v2)->Eq(12);

  # get current status
  print $v1->nb_elements, "\n2;

  # print domain
  print "$v1\n";

=head1 DESCRIPTION

Algorithm::CP::IZ::Int is perl representation of CSint object in iZ-C library.
This class is called also 'domain variable'.

=head2 DOMAIN

Domain is a set of candidate values of solution which can satisfy current
constraint setting.

You can declare range of domain (which integer is in domain) when
creating variable.
Variable can take values 1..9 (1..9 is in domain) in following example.

  my $var = $iz->create_int(1, 9);