view release on metacpan or search on metacpan
pregfree2||5.011000|
pregfree|||
prescan_version||5.011004|
printbuf|||
printf_nocontext|||vn
process_special_blocks|||
ptr_hash|||n
ptr_table_clear||5.009005|
ptr_table_fetch||5.009005|
ptr_table_find|||n
ptr_table_free||5.009005|
view release on metacpan or search on metacpan
lib/Algorithm/Backoff/RetryTimeouts.pm view on Meta::CPAN
#pod
#pod =item * timeout_jitter_factor => I<float> (default: 0.1)
#pod
#pod How much randomness to add to the adjustable timeout.
#pod
#pod Delay jitter may not be enough to desynchronize two processes that are consistently
#pod timing out on the same problem. In those cases, the delay will usually be zero and won't
#pod have any sort of jitter to solve the problem itself. A jitter factor against the timeout
#pod will ensure simultaneous attempts have slightly different timeout windows.
#pod
#pod =back
lib/Algorithm/Backoff/RetryTimeouts.pm view on Meta::CPAN
#pod
#pod my $delay = $retry_algo->delay;
#pod
#pod Returns the last suggested delay, in seconds.
#pod
#pod The delay will return C<-1> to suggest that the process should give up and fail, if
#pod C<max_attempts> or C<max_actual_duration> have been reached.
#pod
#pod =cut
sub delay {
lib/Algorithm/Backoff/RetryTimeouts.pm view on Meta::CPAN
=item * timeout_jitter_factor => I<float> (default: 0.1)
How much randomness to add to the adjustable timeout.
Delay jitter may not be enough to desynchronize two processes that are consistently
timing out on the same problem. In those cases, the delay will usually be zero and won't
have any sort of jitter to solve the problem itself. A jitter factor against the timeout
will ensure simultaneous attempts have slightly different timeout windows.
=back
lib/Algorithm/Backoff/RetryTimeouts.pm view on Meta::CPAN
my $delay = $retry_algo->delay;
Returns the last suggested delay, in seconds.
The delay will return C<-1> to suggest that the process should give up and fail, if
C<max_attempts> or C<max_actual_duration> have been reached.
=head2 timeout
my $timeout = $retry_algo->delay;
view release on metacpan or search on metacpan
t/01-base.t view on Meta::CPAN
# we now waited for 3 seconds, so delay is now 2-2 = 0
is($ar->failure(11), 0);
};
# This tests that consider_actual_delay uses the post-processed _prev_delay
# value correctly.
subtest "attr: consider_actual_delay + post-processing" => sub {
my $ar;
$ar = Algorithm::Backoff::Constant->new(
consider_actual_delay => 1,
delay => 3, # "pre-processor" delay
max_delay => 2, # real delay
max_attempts => 0,
);
# first failure after 1 second
view release on metacpan or search on metacpan
inc/Module/AutoInstall.pm view on Meta::CPAN
.
if (
eval '$>' and lc(`sudo -V`) =~ /version/ and _prompt(
qq(
==> Should we try to re-execute the autoinstall process with 'sudo'?),
((-t STDIN) ? 'y' : 'n')
) =~ /^[Yy]/
)
{
# try to bootstrap ourselves from sudo
print << ".";
*** Trying to re-execute the autoinstall process with 'sudo'...
.
my $missing = join( ',', @Missing );
my $config = join( ',',
UNIVERSAL::isa( $Config, 'HASH' ) ? %{$Config} : @{$Config} )
if $Config;
view release on metacpan or search on metacpan
};
# Preloaded methods go here.
#require Algorithm::BinarySearch::Vec::XS::Whatever;
# Autoload methods go after =cut, and are processed by the autosplit program.
##======================================================================
## Exports
##======================================================================
view release on metacpan or search on metacpan
pregfree|||
prepend_madprops|||
prescan_version||5.011004|
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 release on metacpan or search on metacpan
lib/Algorithm/CP/IZ.pm view on Meta::CPAN
require XSLoader;
XSLoader::load('Algorithm::CP::IZ', $VERSION);
# Preloaded methods go here.
# Autoload methods go after =cut, and are processed by the autosplit program.
my $Instances = 0;
sub _report_error {
my $msg = shift;
lib/Algorithm/CP/IZ.pm view on Meta::CPAN
=item new
Initialize iZ-C library (cs_init is called).
For limitation of iZ-C, living instance of Algorithm::CP::IZ must be
only one per process.
=back
=head1 METHODS
view release on metacpan or search on metacpan
t/test.data view on Meta::CPAN
the DT B
budget NN I
formulation NN I
and CC I
execution NN I
process NN I
which WDT B
, , O
in IN O
turn NN B
, , O
t/test.data view on Meta::CPAN
medical JJ B
therapy NN I
. . O
The DT B
process NN I
dramatically RB O
increased VBD O
our PRP$ B
average JJ I
life NN I
t/test.data view on Meta::CPAN
`` `` O
We PRP B
're VBP O
in IN O
the DT B
process NN I
of IN O
discussing VBG O
an DT B
amended VBN I
plan NN I
view release on metacpan or search on metacpan
lib/Algorithm/CheckDigits/M10_010.pm view on Meta::CPAN
=over 4
=item 1
The sequence of digits is processed left to right. For the first digit
we assume a carry forward of 0.
=item 2
For each digit d(i) the carry forward cf(i) is the digit at the
view release on metacpan or search on metacpan
inc/Module/AutoInstall.pm view on Meta::CPAN
.
if (
eval '$>' and lc(`sudo -V`) =~ /version/ and _prompt(
qq(
==> Should we try to re-execute the autoinstall process with 'sudo'?),
((-t STDIN) ? 'y' : 'n')
) =~ /^[Yy]/
)
{
# try to bootstrap ourselves from sudo
print << ".";
*** Trying to re-execute the autoinstall process with 'sudo'...
.
my $missing = join( ',', @Missing );
my $config = join( ',',
UNIVERSAL::isa( $Config, 'HASH' ) ? %{$Config} : @{$Config} )
if $Config;
view release on metacpan or search on metacpan
perl/Cluster.xs view on Meta::CPAN
if(! SvROK(row_ref) ) {
if(warnings_enabled(aTHX))
Perl_warn(aTHX_
"Row %d: Wanted array reference, but "
"got a scalar. No row to process?\n", i);
break;
}
row_av = (AV *) SvRV(row_ref);
type = SvTYPE(row_av);
perl/Cluster.xs view on Meta::CPAN
if(! SvROK(row_ref) ) {
if(warnings_enabled(aTHX))
Perl_warn(aTHX_
"Row %d: Wanted array reference, but "
"got a scalar. No row to process?\n", i);
break;
}
row_av = (AV *) SvRV(row_ref);
type = SvTYPE(row_av);
view release on metacpan or search on metacpan
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 release on metacpan or search on metacpan
0.01 Wed Oct 22 20:00:00 2014
- original version
0.02 - 0.05
- fix minor isses in build process
- Resolve various build issues. No real
changes involved.
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
}
close FH or die "close($_[0]): $!";
}
END_OLD
# _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 release on metacpan or search on metacpan
lib/Algorithm/CouponCode.pm view on Meta::CPAN
1K7Q-CTFM-LMTC
Coupon Codes are random codes which are easy for the recipient to type
accurately into a web form. An example application might be to print a code on
a letter to a customer who would then enter the code as part of the
registration process for web access to their account.
Features of the codes that make them well suited to manual transcription:
=over 4
lib/Algorithm/CouponCode.pm view on Meta::CPAN
The codes are generated using a SHA1 cryptographic hash of a plaintext. If you
do not supply a plaintext, one will be generated for you (using /dev/urandom if
available or Perl's C<rand()> function otherwise). In the event that an
'inappropriate' code is created, the generated hash will be used as a
plaintext input for generating a new hash and the process will be repeated.
Each 4-character part encodes 15 bits of random data, so a 3-part code will
incorporate 45 bits making a total of 2^45 (approximately 35 trillion) unique
codes.
view release on metacpan or search on metacpan
lib/Algorithm/CurveFit.pm view on Meta::CPAN
=item params
The parameters are the symbols in the formula whose value is varied by the
algorithm to find the best fit of the curve to the data. There may be
one or more parameters, but please keep in mind that the number of parameters
not only increases processing time, but also decreases the quality of the fit.
The value of this options should be an anonymous array. This array should
hold one anonymous array for each parameter. That array should hold (in order)
a parameter name, an initial guess, and optionally an accuracy measure.
lib/Algorithm/CurveFit.pm view on Meta::CPAN
This should be an array reference to an array holding the function values
corresponding to the x-values in 'xdata'.
=item maximum_iterations
Optional parameter to make the process stop after a given number of iterations.
Using the accuracy measure and this option together is encouraged to prevent
the algorithm from going into an endless loop in some cases.
=back
view release on metacpan or search on metacpan
ExamplesBoosting/boosting_for_bulk_classification.pl view on Meta::CPAN
symbolic_to_numeric_cardinality_threshold => 10,
how_many_stages => $how_many_stages,
csv_cleanup_needed => 1,
);
print "Reading and processing training data...\n";
$boosted->get_training_data_for_base_tree();
## UNCOMMENT THE FOLLOWING STATEMENT if you want to see the training data used for
## just the base tree:
$boosted->show_training_data_for_base_tree();
view release on metacpan or search on metacpan
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 release on metacpan or search on metacpan
lib/Algorithm/Dependency/Objects.pm view on Meta::CPAN
making all dependencies of the input objects implicit input objects themselves.
=item B<unknown_object> $object
Called when a new object pops out of the blue in the middle of processing (it
means C<get_deps> is returning inconsistent values).
=item B<get_deps> $object
Extract the dependencies out of an object. Calls C<depends> on the object.
view release on metacpan or search on metacpan
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 release on metacpan or search on metacpan
lib/Algorithm/Dependency.pm view on Meta::CPAN
#pod };
#pod my $deps_source = Algorithm::Dependency::Source::HoA->new( $deps );
#pod
#pod my $dep = Algorithm::Dependency::Ordered->new(
#pod source => $deps_source,
#pod selected => [ 'this', 'that' ], # Items we have processed elsewhere or have already satisfied
#pod )
#pod or die 'Failed to set up dependency algorithm';
#pod
#pod my $also = $dep->schedule_all();
#pod # Returns: ['core', 'a', 'b'] -- ie: installation-order. Whereas using base
lib/Algorithm/Dependency.pm view on Meta::CPAN
#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
#pod =cut
sub depends {
my $self = shift;
lib/Algorithm/Dependency.pm view on Meta::CPAN
#pod
#pod Given a list of one or more item names, the C<depends> method will
#pod return, as a reference to an array, the ordered list of items you
#pod should act upon in whichever order this particular dependency handler
#pod uses - see L<Algorithm::Dependency::Ordered> for one that implements
#pod the most common ordering (process sequence).
#pod
#pod This would be the original names provided, plus those added to satisfy
#pod dependencies, in the preferred order of action. For the normal algorithm,
#pod where order it not important, this is alphabetical order. This makes it
#pod easier for someone watching a program operate on the items to determine
lib/Algorithm/Dependency.pm view on Meta::CPAN
};
my $deps_source = Algorithm::Dependency::Source::HoA->new( $deps );
my $dep = Algorithm::Dependency::Ordered->new(
source => $deps_source,
selected => [ 'this', 'that' ], # Items we have processed elsewhere or have already satisfied
)
or die 'Failed to set up dependency algorithm';
my $also = $dep->schedule_all();
# Returns: ['core', 'a', 'b'] -- ie: installation-order. Whereas using base
lib/Algorithm/Dependency.pm view on Meta::CPAN
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)
=head2 schedule $name1, ..., $nameN
Given a list of one or more item names, the C<depends> method will
return, as a reference to an array, the ordered list of items you
should act upon in whichever order this particular dependency handler
uses - see L<Algorithm::Dependency::Ordered> for one that implements
the most common ordering (process sequence).
This would be the original names provided, plus those added to satisfy
dependencies, in the preferred order of action. For the normal algorithm,
where order it not important, this is alphabetical order. This makes it
easier for someone watching a program operate on the items to determine
view release on metacpan or search on metacpan
lib/Algorithm/Diff/Any.pm view on Meta::CPAN
for arbitrary sequences, it is an NP-hard problem. Simply comparing two
strings together of lengths I<n> and I<m> is B<O(n x m)>. Consequently, this
means the algorithm necessarily has some tight loops, which, for a dynamic
language like Perl, can be slow.
In order to speed up processing, a fast (C/XS-based) implementation of the
algorithm's core loop was implemented. It can confer a noticable performance
advantage (benchmarks show a 54x speedup for the C<compact_diff> routine).
=head1 SYNOPSIS
view release on metacpan or search on metacpan
lib/Algorithm/Diff/Apply.pod view on Meta::CPAN
where this hunk is intended to be applied, and "changes" contains the
changes to apply.
Optimiser callbacks should return a I<permuted copy> of what they were
passed. Empty diffs will be discarded automatically. If only one diff
remains after processing, the conflict will have been optimised away
completely.
=head2 Conflict Resolver Callbacks
Resolver callbacks are invoked when conflicts have been detected, and
view release on metacpan or search on metacpan
lib/Algorithm/Diff/Callback.pm view on Meta::CPAN
version 0.111
=head1 SYNOPSIS
Use callbacks in your diff process to get better control over what will happen.
use Algorithm::Diff::Callback 'diff_arrays';
diff_arrays(
\@old_family_members,
lib/Algorithm/Diff/Callback.pm view on Meta::CPAN
just the values that changes (but neglect to mention how each changed) and some
(such as L<Algorithm::Diff>) give you way too much information that you now have
to skim over and write long complex loops for.
L<Algorithm::Diff::Callback> let's you pick what you're going to diff (Arrays or
Hashes) and set callbacks for the diff process.
=head1 EXPORT
You'll need to declare to explicitly export these functions.
view release on metacpan or search on metacpan
CONTRIBUTING.md view on Meta::CPAN
```
$ dzil test
```
To run the full set of tests (including author and release-process tests),
add the `--author` and `--release` options:
```
$ dzil test --author --release
```
view release on metacpan or search on metacpan
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.
-------------------------------------------------------------------------------
END_MESSAGE
}
}
view release on metacpan or search on metacpan
htmldiff.pl view on Meta::CPAN
use Text::Tabs;
my ( @a, @b );
# Take care of whitespace.
sub preprocess
{
my $arrayRef = shift;
chomp(@$arrayRef);
@$arrayRef = expand(@$arrayRef);
}
htmldiff.pl view on Meta::CPAN
open FH, $ARGV[1];
@b = <FH>;
close FH;
# Expand whitespace
preprocess( \@a );
preprocess( \@b );
# inline style
my $style = <<EOS;
PRE {
margin-left: 24pt;
view release on metacpan or search on metacpan
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.
-------------------------------------------------------------------------------
END_MESSAGE
}
}
view release on metacpan or search on metacpan
lib/Algorithm/DistanceMatrix.pm view on Meta::CPAN
Default is the absolute values of the scalar difference (i.e. C<abs(X-Y)>)
=head2 objects
Array reference. Doesn't matter what kind of objects are in the array, as long
as your C<metric> can process them.
=head2 distancematrix
2D array of distances (or similarities, or whatever) between your objects.
view release on metacpan or search on metacpan
lib/Algorithm/Evolutionary/Op/Base.pm view on Meta::CPAN
}
=head2 fromXML()
Takes a definition in the shape <op></op> and turns it into an object,
if it knows how to do it. The definition must have been processed using XML::Simple.
It parses the common part of the operator, and leaves specific parameters for the
subclass via the "set" method.
=cut