Result:
found more than 872 distributions - search limited to the first 2001 files matching your query
( run in 3.906 )
Filter-gunzip
view release on metacpan or search on metacpan
t/MyTestHelpers.pm view on Meta::CPAN
#
# use Exporter;
# use vars qw(@ISA @EXPORT_OK %EXPORT_TAGS);
# @ISA = ('Exporter');
# @EXPORT_OK = qw(findrefs
# main_iterations
# warn_suppress_gtk_icon
# glib_gtk_versions
# any_signal_connections
# nowarnings);
# %EXPORT_TAGS = (all => \@EXPORT_OK);
t/MyTestHelpers.pm view on Meta::CPAN
#-----------------------------------------------------------------------------
# Gtk/Glib helpers
# Gtk 2.16 can go into a hard loop on events_pending() / main_iteration_do()
# if dbus is not running, or something like that. In any case limiting the
# iterations is good for test safety.
#
sub main_iterations {
my $count = 0;
if (DEBUG) { MyTestHelpers::diag ("main_iterations() ..."); }
while (Gtk2->events_pending) {
$count++;
Gtk2->main_iteration_do (0);
if ($count >= 500) {
MyTestHelpers::diag ("main_iterations(): oops, bailed out after $count events/iterations");
return;
}
}
MyTestHelpers::diag ("main_iterations(): ran $count events/iterations");
}
# warn_suppress_gtk_icon() is a $SIG{__WARN__} handler which suppresses spam
# from Gtk trying to make you buy the hi-colour icon theme. Eg,
#
t/MyTestHelpers.pm view on Meta::CPAN
while (! $done) {
if (DEBUG >= 2) { MyTestHelpers::diag ("wait_for_event() iteration $count"); }
Gtk2->main_iteration;
$count++;
}
MyTestHelpers::diag ("wait_for_event(): '$signame' ran $count events/iterations\n");
$widget->signal_handler_disconnect ($sig_id);
Glib::Source->remove ($timer_id);
}
Finance-Bank-IE
view release on metacpan or search on metacpan
t/lib/Test/MockBank.pm view on Meta::CPAN
}
$GLOBALSTATE{$key};
}
sub fail_on_iterations {
my $self = shift;
my $iterations = [ @_ ];
$self->globalstate( 'fail', [ $iterations, 0 ] );
}
sub on_page {
my $self = shift;
my $uri = shift;
t/lib/Test/MockBank.pm view on Meta::CPAN
$iteration++;
Test::MockBank->globalstate( 'fail', [ $failures, $iteration ]);
if ( grep {m/^$iteration$/} @{$failures} ) {
diag( "failing per request on iteration $iteration when " . $request->method . "ing " . $request->uri) if $ENV{DEBUG};
my @iterations = grep {!m/^$iteration$/} @{$failures};
if ( !@iterations ) {
Test::MockBank->globalstate( 'fail', 0 );
} else {
Test::MockBank->globalstate( 'fail', [ \@iterations, $iteration ] );
}
$response->code( RC_INTERNAL_SERVER_ERROR );
$response->content( 'FAIL' );
diag( "returning " . $response->code) if $ENV{DEBUG};
return $response;
Finance-CompanyNames
view release on metacpan or search on metacpan
CompanyNames/TextSupport.pm view on Meta::CPAN
issuance issuances
istambay istambays
istotype istotypes
ita italian italianate italiani italy
itaconate itaconates itaconic
ital italic italicize italicized italicizes italicizing italics iter iterate iterated iterates iterating iteration iterations iterative iteratively iteratives iterator iterators
italicise italicised
itc itcs
itch itches itchiness itching itchy
ite ites
item itemization itemizations itemize itemized itemizers itemizes itemizing items
CompanyNames/TextSupport.pm view on Meta::CPAN
subimage subimages
subinsurance subinsurers
subinterval subintervals
subinverter subinverters
subirrigated subirrigating subirrigation
subiteration subiterations
subject subjected subjecting subjection subjective subjectively subjectivity subjects
subjugate subjugated subjugating subjugation
sublan sublans
subland sublands
sublanguage sublanguages
CompanyNames/TextSupport.pm view on Meta::CPAN
allied
allies
alligator
alligators
alliteration
alliterations
alliterative
allocatable
allocate
allocated
allocates
CompanyNames/TextSupport.pm view on Meta::CPAN
iterate
iterated
iterates
iterating
iteration
iterations
iterative
iteratively
iterator
iterators
itineraries
Finance-MICR-GOCR-Check
view release on metacpan or search on metacpan
lib/Finance/MICR/GOCR/Check.pm view on Meta::CPAN
}
$self->{crop_sides} ||= 0.15;
return $self->{crop_sides};
}
sub crop_iterations {
my($self,$set) = @_;
if (defined $set){
$self->{crop_iterations} = $set;
$self->{custom_iteration_is_set} =1;
}
$self->{crop_iterations} ||= 12;
return $self->{crop_iterations};
}
sub crop_increment {
my($self,$set) = @_;
if (defined $set){
lib/Finance/MICR/GOCR/Check.pm view on Meta::CPAN
}
$self->{crop_increment} ||= 5;
return $self->{crop_increment};
}
sub scan_iterations_reset {
my $self = shift;
$self->{crop_iterations} = undef;
$self->{custom_iteration_is_set} = undef;
$self->{crop_increment} = undef;
return;
}
# build the increment values and elements
# these are the iterations steps we will try
# stops when we find one that produces valid micr
sub scan_iterations {
my $self = shift;
my @iterations;
if( $self->_custom_iteration_is_set ){
my $i =0;
my $now = 70;
while ( $i != $self->crop_iterations ){
push @iterations, $now;
$now =($now + $self->crop_increment);
$i++;
}
print STDERR "custom iteration is set, steps are [@iterations]\n" if DEBUG;
printf STDERR "step increment is : %s, number of steps: %s\n", $self->crop_increment, $self->crop_iterations if DEBUG;
}
else {
@iterations = qw(70 75 80 85 90 95 100 105 110 115 120 130 140 150 160 170 180 190 200 210 220 230 240 250 300); # aggressive
print STDERR "iterations are default, set to [@iterations]\n" if DEBUG;
}
return \@iterations;
}
sub rescan {
my $self = shift;
$self->{_data}->{_micrdata} = undef;
lib/Finance/MICR/GOCR/Check.pm view on Meta::CPAN
Percentage to crop sides by when iterating, scanning up for MICR line
default is fifteen percent
number should be 0.15 for 15%
=head2 crop_iterations()
argument is number of iterations to do before giving up on searching for micrline scans.. starts from bottom.. does 5 pix increments.
if no argumetn, returns number of iterations set.
If you give 0, it switches to default, which is 12- max is 25
=head2 crop_increment()
argument is pixel increment per iteration
lib/Finance/MICR/GOCR/Check.pm view on Meta::CPAN
If you give 0, it switches to default, which is 5
suggested is min 2, max 8
You must set these values BEFORE you ask for the micr from ocr
=head2 scan_iterations()
returns array ref of what the iterations are set at
dafault are approximately:
70 75 80 85 90 95 100 105 110 115 120 130 140 150 160 170 180 190 200 210 220 230 240 250 300
That means the first image extract is the micr height from 70 pixels from the bottom, then 75, etc.. Until a valid
micr line is found.
=head2 scan_iterations_reset()
will reset crop_sides, crop_increment, crop_iterations to default values.
=head2 found_valid()
will trigger a scan if none was already ran.
lib/Finance/MICR/GOCR/Check.pm view on Meta::CPAN
unless( $c->found_valid ){
$c->s(70); # change the spacing for gocr
$c->d(15); # change the dust size from default of 20 to 15
$c->crop_increment(2); # set more precise iterations, default is 5 or so
$c->crop_iterations(10); # set less iterations to happen
$c->rescan;
if ($c->found_valid){
printf STDERR "worked! found: %s\n", $c->parser->micr_pretty;
lib/Finance/MICR/GOCR/Check.pm view on Meta::CPAN
unless( defined $self->{_data}->{_micrdata} ){
if (DEBUG){
printf STDERR __PACKAGE__ ." _micr defining\n
custom iteration %s
crop iterations %s
crop increment %s
",
$self->_custom_iteration_is_set,
$self->crop_iterations,
$self->crop_increment;
}
my $data = {
lib/Finance/MICR/GOCR/Check.pm view on Meta::CPAN
# it should NOT STOP at first valid.. it should run one more!!! when it gets chopped up it still tries matching!
my $id = time ;# for development purpose.. disregard, names the micrfiles
my $last_one_was_valid =0;
my $stop = 0;
my $iterations = $self->scan_iterations;
for (@$iterations){
if ($last_one_was_valid){ # then do one more just 2px or 4px up
$data->{height} = ($data->{height} + 5);
$stop =1; #force stop
}
lib/Finance/MICR/GOCR/Check.pm view on Meta::CPAN
# if it's not valid try something nuts??
# $last_one_was_valid =0;
# $stop = 0;
my $data2=$data; # copies or .. what?
unless ($data2->{parser}->micr_pretty){
print STDERR "iterations will not match, trying something different\n" if DEBUG;
for (qw(90 95 100 105 110 115)){
# if ($last_one_was_valid){ # then do one more just 2px or 4px up
# $data2->{height} = ($data2->{height} + 5);
lib/Finance/MICR/GOCR/Check.pm view on Meta::CPAN
return $self->_micr->{raw};
}
=head2 abs_micr()
absolute path to micr file what was created.
after the iterations, the one that closest matched is this file.
This is useful to know if you want to build or increment the gocr database.
=head2 gocr_raw()
the raw ocr output for the micrfile that was last made,
Finance-Math-IRR
view release on metacpan or search on metacpan
lib/Finance/Math/IRR.pm view on Meta::CPAN
#
$ARGS_SECANT{precision} = $precision;
_debug("trying secant method on interval [".$ARGS_SECANT{p0}."-".$ARGS_SECANT{p1}."] with precision ".
$ARGS_SECANT{precision}." and max ".$ARGS_SECANT{max_depth}." iterations");
# try finding the IRR with the secant metho
eval {
$root = $poly->secant(%ARGS_SECANT);
};
lib/Finance/Math/IRR.pm view on Meta::CPAN
$ARGS_BRENT{precision} = $precision;
$ARGS_BRENT{a} = $poly->xneg;
$ARGS_BRENT{b} = $poly->xpos;
_debug("trying Brent's method on interval [".$ARGS_BRENT{a}."-".$ARGS_BRENT{b}."] with precision ".
$ARGS_BRENT{precision}." and max ".$ARGS_BRENT{max_depth}." iterations");
eval {
$root = $poly->brent(%ARGS_BRENT);
};
Finance-Performance-Calc
view release on metacpan or search on metacpan
}
print "Using Math::FixedPrecision objects (ROR_objects), the ROR is ", ROR_objects(),"\n";
print "Go get a cup of coffee while we time 10000 iterations each of ROR_native and ROR_objects\n";
print "Start: @{[scalar(localtime())]}\n";
cmpthese($count,
{
ROR_native => \&ROR_native,
Finance-Quote-Grab
view release on metacpan or search on metacpan
t/MyTestHelpers.pm view on Meta::CPAN
#
# use Exporter;
# use vars qw(@ISA @EXPORT_OK %EXPORT_TAGS);
# @ISA = ('Exporter');
# @EXPORT_OK = qw(findrefs
# main_iterations
# warn_suppress_gtk_icon
# glib_gtk_versions
# any_signal_connections
# nowarnings);
# %EXPORT_TAGS = (all => \@EXPORT_OK);
t/MyTestHelpers.pm view on Meta::CPAN
#-----------------------------------------------------------------------------
# Gtk/Glib helpers
# Gtk 2.16 can go into a hard loop on events_pending() / main_iteration_do()
# if dbus is not running, or something like that. In any case limiting the
# iterations is good for test safety.
#
sub main_iterations {
my $count = 0;
if (DEBUG) { MyTestHelpers::diag ("main_iterations() ..."); }
while (Gtk2->events_pending) {
$count++;
Gtk2->main_iteration_do (0);
if ($count >= 500) {
MyTestHelpers::diag ("main_iterations(): oops, bailed out after $count events/iterations");
return;
}
}
MyTestHelpers::diag ("main_iterations(): ran $count events/iterations");
}
# warn_suppress_gtk_icon() is a $SIG{__WARN__} handler which suppresses spam
# from Gtk trying to make you buy the hi-colour icon theme. Eg,
#
t/MyTestHelpers.pm view on Meta::CPAN
while (! $done) {
if (DEBUG >= 2) { MyTestHelpers::diag ("wait_for_event() iteration $count"); }
Gtk2->main_iteration;
$count++;
}
MyTestHelpers::diag ("wait_for_event(): '$signame' ran $count events/iterations\n");
$widget->signal_handler_disconnect ($sig_id);
Glib::Source->remove ($timer_id);
}
Forks-Super
view release on metacpan or search on metacpan
examples/Benchmark.pm view on Meta::CPAN
$t = timeit(10, ' 5 ** $Global ');
Benchmark->debug(0);
=item iters
Returns the number of iterations.
=back
=head2 Standard Exports
examples/Benchmark.pm view on Meta::CPAN
Returns: a Benchmark object.
=item timethis ( COUNT, CODE, [ TITLE, [ STYLE ]] )
Time COUNT iterations of CODE. CODE may be a string to eval or a
code reference; either way the CODE will run in the caller's package.
Results will be printed to STDOUT as TITLE followed by the times.
TITLE defaults to "timethis COUNT" if none is provided. STYLE
determines the format of the output, as described for timestr() below.
examples/Benchmark.pm view on Meta::CPAN
the C<timethese()> result structure. If you want that, just use the two
statement C<timethese>...C<cmpthese> idiom shown above.
Incidentally, note the variance in the result values between the two examples;
this is typical of benchmarking. If this were a real benchmark, you would
probably want to run a lot more iterations.
=item countit(TIME, CODE)
Arguments: TIME is the minimum length of time to run CODE for, and CODE is
the code to run. CODE may be either a code reference or a string to
be eval'd; either way it will be run in the caller's package.
TIME is I<not> negative. countit() will run the loop many times to
calculate the speed of CODE before running it for TIME. The actual
time run for will usually be greater than TIME due to system clock
resolution, so it's best to look at the number of iterations divided
by the times that you are concerned with, not just the iterations.
Returns: a Benchmark object.
=item disablecache ( )
examples/Benchmark.pm view on Meta::CPAN
Real elapsed time "wallclock seconds".
=item iters
Number of iterations run.
=back
The following illustrates use of the Benchmark object:
examples/Benchmark.pm view on Meta::CPAN
my $cache_key = $n . ( ref( $code ) ? 'c' : 's' );
if ($Do_Cache && exists $Cache{$cache_key} ) {
$wn = $Cache{$cache_key};
} else {
$wn = &runloop($n, ref( $code ) ? sub { } : '' );
# Can't let our baseline have any iterations, or they get subtracted
# out of the result.
$wn->[5] = 0;
$Cache{$cache_key} = $wn;
}
examples/Benchmark.pm view on Meta::CPAN
# due to clock granularity and variable CPU speed and load,
# on quick code with a small number of loops, it's possible for
# the empty loop to appear to take longer than the real loop
# (e.g. 1 tick versus 0 ticks). This leads to a negative elapsed
# time. In this case, floor it at zero, to stop bizarre results.
print " (warning: too few iterations for a reliable count)\n";
$t->[$_] = 0 for 1..4;
}
# A conservative warning to spot very silly tests.
# Don't assume that your benchmark is ok simply because
# you don't get this warning!
print " (warning: too few iterations for a reliable count)\n"
if $n < $Min_Count
|| ($t->real < 1 && $n < 1000)
|| $t->cpu_a < $Min_CPU;
$t;
}
examples/Benchmark.pm view on Meta::CPAN
my @names = sort keys %$alt;
$style = "" unless defined $style;
print "Benchmark: " unless $style eq 'none';
if ( $n > 0 ) {
croak "non-integer loopcount $n, stopped" if int($n)<$n;
print "timing $n iterations of" unless $style eq 'none';
} else {
print "running" unless $style eq 'none';
}
print " ", join(', ',@names) unless $style eq 'none';
unless ( $n > 0 ) {
Form-Diva
view release on metacpan or search on metacpan
t/203_prefill.t view on Meta::CPAN
checktest => 'Irish',
name => 'Coffee',
};
# need to create series of tests, several iterations of prefill and then do a plain generate to
# confirm original default/placholder still exist.
my @results1 = (
{ row => 0 , input => q|value="spaghetti"|,
comment => 'prefilled name with value spaghetti is set'},
{ row => 0 , input => q|placeholder="Your Name"|,
Form-Tiny
view release on metacpan or search on metacpan
lib/Form/Tiny/Form.pm view on Meta::CPAN
foreach my $validator (@{$self->field_defs}) {
my $current_data = Form::Tiny::Utils::_find_field($fields, $validator);
if (defined $current_data) {
my $all_ok = 1;
# This may have multiple iterations only if there's an array
foreach my $path_value (@$current_data) {
next if $path_value->[2];
$path_value->[1] = ($inline_hook->($self, $validator, $path_value->[1]))
if $inline_hook;
Fred-Fish-DBUG
view release on metacpan or search on metacpan
lib/Fred/Fish/DBUG/Tutorial.pm view on Meta::CPAN
The interesting part of the B<fish> log:
| <main::some_function - return ([1], [0], [-1])
Notice it was smart enough to return a list of values. And the loop had three
iterations.
********************
while ( some_function ( qw /1 0 -1/ ) ) { ... }
FreeWRL
view release on metacpan or search on metacpan
JS/js/jsdate.c view on Meta::CPAN
/* Use a simple binary search algorithm to find the right
year. This seems like brute force... but the computation
of hi and lo years above lands within one year of the
correct answer for years within a thousand years of
1970; the loop below only requires six iterations
for year 270000. */
while (hi > lo) {
mid = (hi + lo) / 2;
if (TimeFromYear(mid) > t) {
hi = mid - 1;
Frost
view release on metacpan or search on metacpan
t/000_moose_recipes/basics-recipe10.t view on Meta::CPAN
);
}
# Hmm, not sure how to test for random selection of genes since
# I could theoretically run an infinite number of iterations and
# never find proof that a child has inherited a particular gene.
# AUTHOR: Aran Clary Deltac <bluefeet@cpan.org>
# Maybe there is another way to implent this, but for no we have
Fry-Shell
view release on metacpan or search on metacpan
lib/Fry/Opt.pm view on Meta::CPAN
A flag type syncs it value with a shell flag. A var type syncs its value with a
variable. A none type gets its value from the attribute value.
action(\&): Given subroutine is called before a command for an active option.
Subroutine is passed the shell object and the options' value set from the
commandline.
stop($): Maintains an option's value for $stop + 1 loop iterations where $stop
is this attribute's value. This gives an active option a timed noreset interval. Used mostly with menu option.
noreset($): If set, the active option can't be reset (except for an overriding flag to &resetOptions).
*default($): Default value that an option starts with and is set to whenever reset. Default value is 0.
=head1 PUBLIC METHODS
Func-Util
view release on metacpan or search on metacpan
t/040-leak-util-leak.t view on Meta::CPAN
}
# Test for memory leaks
# Run code many times and check memory doesn't grow significantly
sub test_no_leak {
my ($name, $code, $iterations, $threshold_kb) = @_;
$iterations //= 10_000; # Reduced from 100k to avoid SEGV in util
$threshold_kb //= 5_000; # 5MB threshold
# Warmup
$code->() for 1..100;
my $before = get_rss();
$code->() for 1..$iterations;
my $after = get_rss();
my $diff = $after - $before;
my $passed = $diff < $threshold_kb;
FunctionalPerl
view release on metacpan or search on metacpan
lib/Chj/time_this.pm view on Meta::CPAN
my $res = time_this { somefunc(66) } out => \@t; # push to @t instead of stderr
=head1 DESCRIPTION
Currently does not divide the timings by the number of iterations.
Currently does not subtract the overhead of calling the thunk (as
Benchmark.pm does, but can't use it since it doesn't return values;
should we wrap and use assignment instead? But then timings are off
again.)
Future-Selector
view release on metacpan or search on metacpan
);
my $run_f = $selector->run_until_ready( $f );
ok( $run_f->is_ready, '->run_until_ready completed' );
is( $count, 6, 'Loop stopped after 6 iterations' );
is( [ $run_f->get ], [ "Ready" ], 'run future yields completion result' );
}
done_testing;
GBrowse
view release on metacpan or search on metacpan
htdocs/js/unittest.js view on Meta::CPAN
}.bind(this)) && this.pass();
},
assertElementMatches: function(element, expression) {
this.assertElementsMatch([element], expression);
},
benchmark: function(operation, iterations) {
var startAt = new Date();
(iterations || 1).times(operation);
var timeTaken = ((new Date())-startAt);
this.info((arguments[2] || 'Operation') + ' finished ' +
iterations + ' iterations in ' + (timeTaken/1000)+'s' );
return timeTaken;
},
_isVisible: function(element) {
element = $(element);
if(!element.parentNode) return true;
htdocs/js/unittest.js view on Meta::CPAN
this.assert(!this._isVisible(element), Test.Unit.inspect(element) + " was not hidden and didn't have a hidden parent either. " + ("" || arguments[1]));
},
assertVisible: function(element) {
this.assert(this._isVisible(element), Test.Unit.inspect(element) + " was not visible. " + ("" || arguments[1]));
},
benchmark: function(operation, iterations) {
var startAt = new Date();
(iterations || 1).times(operation);
var timeTaken = ((new Date())-startAt);
this.info((arguments[2] || 'Operation') + ' finished ' +
iterations + ' iterations in ' + (timeTaken/1000)+'s' );
return timeTaken;
}
};
Test.Unit.Testcase = Class.create();
GCC-Builtins
view release on metacpan or search on metacpan
lib/GCC/Builtins.pm view on Meta::CPAN
The following benchamrk results indicate that the use
of L<GCC::Builtins> (C<clz()> in this case)
yields more than 100% performance gain
over equivalent pure perl code:
Benchmark: timing 50000000 iterations of clz/xs, clz/pp-ugly...
clz/xs: 3.92331 wallclock secs ( 3.92 usr + 0.00 sys = 3.92 CPU) @ 12755102.04/s (n=50000000)
clz/pp-ugly: 8.24574 wallclock secs ( 8.23 usr + 0.00 sys = 8.23 CPU) @ 6075334.14/s (n=50000000)
Rate clz/pp-ugly clz/xs
clz/pp-ugly 6075334/s -- -52%
clz/xs 12755102/s 110% --
KEY:
clz/xs : calling GCC builtin clz() via XS from Perl
clz/pp-ugly : as suggested by coldr3ality (see https://perlmonks.org/?node_id=11158279)
Benchmark: timing 50000000 iterations of clzl/xs, clzl/pp-ugly...
clzl/xs: 3.84597 wallclock secs ( 3.84 usr + 0.00 sys = 3.84 CPU) @ 13020833.33/s (n=50000000)
clzl/pp-ugly: 8.44006 wallclock secs ( 8.43 usr + 0.00 sys = 8.43 CPU) @ 5931198.10/s (n=50000000)
Rate clzl/pp-ugly clzl/xs
clzl/pp-ugly 5931198/s -- -54%
clzl/xs 13020833/s 120% --
GD-Image-CopyIFS
view release on metacpan or search on metacpan
if not specified.
=item max_factor
This number, greater than 1, determines the maximum number
of iterations that the IFS algorithm uses. A value of 1
will have this iteration number equal to the number of
pixels in the destination; increasing this value will
produce better looking images, but at the expense of speed.
Reasonable values are around 5-10. A default of 7 is used
if not specified.
GDPR-IAB-TCFv2
view release on metacpan or search on metacpan
bench/performance.pl view on Meta::CPAN
$simple_validator->validate_all($strings[$idx++ % @strings]);
},
}
);
print "\nAbsolute throughput (50_000 iterations, single-thread):\n";
for my $bench (
['Parse', sub { GDPR::IAB::TCFv2->Parse($strings[$idx++ % @strings]) }],
[
'Parse+TO_JSON',
GIS-Distance
view release on metacpan or search on metacpan
lib/GIS/Distance.pm view on Meta::CPAN
=back
Calling this gets you pretty close to the fastest bare metal speed you can get.
The speed improvements of calling this is noticeable over hundreds of thousands of
iterations only and you've got to decide if its worth the safety and features
you are dropping. Read more in the L</SPEED> section.
=head1 ARGUMENTS
my $gis = GIS::Distance->new( $formula );
GRID-Cluster
view release on metacpan or search on metacpan
examples/pi/qx/pi_grid.pl view on Meta::CPAN
my $pi = sum @{$c->qx(@commands)};
my $elapsed = tv_interval($t0);
print "Calculating Pi with $N iterations and $np processes\n";
print "Elapsed Time: $elapsed seconds\n";
print "Pi Value: $pi\n";
__END__
examples/pi/qx/pi_grid.pl view on Meta::CPAN
#
cat MachineConfig.pm
return ({europa => 0, beowulf => 0, orion => 0}, {europa => 4, beowulf => 1, orion => 1});
pp2@europa:~/LGRID-Cluster-edusegre/examples/pi/open$ ./pi_grid.pl -co MachineConfig.pm -N 1000000000 -np 1
Calculating Pi with 1000000000 iterations and 1 processes
Elapsed Time: 62.915575 seconds
Pi Value: 3.141593
pp2@europa:~/LGRID-Cluster-edusegre/examples/pi/open$ ./pi_grid.pl -co MachineConfig.pm -N 1000000000 -np 6
Calculating Pi with 1000000000 iterations and 6 processes
Elapsed Time: 10.586874 seconds
Pi Value: 3.141594
pp2@europa:~/LGRID-Cluster-edusegre/examples/pi/open$ ./pi_grid.pl -co MachineConfig.pm -N 1000000000 -np 3
Calculating Pi with 1000000000 iterations and 3 processes
Elapsed Time: 20.986131 seconds
Pi Value: 3.141594
pp2@europa:~/LGRID-Cluster-edusegre/examples/pi/open$ !cat
pp2@europa:~/LGRID-Cluster-edusegre/examples/pi/open$ ./pi_grid.pl -co MachineConfig.pm -N 1000000000 -np 12
Calculating Pi with 1000000000 iterations and 12 processes
Elapsed Time: 10.736294 seconds
Pi Value: 3.141588
*********************************************************
cat MachineConfig.pm
return ({europa => 0, beowulf => 0, orion => 0}, {europa => 1, beowulf => 1, orion => 1});
pp2@europa:~/LGRID-Cluster-edusegre/examples/pi/open$ time ./pi_grid.pl -co MachineConfig.pm -N 1000000000 -np 3
Calculating Pi with 1000000000 iterations and 3 processes
Elapsed Time: 20.956588 seconds
Pi Value: 3.141594
real 0m22.549s
user 0m0.296s
sys 0m0.068s
pp2@europa:~/LGRID-Cluster-edusegre/examples/pi/open$ time ./pi_grid.pl -co MachineConfig.pm -N 1000000000 -np 6
Calculating Pi with 1000000000 iterations and 6 processes
Elapsed Time: 15.694753 seconds
Pi Value: 3.141594
real 0m17.285s
user 0m0.304s
sys 0m0.104s
# gana porque europa son 4 y beowulf son 2
pp2@europa:~/LGRID-Cluster-edusegre/examples/pi/open$ time ./pi_grid.pl -co MachineConfig.pm -N 1000000000 -np 12
Calculating Pi with 1000000000 iterations and 12 processes
Elapsed Time: 13.246352 seconds
Pi Value: 3.141588
real 0m14.798s
user 0m0.328s
sys 0m0.116s
pp2@europa:~/LGRID-Cluster-edusegre/examples/pi/open$ time ./pi_grid.pl -co MachineConfig.pm -N 1000000000 -np 15
Calculating Pi with 1000000000 iterations and 15 processes
Elapsed Time: 12.924256 seconds
Pi Value: 3.1416
real 0m14.500s
user 0m0.372s
sys 0m0.108s
pp2@europa:~/LGRID-Cluster-edusegre/examples/pi/open$ time ./pi_grid.pl -co MachineConfig.pm -N 1000000000 -np 18
Calculating Pi with 1000000000 iterations and 18 processes
Elapsed Time: 14.406338 seconds
Pi Value: 3.141594
real 0m16.008s
user 0m0.364s
Game-Collisions
view release on metacpan or search on metacpan
nytprof/js/jit/jit.js view on Meta::CPAN
Parameters:
options - Some sequence options like
- _condition_ A function returning a boolean instance in order to stop iterations.
- _step_ A function to execute on each step of the iteration.
- _onComplete_ A function to execute when the sequence finishes.
- _duration_ Duration (in milliseconds) of each step.
Example:
Game-DijkstraMap
view release on metacpan or search on metacpan
lib/Game/DijkstraMap.pm view on Meta::CPAN
first e.g. with B<map> or B<str2map>.
=item B<iters>
This is set during the B<normalize>, B<map>, and B<recalc> method
calls and indicates how many iterations it took the B<normfn> to
stabilize the map.
=item B<max_cost>
Cost for non-goal (B<min_cost>) non-wall (B<bad_cost>) cells. C<INT_MAX>
lib/Game/DijkstraMap.pm view on Meta::CPAN
work?" design. Something much more efficient should likely be written,
possibly with fewer features.
B<norm_4way> is not very good with long and mostly unconnected
corridors; this might be improved on by considering adjacent unseen
cells after a cell changes in addition to full map iterations?
=head1 SEE ALSO
L<Game::TextPatterns> may help generate or modify data that can be then
fed to this module.
Game-Entities
view release on metacpan or search on metacpan
or removed from any entity. This should make the common case of systems
operating over sets of components that tend to be relatively stable
(eg. across game frames) as fast as possible.
The distribution includes two tests in its extended suite to test the
performance with iterations over large number of entities
(`xt/short-loops.t`), and many iterations over small numbers of entities
(`xt/long-loops.t`). Please refer to these files for accurate estimations.
# SEE ALSO
- [EnTT](https://skypjack.github.io/entt)
Game-Life-Faster
view release on metacpan or search on metacpan
lib/Game/Life/Faster.pm view on Meta::CPAN
The heavy lifting is done by L<set_point_state()|/set_point_state>.
=head2 process
$life->process( $iterations );
This method runs the game for the specified number of iterations, which
defaults to C<1>.
As an incompatible change to the same-named method of
L<Game::Life|Game::Life>, the number of points that actually changed
state is returned. If C<$iterations> is greater than C<1>, the return
represents the last iteration. The corresponding
L<Game::Life|Game::Life> method does not have an explicit C<return>.
=head2 set_point
Game-Pexeso
view release on metacpan or search on metacpan
$zoom->apply($label);
# Keep a handle to the behaviours otherwise they wont be applied
$pexeso->{zoom} = $zoom;
# Start an infinite loop that will end after two iterations. In the first
# iteration the text is zoomed in a linear way and at the second iteration
# the text is zoomed out with a bouncy effect. Afterwards the animation is
# stopped.
$timeline->set_loop(TRUE);
my $count = 0;
Game-WordBrain
view release on metacpan or search on metacpan
lib/Game/WordBrain/WordList.pm view on Meta::CPAN
alliterating
alliteration
alliteration's
alliterational
alliterationist
alliterations
alliterative
alliteratively
alliterativeness
alliterator
allituric
lib/Game/WordBrain/WordList.pm view on Meta::CPAN
iterated
iterately
iterates
iterating
iteration
iterations
iterative
iteratively
iterativeness
iterator
iterator's
lib/Game/WordBrain/WordList.pm view on Meta::CPAN
obliterate
obliterated
obliterates
obliterating
obliteration
obliterations
obliterative
obliterator
obliterators
oblivescence
oblivial
lib/Game/WordBrain/WordList.pm view on Meta::CPAN
reiteratedly
reiteratedness
reiterates
reiterating
reiteration
reiterations
reiterative
reiteratively
reiterativeness
reiterator
reive
lib/Game/WordBrain/WordList.pm view on Meta::CPAN
transliterate
transliterated
transliterates
transliterating
transliteration
transliterations
transliterator
translocalization
translocate
translocated
translocating
( run in 3.906 seconds using v1.01-cache-2.11-cpan-f03e8824b8d )