view release on metacpan or  search on metacpan

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

package Algorithm::CP::IZ::Int;

use strict;
use warnings;

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);

Values will be removed by applying constraint.
For example, After applying constraint $var->Le(3) to above example variable,
domain of $var is 1..3.

  $var->Le(3);     # $var <= 3 (6..9 is removed from domain)
  print "$var\n";  # Output will be "{1..3}".