view release on metacpan or  search on metacpan

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

from the input sets.

Imagine the input sets to be C<[ 1, 2 ]>, C<[ 3, 4 ]>, C<[ 5, 6 ]>
and C<[ 1, 3, 7 ]>. The returned sets would be C<[ 1, 2, 3, 4, 7 ]> and
C<[ 5, 6 ]>, because C<[ 1, 2 ]> and C<[ 3, 4 ]> are tied together by
C<[ 1, 3, 7 ]>, but C<[ 5, 6 ]> stands on its own. So you could say the
returned sets represent a kind of transitive union. (Real mathematicians may
now flame me about the misuse of terminology.)

Each set is an array reference. The return sets are given as an array in list
context, or as a reference to that array in scalar context.

 view release on metacpan or  search on metacpan

script/bitflip.pl  view on Meta::CPAN

my $length = 16;
my $iterations = 100000;
my $top_length = 2**15;
do {
    my $indi = random_chromosome($length);
    say "perlsimple-BitString, $length, ".time_mutations( $iterations, $indi );
    $length *= 2;
} while $length <= $top_length;

#--------------------------------------------------------------------
sub time_mutations {

 view release on metacpan or  search on metacpan

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

# better the separation between the clusters.  Since this measure has its roots in
# the Fisher linear discriminant function, we incorporate the word 'fisher' in the
# name of the quality measure.  Note that this measure is good only when the clusters
# are disjoint.  When the clusters exhibit significant overlap, the numbers produced
# by this quality measure tend to be generally meaningless.  As an extreme case,
# let's say your data was produced by a set of Gaussians, all with the same mean
# vector, but each with a distinct covariance. For this extreme case, this measure
# will produce a value close to zero --- depending on the accuracy with which the
# means are estimated --- even when your clusterer is doing a good job of identifying
# the individual clusters.
sub clustering_quality_fisher {

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

know the data to be perfectly multimodal Gaussian, EM is probably the most magical
approach to clustering multidimensional data.  Consider the case of clustering
three-dimensional data.  Each Gaussian cluster in 3D space is characterized by the
following 10 variables: the 6 unique elements of the C<3x3> covariance matrix (which
must be symmetric positive-definite), the 3 unique elements of the mean, and the
prior associated with the Gaussian. Now let's say you expect to see six Gaussians in
your data.  What that means is that you would want the values for 59 variables
(remember the unit-summation constraint on the class priors which reduces the overall
number of variables by one) to be estimated by the algorithm that seeks to discover
the clusters in your data.  What's amazing is that, despite the large number of
variables that must be optimized simultaneously, the EM algorithm will very likely

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

guesses for the cluster means can get stuck in a local maximum.

That raises an interesting question of how one judges the correctness of clustering
results when dealing with real experimental data.  For real data, the best approach
is to try the EM algorithm multiple times with all of the seeding options included in
this module.  It would be safe to say that, at least in low dimensional spaces and
with sufficient data, a majority of your runs should yield "correct" results.

Also bear in mind that a pure Perl implementation is not meant for the clustering of
very large data files.  It is really designed more for researching issues related to
EM based approaches to clustering.

 view release on metacpan or  search on metacpan

t/data/2.new  view on Meta::CPAN

[-------------]
<***************************************************************************************************************************************************************************************************************************************************>
peekaboo
peekafoo

They say its the 1st half thats rocky and the latter green
foo
bar
baz
quux
This paragraph contains exactly two hundred and fifty five bytes of data,
if you include the Unix newlines in the middle and the one at the end.
It doesn't actually say anything useful, but it's useful as an example
source file in my tests.  That is all.

 view release on metacpan or  search on metacpan

samples/lights_on.pl  view on Meta::CPAN

if ($sol) {
    my @sol = @$sol;
    while (@sol) {
        my @row = splice @sol, 0, $w;
        say "@row";
    }

    for my $sol0 (@base0) {
        say "sol0:";
        my @sol0 = @$sol0;
        while (@sol0) {
            my @row = splice @sol0, 0, $w;
            say "@row";
        }
    }
}
else {
    say "no solution found"
}

 view release on metacpan or  search on metacpan

xt/rt74303.t  view on Meta::CPAN

#
#   1. Take the initial signed value:
#	  -179.9832104
#   2. Take the decimal value and multiply it by 1e5, flooring the result:
#	  -17998321
### Jidanni: they now say 'round' the result!
sub createEncodings {
    my $pointsRef      = shift;
    my @points         = @{$pointsRef};
    my $encoded_points = '';
    my $pointRef       = '';

 view release on metacpan or  search on metacpan

eg/rainmidi3000.pl  view on Meta::CPAN

# is somehow incorrect.
my $seed = shift;
if ( defined $seed ) {
    srand $seed;
} else {
    say "SEED ", srand;
}

# See MIDI::Event and the MIDI specification.
my @events = (
    [ text_event => 0, 'RAIN-MIDI 3000 ][' ],

eg/rainmidi3000.pl  view on Meta::CPAN

                $s .= ' MIDI -> ' . $cell->context->{pitch};
            } else {
                $s .= ' TOGGLE #' . $cell->context->{toggles}->id;
            }
        }
        say $s;
    }
}

# Generate MIDI events for one or more pitches happening at the
# same time.

 view release on metacpan or  search on metacpan

lib/Algorithm/History/Levels.pm  view on Meta::CPAN

our %SPEC;

sub _pick_history {
    my ($histories, $min_time, $max_time) = @_;
    for my $i (0..$#{$histories}) {
        #say "D:$histories->[$i][1] between $min_time & $max_time?";
        if ($histories->[$i][1] >= $min_time &&
                $histories->[$i][1] <= $max_time) {
            return splice(@$histories, $i, 1);
        }
    }

lib/Algorithm/History/Levels.pm  view on Meta::CPAN

        }

        # if the level is not fully filled yet, fill it with young or old
        # histories
        my $num_filled = @{ $res->{levels}[$l] };
        #say "D:level=$l, num_filled=$num_filled";
        unless ($num_filled >= $num_per_level) {
            my @filler = @histories;
            if ($args{discard_young_histories} // 0) {
                my $time = $now-$num_per_level*$period;
                if ($l > 0) {

 view release on metacpan or  search on metacpan

examples/cluster_and_visualize.pl  view on Meta::CPAN

##      5) Next you need to decide whether or not you want to use the Mahalanobis
##           distance metric for clustering.  The default is the Euclidean metric.
##
##      6) Finally, you need to choose a mask for visualization.  Here is a reason
##           for why the visualization mask is set independently of the data mask
##           that was specified in Step 2: Let's say your datafile has 8 columns and
##           you are choosing to cluster the data records using 4 of those.
##           Subsequently, you may want to visually examine the quality of clustering
##           by examining some or 2D or 3D subspace of of the 4-dimensional space
##           used for clustering

 view release on metacpan or  search on metacpan

eg/kademlia_demo.pl  view on Meta::CPAN

    my $pid = pack 'C*', map { int rand 256 } 1 .. 32;
    $rt->add_peer( $pid, { index => $_ } );
}
my $target  = pack 'H*', 'ff' x 32;
my @closest = $rt->find_closest( $target, 3 );
say 'Top 3 closest peers to FF...:';
say sprintf ' - ID: %s (Peer #%s)', unpack( 'H*', $_->{id} ), $_->{data}{index} for @closest

 view release on metacpan or  search on metacpan

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

=head1 SYNOPSIS

    use Algorithm::Kelly;
    use feature 'say';

    say optimal_f(0.5, 2); # 0.25

=head1 FUNCTIONS

=head2 optimal_f ($probability, $payoff)

 view release on metacpan or  search on metacpan

lib/Algorithm/LibLinear/DataSet.pm  view on Meta::CPAN

  ]);
  my $data_set = Algorithm::LibLinear::DataSet->load(fh => \*DATA);
  my $data_set = Algorithm::LibLinear::DataSet->load(filename => 'liblinear_file');
  my $data_set = Algorithm::LibLinear::DataSet->load(string => "+1 1:0.70833 ...");
  
  say $data_set->size;
  say $data_set->as_string;  # '+1 1:0.70833 2:1 3:1 ...'
  
  __DATA__
  +1 1:0.708333 2:1 3:1 4:-0.320755 5:-0.105023 6:-1 7:1 8:-0.419847 9:-1 10:-0.225806 12:1 13:-1 
  -1 1:0.583333 2:-1 3:0.333333 4:-0.603774 5:1 6:-1 7:1 8:0.358779 9:-1 10:-0.483871 12:-1 13:1 
  +1 1:0.166667 2:1 3:-0.333333 4:-0.433962 5:-0.383562 6:-1 7:-1 8:0.0687023 9:-1 10:-0.903226 11:-1 12:-1 13:1 

 view release on metacpan or  search on metacpan

eg/bench  view on Meta::CPAN

# are the results sane for each? (there may be slight variance if lround
# does something different than Bresenham does? for a game board of a
# particular size you might check all the different possible lines and
# look for any differences between the algos)
say "Bc ", points_of( bline( $first, $last ) );
say "Bp ", points_of( Bresenham::line( $first, $last ) );
say "Lc ", points_of( line( $first, $last ) );
say "Lp ", points_of( ppline( $first, $last ) );

cmpthese(
    -10,
    {   bres_c  => sub { bline( $first, $last ) },
        bres_pp => sub { Bresenham::line( $first, $last ) },

 view release on metacpan or  search on metacpan

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

=back

=head3 Notes

Note that NextPermute() considers two values (say $x and $y) to be
duplicates if (and only if) C<$x eq $y>.

NextPermuteNum() considers $x and $y to be duplicates if C<$x == $y>.

If you have a list of floating point numbers to permute, you might want
to use NextPermute() [instead of NextPermuteNum()] as it is easy to end
up with $x and $y that both display the same (say as "0.1") but are
B<just barely> not equal numerically.  Thus $x and $y would I<look> equal
and it would be true that C<$x eq $y> but also true that C<$x != $y>.  So
NextPermute() would consider them to be duplicates but NextPermuteNum()
would not.

 view release on metacpan or  search on metacpan

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

  
  my $counter = Algorithm::LossyCount->new(max_error_ratio => 0.005);
  $counter->add_sample($_) for @samples;
  
  my $frequencies = $counter->frequencies;
  say $frequencies->{a};  # Approximate freq. of 'a'.
  say $frequencies->{b};  # Approximate freq. of 'b'.
  ...

=head1 DESCRIPTION

Lossy-Counting is a approximate frequency counting algorithm proposed by Manku and Motwani in 2002 (refer L<SEE ALSO> section below.)

 view release on metacpan or  search on metacpan

lib/Algorithm/PageRank/XS.pm  view on Meta::CPAN

The maximum number of tries until we give up trying to achieve convergence.

=item convergence

The maximum number the difference between two subsequent vectors must be before we say we are
"convergent enough". The convergence rate is the rate at which C<alpha^t> goes to 0. Thus,
if you set C<alpha> to C<0.85>, and C<convergence> to C<0.000001>, then you will need C<85> tries.

=back

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

	  working as originally coded (I seem to recall the rules
	  changing some time ago). Changed it to two statements for
	  now.
     2014-07-07
	- After looking over the labeling in the run.t file, added
	  a new attribute, "title". We can now say what the A::QMcC
	  object actually represents.
	- Broke up run.t into separate test files. The original
	  file was compact and in theory easy to add to, but I was
	  having trouble figuring out what was causing my Moose
	  errors. Plus, there were too many eval calls in the code.

 view release on metacpan or  search on metacpan

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

    my $self = shift;
    my $key  = shift;
    return ($key =~ s/\-?\d+(\.\d+)?$/); # test if key is numeric
  }

To use this, we say simply

  $number_list = new Algorithm::SkipList( node_class => 'NumericNode' );

This skip list should work normally, except that the keys must be
numbers.

 view release on metacpan or  search on metacpan

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

  use Algorithm::TSort;

  
  #  $adj = { 1 => [ 2, 3], 2 => [4], 3 => [4]  } ;
  my (@sorted ) = tsort( Graph( ADJ => $adj ). keys %$adj ); 
  say for @sorted; 

  # -- OR --
	
  # $adj_sub = sub { return unless $adj->{ $_[0] } ; return @{$adj->{$_[0]}}; };
  my (@sorted) = tsort( Graph( ADJSUB => $adj_sub ), @nodes_for_sort );

 view release on metacpan or  search on metacpan

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

=item I<min_idf_threshold:>

First recall that IDF stands for Inverse Document Frequency.  It is calculated during
the second of the three-stage processing of the tickets as described in the section
B<THE THREE STAGES OF PROCESSING TICKETS>.  The IDF value of a word gives us a
measure of the discriminatory power of the word.  Let's say you have a word that
occurs in only one out of 1000 tickets.  Such a word is obviously highly
discriminatory and its IDF would be the logarithm (to base 10) of the ratio of 1000
to 1, which is 3.  On the other hand, for a word that occurs in every one of 1000
tickets, its IDF value would be the logarithm of the ratio of 1000 to 1000, which is
0.  So, for the case when you have 1000 tickets, the upper bound on IDF is 3 and the

 view release on metacpan or  search on metacpan

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

This is because such numbers almost never pass the verhoeff check if they as mis-typed.
This includes common typos such as ommitted or repeated digits, transposed digits and so on.
Since it only adds a single digit onto what might already be a longish number, it's
a good algorithm for use where humans need to enter or read the numbers.

When we say 'number' we really mean 'string of digits' since that is what the Verhoeff
algorithm works on.

To generate such a number, pick a starting number, call verhoeff_check() to get a check digit,
and then APPEND that digit to the end of the original number. Do NOT add the digit arithmetically
to the original number.

 view release on metacpan or  search on metacpan

t/Relativity.test  view on Meta::CPAN

from the axioms. The question of "truth" of the individual geometrical
propositions is thus reduced to one of the "truth" of the axioms. Now
it has long been known that the last question is not only unanswerable
by the methods of geometry, but that it is in itself entirely without
meaning. We cannot ask whether it is true that only one straight line
goes through two points. We can only say that Euclidean geometry deals
with things called "straight lines," to each of which is ascribed the
property of being uniquely determined by two points situated on it.
The concept "true" does not tally with the assertions of pure
geometry, because by the word "true" we are eventually in the habit of
designating always the correspondence with a "real" object; geometry,

t/Relativity.test  view on Meta::CPAN

it by "motion relative to a practically rigid body of reference." The
positions relative to the body of reference (railway carriage or
embankment) have already been defined in detail in the preceding
section. If instead of " body of reference " we insert " system of
co-ordinates," which is a useful idea for mathematical description, we
are in a position to say : The stone traverses a straight line
relative to a system of co-ordinates rigidly attached to the carriage,
but relative to a system of co-ordinates rigidly attached to the
ground (embankment) it describes a parabola. With the aid of this
example it is clearly seen that there is no such thing as an
independently existing trajectory (lit. "path-curve"*), but only

t/Relativity.test  view on Meta::CPAN

through the air in such a manner that its motion, as observed from the
embankment, is uniform and in a straight line. If we were to observe
the flying raven from the moving railway carriage. we should find that
the motion of the raven would be one of different velocity and
direction, but that it would still be uniform and in a straight line.
Expressed in an abstract manner we may say : If a mass m is moving
uniformly in a straight line with respect to a co-ordinate system K,
then it will also be moving uniformly and in a straight line relative
to a second co-ordinate system K1 provided that the latter is
executing a uniform translatory motion with respect to K. In
accordance with the discussion contained in the preceding section, it

t/Relativity.test  view on Meta::CPAN

Are two events (e.g. the two strokes of lightning A and B) which are
simultaneous with reference to the railway embankment also
simultaneous relatively to the train? We shall show directly that the
answer must be in the negative.

When we say that the lightning strokes A and B are simultaneous with
respect to be embankment, we mean: the rays of light emitted at the
places A and B, where the lightning occurs, meet each other at the
mid-point M of the length A arrow B of the embankment. But the events
A and B also correspond to positions A and B on the train. Let M1 be
the mid-point of the distance A arrow B on the travelling train. Just

t/Relativity.test  view on Meta::CPAN

gravitational field. just then, however, he discovers the hook in the
middle of the lid of the chest and the rope which is attached to it,
and he consequently comes to the conclusion that the chest is
suspended at rest in the gravitational field.

Ought we to smile at the man and say that he errs in his conclusion ?
I do not believe we ought to if we wish to remain consistent ; we must
rather admit that his mode of grasping the situation violates neither
reason nor known mechanical laws. Even though it is being accelerated
with respect to the "Galileian space" first considered, we can
nevertheless regard the chest as being at rest. We have thus good

t/Relativity.test  view on Meta::CPAN

being emitted continuously from the one pan, but not from the other. I
am surprised at this, even if I have never seen either a gas range or
a pan before. But if I now notice a luminous something of bluish
colour under the first pan but not under the other, I cease to be
astonished, even if I have never before seen a gas flame. For I can
only say that this bluish something will cause the emission of the
steam, or at least possibly it may do so. If, however, I notice the
bluish something in neither case, and if I observe that the one
continuously emits steam whilst the other does not, then I shall
remain astonished and dissatisfied until I have discovered some
circumstance to which I can attribute the different behaviour of the

t/Relativity.test  view on Meta::CPAN

express this property of the surface by describing the latter as a
continuum.

Let us now imagine that a large number of little rods of equal length
have been made, their lengths being small compared with the dimensions
of the marble slab. When I say they are of equal length, I mean that
one can be laid on any other without the ends overlapping. We next lay
four of these little rods on the marble slab so that they constitute a
quadrilateral figure (a square), the diagonals of which are equally
long. To ensure the equality of the diagonals, we make use of a little
testing-rod. To this square we add similar ones, each of which has one

t/Relativity.test  view on Meta::CPAN

their own accord, then this is an especial favour of the marble slab
and of the little rods, about which I can only be thankfully
surprised. We must experience many such surprises if the construction
is to be successful.

If everything has really gone smoothly, then I say that the points of
the marble slab constitute a Euclidean continuum with respect to the
little rod, which has been used as a " distance " (line-interval). By
choosing one corner of a square as " origin" I can characterise every
other corner of a square with reference to this origin by means of two
numbers. I only need state how many rods I must pass over when,

t/Relativity.test  view on Meta::CPAN

can be carried out by means of the rods e.g. the lattice construction,
considered in Section 24. In contrast to ours, the universe of
these beings is two-dimensional; but, like ours, it extends to
infinity. In their universe there is room for an infinite number of
identical squares made up of rods, i.e. its volume (surface) is
infinite. If these beings say their universe is " plane," there is
sense in the statement, because they mean that they can perform the
constructions of plane Euclidean geometry with their rods. In this
connection the individual rods always represent the same distance,
independently of their position.

 view release on metacpan or  search on metacpan

lib/Alice/Config.pm  view on Meta::CPAN

      }
      $loaded->();
    }
  }
  else {
    say STDERR "No config found, writing a few config to ".$self->fullpath;
    $self->write($loaded);
  }
}

sub read_commandline_args {

lib/Alice/Config.pm  view on Meta::CPAN

  for my $key (keys %$config) {
    if (exists $config->{$key} and my $attr = $self->meta->get_attribute($key)) {
      $self->$key($config->{$key}) if $attr->has_write_method;
    }
    else {
      say STDERR "$key is not a valid config option";
    }
  }
}

sub write {

 view release on metacpan or  search on metacpan

script/install-activemq  view on Meta::CPAN

    if ( -d $self->install_dir ) {
        if ( $self->force ) {
            warn($self->script_name . ": Already installed, but --force - reinstalling\n");
        }
        else {
            warn($self->script_name . ": Already installed, you did not say --force - exiting\n");
            exit 0;
        }
    }
    my $tarball = $self->has_tarball ? $self->tarball : $self->download_tarball;

 view release on metacpan or  search on metacpan

Build.PL  view on Meta::CPAN

	# Convert to semantic version
	$version ||= "0.0.0";
	$version =~ s/^(?<!.)(\d\.\d+)$/$1.0/m;
	if ( !$ENV{COMPILE_ALIEN_AUTOTOOLS}
		 && version->new($version) >= $_->{min_version} ) {
		say "Version $version of $tool found; skipping compilation...";
		# Skipping installation and passing directory of path found by &can_run:
		$tool => join "", ( splitpath($bin_path) )[0, 1] }
	else {
		say "Downloading $tool source archive from ftp.gnu.org...";
		my $ftp = Net::FTP->new("ftp.gnu.org")
			or die "Unable to connect to FTP server";
		$ftp->login or die "Unable to anonymously login to FTP server";
		$ftp->binary;
		$ftp->get($ftp_path) or die "Failed to download $ftp_path";

 view release on metacpan or  search on metacpan

lib/Alien/BWIPP.pm  view on Meta::CPAN

=head1 SYNOPSIS

    use Alien::BWIPP;
    say $_->name for @{Alien::BWIPP->encoders_meta_classes};

=head1 DESCRIPTION

This modules builds encoder classes from PostScript source.

 view release on metacpan or  search on metacpan

lib/Alien/Base/Dino.pm  view on Meta::CPAN

provided libraries.  You get the patches and security fixes supplied by 
your operating system.

Okay, so why not build a dynamic library for a B<share> install?

For this discussion, say you have an alienized library C<Alien::libfoo> 
and an XS module that uses it called C<Foo::XS> (as illustrated in the 
synopsis above).

=over 4

lib/Alien/Base/Dino.pm  view on Meta::CPAN

=item Upgrades can and will break your XS module.

Again, when C<Alien::libfoo> builds a static library and it gets linked 
into a DLL or C<.so> for C<Foo::XS>, it doesn't need the original 
library anymore.  If you are using a dynamic library and you do the same 
thing it maybe works today, but say tomorrow you upgrade 
C<Alien::libfoo> and it replaces the DLL or C<.so> file with an 
incompatible API or ABI?  Now your C<Foo::XS> module has stopped 
working!

=item Dynamic libraries are not portable

 view release on metacpan or  search on metacpan

lib/Alien/Base/ModuleBuild/FAQ.pod  view on Meta::CPAN

=head2 How do I test my package once it is built (before it is installed)?

There are many ways to test Alien modules before (or after) they are installed, but instead
of rolling your own, consider using L<Test::Alien> which is light on dependencies and will
test your module very closely to the way that it will actually be used.  That is to say by
building a mini XS or FFI extension and using it.  It even has tests for tool oriented Alien
distributions (like L<Alien::gmake> and L<Alien::patch>).  Here is a short example, there
are many others included with the L<Test::Alien> documentation:

 use Test2::V0;

 view release on metacpan or  search on metacpan

bin/abcache  view on Meta::CPAN

my $opt_clear;

GetOptions(
  'list'      => \$opt_list,
  'clear'     => \$opt_clear,
  'version|v' => sub { say "abcache (Alien::Build::Plugin::Fetch::Cache) version @{[ $main::VERSION // 'dev' ]}" },
  'help|h'    => sub { pod2usage( -exitval => 0 ) },
) || pod2usage( -exitval => 2 );

my $root = path(bsd_glob '~/.alienbuild/plugin_fetch_cache');

bin/abcache  view on Meta::CPAN

  });
}
elsif($opt_clear)
{
  my $rm = sub {
    say "RM    $_[0]";
    unlink $_[0];
  };
  my $rmdir = sub {
    say "RMDIR $_[0]";
    rmdir $_[0];
  };
  recurse(sub {
    my($uri, $meta, $metafile) = @_;

 view release on metacpan or  search on metacpan

lib/Alien/CImg.pm  view on Meta::CPAN

   palien --cflags Alien::CImg

Or alternativly, this one-liner:

   perl -MAlien::CImg -E 'say Alien::CImg->cflags'

Since CImg installation only contains source code, it does not require
linking. So there is no need for a C<-lcimg> command flag.

See also L<palien|App::palien> and L<Alien::Base>