validate results from the CPAN

validate

Algorithm-CP-IZ

view release on metacpan or search on metacpan

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


use Carp;
use Scalar::Util qw(weaken blessed looks_like_number);

require Exporter;
use AutoLoader;

use Algorithm::CP::IZ::Int;
use Algorithm::CP::IZ::RefVarArray;
use Algorithm::CP::IZ::RefIntArray;
use Algorithm::CP::IZ::ParamValidator qw(validate);
use Algorithm::CP::IZ::ValueSelector;
use Algorithm::CP::IZ::CriteriaValueSelector;
use Algorithm::CP::IZ::NoGoodSet;
use Algorithm::CP::IZ::SearchNotify;

our @ISA = qw(Exporter);

# Items to export into callers namespace by default. Note: do not export
# names by default without a very good reason. Use EXPORT_OK instead.
# Do not simply export all your public functions/methods/constants.

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

	_ref_var_arrays => {},
    }, $class;
}

sub DESTROY {
    my $self = shift;
    my $vars = $self->{_vars};

    for my $v (@$vars) {
	# we must check existence of variable for global destruction.
	$v->_invalidate if (defined $v);
    }

    Algorithm::CP::IZ::cs_end();
    $Instances--;
}

sub save_context {
    my $self = shift;
    
    my $ret = Algorithm::CP::IZ::cs_saveContext();

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

	_report_error("restore_context: bottom of context stack");
    }

    Algorithm::CP::IZ::cs_restoreContext();
}

sub restore_context_until {
    my $self = shift;
    my $label = shift;

    validate([$label], ["I"],
	     "Usage: restore_context_until(int_label)");

    my $cxt = $self->{_cxt};
    if (@$cxt == 0) {
	_report_error("restore_context_until: invalid label");
    }

    Algorithm::CP::IZ::cs_restoreContextUntil($label);
}

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

	_report_error("forget_save_context: bottom of context stack");
    }

    Algorithm::CP::IZ::cs_forgetSaveContext();
}

sub forget_save_context_until {
    my $self = shift;
    my $label = shift;

    validate([$label], ["I"],
	     "Usage: forget_save_context_until(int_label)");

    my $cxt = $self->{_cxt};
    if (@$cxt == 0) {
	_report_error("forget_save_context_until: invalid label");
    }

    Algorithm::CP::IZ::cs_forgetSaveContextUntil($label);
}

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

    Algorithm::CP::IZ::cs_acceptContext();

    # pop must be after cs_acceptContext to save cs_backtrack context.
    pop(@$cxt);
}

sub accept_context_until {
    my $self = shift;
    my $label = shift;

    validate([$label], ["I"],
	     "Usage: accept_context_until(int_label)");

    my $cxt = $self->{_cxt};
    if (@$cxt == 0) {
	_report_error("accept_context_until: invalid label");
    }

    while (@$cxt >= $label) {
	Algorithm::CP::IZ::cs_acceptContext();

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

    # pop must be after cs_acceptContext to save cs_backtrack context.
    $self->{_cxt} = [];
}

my $Backtrack_id = 0;

sub backtrack {
    my $self = shift;
    my ($var, $index, $handler) = @_;

    validate([$var, $index, $handler], ["oV", "I", "C"],
	     "Usage: backtrack(variable, index, code_ref)");

    $var = _safe_var($var) if (defined($var));
    
    my $id = $Backtrack_id++;
    $self->{_backtracks}->{$id} = [$var, $index, $handler];

    my $backtracks = $self->{_backtracks};
    weaken($backtracks);

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

    };

    my $vptr = defined($var) ? $$var : 0;

    Algorithm::CP::IZ::cs_backtrack($vptr, $id,
				    $self->{_backtrack_code_ref});
}

sub _create_int_from_min_max {
    my ($self, $min, $max) = @_;
    validate([$min, $max], ["I", "I"], "Usage: create_int(min, max), create_int(constant), create_int([domain])");
    return Algorithm::CP::IZ::cs_createCSint(int($min), int($max));
}

sub _create_int_from_domain {
    my ($self, $int_array) = @_;
    validate([$int_array], ["iA1"], "Usage: create_int(min, max), create_int(constant), create_int([domain])");

    my $parray = Algorithm::CP::IZ::alloc_int_array([map { int($_) } @$int_array]);
    my $ptr = Algorithm::CP::IZ::cs_createCSintFromDomain($parray, scalar @$int_array);
    Algorithm::CP::IZ::free_array($parray);

    return $ptr;
}

sub create_int {
    my $self = shift;

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


    if (defined $name) {
	$ret->name($name);
    }

    $self->_register_variable($ret);

    return $ret;
}

sub _validate_search_params {
    my ($var_array, $params) = @_;
    return 1 unless (defined($params));
    return 0 unless (ref $params eq 'HASH');

    my %checker = (
	FindFreeVar => sub {
	    my $x = shift;
	    if (ref $x) {
		validate([$x], ["C"], "search: FindFreeVar must be a number or a coderef");
	    }
	    else {
		validate([$x], ["I"], "search: FindFreeVar must be a number or a coderef");
	    }
	},
	Criteria => sub {
	    my $x = shift;
	    validate([$x], ["C"], "search: Criteria must be a coderef");
	    return 1;
	},
	MaxFail => sub {
	    my $x = shift;
	    validate([$x], ["I"], "search: MaxFail must be an integer");
	},
	ValueSelectors => sub {
	    my $x = shift;
	    validate([$x], [
			 sub {
			     my $vs = shift;
			     return unless (ref $vs eq 'ARRAY'
					    && scalar @$vs == scalar @$var_array);
			     for my $obj (@$vs) {
				 return unless (blessed($obj)
						&& $obj->isa("Algorithm::CP::IZ::ValueSelector"));
			     }
			     1;
			 }], "search: ValueSelectos must be a arrayref of Algorithm::CP::IZ::ValueSelector instance for each variables");
	},
	MaxFailFunc => sub {
	    my $x = shift;
	    validate([$x], ["C"], "search: MaxFailFunc must be a coderef");
	},
	NoGoodSet => sub {
	    my $x = shift;
	    validate([$x], [
			 sub {
			     my $ngs = shift;
			     return blessed($ngs) && $ngs->isa("Algorithm::CP::IZ::NoGoodSet");
			 }], "search: NoGoodSet must be a instance of Algorithm::CP::IZ::NoGoodSet");
	},
	Notify => sub {
	    my $x = shift;
	    validate([$x], [
			 sub {
			     my $notify = shift;
			     return 1 if (ref $notify eq 'HASH');
			     return 1 if (blessed($notify));
			     return 0;
			 }], "search: Notify must be an hashref or object");
	},
    );

    my @keys = sort keys %$params;

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

    }

    return 1;
}

sub search {
    my $self = shift;
    my $var_array = shift;
    my $params = shift;

    validate([$var_array, $params], ["vA0", sub {_validate_search_params($var_array, @_)}],
	     "Usage: search([variables], {key=>value,...}");

    my $array = [map { $$_ } @$var_array];
    my $max_fail = -1;
    my $find_free_var_id = 0;
    my $find_free_var_func = sub { die "search: Internal error"; };
    my $criteria_func;
    my $value_selectors;
    my $max_fail_func;
    my $ngs;

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

						    $max_fail);
    }
    else {
 	return Algorithm::CP::IZ::cs_search($array,
					    $find_free_var_id,
					    $find_free_var_func,
					    $max_fail);
   }
}

sub _validate_find_all_params {
    my $params = shift;
    return 1 unless (defined($params));
    return 0 unless (ref $params eq 'HASH');

    my %checker = (
	FindFreeVar => sub {
	    my $x = shift;
	    if (ref $x) {
		validate([$x], ["C"], "find_all: FindFreeVar must be a number or coderef");
	    }
	    else {
		validate([$x], ["I"], "search: FindFreeVar must be a number or coderef");
	    }
	},
    );

    my @keys = sort keys %$params;

    for my $k (@keys) {
	if (exists $checker{$k}) {
	    my $func = $checker{$k};
	    &$func($params->{$k});

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


    return 1;
}

sub find_all {
    my $self = shift;
    my $var_array = shift;
    my $found_func = shift;
    my $params = shift;

    validate([$var_array, $found_func, $params],
	     ["vA0", "C", \&_validate_find_all_params],
	     "find_all: usage: find_all([vars], &callback_func, {params})");

    my $array = [map { $$_ } @$var_array];

    my $find_free_var_id = 0;
    my $find_free_var_func = sub { die "find_all: Internal error"; };

    if ($params->{FindFreeVar}) {
	my $ffv = $params->{FindFreeVar};

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

    my $self = shift;
    my $id = shift;

    return Algorithm::CP::IZ::ValueSelector::Simple->new($self, $id);
}

sub create_no_good_set {
    my $self = shift;
    my ($var_array, $prefilter, $max_no_good, $ext) = @_;
    $max_no_good ||= 0;
    validate([$var_array, $prefilter, $max_no_good], ["vA0", "C0", "I"],
	     "Usage: create_no_good_set([variables], prefilter, max_no_good, ext)");

    my $ngsObj = Algorithm::CP::IZ::NoGoodSet->new($var_array, $prefilter, $ext);
    my $ptr = Algorithm::CP::IZ::cs_createNoGoodSet($ngsObj->_parray->ptr,
						    scalar(@$var_array),
						    ($prefilter ? 1 : 0),
						    $max_no_good,
						    $ngsObj);
    $ngsObj->_init($ptr);
    return $ngsObj;

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

}

#####################################################
# Demon
#####################################################

sub event_all_known {
    my $self = shift;
    my ($var_array, $handler, $ext) = @_;

    validate([$var_array, $handler], ["vA0", "C"],
	     "Usage: event_all_known([variables], code_ref, ext)");

    my $parray = $self->_create_registered_var_array($var_array);

    my $h = sub {
	return &$handler($var_array, $ext) ? 1 : 0;
    };

    $self->_push_object($h);

    return Algorithm::CP::IZ::cs_eventAllKnown($$parray, scalar(@$var_array), $h);
}

sub event_known {
    my $self = shift;
    my ($var_array, $handler, $ext) = @_;

    validate([$var_array, $handler], ["vA0", "C"],
	     "Usage: event_known([variables], code_ref, ext)");

    my $parray = $self->_create_registered_var_array($var_array);

    my $h = sub {
	my ($val, $index) = @_;
	return &$handler($val, $index, $var_array, $ext) ? 1 : 0;
    };

    $self->_push_object($h);

    return Algorithm::CP::IZ::cs_eventKnown($$parray, scalar(@$var_array), $h);
}

sub event_new_min {
    my $self = shift;
    my ($var_array, $handler, $ext) = @_;

    validate([$var_array, $handler], ["vA0", "C"],
	     "Usage: event_new_min([variables], code_ref, ext)");

    my $parray = $self->_create_registered_var_array($var_array);

    my $h = sub {
	my ($index, $old_min) = @_;
	return &$handler($var_array->[$index], $index, $old_min, $var_array, $ext) ? 1 : 0;
    };

    $self->_push_object($h);

    return Algorithm::CP::IZ::cs_eventNewMin($$parray, scalar(@$var_array), $h);
}

sub event_new_max {
    my $self = shift;
    my ($var_array, $handler, $ext) = @_;

    validate([$var_array, $handler], ["vA0", "C"],
	     "Usage: event_new_max([variables], code_ref, ext)");

    my $parray = $self->_create_registered_var_array($var_array);

    my $h = sub {
	my ($index, $old_min) = @_;
	return &$handler($var_array->[$index], $index, $old_min, $var_array, $ext) ? 1 : 0;
    };

    $self->_push_object($h);

    return Algorithm::CP::IZ::cs_eventNewMax($$parray, scalar(@$var_array), $h);
}

sub event_neq {
    my $self = shift;
    my ($var_array, $handler, $ext) = @_;

    validate([$var_array, $handler], ["vA0", "C"],
	     "Usage: event_eq([variables], code_ref, ext)");

    my $parray = $self->_create_registered_var_array($var_array);

    my $h = sub {
	my ($index, $val) = @_;
	return &$handler($var_array->[$index], $index, $val, $var_array, $ext) ? 1 : 0;
    };

    $self->_push_object($h);

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


sub Add {
    my $self = shift;
    my @params = @_;

    my $usage_msg = 'usage: Add(v1, v2, ...)';
    if (@params < 1) {
	_report_error($usage_msg);
    }
    for my $v (@params) {
	validate([$v], ["V"], $usage_msg);
    }

    if (@params == 1) {
	return $params[0] if (ref $params[0]);
	return $self->_const_var(int($params[0]));
    }

    my @v = map { ref $_ ? $_ : $self->_const_var(int($_)) } @params;

    my $ptr = _argv_func([map { $$_} @v], 10,

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


sub Mul {
    my $self = shift;
    my @params = @_;

    my $usage_msg = 'usage: Mul(v1, v2, ...)';
    if (@params < 1) {
	_report_error($usage_msg);
    }
    for my $v (@params) {
	validate([$v], ["V"], $usage_msg);
    }

    if (@params == 1) {
	return $params[0] if (ref $params[0]);
	return $self->_const_var(int($params[0]));
    }

    my @v = map { ref $_ ? $_ : $self->_const_var(int($_)) } @params;

    my $ptr = _argv_func([map { $$_ } @v], 10,

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


sub Sub {
    my $self = shift;
    my @params = @_;

    my $usage_msg = 'usage: Sub(v1, v2, ...)';
    if (@params < 1) {
	_report_error($usage_msg);
    }
    for my $v (@params) {
	validate([$v], ["V"], $usage_msg);
    }

    if (@params == 1) {
	return $params[0] if (ref $params[0]);
	return $self->_const_var(int($params[0]));
    }

    my @v = map { ref $_ ? $_ : $self->_const_var(int($_)) } @params;

    my $ptr = _argv_func([map { $$_} @v], 10,

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


sub Div {
    my $self = shift;
    my @params = @_;

    my $usage_msg = 'usage: Div(v1, v2)';
    if (@params != 2) {
	_report_error($usage_msg);
    }
    for my $v (@params) {
	validate([$v], ["V"], $usage_msg);
    }

    if (@params == 1) {
	return $params[0] if (ref $params[0]);
	return $self->_const_var(int($params[0]));
    }

    my @v = map { ref $_ ? $_ : $self->_const_var(int($_)) } @params;
    my $ptr = Algorithm::CP::IZ::cs_Div(map { $$_ } @v);

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

    $self->_register_variable($ret);

    return $ret;
}

sub ScalProd {
    my $self = shift;
    my $vars = shift;
    my $coeffs = shift;

    validate([$vars, $coeffs, 1], ["vA0", "iA0",
				   sub {
				       @$coeffs == @$vars
				   }],
	     "Usage: ScalProd([variables], [coeffs])");

    @$vars = map { ref $_ ? $_ : $self->_const_var(int($_)) } @$vars;

    my $p1 = $self->_create_registered_var_array($vars);
    my $p2 = $self->_create_registered_int_array($coeffs);
    my $n = @$coeffs;

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


    $self->_register_variable($ret);

    return $ret;
}

sub AllNeq {
    my $self = shift;
    my $var_array = shift;;

    validate([$var_array], ["vA0"], "Usage: AllNeq([variables])");

    my $parray = $self->_create_registered_var_array($var_array);

    return Algorithm::CP::IZ::cs_AllNeq($$parray, scalar(@$var_array));
}

sub Sigma {
    my $self = shift;
    my $var_array = shift;;

    validate([$var_array], ["vA0"], "Usage: Sigma([variables])");

    @$var_array = map { ref $_ ? $_ : $self->_const_var(int($_)) } @$var_array;

    my $parray = $self->_create_registered_var_array($var_array);

    my $ptr = Algorithm::CP::IZ::cs_Sigma($$parray, scalar(@$var_array));

    my $ret = Algorithm::CP::IZ::Int->new($ptr);

    $self->_register_variable($ret);

    return $ret;
}

sub Abs {
    my $self = shift;
    my @params = @_;

    validate([scalar @params, $params[0]],
	     [sub { shift == 1 }, "V"], "Usage: Abs(v)");

    my @v = map { ref $_ ? $_ : $self->_const_var(int($_)) } @params;
    my $ptr = Algorithm::CP::IZ::cs_Abs(map { $$_ } @v);
    my $ret = Algorithm::CP::IZ::Int->new($ptr);

    $self->_register_variable($ret);

    return $ret;
}

sub Min {
    my $self = shift;
    my $var_array = shift;;

    validate([$var_array], ["vA1"],
	     "Usage: Min([variables])");

    @$var_array = map { ref $_ ? $_ : $self->_const_var(int($_)) } @$var_array;

    my $parray = $self->_create_registered_var_array($var_array);

    my $ptr = Algorithm::CP::IZ::cs_Min($$parray, scalar(@$var_array));

    my $ret = Algorithm::CP::IZ::Int->new($ptr);

    $self->_register_variable($ret);

    return $ret;
}

sub Max {
    my $self = shift;
    my $var_array = shift;;

    validate([$var_array], ["vA1"],
	     "Usage: Max([variables])");

    @$var_array = map { ref $_ ? $_ : $self->_const_var(int($_)) } @$var_array;

    my $parray = $self->_create_registered_var_array($var_array);

    my $ptr = Algorithm::CP::IZ::cs_Max($$parray, scalar(@$var_array));

    my $ret = Algorithm::CP::IZ::Int->new($ptr);

    $self->_register_variable($ret);

    return $ret;
}

sub IfEq {
    my $self = shift;
    my ($vint1, $vint2, $val1, $val2) = @_;

    validate([scalar @_, $vint1, $vint2, $val1, $val2],
	     [sub { shift == 4 }, "V", "V", "I", "I"],
	     "Usage: IfEq(vint1, vint2, val1, val2)");

    return Algorithm::CP::IZ::cs_IfEq($$vint1, $$vint2,
				      int($val1), int($val2));
}

sub IfNeq {
    my $self = shift;
    my ($vint1, $vint2, $val1, $val2) = @_;

    validate([scalar @_, $vint1, $vint2, $val1, $val2],
	     [sub { shift == 4 }, "V", "V", "I", "I"],
	     "Usage: IfNeq(vint1, vint2, val1, val2)");

    return Algorithm::CP::IZ::cs_IfNeq($$vint1, $$vint2,
				       $val1, $val2);
}

sub OccurDomain {
    my $self = shift;
    my ($val, $var_array) = @_;

    validate([scalar @_, $val, $var_array],
	     [sub { shift == 2 }, "I", "vA0"],
	     "Usage: OccurDomain(val, [variables])");

    @$var_array = map { ref $_ ? $_ : $self->_const_var(int($_)) } @$var_array;

    my $parray = $self->_create_registered_var_array($var_array);

    my $ptr = Algorithm::CP::IZ::cs_OccurDomain(int($val),
						$$parray, scalar(@$var_array));

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


    $self->_register_variable($ret);

    return $ret;
}

sub OccurConstraints {
    my $self = shift;
    my ($vint, $val, $var_array) = @_;

    validate([scalar @_, $vint, $val, $var_array],
	     [sub { shift == 3 }, "V", "I", "vA0"],
	     "Usage: OccurConstraints(vint, val, [variables])");

    $vint = ref $vint ? $vint : $self->_const_var(int($vint));
    @$var_array = map { ref $_ ? $_ : $self->_const_var(int($_)) } @$var_array;

    my $parray = $self->_create_registered_var_array($var_array);

    my $ret = Algorithm::CP::IZ::cs_OccurConstraints($$vint, int($val),
						     $$parray,
						     scalar(@$var_array));
    return $ret;
}

sub Index {
    my $self = shift;
    my ($var_array, $val) = @_;

    validate([scalar @_, $var_array, $val],
	     [sub { shift == 2 }, "vA0", "I"],
	     "Usage: Index([variables], val)");

    @$var_array = map { ref $_ ? $_ : $self->_const_var(int($_)) } @$var_array;

    my $parray = $self->_create_registered_var_array($var_array);

    my $ptr = Algorithm::CP::IZ::cs_Index($$parray, scalar(@$var_array), $val);
    my $ret = Algorithm::CP::IZ::Int->new($ptr);

    $self->_register_variable($ret);

    return $ret;
}

sub Element {
    my $self = shift;
    my ($index, $val_array) = @_;

    validate([scalar @_, $index, $val_array],
	     [sub { shift == 2 }, "V", "iA1"],
	     "Usage: Element(index_var, [values])");

    @$val_array = map { int($_) } @$val_array;
    $index = ref $index ? $index : $self->_const_var(int($index));

    my $parray = $self->_create_registered_int_array($val_array);

    my $ptr = Algorithm::CP::IZ::cs_Element($$index,
					    $$parray, scalar(@$val_array));

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


    $self->_register_variable($ret);

    return $ret;
}

sub VarElement {
    my $self = shift;
    my ($index, $var_array) = @_;

    validate([scalar @_, $index, $var_array],
	     [sub { shift == 2 }, "V", "vA1"],
	     "Usage: VarElement(index_var, [value_vars])");

    @$var_array = map { ref $_ ? $_ : $self->_const_var(int($_)) } @$var_array;
    $index = ref $index ? $index : $self->_const_var(int($index));

    my $parray = $self->_create_registered_var_array($var_array);

    my $ptr = Algorithm::CP::IZ::cs_VarElement($$index,
					    $$parray, scalar(@$var_array));

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


    $self->_register_variable($ret);

    return $ret;
}

sub VarElementRange {
    my $self = shift;
    my ($index, $var_array) = @_;

    validate([scalar @_, $index, $var_array],
	     [sub { shift == 2 }, "V", "vA1"],
	     "Usage: VarElementRange(index_var, [value_vars])");

    @$var_array = map { ref $_ ? $_ : $self->_const_var(int($_)) } @$var_array;
    $index = ref $index ? $index : $self->_const_var(int($index));

    my $parray = $self->_create_registered_var_array($var_array);

    my $ptr = Algorithm::CP::IZ::cs_VarElementRange($$index,
					    $$parray, scalar(@$var_array));

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


    $self->_register_variable($ret);

    return $ret;
}

sub Cumulative {
    my $self = shift;
    my ($starts, $durations, $resources, $limit) = @_;

    validate([$starts, $durations, $resources, $limit, 1],
	     ["vA0", "vA0", "vA0", "V", sub {
		 @$starts == @$durations && @$durations == @$resources
	      }],
	     "Usage: Cumulative([starts], [durations], [resources], limit)");

    @$starts = map { ref $_ ? $_ : $self->_const_var(int($_)) } @$starts;
    @$durations = map { ref $_ ? $_ : $self->_const_var(int($_)) } @$durations;
    @$resources = map { ref $_ ? $_ : $self->_const_var(int($_)) } @$resources;
    $limit = ref $limit ? $limit : $self->_const_var(int($limit));

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


    my $ret = Algorithm::CP::IZ::cs_Cumulative($$pstarts, $$pdurs, $$pres,
					       scalar(@$starts), $$limit);
    return $ret;
}

sub Disjunctive {
    my $self = shift;
    my ($starts, $durations) = @_;

    validate([$starts, $durations, 1],
	     ["vA0", "vA0",  sub {
		 @$starts == @$durations
	      }],
	     "Usage: Disjunctive([starts], [durations])");

    @$starts = map { ref $_ ? $_ : $self->_const_var(int($_)) } @$starts;
    @$durations = map { ref $_ ? $_ : $self->_const_var(int($_)) } @$durations;

    my $pstarts = $self->_create_registered_var_array($starts);
    my $pdurs = $self->_create_registered_var_array($durations);

    my $ret = Algorithm::CP::IZ::cs_Disjunctive($$pstarts, $$pdurs,
						scalar(@$starts));
    return $ret;
}

sub Regular {
    my $self = shift;
    my ($x, $d, $q0, $F) = @_;
    
    validate([scalar(@_), $x,
	      $d,
	      $q0, $F
	     ],
	     [sub { shift == 4 }, "vA0",
	      sub {
		  # array of array of integer
		  return 0 unless (ref $d eq "ARRAY");
		  for my $row (@$d) {
		      return 0 unless (ref $row eq "ARRAY");
		      for my $i (@$row) {

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

{
    my @names = qw(Eq Neq Lt Le Gt Ge);
    
    for my $n (@names) {
	my $meth_name = "Reif$n";
	my $ucn = uc $n;

	my $meth = sub {
	    my $self = shift;
	    my ($v1, $v2) = @_;
	    validate([scalar @_, $v1, $v2],
		     [sub { shift == 2 }, "V", "V"],
		     "Usage: $meth_name(v1, v2)");

	    my $ptr;

	    if (!ref $v1) {
		$v1 = $self->_const_var(int($v1));
	    }

	    if (ref $v2) {

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;

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

	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;

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

# Parameter validator
#
package Algorithm::CP::IZ::ParamValidator;

use strict;
use warnings;

use base qw(Exporter);

use vars qw(@EXPORT_OK);
@EXPORT_OK = qw(validate);

use Carp;
use vars qw(@CARP_NOT);
@CARP_NOT = qw(Algorithm::CP::IZ);

use Scalar::Util qw(looks_like_number);
use List::Util qw(first);

my $INT_CLASS = "Algorithm::CP::IZ::Int";

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

    V => \&_is_var_or_int,
    C => \&_is_code,
    C0 => \&_is_code_if_defined,
    oV => \&_is_optional_var,
    iA0 => sub { _is_array_of_int(0, @_) },
    iA1 => sub { _is_array_of_int(1, @_) },
    vA0 => sub { _is_array_of_var_or_int(0, @_) },
    vA1 => sub { _is_array_of_var_or_int(1, @_) },
);

sub validate {
    my $params = shift;
    my $types = shift;
    my $hint = shift;

    unless (@$params == @$types) {
	local @CARP_NOT; # to report internal error
	croak __PACKAGE__ . ": n of type does not match with params.";
    }

    for my $i (0..@$params-1) {

ppport.h view on Meta::CPAN

utf8_to_uvuni||5.007001|
utf8n_to_uvchr|||
utf8n_to_uvuni||5.007001|
utilize|||
uvchr_to_utf8_flags||5.007003|
uvchr_to_utf8|||
uvuni_to_utf8_flags||5.007003|
uvuni_to_utf8||5.007001|
valid_utf8_to_uvchr|||
valid_utf8_to_uvuni||5.015009|
validate_proto|||
validate_suid|||
varname|||
vcmp||5.009000|
vcroak||5.006000|
vdeb||5.007003|
vform||5.006000|
visit|||
vivify_defelem|||
vivify_ref|||
vload_module|5.006000||p
vmess||5.006000|

t/00basic.t view on Meta::CPAN


# name
{
    my $v1 = $iz->create_int(0, 2);
    $v1->name("abc");
    is($v1->name, "abc");
    $v1->name("æ—¥æœ¬èªž");
    is($v1->name, "æ—¥æœ¬èªž");
}

# destroy and invalidated
{
    my $v2 = $iz->create_int(0, 2);
    my $v3 = $iz->create_int(0, 3);
    $v3 = undef;
    my $v4 = $iz->create_int(0, 4);
    $v4 = undef;
    my $v5 = $iz->create_int(0, 5);
    
    $iz = undef;
    is(ref $v1, "Algorithm::CP::IZ::Int::InvalidInt");

( run in 0.749 second using v1.01-cache-2.11-cpan-a5abf4f5562 )