view release on metacpan or  search on metacpan

lib/Lingua/Norms/SUBTLEX.pm  view on Meta::CPAN

L<Text::CSV::Hashify|Text::CSV::Hashify> : reads in the specs file

L<Text::CSV::Separator|Text::CSV::Separator> : for determining the field delimiter within the datafiles

L<Text::Unidecode|Text::Unidecode> : for plain ASCII transliterations of Unicode text

=head1 REFERENCES

Brysbaert, M., Buchmeier, M., Conrad, M., Jacobs, A.M., Boelte, J., & Boehl, A. (2011). The word frequency effect: A review of recent developments and implications for the choice of frequency estimates in German. I<Experimental Psychology>, I<58>, 41...

 view release on metacpan or  search on metacpan

lib/Lingua/Translit.pm  view on Meta::CPAN

system.
Therefore it is an important and necessary information, which scheme will be
or has been used to transliterate a text, to work integrative and be able to
reconstruct the original data.

Reconstruction is a problem though for non-unique transliterations, if no
language specific knowledge is available as the resulting clusters of
letters may be ambiguous.
For example, the Greek character "PSI" maps to "ps", but "ps" could also
result from the sequence "PI", "SIGMA" since "PI" maps to "p" and "SIGMA"
maps to s.

 view release on metacpan or  search on metacpan

HanConvert.pm  view on Meta::CPAN

a traditional character has two or more corresponding simplified forms,
but this happens much more rarely.

=head1 BUGS, LIMITATIONS

B<There may be mistakes in the transliterations>.  A number of data sources
were used to build the transliteration tables, including dictionaries and
the Unicode consortium's Unihan database, but some mappings may be
incorrect or missing.

Some characters which are simplified forms are also traditional forms.  For

 view release on metacpan or  search on metacpan

cppjieba/deps/gtest/src/gtest.cc  view on Meta::CPAN

      failed = true;
    }

    // Restores the original test order after the iteration.  This
    // allows the user to quickly repro a failure that happens in the
    // N-th iteration without repeating the first (N - 1) iterations.
    // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in
    // case the user somehow changes the value of the flag somewhere
    // (it's always safe to unshuffle the tests).
    UnshuffleTests();

 view release on metacpan or  search on metacpan

clib/libmpeg2/motion_comp_mmx.c  view on Meta::CPAN

static mmx_t round4 = {0x0002000200020002LL};

/*
 * This code should probably be compiled with loop unrolling
 * (ie, -funroll-loops in gcc)becuase some of the loops
 * use a small static number of iterations. This was written
 * with the assumption the compiler knows best about when
 * unrolling will help
 */

static inline void mmx_zero_reg (void)

 view release on metacpan or  search on metacpan

clib/libmpeg2/motion_comp_mmx.c  view on Meta::CPAN

static mmx_t round4 = {0x0002000200020002LL};

/*
 * This code should probably be compiled with loop unrolling
 * (ie, -funroll-loops in gcc)becuase some of the loops
 * use a small static number of iterations. This was written
 * with the assumption the compiler knows best about when
 * unrolling will help
 */

static inline void mmx_zero_reg (void)

 view release on metacpan or  search on metacpan

xt/benchmark.t  view on Meta::CPAN

        my $mean   = $result->raw_number;
        my $sigma  = $result->raw_error->[0];
        my $name   = $instance->_name_prefix;
        diag(
            sprintf(
                "%sRan %u iterations (%u outliers).\n",
                $name,
                scalar( @{ $instance->timings } ),
                scalar( @{ $instance->timings } ) - $result->nsamples
            )
        );

 view release on metacpan or  search on metacpan

libseccomp/build-aux/ltmain.sh  view on Meta::CPAN

        # Relative path, prepend $cwd.
        func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
        ;;
    esac

    # Cancel out all the simple stuff to save iterations.  We also want
    # the path to end with a slash for ease of parsing, so make sure
    # there is one (and only one) here.
    func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
          -e "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"`
    while :; do

 view release on metacpan or  search on metacpan

examples/mand2.pl  view on Meta::CPAN

use Linux::Svgalib;

use vars qw($P @Q $col $row @colours );

my (
    $max_iterations,
    $max_size )       = (512,4);

my $screen = Linux::Svgalib->new();

$screen->init();

examples/mand2.pl  view on Meta::CPAN

    {
        my ($X,$Y,$XSquare,$YSquare) = (0,0,0,0);

        my $colour = 1;

        while (( $colour < $max_iterations ) &&
               (($XSquare + $YSquare ) < $max_size ))
        {
             $XSquare = $X * $X;
             $YSquare = $Y * $Y;

 view release on metacpan or  search on metacpan

perltidyrc  view on Meta::CPAN

-npro
-nsfs
--blank-lines-before-packages=0
--opening-hash-brace-right
--no-outdent-long-comments
--iterations=2
-wbb="% + - * / x != == >= <= =~ !~ < > | & >= < = **= += *= &= <<= &&= -= /= |= >>= ||= .= %= ^= x="

 view release on metacpan or  search on metacpan

lib/List/BinarySearch/XS.pm  view on Meta::CPAN

for inserts.  Binary Searches are best when the data set is already ordered, or
will be searched enough times to justify the cost of an initial sort.

There are cases where a binary search may be an excellent choice. Finding the
first matching element in a list of 1,000,000 items with a linear search would
have a worst-case of 1,000,000 iterations, whereas the worst case for a binary
search of 1,000,000 elements is about 20 iterations.  In fact, if many lookups
will be performed on a seldom-changed list, the savings of O(log n) lookups may
outweigh the cost of sorting or performing occasional linear time inserts.


=head1 EXPORT

 view release on metacpan or  search on metacpan

lib/List/BinarySearch.pm  view on Meta::CPAN

for inserts.  Binary Searches are best when the data set is already ordered, or
will be searched enough times to justify the cost of an initial sort.

There are cases where a binary search may be an excellent choice. Finding the
first matching element in a list of 1,000,000 items with a linear search would
have a worst-case of 1,000,000 iterations, whereas the worst case for a binary
search of 1,000,000 elements is about 20 iterations.  In fact, if many lookups
will be performed on a seldom-changed list, the savings of O(log n) lookups may
outweigh the cost of sorting or performing occasional linear time inserts.


=head1 EXPORT

 view release on metacpan or  search on metacpan

lib/List/Gen.pm  view on Meta::CPAN

        curse {
            FETCH => sub {
                my $i = $_[1];
                while ($i > $#list) {
                    $iter++ >= $size
                        and croak "too many iterations requested: ".
                                  "$iter. index $i out of bounds [0 .. @{[$size - 1]}]";
                    local *_ = $from   ? $list[-1] :
                               $source ? \$source->(undef, scalar @list) :
                               \scalar @list;
                    eval {push @list, map {ref eq 'List::Gen::Thunk' ? \$$_->() : \$_} $code->(); 1}

lib/List/Gen.pm  view on Meta::CPAN

        curse {
            FETCH => sub {
                my $i = $_[1];
                $i < $pos and croak "non-monotone access of iterate multi stream, idx($i) < pos($pos)";
                while ($i >= $pos) {
                     $pos >= $size and croak "too many iterations requested: ".
                                            "$pos. index $i out of bounds [0 .. @{[$size - 1]}]";
                    if ($i == $pos and @last) {
                        $pos++;
                        last
                    }

 view release on metacpan or  search on metacpan

lib/List/Helpers/XS.pm  view on Meta::CPAN

=head1 Benchmarks

Benchmarks of C<random_slice> method in comparison with C<List::MoreUtils::samples> and
C<List::Util::sample> showed that current version of C<random_slice> is very similar to
the first ones in some cases. But in case of huge amount of iterations it starts to slow
down due to some performance degradation.

So, the usage of C<List::MoreUtils::samples> (it's the fastest now) and C<List::Util::sample> is more preferable.
I'll keep C<random_slice> for backward compatibility.

 view release on metacpan or  search on metacpan

lib/List/Pairwise.pod  view on Meta::CPAN

statement

    my $i;
    firstp {
        print "$a: $b\n";
        ++$i==5 # last after 5 iterations
    } %hash;

=item lastp BLOCK LIST

=item last_pairwise BLOCK LIST

 view release on metacpan or  search on metacpan

perltidyrc  view on Meta::CPAN

-npro
-nsfs
--blank-lines-before-packages=0
--opening-hash-brace-right
--no-outdent-long-comments
--iterations=2
-wbb="% + - * / x != == >= <= =~ !~ < > | & >= < = **= += *= &= <<= &&= -= /= |= >>= ||= .= %= ^= x="

 view release on metacpan or  search on metacpan

perltidyrc  view on Meta::CPAN

-npro
-nsfs
--blank-lines-before-packages=0
--opening-hash-brace-right
--no-outdent-long-comments
--iterations=2
-wbb="% + - * / x != == >= <= =~ !~ < > | & >= < = **= += *= &= <<= &&= -= /= |= >>= ||= .= %= ^= x="

 view release on metacpan or  search on metacpan

etc/bench/bench.pl  view on Meta::CPAN

bmzy ovt anya bclp aijn dmmr
ok 1 - same order
ok 2 - same contents, list-u-det-order
ok 3 - same contents, hash ordered
1..3
            (warning: too few iterations for a reliable count)
                Rate      lbs      lmu      lho      ldd baseline
lbs      9.73e-002/s       --      -8%     -94%     -97%    -100%
lmu          0.105/s       8%       --     -94%     -97%    -100%
lho           1.62/s    1570%    1444%       --     -53%     -96%
ldd           3.48/s    3476%    3207%     114%       --     -92%

 view release on metacpan or  search on metacpan

lib/LoadHtml.pm  view on Meta::CPAN

There are four special variables that have meaning within a loop construct:

    * :# Current increment value. If no increment expression or index list is specified, the loop is driven by the 1st array or hash argument. In that case, the increment value is the zero-based iteration of the loop. This value is always numeric and...
    * :* Always the current zero-based iteration of the loop (numeric). Normally, this is the same as :#, but if an increment expression or index list is specified before the parameters, then :# is set to each element of the increment expression/inde...
    * :% Current key value of the 1st (driving) hash (if the 1st argument is a hash-reference). Otherwise, this variable is empty (ie. if the loop is driven by an array).
    * :^ Always contains the number of iterations (one-based) that the loop will perform. 

Naming and nesting IF and LOOP constructs.

IF and LOOP constructs can be nested with each other.  If nested within the same construct, however, they must be named (in order for the parser to match up the proper closing tags).  This allows for qualifying the special variables (:#, :*, etc.) to...

 view release on metacpan or  search on metacpan

Build.PL  view on Meta::CPAN

        'Test::More'        => '0.98',
    },
    add_to_cleanup      => [ 'Locale-CLDR-Transformations-*' ],
    configure_requires => { 'Module::Build' => '0.40' },
    release_status => 'stable',
    dist_abstract => q<Locale::CLDR - Data Package ( Perl localization data for transliterations )>,
    meta_add => {
        keywords => [ qw( locale CLDR locale-data-pack ) ],
        resources => {
            homepage => 'https://github.com/ThePilgrim/perlcldr',
            bugtracker => 'https://github.com/ThePilgrim/perlcldr/issues',

 view release on metacpan or  search on metacpan

lib/Locale/Unicode.pm  view on Meta::CPAN

=back

=head2 Transform extensions

This is used for transliterations, transcriptions, translations, etc, as per L<RFC6497|https://datatracker.ietf.org/doc/html/rfc6497>

For example:

=over 4

 view release on metacpan or  search on metacpan

t/edge_cases.t  view on Meta::CPAN

			$logger->level('debug');
		}
		$logger->debug("msg $i");
	}

	# Only odd iterations have level=debug when debug() is called
	my $m = $logger->messages();
	ok(scalar(@{$m}) > 0,   'some messages logged during level oscillation');
	ok(scalar(@{$m}) < 200, 'some messages filtered during level oscillation');
};

 view release on metacpan or  search on metacpan

lib/Log/Any/Progress.pm  view on Meta::CPAN

progress, similar in concept to L<Term::ProgressBar>.  It can be
useful for monitoring the progress of a long-running process and to
get an idea of how long that process might take to finish.

It is generally applied to a processing loop.  In the typical case
where the expected number of iterations is known in advance, it
produces output containing the iteration count, percent completion,
elapsed time, average time per iteration, and estimated time remaining.
For example:

  Progress: Iteration:0/5 0% STARTING

lib/Log/Any/Progress.pm  view on Meta::CPAN

  Progress: Iteration:4/5 80% Elapsed:8.001s Avg:2.000s Remaining:2.000s
  Progress: Iteration:5/5 100% FINISHED Elapsed:10.002s Avg:2.000s

The remaining time estimate as of any particular iteration is a
simple linear calculation based on the average time per iteration up
to that point, and the number of remaining iterations.

If the expected number of iterations is not known in advance, it still
reports on incremental progress, but cannot compute either percent
completion or estimated remaining time.  For example:

  Progress: Iteration:0 STARTING
  Progress: Iteration:1 Elapsed:2.000s Avg:2.000s

lib/Log/Any/Progress.pm  view on Meta::CPAN

=over 4

=item count

A mandatory non-zero count of the expected number of iterations for
progress tracking.

Specifying C<-1> indicates that the expected number of iterations is
unknown, in which case abbreviated statistics will be logged for each
iteration (percent completion and estimated finish time cannot be
computed without knowing the expected number of iterations in advance).

=item delayed_start

An optional boolean value controlling whether or not L</start> should
be automatically called at time of object construction.  It defaults

lib/Log/Any/Progress.pm  view on Meta::CPAN

calling L</update>).  Values specifying fractional seconds are allowed
(e.g. C<0.5>).  It defaults to C<10> seconds.

Setting C<min_sec_between_messages> appropriately can be used to
control log verbosity in cases where many hundreds or thousands of
iterations are being processed and it's not necessary to report after
each iteration.  Setting it to C<0> will result in every incremental
progress message will be emitted.

=item prefix

 view release on metacpan or  search on metacpan

perltidyrc  view on Meta::CPAN

-npro
-nsfs
--blank-lines-before-packages=0
--opening-hash-brace-right
--no-outdent-long-comments
--iterations=2
-wbb="% + - * / x != == >= <= =~ !~ < > | & >= < = **= += *= &= <<= &&= -= /= |= >>= ||= .= %= ^= x="

 view release on metacpan or  search on metacpan

t/leak.t  view on Meta::CPAN

# Allow up to 128 KB of growth for noise (arena rounding, etc.)
my $max_growth = 128 * 1024;

cmp_ok($growth, '<=', $max_growth,
    sprintf("memory growth after 100k iterations: %d bytes (limit %d)",
            $growth, $max_growth));

if ($growth > $max_growth) {
    diag sprintf("before: %d bytes, after: %d bytes, growth: %d bytes",
                 $before, $after, $growth);

 view release on metacpan or  search on metacpan

t/first.pl  view on Meta::CPAN

use Test::Differences;
my $output = '';
sub record { $output .= join '' => @_ }

sub doit {
    my ($level, $iterations) = @_;
    return if $level > 2;
    record "level $level: begin\n";
    for (1 .. $iterations) {
        FIRST { record "level $level, block 1, iter $_: FIRST A\n" };
        record "level $level, block 1, iter $_: before\n";
        record "level $level, block 1, iter $_: middle\n";
        FIRST { record "level $level, block 1, iter $_: FIRST B\n" };
        record "level $level, block 1, iter $_: after\n";
    }
    record "\n";
    doit($level + 1, $iterations);
    for (1 .. $iterations) {
        FIRST { record "level $level, block 2, iter $_: FIRST A\n" };
        record "level $level, block 2, iter $_: before\n";
        record "level $level, block 2, iter $_: middle\n";
        FIRST { record "level $level, block 2, iter $_: FIRST B\n" };
        record "level $level, block 2, iter $_: after\n";

 view release on metacpan or  search on metacpan

lib/Loop/Util.pm  view on Meta::CPAN

loop. (The C<next> and C<redo> keywords also work as expected.)

=item * C<iffirst [LABEL] BLOCK [else BLOCK]>

Runs C<BLOCK> only on the first loop iteration; if an C<else> block is present
it runs for subsequent iterations.

When C<LABEL> is present, C<iffirst> checks that labeled loop context instead
of the innermost loop. This is useful in nested loops:

  OUTER: loop(2) {

lib/Loop/Util.pm  view on Meta::CPAN

error.

=item * C<iflast [LABEL] BLOCK [else BLOCK]>

Runs C<BLOCK> only on the last loop iteration; if an C<else> block is present
it runs for not-last iterations.

When C<LABEL> is present, C<iflast> checks that
labeled loop context instead of the
innermost loop.

lib/Loop/Util.pm  view on Meta::CPAN

loops over arrays and lists. Calling C<iflast> in other loop kinds throws a
runtime error.

=item * C<ifodd [LABEL] BLOCK [else BLOCK]>

Runs C<BLOCK> for odd-numbered iterations (1st, 3rd, 5th...).
If an C<else> block is present, it runs on even-numbered iterations.

Note that if you loop through an array, the first iteration (an odd
iteration) has index number 0 (an even number).

When C<LABEL> is present, C<ifodd> checks that

lib/Loop/Util.pm  view on Meta::CPAN

arrays and lists. Calling C<ifodd> in other loop kinds throws a runtime
error.

=item * C<ifeven [LABEL] BLOCK [else BLOCK]>

Runs C<BLOCK> for even-numbered iterations (2nd, 4th, 6th...).
If an C<else> block is present, it runs on odd-numbered iterations.

Note that if you loop through an array, the first iteration (an odd
iteration) has index number 0 (an even number).

When C<LABEL> is present, C<ifeven> checks that

 view release on metacpan or  search on metacpan

test/benchmark/binary_trees.lox  view on Meta::CPAN

print "check:";
print Tree(0, stretchDepth).check();

var longLivedTree = Tree(0, maxDepth);

// iterations = 2 ** maxDepth
var iterations = 1;
var d = 0;
while (d < maxDepth) {
  iterations = iterations * 2;
  d = d + 1;
}

var depth = minDepth;
while (depth < stretchDepth) {
  var check = 0;
  var i = 1;
  while (i <= iterations) {
    check = check + Tree(i, depth).check() + Tree(-i, depth).check();
    i = i + 1;
  }

  print "num trees:";
  print iterations * 2;
  print "depth:";
  print depth;
  print "check:";
  print check;

  iterations = iterations / 4;
  depth = depth + 2;
}

print "long lived tree of depth:";
print maxDepth;

 view release on metacpan or  search on metacpan

t/0009-performance.t  view on Meta::CPAN

        # Warm up
        $inference->forward_simple(\@tokens);
        
        # Benchmark
        my $start = time();
        my $iterations = 5;
        for (1..$iterations) {
            $inference->forward_simple(\@tokens);
        }
        my $elapsed = time() - $start;
        my $avg_ms = ($elapsed / $iterations) * 1000;
        
        ok($avg_ms > 0, "CPU forward pass takes measurable time (avg: ${avg_ms}ms)");
        ok($avg_ms < 10000, "CPU forward pass completes in reasonable time (<10s)");
        diag("CPU forward avg: ${avg_ms}ms per iteration");
    }

t/0009-performance.t  view on Meta::CPAN

        # Warm up
        $inference->forward_simple(\@tokens);
        
        # Benchmark
        my $start = time();
        my $iterations = 5;
        for (1..$iterations) {
            $inference->forward_simple(\@tokens);
        }
        my $elapsed = time() - $start;
        my $avg_ms = ($elapsed / $iterations) * 1000;
        
        ok($avg_ms > 0, "Best backend ($best) forward pass takes measurable time (avg: ${avg_ms}ms)");
        ok($avg_ms < 10000, "Best backend forward pass completes in reasonable time (<10s)");
        diag("Best backend ($best) forward avg: ${avg_ms}ms per iteration");
    }

t/0009-performance.t  view on Meta::CPAN

        my @logits_pool = $inference->forward_pool($pool, \@tokens);
        ok(@logits_pool > 0, 'forward_pool returns logits');
        
        # Multiple passes with same pool (should be efficient)
        my $start = time();
        my $iterations = 5;
        for (1..$iterations) {
            my @logits = $inference->forward_pool($pool, \@tokens);
        }
        my $elapsed = time() - $start;
        my $avg_ms = ($elapsed / $iterations) * 1000;
        
        ok($avg_ms > 0, "forward_pool avg: ${avg_ms}ms");
        ok($pool->reset(), 'Pool reset works');
        diag("Memory pool forward avg: ${avg_ms}ms per iteration");
    }

 view release on metacpan or  search on metacpan

lib/MARC/Detrans/Name.pm  view on Meta::CPAN

=head1 DESCRIPTION

MARC::Detrans::Rule represents a single non-standard detransliteration mapping
for a MARC field. For example personal names often have non-standard 
transliterations, so to get them back to the original script a non-rules based
detransliteration has to occur. 

MARC::Detrans::Name and MARC::Detrans::Names aid in this process by allowing you
to create a single mapping of one field to another, and then adding them to a
rule set.