Result:
found more than 872 distributions - search limited to the first 2001 files matching your query
( run in 1.999 )
MCDB_File
view release on metacpan or search on metacpan
MCDB_File.pm view on Meta::CPAN
After the C<tie> shown above, accesses to C<%h> will refer
to the B<mcdb> file C<file.mcdb>, as described in L<perlfunc/tie>.
C<keys>, C<values>, and C<each> can be used to iterate through records.
Note that only one iteration loop can be in progress at any one time.
Performing multiple iterations at the same time (i.e. in nested loops)
will not have independent iterators and therefore should be avoided.
Note that it is safe to use the find('key') method while iterating.
See PERFORMANCE section below for sample usage.
=head2 Creating an mcdb constant database
MCP-K8s
view release on metacpan or search on metacpan
examples/raider-configmap-demo.pl view on Meta::CPAN
# ── Raider ───────────────────────────────────────────────────────────
my $iteration_t0;
my $raider = Langertha::Raider->new(
engine => $engine,
max_iterations => 15,
on_iteration => sub {
my ($raider, $iteration) = @_;
# Show timing for previous iteration
if ($iteration_t0 && $iteration > 2) {
examples/raider-configmap-demo.pl view on Meta::CPAN
banner("Session Metrics");
my $m = $raider->metrics;
label("Total time:", fmt_ms($raid_elapsed));
label("Iterations:", $m->{iterations});
label("Tool calls:", $m->{tool_calls});
if ($raider->has_last_prompt_tokens) {
label("Last prompt tokens:", $raider->_last_prompt_tokens);
}
MCP-Run
view release on metacpan or search on metacpan
.claude/skills/perl-mcp/SKILL.md view on Meta::CPAN
# 4b. Or Raider for multi-turn
my $raider = Langertha::Raider->new(
engine => $engine,
mission => 'You are a calculator.',
max_iterations => 10,
);
my $result = await $raider->raid_f('Add 42 and 17');
}
main()->get;
MHFS-XS
view release on metacpan or search on metacpan
miniaudio/miniaudio.h view on Meta::CPAN
}
MA_API ma_result ma_slot_allocator_alloc(ma_slot_allocator* pAllocator, ma_uint64* pSlot)
{
ma_uint32 iAttempt;
const ma_uint32 maxAttempts = 2; /* The number of iterations to perform until returning MA_OUT_OF_MEMORY if no slots can be found. */
if (pAllocator == NULL || pSlot == NULL) {
return MA_INVALID_ARGS;
}
miniaudio/miniaudio.h view on Meta::CPAN
/* This is an error. */
ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[DirectSound] (Duplex/Playback): Play cursor has moved in front of the write cursor (same loop iteration). physicalPlayCursorInBytes=%ld, virtualWriteCurs...
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. */
ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[DirectSound] (Duplex/Playback): Write cursor has moved behind the play cursor (different loop iterations). physicalPlayCursorInBytes=%ld, virtualWriteCur...
availableBytesPlayback = 0;
}
}
/* If there's no room available for writing we need to wait for more. */
miniaudio/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)) {
miniaudio/miniaudio.h view on Meta::CPAN
if (physicalPlayCursorInBytes <= virtualWriteCursorInBytesPlayback) {
availableBytesPlayback = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - virtualWriteCursorInBytesPlayback;
availableBytesPlayback += physicalPlayCursorInBytes; /* Wrap around. */
} else {
/* This is an error. */
ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[DirectSound] (Playback): Play cursor has moved in front of the write cursor (same loop iterations). physicalPlayCursorInBytes=%ld, virtualWriteCursorInBytes=%ld....
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. */
ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[DirectSound] (Playback): Write cursor has moved behind the play cursor (different loop iterations). physicalPlayCursorInBytes=%ld, virtualWriteCursorInBytes=%ld....
availableBytesPlayback = 0;
}
}
/* If there's no room available for writing we need to wait for more. */
miniaudio/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)) {
miniaudio/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;
}
miniaudio/miniaudio.h view on Meta::CPAN
MA_AT_END. To loop back to the start, all we need to do is seek back to the first frame.
*/
if (result == MA_AT_END) {
/*
The result needs to be reset back to MA_SUCCESS (from MA_AT_END) so that we don't
accidentally return MA_AT_END when data has been read in prior loop iterations. at the
end of this function, the result will be checked for MA_SUCCESS, and if the total
number of frames processed is 0, will be explicitly set to MA_AT_END.
*/
result = MA_SUCCESS;
miniaudio/miniaudio.h view on Meta::CPAN
{
MA_ASSERT(pInputBus != NULL);
MA_ASSERT(pOutputBus != NULL);
/*
Mark the output bus as detached first. This will prevent future iterations on the audio thread
from iterating this output bus.
*/
ma_node_output_bus_set_is_attached(pOutputBus, MA_FALSE);
/*
MILA-Transliterate
view release on metacpan or search on metacpan
lib/MILA/Transliterate.pm view on Meta::CPAN
our @ISA = qw(Exporter);
our @EXPORT_OK = qw(hebrew2treebank treebank2hebrew hebrew2erel erel2hebrew hebrew2fsma fsma2hebrew);
our $VERSION = 0.01;
=head1 NAME
MILA::Transliterate - A Perl Module for transliterating text from Hebrew to various transliterations used in the Knowledge Center for Processing Hebrew (MILA) and vise versa
=head1 SYNOPSIS
use MILA::Transliterate qw((hebrew2treebank hebrew2erel hebrew2fsma);
my $erel_transliterated = hebrew2erel($utf8_encoded_hebrew_text);
MIME-Lite-Generator
view release on metacpan or search on metacpan
t/02_generate.t view on Meta::CPAN
$gen_data .= $$str;
$i++;
}
is(trim $gen_data, trim $msg->as_string, 'simple msg - ' . $encoding);
ok($i > 1, 'simple msg generated in several iterations - ' . $encoding);
}
for my $encoding (qw/BINARY 8BIT 7BIT QUOTED-PRINTABLE BASE64/) {
my $msg = MIME::Lite->new(
From => 'me@myhost.com',
MIME-tools
view release on metacpan or search on metacpan
helpful input.* *Thanks to Klaus Seidenfaden for good feedback on
5.x Alpha!*
Version 4.123 (1999/05/12)
Cleaned up some of the tests for non-Unix OS'es. Will require a few
iterations, no doubt.
Version 4.122 (1999/02/09)
Resolved CORE::open warnings for 5.005. *Thanks to several folks for
this bug report.*
MR-Tarantool
view release on metacpan or search on metacpan
lib/MR/IProto/Connection/Async.pm view on Meta::CPAN
my $callbacks = $self->_callbacks;
for( 1 .. 50 ) {
$sync = $self->$orig();
return $sync unless exists $callbacks->{$sync};
}
die "Can't choose sync value after 50 iterations";
};
sub Close { die "This is not what should be done" }
=back
MRS-Client
view release on metacpan or search on metacpan
lib/MRS/Client/blast.result.xml.template view on Meta::CPAN
<Parameters_gap-open>${PARGAPOPEN}</Parameters_gap-open>
<Parameters_gap-extend>${PARGAPEXTEND}</Parameters_gap-extend>
${PARFILTER}
</Parameters>
</BlastOutput_param>
<BlastOutput_iterations>
<Iteration>
<Iteration_iter-num>1</Iteration_iter-num>
<Iteration_hits>$$HITSTART
<Hit>
<Hit_num>${HITNR}</Hit_num>
lib/MRS/Client/blast.result.xml.template view on Meta::CPAN
<Statistics_lambda>${LAMBDA}</Statistics_lambda>
<Statistics_entropy>${ENTROPY}</Statistics_entropy>
</Statistics>
</Iteration_stat>
</Iteration>
</BlastOutput_iterations>
</BlastOutput>
Mac-Glue
view release on metacpan or search on metacpan
}
#=============================================================================#
# merge additions, dialect, and glue classes together
# wow, this is ugly. i wonder if there is a better/faster way. probably.
# or maybe a way to cache the results between iterations ... ?
# but then, how do we deal with added/removed classes?
sub _merge_classes {
my($db) = @_;
if (!exists $MERGEDCLASSES->{ $db->{ID} }) {
because the glue structures need to be loaded in. However, once a
script has started, a difference in speed from the raw interfaces should
be minimal (though not a lot of testing has been done on that). With the
code above, on a PowerBook G3/292, running Mac OS 8.6:
Benchmark: timing 100 iterations of glue, glue2, raw, simple...
glue: 10 secs ( 9.98 usr 0.00 sys = 9.98 cpu)
glue2: 8 secs ( 8.35 usr 0.00 sys = 8.35 cpu)
raw: 8 secs ( 7.88 usr 0.00 sys = 7.88 cpu)
simple: 7 secs ( 7.50 usr 0.00 sys = 7.50 cpu)
Mac-PopClip-Quick
view release on metacpan or search on metacpan
--blank-lines-before-packages=0
--iterations=2
--no-outdent-long-comments
-b
-bar
-boc
-ci=4
Mail-SpamAssassin
view release on metacpan or search on metacpan
lib/Mail/SpamAssassin/DnsResolver.pm view on Meta::CPAN
foreach my $bucket (0..255) {
# find the bucket containing n-th turned-on bit
my $cnt = $bucket_counts_ref->[$bucket];
if ($cnt > $n) { last } else { $n -= $cnt; $ind += 256 }
}
while ($ind <= 65535) { # scans one bucket, runs at most 256 iterations
# find the n-th turned-on bit within the corresponding bucket
if (vec($ports_bitset, $ind, 1)) {
if ($n <= 0) { $port_number = $ind; last } else { $n-- }
}
$ind++;
Mail-Transport-Dbx
view release on metacpan or search on metacpan
print "I contain emails";
} else {
print "I contain subfolders";
}
This is useful for iterations:
for my $msg ($dbx->emails) {
...
}
Map-Metro
view release on metacpan or search on metacpan
lib/Map/Metro/Plugin/Map.pm view on Meta::CPAN
B<Alternative names> are used when the I<same station> is known as both names. This is not very common.
B<Search names> is mostly useful when a station has changed names (keep the old name as a search name)
Overriding station names through a hook (as L<Map::Metro::Plugin::Hook::Helsinki::Swedish> does) can be a good way to present translations or transliterations of station names.
Just make sure that no names collide.
=head1 WHAT NOW?
Markdent
view release on metacpan or search on metacpan
-npro
-nsfs
--blank-lines-before-packages=0
--opening-hash-brace-right
--no-outdent-long-comments
--iterations=2
-wbb="% + - * / x != == >= <= =~ !~ < > | & >= < = **= += *= &= <<= &&= -= /= |= >>= ||= .= %= ^= x="
Markup-Tree
view release on metacpan or search on metacpan
lib/Markup/Tree.pm view on Meta::CPAN
=back
B<RETURN VALUES MATTER!>
Returning a false value will end the iterations and cause the method to return.
Return true to keep processing.
=item copy_of
Returns a copy, not a reference, of the tree.
Marpa-R2
view release on metacpan or search on metacpan
engine/read_only/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
MarpaX-Hoonlint
view release on metacpan or search on metacpan
hoons/arvo/lib/tester.hoon view on Meta::CPAN
((hard tang) .*(q.v(+6 (init-test eny)) q.call))
::
:> # %per-test
:> data initialized on a per-test basis.
::
++ init-test |=({eny/@uvJ} %*(. tester eny eny, check-iterations 10))
::
++ tester
|_ $: eny=@uvJ :< entropy
check-iterations=@u :< # of check trials
current-iteration=@u :< current iteration
==
:> #
:> # %check
:> #
:> gates for quick check style tests.
+|
+- check
|* [generator=$-(@uvJ *) test=$-(* ?)]
|- ^- tang
?: (gth current-iteration check-iterations)
~
:: todo: wrap generator in mule so it can crash.
=+ sample=(generator eny)
:: todo: wrap test in mule so it can crash.
?: (test sample)
Math-Amoeba
view release on metacpan or search on metacpan
lib/Math/Amoeba.pm view on Meta::CPAN
The simplest use is the B<MinimiseND> function. This takes a reference
to an array of guess values for the parameters at the function
minimum, a reference to an array of scales for these parameters
(sensible ranges around the guess in which to look), a reference to
the function, a convergence tolerence for the minimum, the maximum
number of iterations to be taken and the verbose flag (default ON).
It returns an array consisting of a reference to the function parameters
at the minimum and the value there.
=item C<Amoeba>
lib/Math/Amoeba.pm view on Meta::CPAN
Simpex Method in Multidimensions. It takes a reference to an array of
references to arrays which are the initial n+1 vertices (where n is
the number of function parameters), a reference to the function
valuation at these vertices, a reference to the function, a
convergence tolerence for the minimum, the maximum number of
iterations to be taken and the verbose flag (default ON).
It returns an array consisting of a reference to the function parameters
at the minimum and the value there.
=item C<ConstructVertices>
lib/Math/Amoeba.pm view on Meta::CPAN
# Stopping conditions
my $rtol = 2*abs($y->[$ihi]-$y->[$ilo])/(abs($y->[$ihi])+abs($y->[$ilo])+TINY);
if ($rtol<$ftol) { last; }
if ($iter++>$itmax) {
carp "Amoeba exceeded maximum iterations\n" if ($verbose);
last;
}
# Determine the Centroid
if ($recalc) {
Math-Aronson
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);
}
Math-Base-Convert
view release on metacpan or search on metacpan
lib/Math/Base/Convert/Shortcuts.pm view on Meta::CPAN
$pad = 0 if $pad == $dpr;
if ($pad) {
$str = ($padchar x $pad) . $str; # pad string with zero value digit
}
# number of iterations % digits/register
$len += $pad;
my $i = 0;
my @d32;
while ($i < $len) {
#
Math-Basic-XS
view release on metacpan or search on metacpan
lib/Math/Basic/XS.pm view on Meta::CPAN
}
});
...
Benchmark: timing 1000000 iterations of Math::Basic, XS...
Math::Basic: 5 wallclock secs ( 5.00 usr + 0.00 sys = 5.00 CPU) @ 200000.00/s (n=1000000)
XS: 2 wallclock secs ( 2.21 usr + 0.05 sys = 2.26 CPU) @ 442477.88/s (n=1000000)
=head1 AUTHOR
Math-BigInt
view release on metacpan or search on metacpan
lib/Math/BigInt/Calc.pm view on Meta::CPAN
# First input argument is modified.
my ($c, $n, $k) = @_;
# If k > n/2, or, equivalently, 2*k > n, compute nok(n, k) as
# nok(n, n-k), to minimize the number if iterations in the loop.
{
my $twok = $c->_mul($c->_two(), $c->_copy($k)); # 2 * k
if ($c->_acmp($twok, $n) > 0) { # if 2*k > n
$k = $c->_sub($c->_copy($n), $k); # k = n - k
Math-Brent
view release on metacpan or search on metacpan
lib/Math/Brent.pm view on Meta::CPAN
to the function's minimum using Brent's method.
($x, $y) = Minimise1D($guess, $scale, \&func);
The minimum is reached within a certain tolerance (defaulting 1e-7), and
attempts to do so within a maximum number of iterations (defaulting to 100).
You may override them by providing alternate values:
($x, $y) = Minimise1D($guess, $scale, \&func, 1.5e-8, 120);
=cut
lib/Math/Brent.pm view on Meta::CPAN
=back
Brent() isolates the minimum to a fractional precision of about B<$tol>
using Brent's method.
A maximum number of iterations B<$itmax> may be specified for this search - it
defaults to 100. Returned is a list consisting of the abcissa of the minum
and the function value there.
=cut
Math-Business-BlackScholes-Binaries-Greeks
view release on metacpan or search on metacpan
lib/Math/Business/BlackScholes/Binaries/Greeks/Delta.pm view on Meta::CPAN
my $hyp_part = 0;
my $stability_constant =
Math::Business::BlackScholesMerton::Binaries::get_stability_constant_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $vol, $w, $eta, 2);
my $iterations_required = Math::Business::BlackScholesMerton::Binaries::get_min_iterations_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $vol, $w);
for (my $k = 1; $k < $iterations_required; $k++) {
my $lambda_k_dash = (0.5 * (($mu_dash * $mu_dash) / ($vol * $vol) + ($k * $k * $pi * $pi * $vol * $vol) / ($h * $h)));
my $phi = ($vol * $vol) / ($h * $h * $h) * exp(-$lambda_k_dash * $t) * $k * $k / $lambda_k_dash;
$series_part += $phi * $pi * $pi * cos($k * $pi * ($h - $x) / $h);
Math-Business-BlackScholes
view release on metacpan or search on metacpan
BlackScholes.pm view on Meta::CPAN
the price of the call option, and the volatility is returned.
You can override the default option price tolerance of 1e-4 by passing an
additional argument beyond C<$fractional_yield>.
If called in an array context, the second element of the return value is an
estimate of the error magnitude, and the third element is the number of
iterations required to obtain the result.
The error magnitude may be quite large unless you use a
reference option whose price exceeds its intrinsic value by an amount larger
than or comparable to the absolute difference of the market price and the
strike price, and it is undefined if the price of the reference option is
less than what would be calculated with zero volatility.
If the price of the reference option is greater than what would be calculated
with infinite volatility, then both the result and the error estimate are
undefined.
An exception is thrown if it fails to converge within
C<$Math::Business::BlackScholes::max_iter> (100 by default) iterations.
An analogous implied_volatility_put() is also available.
=head2 American Options
Whereas a European stock option may be exercised only when it expires,
Math-Business-BlackScholesMerton
view release on metacpan or search on metacpan
lib/Math/Business/BlackScholesMerton/Binaries.pm view on Meta::CPAN
#
# SANITY CHECKS
#
# For extreme cases, the price will be wrong due the values in the
# infinite series getting too large or too small, which causes
# roundoff errors in the computer. Thus no matter how many iterations
# you make, the errors will never go away.
#
# For example try this:
#
# my ($S, $U, $D, $t, $r, $q, $vol, $w)
lib/Math/Business/BlackScholesMerton/Binaries.pm view on Meta::CPAN
# These constants will determine whether or not this contract can be
# evaluated to a predefined accuracy. It is VERY IMPORTANT because
# if these conditions are not met, the prices can be complete nonsense!!
my $stability_constant = get_stability_constant_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $eta, 1);
# The number of iterations is important when recommending the
# range of the upper/lower barriers on our site. If we recommend
# a range that is too big and our iteration is too small, the
# price will be wrong! We must know the rate of convergence of
# the formula used.
my $iterations_required = get_min_iterations_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w);
for (my $k = 1; $k < $iterations_required; $k++) {
my $lambda_k_dash = (0.5 * (($mu_dash * $mu_dash) / ($sigma * $sigma) + ($k * $k * $pi * $pi * $sigma * $sigma) / ($h * $h)));
my $phi = ($sigma * $sigma) / ($h * $h) * exp(-$lambda_k_dash * $t) * $k / $lambda_k_dash;
$series_part += $phi * $pi * sin($k * $pi * ($h - $x) / $h);
lib/Math/Business/BlackScholesMerton/Binaries.pm view on Meta::CPAN
my $x = log($S / $D);
return exp(-$mu_new * $x / ($sigma * $sigma)) * common_function_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, 0);
}
=head2 get_min_iterations_pelsser_1997
USAGE
my $min = get_min_iterations_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy)
DESCRIPTION
An estimate of the number of iterations required to achieve a certain
level of accuracy in the price.
=cut
sub get_min_iterations_pelsser_1997 {
my ($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy) = @_;
if (not defined $accuracy) {
$accuracy = $MIN_ACCURACY_UPORDOWN_PELSSER_1997;
}
lib/Math/Business/BlackScholesMerton/Binaries.pm view on Meta::CPAN
$accuracy = $MIN_ACCURACY_UPORDOWN_PELSSER_1997;
} elsif ($accuracy <= 0) {
$accuracy = $MIN_ACCURACY_UPORDOWN_PELSSER_1997;
}
my $it_up = _get_min_iterations_ot_up_ko_down_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy);
my $it_down = _get_min_iterations_ot_down_ko_up_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy);
my $min = max($it_up, $it_down);
return $min;
}
=head2 _get_min_iterations_ot_up_ko_down_pelsser_1997
USAGE
my $k_min = _get_min_iterations_ot_up_ko_down_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy)
DESCRIPTION
An estimate of the number of iterations required to achieve a certain
level of accuracy in the price for ONETOUCH-UP-KNOCKOUT-DOWN.
=cut
sub _get_min_iterations_ot_up_ko_down_pelsser_1997 {
my ($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy) = @_;
if (!defined $accuracy) {
die "accuracy required";
}
lib/Math/Business/BlackScholesMerton/Binaries.pm view on Meta::CPAN
my $delta_dash = $accuracy;
my $delta = $delta_dash * exp(-$mu_new * ($h - $x) / ($sigma * $sigma)) * (($h * $h) / ($pi * $sigma * $sigma));
# This can happen when stability condition fails
if ($delta * $B <= 0) {
die "(_get_min_iterations_ot_up_ko_down_pelsser_1997) Cannot "
. "evaluate minimum iterations because too many iterations "
. "required!! delta=$delta, B=$B for input parameters S=$S, "
. "U=$U, D=$D, t=$t, r_q=$r_q, mu=$mu, sigma=$sigma, w=$w, "
. "accuracy=$accuracy";
}
lib/Math/Business/BlackScholesMerton/Binaries.pm view on Meta::CPAN
}
return int($k_min);
}
=head2 _get_min_iterations_ot_down_ko_up_pelsser_1997
USAGE
DESCRIPTION
An estimate of the number of iterations required to achieve a certain
level of accuracy in the price for ONETOUCH-UP-KNOCKOUT-UP.
=cut
sub _get_min_iterations_ot_down_ko_up_pelsser_1997 {
my ($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy) = @_;
my $h = log($U / $D);
my $mu_new = $mu - (0.5 * $sigma * $sigma);
$accuracy = $accuracy * exp($mu_new * $h / ($sigma * $sigma));
return _get_min_iterations_ot_up_ko_down_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy);
}
=head2 range
USAGE
Math-Business-Blackscholes-Binaries
view release on metacpan or search on metacpan
lib/Math/Business/BlackScholes/Binaries.pm view on Meta::CPAN
#
# SANITY CHECKS
#
# For extreme cases, the price will be wrong due the values in the
# infinite series getting too large or too small, which causes
# roundoff errors in the computer. Thus no matter how many iterations
# you make, the errors will never go away.
#
# For example try this:
#
# my ($S, $U, $D, $t, $r, $q, $vol, $w)
lib/Math/Business/BlackScholes/Binaries.pm view on Meta::CPAN
# These constants will determine whether or not this contract can be
# evaluated to a predefined accuracy. It is VERY IMPORTANT because
# if these conditions are not met, the prices can be complete nonsense!!
my $stability_constant = get_stability_constant_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $eta, 1);
# The number of iterations is important when recommending the
# range of the upper/lower barriers on our site. If we recommend
# a range that is too big and our iteration is too small, the
# price will be wrong! We must know the rate of convergence of
# the formula used.
my $iterations_required = get_min_iterations_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w);
for (my $k = 1; $k < $iterations_required; $k++) {
my $lambda_k_dash = (0.5 * (($mu_dash * $mu_dash) / ($sigma * $sigma) + ($k * $k * $pi * $pi * $sigma * $sigma) / ($h * $h)));
my $phi = ($sigma * $sigma) / ($h * $h) * exp(-$lambda_k_dash * $t) * $k / $lambda_k_dash;
$series_part += $phi * $pi * sin($k * $pi * ($h - $x) / $h);
lib/Math/Business/BlackScholes/Binaries.pm view on Meta::CPAN
my $x = log($S / $D);
return exp(-$mu_new * $x / ($sigma * $sigma)) * common_function_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, 0);
}
=head2 get_min_iterations_pelsser_1997
USAGE
my $min = get_min_iterations_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy)
DESCRIPTION
An estimate of the number of iterations required to achieve a certain
level of accuracy in the price.
=cut
sub get_min_iterations_pelsser_1997 {
my ($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy) = @_;
if (not defined $accuracy) {
$accuracy = $MIN_ACCURACY_UPORDOWN_PELSSER_1997;
}
lib/Math/Business/BlackScholes/Binaries.pm view on Meta::CPAN
$accuracy = $MIN_ACCURACY_UPORDOWN_PELSSER_1997;
} elsif ($accuracy <= 0) {
$accuracy = $MIN_ACCURACY_UPORDOWN_PELSSER_1997;
}
my $it_up = _get_min_iterations_ot_up_ko_down_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy);
my $it_down = _get_min_iterations_ot_down_ko_up_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy);
my $min = max($it_up, $it_down);
return $min;
}
=head2 _get_min_iterations_ot_up_ko_down_pelsser_1997
USAGE
my $k_min = _get_min_iterations_ot_up_ko_down_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy)
DESCRIPTION
An estimate of the number of iterations required to achieve a certain
level of accuracy in the price for ONETOUCH-UP-KNOCKOUT-DOWN.
=cut
sub _get_min_iterations_ot_up_ko_down_pelsser_1997 {
my ($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy) = @_;
if (!defined $accuracy) {
die "accuracy required";
}
lib/Math/Business/BlackScholes/Binaries.pm view on Meta::CPAN
my $delta_dash = $accuracy;
my $delta = $delta_dash * exp(-$mu_new * ($h - $x) / ($sigma * $sigma)) * (($h * $h) / ($pi * $sigma * $sigma));
# This can happen when stability condition fails
if ($delta * $B <= 0) {
die "(_get_min_iterations_ot_up_ko_down_pelsser_1997) Cannot "
. "evaluate minimum iterations because too many iterations "
. "required!! delta=$delta, B=$B for input parameters S=$S, "
. "U=$U, D=$D, t=$t, r_q=$r_q, mu=$mu, sigma=$sigma, w=$w, "
. "accuracy=$accuracy";
}
lib/Math/Business/BlackScholes/Binaries.pm view on Meta::CPAN
}
return int($k_min);
}
=head2 _get_min_iterations_ot_down_ko_up_pelsser_1997
USAGE
DESCRIPTION
An estimate of the number of iterations required to achieve a certain
level of accuracy in the price for ONETOUCH-UP-KNOCKOUT-UP.
=cut
sub _get_min_iterations_ot_down_ko_up_pelsser_1997 {
my ($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy) = @_;
my $h = log($U / $D);
my $mu_new = $mu - (0.5 * $sigma * $sigma);
$accuracy = $accuracy * exp($mu_new * $h / ($sigma * $sigma));
return _get_min_iterations_ot_up_ko_down_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy);
}
=head2 range
USAGE
Math-Business-BlackscholesMerton
view release on metacpan or search on metacpan
lib/Math/Business/BlackScholesMerton/Binaries.pm view on Meta::CPAN
#
# SANITY CHECKS
#
# For extreme cases, the price will be wrong due the values in the
# infinite series getting too large or too small, which causes
# roundoff errors in the computer. Thus no matter how many iterations
# you make, the errors will never go away.
#
# For example try this:
#
# my ($S, $U, $D, $t, $r, $q, $vol, $w)
lib/Math/Business/BlackScholesMerton/Binaries.pm view on Meta::CPAN
# These constants will determine whether or not this contract can be
# evaluated to a predefined accuracy. It is VERY IMPORTANT because
# if these conditions are not met, the prices can be complete nonsense!!
my $stability_constant = get_stability_constant_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $eta, 1);
# The number of iterations is important when recommending the
# range of the upper/lower barriers on our site. If we recommend
# a range that is too big and our iteration is too small, the
# price will be wrong! We must know the rate of convergence of
# the formula used.
my $iterations_required = get_min_iterations_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w);
for (my $k = 1; $k < $iterations_required; $k++) {
my $lambda_k_dash = (0.5 * (($mu_dash * $mu_dash) / ($sigma * $sigma) + ($k * $k * $pi * $pi * $sigma * $sigma) / ($h * $h)));
my $phi = ($sigma * $sigma) / ($h * $h) * exp(-$lambda_k_dash * $t) * $k / $lambda_k_dash;
$series_part += $phi * $pi * sin($k * $pi * ($h - $x) / $h);
lib/Math/Business/BlackScholesMerton/Binaries.pm view on Meta::CPAN
my $x = log($S / $D);
return exp(-$mu_new * $x / ($sigma * $sigma)) * common_function_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, 0);
}
=head2 get_min_iterations_pelsser_1997
USAGE
my $min = get_min_iterations_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy)
DESCRIPTION
An estimate of the number of iterations required to achieve a certain
level of accuracy in the price.
=cut
sub get_min_iterations_pelsser_1997 {
my ($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy) = @_;
if (not defined $accuracy) {
$accuracy = $MIN_ACCURACY_UPORDOWN_PELSSER_1997;
}
lib/Math/Business/BlackScholesMerton/Binaries.pm view on Meta::CPAN
$accuracy = $MIN_ACCURACY_UPORDOWN_PELSSER_1997;
} elsif ($accuracy <= 0) {
$accuracy = $MIN_ACCURACY_UPORDOWN_PELSSER_1997;
}
my $it_up = _get_min_iterations_ot_up_ko_down_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy);
my $it_down = _get_min_iterations_ot_down_ko_up_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy);
my $min = max($it_up, $it_down);
return $min;
}
=head2 _get_min_iterations_ot_up_ko_down_pelsser_1997
USAGE
my $k_min = _get_min_iterations_ot_up_ko_down_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy)
DESCRIPTION
An estimate of the number of iterations required to achieve a certain
level of accuracy in the price for ONETOUCH-UP-KNOCKOUT-DOWN.
=cut
sub _get_min_iterations_ot_up_ko_down_pelsser_1997 {
my ($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy) = @_;
if (!defined $accuracy) {
die "accuracy required";
}
lib/Math/Business/BlackScholesMerton/Binaries.pm view on Meta::CPAN
my $delta_dash = $accuracy;
my $delta = $delta_dash * exp(-$mu_new * ($h - $x) / ($sigma * $sigma)) * (($h * $h) / ($pi * $sigma * $sigma));
# This can happen when stability condition fails
if ($delta * $B <= 0) {
die "(_get_min_iterations_ot_up_ko_down_pelsser_1997) Cannot "
. "evaluate minimum iterations because too many iterations "
. "required!! delta=$delta, B=$B for input parameters S=$S, "
. "U=$U, D=$D, t=$t, r_q=$r_q, mu=$mu, sigma=$sigma, w=$w, "
. "accuracy=$accuracy";
}
lib/Math/Business/BlackScholesMerton/Binaries.pm view on Meta::CPAN
}
return int($k_min);
}
=head2 _get_min_iterations_ot_down_ko_up_pelsser_1997
USAGE
DESCRIPTION
An estimate of the number of iterations required to achieve a certain
level of accuracy in the price for ONETOUCH-UP-KNOCKOUT-UP.
=cut
sub _get_min_iterations_ot_down_ko_up_pelsser_1997 {
my ($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy) = @_;
my $h = log($U / $D);
my $mu_new = $mu - (0.5 * $sigma * $sigma);
$accuracy = $accuracy * exp($mu_new * $h / ($sigma * $sigma));
return _get_min_iterations_ot_up_ko_down_pelsser_1997($S, $U, $D, $t, $r_q, $mu, $sigma, $w, $accuracy);
}
=head2 range
USAGE
Math-Calculus-NewtonRaphson
view release on metacpan or search on metacpan
NewtonRaphson.pm view on Meta::CPAN
};
# Now iterate.
my $curGuess = $guess;
my $lastGuess = !$guess;
my $iterations = 0;
while ($iterations < $MAXITERATIONS && $curGuess != $lastGuess) {
# Write traceback.
$self->{'traceback'} .= "$iterations\t$curGuess\n";
# Sub value in.
$lastGuess = $curGuess;
eval {
$curGuess = $lastGuess - $self->evaluateTree($fiter, $variable => $lastGuess, %mappings);
} || ($self->{'error'} ||= "Fatal error! $@");
# Increment iterations counter.
$iterations++;
}
# Return an appropriate value (or lack thereof...).
if ($self->{'error'}) {
return undef;
( run in 1.999 second using v1.01-cache-2.11-cpan-f03e8824b8d )