view release on metacpan or search on metacpan
lib/Algorithm/BitVector.pm view on Meta::CPAN
bitlist => $args{bitlist},
bitstring => $args{bitstring},
hexstring => $args{hexstring},
textstring => $args{textstring},
};
bless $self, $class;
if ( $self->{filename} ) {
die "When using the `filename' option in the constructor call, you cannot use any " .
"other option at the same time: $!"
if $self->{intVal} or $self->{size} or $self->{bitlist}
or $self->{bitstring} or $self->{hexstring} or $self->{textstring};
lib/Algorithm/BitVector.pm view on Meta::CPAN
{
# This inner class needed for implementing iterator overloading:
package BitVecIterator;
sub new {
my $self = [ $_[1], $_[2] ];
bless $self, $_[0];
$_[1]->{_iter_called} = 1;
return $self;
}
sub next {
my $self = shift;
view release on metacpan or search on metacpan
BloomFilter.xs view on Meta::CPAN
O_OBJECT
if ( sv_isobject($arg) && (SvTYPE(SvRV($arg)) == SVt_PVMG) )
$var = ($type)SvIV((SV*)SvRV( $arg ));
else
croak( \"${Package}::$func_name() -- $var is not a blessed SV reference\" );
HERE
bloom_t *
new(const char *CLASS, UV n_bits, UV k_hashes)
view release on metacpan or search on metacpan
lib/Algorithm/BreakOverlappingRectangles.pm view on Meta::CPAN
my $class = shift;
my $self = { rects => [],
name2id => {},
names => [],
n => 0 };
bless $self, $class;
}
sub add_rectangle {
my ($self, $x0, $y0, $x1, $y1, @names) = @_;
lib/Algorithm/BreakOverlappingRectangles.pm view on Meta::CPAN
use base 'Tie::Array';
sub TIEARRAY {
my ($class, $abor) = @_;
my $self = bless \$abor, $class;
}
sub FETCH {
my ($self, $index) = @_;
my $abor = $$self;
view release on metacpan or search on metacpan
Bucketizer.pm view on Meta::CPAN
cur_bucket_idx => 0,
buckets => [],
};
bless $self, $class;
}
##################################################
sub add_item {
##################################################
Bucketizer.pm view on Meta::CPAN
maxitems => undef,
idx => 0,
@options,
};
bless $self, $class;
}
##################################################
sub serial {
##################################################
view release on metacpan or search on metacpan
lib/Algorithm/CP/IZ.pm view on Meta::CPAN
use 5.010000; # need Newx in XS
use strict;
use warnings;
use Carp;
use Scalar::Util qw(weaken blessed looks_like_number);
require Exporter;
use AutoLoader;
use Algorithm::CP::IZ::Int;
lib/Algorithm/CP/IZ.pm view on Meta::CPAN
}
Algorithm::CP::IZ::cs_init();
$Instances++;
bless {
_vars => [],
_cxt0 => [],
_cxt => [],
_const_vars => {},
_backtracks => {},
lib/Algorithm/CP/IZ.pm view on Meta::CPAN
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");
},
lib/Algorithm/CP/IZ.pm view on Meta::CPAN
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");
},
);
lib/Algorithm/CP/IZ.pm view on Meta::CPAN
my ($v, $index) = @_;
my $self = {
_pos => 0,
};
bless $self, $class;
}
sub next {
my $self = shift;
my ($v, $index) = @_;
view release on metacpan or search on metacpan
lib/Algorithm/CRF.pm view on Meta::CPAN
require XSLoader;
XSLoader::load('Algorithm::CRF', $VERSION);
sub new {
my $package = shift;
my $self = bless {
@_,
}, $package;
return $self;
}
view release on metacpan or search on metacpan
lib/Algorithm/CheckDigits/M07_001.pm view on Meta::CPAN
our @ISA = qw(Algorithm::CheckDigits);
sub new {
my $proto = shift;
my $class = ref($proto) || $proto;
return bless({}, $class);
} # new()
sub is_valid {
my ($self,$number) = @_;
if ($number =~ /^([0-9]*)([0-9])$/) {
view release on metacpan or search on metacpan
ChooseSubsets.pm view on Meta::CPAN
if (!defined($args{'size'})) {
$args{'size'} = 0;
$args{'all'} = 1;
}
bless (+{
_size => ($args{'size'}), # size of the subsets we are returning
_original_size => ($args{'size'}), # ditto, for resetting purposes
_set => ($args{'set'} || croak "Missing set"), # the set
_n => scalar(@{$args{'set'}}), # size of the set
_c => undef, # Current indexes to return.
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
$args{path} = $args{name};
$args{path} =~ s!::!/!g;
}
$args{file} ||= "$args{base}/$args{prefix}/$args{path}.pm";
bless( \%args, $class );
}
sub call {
my ($self, $method) = @_;
my $obj = $self->load($method) or return;
view release on metacpan or search on metacpan
perl/Record.pm view on Meta::CPAN
$self->{gorder} = undef;
$self->{expid} = undef;
$self->{eweight} = undef;
$self->{eorder} = undef;
$self->{uniqid} = undef;
bless($self, $class);
return $self;
}
sub read {
my $self = shift;
view release on metacpan or search on metacpan
lib/Algorithm/ClusterPoints.pm view on Meta::CPAN
my $scales = delete $opts{scales};
my $dimensional_groups = delete $opts{dimensional_groups};
%opts and croak "unknown constructor option(s) '".join("', '", sort keys %opts)."'";
my $self = bless { radius => 1.0,
minimum_size => 1,
ordered => 0,
dimension => $dimension,
coords => [ map [], 1..$dimension ],
scales => [ map 1, 1..$dimension ],
view release on metacpan or search on metacpan
Combinatorics.pm view on Meta::CPAN
# returned or not, since that might potentially be done a lot
# of times.
#
# The solution is to return an iterator that has a first sequence
# associated. The first time you call it that sequence is returned
# and the iterator rebless itself to become just a wrapped coderef.
#
# Note that the public contract is that responds to next(), no
# iterator class name is documented.
package Algorithm::Combinatorics::Iterator;
sub new {
my ($class, $coderef, $first_seq) = @_;
if (defined $first_seq) {
return bless [$coderef, $first_seq], $class;
} else {
return bless $coderef, 'Algorithm::Combinatorics::JustCoderef';
}
}
sub next {
my ($self) = @_;
$_[0] = $self->[0];
bless $_[0], 'Algorithm::Combinatorics::JustCoderef';
return $self->[1];
}
package Algorithm::Combinatorics::JustCoderef;
view release on metacpan or search on metacpan
O_OBJECT
if ( sv_isobject($arg) && (SvTYPE(SvRV($arg)) == SVt_PVMG) )
$var = INT2PTR($type, SvIV((SV*)SvRV( $arg )));
else
croak( \"${Package}::$func_name() -- $var is not a blessed SV reference\" );
HERE
### new({ids => [key1, key2, key3], replicas => 123})
view release on metacpan or search on metacpan
sv_2uv_flags||5.009001|
sv_2uv|5.004000||p
sv_add_arena|||
sv_add_backref|||
sv_backoff|||
sv_bless|||
sv_cat_decode||5.008001|
sv_catpv_flags||5.013006|
sv_catpv_mg|5.004050||p
sv_catpv_nomg||5.013006|
sv_catpvf_mg_nocontext|||pvn
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
$args{path} =~ s!::!/!g;
}
$args{file} ||= "$args{base}/$args{prefix}/$args{path}.pm";
$args{wrote} = 0;
bless( \%args, $class );
}
sub call {
my ($self, $method) = @_;
my $obj = $self->load($method) or return;
view release on metacpan or search on metacpan
lib/Algorithm/ConstructDFA/XS.pm view on Meta::CPAN
# TODO: theoretically there could be name clashes between the
# artificial vertex created here and vertices in the original
# unwrapped input which can interfere with the bimaps mapping
# stringified vertices to numbers.
push @successors, bless \(Storable::freeze([$src, $label, $dst])),
$class;
}
return @successors;
};
view release on metacpan or search on metacpan
lib/Algorithm/ContextVector.pm view on Meta::CPAN
use Storable;
sub new {
my $class = shift;
my %opts = @_;
return bless {
top => $opts{top},
labels => {},
}, $class;
}
view release on metacpan or search on metacpan
lib/Algorithm/Cron.pm view on Meta::CPAN
@params{ @FIELDS_CTOR } = @fields;
}
$params{sec} = 0 unless exists $params{sec};
my $self = bless {
base => $base,
}, $class;
foreach ( @FIELDS_CTOR ) {
next unless exists $params{$_};
view release on metacpan or search on metacpan
lib/Algorithm/DBSCAN.pm view on Meta::CPAN
$self->{eps} = $eps;
$self->{min_points} = $min_points;
$self->{current_cluster} = 1;
$self->{use_external_region_index} = 0;
bless($self, $type);
return($self);
}
=head2 FindClusters
view release on metacpan or search on metacpan
lib/Algorithm/DLX.pm view on Meta::CPAN
right => undef,
up => undef,
down => undef,
column => undef,
};
bless $self, $class;
return $self;
}
# Column structure for DLX
package DLX::Column;
lib/Algorithm/DLX.pm view on Meta::CPAN
my ($class, $col) = @_;
my $self = $class->SUPER::new(undef, $col);
$self->{size} = 0;
$self->{name} = $col;
$self->{column} = $self;
bless $self, $class;
return $self;
}
# Main DLX package
package Algorithm::DLX;
lib/Algorithm/DLX.pm view on Meta::CPAN
};
# Initialize header links
$self->{header}->{left} = $self->{header};
$self->{header}->{right} = $self->{header};
bless $self, $class;
return $self;
}
sub add_column {
view release on metacpan or search on metacpan
lib/Algorithm/BoostedDecisionTree.pm view on Meta::CPAN
croak "\nYou have used a wrong name for a keyword argument --- perhaps a misspelling\n"
if check_for_illegal_params(@params) == 0;
my %dtargs = %args;
delete $dtargs{how_many_stages};
my $instance = Algorithm::DecisionTree->new(%dtargs);
bless $instance, $class;
$instance->{_how_many_stages} = $args{how_many_stages} || undef;
$instance->{_stagedebug} = $args{stagedebug} || 0;
$instance->{_training_samples} = {map {$_ => []} 0..$args{how_many_stages}};
$instance->{_all_trees} = {map {$_ => Algorithm::DecisionTree->new(%dtargs)} 0..$args{how_many_stages}};
$instance->{_root_nodes} = {map {$_ => undef} 0..$args{how_many_stages}};
$instance->{_sample_selection_probs} = {map {$_ => {}} 0..$args{how_many_stages}};
$instance->{_trust_factors} = {map {$_ => undef} 0..$args{how_many_stages}};
$instance->{_misclassified_samples} = {map {$_ => []} 0..$args{how_many_stages}};
$instance->{_classifications} = undef;
$instance->{_trust_weighted_decision_classes} = undef;
bless $instance, $class;
}
############################################## Methods #################################################
sub get_training_data_for_base_tree {
my $self = shift;
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
$args{path} =~ s!::!/!g;
}
$args{file} ||= "$args{base}/$args{prefix}/$args{path}.pm";
$args{wrote} = 0;
bless( \%args, $class );
}
sub call {
my ($self, $method) = @_;
my $obj = $self->load($method) or return;
view release on metacpan or search on metacpan
lib/Algorithm/Dependency/Objects.pm view on Meta::CPAN
use strict;
use warnings;
our $VERSION = '0.04';
use Scalar::Util qw/blessed/;
use Carp qw/croak/;
use Set::Object;
sub _to_set {
my ( $class, $objects ) = @_;
if ( ref $objects ) {
$objects = Set::Object->new(@$objects) if not blessed $objects and ref $objects eq 'ARRAY';
if ( blessed $objects and $objects->isa("Set::Object") ) {
return $objects;
}
}
return;
lib/Algorithm/Dependency/Objects.pm view on Meta::CPAN
# all the contents of the Set::Object must have depends methods
$class->assert_can_get_deps($objects);
$objects = $class->verify_input_set($objects);
return bless {
objects => $objects,
selected => $selected,
}, $class;
}
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
$args{path} =~ s!::!/!g;
}
$args{file} ||= "$args{base}/$args{prefix}/$args{path}.pm";
$args{wrote} = 0;
bless( \%args, $class );
}
sub call {
my ($self, $method) = @_;
my $obj = $self->load($method) or return;
view release on metacpan or search on metacpan
lib/Algorithm/Dependency.pm view on Meta::CPAN
my %args = @_;
my $source = _INSTANCE($args{source}, 'Algorithm::Dependency::Source')
or return undef;
# Create the object
my $self = bless {
source => $source, # Source object
selected => {},
}, $class;
# Were we given the 'ignore_orphans' flag?
view release on metacpan or search on metacpan
t/01-operation.t view on Meta::CPAN
my $operation = Algorithm::DependencySolver::Operation->new(
id => 1,
depends => [ ],
affects => [ ],
prerequisites => [ ],
obj => bless({}, "Object"),
);
ok $operation, 'operation with... no depends, no affects, no prerequesites';
}
t/01-operation.t view on Meta::CPAN
my $operation = Algorithm::DependencySolver::Operation->new(
id => 1,
depends => [ 'a' ],
affects => [ ],
prerequisites => [ ],
obj => bless({}, "Object"),
);
ok $operation, 'operation with... 1 depend, no affects, no prerequesites';
}
t/01-operation.t view on Meta::CPAN
my $operation = Algorithm::DependencySolver::Operation->new(
id => 1,
depends => [ 'a', 'b' ],
affects => [ ],
prerequisites => [ ],
obj => bless({}, "Object"),
);
ok $operation, 'operation with... 2 depends, no affects, no prerequesites';
}
t/01-operation.t view on Meta::CPAN
my $operation = Algorithm::DependencySolver::Operation->new(
id => 1,
depends => [ ],
affects => [ 'a' ],
prerequisites => [ ],
obj => bless({}, "Object"),
);
ok $operation, 'operation with... no depends, 1 affects, no prerequesites';
}
t/01-operation.t view on Meta::CPAN
my $operation = Algorithm::DependencySolver::Operation->new(
id => 1,
depends => [ ],
affects => [ 'a', 'b' ],
prerequisites => [ ],
obj => bless({}, "Object"),
);
ok $operation, 'operation with... no depends, 2 affects, no prerequesites';
}
t/01-operation.t view on Meta::CPAN
my $operation = Algorithm::DependencySolver::Operation->new(
id => 1,
depends => [ ],
affects => [ ],
prerequisites => [ 'a' ],
obj => bless({}, "Object"),
);
ok $operation, 'operation with... no depends, no affects, 1 prerequesite';
}
t/01-operation.t view on Meta::CPAN
my $operation = Algorithm::DependencySolver::Operation->new(
id => 1,
depends => [ ],
affects => [ ],
prerequisites => [ 'a', 'b' ],
obj => bless({}, "Object"),
);
ok $operation, 'operation with... no depends, no affects, 2 prerequesites';
}
t/01-operation.t view on Meta::CPAN
my $operation = Algorithm::DependencySolver::Operation->new(
id => 1,
depends => [ 'a' ],
affects => [ 'b', 'c' ],
prerequisites => [ 'd', 'e', 'f' ],
obj => bless({}, "Object"),
);
ok $operation, 'operation with... 1 depend, 2 affects, 3 prerequesites';
}
view release on metacpan or search on metacpan
lib/Algorithm/Diff/Any.pm view on Meta::CPAN
}
else {
$self->{backend} = Algorithm::Diff->new($seq1, $seq2, $opts);
}
bless($self, $class);
return $self;
}
=head2 Next
view release on metacpan or search on metacpan
lib/Algorithm/Diff/HTMLTable.pm view on Meta::CPAN
our $VERSION = '0.05';
sub new {
my ($class, @param) = @_;
return bless {@param}, $class;
}
sub diff {
my $self = shift;
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
$args{path} = $args{name};
$args{path} =~ s!::!/!g;
}
$args{file} ||= "$args{base}/$args{prefix}/$args{path}.pm";
bless( \%args, $class );
}
sub call {
my ($self, $method) = @_;
my $obj = $self->load($method) or return;
view release on metacpan or search on metacpan
"start2" => $start2,
"end1" => $end1,
"end2" => $end2,
"blocks" => [$block],
};
bless $hunk, $class;
$hunk->flag_context($context_items);
return $hunk;
}
my $hashref = {"sign" => $sign, "item_no" => $item_no};
push @changes, $hashref;
}
my $block = { "changes" => \@changes };
bless $block, $class;
$block->{"length_diff"} = $block->insert - $block->remove;
return $block;
}