Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
tree: b9261ad17c
Fetching contributors…

Cannot retrieve contributors at this time

291 lines (191 sloc) 6.763 kb
/*
** math.ops
*/
BEGIN_OPS_PREAMBLE
#include <math.h>
END_OPS_PREAMBLE
=head1 NAME
math.ops - Mathematical Opcodes
=cut
=head1 DESCRIPTION
Parrot's library of mathematical ops.
To use this library of ops, add this directive to your PIR:
.loadlib 'math_ops'
=cut
=head2 General Math
=over 4
=cut
########################################
=item B<cmod>(out INT, in INT, in INT)
=item B<cmod>(invar PMC, invar PMC, in INT)
=item B<cmod>(invar PMC, invar PMC, invar PMC)
NOTE: This "uncorrected mod" algorithm uses the C language's built-in
mod operator (x % y), which is
... the remainder when x is divided by y, and thus is zero
when y divides x exactly.
...
The direction of truncation for / and the sign of the result
for % are machine-dependent for negative operands, as is the
action taken on overflow or underflow.
-- [1], page 41
Also:
... if the second operand is 0, the result is undefined.
Otherwise, it is always true that (a/b)*b + a%b is equal to z. If
both operands are non-negative, then the remainder is non-
negative and smaller than the divisor; if not, it is guaranteed
only that the absolute value of the remainder is smaller than
the absolute value of the divisor.
-- [1], page 205
This op is provided for those who need it (such as speed-sensitive
applications with heavy use of mod, but using it only with positive
arguments), but a more mathematically useful mod based on ** floor(x/y)
and defined with y == 0 is provided by the mod op.
[1] Brian W. Kernighan and Dennis M. Ritchie, *The C Programming
Language*, Second Edition. Prentice Hall, 1988.
If the denominator is zero, a 'Divide by zero' exception is thrown.
=cut
inline op cmod(out INT, in INT, in INT) :base_core {
const INTVAL den = $3;
if ($3 == 0) {
opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
EXCEPTION_DIV_BY_ZERO,
"Divide by zero");
goto ADDRESS(handler);
}
$1 = $2 % den;
}
inline op cmod(invar PMC, invar PMC, in INT) :base_core {
INTVAL result;
if ($3 == 0) {
opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
EXCEPTION_DIV_BY_ZERO,
"Divide by zero");
goto ADDRESS(handler);
}
result = VTABLE_get_integer(interp, $2) % $3;
$1 = Parrot_pmc_new_init_int(interp, VTABLE_type(interp, $2), result);
}
inline op cmod(invar PMC, invar PMC, invar PMC) :base_core {
INTVAL result;
const INTVAL value = VTABLE_get_integer(interp, $3);
if (value == 0) {
opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
EXCEPTION_DIV_BY_ZERO,
"Divide by zero");
goto ADDRESS(handler);
}
result = VTABLE_get_integer(interp, $2) % value;
$1 = Parrot_pmc_new_init_int(interp, VTABLE_type(interp, $2), result);
}
########################################
=item B<cmod>(out NUM, in NUM, in NUM)
=item B<cmod>(invar PMC, invar PMC, in NUM)
NOTE: This "uncorrected mod" algorithm uses the built-in C math library's
fmod() function, which computes
... the remainder of dividing x by y. The return value is
x - n * y, where n is the quotient of x / y, rounded towards
zero to an integer.
-- fmod() manpage on RedHat Linux 7.0
In addition, fmod() returns
the remainder, unless y is zero, when the function fails and
errno is set.
According to page 251 of [1], the result when y is zero is implementation-
defined.
This op is provided for those who need it, but a more mathematically
useful numeric mod based on floor(x/y) instead of truncate(x/y) and
defined with y == 0 is provided by the mod op.
[1] Brian W. Kernighan and Dennis M. Ritchie, *The C Programming
Language*, Second Edition. Prentice Hall, 1988.
If the denominator is zero, a 'Divide by zero' exception is thrown.
=cut
inline op cmod(out NUM, in NUM, in NUM) :base_core {
const FLOATVAL den = $3;
if (FLOAT_IS_ZERO($3)) {
opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
EXCEPTION_DIV_BY_ZERO,
"Divide by zero");
goto ADDRESS(handler);
}
$1 = fmod($2, den);
}
inline op cmod(invar PMC, invar PMC, in NUM) :base_core {
FLOATVAL result;
const FLOATVAL value = $3;
if (FLOAT_IS_ZERO(value)) {
opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
EXCEPTION_DIV_BY_ZERO,
"Divide by zero");
goto ADDRESS(handler);
}
result = fmod(VTABLE_get_integer(interp, $2), value);
$1 = Parrot_pmc_new_init_int(interp,
VTABLE_type(interp, $2), (INTVAL)result);
}
=back
=cut
###############################################################################
=head2 Pseudorandom number operations
These operations perform various pseudorandom number operations.
=over 4
=item B<rand>(out NUM)
Set $1 to a random floating point number between 0 and 1, inclusive.
=cut
inline op rand(out NUM) {
$1 = Parrot_util_float_rand(0);
}
=item B<rand>(out INT)
Set $1 to a random integer between C<[-2^31, 2^31)> .
=cut
inline op rand(out INT) {
$1 = Parrot_util_int_rand(0);
}
=item B<rand>(out NUM, in NUM)
Set $1 to a random floating point number between 0 and $2, inclusive.
=cut
inline op rand(out NUM, in NUM) {
$1 = $2 * Parrot_util_float_rand(0);
}
=item B<rand>(out INT, in INT)
Set $1 to a integer between 0 and $2, inclusive.
=cut
inline op rand(out INT, in INT) {
$1 = Parrot_util_range_rand(0, $2, 0);
}
=item B<rand>(out NUM, in NUM, in NUM)
Set $1 to a random floating point number between $2 and $3, inclusive.
=cut
inline op rand(out NUM, in NUM, in NUM) {
$1 = $2 + ($3 - $2) * Parrot_util_float_rand(0);
}
=item B<srand>(in NUM)
Set the random number seed to $1. $1 is casted to an INTVAL.
=cut
inline op srand(in NUM) {
Parrot_util_srand((INTVAL)$1);
}
=item B<srand>(in INT)
Set the random number seed to $1.
=cut
inline op srand(in INT) {
Parrot_util_srand((INTVAL)$1);
}
=item B<rand>(out INT, in INT, in INT)
Set $1 to a integer between $2 and $3, inclusive.
=cut
inline op rand(out INT, in INT, in INT) {
$1 = Parrot_util_range_rand($2, $3, 0);
}
=back
=cut
=head1 COPYRIGHT
Copyright (C) 2001-2011, Parrot Foundation.
=head1 LICENSE
This program is free software. It is subject to the same license
as the Parrot interpreter itself.
=cut
/*
* Local variables:
* c-file-style: "parrot"
* End:
* vim: expandtab shiftwidth=4 cinoptions='\:2=2' :
*/
Jump to Line
Something went wrong with that request. Please try again.