Math Utilities #18

xsin

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #18:xsin line 6: this:xsin
• #18:xsin line 6: this:xsin
• #18:xcos line 6: this:xsin
• #18:xcos line 6: this:xsin

Source

"xsin(INT x) -- calculates the taylor approximation for the sine function";
if (typeof(x = args[1]) != INT)
return E_TYPE;
endif
if ((x * x) > this.taylor)
return ((this:xsin(x / 2) * this:xcos((x + 1) / 2)) + (this:xsin((x + 1) / 2) * this:xcos(x / 2))) / 10000;
else
return (x * (17453000 - ((x * x) * 886))) / 100000;
endif

xcos

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #18:xsin line 6: this:xcos
• #18:xsin line 6: this:xcos
• #18:xcos line 6: this:xcos
• #18:xcos line 6: this:xcos

Source

"xcos(INT x) -- calculates the taylor approximation for the cosine function";
if (typeof(x = args[1]) != INT)
return E_TYPE;
endif
if ((x * x) > this.taylor)
return ((this:xcos(x / 2) * this:xcos((x + 1) / 2)) - (this:xsin(x / 2) * this:xsin((x + 1) / 2))) / 10000;
else
return (1000000000 - ((x * x) * (152309 + ((4 * x) * x)))) / 100000;
endif

factorial

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

"factorial(INT n) -- returns n factorial for 0 <= n (<= 12).";
if ((number = args[1]) < 0)
return E_INVARG;
elseif (typeof(number) != INT)
return E_TYPE;
endif
fact = 1;
for i in [2..number]
fact = fact * i;
endfor
return fact;

pow

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #85:inverse line 14: $math_utils:pow

Source

"pow(INT|FLOAT x,(INT)|(INT|FLOAT) n) -- returns x raised to the nth power. n must be >= 0. If x is an integer, n must be an integer. If x is a floating point number, n can be either.";
{x, n} = args;
if (n < 0)
return E_INVARG;
elseif ((typeof(x) == INT) && (typeof(n) == FLOAT))
return E_TYPE;
endif
return x ^ n;
"old code below";
n = args[1];
if (power % 2)
ret = n;
else
ret = 1;
endif
while (power = power / 2)
n = n * n;
if (power % 2)
ret = ret * n;
endif
endwhile
return ret;

fibonacci

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

"fibonacci(INT n) -- calculates the fibonacci numbers to the nth term";
"and returns them in a list. n must be >= 0.";
if (typeof(n = args[1]) != INT)
return E_TYPE;
elseif (n < 0)
return E_INVARG;
elseif (n == 0)
return {0};
else
x = {0, 1};
for i in [2..n]
x = {@x, x[$ - 1] + x[$]};
endfor
return x;
endif

geometric

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

"geometric(INT|FLOAT x [,INT n]) -- calculates the value of the geometric series at x to the nth term. i.e., approximates 1/(1-x) when |x| < 1. This, of course, is impossible in MOO, but someone may find it useful in some way.";
"n defaults to 5. n must be >= 0.";
{n, ?order = 5} = args;
if ((!(typeof(n) in {INT, FLOAT})) || (typeof(order) != INT))
return E_TYPE;
elseif (order <= 0)
return E_INVARG;
endif
x = 1;
for i in [1..order]
x = x + (n ^ i);
endfor
return x;

divmod

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #18:div line 2: this:divmod

Source

"divmod(INT n, INT d) => {q,r} such that n = dq + r";
"  handles negative numbers correctly   0<=r<d if d>0, -d<r<=0 if d<0.";
{n, d} = args;
if ((typeof(n) != INT) && (typeof(d) != INT))
return E_TYPE;
endif
r = ((n % d) + d) % d;
q = (n - r) / d;
return {q, r};

combinations

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

"combinations(INT n, INT r) -- returns the number of ways one can choose r";
"objects from n distinct choices.";
"C(n,r) = n!/[r!(n-r)!]";
"  overflow may occur if n>29...";
{n, r} = args;
if ((typeof(n) != INT) && (typeof(r) != INT))
return E_TYPE;
endif
if (0 > (r = min(r, n - r)))
return 0;
else
c = 1;
n = n + 1;
for i in [1..r]
c = (c * (n - i)) / i;
endfor
return c;
endif

permutations

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

"permutations(INT n, INT r) -- returns the number of ways possible for one to";
"order r distinct objects given n locations.";
"P(n,r) = n!/(n-r)!";
{n, r} = args;
if ((typeof(n) != INT) && (typeof(r) != INT))
return E_TYPE;
endif
if ((r < 1) || ((diff = n - r) < 0))
return 0;
else
p = n;
for i in [diff + 1..n - 1]
p = p * i;
endfor
return p;
endif

simpson

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

"simpson({a,b},{f(a),f((a+b)/2),f(b)} [,INT ret-float])";
" -- given two endpoints, a and b, and the functions value at a, (a+b)/2, and b, this will calculate a numerical approximation of the integral using simpson's rule.";
"Entries can either be all INT or all FLOAT. Don't mix!";
"If the optional 3rd argument is provided and true, the answer is returned as a floating point regardless of what the input was. Otherwise, if the input was all INT, the answer is returned as {integer,fraction}";
{point, fcn, ?retfloat = 0} = args;
if ((!retfloat) && (typeof(point[1]) == INT))
numer = (point[2] - point[1]) * ((fcn[1] + (4 * fcn[2])) + fcn[3]);
return this:parts(numer, 6);
else
numer = tofloat(point[2] - point[1]) * ((tofloat(fcn[1]) + (4.0 * tofloat(fcn[2]))) + tofloat(fcn[3]));
return numer / 6.0;
endif

parts

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #18:simpson line 8: this:parts
• #18:exp line 15: this:parts

Source

"parts(INT n, INT q [,INT i]) -- returns a decomposition of n by q into integer and floating point parts with i = the number of digits after the decimal.";
"i defaults to 5.";
"warning: it is quite easy to hit maxint which results in unpredictable";
"         results";
{n, q, ?i = 5} = args;
if (((typeof(n) != INT) && (typeof(q) != INT)) && (typeof(i) != INT))
return E_TYPE;
endif
parts = {n / q, n % q};
return {parts[1], (parts[2] * (10 ^ i)) / q};

sqrt

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #114:announce_low_sky line 13: $math_utils:sqrt

Source

"sqrt(INT|FLOAT n) => largest integer <= square root of n. Returns the same type as the input. (Backwards compatibility)";
n = args[1];
return (typeof(n) == INT) ? toint(sqrt(tofloat(n))) | sqrt(n);
"Old code. Newton's method";
if (n < 0)
return E_RANGE;
elseif (n)
x1 = n;
while (x1 > (x2 = (x1 + (n / x1)) / 2))
x1 = x2;
endwhile
return x1;
else
return 0;
endif

div

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

"div(INT n, INT d) => q such that n = dq + r and  (0<=r<d if d>0, -d<r<=0 if d<0).";
return this:divmod(@args)[1];

mod

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #35:daytime_to_str line 4: $math_utils:mod
• #112:moon_phase line 8: $au:mod

Source

"A correct mod function.";
"mod(INT n, INT d) => r such that n = dq + r and (0<=r<d if d>0 or -d<r<=0 if d<0).";
{n, d} = args;
if ((typeof(n) != INT) && (typeof(d) != INT))
return E_TYPE;
endif
return ((n % d) + d) % d;

exp

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

"exp(INT|FLOAT x[,INT n]) -- calculates an nth order taylor approximation for e^x.";
"n defaults to 5. Any n given must be >= 0. you need to divide the result";
"the answer will be returned as {integer part,fractional part} if the input x was an integer. If it is floating point, so will the answer (and this uses the builtin function.)";
{x, ?n = 5} = args;
if (typeof(x) == FLOAT)
return exp(x);
elseif ((typeof(x) != INT) && (typeof(n) != INT))
return E_TYPE;
endif
ex = nfact = 1;
for i in [0..n - 1]
j = n - i;
ex = (ex * x) + (nfact = nfact * j);
endfor
return this:parts(ex, nfact);

aexp

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

"returns 10000 exp (x/10000)";
"The accuracy seems to be ~0.1% for 0<x<4";
x = args[1];
if (x < 0)
z = this:(verb)(-x);
return (100000000 + (z / 2)) / z;
elseif (x > 1000)
z = this:(verb)(x / 2);
if (z > 1073741823)
return $maxint;
"maxint for overflows";
elseif (z > 460000)
z = ((z + 5000) / 10000) * z;
elseif (z > 30000)
z = ((((z + 50) / 100) * z) + 50) / 100;
else
z = ((z * z) + 5000) / 10000;
endif
if (x % 2)
return z + ((z + 5000) / 10000);
else
return z;
endif
else
return ((10000 + x) + (((x * x) + 10000) / 20000)) + ((((x * x) * x) + 300000000) / 600000000);
endif

random

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #18:random_range line 8: this:random

Source

"random(INT n): returns a random integer in the following manner:";
"random(n > 0) will return a integer in the range 0 to n";
"random(n < 0) will return a integer in the range n to 0";
if (typeof(prob = args[1]) != INT)
return E_TYPE;
endif
mod = (prob < 0) ? -1 | 1;
return (mod * random(abs(prob + mod))) - mod;

random_range

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

"random_range(INT range [,INT mean]): returns a random integer within the given range from the mean. if the mean isn't given, it defaults to 0";
"e.g., random_range(10) => -10..10";
"      random_range(10,4) => -6..14";
{range, ?mean = 0} = args;
if ((typeof(range) != INT) && (typeof(mean) != INT))
return E_TYPE;
endif
return mean + (((random(2) == 1) ? -1 | 1) * this:random(range));

is_prime

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

"is_prime(INT number) returns 1 if the number is prime or 0 if it isn't.";
"of course, only positive numbers are candidates for primality.";
if (typeof(number = args[1]) != INT)
return E_TYPE;
endif
if (number == 2)
return 1;
elseif ((number < 2) || ((number % 2) == 0))
return 0;
else
choice = 3;
while (((denom = choice * choice) <= number) && (denom > 0))
if ((seconds_left() < 2) || (ticks_left() < 25))
suspend(0);
endif
if ((number % choice) == 0)
return 0;
endif
choice = choice + 2;
endwhile
endif
return 1;

AND XOR

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #18:OR line 1: this:AND

Source

"Only useful for integer input.";
{x, y} = args;
if ((typeof(x) != INT) && (typeof(y) != INT))
return E_TYPE;
endif
table = this.(verb);
if (xsgn = x < 0)
x = x + $minint;
endif
if (ysgn = y < 0)
y = y + $minint;
endif
power = 1;
z = 0;
while (x || y)
z = z + (power * table[1 + (x % 16)][1 + (y % 16)]);
x = x / 16;
y = y / 16;
power = power * 16;
endwhile
if (table[1 + xsgn][1 + ysgn])
return z + $minint;
else
return z;
endif

OR

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

return this:NOT(this:AND(this:NOT(args[1]), this:NOT(args[2])));

NOT

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #18:OR line 1: this:NOT
• #18:OR line 1: this:NOT
• #18:OR line 1: this:NOT

Source

return -(1 + args[1]);
"";
"... here's what it used to be ...";
bl1 = this:BLFromInt(args[1]);
blOut = {};
for i in [1..32]
blOut = {@blOut, !bl1[i]};
endfor
return this:IntFromBL(blOut);

BLFromInt

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #18:NOT line 4: this:BLFromInt
• #20:to_hex line 3: $math_utils:BLFromInt
• #183:clip line 2: $math_utils:BLFromInt

Source

"BlFromInt(INT x) => converts the number provided into a 32 bit binary number, which is returned via a 32 element LIST of 1's and 0's. Note that this verb was originally written to be used with the $math_utils verbs: AND, NOT, OR, XOR, but has since been taken out of them.";
if (typeof(x = args[1]) != INT)
return E_TYPE;
endif
l = {};
firstbit = x < 0;
if (firstbit)
x = x + $minint;
endif
for i in [1..31]
l = {x % 2, @l};
x = x / 2;
endfor
return {firstbit, @l};

IntFromBL

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #18:NOT line 9: this:IntFromBL
• #20:to_hex line 7: $math_utils:IntFromBL
• #20:to_hex line 8: $math_utils:IntFromBL
• #183:clip line 2: $math_utils:IntFromBL

Source

"IntFromBl(LIST of 1's and 0's) => converts the 32 bit binary representation given by the list of 1's and 0's and converts it to a normal decimal number. Note that this verb was originally written to be used with the $math_utils verbs: AND, NOT, OR, XOR, but has since been taken out of them.";
bl = args[1];
x = 0;
for l in (bl)
x = x * 2;
x = x + l;
endfor
return x;

gcd greatest_common_divisor

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #18:lcm line 6: this:gcd
• #18:are_rel_prime line 4: this:gcd

Source

"gcd(INT num1,INT num2): find the greatest common divisor of the two numbers";
"using the division algorithm. the absolute values of num1 and num2 are";
"used without loss of generality.";
num1 = abs(args[1]);
num2 = abs(args[2]);
max = max(num1, num2);
min = min(num1, num2);
if (r1 = max % min)
while (r2 = min % r1)
min = r1;
r1 = r2;
endwhile
return r1;
else
return min;
endif

lcm least_common_multiple

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

"lcm(INT num1,INT num2): find the least common multiple of the two numbers.";
"we shall use the positive lcm value without loss of generality.";
"since we have gcd already, we'll just use lcm*gcd = num1*num2";
num1 = abs(args[1]);
num2 = abs(args[2]);
return (num1 * num2) / this:gcd(num1, num2);

are_rel_prime are_relatively_prime

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

"are_rel_prime(INT num1,INT num2): returns 1 if num1 and num2 are relatively";
"prime.";
"since we have gcd, this is pretty easy.";
if (this:gcd(args[1], args[2]) == 1)
return 1;
else
return 0;
endif

base_conversion

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #20:to_hex2 line 3: $math_utils:base_conversion
• #20:to_hex2 line 4: $math_utils:base_conversion
• #20:to_hex2 line 5: $math_utils:base_conversion
• #20:to_hex2 line 7: $math_utils:base_conversion
• #90:ascii_sub line 6: $math_utils:base_conversion
• #103:get_html_icon line 6: $math_utils:base_conversion
• #324:from64 line 17: $math_utils:base_conversion
• #324:from64 line 25: $math_utils:base_conversion

Source

"Call with first arg either a number or a string, being the number";
"desired for conversion. capital letters denote values from 10-35;";
"lowercase letters from 36 to 61. Maximal base is 62.";
"You will be unable to use the extra 26 lowercases as separate unless";
"you pass a nonzero fourth argument. Passing zero or none uses the";
"default value, which is to have AAAA=aaaa.";
"The second and third arguments should be the base of the number and";
"the base you want it in, respectively.";
"Any of the arguments can be strings or nums, but high-base numbers";
"will need to be strings. This returns a string.";
"Any problems, talk to Ozymandias.";
sensitive = 0;
if (length(args) < 3)
return E_INVARG;
elseif (length(args) == 4)
sensitive = toint(args[4]);
endif
result = 0;
thenum = tostr(args[1]);
origbase = toint(args[2]);
newbase = toint(args[3]);
if ((((origbase < 2) || (newbase < 2)) || (origbase > 62)) || (newbase > 62))
return E_INVARG;
endif
for which in [1..length(thenum)]
value = index(this.base_alphabet, thenum[which], sensitive);
if ((!value) || (value > origbase))
return E_INVARG;
endif
result = ((result * origbase) + value) - 1;
endfor
thestring = "";
if (result < 0)
return E_INVARG;
endif
while (result)
if ((which = (result % newbase) + 1) <= length(this.base_alphabet))
thestring = this.base_alphabet[which] + thestring;
else
return E_INVARG;
endif
result = result / newbase;
endwhile
return thestring;

norm

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

":norm(a,b,c,d...) => sqrt(a^2+b^2+c^2+...)";
m = max(max(@args), -min(@args));
logm = length(tostr(m));
if (logm <= 4)
s = 0;
for a in (args)
s = s + (a * a);
endfor
return toint(sqrt(tofloat(s)));
else
factor = toint("1" + "0000000"[1..logm - 4]);
s = 0;
for a in (args)
a = a / factor;
s = s + (a * a);
endfor
return toint(sqrt(tofloat(s))) * factor;
endif

sin

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #18:cos line 14: this:sin
• #18:tan line 6: this:sin
• #35:sun line 8: $trig_utils:sin
• #35:sun line 8: $trig_utils:sin

Source

"Copied from Trig_Utils (#25800):sin by Obvious (#54879) Fri Nov 17 06:07:39 1995 PST";
theta = args[1];
if (typeof(theta) == FLOAT)
return sin(theta);
elseif (typeof(theta) == INT)
degtheta = theta % 360;
mintheta = 0;
elseif (typeof(theta) == LIST)
degtheta = theta[1] % 360;
mintheta = theta[2] % 60;
else
return E_INVARG;
endif
if (mintheta < 0)
mintheta = mintheta + 60;
degtheta = degtheta - 1;
endif
while (degtheta < 1)
degtheta = degtheta + 360;
endwhile
if (mintheta == 0)
return this.sines[degtheta];
endif
lim1 = this.sines[degtheta];
lim2 = this.sines[degtheta + 1];
delta = lim2 - lim1;
result = (((delta * mintheta) + 30) / 60) + lim1;
return result;

cos

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #18:tan line 7: this:cos
• #35:sun line 7: $trig_utils:cos
• #35:sun line 9: $trig_utils:cos

Source

"Copied from Trig_Utils (#25800):cos by Obvious (#54879) Fri Nov 17 06:07:50 1995 PST";
theta = args[1];
if (typeof(theta) == FLOAT)
return cos(theta);
elseif (typeof(theta) == INT)
degtheta = 90 - theta;
mintheta = 0;
elseif (typeof(theta) == LIST)
degtheta = 89 - theta[1];
mintheta = 60 - theta[2];
else
return;
endif
return this:sin({degtheta, mintheta});

tan

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

"Copied from Trig_Utils (#25800):tan by Obvious (#54879) Fri Nov 17 06:07:53 1995 PST";
{theta} = args;
if (typeof(theta) == FLOAT)
return tan(theta);
endif
sine = this:sin(theta);
cosine = this:cos(theta);
return ((sine * 10000) + ((cosine + 1) / 2)) / cosine;

arcsin asin

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #18:arccos line 6: this:arcsin

Source

"Copied from Trig_Utils (#25800):arcsin by Obvious (#54879) Fri Nov 17 06:08:01 1995 PST";
{given} = args;
if (typeof(given) == FLOAT)
return asin(given);
endif
given = abs(given);
if (given > 10000)
return E_RANGE;
endif
i = 1;
while (given > this.sines[i])
i = i + 1;
endwhile
if (given == this.sines[i])
if (args[1] < 0)
return {-i, 0};
else
return {i, 0};
endif
endif
degrees = i - 1;
if (i == 1)
lower = 0;
else
lower = this.sines[i - 1];
endif
upper = this.sines[i];
delta1 = given - lower;
delta2 = upper - lower;
minutes = ((delta1 * 60) + ((delta2 + 1) / 2)) / delta2;
if (args[1] < 0)
degrees = -degrees;
minutes = -minutes;
endif
return {degrees, minutes};

arccos acos

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #18:arctan line 9: this:arccos

Source

"Copied from Trig_Utils (#25800):arccos by Obvious (#54879) Fri Nov 17 06:08:08 1995 PST";
given = args[1];
if (typeof(given) == FLOAT)
return acos(given);
endif
arcsin = this:arcsin(given);
degrees = 89 - arcsin[1];
minutes = 60 - arcsin[2];
if (minutes > 60)
minutes = minutes - 60;
degrees = degrees + 1;
endif
return {degrees, minutes};

arctan atan

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

"Copied from Trig_Utils (#25800):arctan by Obvious (#54879) Fri Nov 17 06:08:18 1995 PST";
given = args[1];
if (typeof(given) == FLOAT)
return atan(given);
endif
reciprocal = ((given * given) / 10000) + 10000;
reciprocal = sqrt(reciprocal * 10000);
cosine = 100000000 / reciprocal;
return this:arccos(cosine);

deg2rads deg2rad

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

":deg2rad(FLOAT Degrees) => FLOAT Radians";
return tofloat(args[1]) * 0.0174532925199433;

rads2deg rad2deg

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

":rads2deg(FLOAT Radians) => FLOAT Degrees";
return tofloat(args[1]) * 57.2957795130824;

precision

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

":precision(FLOAT Number, INT Digits of Precision) => FLOAT Number";
"Cuts the given number to the given digits of precision.  Uses rounding.";
{digits, pre} = args;
mult = 10.0 ^ pre;
return this:rint(digits * mult) / mult;

round

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

"Usage: round(INT number, INT round)";
"Rounds 'number' off to the nearest multiple of 'round'.";
"Rounds UP numbers exactly half way in between two round possibilities.";
{what, round} = args;
low = (what / round) * round;
return (what < (low + (round / 2))) ? low | (low + round);

mean average

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #214:inspect line 3: $math_utils:average
• #214:average_pressure line 7: $math_utils:average

Source

"Usage: mean(INT, INT, ... )";
"       mean({INT, INT, ...})";
"Returns the average of all integers provided.";
return this:sum(rlist = (typeof(args[1]) == LIST) ? args[1] | args) / length(rlist);

sum_float

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

none

Source

":sum_float(FLOAT num, num, num ...) => Total of all arguments added together.";
":sum_float({num, num, num, ...}) will also work.";
{?total = 0.0, @rest} = args;
if (typeof(total) == LIST)
{?total = 0.0, @rest} = total;
endif
for number in (rest)
total = total + number;
endfor
return total;

sum_int sum

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #18:mean line 4: this:sum

Source

":sum_int(INT num, num, num ...) => Total of all arguments added together.";
":sum_int({num, num, num, ...}) will also work.";
"(...also named :sum for backward compatibility).";
"Use :sum_float to sum a list of floats.";
{?total = 0, @rest} = args;
if (typeof(total) == LIST)
{?total = 0, @rest} = total;
endif
for number in (rest)
total = total + number;
endfor
return total;
"... N.B.  For the sake of backward compatibility this routine will also return the float sum of a non-empty lists of floats, but using it this way should not be encouraged.";

rint

Spec this none thisFlags rxdOwner #29Definer #18

Referenced by

• #18:precision line 5: this:rint
• #103:gbar line 11: $math_utils:rint
• #103:gbar line 13: $math_utils:rint
• #167:rating_grade line 4: $math_utils:rint
• #246:graphical_bar line 10: $math_utils:rint
• #246:graphical_bar line 11: $math_utils:rint

Source

":rint(FLOAT Number) => FLOAT Number";
"Returns the given floating-point number rounded to the nearest integer, as a floating-point number.  In case of ties, rounds away from 0.";
{f} = args;
return trunc((f > 0.0) ? f + 0.5 | (f - 0.5));

gil_float_to_int

Spec this none thisFlags rxdOwner #361Definer #18

Referenced by

• #92:process_queue line 79: $math_utils:gil_float_to_int
• #155:process_queue line 38: $math_utils:gil_float_to_int
• #256:creature_heartbeat line 14: $math_utils:gil_float_to_int
• #256:heartbeat line 10: $math_utils:gil_float_to_int

Source

"Given a float, r = an int.  Use the fraction as a random chance to add 1.";
f = args[1];
if (typeof(f) == FLOAT)
sign = (f >= 0.0) ? 1 | -1;
elseif (typeof(f) == INT)
sign = (f >= 0) ? 1 | -1;
else
return 1;
endif
f = abs(f);
if (typeof(f) == FLOAT)
frem = f - tofloat(fint = toint(f));
if (random(100) < toint(frem * 100.0))
r = fint + 1;
else
r = fint;
endif
else
r = toint(f);
endif
r = max(r, 0);
return r * sign;

approx_number

Spec this none thisFlags rxdOwner #361Definer #18

Referenced by

none

Source

":approx_number(INT number, INT precision)";
"For a precision of 0, return the number exactly.  For >0, approximate.";
NUM = args[1];
precision = args[2];
if (precision == 0)
return NUM;
elseif (precision == 1)
return (NUM - 2) + random(3);
else
pval = {1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000}[precision];
NUM = (NUM / pval) * pval;
return NUM;
endif

sign

Spec this none thisFlags rxdOwner #361Definer #18

Referenced by

none

Source

return (args[1] >= 0) ? 1 | -1;

add

Spec this none thisFlags rxdOwner #361Definer #18

Referenced by

none

Source

return args[1] + args[2];

line_len

Spec this none thisFlags rxdOwner #361Definer #18

Referenced by

none

Source

{x1, y1, x2, y2} = args;
dist = sqrt((tofloat(x2 - x1) ^ 2.0) + (tofloat(y2 - y1) ^ 2.0));
return toint(dist);

constrain

Spec this none thisFlags rxdOwner #361Definer #18

Referenced by

none

Source

{n, min, max} = args;
while (n < min)
n = n + (max - min);
endwhile
while (n > max)
n = n - (max - min);
endwhile
return n;

points_to_angle

Spec this none thisFlags rxdOwner #361Definer #18

Referenced by

none

Source

{x1, y1, x2, y2} = args;
if (x2 == x1)
if (y2 > y1)
theta = 0.0;
else
theta = 3.14159265;
endif
else
theta = atan(tofloat(y2 - y1) / tofloat(x2 - x1));
if (x2 > x1)
theta = (3.14159265 / 2.0) - theta;
else
theta = (3.14159265 * 1.5) - theta;
endif
endif
return mod(180 - toint(theta * 57.295779), 360);