process results from the CPAN

    use Algorithm::Loops qw( Filter );

    @copy = Filter { s/\\(.)/$1/g } @list;
    $text = Filter { s/^\s+// } @lines;

The same process can be accomplished using a careful and more complex
invocation of map, grep, or foreach.  However, many incorrect ways to
attempt this seem rather seductively appropriate so this function helps
to discourage such (rather common) mistakes.

=head3 Usage


The MapCar* functions are all like C<map> except they each loop over more
than one list at the same time.

[ The name "mapcar" comes from LISP. As I understand it, 'car' comes from
the acronym for a register of the processor where LISP was first
developed, one of two registers used to implement lists in LISP.  I only
mention this so you won't waste too much time trying to figure out what
"mapcar" is supposed to mean. ]

The MapCar* functions all have prototype specifications of (\&@).

corresponding order).  Any value(s) returned by your subroutine are
pushed onto an array that will eventually be returned by MapCar*.

Next your subroutine is called and is passed the B<second> element of
each of the arrays and any value(s) returned are pushed onto the results
array.  Then the process is repeated with the B<third> elements.

This continues until your subroutine has been passed all elements [except
for some cases with MapCarMin()].  If the longest array whose reference
you passed to MapCar() or MapCarU() contained $N elements, then your
subroutine would get called $N times.

Some permutation generators return the full set of all permutations (as a
huge list of lists).  Your input list doesn't have to be very big at all
for the resulting set to be too large to fit in your available memory.

So the NextPermute* routines return each permutation, one at a time, so
you can process them all (eventually) without the need for lots of memory.

A programming object that gives you access to things one-at-a-time is
called an "iterator".

=item No context - Hardly any memory required

view all matches for this distribution

Algorithm-MCL

2 results

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


easy integration MCL in perl scripts and modules. Algorithm::MCL accept references as input and every reference will be found later in some cluster.

=item *

performance and scale. Algorithm::MCL use Perl Data Language for most of its processing and should run very fast on very big clusters. Main Algorithm::MCL procedures are written with "pdlpp".

=back

=head1 METHODS

=head2 new()

create new Algorithm::MCL object that accumulate graph edges and process data.

=head2 addEdge($ref1, $ref2, $distance)

add new edge to graph. first two parameters are reference to vertex objects. third parameter is "connection strength measurement" between vetices. "connection strength measurement" should be number between 0 and 1, higher number means stronger connec...

view all matches for this distribution

Algorithm-MLCS

1 match

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


    wantarray ? @lcs : scalar @lcs;
}

# Auxiliary function that gets single sequence arrayref and
# build specific data structure for further processing
# in order to find LCS
sub _build_seq {
    my ( $seq, %dict, @seq_st ) = @_;

    for ( 0 .. $#{$seq} ) { push @{ $dict{ $seq->[$_] } }, $_ }

view all matches for this distribution

Algorithm-MasterMind

1 match

MANIFEST view on Meta::CPAN

t/12_evo_mm.t
app/mm-eda.cgi
app/run_experiment.pl
app/run_experiment_all.pl
app/evorank.yaml
app/process_experiment.pl
META.yml                                 Module meta-data (added by MakeMaker)

view all matches for this distribution

Algorithm-MedianSelect-XS

1 match

pregfree|||
prepend_elem|||
prepend_madprops|||
printbuf|||
printf_nocontext|||vn
process_special_blocks|||
ptr_table_clear||5.009005|
ptr_table_fetch||5.009005|
ptr_table_find|||n
ptr_table_free||5.009005|
ptr_table_new||5.009005|

view all matches for this distribution

Algorithm-Merge

1 match

CHANGES view on Meta::CPAN


0.03  -  22 Apr 2003

  Fixed some bugs in the traverse_sequences3, diff3, and merge routines.

    merge: properly manage conflicts that remain after processing the 
           diff3 results

    traverse_sequences3: defined some more states in the Callback Map.

    diff3: handle some sequence differences better

view all matches for this distribution

Algorithm-MinPerfHashTwoLevel

5 results

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

used is SipHash 1-3. The full 64 bit hash is called h0, the high 32 bits are
called h1, and the low 32 bits are called h2.)

Computing the hash and mask is done in C (via XS).

The process for looking up a value in a two level hash with n buckets is
as follows:

    0. compute the h0 for the key. (giving: h1 = h0 >> 32; h2 = h0 & 0xFFFFFFFF;)
    1. compute idx1 = h1 % n;
    2. find the xor_val for bucket[idx1]

view all matches for this distribution

Algorithm-NGram

1 match

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


=cut

=item add_text

Splits a block of text up by whitespace and processes each word as a
token. Automatically calls C<add_start_token()> at the beginning of
the text and C<add_end_token()> at the end.

=cut

# process a block of text, auto-tokenizing it
sub add_text {
    my ($self, $text) = @_;

    $self->add_start_token;

view all matches for this distribution

Algorithm-Networksort-Chooser

1 match

bin/algorithm-networksort-chooser view on Meta::CPAN

}




#### Selection network processing

if ($opt->{median}) {
  die "--selection and --median are incompatible" if defined $opt->{selection};

  $opt->{selection} = int($network_size / 2);

view all matches for this distribution

Algorithm-Networksort

1 match

Build.PL view on Meta::CPAN

sub ACTION_test {
	my $self = shift;

	#
	# Some test files take a long time to run. To save
	# the testers some processing time, skip those tests
	# by default (this is determined within the individual
	# test files).  Use the --Testlong option to set the
	# AUTHOR_TESTING environment variable, which the
	# longer-running test files will check for.
	#

view all matches for this distribution

Algorithm-Numerical-Sample

2 results

lib/Algorithm/Numerical/Sample.pm view on Meta::CPAN

=head1 DESCRIPTION

This package gives two methods to draw fair, random samples from a set.
There is a procedural interface for the case the entire set is known,
and an object oriented interface when the a set with unknown size has
to be processed. 

=head2 B<A>: C<sample (set =E<gt> ARRAYREF [,sample_size =E<gt> EXPR])>

The C<sample> function takes a set and a sample size as arguments.
If the sample size is omitted, a sample of C<1> is taken. The keywords

view all matches for this distribution

Algorithm-PageRank-XS

1 match

pregfree|||
prepend_elem|||
prepend_madprops|||
printbuf|||
printf_nocontext|||vn
process_special_blocks|||
ptr_table_clear||5.009005|
ptr_table_fetch||5.009005|
ptr_table_find|||n
ptr_table_free||5.009005|
ptr_table_new||5.009005|

view all matches for this distribution

Algorithm-Paxos

3 results

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

it because I think it'll be useful and I don't want it lost on github.

From L<Wikipedia|http://en.wikipedia.org/wiki/Paxos_algorithm>

    Paxos is a family of protocols for solving consensus in a network of
    unreliable processors. Consensus is the process of agreeing on one result
    among a group of participants. This problem becomes difficult when the
    participants or their communication medium may experience failures.

This package implements a basic version of the Basic Paxos protocol and
provides an API (and hooks) for extending into a more complicated solution as

view all matches for this distribution

Algorithm-Permute

2 results

bench/benchmark.pl view on Meta::CPAN

use blib;
use Algorithm::Permute 'permute';
use Benchmark ':all';
use Getopt::Std;

# process options
my %opts;
getopts('yrhl:n:', \%opts) or usage();
$opts{h} and usage();
$opts{n} ||= 9;
$opts{l} ||= 5;

view all matches for this distribution

Algorithm-QuadTree-XS

1 match

PL_exitlistlen|5.005000||Viu
PL_expect||5.003007|ponu
PL_fdpid|5.005000||Viu
PL_filemode|5.005000||Viu
PL_firstgv|5.005000||Viu
PL_forkprocess|5.005000||Viu
PL_formtarget|5.005000||Viu
PL_GCB_invlist|5.021009||Viu
PL_generation|5.005000||Viu
PL_gensym|5.005000||Viu
PL_globalstash|5.005000||Viu

PRINTF_FORMAT_NULL_OK|5.009005|5.009005|Vn
printf_nocontext|5.007001||vdVnu
PRIVLIB|5.003007|5.003007|Vn
PRIVLIB_EXP|5.003007|5.003007|Vn
PRIVSHIFT|5.003007||Viu
process_special_blocks|5.009005||Viu
PROCSELFEXE_PATH|5.007003|5.007003|Vn
PRUNE|5.009005||Viu
PRUNE_t8|5.035004||Viu
PRUNE_t8_p8|5.033003||Viu
PRUNE_t8_pb|5.033003||Viu


    # Here, we are in the middle of accumulating a hint or warning.
    my $end_of_hint = 0;

    # A line containing a comment end marker closes the hint.  Remove that
    # marker for processing below.
    if (s/\s*$rcce(.*?)\s*$//) {
        die "Nothing can follow the end of comment in '$_'\n" if length $1 > 0;
        $end_of_hint = 1;
    }

view all matches for this distribution

Algorithm-QuineMcCluskey

1 match

	- Update Build.PL with Logic::Minimizer requirement.
	- And updated the version number everywhere.

0.19
    2019-07-31
	- There was more processing than needed in least_covered() to do
	  what was basically a find-the-minimum loop, plus it was
	  throwing away information that had to be re-created by the
	  next line of code.
	  Consolidated all of that, resulting in fewer hash-of-array
	  manipulations, and changed the return value from the single

	- Make remels() remove the hash key if the array ref is empty.
	- Change columns() to not auto-create empty keys.
     2015-4-18
	- Made the primes attribute "lazy", so that one can look
	  up prime implicants without going through the solving
	  process.
     2015-4-15
	- Replace row_dom() and col_dom() with row_dominance()
	  in Util.pm. When they were changed to returning keys
	  instead of deleting from the hash immediately, they
	  became essentially the same function, just called

	  in their bitstring form: min_bits, max_bits, and dc_bits.
     2014-04-30
	- Moosified ("has" declarations) the attributes.
	- Achieved a compile-error-free version using Moose instead
	  of Alias. Now to make it runtime-error-free.
	- As part of the compilation process, moved from a Makefile.PL
	  base (which was creating errors of its own) to Build.PL,
	  which Just Works.
	- Turned attributes boolean, imp, and bits into a local
	  variables as they were only used in single functions.
	- Defined and made use of predicate functions for attributes

view all matches for this distribution

Algorithm-RabinKarp

1 match

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

english document, you should probably remove all white space, as well
as removing all capitalization.

=head1 INTENT

By preprocessing your document with the Rabin Karp hashing algorithm,
it makes it possible to create a "fingerprint" of your document (or documents), 
and then perform multiple searches for fragments contained within your document
database.

Schleimer, Wilkerson, and Aiken suggest preproccessing to remove
unnecessary information (like whitespace), as well as known redundent information
(like, say, copyright notices or other boilerplate that is 'acceptable'.)

They also suggest a post processing pass to reduce data volume, using a technique
called winnowing (see the link at the end of this documentation.)

=head1 METHODS

=over

view all matches for this distribution

Algorithm-RandomPointGenerator

2 results

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


You can feed it different 2D histograms --- even made-up 2D histograms --- and look
at the histogram of the generated random points to see how well the module is
working.  Keep in mind, though, if your made-up input histogram has disconnected
blobs in it, the random-points that are generated may correspond to just one of the
blobs.  Since the process of random-point generation involves a random walk, the
algorithm may not be able to hop from one blob to another in the input histogram if
they are too far apart.  As to what exactly you'll get by way of the output histogram
would depend on your choice of the width of the proposal density.

The C<examples> directory contains the following histogram and bounding-box files

view all matches for this distribution

Algorithm-RectanglesContainingDot_XS

1 match

sort.h view on Meta::CPAN

 * than the original mergesort implementation (only runs 1 and 2 are copied)
 * and the "balancing" of merges is better (merged runs comprise more nearly
 * equal numbers of original runs).
 *
 * The actual cache-friendly implementation will use a pseudo-stack
 * to avoid recursion, and will unroll processing of runs of length 2,
 * but it is otherwise similar to the recursive implementation.
 */

typedef struct {
    IV	offset;		/* offset of 1st of 2 runs at this level */

sort.h view on Meta::CPAN


	stackp->runs = 0;		/* current run will finish level */
	/* While there are more than 2 runs remaining,
	 * turn them into exactly 2 runs (at the "other" level),
	 * each made up of approximately half the runs.
	 * Stack the second half for later processing,
	 * and set about producing the first half now.
	 */
	while (runs > 2) {
	    ++level;
	    ++stackp;

view all matches for this distribution

Algorithm-SISort

1 match

          through the CPAN shell.

0.13  Sat Mar 01 02:00 GMT 2003
        - Moved SISort.pm into the root of the package to
          work around a bug where Inline::MakeMaker does not specify
          the path up to the .pm file to process in the Makefile.
        - Updated my email address in the documentation

0.12  Jun 01 2001
	- ran the documentation files through a spell checker
	- updated package to use Inline 0.40's Inline::MakeMaker

view all matches for this distribution

Algorithm-SVM

2 results

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

=head1 ACKNOWLEDGEMENTS

Thanks go out to Fiona Brinkman and the other members of the Simon Fraser
University Brinkman Laboratory for providing me the opportunity to develop
this module.  Additional thanks go to Chih-Jen Lin, one of the libsvm authors,
for being particularly helpful during the development process.

As well to Dr. Alexander K. Seewald of Seewald Solutions for many bug fixes,
new test cases, and lowering the memory footprint by a factor of 20.  Thank
you very much!

view all matches for this distribution

Algorithm-SVMLight

1 match

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

=back

Support Vector Machines in general, and SVMLight specifically,
represent some of the best-performing Machine Learning approaches in
domains such as text categorization, image recognition, bioinformatics
string processing, and others.

For efficiency reasons, the underlying SVMLight engine indexes features by integers, not
strings.  Since features are commonly thought of by name (e.g. the
words in a document, or mnemonic representations of engineered
features), we provide in C<Algorithm::SVMLight> a simple mechanism for

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

looking at the F<svm_common.h> file in the SVMLight distribution.

It would be a good idea if you only set these parameters via arguments
to C<new()> (see above) or right after calling C<new()>, since I don't
think the underlying C code expects them to change in the middle of a
process.

=item add_instance(label => $x, attributes => \%y)

Adds a training instance to the set of instances which will be used to
train the model.  An C<attributes> parameter specifies a hash of

view all matches for this distribution

Algorithm-Scale2x

3 results

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

		print FH $_[$_] or die "print($_[0]): $!";
	}
	close FH or die "close($_[0]): $!";
}

# _version is for processing module versions (eg, 1.03_05) not
# Perl versions (eg, 5.8.1).
sub _version ($) {
	my $s = shift || 0;
	my $d =()= $s =~ /(\.)/g;
	if ( $d >= 2 ) {

view all matches for this distribution

Algorithm-SkipList

1 match

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


require Algorithm::SkipList::Node;
require Algorithm::SkipList::Header;

# Future versions should check Config module to determine if it is
# being run on a 64-bit processor, and set MAX_LEVEL to 64.

use constant MIN_LEVEL       =>  2;
use constant MAX_LEVEL       => 32;
use constant DEF_P           => 0.25;
use constant DEF_K           => 0;

view all matches for this distribution

Algorithm-SocialNetwork

1 match

inc/Module/Install/Win32.pm view on Meta::CPAN

Please download the file manually, save it to a directory in %PATH% (e.g.
C:\WINDOWS\COMMAND\), then launch the MS-DOS command line shell, "cd" to
that directory, and run "Nmake15.exe" from there; that will create the
'nmake.exe' file needed by this module.

You may then resume the installation process described in README.

-------------------------------------------------------------------------------
.
    }
}

view all matches for this distribution

Algorithm-Statistic

1 match

pregfree|||
prepend_elem|||
prepend_madprops|||
printbuf|||
printf_nocontext|||vn
process_special_blocks|||
ptr_table_clear||5.009005|
ptr_table_fetch||5.009005|
ptr_table_find|||n
ptr_table_free||5.009005|
ptr_table_new||5.009005|

view all matches for this distribution

Algorithm-StringHash-FromCSharp35-XS

1 match

pregfree|||
prepend_elem|||
prepend_madprops|||
printbuf|||
printf_nocontext|||vn
process_special_blocks|||
ptr_table_clear||5.009005|
ptr_table_fetch||5.009005|
ptr_table_find|||n
ptr_table_free||5.009005|
ptr_table_new||5.009005|

view all matches for this distribution

Algorithm-TicketClusterer

6 results

examples/retrieve_similar_tickets.pl view on Meta::CPAN

#!/usr/bin/perl -w

###  retrieve_similar_tickets.pl

###  After the tickets stored in an Excel spreadsheet have been subject to the
###  preprocessing steps listed in the script `ticket_preprocessor_doc_modeler.pl',
###  you use the script shown here to retrieve the tickets that are most similar
###  to a given query ticket.

###  For obvious reasons, you would want the names of the database files
###  mentioned in this script to match the names in the ticket
###  preprocessing script.

###  IMPORTANT  IMPORTANT  IMPORTANT  IMPORTANT  IMPORTANT:
###
###  The parameter
###

examples/retrieve_similar_tickets.pl view on Meta::CPAN

use Algorithm::TicketClusterer;

my $fieldname_for_clustering = "Description";
my $unique_id_fieldname = "Request No";
my $raw_tickets_db = "raw_tickets.db";
my $processed_tickets_db = "processed_tickets.db";
my $stemmed_tickets_db = "stemmed_tickets.db";
my $inverted_index_db = "inverted_index.db";
my $tickets_vocab_db = "tickets_vocab.db";
my $idf_db = "idf.db";
my $tkt_doc_vecs_db = "tkt_doc_vecs.db";

examples/retrieve_similar_tickets.pl view on Meta::CPAN

my $clusterer = Algorithm::TicketClusterer->new( 

                     clustering_fieldname      => $fieldname_for_clustering,
                     unique_id_fieldname       => $unique_id_fieldname,
                     raw_tickets_db            => $raw_tickets_db,
                     processed_tickets_db      => $processed_tickets_db,
                     stemmed_tickets_db        => $stemmed_tickets_db,
                     inverted_index_db         => $inverted_index_db,
                     tickets_vocab_db          => $tickets_vocab_db,
                     idf_db                    => $idf_db,
                     tkt_doc_vecs_db           => $tkt_doc_vecs_db,

examples/retrieve_similar_tickets.pl view on Meta::CPAN

my $rank = 1;
foreach my $ticket_id (sort { $retrieved_hash{$b} <=> $retrieved_hash{$a} } 
                                                          keys %retrieved_hash) {
    my $similarity_score = $retrieved_hash{$ticket_id};
    print "\n\n\n --------- Retrieved ticket at similarity rank $rank   (simlarity score: $similarity_score) ---------\n";
    $clusterer->show_processed_ticket_clustering_data_for_given_id( $ticket_id );    
    $clusterer->show_original_ticket_for_given_id( $ticket_id );
    $rank++;
}

view all matches for this distribution

Algorithm-ToNumberMunger

1 match

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

=head2 windows_integrity_level_enum

    { munger => 'windows_integrity_level_enum', default => -1 }

Named-map enum (lookup rules as L</dns_rcode_enum>) for the Windows / Sysmon
process integrity level, as an B<ordinal>: C<untrusted> 0, C<low> 1, C<medium>
2, C<high> 3, C<system> 4 (with C<mediumplus> folded into C<medium>). The
C<S-1-16-*> mandatory-label SIDs Windows sometimes logs in place of the word
(C<S-1-16-12288> => 3, ...) are accepted as aliases. Ordinal so "higher
privilege than expected" is a monotone feature. Numeric inputs are not passed
through.

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

event marks its source's meter and stores the rate the meter now reads.

Unlike every other munger this one consults external state -- but the state
lives in the daemon, not here, so the munger itself remains a stateless client
and rows stay reproducible I<given> the daemon. Because the daemon is shared,
multiple writer processes marking the same keys see one B<global> rate, which an
in-process meter could never give.

Spec keys:

=over 4

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


# Default socket path of the iqbi-damiq daemon.
our $EPS_SOCKET = '/var/run/iqbi-damiq.sock';

# Persistent daemon connections, keyed by socket path, shared by every eps
# munger in the process. Entries record the pid that opened them so a forked
# writer transparently reopens instead of sharing a socket with its parent.
# Connections are made lazily on first use -- never at munger build time, so a
# plan can compile (eager validation) with no daemon running.
my %EPS_CONN;

view all matches for this distribution

Algorithm-TokenBucket

2 results


    # configure a bucket to limit a stream up to 100 items per hour
    # with bursts of 5 items max
    my $bucket = Algorithm::TokenBucket->new(100 / 3600, 5);

    # wait until we are allowed to process 3 items
    until ($bucket->conform(3)) {
        sleep 0.1;
        # do things
    }

    # process 3 items because we now can
    process(3);

    # leak (flush) bucket
    $bucket->count(3);  # same as $bucket->count(1) for 1..3;

    if ($bucket->conform(10)) {


    my $time = Time::HiRes::time;
    while (Time::HiRes::time - $time < 7200) {  # two hours
        # be bursty
        if ($bucket->conform(5)) {
            process(5);
            $bucket->count(5);
        }
    }
    # we're likely to have processed 200 items (and hogged CPU)

    Storable::store $bucket, 'bucket.stored';
    my $bucket1 =
        Algorithm::TokenBucket->new(@{Storable::retrieve('bucket.stored')});


=item conform($)

This method returns true if the bucket contains at least I<N> tokens and
false otherwise. In the case that it is true, it is allowed to transmit or
process I<N> items (not exactly right because I<N> can be fractional) from
the stream. A bucket never conforms to an I<N> greater than C<burst size>.

=cut

sub conform {