looks results from the CPAN

listkids|||
list|||
load_module_nocontext|||vn
load_module|5.006000||pv
localize|||
looks_like_bool|||
looks_like_number|||
lop|||
mPUSHi|5.009002||p
mPUSHn|5.009002||p
mPUSHp|5.009002||p
mPUSHs|5.010001||p

view all matches for this distribution

Algorithm-BreakOverlappingRectangles

1 match

listkids|||
list|||
load_module_nocontext|||vn
load_module||5.006000|v
localize|||
looks_like_bool|||
looks_like_number|||
lop|||
mPUSHi|5.009002||p
mPUSHn|5.009002||p
mPUSHp|5.009002||p
mPUSHu|5.009002||p

view all matches for this distribution

Algorithm-CP-IZ

4 results

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

		  # array of array of integer
		  return 0 unless (ref $d eq "ARRAY");
		  for my $row (@$d) {
		      return 0 unless (ref $row eq "ARRAY");
		      for my $i (@$row) {
			  return 0 unless (looks_like_number($i));
		      }
		  }
		  return 1;
	      },
	      "I","iA0"

view all matches for this distribution

Algorithm-CRF

2 results

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

  use Algorithm::CRF;
  Algorithm::CRF::crfpp_learn( ... );

=head1 DESCRIPTION

Stub documentation for Algorithm::CRF, created by h2xs. It looks like the
author of the extension was negligent enough to leave the stub
unedited.


=head1 FUNCTIONS

view all matches for this distribution

Algorithm-Classifier-IsolationForest

12 results

lib/Algorithm/Classifier/IsolationForest.pm view on Meta::CPAN

use strict;
use warnings;
use Carp         qw(croak);
use Config       ();
use List::Util   qw(min);
use Scalar::Util qw(looks_like_number);
use POSIX        qw(ceil);
use JSON::PP     ();
use File::Slurp  qw(read_file write_file);

our $VERSION = '0.7.0';

lib/Algorithm/Classifier/IsolationForest.pm view on Meta::CPAN


=item * C<< index_max => bytes >> -- ceiling on the offset table (default
256 MiB).  Above it, the index is abandoned mid-scan and gather streams.

=item * C<< c_scan => 0 >> -- validate each scored cell with
C<looks_like_number> in the threshold pass instead of letting the C packer
coerce it.  C<c_scan> is on by default and takes effect only on the C
mean-voting scoring path, where it is a large saving over millions of rows;
it produces the identical result on valid data, but coerces a non-numeric
scored cell to C<0.0> (nudging the threshold) rather than dying on it.

lib/Algorithm/Classifier/IsolationForest.pm view on Meta::CPAN

	# buffers from a prior fit so the repack reflects the new forest.
	delete @$self{qw(_c_nodes _c_coef_idx _c_coef_val)};
	$self->_rebuild_c_trees() if $self->{_use_c};

	# c_scan (default on): let the C scorer's packer coerce raw cells via SvNV
	# in the contamination pass instead of validating each with looks_like_number
	# in Perl -- a large saving over millions of rows.  It only takes effect on
	# the C mean-voting path; see _stream_scores.
	my $c_scan = exists $opt{c_scan} ? $opt{c_scan} : 1;
	$self->_learn_contamination_threshold_streaming( $path, $skip_first, $n, $c_scan )
		if defined $self->{contamination};

lib/Algorithm/Classifier/IsolationForest.pm view on Meta::CPAN

	return 1 if $forced;

	my @f = split /,/, $first, -1;
	for my $x (@f) {
		next if !length $x;                       # empty cell: fine in data
		return 1 unless looks_like_number($x);    # text: it is a header
	}

	# All-numeric first line: only a header if it reproduces feature_names.
	my $names = $self->{feature_names};
	if ( ref $names eq 'ARRAY' && @$names == @f ) {

lib/Algorithm/Classifier/IsolationForest.pm view on Meta::CPAN

			my @fields = split /,/, $line, -1;
			for my $f (@fields) {
				if ( !length $f ) { $f = undef; next; }
				next unless $parse;
				croak "fit_from_csv(): line $line_no value '$f' is not a number"
					unless looks_like_number($f);
				$f += 0;
			}
			return ( \@fields, $line_no );
		} ## end while ( defined( my $line = <$fh> ) )
		close $fh;

lib/Algorithm/Classifier/IsolationForest.pm view on Meta::CPAN

				. "with missing values"
				if $die;
			next;
		}
		croak "fit_from_csv(): $where value '$f' is not a number"
			unless looks_like_number($f);
		$f += 0;
	} ## end for my $f (@$row)
	return;
} ## end sub _numify_row

lib/Algorithm/Classifier/IsolationForest.pm view on Meta::CPAN


# Stream the CSV, score rows in flat batches (through the same mean/majority
# path score_samples/predict use), and invoke $cb->($score) for each row.
# c_scan fast path: when scoring runs through the C packer (mean voting, use_c,
# trees packed) the packer coerces each cell via SvNV, so the reader can run
# raw (parse => 0) and skip the Perl looks_like_number validation.  Every other
# path parses (parse => 1) so its Perl scorer sees real numbers.
#
# Args:
#   $path :: path to the CSV file, which must be readable.
#   $skip_first :: true to drop the first non-blank line as a header.

view all matches for this distribution

Algorithm-Classifier-NaiveBayes

1 match

lib/Algorithm/Classifier/NaiveBayes.pm view on Meta::CPAN

} ## end sub tweak

=head2 to_string

Returns the model as a JSON string. See the section MODEL FORMAT for
what the JSON looks like.

    my $json = $nb->to_string;

The JSON is generated with canonical set, so the keys are sorted,
meaning two calls against the same model will always produce identical

view all matches for this distribution

Algorithm-Cluster

1 match

perl/Cluster.xs view on Meta::CPAN

extract_double_from_scalar(pTHX_ SV * mysv, double * number) {

    if (SvPOKp(mysv) && SvLEN(mysv)) {  

        /* This function is not in the public perl API */
        if (Perl_looks_like_number(aTHX_ mysv)) {
            *number = SvNV( mysv );
            return 1;
        } else {
            return 0;
        }

view all matches for this distribution

Algorithm-ConsistentHash-CHash

1 match

listkids|||
list|||
load_module_nocontext|||vn
load_module|5.006000||pv
localize|||
looks_like_bool|||
looks_like_number|||
lop|||
mPUSHi|5.009002||p
mPUSHn|5.009002||p
mPUSHp|5.009002||p
mPUSHs|5.011000||p

view all matches for this distribution

Algorithm-ConsistentHash-JumpHash

1 match

listkids|||
list|||
load_module_nocontext|||vn
load_module|5.006000||pv
localize|||
looks_like_bool|||
looks_like_number|||
lop|||
mPUSHi|5.009002||p
mPUSHn|5.009002||p
mPUSHp|5.009002||p
mPUSHs|5.010001||p

view all matches for this distribution

Algorithm-ConsistentHash-Ketama

2 results

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

		if ( my $code = $sym->{$pwd} ) {
			# Delegate back to parent dirs
			goto &$code unless $cwd eq $pwd;
		}
		unless ($$sym =~ s/([^:]+)$//) {
			# XXX: it looks like we can't retrieve the missing function
			# via $$sym (usually $main::AUTOLOAD) in this case.
			# I'm still wondering if we should slurp Makefile.PL to
			# get some context or not ...
			my ($package, $file, $line) = caller;
			die <<"EOT";

view all matches for this distribution

Algorithm-Cron

2 results

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


 wday => "fri-sun"
 wday => "5-7"
 # Both equivalent to: wday => "0,5,6"

As per F<cron(8)> behaviour, this algorithm looks for a match of the C<min>,
C<hour> and C<mon> fields, and at least one of the C<mday> or C<mday> fields.
If both C<mday> and C<wday> are specified, a match of either will be
sufficient.

As an extension, seconds may be provided either by passing six space-separated

view all matches for this distribution

Algorithm-DecisionTree

1 match


      $root_node = $dt->construct_decision_tree_classifier();

  # where $root_node is an instance of the DTNode class that is also defined in the
  # module file.  Now you are ready to classify a new data record.  Let's say that
  # your data record looks like:

      my @test_sample  = qw /  g2=4.2
                               grade=2.3
                               gleason=4
                               eet=1.7

assigned to that node.  The third script shows for each training sample how it
affects the decision-tree nodes either directly or indirectly through the
generalization achieved by the probabilistic modeling of the data.

The output of the script
C<introspection_show_training_samples_at_all_nodes_direct_influence.pl> looks like:

    Node 0: the samples are: None
    Node 1: the samples are: [sample_46 sample_58]
    Node 2: the samples are: [sample_1 sample_4 sample_7 .....]
    Node 3: the samples are: []


The nodes for which no samples are listed come into existence through
the generalization achieved by the probabilistic modeling of the data.

The output produced by the script
C<introspection_show_training_samples_to_nodes_influence_propagation.pl> looks like

    sample_1:                                                                 
       nodes affected directly: [2 5 19 23]                                
       nodes affected through probabilistic generalization:                   
            2=> [3 4 25]


=over 4

=item B<Calling the bagging constructor::>

A typical call to the constructor for the C<DecisionTreeWithBagging> class looks
like:

    use Algorithm::DecisionTreeWithBagging;
    
    my $training_datafile = "stage3cancer.csv";

=over 4

=item B<Calling the BoostedDecisionTree constructor:>

If you'd like to experiment with boosting, a typical call to the constructor for the
C<BoostedDecisionTree> class looks like: 

    use Algorithm::BoostedDecisionTree;
    my $training_datafile = "training6.csv";
    my $boosted = Algorithm::BoostedDecisionTree->new(
                              training_datafile => $training_datafile,

view all matches for this distribution

Algorithm-Diff-XS

1 match

listkids|||
list|||
load_module_nocontext|||vn
load_module||5.006000|v
localize|||
looks_like_number|||
lop|||
mPUSHi|5.009002||p
mPUSHn|5.009002||p
mPUSHp|5.009002||p
mPUSHu|5.009002||p

view all matches for this distribution

Algorithm-Diff

1 match

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

a contiguous section of items which should be added, deleted, replaced,
or left unchanged.

=over 4

The following summary of all of the methods looks a lot like Perl code
but some of the symbols have different meanings:

    [ ]     Encloses optional arguments
    :       Is followed by the default value for an optional argument
    |       Separates alternate return results

view all matches for this distribution

Algorithm-ExpectationMaximization

1 match

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

If instead of random seeding, you wish to use the kmeans
based seeding, just replace the option C<random> supplied
for C<seeding> by C<kmeans>.  You can also do manual seeding
by designating a specified set of data elements to serve as
cluster seeds.  The call to the constructor in this case
looks like

    my $clusterer = Algorithm::ExpectationMaximization->new(
                                datafile            => $datafile,
                                mask                => $mask,
                                K                   => 3,

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


where the option C<seed_tags> is set to an anonymous array
of symbolic names associated with the data elements.

If you know the class priors, you can supply them through an
additional option to the constructor that looks like

    class_priors    => [0.6, 0.2, 0.2],

for the case of C<K> equal to 3.  B<In general, this would
be a useful thing to do only for the case of manual

view all matches for this distribution

Algorithm-FeatureSelection

1 match

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

		if ( my $code = $sym->{$pwd} ) {
			# Delegate back to parent dirs
			goto &$code unless $cwd eq $pwd;
		}
		unless ($$sym =~ s/([^:]+)$//) {
			# XXX: it looks like we can't retrieve the missing function
			# via $$sym (usually $main::AUTOLOAD) in this case.
			# I'm still wondering if we should slurp Makefile.PL to
			# get some context or not ...
			my ($package, $file, $line) = caller;
			die <<"EOT";

view all matches for this distribution

Algorithm-Heapify-XS

3 results

listkids|||
list|||
load_module_nocontext|||vn
load_module|5.006000||pv
localize|||
looks_like_bool|||
looks_like_number|||
lop|||
mPUSHi|5.009002||p
mPUSHn|5.009002||p
mPUSHp|5.009002||p
mPUSHs|5.010001||p

view all matches for this distribution

Algorithm-IncludeExclude

1 match

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


=back

=cut

# self is a tree, that looks like:
# {path1 => [ value1, {path2 => [ value2, ... ]}]}
# path1 has value value1
# path1->path2 has value value2
# path3 is undefined
# etc

view all matches for this distribution

Algorithm-KMeans

1 match

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

you want the module to cluster.

=item C<mask>:

This parameter supplies the mask to be applied to the columns of your data file. See
the explanation in Synopsis for what this mask looks like.

=item C<K>:

This parameter supplies the number of clusters you are looking for.  If you set this
option to 0, that means that you want the module to search for the best value for

view all matches for this distribution

Algorithm-KNN-XS

1 match

listkids|||
list|||
load_module_nocontext|||vn
load_module|5.006000||pv
localize|||
looks_like_bool|||
looks_like_number|||
lop|||
mPUSHi|5.009002||p
mPUSHn|5.009002||p
mPUSHp|5.009002||p
mPUSHs|5.011000||p

view all matches for this distribution

Algorithm-KernelKMeans

1 match

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

		if ( my $code = $sym->{$pwd} ) {
			# Delegate back to parent dirs
			goto &$code unless $cwd eq $pwd;
		}
		unless ($$sym =~ s/([^:]+)$//) {
			# XXX: it looks like we can't retrieve the missing function
			# via $$sym (usually $main::AUTOLOAD) in this case.
			# I'm still wondering if we should slurp Makefile.PL to
			# get some context or not ...
			my ($package, $file, $line) = caller;
			die <<"EOT";

view all matches for this distribution

Algorithm-Knapsack

1 match

bin/filesack view on Meta::CPAN

B<filesack> { size | B<-c> | B<-d> } F<file> ...

=head1 DESCRIPTION

The B<filesack> program finds one or more subsets of files or directories
with the maximum total size not exceeding a given size. Its output looks
as follows:

    size
        file
        file

view all matches for this distribution

Algorithm-LBFGS

1 match

listkids|||
list|||
load_module_nocontext|||vn
load_module||5.006000|v
localize|||
looks_like_number|||
lop|||
mPUSHi|5.009002||p
mPUSHn|5.009002||p
mPUSHp|5.009002||p
mPUSHu|5.009002||p

view all matches for this distribution

Algorithm-Line-Lerp

1 match

$opt{'compat-version'} = 5.003_07 unless exists $opt{'compat-version'};
$opt{'compat-version'} = int_parse_version($opt{'compat-version'});

my $int_min_perl = int_parse_version(5.003_07);

# Each element of this hash looks something like:
# 'Poison' => {
#                         'base' => '5.008000',
#                         'provided' => 1,
#                         'todo' => '5.003007'
#             },

LOOKBEHIND_END_t8|||Viu
LOOKBEHIND_END_tb_p8|||Viu
LOOKBEHIND_END_tb_pb|||Viu
LOOKBEHIND_END_tb|||Viu
LOOKBEHIND_END|||Viu
looks_like_bool|5.027008||Viu
looks_like_number|5.003007|5.003007|
LOOP_PAT_MODS|5.009005||Viu
lop|5.005000||Viu
lossless_NV_to_IV|5.031001||Vniu
LOWEST_ANYOF_HRx_BYTE|5.031002||Viu
L_R_TZSET|5.009005|5.009005|Vn

 * otherwise call the original that doesn't have an upper limit parameter */
#  define D_PPP_GENERIC_MULTI_ARG_TO(name, s, e,r,l)                        \
    (((((e) - (s)) <= 0)                                                    \
         /* We could just do nothing, but modern perls croak */             \
      ? (croak("Attempting case change on zero length string"),             \
         0) /* So looks like it returns something, and will compile */      \
      : ((e) - (s)) < UTF8SKIP(s))                                          \
        ? (croak(D_PPP_TOO_SHORT_MSG,                                       \
                               s[0], (int) ((e) - (s)), (int) UTF8SKIP(s)), \
           0)                                                               \
        : D_PPP_TO_ ## name ## _CALLEE(s,r,l))

#endif

#  define D_PPP_GENERIC_SINGLE_ARG_TO_UTF8(name, s, e, r, l)                \
    (((((e) - (s)) <= 0)                                                    \
      ? (croak("Attempting case change on zero length string"),             \
         0) /* So looks like it returns something, and will compile */      \
      : ((e) - (s)) < UTF8SKIP(s))                                          \
        ? (croak(D_PPP_TOO_SHORT_MSG,                                       \
                               s[0], (int) ((e) - (s)), (int) UTF8SKIP(s)), \
           0)                                                               \
          /* Get the changed code point and store its UTF-8 */              \

view all matches for this distribution

Algorithm-MedianSelect-XS

1 match

listkids|||
list|||
load_module_nocontext|||vn
load_module|5.006000||pv
localize|||
looks_like_bool|||
looks_like_number|||
lop|||
mPUSHi|5.009002||p
mPUSHn|5.009002||p
mPUSHp|5.009002||p
mPUSHu|5.009002||p

view all matches for this distribution

Algorithm-MinPerfHashTwoLevel

1 match

listkids|||
list|||
load_module_nocontext|||vn
load_module|5.006000||pv
localize|||
looks_like_bool|||
looks_like_number|||
lop|||
mPUSHi|5.009002||p
mPUSHn|5.009002||p
mPUSHp|5.009002||p
mPUSHs|5.010001||p

view all matches for this distribution

Algorithm-Networksort

1 match

Changes view on Meta::CPAN

	  for 5.6.0 in various perl development tools is being dropped,
	  and 5.8.3 seems to be a safe minimum, at least for the current
	  year. Change made in Build.PL and Networksort.pm.
	- Changed "repository" key in Build.PL from a hash to a string,
	  as seems to be currently required under the version of
	  Module::Build that I'm developing with (the hash form looks
	  to be for a later version that I cannot install yet).
	Tue Jan 11 2011
	- Found an error in the SYNOPSIS portion of the POD. Function
	  nw_format() had an incorrect argument.
	Thu Sep 23 2010

Changes view on Meta::CPAN

	- Added the Meta.yml and Build.PL files.
	- Changed test files to use Test::Simple.
	Fri Jun 2 2006
	- Added pod.t.
	- Typo fix in pod (itme instead of item).  Fixed stale links.
	- It looks like the Forbes D. Lewis article, "Sorting Networks"
	  has vanished altogether.  Removed it from the See Also section.
	Wed Jul 26 2006
	- Split the batcher.t, best.t, bn.t, and hibbard.t files into
	  two.  I'm trying to  cut down the time-to-finish length, which
	  some test environments don't handle well ("Is this test done

view all matches for this distribution

Algorithm-PageRank-XS

1 match

listkids|||
list|||
load_module_nocontext|||vn
load_module|5.006000||pv
localize|||
looks_like_bool|||
looks_like_number|||
lop|||
mPUSHi|5.009002||p
mPUSHn|5.009002||p
mPUSHp|5.009002||p
mPUSHs|5.011000||p

view all matches for this distribution

Algorithm-Permute

1 match

listkids|||
list|||
load_module_nocontext|||vn
load_module|5.006000||pv
localize|||
looks_like_bool|||
looks_like_number|||
lop|||
mPUSHi|5.009002||p
mPUSHn|5.009002||p
mPUSHp|5.009002||p
mPUSHs|5.010001||p

view all matches for this distribution

Algorithm-QuadTree-XS

1 match

$opt{'compat-version'} = 5.003_07 unless exists $opt{'compat-version'};
$opt{'compat-version'} = int_parse_version($opt{'compat-version'});

my $int_min_perl = int_parse_version(5.003_07);

# Each element of this hash looks something like:
# 'Poison' => {
#                         'base' => '5.008000',
#                         'provided' => 1,
#                         'todo' => '5.003007'
#             },

LOOKBEHIND_END_t8|||Viu
LOOKBEHIND_END_tb_p8|||Viu
LOOKBEHIND_END_tb_pb|||Viu
LOOKBEHIND_END_tb|||Viu
LOOKBEHIND_END|||Viu
looks_like_bool|5.027008||Viu
looks_like_number|5.003007|5.003007|
LOOP_PAT_MODS|5.009005||Viu
lop|5.005000||Viu
lossless_NV_to_IV|5.031001||Vniu
LOWEST_ANYOF_HRx_BYTE|5.031002||Viu
L_R_TZSET|5.009005|5.009005|Vn

 * otherwise call the original that doesn't have an upper limit parameter */
#  define D_PPP_GENERIC_MULTI_ARG_TO(name, s, e,r,l)                        \
    (((((e) - (s)) <= 0)                                                    \
         /* We could just do nothing, but modern perls croak */             \
      ? (croak("Attempting case change on zero length string"),             \
         0) /* So looks like it returns something, and will compile */      \
      : ((e) - (s)) < UTF8SKIP(s))                                          \
        ? (croak(D_PPP_TOO_SHORT_MSG,                                       \
                               s[0], (int) ((e) - (s)), (int) UTF8SKIP(s)), \
           0)                                                               \
        : D_PPP_TO_ ## name ## _CALLEE(s,r,l))