view release on metacpan or  search on metacpan

ImageMagick.pm  view on Meta::CPAN

    cache-threshold colormap colorspace compression
    debug delay density depth dispose dither display
    endian
    filename file fill font fuzz 
    gravity green-primary
    index iterations interlace
    loop 
    magick mattecolor matte monochrome
    page pen pixel pointsize preview
    quality 
    red_primary render 

ImageMagick.pm  view on Meta::CPAN

font
fuzz
green-primary
index
interlace
iterations
loop
magick
matte
mattecolor
monochrome

 view release on metacpan or  search on metacpan

Skin.pm  view on Meta::CPAN

 __COUNT__ values: 1, 4, 7, 10, etc.

=item __LAST_COL_x__

(1|0) Similar to __FIRST_COL_x__ but given x is 3, __LAST_COL_3__ 
would return 1, on the following iterations: 3, 6, 9, 12, etc.

=item __INNER_COL_x__

If an iteration is not a __FIRST_COL_x__ or a __LAST_COL_x__ it is an __INNER_COL_x__.

Skin.pm  view on Meta::CPAN

A variety of loops are possible, and all can be nested inside of each other for some 
interesting and sometimes useless effects. Note that when looping through a series of 
directories, the current directory context changes. So multiple nested DIRS loops would result
in a directory tree because DIRS loops through the current directory context, and inside 
iterations change that same context.

Valid loop names are:

=over 4

 view release on metacpan or  search on metacpan

lib/Apache/SdnFw/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;

lib/Apache/SdnFw/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/Apache/TestSmoke.pm  view on Meta::CPAN

    my $self = bless {
        seen    => {}, # seen sequences and tried them md5 hash
        results => {}, # final reduced sequences md5 hash
        smoking_completed         => 0,
        tests                     => [],
        total_iterations          => 0,
        total_reduction_attempts  => 0,
        total_reduction_successes => 0,
        total_tests_run           => 0,
    }, ref($class)||$class;

lib/Apache/TestSmoke.pm  view on Meta::CPAN

    my @good = ();

    # first time run all tests, or all specified tests
    my @tests = @{ $self->{tests} }; # copy
    my $bad = $self->run_test($iter, $reduce_iter, \@tests, \@good);
    $self->{total_iterations}++;

}


# returns true if for some reason no more iterations should be made
sub run_iter {
    my($self, $iter) = @_;
    my $stop_now = 0;
    my $reduce_iter = 0;
    my @good = ();

lib/Apache/TestSmoke.pm  view on Meta::CPAN

    # hack to ensure a new random seed is generated
    Apache::TestSort->run(\@tests, $self);

    my $bad = $self->run_test($iter, $reduce_iter, \@tests, \@good);
    unless ($bad) {
        $self->{total_iterations}++;
        return $stop_now;
    }
    error "recorded a positive failure ('$bad'), " .
        "will try to minimize the input now";

lib/Apache/TestSmoke.pm  view on Meta::CPAN

        my $bad = $self->run_test($iter, $reduce_iter, \@tests, \@good);
        # if a test is failing on its own there is no point to
        # continue looking for other sequences
        if ($bad) {
            $stop_now = 1;
            $self->{total_iterations}++;
            unless ($self->sequence_seen($self->{results}, [@good, $bad])) {
                $self->report_success($iter, $reduce_iter, "$command $bad", 1);
            }
            return $stop_now;
        }

lib/Apache/TestSmoke.pm  view on Meta::CPAN

    # we have a minimal failure sequence at this point (to the extend
    # of success of our attempts to reduce)

    # report the sequence if we didn't see such one yet in the
    # previous iterations
    unless ($self->sequence_seen($self->{results}, [@good, $bad])) {
        # if no reduction succeeded, it's 0
        $reduce_iter = 0 unless $reduction_success;
        $self->report_success($iter, $reduce_iter,
                              "$command @good $bad", @good + 1);
    }

    $self->{total_iterations}++;

    return $stop_now;
}

# my $sub = $self->reduce_stream(\@items);

lib/Apache/TestSmoke.pm  view on Meta::CPAN

        my $completion    = $self->{smoking_completed}
            ? "Completed"
            : "Not Completed (aborted by user)";

        my $status = "Unknown";
        if ($self->{total_iterations} > 0) {
            if ($failures) {
                $status = "*** NOT OK ***";
            }
            else {
                $status = "+++ OK +++";

lib/Apache/TestSmoke.pm  view on Meta::CPAN

        }

        my $title = sep('=', "Summary");

        my $iter_made = sprintf "Iterations (%s) made : %d",
            $self->{order}, $self->{total_iterations};

        print $fh <<EOM;

$title
Completion               : $completion

lib/Apache/TestSmoke.pm  view on Meta::CPAN

  # repeat all tests 5 times and save the report into
  # the file 'myreport'
  % t/SMOKE -times=5 -report=myreport

  # run all tests default number of iterations, and repeat tests
  # default number of times
  % t/SMOKE

  # same as above but work only the specified tests
  % t/SMOKE foo/bar foo/tar

 view release on metacpan or  search on metacpan

lib/Apache2/API.pm  view on Meta::CPAN

    }

    # 16 bytes
    my $final = $ctx->digest;

    # 5) 1000 iterations "rounds"
    for( my $i = 0; $i < 1000; $i++ )
    {
        my $t = Digest::MD5->new;

        eval

 view release on metacpan or  search on metacpan

lib/HTTPD/Bench/ApacheBench.pm  view on Meta::CPAN

=item $i = $run->iteration( $iter_no )

Return a regression object specific to iteration $iter_no of this run.
If $iter_no is not given, it assumes 0, or the first iteration of the run.
The number of iterations for the run can be retrieved with $run->repeat().

=item $i->connect_times( $url_no )

Returns the connection time, in milliseconds, for the URL specified by $url_no.

 view release on metacpan or  search on metacpan

lib/App/Benchmark/Accessors.pm  view on Meta::CPAN

Not every benchmark is run on every module; for example, L<Object::Tiny>
doesn't create setter methods, and L<accessors> doesn't generate constructors.

Each benchmark test file takes an optional numeric parameter that is used as
the number of iterations.

It's probably a good idea not to read too much into these benchmarks; they
could be seen as micro-optimization. However, if you have a complex object
hierarchy and create lots of objects and run many many getters/setters on
them, they could help to save some time. But be sure to use L<Devel::NYTProf>

 view release on metacpan or  search on metacpan

lib/App/Benchmark.pm  view on Meta::CPAN

use Exporter qw(import);
our $VERSION = '2.00';
our @EXPORT  = qw(benchmark_diag);

sub benchmark_diag {
    my ($iterations, $benchmark_hash) = @_;
    my $stdout = capture {
        cmpthese(timethese($iterations, $benchmark_hash));
    };
    diag $stdout;
    plan tests => 1;
    pass('benchmark');
}

lib/App/Benchmark.pm  view on Meta::CPAN

=head1 FUNCTIONS

=head2 benchmark_diag

Takes a number of iterations and a benchmark definition hash, just like
C<timethese()> from the L<Benchmark> module. Runs the benchmarks and reports
them, each line prefixed by a hash sign so it doesn't mess up the TAP output.
Also, a dummy test is being generated to keep the testing framework happy.

This function is exported automatically.

 view release on metacpan or  search on metacpan

lib/App/Bernard.pm  view on Meta::CPAN

=head2 gnome

In this mode, the sole non-option argument should be
the name of a Shavian .po file.  The master template
for that package will be downloaded and merged with
the .po file, the transliterations will be updated,
and then run through C<msgfmt -c> to check them.

Alternatively, the non-option argument may be the
name of a directory.  Each subdirectory of this
directory should contain a GNOME package, which

 view release on metacpan or  search on metacpan

lib/App/BorgRestore/PathTimeTable/DB.pm  view on Meta::CPAN

	# We start by checking the currently cached path ($old_cache_path) against
	# the new $path. Then we remove one part from the path at a time, until we
	# reach a parent path (directory) of $path.
	$log->tracef("Checking if cache invalidation is required") if TRACE;
	while ((my $slash_index = rindex($old_cache_path, "/")) != -1) {
		$self->{stats}->{cache_invalidation_loop_iterations}++;
		# Directories in the borg output cannot be differentiated by their
		# path, since their path looks just like a file path. I.e. there is no
		# directory separator (/) at the end of a directory path.
		#
		# Since we want to keep any directory in our cache, if it contains

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

 view release on metacpan or  search on metacpan

cheats.txt  view on Meta::CPAN

const endTime = new Date().getTime();
console.log("sort function took " + (endTime-startTime) + "(ms)")

# Function for benchmarking different code snippets (timing,testing,profiling)
# Simple.
function benchmark(functions,iterations=1) {
  for(const code of functions){ // foreach loop in javascript
    const name = code.name;     // Code refence to name
    console.time(name);         // Timing/benchmarking function
    for(let i = 1; i <= iterations; i++ )
      code();
    console.timeEnd(name);
  }
}
# Usage

cheats.txt  view on Meta::CPAN

# Function for benchmarking different code snippets (timing,testing,profiling)
# Includes percentages and sorted.
// function benchmark() {
//   // Get inputs
//   let   code_refs  = [...arguments];
//   let   iterations = 1;
//   const last_index = code_refs.length - 1;
//
//   // Check last input
//   if(typeof(code_refs[last_index]) == "number")
//     iterations = code_refs.pop();
//
//   // Check for tests
//   if(!code_refs.length)
//     return;
//
//   const stats = [];
//
//   // Get statistics
//   for(const code of code_refs){           // foreach loop in javascript
//     const t0 = performance.now();         // High precision time
//     for(let i = 1; i <= iterations; i++ ) // Run a specified amount of times
//       code();
//     const time = (performance.now()-t0).toFixed(2);
//     stats.push({name: _get_code_name(code), time: time});
//   }
//

cheats.txt  view on Meta::CPAN

            tr///cs;
            $_;
        }
    }, 1000000
'
            (warning: too few iterations for a reliable count)
        Rate    s   tr
s  1408451/s   -- -70%
tr 4761905/s 238%   --

# Comparing different ways in perl to combine hashes.

 view release on metacpan or  search on metacpan

share/status/app/lib/angular/angular.js  view on Meta::CPAN

      * @description
      * Angular's wrapper for `window.setInterval`. The `fn` function is executed every `delay`
      * milliseconds.
      *
      * The return value of registering an interval function is a promise. This promise will be
      * notified upon each tick of the interval, and will be resolved after `count` iterations, or
      * run indefinitely if `count` is not defined. The value of the notification will be the
      * number of iterations that have run.
      * To cancel an interval, call `$interval.cancel(promise)`.
      *
      * In tests you can use {@link ngMock.$interval#methods_flush `$interval.flush(millis)`} to
      * move forward by `millis` milliseconds and trigger any functions scheduled to run in that
      * time.

share/status/app/lib/angular/angular.js  view on Meta::CPAN

 * @ngdoc function
 * @name ng.$rootScopeProvider#digestTtl
 * @methodOf ng.$rootScopeProvider
 * @description
 *
 * Sets the number of `$digest` iterations the scope should attempt to execute before giving up and
 * assuming that the model is unstable.
 *
 * The current default is 10 iterations.
 *
 * In complex applications it's possible that the dependencies between `$watch`s will result in
 * several digest iterations. However if an application needs more than the default 10 digest
 * iterations for its model to stabilize then you should investigate what is causing the model to
 * continuously change during the digest.
 *
 * Increasing the TTL could have performance implications, so you should not change it without
 * proper justification.
 *
 * @param {number} limit The number of digest iterations.
 */


/**
 * @ngdoc object

share/status/app/lib/angular/angular.js  view on Meta::CPAN

       * Processes all of the {@link ng.$rootScope.Scope#methods_$watch watchers} of the current scope and
       * its children. Because a {@link ng.$rootScope.Scope#methods_$watch watcher}'s listener can change
       * the model, the `$digest()` keeps calling the {@link ng.$rootScope.Scope#methods_$watch watchers}
       * until no more listeners are firing. This means that it is possible to get into an infinite
       * loop. This function will throw `'Maximum iteration limit exceeded.'` if the number of
       * iterations exceeds 10.
       *
       * Usually, you don't call `$digest()` directly in
       * {@link ng.directive:ngController controllers} or in
       * {@link ng.$compileProvider#methods_directive directives}.
       * Instead, you should call {@link ng.$rootScope.Scope#methods_$apply $apply()} (typically from within

share/status/app/lib/angular/angular.js  view on Meta::CPAN

          // `break traverseScopesLoop;` takes us to here

          if(dirty && !(ttl--)) {
            clearPhase();
            throw $rootScopeMinErr('infdig',
                '{0} $digest() iterations reached. Aborting!\n' +
                'Watchers fired in the last 5 iterations: {1}',
                TTL, toJson(watchLog));
          }

        } while (dirty || asyncQueue.length);

 view release on metacpan or  search on metacpan

share/sample0.txt  view on Meta::CPAN

mutts xylotomies remained gibbsite greenhorns elds outrated interstate wattages siziness savarin waterways plasmaphereses automatizes shelved timberman theatricalisms dismantling encyclopedisms neurologically doomsdayer cormel laicises rawins transdu...
instillments ganofs interlayer chowder putt coagulates frowzily emeerate vascular unpatentable cyphers outgnaws tributes sautoir demineralizer cadmium wantage neap glycosylated palingenesis doglegging preferring sponginess formulary pyrolize lengthen...
futurelessness thorned nonhunter robands scholastics haha jokesters fideists plonks tunelessly patience felspar mythoi euglobulin diminish orismology cleanups juristic epoxidizing kaif numbered saturated palpitates overlived replanning maced scaup vi...
arquebus challenged bevellers oversup lychee unsterilized instauration exospheric smashing polynyas cineasts excursivenesses exsertile tabetics springwaters bumptiously delectable microphotometer nonconsumers overelaborates latchstring kernels serran...
carcanets inditers astomous megadose underground potzer torrefying odd cloudinesses knucklebones runniest nonoverlappings purpleheart transitoriness roughdries outsinned buttinskies mercerises worthinesses ascitic invisibility dice determiner pigskin...
lechwes outspell seadog shieling deadeyes unluckiness alliterations corkwoods splenic restock diaphragmatic brandished amoretti guileful confiscated skilless tablesful incurred register zarebas pardahs bandoliers mayoralty minoring plexal hobbledehoy...
toolmakers schismatical parricides offenders refined mainstream hobnailing wretchedly pyranosides arugola deflowerer reconceptualization medusoid prefigures avalanching proportionally ephemerid tilted marching miscellanies chivarees interinvolving cr...
salience trembles superindividual translated helicoptering floc gets cochineal casefying minestrone currant lookalikes ammoniac claddings rehardening balder micrographically seminarian protocols rower substantives overcold propagandizer giglots foame...
traditor neglectfully knockers pool ravelling confessionalism cresset bullterrier carioles replenished discourageable antiabortion java uncivilized wearingly outpopulating careered imperiled opiates cicatrized convening fissipeds jupe reconversions i...
crematories savoriest titlarks rejiggers immature lobbyisms greenmailer dipsomaniacs flackery experimented liturgist ricer sargassums unaddressed female tables paratrooper rams hammerers antacid regrating photomontage immaturities latewood filaria di...
women intarsias exploder onboard caseated jazzily ancientness whomps blackcock delusters brills frenula cephalosporins resurface rhetors generosities dewool quaternions repacifies inscroll stereopsis coenzyme opossum caressingly tartar zincous pyrans...

 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/App/GUI/Juliagraph.pm  view on Meta::CPAN

C<z_n+1 = z_n ** 2 + C> behaves on the complex plane.
Our running variable gets an initial value and gets squared each time,
plus an constant is added, also each time. Mandelbrot mean this constant
are the pixel coordinates, Julia means the coordinates are the starting
value. And the pixel color just contains the information how many
iterations (times) it took until z got greater than our bailout value.

=for HTML <p>
<img src="https://raw.githubusercontent.com/lichtkind/App-GUI-Juliagraph/master/img/examples/first.png"         alt=""  width="300" height="300">
<img src="https://raw.githubusercontent.com/lichtkind/App-GUI-Juliagraph/master/img/examples/first_detail.png"  alt=""  width="300" height="300">
<img src="https://raw.githubusercontent.com/lichtkind/App-GUI-Juliagraph/master/img/examples/feingoldkreutz.png"alt=""  width="300" height="300">

lib/App/GUI/Juliagraph.pm  view on Meta::CPAN

chosen the constant or starting value is then the sum of pixel coordinates
with the displayed value.

The fifth section holds all values that determine the end of the computation
on one spot. There are two conditions that can trigger that. Either you run
out of iterations (exceeded the maximal interation I<count>). Please note,
that the actual number is the displayed number squared. This gives you a
wider range eof options and a little more comfort while changing the value.
When the computation runs out of iterations, the current pixel will get
the background  color. The second stop criterion is fulfilled when
the value exceeds the bailout limit (I<Value>), which is also the displayed
number squared. In the right corner you got ten different ways how to compute
the amount of z. Mathematicians call them merics. They mostly influence
the shape around the main shape (the crwon - corona).

 view release on metacpan or  search on metacpan

script/kgb-bot  view on Meta::CPAN

use Storable qw(dclone);

our %current = ();
our $irc_object;
our $autoresponse_limitter
    = Schedule::RateLimiter->new( iterations => 5, seconds => 30,
    block => 0 );

# Monkey patch to avoid delaying high priority commands when flood protection
# is enabled.
sub _sl_delayed {

 view release on metacpan or  search on metacpan

lib/App/Lingua/BO/Wylie/Transliteration.pm  view on Meta::CPAN

=back

Classical Tibetan alphabet itself works in a really interesting way.

First, let's have a look at the table of the individual "characters"
with their Wylie transliterations:

E<lt>http:E<sol>E<sol>en.wikipedia.orgE<sol>wikiE<sol>Tibetan_alphabetE<gt>

A few key observations:

 view release on metacpan or  search on metacpan

share/public_html/static/music_inc/src/miniaudio.h  view on Meta::CPAN

                                availableBytesPlayback  = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - virtualWriteCursorInBytesPlayback;
                                availableBytesPlayback += physicalPlayCursorInBytes;    /* Wrap around. */
                            } else {
                                /* This is an error. */
                            #ifdef MA_DEBUG_OUTPUT
                                printf("[DirectSound] (Duplex/Playback) WARNING: Play cursor has moved in front of the write cursor (same loop iterations). physicalPlayCursorInBytes=%ld, virtualWriteCursorInBytes=%ld.\n", physicalPlayCursorInBytes, v...
                            #endif
                                availableBytesPlayback = 0;
                            }
                        } else {
                            /* Different loop iterations. The available bytes only goes from the virtual write cursor to the physical play cursor. */
                            if (physicalPlayCursorInBytes >= virtualWriteCursorInBytesPlayback) {
                                availableBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
                            } else {
                                /* This is an error. */
                            #ifdef MA_DEBUG_OUTPUT
                                printf("[DirectSound] (Duplex/Playback) WARNING: Write cursor has moved behind the play cursor (different loop iterations). physicalPlayCursorInBytes=%ld, virtualWriteCursorInBytes=%ld.\n", physicalPlayCursorInBytes, v...
                            #endif
                                availableBytesPlayback = 0;
                            }
                        }

share/public_html/static/music_inc/src/miniaudio.h  view on Meta::CPAN

                        lockOffsetInBytesPlayback = virtualWriteCursorInBytesPlayback;
                        if (physicalPlayCursorLoopFlagPlayback == virtualWriteCursorLoopFlagPlayback) {
                            /* Same loop iteration. Go up to the end of the buffer. */
                            lockSizeInBytesPlayback = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - virtualWriteCursorInBytesPlayback;
                        } else {
                            /* Different loop iterations. Go up to the physical play cursor. */
                            lockSizeInBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
                        }

                        hr = ma_IDirectSoundBuffer_Lock((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, lockOffsetInBytesPlayback, lockSizeInBytesPlayback, &pMappedDeviceBufferPlayback, &mappedSizeInBytesPlayback, NULL, NULL, 0);
                        if (FAILED(hr)) {

share/public_html/static/music_inc/src/miniaudio.h  view on Meta::CPAN

                        availableBytesPlayback  = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - virtualWriteCursorInBytesPlayback;
                        availableBytesPlayback += physicalPlayCursorInBytes;    /* Wrap around. */
                    } else {
                        /* This is an error. */
                    #ifdef MA_DEBUG_OUTPUT
                        printf("[DirectSound] (Playback) WARNING: Play cursor has moved in front of the write cursor (same loop iterations). physicalPlayCursorInBytes=%ld, virtualWriteCursorInBytes=%ld.\n", physicalPlayCursorInBytes, virtualWriteCurs...
                    #endif
                        availableBytesPlayback = 0;
                    }
                } else {
                    /* Different loop iterations. The available bytes only goes from the virtual write cursor to the physical play cursor. */
                    if (physicalPlayCursorInBytes >= virtualWriteCursorInBytesPlayback) {
                        availableBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
                    } else {
                        /* This is an error. */
                    #ifdef MA_DEBUG_OUTPUT
                        printf("[DirectSound] (Playback) WARNING: Write cursor has moved behind the play cursor (different loop iterations). physicalPlayCursorInBytes=%ld, virtualWriteCursorInBytes=%ld.\n", physicalPlayCursorInBytes, virtualWriteCurs...
                    #endif
                        availableBytesPlayback = 0;
                    }
                }

share/public_html/static/music_inc/src/miniaudio.h  view on Meta::CPAN

                lockOffsetInBytesPlayback = virtualWriteCursorInBytesPlayback;
                if (physicalPlayCursorLoopFlagPlayback == virtualWriteCursorLoopFlagPlayback) {
                    /* Same loop iteration. Go up to the end of the buffer. */
                    lockSizeInBytesPlayback = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - virtualWriteCursorInBytesPlayback;
                } else {
                    /* Different loop iterations. Go up to the physical play cursor. */
                    lockSizeInBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
                }

                hr = ma_IDirectSoundBuffer_Lock((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, lockOffsetInBytesPlayback, lockSizeInBytesPlayback, &pMappedDeviceBufferPlayback, &mappedSizeInBytesPlayback, NULL, NULL, 0);
                if (FAILED(hr)) {

share/public_html/static/music_inc/src/miniaudio.h  view on Meta::CPAN

                        availableBytesPlayback += physicalPlayCursorInBytes;    /* Wrap around. */
                    } else {
                        break;
                    }
                } else {
                    /* Different loop iterations. The available bytes only goes from the virtual write cursor to the physical play cursor. */
                    if (physicalPlayCursorInBytes >= virtualWriteCursorInBytesPlayback) {
                        availableBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
                    } else {
                        break;
                    }

 view release on metacpan or  search on metacpan

script/mowyw  view on Meta::CPAN

Data sources are handled via plugins. Currently XML and DBI are supported.

The XML source is explained by the example above. The only additional option
is 'limit', which can be set to a positive number and which limits the number
of iterations. This plugin is quite limited in that the file structure always
has be the
same: one root tag that contains a list of secondary tags, each of which many
only contain distinct tags. Nested tags might work, but aren't officially
supported.

 view release on metacpan or  search on metacpan

public/javascripts/ace/mode-php.js  view on Meta::CPAN

imagick_getimagechannelrange|imagick_getimagechannelstatistics|imagick_getimageclipmask|imagick_getimagecolormapcolor|\
imagick_getimagecolors|imagick_getimagecolorspace|imagick_getimagecompose|imagick_getimagecompression|imagick_getimagecompressionquality|\
imagick_getimagedelay|imagick_getimagedepth|imagick_getimagedispose|imagick_getimagedistortion|imagick_getimageextrema|\
imagick_getimagefilename|imagick_getimageformat|imagick_getimagegamma|imagick_getimagegeometry|imagick_getimagegravity|\
imagick_getimagegreenprimary|imagick_getimageheight|imagick_getimagehistogram|imagick_getimageindex|imagick_getimageinterlacescheme|\
imagick_getimageinterpolatemethod|imagick_getimageiterations|imagick_getimagelength|imagick_getimagemagicklicense|imagick_getimagematte|\
imagick_getimagemattecolor|imagick_getimageorientation|imagick_getimagepage|imagick_getimagepixelcolor|imagick_getimageprofile|\
imagick_getimageprofiles|imagick_getimageproperties|imagick_getimageproperty|imagick_getimageredprimary|imagick_getimageregion|\
imagick_getimagerenderingintent|imagick_getimageresolution|imagick_getimagesblob|imagick_getimagescene|imagick_getimagesignature|\
imagick_getimagesize|imagick_getimagetickspersecond|imagick_getimagetotalinkdensity|imagick_getimagetype|imagick_getimageunits|\
imagick_getimagevirtualpixelmethod|imagick_getimagewhitepoint|imagick_getimagewidth|imagick_getinterlacescheme|imagick_getiteratorindex|\

public/javascripts/ace/mode-php.js  view on Meta::CPAN

imagick_setimageartifact|imagick_setimagebackgroundcolor|imagick_setimagebias|imagick_setimageblueprimary|imagick_setimagebordercolor|\
imagick_setimagechanneldepth|imagick_setimageclipmask|imagick_setimagecolormapcolor|imagick_setimagecolorspace|imagick_setimagecompose|\
imagick_setimagecompression|imagick_setimagecompressionquality|imagick_setimagedelay|imagick_setimagedepth|imagick_setimagedispose|\
imagick_setimageextent|imagick_setimagefilename|imagick_setimageformat|imagick_setimagegamma|imagick_setimagegravity|\
imagick_setimagegreenprimary|imagick_setimageindex|imagick_setimageinterlacescheme|imagick_setimageinterpolatemethod|\
imagick_setimageiterations|imagick_setimagematte|imagick_setimagemattecolor|imagick_setimageopacity|imagick_setimageorientation|\
imagick_setimagepage|imagick_setimageprofile|imagick_setimageproperty|imagick_setimageredprimary|imagick_setimagerenderingintent|\
imagick_setimageresolution|imagick_setimagescene|imagick_setimagetickspersecond|imagick_setimagetype|imagick_setimageunits|\
imagick_setimagevirtualpixelmethod|imagick_setimagewhitepoint|imagick_setinterlacescheme|imagick_setiteratorindex|imagick_setlastiterator|\
imagick_setoption|imagick_setpage|imagick_setpointsize|imagick_setresolution|imagick_setresourcelimit|imagick_setsamplingfactors|\
imagick_setsize|imagick_setsizeoffset|imagick_settype|imagick_shadeimage|imagick_shadowimage|imagick_sharpenimage|imagick_shaveimage|\

 view release on metacpan or  search on metacpan

share/public/javascripts/d3-force-network-chart.js  view on Meta::CPAN

        }
        return graph;
    };

    /**
     * The number of iterations for the preventLabelOverlappingOnForceEnd option - default is 250 - as higher the number, as higher the quality of the result. For details refer to the [description of the simulated annealing function of the author Eva...
     *
     *     example.preventLabelOverlappingOnForceEnd(true).resume();
     * @see {@link module:API.labelPlacementIterations}
     * @param {number} [value=250] - The new config value.
     * @returns {(number|Object)} The current config value if no parameter is given or the graph object for method chaining.

 view release on metacpan or  search on metacpan

lib/App/PasswordManager.pm  view on Meta::CPAN

    my $file     = File::Spec->catfile( $home_dir, '.password_manager.json' );

    my $self = {
        pbkdf2     => Crypt::PBKDF2->new(
            hash_class => 'HMACSHA1',
            iterations => 10000,
            salt_len   => 10,
        ),
        data_file  => $args{file} || $file,
        salt       => 42,
        passwords  => {},

 view release on metacpan or  search on metacpan

lib/App/Physics/ParticleMotion.pm  view on Meta::CPAN

	# Starting time and time steps. $dt will be adjusted by the integrator
	my $t = 0;
	my $dt = 0.1;

    # @prevlines holds line objects from the previous iterations.
    my @prevlines = ();

    # Previous values for line drawing
    my @prev_x = ();
    my @prev_y = ();

 view release on metacpan or  search on metacpan

t/cpan/ojo.pm  view on Meta::CPAN

=head2 n

  n {...};
  n {...} 100;

Benchmark block and print the results to C<STDERR>, with an optional number of iterations, which defaults to C<1>.

  $ perl -Mojo -E 'n { say g("mojolicious.org")->code }'

=head2 o

 view release on metacpan or  search on metacpan

lib/App/Raider.pm  view on Meta::CPAN

  - bash(command, [working_directory], [timeout])
  - web_search(query, [limit])
  - web_fetch(url, [as_html])

How you work:
  - User turn = task. Pursue with tools until done. Unlimited iterations.
  - Read before write. No guessing file contents.
  - After write_file / edit_file: verify. Re-read, or run check (perl -c,
    tests, etc.).
  - Small targeted edits > full rewrites.
  - bash is full shell, not sandbox. Use freely.

lib/App/Raider.pm  view on Meta::CPAN

  isa       => 'ArrayRef[Str]',
  predicate => 'has_allowed_commands',
);


has max_iterations => (
  is      => 'ro',
  isa     => 'Int',
  default => 10_000,
);

lib/App/Raider.pm  view on Meta::CPAN

  }
  push @plugins, '+App::Raider::Plugin::Situation';
  return Langertha::Raider->new(
    engine                     => $self->_engine,
    mission                    => $self->mission,
    max_iterations             => $self->max_iterations,
    max_context_tokens         => $self->max_context_tokens,
    context_compress_threshold => $self->context_compress_threshold,
    (@plugins ? (plugins => \@plugins) : ()),
  );
}

lib/App/Raider.pm  view on Meta::CPAN

=head2 allowed_commands

Optional arrayref restricting which bash commands may run (first word match).
When undef, any command is allowed.

=head2 max_iterations

Maximum tool-calling iterations per raid. Defaults to 10_000 — effectively
unlimited, so a raid only ends when the model itself stops emitting tool
calls. The conversation history is preserved between raids, so the next user
message in the REPL simply continues the same thread.

Set this to a smaller number if you want a hard safety cap.

 view release on metacpan or  search on metacpan

lib/App/SeismicUnixGui/geopsy/dinver.pm  view on Meta::CPAN

                            '-param' and '-target'.
  -param <PARAM>            Set parameters from file PARAM. It can be a .param
                            or a .dinver file. A .dinver file contains both
                            parameters and targets. Provide it to both options
                            '-param' and '-target'.
  -itmax <ITMAX>            Number of iterations started by option -run
                            (default=50).
  -ns0 <NS0>                Number of initial models (default=50).
  -ns <NS>                  Number of models generated (default=50).
  -nr <NR>                  Number of best cells (default=50).
  -seed <SEED>              Set random seed to SEED. This option is for debug

lib/App/SeismicUnixGui/geopsy/dinver.pm  view on Meta::CPAN

  -f                        Force overwrite if output report already exists.
  -resume                   If the output report file already exists, it is
                            imported into the parameter space before starting
                            the inversion. Better to set NS0 to zero in this
                            case. This way, it is possible to continue an
                            existing inversion adding new iterations.

Importance sampling options:
  -dof <DOF>                Set degrees of freedom for conversion from misfit
                            to a posteriori probability function.
  -param <PARAM>            Set parameters from file PARAM. It can be a .param

lib/App/SeismicUnixGui/geopsy/dinver.pm  view on Meta::CPAN

=pod

=head2 Subroutine itmax

	Number of iterations for inversion to run
	0 iterations = Pure Monte Carlo

=cut

sub itmax {
    my ( $sub, $itmax ) = @_;

lib/App/SeismicUnixGui/geopsy/dinver.pm  view on Meta::CPAN

=head2 Subroutine resume

	If output file already exists, it is improted before starting inversion
	Safer to set ns0 -> 0 for this case
	Adds new iterations to existing inversion

=cut

sub resume {
    my ( $sub, $resume ) = @_;

 view release on metacpan or  search on metacpan

share/public/highlight/highlight.min.js  view on Meta::CPAN

d(),i.returnBegin||i.excludeBegin||(S=t)),h(i,e),i.returnBegin?0:t.length})(s)
;if("illegal"===s.type&&!r){
const e=Error('Illegal lexeme "'+a+'" for mode "'+(N.scope||"<unnamed>")+'"')
;throw e.mode=N,e}if("end"===s.type){const e=b(s);if(e!==ee)return e}
if("illegal"===s.type&&""===a)return 1
;if(A>1e5&&A>3*s.index)throw Error("potential infinite loop, way more iterations than matches")
;return S+=a,a.length}const y=O(e)
;if(!y)throw K(a.replace("{}",e)),Error('Unknown language: "'+e+'"')
;const _=V(y);let v="",N=s||_;const k={},M=new g.__emitter(g);(()=>{const e=[]
;for(let t=N;t!==y;t=t.parent)t.scope&&e.unshift(t.scope)
;e.forEach((e=>M.openNode(e)))})();let S="",R=0,j=0,A=0,I=!1;try{