error results from the CPAN

lib/Algorithm/CurveFit/Simple.pm view on Meta::CPAN

        return $y;
    }

=item C<fit(bounds_check =E<gt> 1)>

When set, the implementation will include logic for checking whether the input is out-of-bounds, per the highest and lowest x points in the data used to fit the formula.  For implementation languages which support exceptions, an exception will be thr...

For instance, if the highest x in C<$xydata> is 83.0 and the lowest x is 60.0:

    my($max_dev, $avg_dev, $src) = fit(xydata => \@xy, bounds_check => 1);

view all matches for this distribution

Algorithm-DBSCAN

3 results

t/01-clustering.t view on Meta::CPAN

				my $nb_ok = 0;
				foreach my $p (@points) {
					$nb_ok++ if ($clusters{$cluster_id}->{$p})
				}
				
				die "error: [$nb_ok] != [".scalar(keys %{$clusters{$cluster_id}})."]" unless ($nb_ok == scalar(keys %{$clusters{$cluster_id}}));
			}
		}
		die "error: point [$points[0]] not found in any cluster" unless($cluster_found);
	}
	
	say "RESULT OK";
	return 1;
}

view all matches for this distribution

Algorithm-Damm

5 results

lib/Algorithm/Damm.pm view on Meta::CPAN


=pod

=head1 NAME

Algorithm::Damm - Calculate the Damm error correction check digit.

=head1 SYNOPSIS

  use Algorithm::Damm qw/check_digit is_valid/;

lib/Algorithm/Damm.pm view on Meta::CPAN

Slightly different approach to generating check digits.

=item Wikipedia

L<http://en.wikipedia.org/wiki/Damm_algorithm> - Article explaining
the Damm error correction algorithm.

=back

=head1 REPOSITORY

view all matches for this distribution

Algorithm-DecisionTree

4 results

ExamplesRandomizedTrees/classify_database_records.pl view on Meta::CPAN

###
###   --- It shows for each test sample the class label as calculated by
###        RandomizedTreesForBigData and the class label as present in the training
###        database.
###
###   ---  It presents the overall classification error.
###
###   --- It presents the confusion matrix that is obtaining by aggregating the
###        calculated-class-labels versus the true-class-labels

ExamplesRandomizedTrees/classify_database_records.pl view on Meta::CPAN

    $original_classifications{$record_index} = $record_ids_with_class_labels{$record_index};
    $classification =~ /=(.+)$/;
    $calculated_classifications{$record_index} = $1;
}

my $total_errors = 0;
my @confusion_matrix_row1 = (0,0);
my @confusion_matrix_row2 = (0,0);

print "\n\nCalculating the error rate and the confusion matrix:\n";
foreach my $record_index (sort keys %calculated_classifications) {
    $total_errors += 1 if $original_classifications{$record_index} ne $calculated_classifications{$record_index};    
    if ($original_classifications{$record_index} eq $class_names_used_in_database[1]) {
        if ($calculated_classifications{$record_index} eq $class_names_used_in_database[1]) {
            $confusion_matrix_row1[0] += 1;
        } else {
            $confusion_matrix_row1[1] += 1;

ExamplesRandomizedTrees/classify_database_records.pl view on Meta::CPAN

            $confusion_matrix_row2[1] += 1;
        }
    }
}

my $percentage_errors =  ($total_errors * 100.0) / scalar keys %calculated_classifications;
print "\n\nClassification error rate: $percentage_errors\n";
print "\nConfusion Matrix:\n\n";
printf("%50s          %25s\n", "classified as NOT at risk", "classified as at risk");
printf("Known to be NOT at risk: %10d  %35d\n\n", @confusion_matrix_row1);                       #(G)
printf("Known to be at risk:%15d  %35d\n\n", @confusion_matrix_row2);                            #(H)

view all matches for this distribution

Algorithm-Dependency-MapReduce

1 match

# Whether or not inc::Module::Install is actually loaded, the
# $INC{inc/Module/Install.pm} is what will still get set as long as
# the caller loaded module this in the documented manner.
# If not set, the caller may NOT have loaded the bundled version, and thus
# they may not have a MI version that works with the Makefile.PL. This would
# result in false errors or unexpected behaviour. And we don't want that.
my $file = join( '/', 'inc', split /::/, __PACKAGE__ ) . '.pm';
unless ( $INC{$file} ) { die <<"END_DIE" }

Please invoke ${\__PACKAGE__} with:

	# If the modification time is only slightly in the future,
	# sleep briefly to remove the problem.
	my $a = $s - time;
	if ( $a > 0 and $a < 5 ) { sleep 5 }

	# Too far in the future, throw an error.
	my $t = time;
	if ( $s > $t ) { die <<"END_DIE" }

Your installer $0 has a modification time in the future ($s > $t).

view all matches for this distribution

Algorithm-Dependency-Objects

1 match

lib/Algorithm/Dependency/Objects/Ordered.pm view on Meta::CPAN

sub _order {
	my ( $self, @queue ) = @_;

	my $selected = Set::Object->new( $self->selected->members );

	my $error_marker;
	my @schedule;

	my %dep_set; 

	while (@queue){
		my $obj = shift @queue;

		if ( defined($error_marker) and refaddr($error_marker) == refaddr($obj) ) {
			$self->circular_dep($obj, @queue);
		}
		
		my $dep_set = $dep_set{refaddr $obj} ||= Set::Object->new( $self->get_deps($obj) );

lib/Algorithm/Dependency/Objects/Ordered.pm view on Meta::CPAN

			# put the object back in the queue
			push @queue, $obj;

			# if we encounter it again without any change
			# then a circular dependency is detected
			$error_marker = $obj unless defined $error_marker;
		} else {
			# the dependancies are a subset of the selected objects,
			# so they are all resolved.
			push @schedule, $obj;

			# mark the object as selected
			$selected->insert($obj);

			# since something changed we can forget about the error marker
			undef $error_marker;
		}
	}

	# return the ordered list
	@schedule;

view all matches for this distribution

Algorithm-Dependency-Source-DBI

3 results

# Whether or not inc::Module::Install is actually loaded, the
# $INC{inc/Module/Install.pm} is what will still get set as long as
# the caller loaded module this in the documented manner.
# If not set, the caller may NOT have loaded the bundled version, and thus
# they may not have a MI version that works with the Makefile.PL. This would
# result in false errors or unexpected behaviour. And we don't want that.
my $file = join( '/', 'inc', split /::/, __PACKAGE__ ) . '.pm';
unless ( $INC{$file} ) { die <<"END_DIE" }

Please invoke ${\__PACKAGE__} with:

	# If the modification time is only slightly in the future,
	# sleep briefly to remove the problem.
	my $a = $s - time;
	if ( $a > 0 and $a < 5 ) { sleep 5 }

	# Too far in the future, throw an error.
	my $t = time;
	if ( $s > $t ) { die <<"END_DIE" }

Your installer $0 has a modification time in the future ($s > $t).

view all matches for this distribution

Algorithm-Dependency

9 results

#pod in this list, we don't have to include it in the output of the C<schedule> or
#pod C<depends> methods.
#pod
#pod =item ignore_orphans => 1
#pod
#pod Normally, the item source is expected to be largely perfect and error free.
#pod An 'orphan' is an item name that appears as a dependency of another item, but
#pod doesn't exist, or has been deleted.
#pod
#pod By providing the C<ignore_orphans> flag, orphans are simply ignored. Without
#pod the C<ignore_orphans> flag, an error will be returned if an orphan is found.
#pod
#pod =back
#pod
#pod The C<new> constructor returns a new Algorithm::Dependency object on success,
#pod or C<undef> on error.
#pod
#pod =cut

sub new {
	my $class  = shift;

#pod =pod
#pod
#pod =head2 selected $name
#pod
#pod Given an item name, the C<selected> method will return true if the item is
#pod selected, false is not, or C<undef> if the item does not exist, or an error
#pod occurs.
#pod
#pod =cut

sub selected { $_[0]->{selected}->{$_[1]} }

#pod If multiple item names are provided, the same applies. The list returned
#pod will not contain duplicates.
#pod
#pod The method returns a reference to an array of item names on success, a
#pod reference to an empty array if no other items are needed, or C<undef>
#pod on error.
#pod
#pod NOTE: The result of C<depends> is ordered by an internal C<sort>
#pod irrespective of the ordering provided by the dependency handler.  Use
#pod L<Algorithm::Dependency::Ordered> and C<schedule> to use the most
#pod common ordering (process sequence)

#pod If any of the names you provided in the arguments is already selected, it
#pod will not be included in the list.
#pod
#pod The method returns a reference to an array of item names on success, a
#pod reference to an empty array if no items need to be acted upon, or C<undef>
#pod on error.
#pod
#pod =cut

sub schedule {
	my $self  = shift;

in this list, we don't have to include it in the output of the C<schedule> or
C<depends> methods.

=item ignore_orphans => 1

Normally, the item source is expected to be largely perfect and error free.
An 'orphan' is an item name that appears as a dependency of another item, but
doesn't exist, or has been deleted.

By providing the C<ignore_orphans> flag, orphans are simply ignored. Without
the C<ignore_orphans> flag, an error will be returned if an orphan is found.

=back

The C<new> constructor returns a new Algorithm::Dependency object on success,
or C<undef> on error.

=head2 source

The C<source> method retrieves the L<Algorithm::Dependency::Source> object
for the algorithm context.

the list of the names of the selected items.

=head2 selected $name

Given an item name, the C<selected> method will return true if the item is
selected, false is not, or C<undef> if the item does not exist, or an error
occurs.

=head2 item $name

The C<item> method fetches and returns the item object, as specified by the

If multiple item names are provided, the same applies. The list returned
will not contain duplicates.

The method returns a reference to an array of item names on success, a
reference to an empty array if no other items are needed, or C<undef>
on error.

NOTE: The result of C<depends> is ordered by an internal C<sort>
irrespective of the ordering provided by the dependency handler.  Use
L<Algorithm::Dependency::Ordered> and C<schedule> to use the most
common ordering (process sequence)

If any of the names you provided in the arguments is already selected, it
will not be included in the list.

The method returns a reference to an array of item names on success, a
reference to an empty array if no items need to be acted upon, or C<undef>
on error.

=head2 schedule_all;

The C<schedule_all> method acts the same as the C<schedule> method, but 
returns a schedule that selected all the so-far unselected items.

view all matches for this distribution

Algorithm-DependencySolver

1 match

.travis.yml view on Meta::CPAN

branches:
  only:
    - /^build/

before_install:
   # Prevent "Please tell me who you are" errors for certain DZIL configs
   - git config --global user.name "lokku"

view all matches for this distribution

Algorithm-Diff-Any

1 match

lib/Algorithm/Diff/Any.pm view on Meta::CPAN

  my $diff = Algorithm::Diff::Any->new( \@seq1, \@seq2 );
  # or with options
  my $diff = Algorithm::Diff::Any->new( \@seq1, \@seq2, \%opts );

This method will return an appropriate B<Algorithm::Diff::Any> object or
throw an exception on error.

=cut

# Wrappers around the actual methods
sub new {

view all matches for this distribution

Algorithm-Diff-Callback

1 match

t/croak.t view on Meta::CPAN

my @old = qw( one two  );
my @new = qw( one four );
$|++;

eval { diff_arrays( \@old, \@new, added => sub {}, deleted => sub {} ) };
ok( $@, 'Caught error' );

like( $@, qr/Can't recognize change in changeset\: '\*'/, 'Unknown change' );

view all matches for this distribution

Algorithm-Diff-HTMLTable

1 match

t/10_diff.t view on Meta::CPAN

use Algorithm::Diff::HTMLTable;

my $table = Algorithm::Diff::HTMLTable->new;

{
    my $error;

    eval {
        $table->diff();
        1;
    } or $error = $@;

    like $error, qr/need two filenames/, 'no filenames';
}

{
    my $error;

    eval {
        $table->diff('file1');
        1;
    } or $error = $@;

    like $error, qr/need two filenames/, 'one filenames';
}

{
    my $error;

    eval {
        $table->diff('file1', 'file2', 'file3');
        1;
    } or $error = $@;

    like $error, qr/need two filenames/, 'too many arguments';
}

{
    my $error;

    eval {
        $table->diff('file1', 'file2');
        1;
    } or $error = $@;

    like $error, qr/is not a file/, 'is not a file';
}

{
    my $error;

    eval {
        $table->diff( {}, {} );
        1;
    } or $error = $@;

    like $error, qr/Need either filename/, 'Hashref passed';
}

done_testing();

view all matches for this distribution

Algorithm-Diff-XS

2 results

# Whether or not inc::Module::Install is actually loaded, the
# $INC{inc/Module/Install.pm} is what will still get set as long as
# the caller loaded module this in the documented manner.
# If not set, the caller may NOT have loaded the bundled version, and thus
# they may not have a MI version that works with the Makefile.PL. This would
# result in false errors or unexpected behaviour. And we don't want that.
my $file = join( '/', 'inc', split /::/, __PACKAGE__ ) . '.pm';
unless ( $INC{$file} ) {
    die <<"END_DIE";
Please invoke ${\__PACKAGE__} with:

view all matches for this distribution

Algorithm-Diff

1 match

lib/Algorithm/Diff.pm view on Meta::CPAN


    # Check for bogus (non-ref) argument values
    if ( !ref($a) || !ref($b) )
    {
        my @callerInfo = caller(1);
        die 'error: must pass array or hash references to ' . $callerInfo[3];
    }

    # set up code refs
    # Note that these are optimized.
    if ( !defined($keyGen) )    # optimize for strings

lib/Algorithm/Diff.pm view on Meta::CPAN


    $diff->Get('min1') == $diff->Min(1)
    $diff->Get('0min2') == $diff->Min(2,0)

Using C<Get> in a scalar context when you've passed in more than one
name is a fatal error (C<die> is called).

=back

=head2 C<prepare>

view all matches for this distribution

Algorithm-DimReduction

3 results

# Whether or not inc::Module::Install is actually loaded, the
# $INC{inc/Module/Install.pm} is what will still get set as long as
# the caller loaded module this in the documented manner.
# If not set, the caller may NOT have loaded the bundled version, and thus
# they may not have a MI version that works with the Makefile.PL. This would
# result in false errors or unexpected behaviour. And we don't want that.
my $file = join( '/', 'inc', split /::/, __PACKAGE__ ) . '.pm';
unless ( $INC{$file} ) {
    die <<"END_DIE";
Please invoke ${\__PACKAGE__} with:

view all matches for this distribution

Algorithm-EquivalenceSets

1 match

# Create an object from a file
sub read {
	my $class = ref $_[0] ? ref shift : shift;

	# Check the file
	my $file = shift or return $class->_error( 'You did not specify a file name' );
	return $class->_error( "File '$file' does not exist" )              unless -e $file;
	return $class->_error( "'$file' is a directory, not a file" )       unless -f _;
	return $class->_error( "Insufficient permissions to read '$file'" ) unless -r _;

	# Slurp in the file
	local $/ = undef;
	local *CFG;
	unless ( open(CFG, $file) ) {
		return $class->_error("Failed to open file '$file': $!");
	}
	my $contents = <CFG>;
	unless ( close(CFG) ) {
		return $class->_error("Failed to close file '$file': $!");
	}

	$class->read_string( $contents );
}

sub read_string {
	my $class  = ref $_[0] ? ref shift : shift;
	my $self   = bless [], $class;
	my $string = $_[0];
	unless ( defined $string ) {
		return $self->_error("Did not provide a string to load");
	}

	# Byte order marks
	# NOTE: Keeping this here to educate maintainers
	# my %BOM = (

	#     "\377\376"     => 'UTF-16LE',
	#     "\377\376\0\0" => 'UTF-32LE'
	#     "\0\0\376\377" => 'UTF-32BE',
	# );
	if ( $string =~ /^(?:\376\377|\377\376|\377\376\0\0|\0\0\376\377)/ ) {
		return $self->_error("Stream has a non UTF-8 BOM");
	} else {
		# Strip UTF-8 bom if found, we'll just ignore it
		$string =~ s/^\357\273\277//;
	}

	utf8::decode($string) if HAVE_UTF8;

	# Check for some special cases
	return $self unless length $string;
	unless ( $string =~ /[\012\015]+\z/ ) {
		return $self->_error("Stream does not end with newline character");
	}

	# Split the file into lines
	my @lines = grep { ! /^\s*(?:\#.*)?\z/ }
	            split /(?:\015{1,2}\012|\015|\012)/, $string;

	}

	return 1;
}

# Set error
sub _error {
	$YAML::Tiny::errstr = $_[1];
	undef;
}

# Retrieve error
sub errstr {
	$YAML::Tiny::errstr;
}

view all matches for this distribution

Algorithm-Evolutionary-Fitness

2 results

lib/Algorithm/Evolutionary/Fitness/ECC.pm view on Meta::CPAN


"                                                    The ECC problem was presented in
[MW]. We will consider a three-tuple (n, M, d), where n is the length of each codeword
(number of bits), M is the number of codewords, and d is the minimum Hamming
distance between any pair of codewords. Our objective will be to find a code which
has a value for d as large as possible (reflecting greater tolerance to noise and errors),
given previously fixed values for n and M . The problem we have studied is a simplified
version of that in [MW]. In our case we search half of the codewords (M/2) that will
compose the code, and the other half is made up by the complement of the codewords
computed by the algorithm"

view all matches for this distribution

Algorithm-Evolutionary-Utils

1 match

2016-03-22  JJ Merelo  <jmerelo@flash>

	* lib/Algorithm/Evolutionary/Utils.pm (consensus): Fixes the consensus string and changes threshold. 
	Covering also default values.
	Improving coverage of conditionals and testing new version.
	Fixes error generating random bitstring: Always generated hashref.

2016-03-21  JJ Merelo  <jmerelo@flash>

	* lib/Algorithm/Evolutionary/Utils.pm: bumping up version to 1.0.1 with generation of seudo-chromosomes

	* MANIFEST: Eliminating pod.t also in production code.

2012-07-09  Juan J. Merelo Guervós  <jjmerelo@gmail.com>

	* MANIFEST: Eliminated pod-coverage.t, which is not needed for
	production and causes errors in some systems. 

2012-07-08  Juan J. Merelo Guervós  <jjmerelo@gmail.com>

	* MANIFEST: Adding missing test files


	* lib/Algorithm/Evolutionary/Fitness/Rastrigin.pm (Rastrigin):
	Fixed formula

	* lib/Algorithm/Evolutionary.pm: Starting 0.74_1 with cosmetic
	changes and an attempt to fix sporadic test errors.  

2010-09-24  Juan Julian Merelo Guervos  <jmerelo@usuario-desktop>

	* lib/Algorithm/Evolutionary/Fitness/Rastrigin.pm (Rastrigin): Added first floating-point fitness func.


2009-07-30  Juan Julian Merelo Guervos  <jmerelo@geneura.ugr.es>

	* lib/Algorithm/Evolutionary.pm: Moved a GUI example to the
	scripts dir so that it's installed automatically. Expanded
	documentation to reflect that. Fixed also error (population
	explosion) in Easy_MO.

2009-07-28  Juan Julian Merelo Guervos  <jmerelo@geneura.ugr.es>

	* lib/Algorithm/Evolutionary.pm: Starting 0.70_1 with the


2009-07-24    <jmerelo@localhost.localdomain>

	* lib/Algorithm/Evolutionary.pm: 0.68 was shortlived, but 0.69
	more or less the same. 0.69 included missing file and fixed some
	docs errors; 0.69_1 starts with the same objective, let's see how
	it ends.

2009-07-24  Juan Julian Merelo Guervos  <jmerelo@geneura.ugr.es>

	* TODO: 0.68 ends with several new test functions added (Trap,

view all matches for this distribution

Algorithm-Evolutionary

6 results

lib/Algorithm/Evolutionary/Fitness/ECC.pm view on Meta::CPAN

Extracted from article "Effects of scale-free and small-world topologies on binary coded self-adaptive CEA", by Giacobini et al [Ga]. Quoting:
"                                                    The ECC problem was presented in
[MW]. We will consider a three-tuple (n, M, d), where n is the length of each codeword
(number of bits), M is the number of codewords, and d is the minimum Hamming
distance between any pair of codewords. Our objective will be to find a code which
has a value for d as large as possible (reflecting greater tolerance to noise and errors),
given previously fixed values for n and M . The problem we have studied is a simplified
version of that in [MW]. In our case we search half of the codewords (M/2) that will
compose the code, and the other half is made up by the complement of the codewords
computed by the algorithm"

view all matches for this distribution

Algorithm-ExpectationMaximization

1 match

lib/Algorithm/ExpectationMaximization.pm view on Meta::CPAN

        my @num_strings = split /  /, $cluster_strings[$i];
        my @cluster_mean = map {/$_num_regex/;$_} split / /, $num_strings[0];
        $data_dimension = @cluster_mean;
        push @means, \@cluster_mean;
        my @covariance_nums = map {/$_num_regex/;$_} split / /, $num_strings[1];
        croak "dimensionality error" if @covariance_nums != 
                                      ($data_dimension ** 2);
        my $cluster_covariance;
        foreach my $j (0..$data_dimension-1) {
            foreach my $k (0..$data_dimension-1) {        
                $cluster_covariance->[$j]->[$k] =

view all matches for this distribution

Algorithm-FEC

4 results

	- apply fix for newer perl versions and additional testing patch by
          Father Chrysostomos.

1.0   Sun Dec 23 16:43:02 CET 2007
	- more small doc fixes.
        - fix a crash occuring while generating an error message.

0.5   Mon Jun 21 15:06:15 CEST 2004
	- check filesize and croak if mmap extends. also laid
          the foundation for auto-extending short segments.
        - small doc corrections by Jochen Stenzel.

view all matches for this distribution

Algorithm-FastPermute

2 results

FastPermute.pm view on Meta::CPAN

=head1 DESCRIPTION

Algorithm::FastPermute generates all the permutations of an array. You pass a
block of code, which will be executed for each permutation. The array will be
changed in place, and then changed back again before C<permute> returns. During
the execution of the callback, the array is read-only and you'll get an error
if you try to change its length. (You I<can> change its elements, but the
consequences are liable to confuse you and may change in future versions.)

You have to pass an array, it can't just be a list. It B<does> work with
special arrays and tied arrays, though unless you're doing something

view all matches for this distribution

Algorithm-FeatureSelection

2 results

	# Whether or not inc::Module::Install is actually loaded, the
	# $INC{inc/Module/Install.pm} is what will still get set as long as
	# the caller loaded module this in the documented manner.
	# If not set, the caller may NOT have loaded the bundled version, and thus
	# they may not have a MI version that works with the Makefile.PL. This would
	# result in false errors or unexpected behaviour. And we don't want that.
	my $file = join( '/', 'inc', split /::/, __PACKAGE__ ) . '.pm';
	unless ( $INC{$file} ) { die <<"END_DIE" }

Please invoke ${\__PACKAGE__} with:

		# If the modification time is only slightly in the future,
		# sleep briefly to remove the problem.
		my $a = $s - time;
		if ( $a > 0 and $a < 5 ) { sleep 5 }

		# Too far in the future, throw an error.
		my $t = time;
		if ( $s > $t ) { die <<"END_DIE" }

Your installer $0 has a modification time in the future ($s > $t).

			# I'm still wondering if we should slurp Makefile.PL to
			# get some context or not ...
			my ($package, $file, $line) = caller;
			die <<"EOT";
Unknown function is found at $file line $line.
Execution of $file aborted due to runtime errors.

If you're a contributor to a project, you may need to install
some Module::Install extensions from CPAN (or other repository).
If you're a user of a module, please contact the author.
EOT

view all matches for this distribution

Algorithm-FloodControl

2 results

inc/Module/AutoInstall.pm view on Meta::CPAN

        return
          unless system( 'sudo', $^X, $0, "--config=$config",
            "--installdeps=$missing" );

        print << ".";
*** The 'sudo' command exited with error!  Resuming...
.
    }

    return _prompt(
        qq(

view all matches for this distribution

Algorithm-FuzzyCmeans

2 results

# Whether or not inc::Module::Install is actually loaded, the
# $INC{inc/Module/Install.pm} is what will still get set as long as
# the caller loaded module this in the documented manner.
# If not set, the caller may NOT have loaded the bundled version, and thus
# they may not have a MI version that works with the Makefile.PL. This would
# result in false errors or unexpected behaviour. And we don't want that.
my $file = join( '/', 'inc', split /::/, __PACKAGE__ ) . '.pm';
unless ( $INC{$file} ) { die <<"END_DIE" }

Please invoke ${\__PACKAGE__} with:

	# If the modification time is only slightly in the future,
	# sleep briefly to remove the problem.
	my $a = $s - time;
	if ( $a > 0 and $a < 5 ) { sleep 5 }

	# Too far in the future, throw an error.
	my $t = time;
	if ( $s > $t ) { die <<"END_DIE" }

Your installer $0 has a modification time in the future ($s > $t).

view all matches for this distribution

Algorithm-GDiffDelta

6 results

GDiffDelta.pm view on Meta::CPAN

This generates a binary delta describing the changes from I<$file1>
to I<$file2>.  The delta will allow I<$file2> to be reconstructed
from I<$file1> later.

No value is returned.  Errors will cause this function to croak
with a suitable error message.

=item gdiff_delta(I<$file1>, I<$delta_file>, I<$file2>)

Takes three file handles.  The first two are read from, and it must
be possible to seek in them.  The third is written to.

The delta is used to reconstruct I<$file2> from I<$file1>.
The delta must be a valid GDIFF file.

No value is returned.  Errors will cause this function to croak
with a suitable error message.

=back

=head1 ALGORITHM AND DELTA FORMAT

view all matches for this distribution

Algorithm-Genetic-Diploid

1 match

lib/Algorithm/Genetic/Diploid/Logger.pm view on Meta::CPAN


sub FATAL () { 0 }

=item ERROR

Possibly unrecoverable errors are transmitted.

=cut

sub ERROR () { 1 }

lib/Algorithm/Genetic/Diploid/Logger.pm view on Meta::CPAN

sub DEBUG () { 4 }

# constants mapped to string for AUTOLOAD
my %levels = (
	'fatal' => FATAL,
	'error' => ERROR,
	'warn'  => WARN,
	'info'  => INFO,
	'debug' => DEBUG,
);

view all matches for this distribution

Algorithm-GooglePolylineEncoding

2 results

	- stable release with changes in 0.05_50

0.05_50	2017-12-31
	- fix encode_level for large integers (by using
	  Math::BigInt's as_bin)
	  This should fix the test errors seen on 32bit
	  systems.

0.05	2017-06-10
	- fix link in documentation

view all matches for this distribution

Algorithm-Graphs-TransitiveClosure

1 match

t/000_tests.t view on Meta::CPAN

    else {
        print "not ok ", $test_num ++, "\n";
    }
};

if ($@) {print "... error: $@\n";}

eval {
    my $graph = {
        one   => {one => 1},
        two   => {two => 1, three => 1, four => 1},

t/000_tests.t view on Meta::CPAN

    else {
        print "not ok ", $test_num ++, "\n";
    }
};

if ($@) {print "... error: $@\n";}

view all matches for this distribution

Algorithm-Gutter

2 results