Math Utilities #26

xsin

Spec this none thisFlags rxdOwner #36Definer #26

Referenced by

• #26:xsin line 6: this:xsin
• #26:xsin line 6: this:xsin
• #26:xcos line 6: this:xsin
• #26: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 #36Definer #26

Referenced by

• #26:xsin line 6: this:xcos
• #26:xsin line 6: this:xcos
• #26:xcos line 6: this:xcos
• #26: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 #36Definer #26

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 #36Definer #26

Referenced by

• #93: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 #36Definer #26

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) != INT)
return E_TYPE;
elseif ((n = args[1]) < 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 #36Definer #26

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 #36Definer #26

Referenced by

• #26: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 #36Definer #26

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 #36Definer #26

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 #36Definer #26

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 #36Definer #26

Referenced by

• #26:simpson line 8: this:parts
• #26: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 #36Definer #26

Referenced by

none

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 #36Definer #26

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 #36Definer #26

Referenced by

• #119:globify line 16: $math_utils:mod
• #128:weather_msg line 8: $math_utils:mod
• #128:weather_msg line 9: $math_utils:mod
• #128:time_of_day line 5: $math_utils:mod
• #128:time_of_day line 6: $math_utils: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 #36Definer #26

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 #36Definer #26

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 #36Definer #26

Referenced by

• #26: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 #36Definer #26

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 #36Definer #26

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 #36Definer #26

Referenced by

• #26:OR line 1: this:AND
• #119:globify line 17: $math_utils:XOR

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 #36Definer #26

Referenced by

none

Source

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

NOT

Spec this none thisFlags rxdOwner #36Definer #26

Referenced by

• #26:OR line 1: this:NOT
• #26:OR line 1: this:NOT
• #26: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 #36Definer #26

Referenced by

• #26:NOT line 4: this: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 #36Definer #26

Referenced by

• #26:NOT line 9: this: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 #36Definer #26

Referenced by

• #26:lcm line 6: this:gcd
• #26: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 #36Definer #26

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 #36Definer #26

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 #36Definer #26

Referenced by

none

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 #36Definer #26

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

sum

Spec this none thisFlags rxdOwner #36Definer #26

Referenced by

• #128:generate_weather line 4: $math_utils:sum

Source

":sum(INT|FLOAT num, num, num ...) => Total of all arguments added together.";
":sum({num, num, num, ...}) will also work.";
total = (typeof((typeof(x = args[1]) == LIST) ? x[1] | x) == INT) ? 0 | 0.0;
for number in ((typeof(x) == LIST) ? x | args)
total = total + number;
endfor
return total;

sin

Spec this none thisFlags rxdOwner #36Definer #26

Referenced by

• #26:cos line 14: this:sin
• #26:tan line 6: this:sin
• #43:sun line 8: $trig_utils:sin
• #43: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 #36Definer #26

Referenced by

• #26:tan line 7: this:cos
• #43:sun line 7: $trig_utils:cos
• #43: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 #36Definer #26

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 #36Definer #26

Referenced by

• #26: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 #36Definer #26

Referenced by

• #26: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 #36Definer #26

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

round

Spec this none thisFlags rxdOwner #2Definer #26

Referenced by

• #91:reached_limit line 15: $math_utils:round
• #91:reached_limit line 16: $math_utils:round
• #102:wield line 5: $math_utils:round
• #126:encrypt line 17: $math_utils:round
• #129:learn line 23: $math_utils:round
• #129:enterfunc line 26: $math_utils:round

Source

"returns integer from float, rounded up or down from the x.5 boundary";
fnum = args[1];
extra = fnum - tofloat(toint(fnum));
posneg = (fnum > 0.0) ? 1 | -1;
return (abs(extra) >= 0.5) ? toint(fnum) + posneg | toint(fnum);