Algorithm::Bucketizer distributes items of a defined size into a number of
dynamically created buckets, each of them capable of holding items of a defined
total size.
Acme::Comment allows multi-line comments which are filtered out.
Unlike the pseudo multi-line comment if (0) {}, the code being
commented out need not be syntactically valid.
This module implements the C3 algorithm. I have broken this out
into it's own module because I found myself copying and pasting
it way too often for various needs. Most of the uses I have for
C3 revolve around class building and metamodels, but it could
also be used for things like dependency resolution as well since
it tends to do such a nice job of preserving local precedence
orderings.
This module is an interface to the C Clustering Library, a general
purpose library implementing functions for hierarchical clustering
(pairwise simple, complete, average, and centroid linkage),
along with k-means and k-medians clustering, and 2D self-organizing maps.
The library is distributed along with Cluster 3.0, an enhanced version
of the famous Cluster program originally written by Michael Eisen
while at Stanford University. The C clustering library was written
by Michiel de Hoon.
This module is a Perl wrapper for the C clustering library for
cDNA microarray data, Copyright (C) 2002 Michiel Jan Laurens de Hoon.
Algorithm::Cron - abstract implementation of the cron(8) scheduling algorithm
Objects in this class implement a time scheduling algorithm such as used by
cron(8). Objects are stateless once constructed, and represent a single schedule
as defined by a crontab(5) entry. The object implements a method next_time
which returns an epoch timestamp value to indicate the next time included
in the crontab schedule.
This modules is a re-implementation of Algorithm::Dependency using only
objects instead of object ids, making use of Set::Object for book-keeping.
Algorithm::Dependency is a framework for creating simple read-only
dependency hierarchies, where you have a set of items that rely on other
items in the set, and require actions on them as well.
Despite the most visible of these being software installation systems like
the CPAN installer, or debian apt-get, they are useful in other
situations. This module intentionally uses implementation-neutral words,
to avoid confusion.
Algorithm::BinPack efficiently packs items into bins. The bins are given
a maximum size, and items are packed in with as little empty space as
possible. An example use would be backing up files to CD, while
minimizing the number of discs required.
Apache Pig is a platform for analyzing large data sets that consists of a
high-level language for expressing data analysis programs, coupled with
infrastructure for evaluating these programs. The salient property of Pig
programs is that their structure is amenable to substantial parallelization,
which in turns enables them to handle very large data sets.
At the present time, Pig's infrastructure layer consists of a compiler that
produces sequences of Map-Reduce programs, for which large-scale parallel
implementations already exist (e.g., the Hadoop subproject). Pig's language
layer currently consists of a textual language called Pig Latin, which has
the following key properties:
-- Ease of programming. It is trivial to achieve parallel execution of simple,
"embarrassingly parallel" data analysis tasks. Complex tasks comprised of
multiple interrelated data transformations are explicitly encoded as data flow
sequences, making them easy to write, understand, and maintain.
-- Optimization opportunities. The way in which tasks are encoded permits the
system to optimize their execution automatically, allowing the user to focus
on semantics rather than efficiency.
-- Extensibility. Users can create their own functions to do special-purpose
processing.
It's a library for doing evolutionary computation in Perl.
Algorithm::Evolutionary was formerly called OPEAL, which is an acronym for
Obvious Pearl Evolutionary Algorithm Library.
The design principles of Algorithm::Evolutionary are:
* It should be easy to program any kind of evolutionary algorithm; all
chromosome representations and operators are possible.
* An XML dialect called EvoSpec is used as a language for description of
algorithms and for representation of the state of an algorithm. This
could make Algorithm::Evolutionary interoperable with other EA libraries,
such as EO or JEO.