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.)

 view release on metacpan or  search on metacpan

t/10run.t  view on Meta::CPAN

   );

   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;

 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();

 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%           --

 view release on metacpan or  search on metacpan

CopyIFS.pm  view on Meta::CPAN

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.

 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',

 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 );

 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

 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:

 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.

 view release on metacpan or  search on metacpan

README.md  view on Meta::CPAN

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)

 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

 view release on metacpan or  search on metacpan

bin/pexeso  view on Meta::CPAN

	$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;

 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

 view release on metacpan or  search on metacpan

lib/Game/Xomb.pm  view on Meta::CPAN

=item B<distance>

Pythagorean distance between two cells, with rounding. Will differ in
some cases from the Chebyshev distance that the B<linecb> and B<walkcb>
line functions use for an iterations count.

=item B<does_hit>

Whether or not the given weapon hits at the given B<distance>, and
what the cost of that move was. The cost will be higher if the target

 view release on metacpan or  search on metacpan

inc/cpSpace.xsh  view on Meta::CPAN

int
cpSpaceGetIterations( space )
    cpSpace *space

void
cpSpaceSetIterations( space, iterations )
    cpSpace *space
    int iterations

cpVect
cpSpaceGetGravity( space )
    cpSpace *space

 view release on metacpan or  search on metacpan

t/patterns.txt  view on Meta::CPAN

1|2|2|4|5|6|7|1|3|10|7|12:immaterially|
1|2|2|4|5|6|7|1|3|2:innovation|
1|2|2|4|5|6|7|1|3|2|11:innovations|
1|2|2|4|5|6|7|1|4|10:immaturity|innovative|
1|2|2|4|5|6|7|1|4|3|11|12:alliteration|
1|2|2|4|5|6|7|1|4|3|11|12|13:alliterations|
1|2|2|4|5|6|7|1|4|3|11|5:alliterative|
1|2|2|4|5|6|7|1|5|10|11|4:accentuation|
1|2|2|4|5|6|7|1|5|10|4|12:accentuating|
1|2|2|4|5|6|7|1|5|2|11:accountancy|
1|2|2|4|5|6|7|1|5|3:accentuate|

t/patterns.txt  view on Meta::CPAN

1|2|3|4|5|2|1|8|4|10|11|12|13|10:thoughtfulness|
1|2|3|4|5|2|1|8|4|10|7|12:thoughtfully|
1|2|3|4|5|2|1|8|5:reinserts|
1|2|3|4|5|2|1|8|6|1|11|12|4:impermissible|
1|2|3|4|5|2|1|8|9:devotedly|indemnify|indemnity|insomniac|iterating|iteration|tabulated|tabulates|tabulator|
1|2|3|4|5|2|1|8|9|10:iterations|recovering|tabulating|tabulation|tabulators|
1|2|3|4|5|2|1|8|9|10|11:tabulations|
1|2|3|4|5|2|1|8|9|10|11|5:remuneration|
1|2|3|4|5|2|1|8|9|10|2:recoverable|
1|2|3|4|5|2|1|8|9|10|8:thoughtless|
1|2|3|4|5|2|1|8|9|10|8|12|7|8|8:thoughtlessness|

 view release on metacpan or  search on metacpan

lib/Games/Dissociate.pm  view on Meta::CPAN

      characters as the group size.
  -wNUMBER
      Run a by-word dissociation with that number of
      words as the group size.
  -mNUMBER
      Specifies how many iterations the dissociator loop should make.
";
  }

  my $o;
  my $max;

lib/Games/Dissociate.pm  view on Meta::CPAN

characters) instead.  A value of -1 is invalid, and currently causes
C<dissociate> to use the value of -2 (2 words) instead.  The
behavior/validity of $group_size values of 0, 1, or -1 may change in
future versions.

$max is a parameter used to control the maximum number of iterations
of C<dissociate>'s central loop -- it corresponds roughly to the
number of "chunks" of text you get back, where a chunk is N *
-$group_size words for negative values of $group_size, and N *
$group_size characters for positive values of $group_size.  $max must
be greater than 1.

 view release on metacpan or  search on metacpan

bin/bayrate.pl  view on Meta::CPAN

    my $collection = Games::Go::AGA::BayRate::Collection->new(
            iter_hook         => \&iter_hook,
            tournamentDate    => $tournamentDate,
            strict_compliance => $strict_compliance, # match original bayrate C++ code exactly
            #f_iterations     => 50,
            #fdf_iterations   => 50,
    );

    # enter all the players who were in a game
    my %players_by_id;
    foreach my $id (sort { $a <=> $b } keys %player_seeds_by_id) {

 view release on metacpan or  search on metacpan

lib/Games/LMSolve/Base.pm  view on Meta::CPAN

=head2 $self->solve_board($file_spec, %args)

Solves the board specification specified in $file_spec. %args specifies
optional arguments. Currently there is one: 'max_iters' that specifies the
maximal iterations to run.

Returns whatever run_scan returns.

=head2 $self->run_scan(%args)

Continues the current scan. %args may contain the 'max_iters' parameter
to specify a maximal iterations limit.

Returns two values. The first is a progress indicator. "solved" means the
puzzle was solved. "unsolved" means that all the states were covered and
the puzzle was proven to be unsolvable. "interrupted" means that the
scan was interrupted in the middle, and could be proved to be either

lib/Games/LMSolve/Base.pm  view on Meta::CPAN

The second argument is the final state and is valid only if the progress
value is "solved".

=head2 $self->get_num_iters()

Retrieves the current number of iterations.

=head2 $self->display_solution($progress_code, $final_state)

If you input this message with the return value of run_scan() you'll get
a nice output of the moves to stdout.

 view release on metacpan or  search on metacpan

Object.pod  view on Meta::CPAN

process() is next called on the object.

=item Delayed-action modifiers

A persistent modifier, either one that is timed or not, can be set up such
that it does not take effect for a given number of iterations through the
C<process()> method. This is done via the I<-delay> option, as in this example:

    $obj->mod_attr(-name => "health",
		   -modify => -5,
		   -incremental => 1,

 view release on metacpan or  search on metacpan

lib/Games/Perlwar/Shell.pm  view on Meta::CPAN

});

### run
$shell->add_commands({
    run => {
        desc => 'run iterations of the game',
        proc => \&do_run,
    }
});

### exec, info

 view release on metacpan or  search on metacpan

HACKING  view on Meta::CPAN

    $ dzil test                         # to run the tests
    $ dzil run ./bin/prisk              # to run the game from local checkout
    $ dzil run bash                     # to examine what built dist will look like

This takes quite some time, but you will be sure to run against what
would be released to CPAN. For quicker iterations, you can run directly:
    $ ./bin/prisk

Note however that some windows will fail (such as the about box,
and maybe others): indeed, they would need some information added
by dist-zilla.

 view release on metacpan or  search on metacpan

lib/Games/Roguelike/Caves.pm  view on Meta::CPAN

#use cellular automata to carve out a decent cave
#initially contain 45% walls at random
#a tile becomes or remains a wall if the 3x3 region centered on it contains at least 5 walls.
#use 1 to represent wall, 0 is space
sub generate_cave{
    my ($w, $h, $iterations, $percentWalls, $wall, $floor) = @_;
    die 'dimensions?' unless ($w and $h);
    $iterations ||= 12;
    $percentWalls ||= .45;
    $percentWalls /= 100 if $percentWalls>1; # in case it's .45 or something
    $wall = ' ' unless defined $wall;
    $floor = '.' unless defined $floor;
    

lib/Games/Roguelike/Caves.pm  view on Meta::CPAN

    for my $x (0..$w-1){
        for my $y (0..$h-1){
            $terrain[$y][$x] = rand()<$percentWalls ? 1 : 0;
        }
    }
    for (1..$iterations){
        for my $x (0..$w-1){
            for my $y (0..$h-1){
                if ( !$x or !$y or $x==$w-1 or $y==$h-1){
                    #we're at edge: be wall.
                    $nextStep[$y][$x] = 1;

 view release on metacpan or  search on metacpan

lib/Games/ScottAdams/Manual.pod  view on Meta::CPAN

=head2 %version

	%version 416

Specifies the version of this adventure.  Looks like Adams went
through 416 design iterations before he got I<Adventureland> into a
state he was happy to release.

=head2 %wordlen

	%wordlen 3

 view release on metacpan or  search on metacpan

examples/benchmark.pl  view on Meta::CPAN

if ( $ARGV[0] =~ m{\A-h|--help\z} )
{
    print <<'EOF';
summarize-fc-solve [Game Params] -- [Extra fc-solve Args]

Display the solution status, the iterations count and the solution length
of the Freecell Solver invocation specified by the arguments. Also verifies
that the solution is true.

The [Game Params] flags (e.g: -g , --freecells-num, --stacks-num, etc.) are also
used to determine the variant used by the solution verifier.

 view release on metacpan or  search on metacpan

lib/Games/Sudoku/General.pm  view on Meta::CPAN

sub _constrain {
    my ( $self ) = @_;
    my $stack = $self->{backtrack_stack} ||= [];	# May hit this
							# when initializing.
    my $used = $self->{constraints_used} ||= {};
    my $iterations;
    $iterations = $self->{iteration_limit}
	if $self->{iteration_limit} > 0;

    $self->{no_more_solutions} and
	return $self->_unload (undef, SUDOKU_NO_SOLUTION);

lib/Games/Sudoku/General.pm  view on Meta::CPAN

# ? constraint - initiate backtracking.

sub _constraint_backtrack {
    my ( $self ) = @_;
##  --$iterations >= 0 or return $self->_unload ('', SUDOKU_TOO_HARD)
##	if defined $iterations;
    my @try;
    my $syms = @{$self->{symbol_list}};
    foreach my $cell (@{$self->{cell}}) {
	next if $cell->{content};
	next unless @{$cell->{membership}};

 view release on metacpan or  search on metacpan

lib/Games/Word/Wordlist/Enable.pm  view on Meta::CPAN

allergens allergic allergies allergin allergins allergist allergists allergy
allethrin allethrins alleviate alleviated alleviates alleviating alleviation
alleviations alleviator alleviators alley alleys alleyway alleyways allheal
allheals alliable alliaceous alliance alliances allicin allicins allied allies
alligator alligators alliterate alliterated alliterates alliterating
alliteration alliterations alliterative alliteratively allium alliums
alloantibodies alloantibody alloantigen alloantigens allobar allobars
allocable allocatable allocate allocated allocates allocating allocation
allocations allocator allocators allocution allocutions allod allodia allodial
allodium allods allogamies allogamous allogamy allogeneic allogenic allograft
allografted allografting allografts allograph allographic allographs

lib/Games/Word/Wordlist/Enable.pm  view on Meta::CPAN

italicizations italicize italicized italicizes italicizing italics itch itched
itches itchier itchiest itchily itchiness itchinesses itching itchings itchy
item itemed iteming itemise itemised itemises itemising itemization
itemizations itemize itemized itemizer itemizers itemizes itemizing items
iterance iterances iterant iterate iterated iterates iterating iteration
iterations iterative iteratively iterum ither ithyphallic itinerancies
itinerancy itinerant itinerantly itinerants itineraries itinerary itinerate
itinerated itinerates itinerating itineration itinerations its itself
ivermectin ivermectins ivied ivies ivories ivory ivorybill ivorybills ivy
ivylike iwis ixia ixias ixodid ixodids ixora ixoras ixtle ixtles izar izars
izzard izzards jab jabbed jabber jabbered jabberer jabberers jabbering jabbers

lib/Games/Word/Wordlist/Enable.pm  view on Meta::CPAN

litany litas litchi litchis lite liter literacies literacy literal literalism
literalisms literalist literalistic literalists literalities literality
literalization literalizations literalize literalized literalizes literalizing
literally literalness literalnesses literals literarily literariness
literarinesses literary literate literately literateness literatenesses
literates literati literatim literation literations literator literators
literature literatures literatus liters litharge litharges lithe lithely
lithemia lithemias lithemic litheness lithenesses lither lithesome lithest
lithia lithias lithiases lithiasis lithic lithification lithifications
lithified lithifies lithify lithifying lithium lithiums litho lithoed
lithograph lithographed lithographer lithographers lithographic

lib/Games/Word/Wordlist/Enable.pm  view on Meta::CPAN

obligates obligati obligating obligation obligations obligato obligatorily
obligatory obligatos oblige obliged obligee obligees obliger obligers obliges
obliging obligingly obligingness obligingnesses obligor obligors oblique
obliqued obliquely obliqueness obliquenesses obliques obliquing obliquities
obliquity obliterate obliterated obliterates obliterating obliteration
obliterations obliterative obliterator obliterators oblivion oblivions
oblivious obliviously obliviousness obliviousnesses oblong oblongly oblongs
obloquies obloquy obnoxious obnoxiously obnoxiousness obnoxiousnesses
obnubilate obnubilated obnubilates obnubilating obnubilation obnubilations
oboe oboes oboist oboists obol obole oboles oboli obols obolus obovate obovoid
obscene obscenely obscener obscenest obscenities obscenity obscurant

lib/Games/Word/Wordlist/Enable.pm  view on Meta::CPAN

reinvestigates reinvestigating reinvestigation reinvestigations reinvesting
reinvestment reinvestments reinvests reinvigorate reinvigorated reinvigorates
reinvigorating reinvigoration reinvigorations reinvigorator reinvigorators
reinvite reinvited reinvites reinviting reinvoke reinvoked reinvokes
reinvoking reis reissue reissued reissuer reissuers reissues reissuing reitbok
reitboks reiterate reiterated reiterates reiterating reiteration reiterations
reiterative reiteratively reive reived reiver reivers reives reiving rejacket
rejacketed rejacketing rejackets reject rejected rejectee rejectees rejecter
rejecters rejecting rejectingly rejection rejections rejective rejector
rejectors rejects rejigger rejiggered rejiggering rejiggers rejoice rejoiced
rejoicer rejoicers rejoices rejoicing rejoicingly rejoicings rejoin rejoinder

lib/Games/Word/Wordlist/Enable.pm  view on Meta::CPAN

transitively transitiveness transitivenesses transitivities transitivity
transitorily transitoriness transitorinesses transitory transits
translatabilities translatability translatable translate translated translates
translating translation translational translations translative translator
translators translatory transliterate transliterated transliterates
transliterating transliteration transliterations translocate translocated
translocates translocating translocation translocations translucence
translucences translucencies translucency translucent translucently
transmarine transmembrane transmigrate transmigrated transmigrates
transmigrating transmigration transmigrations transmigrator transmigrators
transmigratory transmissibilities transmissibility transmissible transmission

 view release on metacpan or  search on metacpan

scripts/Gin/Calibrate/GcodeGenerator.pm  view on Meta::CPAN

  return \@gcode;
}

sub waggle {
  my ($self, $directions, $distance, $iterations) = @_;

  my @gcode = ();

  for(my $i = 0; $i < $iterations; $i++) {
    foreach my $direction (1, -1) {
      my $moves = {
        'X' => 0,
        'Y' => 0,
        'Z' => 0,

 view release on metacpan or  search on metacpan

t/lib_for_test_class/Test/GenOO/Data/Structure/DoubleHashArray.pm  view on Meta::CPAN

sub foreach_entry_do : Test(3) {
	my ($self) = @_;
	
	can_ok $self->obj, 'foreach_entry_do';
	
	my $iterations = 0;
	$self->obj->foreach_entry_do(sub{
		my ($arg) = @_;
		$iterations++ if ($arg =~ /^\d+$/);
	});
	is $iterations, $self->obj->entries_count, "... and should do the correct number of iterations";
	
	$iterations = 0;
	$self->obj->foreach_entry_do(sub{
		my ($arg) = @_;
		$iterations++ if ($arg =~ /^\d+$/);
		return 'break_loop' if ($iterations == 3)
	});
	is $iterations, 3, "... and should break when requested";
}

sub foreach_entry_on_secondary_key_do : Test(2) {
	my ($self) = @_;
	
	can_ok $self->obj, 'foreach_entry_on_secondary_key_do';
	
	my $iterations = 0;
	$self->obj->foreach_entry_on_secondary_key_do('chr3', sub{
		my ($arg) = @_;
		if ($arg =~ /^\d+$/) {
			$iterations++;
		}
	});
	is $iterations, 3, "... and should do the correct number of iterations";
}

sub add_entry : Test(2) {
	my ($self) = @_;