mirror of
https://github.com/lcn2/calc.git
synced 2025-08-19 01:13:27 +03:00
3680 lines
122 KiB
Plaintext
3680 lines
122 KiB
Plaintext
/*
|
|
* Copyright (c) 1996 David I. Bell
|
|
* Permission is granted to use, distribute, or modify this source,
|
|
* provided that this copyright notice remains intact.
|
|
*
|
|
* Test the correct execution of the calculator by reading this library file.
|
|
* Errors are reported with '****' messages, or worse. :-)
|
|
*
|
|
* NOTE: Unlike most calc lib files, this one performs its work when
|
|
* it is read. Normally one would just define functions and
|
|
* values for later use. In the case of the regression test,
|
|
* we do not want to do this.
|
|
*/
|
|
|
|
print '000: Beginning regression tests';
|
|
print '001: Some of these tests may take a while ...';
|
|
print '002: Within each section, output should be numbered sequentially';
|
|
|
|
|
|
global err;
|
|
lib_debug = -1; /* disable lib startup messages */
|
|
initcfg = config("all", "oldstd"); /* set config to startup default */
|
|
print '003: parsed global definitions';
|
|
|
|
|
|
/*
|
|
* vrfy - vrfy that a test is true
|
|
*
|
|
* Counts and reports errors or prints test string if successful.
|
|
*/
|
|
define vrfy(test, str)
|
|
{
|
|
if (test != 1) {
|
|
print '**** Non-true result (' : test : '): ' : str;
|
|
++err;
|
|
return;
|
|
}
|
|
print str;
|
|
}
|
|
print '004: parsed vrfy()';
|
|
|
|
|
|
/*
|
|
* err - alternate error notification and count
|
|
*/
|
|
define err(str)
|
|
{
|
|
print '****' , str;
|
|
++err;
|
|
}
|
|
print '005: parsed err(str)';
|
|
|
|
|
|
/*
|
|
* getglobalvar - used to return a global value
|
|
*/
|
|
define getglobalvar()
|
|
{
|
|
global globalvar;
|
|
|
|
return globalvar;
|
|
}
|
|
print '006: parsed getglobalvar()';
|
|
|
|
|
|
/*
|
|
* Test boolean operations and IF tests.
|
|
*
|
|
* Some of these tests are done twice, once to print the message and
|
|
* once to count any errors. This means that some successful tests
|
|
* will display a passing message twice. Oh well, no biggie.
|
|
*/
|
|
define test_booleans()
|
|
{
|
|
local x;
|
|
local y;
|
|
local t1, t2, t3;
|
|
|
|
print '200: Beginning test_booleans';
|
|
|
|
if (0)
|
|
print '**** if (0)';
|
|
if (0)
|
|
err = err + 1;
|
|
|
|
if (1)
|
|
print '201: if (1)';
|
|
|
|
if (2)
|
|
print '202: if (2)';
|
|
|
|
if (1)
|
|
print '203: if (1) else';
|
|
else
|
|
print '**** if (1) else';
|
|
if (1)
|
|
print '204: if (1) else';
|
|
else
|
|
err = err + 1;
|
|
|
|
if (0)
|
|
print '**** if (0) else';
|
|
else
|
|
print '205: if (0) else';
|
|
if (0)
|
|
err = err + 1;
|
|
else
|
|
print '206: if (0) else';
|
|
|
|
if (1 == 1)
|
|
print '207: if 1 == 1';
|
|
else
|
|
print '**** if 1 == 1';
|
|
if (1 == 1)
|
|
print '208: if 1 == 1';
|
|
else
|
|
err = err + 1;
|
|
|
|
if (1 != 2)
|
|
print '209: if 1 != 2';
|
|
else
|
|
print '**** if 1 != 2';
|
|
if (1 != 2)
|
|
print '210: if 1 != 2';
|
|
else
|
|
err = err + 1;
|
|
|
|
vrfy(1, '211: vrfy 1');
|
|
vrfy(2 == 2, '212: vrfy 2 == 2');
|
|
vrfy(2 != 3, '213: vrfy 2 != 3');
|
|
vrfy(2 < 3, '214: vrfy 2 < 3');
|
|
vrfy(2 <= 2, '215: vrfy 2 <= 2');
|
|
vrfy(2 <= 3, '216: vrfy 2 <= 3');
|
|
vrfy(3 > 2, '217: vrfy 3 > 2');
|
|
vrfy(2 >= 2, '218: vrfy 2 >= 2');
|
|
vrfy(3 >= 2, '219: vrfy 3 >= 2');
|
|
vrfy(!0, '220: vrfy !0');
|
|
vrfy(!1 == 0,'221: vrfy !1 == 0');
|
|
vrfy((1 ? 2 ? 3 : 4 : 5) == 3, '222: (1 ? 2 ? 3 : 4 : 5) == 3');
|
|
|
|
print '223: Ending test_booleans';
|
|
}
|
|
print '007: parsed test_booleans()';
|
|
|
|
|
|
/*
|
|
* Test variables, simple assignments, AND and OR operators, short-circuit eval
|
|
*/
|
|
define test_variables()
|
|
{
|
|
local x1, x2, x3;
|
|
global g1, g2;
|
|
local t;
|
|
global globalvar;
|
|
local x;
|
|
|
|
print '300: Beginning test_variables';
|
|
|
|
x1 = 5;
|
|
x3 = 7 * 2;
|
|
x2 = 9 + 1;
|
|
globalvar = 22;
|
|
g1 = 19 - 3;
|
|
g2 = 79;
|
|
vrfy(x1 == 5, '301: x1 == 5');
|
|
vrfy(x2 == 10, '302: x2 == 10');
|
|
vrfy(x3 == 14, '303: x3 == 14');
|
|
vrfy(g1 == 16, '304: g1 == 16');
|
|
vrfy(g2 == 79, '305: g2 == 79');
|
|
vrfy(globalvar == 22, '306: globalvar == 22');
|
|
vrfy(getglobalvar() == 22, '307: getglobalvar() == 22');
|
|
x1 = x2 + x3 + g1;
|
|
vrfy(x1 == 40, '308: x1 == 40');
|
|
g1 = x3 + g2;
|
|
vrfy(g1 == 93, '309: g1 == 207');
|
|
x1 = 5;
|
|
vrfy(x1++ == 5, '310: x1++ == 5');
|
|
vrfy(x1 == 6, '311: x1 == 6');
|
|
vrfy(++x1 == 7, '312: ++x1 == 7');
|
|
x1 += 3;
|
|
vrfy(x1 == 10, '313: x1 == 10');
|
|
x1 -= 6;
|
|
vrfy(x1 == 4, '314: x1 == 4');
|
|
x1 *= 3;
|
|
vrfy(x1 == 12, '315: x1 == 12');
|
|
x1 /= 4;
|
|
vrfy(x1 == 3, '316: x1 == 3');
|
|
x1 = x2 = x3;
|
|
vrfy(x2 == 14, '317: x2 == 14');
|
|
vrfy(x1 == 14, '318: x1 == 14');
|
|
|
|
if (2 && 3) {
|
|
print '319: if (2 && 3)';
|
|
} else {
|
|
print '**** if (2 && 3)';
|
|
++err;
|
|
}
|
|
|
|
if (2 && 0) {
|
|
print '**** if (2 && 0)';
|
|
++err;
|
|
} else {
|
|
print '320: if (2 && 0)';
|
|
}
|
|
|
|
if (0 && 2) {
|
|
print '**** if (0 && 2)';
|
|
++err;
|
|
} else {
|
|
print '321: if (0 && 2)';
|
|
}
|
|
|
|
if (0 && 0) {
|
|
print '**** if (0 && 0)';
|
|
++err;
|
|
} else {
|
|
print '322: if (0 && 0)';
|
|
}
|
|
|
|
if (2 || 0) {
|
|
print '323: if (2 || 0)';
|
|
} else {
|
|
print '**** if (2 || 0)';
|
|
++err;
|
|
}
|
|
|
|
if (0 || 2) {
|
|
print '324: if (0 || 2)';
|
|
} else {
|
|
print '**** if (0 || 2)';
|
|
++err;
|
|
}
|
|
|
|
if (0 || 0) {
|
|
print '**** if (0 || 0)';
|
|
++err;
|
|
} else {
|
|
print '325: if (0 || 0)';
|
|
}
|
|
|
|
x = 2 || 3; vrfy(x == 2, '326: (2 || 3) == 2');
|
|
x = 2 || 0; vrfy(x == 2, '327: (2 || 0) == 2');
|
|
x = 0 || 3; vrfy(x == 3, '328: (0 || 3) == 3');
|
|
x = 0 || 0; vrfy(x == 0, '329: (0 || 0) == 0');
|
|
x = 2 && 3; vrfy(x == 3, '330: (2 && 3) == 3');
|
|
x = 2 && 0; vrfy(x == 0, '331: (2 && 0) == 0');
|
|
x = 0 && 3; vrfy(x == 0, '332: (0 && 3) == 0');
|
|
x = 2 || err('2 || err()');
|
|
print "333: x = 2 || err('2 || err()'";
|
|
x = 0 && err('0 && err()');
|
|
print "334: x = 0 && err('0 && err()'";
|
|
|
|
print '335: Ending test_variables';
|
|
}
|
|
print '008: parsed test_variables()';
|
|
|
|
|
|
/*
|
|
* Test simple arithmetic operations and expressions.
|
|
*/
|
|
define test_arithmetic()
|
|
{
|
|
print '400: Beginning test_arithmetic';
|
|
|
|
vrfy(3+4==7, '401: 3 + 4 == 7');
|
|
vrfy(4-1==3, '402: 4 - 1 == 3');
|
|
vrfy(2*3==6, '403: 2 * 3 == 6');
|
|
vrfy(8/4==2, '404: 8 / 4 == 2');
|
|
vrfy(2^3==8, '405: 2 ^ 3 == 8');
|
|
vrfy(9-4-2==3, '406: 9-4-2 == 3');
|
|
vrfy(9-4+2==7, '407: 9-4+2 == 6');
|
|
vrfy(-5+2==-3, '408: -5+2 == -3');
|
|
vrfy(2*3+1==7, '409: 2*3+1 == 7');
|
|
vrfy(1+2*3==7, '410: 1+2*3 == 7');
|
|
vrfy((1+2)*3==9, '411: (1+2)*3 == 9');
|
|
vrfy(2*(3+1)==8, '412: 2*(3+1) == 8');
|
|
vrfy(9-(2+3)==4, '413: 9-(2+3) == 4');
|
|
vrfy(9+(2-3)==8, '414: 9+(2-3) == 8');
|
|
vrfy((2+3)*(4+5)==45, '415: (2+3)*(4+5) == 45');
|
|
vrfy(10/(2+3)==2, '416: 10/(2+3) == 2');
|
|
vrfy(12/3+4==8, '417: 12/3+4 == 8');
|
|
vrfy(6+12/3==10, '418: 6+12/3 == 10');
|
|
vrfy(2+3==1+4, '419: 2+3 == 1+4');
|
|
vrfy(-(2+3)==-5, '420: -(2+3) == -5');
|
|
vrfy(7&18==2, '421: 7&18 == 2');
|
|
vrfy(3|17==19, '422: 3|17 == 19');
|
|
vrfy(2&3|1==3, '423: 2&3|1 == 3');
|
|
vrfy(2&(3|1)==2, '424: 2&(3|1) == 2');
|
|
vrfy(3<<4==48, '425: 3<<4 == 48');
|
|
vrfy(5>>1==2, '426: 5>>1 == 2');
|
|
vrfy(3<<-1==1, '427: 3<<-1 == 1');
|
|
vrfy(5>>-2==20, '428: 5>>-2 == 20');
|
|
vrfy(1<<2<<3==65536, '429: 1<<2<<3 == 65536');
|
|
vrfy((1<<2)<<3==32, '430: (1<<2)<<3 == 32');
|
|
vrfy(2^3^2==512, '431: 2^3^2 == 512');
|
|
vrfy((2^3)^2==64, '432: (2^3)^2 == 64');
|
|
vrfy(4//3==1, '433: 4//3==1');
|
|
vrfy(4//-3==-1, '434: 4//-3==-1');
|
|
vrfy(0.75//-0.51==-1, '435: 0.75//-0.51==-1');
|
|
vrfy(0.75//-0.50==-1, '436: 0.75//-0.50==-1');
|
|
vrfy(0.75//-0.49==-1, '437: 0.75//-0.49==-1');
|
|
vrfy((3/4)//(-1/4)==-3, '438: (3/4)//(-1/4)==-3');
|
|
vrfy(7%3==1, '439: 7%3==1');
|
|
vrfy(0-.5==-.5, '440: 0-.5==-.5');
|
|
vrfy(0^0 == 1, '441: 0^0 == 1');
|
|
vrfy(0^1 == 0, '442: 0^1 == 0');
|
|
vrfy(1^0 == 1, '443: 1^0 == 1');
|
|
vrfy(1^1 == 1, '444: 1^1 == 1');
|
|
vrfy(1/(.8+.8i)==.625-.625i, '445: 1/(.8+.8i)==.625-.625i');
|
|
vrfy((.6+.8i)*(3.6-4.8i)==6, '446: (.6+.8i)*(3.6-4.8i)==6');
|
|
|
|
print '447: Ending test_arithmetic';
|
|
}
|
|
print '009: parsed test_arithmetic()';
|
|
|
|
|
|
/*
|
|
* test_config - test config control
|
|
*/
|
|
define test_config()
|
|
{
|
|
local callcfg; /* caller configuration value */
|
|
local oldcfg; /* caller configuration value */
|
|
local newcfg; /* caller configuration value */
|
|
|
|
print '500: Beginning test_config';
|
|
|
|
/* check the set and return of all config */
|
|
callcfg = config("all");
|
|
print '501: callcfg = config("all")';
|
|
callcfg = config("all", "oldstd");
|
|
print '502: callcfg = config("all","oldstd")';
|
|
oldcfg = config("all", "newstd");
|
|
print '503: oldcfg = config("all","newstd")';
|
|
vrfy(callcfg == oldcfg, '504: callcfg == oldcfg');
|
|
newcfg = config("all");
|
|
print '505: newcfg = config("all")';
|
|
vrfy(config("all") == newcfg, '506: config("all") == newcfg');
|
|
vrfy(config("all", oldcfg) == newcfg,
|
|
'507: config("all", oldcfg) == newcfg');
|
|
|
|
/* vrfy the state of the default config */
|
|
vrfy(config("all") == oldcfg, '508: config("all") == oldcfg');
|
|
vrfy(config("mode") == "real",
|
|
'509: config("mode") == "real"');
|
|
vrfy(config("display") == 20,
|
|
'510: config("display") == 20');
|
|
vrfy(config("epsilon") == 1e-20,
|
|
'511: config("epsilon") == 1e-20');
|
|
vrfy(config("trace") == 0,
|
|
'512: config("trace") == 0');
|
|
vrfy(config("maxprint") == 16,
|
|
'513: config("maxprint") == 16');
|
|
vrfy(config("mul2") == 20,
|
|
'514: config("mul2") == 20');
|
|
vrfy(config("sq2") == 20,
|
|
'515: config("sq2") == 20');
|
|
vrfy(config("pow2") == 40,
|
|
'516: config("pow2") == 40');
|
|
vrfy(config("redc2") == 50,
|
|
'517: config("redc2") == 50');
|
|
vrfy(config("tilde") == 1,
|
|
'518: config("tilde") == 1');
|
|
vrfy(config("tab") == 1,
|
|
'519: config("tab") == 1');
|
|
vrfy(config("quomod") == 0,
|
|
'520: config("quomod") == 0');
|
|
vrfy(config("quo") == 2,
|
|
'521: config("quo") == 2');
|
|
vrfy(config("mod") == 0,
|
|
'522: config("mod") == 0');
|
|
vrfy(config("sqrt") == 24,
|
|
'523: config("sqrt") == 24');
|
|
vrfy(config("appr") == 24,
|
|
'524: config("appr") == 24');
|
|
vrfy(config("cfappr") == 0,
|
|
'525: config("cfappr") == 0');
|
|
vrfy(config("cfsim") == 8,
|
|
'526: config("cfsim") == 8');
|
|
vrfy(config("outround") == 2,
|
|
'527: config("outround") == 2');
|
|
vrfy(config("round") == 24,
|
|
'528: config("round") == 24');
|
|
vrfy(config("leadzero") == 0,
|
|
'529: config("leadzero") == 0');
|
|
vrfy(config("fullzero") == 0,
|
|
'530: config("fullzero") == 0');
|
|
vrfy(config("maxerr") == 20,
|
|
'531: config("maxerr") == 20');
|
|
vrfy(config("prompt") == "> ",
|
|
'532: config("prompt") == "> "');
|
|
vrfy(config("more") == ">> ",
|
|
'533: config("more") == ">> "');
|
|
|
|
/* convert to "newstd" config by individual changes */
|
|
vrfy(config("display", 10) == 20,
|
|
'534: config("display") == 20');
|
|
vrfy(config("epsilon",1e-10)==1e-20,
|
|
'535: config("epsilon",1e-10)==1e-20');
|
|
vrfy(config("quo", 0) == 2, '536: config("quo", 0) == 2');
|
|
vrfy(config("outround", 24) == 2,
|
|
'537: config("outround", 24) == 2');
|
|
vrfy(config("leadzero", "y") == 0,
|
|
'538: config("leadzero", "y") == 0');
|
|
vrfy(config("fullzero", 1) == 0,
|
|
'539: config("fullzero", 1) == 0');
|
|
vrfy(config("prompt", "; ") == "> ",
|
|
'540: config("prompt", "; ") == "> "');
|
|
vrfy(config("more", ";; ") == ">> ",
|
|
'541: config("more", ";; ") == ">> "');
|
|
vrfy(config("all") == newcfg, '542: config("all") == newcfg');
|
|
|
|
/* check on the new config("fullzero") effect */
|
|
vrfy(config("all","oldstd") == newcfg,
|
|
'543: config("all",callcfg) == newcfg');
|
|
vrfy(config("display",2) == 20,
|
|
'544: config("display",2) == 20');
|
|
vrfy(config("fullzero",1) == 0,
|
|
'545: config("fullzero",1) == 0');
|
|
vrfy(strprintf("%d %d %d", 0, 1, 2) == ".00 1.00 2.00",
|
|
'546: strprintf("%d %d %d", 0, 1, 2) == ".00 1.00 2.00"');
|
|
vrfy(config("display",20) == 2,
|
|
'547: config("display",20) == 2');
|
|
vrfy(config("fullzero",0) == 1,
|
|
'548: config("fullzero",0) == 1');
|
|
vrfy(strprintf("%d %d %d", 0, 1, 2) == "0 1 2",
|
|
'549: strprintf("%d %d %d", 0, 1, 2) == "0 1 2"');
|
|
|
|
/* restore calling config */
|
|
vrfy(config("all",callcfg) == oldcfg,
|
|
'550: config("all",callcfg) == oldcfg');
|
|
vrfy(config("all") == callcfg, '551: config("all") == callcfg');
|
|
vrfy(config("all") == oldcfg, '552: config("all") == oldcfg');
|
|
|
|
print '553: Ending test_config';
|
|
}
|
|
print '010: parsed test_config()';
|
|
|
|
|
|
|
|
/*
|
|
* Do multiplication and division on three numbers in various ways
|
|
* and vrfy the results agree.
|
|
*/
|
|
define muldivcheck(a, b, c, str)
|
|
{
|
|
local abc, acb, bac, bca, cab, cba;
|
|
|
|
abc = (a * b) * c;
|
|
acb = (a * c) * b;
|
|
bac = (b * a) * c;
|
|
bca = (b * c) * a;
|
|
cab = (c * a) * b;
|
|
cba = (c * b) * a;
|
|
|
|
if (abc != acb) {print '**** abc != acb:', str; ++err;}
|
|
if (acb != bac) {print '**** acb != bac:', str; ++err;}
|
|
if (bac != bca) {print '**** bac != bca:', str; ++err;}
|
|
if (bca != cab) {print '**** bca != cab:', str; ++err;}
|
|
if (cab != cba) {print '**** cab != cba:', str; ++err;}
|
|
if (abc/a != b*c) {print '**** abc/a != bc:', str; ++err;}
|
|
if (abc/b != a*c) {print '**** abc/b != ac:', str; ++err;}
|
|
if (abc/c != a*b) {print '**** abc/c != ab:', str; ++err;}
|
|
print str;
|
|
}
|
|
print '011: parsed muldivcheck(a, b, c, str)';
|
|
|
|
|
|
/*
|
|
* Use the identity for squaring the sum of two squares to check
|
|
* multiplication and squaring.
|
|
*/
|
|
define squarecheck(a, b, str)
|
|
{
|
|
local a2, b2, tab, apb, apb2, t;
|
|
|
|
a2 = a^2;
|
|
b2 = b^2;
|
|
tab = a * b * 2;
|
|
apb = a + b;
|
|
apb2 = apb^2;
|
|
if (a2 != a*a) {print '**** a^2 != a*a:', str; ++err;}
|
|
if (b2 != b*b) {print '**** b^2 != b*b:', str; ++err;}
|
|
if (apb2 != apb*apb) {
|
|
print '**** (a+b)^2 != (a+b)*(a+b):', str;
|
|
++err;
|
|
}
|
|
if (a2+tab+b2 != apb2) {
|
|
print '**** (a+b)^2 != a^2 + 2ab + b^2:', str;
|
|
++err;
|
|
}
|
|
if (a2/a != a) {print '**** a^2/a != a:', str; ++err;}
|
|
if (b2/b != b) {print '**** b^2/b != b:', str; ++err;}
|
|
if (apb2/apb != apb) {print '**** (a+b)^2/(a+b) != a+b:', str; ++err;}
|
|
if (a2*b2 != (a*b)^2) {print '**** a^2*b^2 != (ab)^2:', str; ++err;}
|
|
print str;
|
|
}
|
|
print '012: parsed squarecheck(a, b, str)';
|
|
|
|
|
|
/*
|
|
* Use the raising of numbers to large powers to check multiplication
|
|
* and exponentiation.
|
|
*/
|
|
define powercheck(a, p1, p2, str)
|
|
{
|
|
local a1, a2, a3;
|
|
|
|
a1 = (a^p1)^p2;
|
|
a2 = (a^p2)^p1;
|
|
a3 = a^(p1*p2);
|
|
if (a1 != a2) {print '**** (a^p1)^p2 != (a^p2)^p1:', str; ++err;}
|
|
if (a1 != a3) {print '**** (a^p1)^p2 != a^(p1*p2):', str; ++err;}
|
|
print str;
|
|
}
|
|
print '013: parsed powercheck(a, p1, p2, str)';
|
|
|
|
|
|
/*
|
|
* Test fraction reductions.
|
|
* Arguments MUST be relatively prime.
|
|
*/
|
|
define fraccheck(a, b, c, str)
|
|
{
|
|
local ab, bc, ca, aoc, boc, aob;
|
|
|
|
ab = a * b;
|
|
bc = b * c;
|
|
ca = c * a;
|
|
aoc = ab / bc;
|
|
if (num(aoc) != a) {print '**** num(aoc) != a:', str; ++err;}
|
|
if (den(aoc) != c) {print '**** den(aoc) != c:', str; ++err;}
|
|
boc = ab / ca;
|
|
if (num(boc) != b) {print '**** num(boc) != b:', str; ++err;}
|
|
if (den(boc) != c) {print '**** den(boc) != c:', str; ++err;}
|
|
aob = ca / bc;
|
|
if (num(aob) != a) {print '**** num(aob) != a:', str; ++err;}
|
|
if (den(aob) != b) {print '**** den(aob) != b:', str; ++err;}
|
|
if (aob*boc != aoc) {print '**** aob*boc != aoc;', str; ++err;}
|
|
print str;
|
|
}
|
|
print '014: parsed fraccheck(a, b, c, str)';
|
|
|
|
|
|
/*
|
|
* Test multiplication and squaring algorithms.
|
|
*/
|
|
define algcheck(a, b, str)
|
|
{
|
|
local ss, ms, t1, t2, t3, t4, t5, t6, t7;
|
|
local a1, a2, a3, a4, a5, a6, a7;
|
|
local oldmul2, oldsq2;
|
|
|
|
oldmul2 = config("mul2", 2);
|
|
oldsq2 = config("sq2", 2);
|
|
a1 = a * b;
|
|
a2 = a * a;
|
|
a3 = b * b;
|
|
a4 = a^2;
|
|
a5 = b^2;
|
|
a6 = a2^2;
|
|
a7 = pmod(3,a-1,a);
|
|
for (ms = 2; ms < 20; ms++) {
|
|
for (ss = 2; ss < 20; ss++) {
|
|
config("mul2", ms);
|
|
config("sq2", ss);
|
|
t1 = a * b;
|
|
t2 = a * a;
|
|
t3 = b * b;
|
|
t4 = a^2;
|
|
t5 = b^2;
|
|
t6 = t2^2;
|
|
if (((ms + ss) % 37) == 4)
|
|
t7 = pmod(3,a-1,a);
|
|
if (t1 != a1) {print '**** t1 != a1:', str; ++err;}
|
|
if (t2 != a2) {print '**** t2 != a2:', str; ++err;}
|
|
if (t3 != a3) {print '**** t3 != a3:', str; ++err;}
|
|
if (t4 != a4) {print '**** t4 != a4:', str; ++err;}
|
|
if (t5 != a5) {print '**** t5 != a5:', str; ++err;}
|
|
if (t6 != a6) {print '**** t6 != a6:', str; ++err;}
|
|
if (t7 != a7) {print '**** t7 != a7:', str; ++err;}
|
|
}
|
|
}
|
|
config("mul2", oldmul2);
|
|
config("sq2", oldsq2);
|
|
print str;
|
|
}
|
|
print '015: parsed algcheck(a, b, str)';
|
|
|
|
|
|
/*
|
|
* Test big numbers using some identities.
|
|
*/
|
|
define test_bignums()
|
|
{
|
|
local a, b, c, d;
|
|
|
|
print '600: Beginning test_bignums';
|
|
|
|
a = 64357824568234938591;
|
|
b = 12764632632458756817;
|
|
c = 43578234973856347982;
|
|
muldivcheck(a, b, c, '601: muldivcheck 1');
|
|
a = 3^100;
|
|
b = 5^97;
|
|
c = 7^88;
|
|
muldivcheck(a, b, c, '602: muldivcheck 2');
|
|
a = 2^160 - 1;
|
|
b = 2^161 - 1;
|
|
c = 2^162 - 1;
|
|
muldivcheck(a, b, c, '603: muldivcheck 3');
|
|
a = 3^35 / 5^35;
|
|
b = 7^35 / 11^35;
|
|
c = 13^35 / 17^35;
|
|
muldivcheck(a, b, c, '604: muldivcheck 4');
|
|
a = (10^97-1) / 9;
|
|
b = (10^53-1) / 9;
|
|
c = (10^37-1) / 9;
|
|
muldivcheck(a, b, c, '605: muldivcheck 5');
|
|
a = 17^50;
|
|
b = 19^47;
|
|
squarecheck(a, b, '606: squarecheck 1');
|
|
a = 2^111-1;
|
|
b = 2^17;
|
|
squarecheck(a, b, '607: squarecheck 2');
|
|
a = 23^43 / 29^43;
|
|
b = 31^42 / 37^29;
|
|
squarecheck(a, b, '608: squarecheck 3');
|
|
a = 4657892345743659834657238947854639;
|
|
b = 43784356784365893467659347867689;
|
|
squarecheck(a, b, '609: squarecheck 4');
|
|
a = (10^80-1) / 9;
|
|
b = (10^50-1) / 9;
|
|
squarecheck(a, b, '610: squarecheck 5');
|
|
a = 101^99;
|
|
b = 2 * a;
|
|
squarecheck(a, b, '611: squarecheck 6');
|
|
a = (10^19-1) / 9;
|
|
vrfy(ptest(a, 20), '612: primetest R19');
|
|
a = (10^23-1) / 9;
|
|
vrfy(ptest(a, 20), '613: primetest R23');
|
|
a = 2^127 - 1;
|
|
vrfy(ptest(a, 1), '614: primetest M127');
|
|
a = 2^521 - 1;
|
|
vrfy(ptest(a, 1), '615: primetest M521');
|
|
powercheck(17, 127, 30, '616: powercheck 1');
|
|
powercheck(111, 899, 6, '617: powercheck 2');
|
|
powercheck(3, 87, 89, '618: powercheck 3');
|
|
fraccheck(3^200, 5^173, 7^138, '619: fraccheck 1');
|
|
fraccheck(11^100, 12^98, 13^121, '620: fraccheck 2');
|
|
fraccheck(101^270, 103^111, 105^200, '621: fraccheck 3');
|
|
a = 0xffff0000ffffffff00000000ffff0000000000000000ffff;
|
|
b = 0x555544440000000000000000000000000000000011112222333344440000;
|
|
c = 0x999911113333000011111111000022220000000000000000333300000000ffff;
|
|
d = 0x3333ffffffff0000000000000000ffffffffffffffff000000000000;
|
|
algcheck(a, a, '622: algcheck 1');
|
|
algcheck(a, b, '623: algcheck 2');
|
|
algcheck(a, c, '624: algcheck 3');
|
|
algcheck(a, d, '625: algcheck 4');
|
|
algcheck(b, b, '626: algcheck 5');
|
|
algcheck(b, c, '627: algcheck 6');
|
|
algcheck(b, d, '628: algcheck 7');
|
|
algcheck(c, c, '629: algcheck 8');
|
|
algcheck(c, d, '630: algcheck 9');
|
|
algcheck(d, d, '631: algcheck 10');
|
|
|
|
print '632: Ending test_bignums';
|
|
}
|
|
print '016: parsed test_bignums()';
|
|
|
|
|
|
/*
|
|
* Test many of the built-in functions.
|
|
*/
|
|
define test_functions()
|
|
{
|
|
local a, b;
|
|
local pi;
|
|
|
|
print '700: Beginning test_functions';
|
|
|
|
vrfy(abs(3) == 3, '701: abs(3) == 3');
|
|
vrfy(abs(-4) == 4, '702: abs(-4) == 4');
|
|
vrfy(avg(7) == 7, '703: avg(7) == 7');
|
|
vrfy(avg(3,5) == 4, '704: avg(3,5) == 4');
|
|
vrfy(cmp(2,3) == -1, '705: cmp(2,3) == -1');
|
|
vrfy(cmp(6,6) == 0, '706: cmp(6,6) == 0');
|
|
vrfy(cmp(7,4) == 1, '707: cmp(7,4) == 1');
|
|
vrfy(comb(9,9) == 1, '708: comb(9,9) == 1');
|
|
vrfy(comb(5,2) == 10, '709: comb(5,2) == 10');
|
|
vrfy(conj(4) == 4, '710: conj(4) == 4');
|
|
vrfy(conj(2-3i) == 2+3i, '711: conj(2-3i) == 2+3i');
|
|
vrfy(den(17) == 1, '712: den(17) == 1');
|
|
vrfy(den(3/7) == 7, '713: den(3/7) == 7');
|
|
vrfy(den(-2/3) == 3, '714: den(-2/3) == 3');
|
|
vrfy(digits(0) == 1, '715: digits(0) == 1');
|
|
vrfy(digits(9) == 1, '716: digits(9) == 1');
|
|
vrfy(digits(10) == 2, '717: digits(10) == 2');
|
|
vrfy(digits(-691) == 3, '718: digits(-691) == 3');
|
|
vrfy(eval('2+3') == 5, "719: eval('2+3') == 5");
|
|
vrfy(fcnt(11,3) == 0, '720: fcnt(11,3) == 0');
|
|
vrfy(fcnt(18,3) == 2, '721: fcnt(18,3) == 2');
|
|
vrfy(fib(0) == 0, '722: fib(0) == 0');
|
|
vrfy(fib(1) == 1, '723: fib(1) == 1');
|
|
vrfy(fib(9) == 34, '724: fib(9) == 34');
|
|
vrfy(frem(12,5) == 12, '725: frem(12,5) == 12');
|
|
vrfy(frem(45,3) == 5, '726: frem(45,3) == 5');
|
|
vrfy(fact(0) == 1, '727: fact(0) == 1');
|
|
vrfy(fact(1) == 1, '728: fact(1) == 1');
|
|
vrfy(fact(5) == 120, '729: fact(5) == 120');
|
|
vrfy(frac(3) == 0, '730: frac(3) == 0');
|
|
vrfy(frac(2/3) == 2/3, '731: frac(2/3) == 2/3');
|
|
vrfy(frac(17/3) == 2/3, '732: frac(17/3) == 2/3');
|
|
vrfy(gcd(0,3) == 3, '733: gcd(0,3) == 3');
|
|
vrfy(gcd(1,12) == 1, '734: gcd(1,12) == 1');
|
|
vrfy(gcd(11,7) == 1, '735: gcd(11,7) == 1');
|
|
vrfy(gcd(20,65) == 5, '736: gcd(20,65) == 5');
|
|
vrfy(gcdrem(20,3) == 20, '737: gcdrem(20,3) == 20');
|
|
vrfy(gcdrem(100,6) == 25, '738: gcdrem(100,6) == 25');
|
|
vrfy(highbit(1) == 0, '739: highbit(1) == 0');
|
|
vrfy(highbit(15) == 3, '740: highbit(15) == 3');
|
|
vrfy(hypot(3,4) == 5, '741: hypot(3,4) == 5');
|
|
vrfy(ilog(90,3) == 4, '742: ilog(90,3) == 4');
|
|
vrfy(ilog10(123) == 2, '743: ilog10(123) == 2');
|
|
vrfy(ilog2(17) == 4, '744: ilog2(17) == 4');
|
|
vrfy(im(3) == 0, '745: im(3) == 0');
|
|
vrfy(im(2+3i) == 3, '746: im(2+3i) == 3');
|
|
print '747: test unused';
|
|
print '748: test unused';
|
|
print '749: test unused';
|
|
print '750: test unused';
|
|
print '751: test unused';
|
|
print '752: test unused';
|
|
print '753: test unused';
|
|
print '754: test unused';
|
|
print '755: test unused';
|
|
print '756: test unused';
|
|
vrfy(int(5) == 5, '757: int(5) == 5');
|
|
vrfy(int(19/3) == 6, '758: int(19/3) == 6');
|
|
vrfy(inverse(3/2) == 2/3, '759: inverse(3/2) == 2/3');
|
|
vrfy(iroot(18,2) == 4, '760: iroot(18,2) == 4');
|
|
vrfy(iroot(100,3) == 4, '761: iroot(100,3) == 4');
|
|
vrfy(iseven(10) == 1, '762: iseven(10) == 1');
|
|
vrfy(iseven(13) == 0, '763: iseven(13) == 0');
|
|
vrfy(iseven('a') == 0, "764: iseven('a') == 0");
|
|
vrfy(isint(7) == 1, '765: isint(7) == 1');
|
|
vrfy(isint(19/2) == 0, '766: isint(19/2) == 0');
|
|
vrfy(isint('a') == 0, "767: isint('a') == 0");
|
|
vrfy(islist(3) == 0, '768: islist(3) == 0');
|
|
vrfy(islist(list(2,3)) == 1, '769: islist(list(2,3)) == 1');
|
|
vrfy(ismat(3) == 0, '770: ismat(3) == 0');
|
|
vrfy(ismult(7,3) == 0, '771: ismult(7,3) == 0');
|
|
vrfy(ismult(15,5) == 1, '772: ismult(15,5) == 1');
|
|
vrfy(isnull(3) == 0, '773: isnull(3) == 0');
|
|
vrfy(isnull(null()) == 1, '774: isnull(null()) == 1');
|
|
vrfy(isnum(2/3) == 1, '775: isnum(2/3) == 1');
|
|
vrfy(isnum('xx') == 0, "776: isnum('xx') == 0");
|
|
vrfy(isobj(3) == 0, '777: isobj(3) == 0');
|
|
vrfy(isodd(7) == 1, '778: isodd(7) == 1');
|
|
vrfy(isodd(8) == 0, '779: isodd(8) == 0');
|
|
vrfy(isodd('x') == 0, "780: isodd('a') == 0");
|
|
vrfy(isqrt(27) == 5, '781: isqrt(27) == 5');
|
|
vrfy(isreal(3) == 1, '782: isreal(3) == 1');
|
|
vrfy(isreal('x') == 0, "783: isreal('x') == 0");
|
|
vrfy(isreal(2+3i) == 0, '784: isreal(2+3i) == 0');
|
|
vrfy(isstr(5) == 0, '785: isstr(5) == 0');
|
|
vrfy(isstr('foo') == 1, "786: isstr('foo') == 1");
|
|
vrfy(isrel(10,14) == 0, '787: isrel(10,14) == 0');
|
|
vrfy(isrel(15,22) == 1, '788: isrel(15,22) == 1');
|
|
vrfy(issimple(6) == 1, '789: issimple(6) == 1');
|
|
vrfy(issimple(3-2i) == 1, '790: issimple(3-2i) == 1');
|
|
vrfy(issimple(list(5)) == 0, '791: issimple(list(5)) == 0');
|
|
vrfy(issq(26) == 0, '792: issq(26) == 0');
|
|
vrfy(issq(9/4) == 1, '793: issq(9/4) == 1');
|
|
print '794: test unused';
|
|
vrfy(istype(9,4) == 1, '795: istype(9,4) == 1');
|
|
vrfy(istype(3,'xx') == 0, "796: istype(3,'xx') == 0");
|
|
vrfy(jacobi(5,11) == 1, '797: jacobi(2,7) == 1');
|
|
vrfy(jacobi(6,13) == -1, '798: jacobi(6,13) == -1');
|
|
vrfy(lcm(3,4,5,6) == 60, '799: lcm(3,4,5,6) == 60');
|
|
vrfy(lcmfact(8) == 840, '800: lcmfact(8) == 840');
|
|
vrfy(lfactor(21,5) == 3, '801: lfactor(21,5) == 3');
|
|
vrfy(lfactor(97,20) == 1, '802: lfactor(97,20) == 1');
|
|
vrfy(lowbit(12) == 2, '803: lowbit(12) == 2');
|
|
vrfy(lowbit(17) == 0, '804: lowbit(17) == 0');
|
|
vrfy(ltol(1) == 0, '805: ltol(1) == 0');
|
|
vrfy(max(3,-9,7,4) == 7, '806: max(3,-9,7,4) == 7');
|
|
vrfy(meq(13,33,10) == 1, '807: meq(13,33,10) == 1');
|
|
vrfy(meq(7,19,11) == 0, '808: meq(7,19,11) == 0');
|
|
vrfy(min(9,5,12) == 5, '809: min(9,5,12) == 5');
|
|
vrfy(minv(13,97) == 15, '810: minv(13,97) == 15');
|
|
vrfy(mne(16,37,10) == 1, '811: mne(16,37,10) == 1');
|
|
vrfy(mne(46,79,11) == 0, '812: mne(46,79,11) == 0');
|
|
vrfy(norm(4) == 16, '813: norm(4) == 16');
|
|
vrfy(norm(2-3i) == 13, '814: norm(2-3i) == 13');
|
|
vrfy(num(7) == 7, '815: num(7) == 7');
|
|
vrfy(num(11/4) == 11, '816: num(11/4) == 11');
|
|
vrfy(num(-9/5) == -9, '817: num(-9/5) == -9');
|
|
vrfy(char(ord('a')+2) == 'c', "818: char(ord('a')+2) == 'c'");
|
|
vrfy(perm(7,3) == 210, '819: perm(7,3) == 210');
|
|
vrfy(pfact(10) == 210, '820: pfact(10) == 210');
|
|
vrfy(places(3/7) == -1, '821: places(3/7) == -1');
|
|
vrfy(places(.347) == 3, '822: places(.347) == 3');
|
|
vrfy(places(17) == 0, '823: places(17) == 0');
|
|
vrfy(pmod(3,36,37) == 1, '824: pmod(3,36,37) == 1');
|
|
vrfy(poly(2,3,5,2) == 19, '825: poly(2,3,5,2) == 19');
|
|
vrfy(ptest(101,10) == 1, '826: ptest(101,10) == 1');
|
|
vrfy(ptest(221,30) == 0, '827: ptest(221,30) == 0');
|
|
vrfy(re(9) == 9, '828: re(9) == 9');
|
|
vrfy(re(-7+3i) == -7, '829: re(-7+3i) == -7');
|
|
vrfy(scale(3,4) == 48, '830: scale(3,4) == 48');
|
|
vrfy(sgn(-4) == -1, '831: sgn(-4) == -1');
|
|
vrfy(sgn(0) == 0, '832: sgn(0) == 0');
|
|
vrfy(sgn(3) == 1, '833: sgn(3) == 1');
|
|
vrfy(size(7) == 1, '834: size(7) == 1');
|
|
vrfy(sqrt(121) == 11, '835: sqrt(121) == 11');
|
|
vrfy(ssq(2,3,4) == 29, '836: ssq(2,3,4) == 29');
|
|
vrfy(str(45) == '45', "837: str(45) == '45'");
|
|
vrfy(strcat('a','bc','def')=='abcdef',
|
|
"838: strcat('a','bc','def')=='abcdef'");
|
|
vrfy(strlen('') == 0, "839: strlen('') == 0");
|
|
vrfy(strlen('abcd') == 4, "840: strlen('abcd') == 4");
|
|
vrfy(substr('abcd',2,1) == 'b', "841: substr('abcd',2,1) == 'b'");
|
|
vrfy(substr('abcd',3,4) == 'cd', "842: substr('abcd',3,4) == 'cd'");
|
|
vrfy(substr('abcd',1,3) == 'abc', "843: substr('abcd',1,3) == 'abc'");
|
|
vrfy(xor(17,17) == 0, '844: xor(17,17) == 0');
|
|
vrfy(xor(12,5) == 9, '845: xor(12,5) == 9');
|
|
vrfy(mmin(3,7) == 3, '846: mmin(3,7) == 3');
|
|
vrfy(mmin(4,7) == -3, '847: mmin(4,7) == -3');
|
|
vrfy(digit(123,2) == 1, '848: digit(123,2) == 1');
|
|
vrfy(ismult(3/4, 1/7) == 0, '849: ismult(3/4, 1/7) == 0');
|
|
vrfy(gcd(3/4, 1/7) == 1/28, '850: gcd(3/4,1/7) == 1/28');
|
|
vrfy(gcd(2,3,1/2) == 1/2, '851: gcd(2,3,1/2) == 1/2');
|
|
vrfy(gcd(17,7,1/7) == 1/7, '852: gcd(17,7,1/7) == 1/7');
|
|
vrfy(gcd(2) == 2, '853: gcd(2) == 2');
|
|
vrfy(gcd(-2) == 2, '854: gcd(-2) == 2');
|
|
vrfy(floor(1.5) == 1, '855: floor(1.5) == 1');
|
|
vrfy(floor(.5) == 0, '856: floor(.5) == 0');
|
|
vrfy(floor(-.5) == -1, '857: floor(-.5) == -1');
|
|
vrfy(floor(-1.5) == -2, '858: floor(-1.5) == -2');
|
|
vrfy(ceil(1.5) == 2, '859: ceil(1.5) == 2');
|
|
vrfy(ceil(.5) == 1, '860: ceil(.5) == 1');
|
|
vrfy(ceil(-.5) == 0, '861: ceil(-.5) == 0');
|
|
vrfy(ceil(-1.5) == -1, '862: ceil(-1.5) == -1');
|
|
vrfy(frac(-7.2) == -.2, '863: frac(-7.2) == -.2');
|
|
vrfy(gcd(4, 5, 1/3) == 1/3, '864: gcd(4, 5, 1/3) == 1/3');
|
|
vrfy(ltol(7/25) == 24/25, '865: ltol(7/25) == 24/25');
|
|
vrfy(hmean(1,2,3) == 18/11, '866: hmean(1,2,3) == 18/11');
|
|
vrfy(ilog2(2^-20) == -20, '867: ilog2(2^-20) == -20');
|
|
vrfy(ord("DBell") == 68, '868: ord("DBell") == 68');
|
|
vrfy(cmp("a","b") == -1, '869: cmp("a","b") == -1');
|
|
vrfy(cmp("abcd","abc") == 1, '870: cmp("abcd","abc") == 1');
|
|
vrfy(cmp(3,4i) == 1-1i, '871: cmp(3,4i) == 1-1i');
|
|
vrfy(cmp(4,4i) == 1-1i, '872: cmp(4,4i) == 1-1i');
|
|
vrfy(cmp(5,4i) == 1-1i, '873: cmp(5,4i) == 1-1i');
|
|
vrfy(cmp(-5,4i) == -1-1i, '874: cmp(-5,4i) == -1-1i');
|
|
vrfy(cmp(-4i,5) == -1-1i, '875: cmp(-4i,5) == -1-1i');
|
|
vrfy(cmp(-4i,-5) == 1-1i, '876: cmp(-4i,-5) == 1-1i');
|
|
vrfy(cmp(3i,4i) == -1i, '877: cmp(3i,4i) == -1i');
|
|
vrfy(cmp(4i,4i) == 0, '878: cmp(4i,4i) == 0');
|
|
vrfy(cmp(5i,4i) == 1i, '879: cmp(5i,4i) == 1i');
|
|
vrfy(cmp(3+4i,5) == -1+1i, '880: cmp(3+4i,5) == -1+1i');
|
|
vrfy(cmp(3+4i,-5) == 1+1i, '881: cmp(3+4i,-5) == 1+1i');
|
|
vrfy(cmp(3+4i,3+4i) == 0, '882: cmp(3+4i,3+4i) == 0');
|
|
vrfy(cmp(3+4i,3-4i) == 1i, '883: cmp(3+4i,3-4i) == 1i');
|
|
vrfy(cmp(3+4i,2+3i) == 1+1i, '884: cmp(3+4i,2+3i) == 1+1i');
|
|
vrfy(cmp(3+4i,-4-5i) == 1+1i, '885: cmp(3+4i,-4-5i) == 1+1i');
|
|
vrfy(comb(7,0) == 1, '886: comb(7,0) == 1');
|
|
vrfy(comb(0,0) == 1, '887: comb(0,0) == 1');
|
|
vrfy(perm(7,0) == 7, '888: perm(7,0) == 7');
|
|
vrfy(perm(0,0) == 0, '889: perm(0,0) == 0');
|
|
vrfy(isfile(files(0)) == 1, '890: isfile(files(0)) == 1');
|
|
vrfy(isfile(0) == 0, '891: isfile(0) == 0');
|
|
vrfy(ismult(4^67, 2^59) == 1, '892: ismult(4^67, 2^59) == 1');
|
|
vrfy(ismult(13, 4/67) == 0, '893: ismult(13, 4/67) == 0');
|
|
vrfy(ismult(13, 7/56) == 1, '894: ismult(13, 7/56) == 1');
|
|
vrfy(isnum(2i) == 1, '895: isnum(2i) == 1');
|
|
vrfy(iseven(1/3) == 0, '896: iseven(1/3) == 0');
|
|
vrfy(isodd(1/3) == 0, '897: isodd(1/3) == 0');
|
|
vrfy(isrel(-5, 6) == 1, '898: isrel(-5, 6) == 1');
|
|
vrfy(isrel(-2, 6) == 0, '899: isrel(-2, 6) == 0');
|
|
vrfy(isset(9,0) == 1, '900: isset(9,0) == 1');
|
|
vrfy(isset(9,1) == 0, '901: isset(9,1) == 0');
|
|
vrfy(isset(9,2) == 0, '902: isset(9,2) == 0');
|
|
vrfy(isset(9,3) == 1, '903: isset(9,3) == 1');
|
|
vrfy(isset(1.25, -2) == 1, '904: isset(1.25, -2) == 1');
|
|
vrfy(isset(1.25, -1) == 0, '905: isset(1.25, -1) == 0');
|
|
vrfy(isset(1.25, 0) == 1, '906: isset(1.25, 0) == 1');
|
|
vrfy(isset(pi(), 1) == 1, '907: isset(pi(), 1) == 1');
|
|
vrfy(isset(pi(), -2) == 0, '908: isset(pi(), -2) == 0');
|
|
vrfy(isset(pi(), -3) == 1, '909: isset(pi(), -3) == 1');
|
|
vrfy(istype(2, 3.0) == 1, '910: istype(2, 3.0) == 1');
|
|
vrfy(istype(2, "2") == 0, '911: istype(2, "2") == 0');
|
|
vrfy(istype(2, 3i) == 0, '912: istype(2, 3i) == 0');
|
|
vrfy(istype(2i+2, 3i) == 1, '913: istype(2i+2, 3i) == 1');
|
|
a = epsilon();
|
|
print '914: a = epsilon()';
|
|
vrfy(epsilon(a) == epsilon(), '915: epsilon(a) == epsilon()');
|
|
vrfy(epsilon(a) == epsilon(), '916: epsilon(a) == epsilon()');
|
|
vrfy(epsilon(a) == epsilon(), '917: epsilon(a) == epsilon()');
|
|
vrfy(epsilon() == a, '918: epsilon() == a');
|
|
b = 1e-6;
|
|
print '919: b = 1e-6';
|
|
vrfy(epsilon(b) == a, '920: epsilon(b) == a');
|
|
vrfy(epsilon(b) == epsilon(), '921: epsilon(b) == epsilon()');
|
|
vrfy(epsilon(b) == epsilon(), '922: epsilon(b) == epsilon()');
|
|
vrfy(epsilon(b) == epsilon(), '923: epsilon(b) == epsilon()');
|
|
vrfy(epsilon() == 1e-6, '924: epsilon() == 1e-6');
|
|
vrfy(epsilon(a) == b, '925: epsilon(a) == b');
|
|
vrfy(epsilon(a) == epsilon(), '926: epsilon(a) == epsilon()');
|
|
vrfy(epsilon(a) == epsilon(), '927: epsilon(a) == epsilon()');
|
|
vrfy(epsilon(a) == epsilon(), '928: epsilon(a) == epsilon()');
|
|
vrfy(epsilon(a) == a, '929: epsilon(a) == a');
|
|
vrfy(quomod(13,5,a,b) == 1, '930: quomod(13,5,a,b) == 1');
|
|
vrfy(a == 2, '931: a == 2');
|
|
vrfy(b == 3, '932: b == 3');
|
|
vrfy(quomod(15.6,5.2,a,b) == 0, '933: quomod(15.6,5.2,a,b) == 0');
|
|
vrfy(a == 3, '934: a == 3');
|
|
vrfy(b == 0, '935: b == 0');
|
|
vrfy(putenv("abcd=efg") == 0, '936: putenv("abcd=efg")');
|
|
vrfy(getenv("abcd") == "efg", '937: getenv("abcd") == "efg"');
|
|
vrfy(putenv("abcd","123")==0, '938: putenv("abcd","123")');
|
|
vrfy(getenv("abcd") == "123", '939: getenv("abcd") == "123"');
|
|
vrfy(isnull(getenv("notavar")) == 1,
|
|
'940: isnull(getenv("notavar")) == 1');
|
|
a = "abcdefg";
|
|
print '941: a = "abcdefg"';
|
|
vrfy(strpos(a, "c") == 3, '942: strpos(a, "c") == 3');
|
|
vrfy(strpos(a, "def") == 4, '943: strpos(a, "def") == 4');
|
|
vrfy(strpos(a, "defg") == 4, '944: strpos(a, "defg") == 4');
|
|
vrfy(strpos(a, "defgh") == 0, '945: strpos(a, "defgh") == 0');
|
|
vrfy(strpos(a, "abc") == 1, '946: strpos(a, "abc") == 1');
|
|
vrfy(strpos(a, "xyz") == 0, '947: strpos(a, "xyz") == 0');
|
|
vrfy(strpos(a, a) == 1, '948: strpos(a, a) == 1');
|
|
vrfy(system("") == 0, '949: system("") == 0');
|
|
vrfy(system("true") == 0, '950: system("true") == 0');
|
|
vrfy(isatty(files(0)) == 1, '951: isatty(files(0)) == 1');
|
|
print '952: test removed';
|
|
print '953: test removed';
|
|
vrfy(isstr(cmdbuf()) == 1, '954: isstr(cmdbuf()) == 1');
|
|
vrfy(abs(root(4,3,0.1)-1.5874) < 0.1,
|
|
'955: abs(root(4,3,0.1)-1.5874) < 0.1');
|
|
print '956: a = 2^300 + 69962309754533779525365054067';
|
|
a = 2^300 + 69962309754533779525365054067;
|
|
a /= 2^211;
|
|
print '957: a /= 2^211';
|
|
vrfy(appr(a, 1e-20) == 2^89, '958: appr(a, 1e-20) == 2^89');
|
|
vrfy(digits(5e149) == 150, '959: digits(5e149) == 150');
|
|
vrfy(highbit(2) == 1, '960: highbit(2) == 1');
|
|
vrfy(highbit(3) == 1, '961: highbit(3) == 1');
|
|
vrfy(highbit(4) == 2, '962: highbit(4) == 2');
|
|
vrfy(highbit(-15) == 3, '963: highbit(-15) == 3');
|
|
vrfy(highbit(2^27) == 27, '964: highbit(2^27) == 27');
|
|
a = 12.34;
|
|
print '965: a = 12.34';
|
|
vrfy(digit(a,2) == 0, '966: digit(a,2) == 0');
|
|
vrfy(digit(a,1) == 1, '967: digit(a,1) == 1');
|
|
vrfy(digit(a,0) == 2, '968: digit(a,0) == 2');
|
|
vrfy(digit(a,-1) == 3, '969: digit(a,-1) == 3');
|
|
vrfy(digit(a,-2) == 4, '970: digit(a,-2) == 4');
|
|
a = 10/7;
|
|
print '971: a = 10/7';
|
|
vrfy(digit(a,1) == 0, '972: digit(a,1) == 0');
|
|
vrfy(digit(a,0) == 1, '973: digit(a,0) == 1');
|
|
vrfy(digit(a,-1) == 4, '974: digit(a,-1) == 4');
|
|
vrfy(digit(a,-2) == 2, '975: digit(a,-2) == 2');
|
|
vrfy(digit(a,-3) == 8, '976: digit(a,-3) == 8');
|
|
vrfy(digits(0) == 1, '977: digits(0) == 1');
|
|
vrfy(digits(0.0123) == 1, '978: digits(0.0123) == 1');
|
|
vrfy(digits(3.7) == 1, '979: digits(3.7) == 1');
|
|
vrfy(digits(-27) == 2, '980: digits(-27) == 2');
|
|
vrfy(digits(-99.7) == 2, '981: digits(-99.7) == 2');
|
|
vrfy(ilog2(1) == 0, '982: ilog2(1) == 0');
|
|
vrfy(ilog2(2) == 1, '983: ilog2(2) == 1');
|
|
vrfy(ilog2(3) == 1, '984: ilog2(3) == 1');
|
|
vrfy(ilog2(4) == 2, '985: ilog2(4) == 2');
|
|
vrfy(ilog2(1/15) == -4, '986: ilog2(1/15) == -4');
|
|
vrfy(places(3) == 0, '987: places(3) == 0');
|
|
vrfy(places(0.0123) == 4, '988: places(0.0123) == 4');
|
|
vrfy(places(3.70) == 1, '989: places(3.70) == 1');
|
|
vrfy(places(1e-10) == 10, '990: places(1e-10) == 10');
|
|
vrfy(places(3/7) == -1, '991: places(/37) == -1');
|
|
vrfy(ilog10(7.7) == 0, '992: ilog10(7.7) == 0');
|
|
vrfy(ilog10(77.7) == 1, '993: ilog10(77.7) == 1');
|
|
vrfy(ilog10(777) == 2, '994: ilog10(777) == 2');
|
|
vrfy(ilog10(.00777) == -3, '995: ilog10(.00777) == -3');
|
|
vrfy(ilog10(1e27) == 27, '996: ilog10(1e27) == 27');
|
|
vrfy(lowbit(2) == 1, '997: lowbit(2) == 1');
|
|
vrfy(lowbit(3) == 0, '998: lowbit(3) == 0');
|
|
vrfy(lowbit(4) == 2, '999: lowbit(4) == 2');
|
|
vrfy(lowbit(-15) == 0, '1000: lowbit(-15) == 0');
|
|
vrfy(lowbit(2^27) == 27, '1001: lowbit(2^27) == 27');
|
|
vrfy(char(0102) == 'B', '1002: char(0102) == \'B\'');
|
|
vrfy(char(0x6f) == 'o', '1003: char(0x6f) == \'o\'');
|
|
vrfy(char(119) == 'w', '1004: char(119) == \'w\'');
|
|
vrfy(char(0145) == 'e', '1005: char(0145) == \'e\'');
|
|
vrfy(char(0x6e) == 'n', '1006: char(0x6e) == \'n\'');
|
|
vrfy(den(-1.25) == 4, '1007: den(-1.25) == 4');
|
|
vrfy(den(121/33) == 3, '1008: den(121/33) == 3');
|
|
vrfy(gcd(9/10, 11/5, 4/25) == 0.02,
|
|
'1009: gcd(9/10, 11/5, 4/25) == 0.02');
|
|
vrfy(gcd(0,0,0,0,0) == 0, '1010: gcd(0,0,0,0,0) == 0');
|
|
vrfy(hypot(3, 4, 1e-6) == 5, '1011: hypot(3, 4, 1e-6) == 5');
|
|
vrfy(hypot(2,-3,1e-6) == 3605551/1e6,
|
|
'1012: hypot(2,-3,1e-6) == 3605551/1e6');
|
|
vrfy(im(-4.25 - 7i) == -7, '1013: im(-4.25 - 7i) == -7');
|
|
vrfy(lcm(12, -24, 30) == -120,'1014: lcm(12, -24, 30) == -120');
|
|
vrfy(lcm(9/10, 11/5, 4/25) == 79.2,
|
|
'1015: lcm(9/10, 11/5, 4/25) == 79.2');
|
|
vrfy(lcm(2) == 2, '1016: lcm(2) == 2');
|
|
vrfy(max(2) == 2, '1017: max(2) == 2');
|
|
vrfy(min(2) == 2, '1018: min(2) == 2');
|
|
vrfy(re(-4.25 - 7i) == -4.25, '1019: re(-4.25 - 7i) == -4.25');
|
|
vrfy(size("abc") == 3, '1020: size("abc") == 3');
|
|
vrfy(str("") == "", '1021: str("") == ""');
|
|
vrfy(str(null()) == "", '1022: str(null()) == ""');
|
|
vrfy(str("Ernest Bowen") == "Ernest Bowen",
|
|
'1023: str("Ernest Bowen") == "Ernest Bowen"');
|
|
vrfy(strlen("a b\tc\\d") == 7,
|
|
'1024: strlen("a b\tc\\d") == 7');
|
|
vrfy(xor(2) == 2, '1025: xor(2) == 2');
|
|
vrfy(xor(5, 3, -7, 2, 9) == 10,
|
|
'1026: xor(5, 3, -7, 2, 9) == 10');
|
|
vrfy(xor(0,0) == 0, '1027: xor(0,0) == 0');
|
|
vrfy(xor(0,1) == 1, '1028: xor(0,1) == 1');
|
|
vrfy(xor(1,0) == 1, '1029: xor(1,0) == 1');
|
|
vrfy(xor(1,1) == 0, '1030: xor(1,1) == 0');
|
|
vrfy(xor(5,3,-7,2,9) == 10, '1031: xor(5,3,-7,2,9) == 10');
|
|
vrfy(fib(-2) == -1, '1032: fib(-2) == -1');
|
|
vrfy(fib(-1) == 1, '1033: fib(-1) == 1');
|
|
vrfy(fib(-10) == -55, '1034: fib(-10) == -55');
|
|
vrfy(ilog(1/8, 3) == -2, '1035: ilog(1/8, 3) == -2');
|
|
vrfy(ilog(8.9, 3) == 1, '1036: ilog(8.9, 3) == 1');
|
|
vrfy(iroot(1,9) == 1, '1037: iroot(1,9) == 1');
|
|
vrfy(iroot(pi()^8,5) == 6, '1038: iroot(pi()^8,5)');
|
|
vrfy(isqrt(8.5) == 2, '1039: isqrt(8.5) == 2');
|
|
vrfy(isqrt(2e56) == 14142135623730950488016887242,
|
|
'1040: isqrt(2e56) == 14142135623730950488016887242');
|
|
vrfy(near(22/7, 3.15, .01) == -1,
|
|
'1041: near(22/7, 3.15, .01) == -1');
|
|
vrfy(near(22/7, 3.15, .005) == 1,
|
|
'1042: near(22/7, 3.15, .005) == 1');
|
|
vrfy(norm(3.4) == 11.56, '1043: isqrt(3.4) == 11.56');
|
|
vrfy(pi(1e-5) == 3.14159, '1044: pi(1e-5) == 3.14159');
|
|
pi = pi(1e-10);
|
|
print '1045: pi = pi(1e-10)';
|
|
vrfy(pi == 3.1415926536, '1046: pi == 3.1415926536');
|
|
vrfy(polar(2,pi/2,1e-5)==2i, '1047: polar(2,pi/2,1e-5)==2i');
|
|
vrfy(power(exp(1,1e-20),pi(1e-20)*1i/2,1e-20) == 1i,
|
|
'1048: power(exp(1,1e-20),pi(1e-20)*1i/2,1e-20) == i1');
|
|
vrfy(ssq(1+2i, 3-4i, 5 +6i) == -21+40i,
|
|
'1049: ssq(1+2i, 3-4i, 5 +6i) == -21+40i');
|
|
vrfy(isreal(ln(1 + 1e-10i, 1e-5)),
|
|
'1050: isreal(ln(1 + 1e-10i, 1e-5))');
|
|
vrfy(isreal(exp(pi(1e-10)*1i, 1e-5)),
|
|
'1051: isreal(exp(pi(1e-10)*1i, 1e-5))');
|
|
vrfy(cfappr(43/30, 10, 0) == 10/7,
|
|
'1052: cfappr(43/30, 10, 0) == 10/7');
|
|
vrfy(cfappr(43/30, 10, 1) == 13/9,
|
|
'1053: cfappr(43/30, 10, 1) == 13/9');
|
|
vrfy(cfappr(43/30, 10, 16) == 10/7,
|
|
'1054: cfappr(43/30, 10, 16) == 10/7');
|
|
vrfy(cfappr(6/5, 1/2, 16) == 1,
|
|
'1055: cfappr(6/5, 1/2, 16) == 1');
|
|
vrfy(cfsim(13,8) == 0, '1056: cfsim(13,8) == 0');
|
|
vrfy(cfsim(1057,8) == 0, '1057: cfsim(1057,8) == 0');
|
|
vrfy(mod(11,5,0) == 1, '1058: mod(11,5,0) == 1');
|
|
vrfy(mod(11,5,1) == -4, '1059: mod(11,5,1) == -4');
|
|
vrfy(mod(-11,5,2) == -1, '1060: mod(-11,5,2) == -1');
|
|
vrfy(mod(-11,-5,3) == 4, '1061: mod(-11,-5,3) == 4');
|
|
vrfy(mod(12.5,5,16) == 2.5, '1062: mod(12.5,5,16) == 2.5');
|
|
vrfy(mod(12.5,5,17) == -2.5, '1063: mod(12.5,5,17) == -2.5');
|
|
vrfy(mod(12.5,5,24) == 2.5, '1064: mod(12.5,5,24) == 2.5');
|
|
vrfy(mod(-7.5,-5,24) == 2.5, '1065: mod(-7.5,-5,24) == 2.5');
|
|
vrfy(quo(11,5,0) == 2, '1066: quo(11,5,0) == 2');
|
|
vrfy(quo(11,5,1) == 3, '1067: quo(11,5,1) == 3');
|
|
vrfy(quo(-11,5,2) == -2, '1068: quo(-11,5,2) == -2');
|
|
vrfy(quo(-11,-5,3) == 3, '1069: quo(-11,-5,3) == 3');
|
|
vrfy(quo(12.5,5,16) == 2, '1070: quo(12.5,5,16) == 2');
|
|
vrfy(quo(12.5,5,17) == 3, '1071: quo(12.5,5,17) == 3');
|
|
vrfy(quo(12.5,5,24) == 2, '1072: quo(12.5,5,24) == 2');
|
|
vrfy(quo(-7.5,-5,24) == 2, '1073: quo(-7.5,-5,24) == 2');
|
|
vrfy(frac(2.5 + 3i) == .5, '1074: frac(2.5 + 3i) == .5');
|
|
vrfy(root(1i,1000,1e-2)==1, '1075: root(1i,1000,1e-2) == 1');
|
|
vrfy(scale(2+3i,2)==8+12i, '1076: scale(2+3i,2) == 8+12i');
|
|
vrfy(frem(8,4) == 2, '1077: frem(8,4) == 2');
|
|
vrfy(jacobi(80,199) == 1, '1078: jacobi(80,199) == 1');
|
|
|
|
print '1079: Ending test_functions';
|
|
|
|
print;
|
|
print '1100: reserved for future expansion of test_functions';
|
|
}
|
|
print '017: parsed test_functions()';
|
|
|
|
|
|
/*
|
|
* _test_underscore - test use of _'s in identifiers
|
|
*/
|
|
_ = 49;
|
|
print '018: _ = 49';
|
|
__ = 63;
|
|
print "019: __ = 63";
|
|
define _test_underscore()
|
|
{
|
|
local _a = 27;
|
|
local __a = 23209;
|
|
|
|
print "1200: Beginning _test_underscore";
|
|
|
|
vrfy(_a == 27, '1201: _a == 27');
|
|
vrfy(_ == 49, '1202: _ == 49');
|
|
vrfy(__ == 63, '1203: __ == 63');
|
|
vrfy(__a == 23209, '1204: __a == 23209');
|
|
|
|
print "1205: Ending _test_underscore";
|
|
}
|
|
print '020: parsed _test_underscore';
|
|
|
|
|
|
/*
|
|
* place holder for any print items
|
|
*/
|
|
print "021:", "reserved for future use";
|
|
print "022:": " reserved for future use";
|
|
|
|
|
|
/*
|
|
* Test associations
|
|
*/
|
|
define test_assoc()
|
|
{
|
|
static a;
|
|
static b;
|
|
local A;
|
|
|
|
print '1300: Beginning associations test';
|
|
|
|
a = assoc();
|
|
vrfy(size(a) == 0, '1301: size(a) == 0');
|
|
a["curds"] = 13;
|
|
print '1302: a["curds"] = 13';
|
|
vrfy(a["curds"] == 13, '1303: a["curds"] == 13');
|
|
a[13] = 17;
|
|
print '1304: a[13] = 17';
|
|
vrfy(a[13] == 17, '1305: a[13] == 17');
|
|
vrfy(a[a["curds"]] == 17, '1306: a[a["curds"]] == 17');
|
|
a[17] = 19;
|
|
print '1307: a[17] = 19';
|
|
vrfy(a[17] == 19, '1308: a[17] == 19');
|
|
vrfy(a[a["curds"]+4] == 19, '1309: a[a["curds"]+4] == 19');
|
|
vrfy(size(a) == 3, '1310: size(a) == 3');
|
|
vrfy(a[[search(a,17)]] == 17, '1311: (a[[search(a,17)]] == 17');
|
|
vrfy(isnull(search(a,16)), '1312: isnull(search(a,16))');
|
|
a["curds","whey"] = "spider";
|
|
print '1313: a["curds","whey"] = "spider"';
|
|
vrfy(a["curds","whey"] == "spider", '1314: a["curds","whey"] == "spider"');
|
|
vrfy(a[[rsearch(a,"spider")]] == "spider", '1315: a[[search(a,"spider")]] == "spider"');
|
|
b = a;
|
|
print '1316: b = a';
|
|
vrfy(b[17] == 19, '1317: b[17] == 19');
|
|
vrfy(a == b, '1318: a == b');
|
|
vrfy(isassoc(a) == 1, '1319: isassoc(a) == 1');
|
|
vrfy(isassoc(1) == 0, '1320: isassoc(1) == 0');
|
|
A = assoc();
|
|
vrfy(quomod(13, 5, A[1], A[2]) == 1,
|
|
'1321: quomod(13, 5, A[1], A[2]) == 1');
|
|
vrfy(A[1] == 2, '1322: A[1] == 2');
|
|
vrfy(A[2] == 3, '1323: A[2] == 3');
|
|
|
|
print '1324: Ending associations test';
|
|
}
|
|
print '023: parsed test_assoc()';
|
|
|
|
|
|
/*
|
|
* Test lists
|
|
*/
|
|
define test_list()
|
|
{
|
|
static a;
|
|
static b;
|
|
static x = list(11,13,17,23,29);
|
|
static y0 = list(1,3,7,3,9);
|
|
static y1 = list(-9,-7,-3,-7,-1);
|
|
static y2 = list(-9,-7,-3,3,9);
|
|
static y3 = list(1,3,7,-7,-1);
|
|
static y4 = list(1,3,-3,3,-1);
|
|
local A,B,C,D,E;
|
|
local y,z;
|
|
local list1, list2;
|
|
|
|
print '1400: Beginning list test';
|
|
|
|
a = list(2,3,5);
|
|
vrfy(a == list(2,3,5), '1401: a == list(2,3,5)');
|
|
vrfy(a[[0]] == 2, '1402: a[[0]] == 2');
|
|
vrfy(a[[1]] == 3, '1403: a[[1]] == 3');
|
|
vrfy(a[[2]] == 5, '1404: a[[2]] == 5');
|
|
vrfy(size(a) == 3, '1405: size(a) == 3');
|
|
vrfy(search(a,3) == 1, '1406: search(a,3) == 1');
|
|
vrfy(isnull(search(a,3,2)), '1407: isnull(search(a,3,2))');
|
|
vrfy(rsearch(a,3,2) == 1, '1408: rsearch(a,3,2) == 1');
|
|
push(a,7);
|
|
print '1409: push(a,7)';
|
|
vrfy(search(a,7) == 0, '1410: search(a,7) == 0');
|
|
vrfy(pop(a) == 7, '1411: pop(a) == 7');
|
|
vrfy(size(a) == 3, '1412: size(a) == 3');
|
|
append(a,7);
|
|
print '1413: append(a,7)';
|
|
vrfy(search(a,7) == 3, '1414: search(a,7) == 3');
|
|
vrfy(size(a) == 4, '1415: size(a) == 4');
|
|
vrfy(remove(a) == 7, '1416: remove(a) == 7');
|
|
vrfy(size(a) == 3, '1417: size(a) == 3');
|
|
b = a;
|
|
print '1418: b = a';
|
|
insert(a,1,7);
|
|
print '1419: insert(a,1,7)';
|
|
vrfy(search(a,2) == 0, '1420: search(a,2) == 0');
|
|
vrfy(search(a,7) == 1, '1421: search(a,7) == 1');
|
|
vrfy(search(a,3) == 2, '1422: search(a,3) == 2');
|
|
vrfy(search(a,5) == 3, '1423: search(a,5) == 3');
|
|
vrfy(size(a) == 4, '1424: size(a) == 4');
|
|
vrfy(delete(a,1) == 7, '1425: remove(a) == 7');
|
|
vrfy(search(a,2) == 0, '1426: search(a,2) == 0');
|
|
vrfy(search(a,3) == 1, '1427: search(a,3) == 1');
|
|
vrfy(search(a,5) == 2, '1428: search(a,5) == 2');
|
|
vrfy(size(a) == 3, '1429: size(a) == 3');
|
|
vrfy(a == b, '1430: a == b');
|
|
A = list(1,2,3);
|
|
print '1431: A = list(1,2,3)';
|
|
B = list(4,5);
|
|
print '1432: B = list(4,5)';
|
|
C = join(A,B);
|
|
print '1433: C = join(A,B)';
|
|
D = list(1,2,3,4,5);
|
|
print '1434: D = list(1,2,3,4,5)';
|
|
vrfy(C == D, '1435: C == D');
|
|
E = list(5,4,3,2,1);
|
|
print '1436: E = list(5,4,3,2,1)';
|
|
vrfy(reverse(D) == E, '1437: reverse(D) == E');
|
|
vrfy(sort(list(1,3,5,2,4))==D,'1438: sort(list(1,3,5,2,4))==D');
|
|
vrfy(head(D,2) == list(1,2), '1439: head(D,2) == list(1,2)');
|
|
vrfy(head(D,-2)==list(1,2,3), '1440: head(D,-2)==list(1,2,3)');
|
|
vrfy(head(D,5) == D, '1441: head(D,5) == D');
|
|
vrfy(head(D,6) == D, '1442: head(D,6) == D');
|
|
vrfy(head(D,-5) == list(), '1443: head(D,-5) == list()');
|
|
vrfy(head(D,-6) == list(), '1444: head(D,-6) == list()');
|
|
vrfy(tail(E,2) == list(2,1), '1445: tail(E,2) == list(2,1)');
|
|
vrfy(tail(E,-2)==list(3,2,1), '1446: tail(E,-2)==list(3,2,1)');
|
|
vrfy(tail(E,5) == E, '1447: tail(E,5) == E');
|
|
vrfy(tail(E,6) == E, '1448: tail(E,6) == E');
|
|
vrfy(tail(E,-5) == list(), '1449: tail(E,-5) == list()');
|
|
vrfy(tail(E,-6) == list(), '1450: tail(E,-6) == list()');
|
|
vrfy(segment(D,1,3) == list(2,3,4),
|
|
'1451: segment(D,1,3) == list(2,3,4)');
|
|
vrfy(segment(D,3,1) == list(4,3,2),
|
|
'1452: segment(D,3,1) == list(4,3,2)');
|
|
vrfy(segment(D,0,2) == head(D,3),
|
|
'1453: segment(D,0,2) == head(D,3)');
|
|
vrfy(segment(D,2,0) == tail(E,3),
|
|
'1454: segment(D,2,0) == tail(E,3)');
|
|
vrfy(segment(D,0,4) == head(D,5),
|
|
'1455: segment(D,0,4) == head(D,5)');
|
|
vrfy(segment(D,4,0) == head(E,5),
|
|
'1456: segment(D,4,0) == head(E,5)');
|
|
vrfy(segment(D,3,4) == tail(D,2),
|
|
'1457: segment(D,3,4) == tail(D,2)');
|
|
vrfy(segment(D,4,3) == head(E,2),
|
|
'1458: segment(D,4,3) == head(E,2)');
|
|
for (y=0; y < size(D); ++y) {
|
|
for (z=y; z < size(D); ++z) {
|
|
if (D != join(head(D,y), segment(D,y,z), tail(D,size(D)-z-1))) {
|
|
err(strcat("join loop failed at y=",str(y)," z=",str(z)));
|
|
}
|
|
}
|
|
}
|
|
print '1459: join loop test';
|
|
vrfy(mod(x,10,0) == y0, '1460: mod(x,10,0) == y0');
|
|
vrfy(mod(x,10,1) == y1, '1461: mod(x,10,1) == y1');
|
|
vrfy(mod(x,10,2) == y0, '1462: mod(x,10,2) == y0');
|
|
vrfy(mod(x,10,3) == y1, '1463: mod(x,10,3) == y1');
|
|
vrfy(mod(x,10,4) == y0, '1464: mod(x,10,4) == y0');
|
|
vrfy(mod(x,10,5) == y1, '1465: mod(x,10,5) == y1');
|
|
vrfy(mod(x,10,6) == y0, '1466: mod(x,10,6) == y0');
|
|
vrfy(mod(x,10,7) == y1, '1467: mod(x,10,7) == y1');
|
|
vrfy(mod(x,10,8) == y2, '1468: mod(x,10,8) == y2');
|
|
vrfy(mod(x,10,9) == y3, '1469: mod(x,10,9) == y3');
|
|
vrfy(mod(x,10,10) == y2, '1470: mod(x,10,10) == y2');
|
|
vrfy(mod(x,10,11) == y3, '1471: mod(x,10,11) == y3');
|
|
vrfy(mod(x,10,12) == y2, '1472: mod(x,10,12) == y2');
|
|
vrfy(mod(x,10,13) == y3, '1473: mod(x,10,13) == y3');
|
|
vrfy(mod(x,10,14) == y2, '1474: mod(x,10,14) == y2');
|
|
vrfy(mod(x,10,15) == y3, '1475: mod(x,10,15) == y3');
|
|
vrfy(mod(x,10,16) == y4, '1476: mod(x,10,16) == y4');
|
|
vrfy(mod(x,10,16) == y4, '1477: mod(x,10,16) == y4');
|
|
vrfy(mod(x,10,18) == y4, '1478: mod(x,10,18) == y4');
|
|
vrfy(mod(x,10,19) == y4, '1479: mod(x,10,18) == y4');
|
|
vrfy(mod(x,10,20) == y4, '1480: mod(x,10,20) == y4');
|
|
vrfy(mod(x,10,21) == y4, '1481: mod(x,10,21) == y4');
|
|
vrfy(mod(x,10,22) == y4, '1482: mod(x,10,22) == y4');
|
|
vrfy(mod(x,10,23) == y4, '1483: mod(x,10,23) == y4');
|
|
vrfy(mod(x,10,24) == y4, '1484: mod(x,10,24) == y4');
|
|
vrfy(mod(x,10,25) == y4, '1485: mod(x,10,25) == y4');
|
|
vrfy(mod(x,10,26) == y4, '1486: mod(x,10,26) == y4');
|
|
vrfy(mod(x,10,27) == y4, '1487: mod(x,10,27) == y4');
|
|
vrfy(mod(x,10,28) == y4, '1488: mod(x,10,28) == y4');
|
|
vrfy(mod(x,10,29) == y4, '1489: mod(x,10,29) == y4');
|
|
vrfy(mod(x,10,30) == y4, '1490: mod(x,10,30) == y4');
|
|
vrfy(mod(x,10,31) == y4, '1491: mod(x,10,31) == y4');
|
|
list1 = list(3,1,"x",2,null());
|
|
print '1492: list1 = list(3,1,"x",2,null())';
|
|
list2 = list(null(),1,2,3,"x");
|
|
print '1493: list2 = list(null(),1,2,3,"x")';
|
|
vrfy(sort(list1) == list2, '1494: sort(list1) == list2');
|
|
|
|
print '1495: Ending list test';
|
|
}
|
|
print '024: parsed test_list()';
|
|
|
|
|
|
/*
|
|
* Test rand
|
|
*/
|
|
define test_rand()
|
|
{
|
|
local init; /* initial generator state */
|
|
local state0; /* a generator state */
|
|
local state1; /* a generator state */
|
|
local state2; /* a generator state */
|
|
local tmp;
|
|
local n;
|
|
|
|
print '1500: Beginning rand test';
|
|
|
|
/* test save and restore of the initial state */
|
|
tmp = srand(0);
|
|
print '1501: tmp = srand(0)';
|
|
init = srand();
|
|
print '1502: init = srand()';
|
|
state0 = srand(0);
|
|
print '1503: state0 = srand(0)';
|
|
vrfy(state0 == init, '1504: state0 == init');
|
|
|
|
/* test the additive 55 shuffle generator */
|
|
tmp = srand(0);
|
|
print '1505: tmp = srand(0)';
|
|
vrfy(rand() == 0xc79ef743e2e6849c, \
|
|
'1506: rand() == 0xc79ef743e2e6849c');
|
|
vrfy(rand() == 0x8d2dcb2bed321284, \
|
|
'1507: rand() == 0x8d2dcb2bed321284');
|
|
tmp = srand(init);
|
|
print '1508: tmp = srand(init)';
|
|
vrfy(rand() == 0xc79ef743e2e6849c, \
|
|
'1509: rand() == 0xc79ef743e2e6849c');
|
|
vrfy(rand() == 0x8d2dcb2bed321284, \
|
|
'1510: rand() == 0x8d2dcb2bed321284');
|
|
|
|
/* test range interface */
|
|
tmp = srand(0);
|
|
print '1511: tmp = srand(0)';
|
|
vrfy(rand(12345678901234567890) == 0x8d2dcb2bed321284, \
|
|
'1512: rand(12345678901234567890) == 0x8d2dcb2bed321284');
|
|
vrfy(rand(216091) == 0x13d2b, '1513: rand(216091) == 0x13d2b');
|
|
vrfy(rand(100) == 0x26, '1514: rand(100) == 0x26');
|
|
vrfy(rand(-46,46) == -0xf, '1515: rand(-46,46) == -0xf');
|
|
tmp = srand(0);
|
|
print '1516: tmp = srand(0)';
|
|
vrfy(rand(2^64) == 0xc79ef743e2e6849c, \
|
|
'1517: rand(2^64) == 0xc79ef743e2e6849c');
|
|
vrfy(rand(0,2^64) == 0x8d2dcb2bed321284, \
|
|
'1518: rand(0,2^64) == 0x8d2dcb2bed321284');
|
|
|
|
/* test different forms of seeding the initial state */
|
|
tmp = srand(0);
|
|
print '1519: tmp = srand(0)';
|
|
vrfy(srand() == init, '1520: srand() == init');
|
|
tmp = srand(0x87e6ec938ff55aa5<<64);
|
|
print '1521: tmp = srand(0x87e6ec938ff55aa5<<64)';
|
|
vrfy(srand() == init, '1522: srand() == init');
|
|
tmp = srand(state0);
|
|
print '1523: tmp = srand(state0)';
|
|
vrfy(srand() == init, '1524: srand() == init');
|
|
tmp = srand(init);
|
|
print '1525: tmp = srand(init)';
|
|
vrfy(srand() == init, '1526: srand() == init');
|
|
vrfy(tmp == init, '1527: tmp == init');
|
|
|
|
/* test the bit length interface */
|
|
tmp = srand(0);
|
|
print '1528: tmp = srand(0)';
|
|
vrfy(randbit(64) == 0xc79ef743e2e6849c, \
|
|
'1529: randbit(64) == 0xc79ef743e2e6849c');
|
|
vrfy(randbit(128) == 0x8d2dcb2bed3212844f4ad31f3818af34, \
|
|
'1530: randbit(128) == 0x8d2dcb2bed3212844f4ad31f3818af34');
|
|
vrfy(randbit(64) == 0x23a252f60bae4907, \
|
|
'1531: randbit(64) == 0x23a252f60bae4907');
|
|
vrfy(randbit(128) == 0xa8ed5b6203e2b1da32848cd9b3f1e3fa, \
|
|
'1532: randbit(128) == 0xa8ed5b6203e2b1da32848cd9b3f1e3fa');
|
|
tmp = srand(0);
|
|
print '1533: tmp = srand(0)';
|
|
vrfy(randbit(32) == 0xc79ef743, '1534: randbit(64) == 0xc79ef743');
|
|
vrfy(randbit(32) == 0xe2e6849c, '1535: randbit(64) == 0xe2e6849c');
|
|
vrfy(randbit(1) == 0x1, '1536: randbit(1) == 0x1');
|
|
vrfy(randbit(5) == 0x3, '1537: randbit(5) == 0x3');
|
|
vrfy(randbit(33) == 0x96e595f6, '1538: randbit(33) == 0x96e595f6');
|
|
vrfy(randbit(25) == 0x1321284, '1539: randbit(25) == 0x1321284');
|
|
vrfy(randbit(2) == 0x1, '1540: randbit(2) == 0x1');
|
|
vrfy(randbit(13) == 0x7a5, '1541: randbit(13) == 0x7a5');
|
|
vrfy(randbit(18) == 0x1a63e, '1542: randbit(19) == 0x1a63e');
|
|
vrfy(randbit(8) == 0x70, '1543: randbit(8) == 0x70');
|
|
vrfy(randbit(9) == 0x62, '1544: randbit(9) == 0x62');
|
|
vrfy(randbit(70) == 0x2f3423a252f60bae49, \
|
|
'1545: randbit(70) == 0x2f3423a252f60bae49');
|
|
print '1546: test unused';
|
|
vrfy(randbit(8) == 0x7, '1547: randbit(8) == 0x7');
|
|
vrfy(randbit(65) == 0x151dab6c407c563b4, \
|
|
'1548: randbit(65) == 0x151dab6c407c563b4');
|
|
vrfy(randbit(63) == 0x32848cd9b3f1e3fa, \
|
|
'1549: randbit(63) == 0x32848cd9b3f1e3fa');
|
|
|
|
/* check to be sure that the srand(1) bug was fixed */
|
|
tmp = srand(1);
|
|
print '1550: tmp = srand(1)';
|
|
n = 1;
|
|
print '1551: n = 1';
|
|
vrfy(num(n), '1552: num(n)');
|
|
vrfy(den(n), '1553: den(n)');
|
|
vrfy(randbit(64) == 0x4280429f8069cb27, \
|
|
'1554: randbit(64) == 0x4280429f8069cb27');
|
|
|
|
/* test randbit skip interface */
|
|
tmp = srand(0);
|
|
print '1555: tmp = srand(0)';
|
|
vrfy(randbit(20) == 817647, '1556: randbit(20) == 817647');
|
|
vrfy(randbit(20) == 476130, '1557: randbit(20) == 476130');
|
|
vrfy(randbit(20) == 944201, '1558: randbit(20) == 944201');
|
|
vrfy(randbit(20) == 822573, '1559: randbit(20) == 822573');
|
|
tmp = srand(0);
|
|
print '1560: tmp = srand(0)';
|
|
vrfy(randbit(-20) == 20, '1561: randbit(-20) == 20');
|
|
vrfy(randbit(20) == 476130, '1562: randbit(20) == 476130');
|
|
vrfy(randbit(-20) == 20, '1563: randbit(-20) == 20');
|
|
vrfy(randbit(20) == 822573, '1564: randbit(20) == 822573');
|
|
|
|
/* test randbit without and arg */
|
|
tmp = srand(0);
|
|
print '1565: tmp = srand(0)';
|
|
vrfy(randbit() == 1, '1566: randbit() == 1');
|
|
vrfy(randbit() == 1, '1567: randbit() == 1');
|
|
vrfy(randbit() == 0, '1568: randbit() == 0');
|
|
|
|
print '1569: Ending rand test';
|
|
}
|
|
print '025: parsed test_rand()';
|
|
|
|
|
|
/*
|
|
* Config mode/base testing
|
|
*/
|
|
define test_mode()
|
|
{
|
|
local tmp;
|
|
|
|
print '1600: Beginning mode/base test';
|
|
|
|
tmp = config("mode", "frac");
|
|
print '1601: tmp = config("mode", "frac")';
|
|
tmp = config("mode", "frac");
|
|
print '1602: tmp = config("mode", "frac")';
|
|
vrfy(base() == 1/3, '1603: base() == 1/3');
|
|
|
|
tmp = config("mode", "int");
|
|
print '1604: tmp = config("mode", "int")';
|
|
vrfy(tmp == "frac", '1605: tmp == "frac"');
|
|
vrfy(base() == -10, '1606: base() == -10');
|
|
|
|
tmp = config("mode", "real");
|
|
print '1607: tmp = config("mode", "real")';
|
|
vrfy(tmp == "int", '1608: tmp == "int"');
|
|
vrfy(base() == 10, '1609: base() == 10');
|
|
|
|
tmp = config("mode", "exp");
|
|
print '1610: tmp = config("mode", "exp")';
|
|
vrfy(tmp == "real", '1611: tmp == "real"');
|
|
vrfy(base() == 1e20, '1612: base() == 1e20');
|
|
|
|
tmp = config("mode", "hex");
|
|
print '1613: tmp = config("mode", "hex")';
|
|
vrfy(tmp == "exp", '1614: tmp == "exp"');
|
|
vrfy(base() == 16, '1615: base() == 16');
|
|
|
|
tmp = config("mode", "oct");
|
|
print '1616: tmp = config("mode", "oct")';
|
|
vrfy(tmp == "hexadecimal", '1617: tmp == "hexadecimal"');
|
|
vrfy(base() == 8, '1618: base() == 8');
|
|
|
|
tmp = config("mode", "bin");
|
|
print '1619: tmp = config("mode", "bin")';
|
|
vrfy(tmp == "octal", '1620: tmp == "octal"');
|
|
vrfy(base() == 2, '1621: base() == 2');
|
|
|
|
tmp = config("mode", "real");
|
|
print '1622: tmp = config("mode", "real")';
|
|
vrfy(tmp == "binary", '1623: tmp == "binary"');
|
|
|
|
tmp = base(1/3);
|
|
print '1624: tmp = base(1/3)';
|
|
vrfy(config("mode") == "frac", '1625: config("mode") == "frac"');
|
|
|
|
tmp = base(-10);
|
|
print '1626: tmp = base(-10)';
|
|
vrfy(config("mode") == "int", '1627: config("mode") == "int"');
|
|
|
|
tmp = base(10);
|
|
print '1628: tmp = base(10)';
|
|
vrfy(config("mode") == "real", '1629: config("mode") == "real"');
|
|
|
|
tmp = base(1e20);
|
|
print '1630: tmp = base(1e20)';
|
|
vrfy(config("mode") == "exp", '1631: config("mode") == "exp"');
|
|
|
|
tmp = base(16);
|
|
print '1632: tmp = base(16)';
|
|
vrfy(config("mode") == "hexadecimal", \
|
|
'1633: config("mode") == "hexadecimal"');
|
|
|
|
tmp = base(8);
|
|
print '1634: tmp = base(8)';
|
|
vrfy(config("mode") == "octal", '1635: config("mode") == "octal"');
|
|
|
|
tmp = base(2);
|
|
print '1636: tmp = base(2)';
|
|
vrfy(config("mode") == "binary",'1637: config("mode") == "binary"');
|
|
|
|
tmp = base(8);
|
|
print '1638: tmp = base(8)';
|
|
vrfy(str(0x80000000) == "020000000000", \
|
|
'1639: str(0x8000000) == \"020000000000\"');
|
|
vrfy(str(0xffffffff) == "037777777777", \
|
|
'1640: str(0xffffffff) == \"037777777777\"');
|
|
vrfy(str(3e9) == "026264057000", \
|
|
'1641: str(3e9) == \"026264057000\"');
|
|
|
|
tmp = base(16);
|
|
print '1642: tmp = base(16)';
|
|
vrfy(str(0x80000000) == "0x80000000", \
|
|
'1643: str(0x8000000) == \"0x80000000\"');
|
|
vrfy(str(0xffffffff) == "0xffffffff", \
|
|
'1644: str(0xffffffff) == \"0xffffffff\"');
|
|
vrfy(str(3e9) == "0xb2d05e00", \
|
|
'1645: str(3e9) == \"0xb2d05e00\"');
|
|
|
|
tmp = base(10);
|
|
print '1646: tmp = base(10)';
|
|
vrfy(config("mode") == "real", \
|
|
'1647: config("mode") == "real"');
|
|
|
|
vrfy(str(0x80000000) == "2147483648", \
|
|
'1648: str(0x80000000) == \"2147483648\"');
|
|
vrfy(str(0xffffffff) == "4294967295", \
|
|
'1649: str(0xffffffff) == \"4294967295\"');
|
|
vrfy(str(3e9) == "3000000000", \
|
|
'1650: str(3e9) == \"3000000000\"');
|
|
|
|
print '1651: Ending mode/base test';
|
|
}
|
|
print '026: parsed test_mode()';
|
|
|
|
|
|
/*
|
|
* The 1700's contain tests for reading scripts. These tests are
|
|
* done inline near the bottom.
|
|
*/
|
|
|
|
|
|
/*
|
|
* Test objects
|
|
*/
|
|
read -once "surd";
|
|
print '027: read -once surd';
|
|
/**/
|
|
define test_obj()
|
|
{
|
|
static obj surd a;
|
|
static obj surd b;
|
|
|
|
print '1800: Beginning object test';
|
|
|
|
surd_type = -1;
|
|
vrfy(surd_type == -1, '1801: surd_type == -1');
|
|
a = surd(2,3);
|
|
print '1802: a = surd(2,3)';
|
|
vrfy(a == surd(2,3), '1803: a == surd(2,3)');
|
|
vrfy(surd_value(a) == 2+3i, '1804: surd_value(a) == 2+3i');
|
|
vrfy(conj(a) == surd(2,-3), '1805: conj(a) == surd(2,-3)');
|
|
vrfy(norm(a) == 13, '1806: norm(a) == 13');
|
|
vrfy(a+1 == surd(3,3), '1807: a+1 == surd(3,3)');
|
|
b = surd(3,4);
|
|
print '1808: b = surd(3,4)';
|
|
vrfy(a+b == surd(5,7), '1809: a+b == surd(5,7)');
|
|
vrfy(a-b == surd(-1,-1), '1810: a-b == surd(-1,-1)');
|
|
vrfy(++a == surd(3,3), '1811: ++a == surd(3,3)');
|
|
vrfy(--a == surd(2,3), '1812: --a == surd(2,3)');
|
|
vrfy(-a == surd(-2,-3), '1813: -a == surd(-2,-3)');
|
|
vrfy(a*2 == surd(4,6), '1814: a*2 == surd(4,6)');
|
|
vrfy(a*b == surd(-6,17), '1815: a*b == surd(-6,17)');
|
|
vrfy(a^2 == surd(-5,12), '1816: a^2 == surd(-5,12)');
|
|
vrfy(scale(a,2) == surd(8,12), '1817: scale(a,2) == surd(8,12)');
|
|
vrfy(a<<3 == surd(16,24), '1818: a<<3 == surd(16,24)');
|
|
vrfy(a/2 == surd(1,1.5), '1819: a/2 == surd(1,1.5)');
|
|
vrfy(a/b == surd(0.72,0.04), '1820: a/b == surd(0.72,0.04)');
|
|
vrfy(1/b == surd(0.12,-0.16), '1821: 1/b == surd(0.12,-0.16)');
|
|
vrfy(inverse(b) == 1/b, '1822: inverse(b) == 1/b');
|
|
vrfy(a != b, '1823: a != b');
|
|
surd_type = 2;
|
|
print '1824: surd_type = 2';
|
|
vrfy(surd_type == 2, '1825: surd_type == 2');
|
|
vrfy(sgn(a) == 1, '1826: sgn(a) == 1');
|
|
vrfy(a < b, '1827: a < b');
|
|
vrfy(a <= a, '1828: a < a');
|
|
vrfy(isobj(a) == 1, '1829: isobj(a) == 1');
|
|
|
|
print '1830: Ending object test';
|
|
}
|
|
print '028: parsed test_obj()';
|
|
|
|
|
|
/*
|
|
* Prime builtin function testing
|
|
*/
|
|
define test_prime()
|
|
{
|
|
print '1900: Beginning prime builtins test';
|
|
|
|
vrfy(isprime(-3) == 1, '1901: isprime(-3) == 1');
|
|
vrfy(isprime(-1) == 0, '1902: isprime(-1) == 0');
|
|
vrfy(isprime(0) == 0, '1903: isprime(0) == 0');
|
|
vrfy(isprime(1) == 0, '1904: isprime(1) == 0');
|
|
vrfy(isprime(2) == 1, '1905: isprime(2) == 1');
|
|
vrfy(isprime(3) == 1, '1906: isprime(3) == 1');
|
|
vrfy(isprime(4) == 0, '1907: isprime(4) == 0');
|
|
vrfy(isprime(5) == 1, '1908: isprime(5) == 1');
|
|
vrfy(isprime(17) == 1, '1909: isprime(17) == 1');
|
|
vrfy(isprime(100) == 0, '1910: isprime(100) == 0');
|
|
vrfy(isprime(21701,-1) == 1, '1911: isprime(21701,-1) == 1');
|
|
vrfy(isprime(65521,-1) == 1, '1912: isprime(65521,-1) == 1');
|
|
vrfy(isprime(65535,-1) == 0, '1913: isprime(65535,-1) == 0');
|
|
vrfy(isprime(65536,-1) == 0, '1914: isprime(65536,-1) == 0');
|
|
vrfy(isprime(1234577) == 1, '1915: isprime(1234577) == 1');
|
|
vrfy(isprime(1234579) == 0, '1916: isprime(1234579) == 0');
|
|
vrfy(isprime(2^31-9) == 0, '1917: isprime(2^31-9) == 0');
|
|
vrfy(isprime(2^31-1) == 1, '1918: isprime(2^31-1) == 1');
|
|
vrfy(isprime(2^31+9) == 0, '1919: isprime(2^31+11) == 0');
|
|
vrfy(isprime(2^31+11) == 1, '1920: isprime(2^31+11) == 1');
|
|
vrfy(isprime(3e9) == 0, '1921: isprime(3e9) == 0');
|
|
vrfy(isprime(3e9+19) == 1, '1922: isprime(3e9+19) == 1');
|
|
vrfy(isprime(2^32-7) == 0, '1923: isprime(2^32-7) == 0');
|
|
vrfy(isprime(2^32-5) == 1, '1924: isprime(2^32-5) == 1');
|
|
vrfy(isprime(2^32,-1) == 0, '1925: isprime(2^32,-1) == 0');
|
|
vrfy(isprime(2^32+1,-1) == -1, '1926: isprime(2^32+1,-1) == -1');
|
|
vrfy(isprime(3^99,2) == 2, '1927: isprime(3^99,2) == 2');
|
|
vrfy(isprime(4^99,2) == 0, '1928: isprime(3^99,2) == 0');
|
|
vrfy(nextprime(-3) == 5, '1929: nextprime(-3) == 5');
|
|
vrfy(nextprime(0) == 2, '1930: nextprime(0) == 2');
|
|
vrfy(nextprime(1) == 2, '1931: nextprime(1) == 2');
|
|
vrfy(nextprime(2) == 3, '1932: nextprime(2) == 3');
|
|
vrfy(nextprime(3) == 5, '1933: nextprime(3) == 5');
|
|
vrfy(nextprime(4) == 5, '1934: nextprime(4) == 5');
|
|
vrfy(nextprime(5) == 7, '1935: nextprime(5) == 7');
|
|
vrfy(nextprime(17) == 19, '1936: nextprime(17) == 19');
|
|
vrfy(nextprime(100) == 101, '1937: nextprime(100) == 101');
|
|
vrfy(nextprime(21701,-1) == 21713,
|
|
'1938: nextprime(21701,-1) == 21713');
|
|
vrfy(nextprime(65519) == 65521,
|
|
'1939: nextprime(65519) == 65521');
|
|
vrfy(nextprime(65520) == 65521,
|
|
'1940: nextprime(65520) == 65521');
|
|
vrfy(nextprime(65521,-1) == 65537,
|
|
'1941: nextprime(65521,-1) == 65537');
|
|
vrfy(nextprime(65531) == 65537,
|
|
'1942: nextprime(65531) == 65537');
|
|
vrfy(nextprime(65535,-1) == 65537,
|
|
'1943: nextprime(65535,-1) == 65537');
|
|
vrfy(nextprime(65536) == 65537,
|
|
'1944: nextprime(65536) == 65537');
|
|
vrfy(nextprime(1234576,2)==1234577,
|
|
'1945: nextprime(1234576,2)==1234577');
|
|
vrfy(nextprime(2^31-9) == 2^31-1,
|
|
'1946: nextprime(2^31-9) == 2^31-1');
|
|
vrfy(nextprime(2^31-1) == 2^31+11,
|
|
'1947: nextprime(2^31-1) == 2^31+11');
|
|
vrfy(nextprime(3e9) == 3e9+19,'1948: nextprime(3e9) == 3e9+19');
|
|
vrfy(nextprime(2^32-7) == 2^32-5,
|
|
'1949: nextprime(2^32-7) == 2^32-5');
|
|
vrfy(nextprime(2^32,-1) == -1, '1950: nextprime(2^32,-1) == -1');
|
|
vrfy(nextprime(2^32+5,-1) == -1,'1951: nextprime(2^32+5,-1) == -1');
|
|
vrfy(nextprime(3^99,-1) == -1, '1952: nextprime(3^99,-1) == -1');
|
|
vrfy(nextprime(3^99,2) == 2, '1953: nextprime(3^99,2) == 2');
|
|
vrfy(prevprime(-3,-1) == 2, '1954: prevprime(-3,-1) == 2');
|
|
vrfy(prevprime(0,-1) == 0, '1955: prevprime(0,-1) == 0');
|
|
vrfy(prevprime(1,-1) == 0, '1956: prevprime(1,-1) == 0');
|
|
vrfy(prevprime(2,-2) == 0, '1957: prevprime(2,-2) == 0');
|
|
vrfy(prevprime(5) == 3, '1958: prevprime(5) == 3');
|
|
vrfy(prevprime(4) == 3, '1959: prevprime(4) == 3');
|
|
vrfy(prevprime(7) == 5, '1960: prevprime(7) == 5');
|
|
vrfy(prevprime(19) == 17, '1961: prevprime(19) == 17');
|
|
vrfy(prevprime(100) == 97, '1962: prevprime(100) == 97');
|
|
vrfy(prevprime(21713,-1) == 21701,
|
|
'1963: prevprime(21713,-1) == 21701');
|
|
vrfy(prevprime(65520) == 65519,
|
|
'1964: prevprime(65520) == 65519');
|
|
vrfy(prevprime(65521) == 65519,
|
|
'1965: prevprime(65521) == 65519');
|
|
vrfy(prevprime(65522) == 65521,
|
|
'1966: prevprime(65520) == 65521');
|
|
vrfy(prevprime(65523) == 65521,
|
|
'1967: prevprime(65523) == 65521');
|
|
vrfy(prevprime(65531) == 65521,
|
|
'1968: prevprime(65531) == 65521');
|
|
vrfy(prevprime(65535) == 65521,
|
|
'1969: prevprime(65535) == 65521');
|
|
vrfy(prevprime(65536) == 65521,
|
|
'1970: prevprime(65536) == 65521');
|
|
vrfy(prevprime(65537) == 65521,
|
|
'1971: prevprime(65537) == 65521');
|
|
vrfy(prevprime(65539) == 65537,
|
|
'1972: prevprime(65539) == 65537');
|
|
vrfy(prevprime(1234578,2)==1234577,
|
|
'1973: prevprime(1234578,2)==1234577');
|
|
vrfy(prevprime(2^31-1) == 2^31-19,
|
|
'1974: prevprime(2^31-1) == 2^31-19');
|
|
vrfy(prevprime(2^31+11) == 2^31-1,
|
|
'1975: prevprime(2^31+11) == 2^31-1');
|
|
vrfy(prevprime(3e9) == 3e9-71,'1976: prevprime(3e9) == 3e9-17');
|
|
vrfy(prevprime(2^32-3) == 2^32-5,
|
|
'1977: prevprime(2^32-3) == 2^32-5');
|
|
vrfy(prevprime(2^32-1) == 2^32-5,
|
|
'1978: prevprime(2^32-1) == 2^32-5');
|
|
vrfy(prevprime(2^32,-1) == -1, '1979: prevprime(2^32,-1) == -1');
|
|
vrfy(prevprime(3^99,-1) == -1, '1980: prevprime(3^99,-1) == -1');
|
|
vrfy(prevprime(3^99,2) == 2, '1981: prevprime(3^99,2) == 2');
|
|
vrfy(pix(-1) == 0, '1982: pix(-1) == 0');
|
|
vrfy(pix(1) == 0, '1983: pix(1) == 0');
|
|
vrfy(pix(2) == 1, '1984: pix(2) == 1');
|
|
vrfy(pix(3) == 2, '1985: pix(3) == 2');
|
|
vrfy(pix(100) == 25, '1986: pix(100) == 25');
|
|
vrfy(pix(1000) == 168, '1987: pix(1000) == 168');
|
|
vrfy(pix(10000) == 1229, '1988: pix(10000) == 1229');
|
|
vrfy(pix(100000) == 9592, '1989: pix(100000) == 9592');
|
|
vrfy(pix(2^19+59) == 43393, '1990: pix(2^19+59) == 43393');
|
|
vrfy(pix(1000000) == 78498, '1991: pix(1000000) == 78498');
|
|
vrfy(pix(10000000) == 664579, '1992: pix(10000000) == 664579');
|
|
vrfy(pix(2^32-6) == 203280220, '1993: pix(2^32-6) == 203280220');
|
|
vrfy(pix(2^32-5) == 203280221, '1994: pix(2^32-5) == 203280221');
|
|
vrfy(pix(2^32-1) == 203280221, '1995: pix(2^32-1) == 203280221');
|
|
vrfy(pfact(40) == 7420738134810,'1996: pfact(40) == 7420738134810');
|
|
vrfy(pfact(200)/pfact(198)==199,'1997: pfact(200)/pfact(198)==199');
|
|
vrfy(nextprime(3e9)==nextcand(3e9),
|
|
'1998: nextprime(3e9)==nextcand(3e9)');
|
|
vrfy(prevprime(3e9)==prevcand(3e9),
|
|
'1999: prevprime(3e9)==prevcand(3e9)');
|
|
vrfy(nextcand(2^100,0)-2^100 == 3,
|
|
'2000: nextcand(2^100,0)-2^100 == 3');
|
|
vrfy(nextcand(2^100)-2^100 == 277,
|
|
'2001: nextcand(2^100)-2^100 == 277');
|
|
vrfy(2^100-prevcand(2^100,0) == 5,
|
|
'2002: 2^100-prevcand(2^100,0) == 5');
|
|
vrfy(2^100-prevcand(2^100) == 15,
|
|
'2003: 2^100-prevcand(2^100) == 15');
|
|
vrfy(nextcand(2^50,4,5)-2^50 == 55,
|
|
'2004: nextcand(2^50,4,5)-2^50 == 55');
|
|
vrfy(2^50-prevcand(2^50,4,5) == 27,
|
|
'2005: 2^50-prevcand(2^50,4,5) == 27');
|
|
vrfy(nextprime(2^32-6) == 2^32-5,
|
|
'2006: nextprime(2^32-6) == 2^32-5');
|
|
vrfy(nextprime(2^32-5) == 2^32+15,
|
|
'2007: nextprime(2^32-5) == 2^32+15');
|
|
vrfy(prevprime(2^32-1) == 2^32-5,
|
|
'2008: prevprime(2^32-1) == 2^32-5');
|
|
vrfy(prevcand(2^50,4,5,0,4) == 0,
|
|
'2009: prevcand(2^50,4,5,0,4) == 0');
|
|
vrfy(2^50-prevcand(2^50,4,5,1,4) == 27,
|
|
'2010: 2^50-prevcand(2^50,4,5,1,4) == 27');
|
|
vrfy(prevcand(2^50,4,5,2,4) == 2,
|
|
'2011: prevcand(2^50,4,5,2,4) == 2');
|
|
vrfy(2^50-prevcand(2^50,4,5,3,4) == 113,
|
|
'2012: 2^50-prevcand(2^50,4,5,3,4) == 113');
|
|
vrfy(2^50-prevcand(2^50,4,5,7,17) == 813,
|
|
'2013: 2^50-prevcand(2^50,4,5,7,17) == 813');
|
|
vrfy(nextcand(2^50,4,5,0,4) == 0,
|
|
'2014: nextcand(2^50,4,5,0,4) == 0');
|
|
vrfy(nextcand(2^50,4,5,1,4)-2^50 == 145,
|
|
'2015: nextcand(2^50,4,5,1,4)-2^50 == 145');
|
|
vrfy(nextcand(2^50,4,5,2,4) == 0,
|
|
'2016: nextcand(2^50,4,5,2,4) == 0');
|
|
vrfy(nextcand(2^50,4,5,3,4)-2^50 == 55,
|
|
'2017: nextcand(2^50,4,5,3,4)-2^50 == 55');
|
|
vrfy(nextcand(2^50,4,5,7,17)-2^50 == 853,
|
|
'2018: nextcand(2^50,4,5,7,17)-2^50 == 853');
|
|
vrfy(ptest(2^100+277) == 1, '2019: ptest(2^100+277) == 1');
|
|
vrfy(ptest(2^50-27,4,5) == 1, '2020: ptest(2^50-27,4,5) == 1');
|
|
vrfy(ptest(2^50+55,4,5) == 1, '2021: ptest(2^50+55,4,5) == 1');
|
|
vrfy(ptest(2^32+1,10) == 0, '2022: ptest(2^32+1,10) == 0');
|
|
vrfy(lfactor(1001,100) == 7, '2023: lfactor(1001,100) == 7');
|
|
vrfy(lfactor(1001,4) == 7, '2024: lfactor(1001,4) == 7');
|
|
vrfy(lfactor(1001,3) == 1, '2025: lfactor(1001,3) == 1');
|
|
vrfy(lfactor(127,10000) == 1, '2026: lfactor(127,10000) == 1');
|
|
vrfy(lfactor(2^19-1,10000) == 1,'2027: lfactor(2^19-1,10000) == 1');
|
|
vrfy(lfactor(2^31-1,10000) == 1,'2028: lfactor(2^31-1,10000) == 1');
|
|
vrfy(lfactor(2^32-5,10000) == 1,'2029: lfactor(2^32-5,10000) == 1');
|
|
vrfy(lfactor(2^38+7,50000) == 1,'2030: lfactor(2^38+7,50000) == 1');
|
|
vrfy(lfactor(1009^2,pix(1009)) == 1009,
|
|
'2031: lfactor(1009^2,pix(1009)) == 1009');
|
|
vrfy(lfactor(1009^2,pix(1009)-1) == 1,
|
|
'2032: lfactor(1009^2,pix(1009)-1) == 1');
|
|
vrfy(lfactor(65519*65521,7000) == 65519,
|
|
'2033: lfactor(65519*65521,7000) == 65519');
|
|
vrfy(lfactor(65521^2,pix(65521)) == 65521,
|
|
'2034: lfactor(65521^2,pix(65521)) == 65521');
|
|
vrfy(lfactor(65521^2,pix(65521)-1) == 1,
|
|
'2035: lfactor(65521^2,pix(65521)-1) == 1');
|
|
vrfy(lfactor(524309^6,100000) == 524309,
|
|
'2036: lfactor(524309^6,100000) == 524309');
|
|
|
|
print '2037: Ending prime builtins test';
|
|
}
|
|
print '029: parsed test_prime()';
|
|
|
|
|
|
/*
|
|
* Test the Lucas primality test library
|
|
*/
|
|
read -once "lucas_chk"; /* obtain our needed Lucas library */
|
|
print '030: read lucas_chk';
|
|
/**/
|
|
define test_lucas()
|
|
{
|
|
print '2100: Beginning lucas check test';
|
|
|
|
vrfy(lucas_chk(100,1) == 1, '2101: lucas_chk(100,1) == 1');
|
|
|
|
print '2102: Ending lucas check test';
|
|
}
|
|
print '031: parsed test_lucas()';
|
|
|
|
|
|
/*
|
|
* Test new operator functionality
|
|
*/
|
|
define test_newop()
|
|
{
|
|
static mat A[3] = {1,2,3};
|
|
static mat A2[3] = {1,2,3};
|
|
local B;
|
|
local v;
|
|
local a;
|
|
local b;
|
|
|
|
print '2200: Beginning new operator functionality test';
|
|
|
|
(v = 3) = 4;
|
|
print '2201: (v = 3) = 4';
|
|
vrfy(v == 4, '2202: v == 4');
|
|
(v += 3) *= 4;
|
|
print '2203: (v += 3) *= 4';
|
|
vrfy(v == 28, '2204: v == 28');
|
|
vrfy(A == A2, '2205: A == A2');
|
|
matfill(B = A, 4);
|
|
print '2206: matfill(B = A, 4)';
|
|
vrfy(A == A2, '2207: A == A2');
|
|
vrfy(size(B) == 3, '2208: size(B) == 3');
|
|
vrfy(B[0] == 4, '2209: B[0] == 4');
|
|
vrfy(B[1] == 4, '2210: B[1] == 4');
|
|
vrfy(B[2] == 4, '2211: B[2] == 4');
|
|
a = 3;
|
|
print '2212: a = 3';
|
|
++(b = a);
|
|
print '2213: ++(b = a)';
|
|
vrfy(a == 3, '2214: a == 3');
|
|
vrfy(b == 4, '2215: b == 4');
|
|
++++a;
|
|
print '2216: ++++a';
|
|
vrfy(a == 5, '2217: a == 5');
|
|
vrfy((++a)++ == 6, '2218: (++a)++ == 6');
|
|
vrfy(a == 7, '2219: a == 7');
|
|
(++a) *= b;
|
|
print '2220: (++a) *= b';
|
|
vrfy(a == 32, '2221: a == 32');
|
|
vrfy(b == 4, '2222: b == 4');
|
|
vrfy(++(a*=b) == 129, '2223: ++(a*=b) == 129');
|
|
vrfy(a == 129, '2224: a == 129');
|
|
vrfy(b == 4, '2225: b == 4');
|
|
vrfy((a = (--a / b++))-- == 32,
|
|
'2226: (a = (--a / b++))-- == 32');
|
|
vrfy(a == 31, '2227: a == 31');
|
|
vrfy(b == 5, '2228: b == 5');
|
|
vrfy((++++a / ----b) == 11,
|
|
'2229: (++++a / ----b) == 11');
|
|
vrfy(a == 33, '2230: a == 33');
|
|
vrfy(b == 3, '2231: b == 3');
|
|
vrfy((a/=(--a/++b))-- == 4,
|
|
'2232: (a/=(--a/++b))-- == 4');
|
|
vrfy(a == 3, '2233: a == 3');
|
|
vrfy(b == 4, '2234: b == 4');
|
|
v = a----;
|
|
print '2235: v = a----';
|
|
vrfy(v == 3, '2236: v == 3');
|
|
vrfy(a == 1, '2237: a == 1');
|
|
a = ----v;
|
|
print '2238: a = ----v';
|
|
vrfy(a == 1, '2239: a == 1');
|
|
vrfy(v == 1, '2240: v == 1');
|
|
v = a++++;
|
|
print '2241: v = a++++';
|
|
vrfy(a == 3, '2242: a == 3');
|
|
vrfy(v == 1, '2243: v == 1');
|
|
a = ++++v;
|
|
print '2244: a = ++++v';
|
|
vrfy(a == 3, '2245: a == 3');
|
|
vrfy(v == 3, '2246: v == 3');
|
|
a = ----v----;
|
|
print '2247: a = ----v----';
|
|
vrfy(a == 1, '2248: a == 1');
|
|
vrfy(v == -1, '2249: v == -1');
|
|
v = ++++a++++;
|
|
print '2250: v = ++++a++++';
|
|
vrfy(a == 5, '2251: a == 5');
|
|
vrfy(v == 3, '2252: v == 3');
|
|
a = ++++v----;
|
|
print '2253: a = ++++v----';
|
|
vrfy(a == 5, '2254: a == 5');
|
|
vrfy(v == 3, '2255: v == 3');
|
|
v = --++a--++;
|
|
print '2256: v = --++a--++';
|
|
vrfy(a == 5, '2257: a == 5');
|
|
vrfy(v == 5, '2258: v == 5');
|
|
a = -++v;
|
|
print '2259: a = -++v';
|
|
vrfy(a == -6, '2260: a == -6');
|
|
vrfy(v == 6, '2261: v == 6');
|
|
|
|
print '2262: Ending new operator functionality test';
|
|
}
|
|
print '032: parsed test_newop()';
|
|
|
|
|
|
/*
|
|
* Test object increment/decrement
|
|
*/
|
|
read -once "test2300";
|
|
print '033: read -once test2300';
|
|
/**/
|
|
define test_xx_incdec()
|
|
{
|
|
local A, B;
|
|
|
|
print '2300: Beginning object increment/decrement test';
|
|
|
|
A = mkmat(1,2,3);
|
|
print '2301: A = mkmat(1,2,3)';
|
|
vrfy(ckmat(A,1,2,3) == 1,
|
|
'2302: ckmat(A,1,2,3) == 1');
|
|
B = A++;
|
|
print '2303: B = A++';
|
|
vrfy(ckmat(B,1,2,3) == 1,
|
|
'2304: ckmat(B,1,2,3) == 1');
|
|
vrfy(ckmat(A,2,3,4) == 1,
|
|
'2305: ckmat(A,2,3,4) == 1');
|
|
B = A--;
|
|
print '2306: B = A--';
|
|
vrfy(ckmat(A,1,2,3) == 1,
|
|
'2307: ckmat(A,1,2,3) == 1');
|
|
vrfy(ckmat(B,2,3,4) == 1,
|
|
'2308: ckmat(B,2,3,4) == 1');
|
|
B = ++A;
|
|
print '2309: B = ++A';
|
|
vrfy(ckmat(A,2,3,4) == 1,
|
|
'2310: ckmat(A,2,3,4) == 1');
|
|
vrfy(ckmat(B,2,3,4) == 1,
|
|
'2311: ckmat(B,2,3,4) == 1');
|
|
B = --A;
|
|
print '2312: B = --A';
|
|
vrfy(ckmat(A,1,2,3) == 1,
|
|
'2313: ckmat(A,1,2,3) == 1');
|
|
vrfy(ckmat(B,1,2,3) == 1,
|
|
'2314: ckmat(B,1,2,3) == 1');
|
|
|
|
print '2315: Ending object increment/decrement test';
|
|
}
|
|
print '034: parsed test_xx_incdec()';
|
|
|
|
|
|
/*
|
|
* testing rounding config modes
|
|
*/
|
|
define test_round()
|
|
{
|
|
local mode;
|
|
|
|
print '2400: Beginning config rounding mode test';
|
|
|
|
/* appr mode 0 */
|
|
mode = 0;
|
|
print '2401: mode = 0';
|
|
vrfy(appr(-5.44,0.1,mode) == -5.5,
|
|
'2402: appr(-5.44,0.1,mode) == -5.5');
|
|
vrfy(appr(5.44,0.1,mode) == 5.4,
|
|
'2403: appr(5.44,0.1,mode) == 5.4');
|
|
vrfy(appr(5.7,1,mode) == 5,
|
|
'2404: appr(5.7,1,mode) == 5');
|
|
vrfy(appr(-5.7,1,mode) == -6,
|
|
'2405: appr(-5.7,1,mode) == -6');
|
|
vrfy(appr(-5.44,-0.1,mode) == -5.4,
|
|
'2406: appr(-5.44,-0.1,mode) == -5.4');
|
|
vrfy(appr(5.44,-0.1,mode) == 5.5,
|
|
'2407: appr(5.44,-0.1,mode) == 5.5');
|
|
vrfy(appr(5.7,-1,mode) == 6,
|
|
'2408: appr(5.7,-1,mode) == 6');
|
|
vrfy(appr(-5.7,-1,mode) == -5,
|
|
'2409: appr(-5.7,-1,mode) == -5');
|
|
|
|
/* appr mode 1 */
|
|
mode = 1;
|
|
print '2410: mode = 1';
|
|
vrfy(appr(-5.44,0.1,mode) == -5.4,
|
|
'2411: appr(-5.44,0.1,mode) == -5.4');
|
|
vrfy(appr(5.44,0.1,mode) == 5.5,
|
|
'2412: appr(5.44,0.1,mode) == 5.5');
|
|
vrfy(appr(5.7,1,mode) == 6,
|
|
'2413: appr(5.7,1,mode) == 6');
|
|
vrfy(appr(-5.7,1,mode) == -5,
|
|
'2414: appr(-5.7,1,mode) == -5');
|
|
vrfy(appr(-5.44,-0.1,mode) == -5.5,
|
|
'2415: appr(-5.44,-0.1,mode) == -5.5');
|
|
vrfy(appr(5.44,-0.1,mode) == 5.4,
|
|
'2416: appr(5.44,-0.1,mode) == 5.4');
|
|
vrfy(appr(5.7,-1,mode) == 5,
|
|
'2417: appr(5.7,-1,mode) == 5');
|
|
vrfy(appr(-5.7,-1,mode) == -6,
|
|
'2418: appr(-5.7,-1,mode) == -6');
|
|
|
|
/* appr mode 2 */
|
|
mode = 2;
|
|
print '2419: mode = 2';
|
|
vrfy(appr(-5.44,0.1,mode) == -5.4,
|
|
'2420: appr(-5.44,0.1,mode) == -5.4');
|
|
vrfy(appr(5.44,0.1,mode) == 5.4,
|
|
'2421: appr(5.44,0.1,mode) == 5.4');
|
|
vrfy(appr(5.7,1,mode) == 5,
|
|
'2422: appr(5.7,1,mode) == 5');
|
|
vrfy(appr(-5.7,1,mode) == -5,
|
|
'2423: appr(-5.7,1,mode) == -5');
|
|
|
|
/* appr mode 3 */
|
|
mode = 3;
|
|
print '2424: mode = 3';
|
|
vrfy(appr(-5.44,0.1,mode) == -5.5,
|
|
'2425: appr(-5.44,0.1,mode) == -5.5');
|
|
vrfy(appr(5.44,0.1,mode) == 5.5,
|
|
'2426: appr(5.44,0.1,mode) == 5.5');
|
|
vrfy(appr(5.7,1,mode) == 6,
|
|
'2427: appr(5.7,1,mode) == 6');
|
|
vrfy(appr(-5.7,1,mode) == -6,
|
|
'2428: appr(-5.7,1,mode) == -6');
|
|
|
|
/* appr mode 4 */
|
|
mode = 4;
|
|
print '2429: mode = 4';
|
|
vrfy(appr(-5.44,0.1,mode) == -5.5,
|
|
'2430: appr(-5.44,0.1,mode) == -5.5');
|
|
vrfy(appr(5.44,0.1,mode) == 5.4,
|
|
'2431: appr(5.44,0.1,mode) == 5.4');
|
|
vrfy(appr(5.7,1,mode) == 5,
|
|
'2432: appr(5.7,1,mode) == 5');
|
|
vrfy(appr(-5.7,1,mode) == -6,
|
|
'2433: appr(-5.7,1,mode) == -6');
|
|
|
|
/* appr mode 5 */
|
|
mode = 5;
|
|
print '2434: mode = 5';
|
|
vrfy(appr(-5.44,0.1,mode) == -5.4,
|
|
'2435: appr(-5.44,0.1,mode) == -5.4');
|
|
vrfy(appr(5.44,0.1,mode) == 5.5,
|
|
'2436: appr(5.44,0.1,mode) == 5.5');
|
|
vrfy(appr(5.7,1,mode) == 6,
|
|
'2437: appr(5.7,1,mode) == 6');
|
|
vrfy(appr(-5.7,1,mode) == -5,
|
|
'2438: appr(-5.7,1,mode) == -5');
|
|
|
|
/* appr mode 6 */
|
|
mode = 6;
|
|
print '2439: mode = 6';
|
|
vrfy(appr(-5.44,0.1,mode) == -5.4,
|
|
'2440: appr(-5.44,0.1,mode) == -5.4');
|
|
vrfy(appr(5.44,0.1,mode) == 5.4,
|
|
'2441: appr(5.44,0.1,mode) == 5.4');
|
|
vrfy(appr(5.7,1,mode) == 5,
|
|
'2442: appr(5.7,1,mode) == 5');
|
|
vrfy(appr(-5.7,1,mode) == -5,
|
|
'2443: appr(-5.7,1,mode) == -5');
|
|
vrfy(appr(-5.44,-0.1,mode) == -5.5,
|
|
'2444: appr(-5.44,-0.1,mode) == -5.5');
|
|
vrfy(appr(5.44,-0.1,mode) == 5.5,
|
|
'2445: appr(5.44,-0.1,mode) == 5.5');
|
|
vrfy(appr(5.7,-1,mode) == 6,
|
|
'2446: appr(5.7,-1,mode) == 6');
|
|
vrfy(appr(-5.7,-1,mode) == -6,
|
|
'2447: appr(-5.7,-1,mode) == -6');
|
|
|
|
/* appr mode 7 */
|
|
mode = 7;
|
|
print '2448: mode = 7';
|
|
vrfy(appr(-5.44,0.1,mode) == -5.5,
|
|
'2449: appr(-5.44,0.1,mode) == -5.5');
|
|
vrfy(appr(5.44,0.1,mode) == 5.5,
|
|
'2450: appr(5.44,0.1,mode) == 5.5');
|
|
vrfy(appr(5.7,1,mode) == 6,
|
|
'2451: appr(5.7,1,mode) == 6');
|
|
vrfy(appr(-5.7,1,mode) == -6,
|
|
'2452: appr(-5.7,1,mode) == -6');
|
|
vrfy(appr(-5.44,-0.1,mode) == -5.4,
|
|
'2453: appr(-5.44,-0.1,mode) == -5.4');
|
|
vrfy(appr(5.44,-0.1,mode) == 5.4,
|
|
'2454: appr(5.44,-0.1,mode) == 5.4');
|
|
vrfy(appr(5.7,-1,mode) == 5,
|
|
'2455: appr(5.7,-1,mode) == 5');
|
|
vrfy(appr(-5.7,-1,mode) == -5,
|
|
'2456: appr(-5.7,-1,mode) == -5');
|
|
|
|
/* appr mode 8 */
|
|
mode = 8;
|
|
print '2457: mode = 8';
|
|
vrfy(appr(-5.44,0.1,mode) == -5.4,
|
|
'2458: appr(-5.44,0.1,mode) == -5.4');
|
|
vrfy(appr(5.44,0.1,mode) == 5.4,
|
|
'2459: appr(5.44,0.1,mode) == 5.4');
|
|
vrfy(appr(5.7,1,mode) == 6,
|
|
'2460: appr(5.7,1,mode) == 6');
|
|
vrfy(appr(-5.7,1,mode) == -6,
|
|
'2461: appr(-5.7,1,mode) == -6');
|
|
|
|
/* appr mode 9 */
|
|
mode = 9;
|
|
print '2462: mode = 9';
|
|
vrfy(appr(-5.44,0.1,mode) == -5.5,
|
|
'2463: appr(-5.44,0.1,mode) == -5.5');
|
|
vrfy(appr(5.44,0.1,mode) == 5.5,
|
|
'2464: appr(5.44,0.1,mode) == 5.5');
|
|
vrfy(appr(5.7,1,mode) == 5,
|
|
'2465: appr(5.7,1,mode) == 5');
|
|
vrfy(appr(-5.7,1,mode) == -5,
|
|
'2466: appr(-5.7,1,mode) == -5');
|
|
|
|
/* appr mode 10 */
|
|
mode = 10;
|
|
print '2467: mode = 10';
|
|
vrfy(appr(-5.44,0.1,mode) == -5.5,
|
|
'2468: appr(-5.44,0.1,mode) == -5.5');
|
|
vrfy(appr(5.44,0.1,mode) == 5.4,
|
|
'2469: appr(5.44,0.1,mode) == 5.4');
|
|
vrfy(appr(5.7,1,mode) == 6,
|
|
'2470: appr(5.7,1,mode) == 6');
|
|
vrfy(appr(-5.7,1,mode) == -5,
|
|
'2471: appr(-5.7,1,mode) == -5');
|
|
vrfy(appr(-5.44,-0.1,mode) == -5.4,
|
|
'2472: appr(-5.44,-0.1,mode) == -5.4');
|
|
vrfy(appr(5.44,-0.1,mode) == 5.5,
|
|
'2473: appr(5.44,-0.1,mode) == 5.5');
|
|
vrfy(appr(5.7,-1,mode) == 5,
|
|
'2474: appr(5.7,-1,mode) == 5');
|
|
vrfy(appr(-5.7,-1,mode) == -6,
|
|
'2475: appr(-5.7,-1,mode) == -6');
|
|
|
|
/* appr mode 11 */
|
|
mode = 11;
|
|
print '2476: mode = 11';
|
|
vrfy(appr(-5.44,0.1,mode) == -5.4,
|
|
'2477: appr(-5.44,0.1,mode) == -5.4');
|
|
vrfy(appr(5.44,0.1,mode) == 5.5,
|
|
'2478: appr(5.44,0.1,mode) == 5.5');
|
|
vrfy(appr(5.7,1,mode) == 5,
|
|
'2479: appr(5.7,1,mode) == 5');
|
|
vrfy(appr(-5.7,1,mode) == -6,
|
|
'2480: appr(-5.7,1,mode) == -6');
|
|
vrfy(appr(-5.44,-0.1,mode) == -5.5,
|
|
'2481: appr(-5.44,-0.1,mode) == -5.5');
|
|
vrfy(appr(5.44,-0.1,mode) == 5.4,
|
|
'2482: appr(5.44,-0.1,mode) == 5.4');
|
|
vrfy(appr(5.7,-1,mode) == 6,
|
|
'2483: appr(5.7,-1,mode) == 6');
|
|
vrfy(appr(-5.7,-1,mode) == -5,
|
|
'2484: appr(-5.7,-1,mode) == -5');
|
|
|
|
/* appr mode 12 */
|
|
mode = 12;
|
|
print '2485: mode = 12';
|
|
vrfy(appr(-5.44,0.1,mode) == -5.4,
|
|
'2486: appr(-5.44,0.1,mode) == -5.4');
|
|
vrfy(appr(5.44,0.1,mode) == 5.4,
|
|
'2487: appr(5.44,0.1,mode) == 5.4');
|
|
vrfy(appr(5.7,1,mode) == 6,
|
|
'2488: appr(5.7,1,mode) == 6');
|
|
vrfy(appr(-5.7,1,mode) == -6,
|
|
'2489: appr(-5.7,1,mode) == -6');
|
|
vrfy(appr(-5.44,-0.1,mode) == -5.5,
|
|
'2490: appr(-5.44,-0.1,mode) == -5.5');
|
|
vrfy(appr(5.44,-0.1,mode) == 5.5,
|
|
'2491: appr(5.44,-0.1,mode) == 5.5');
|
|
vrfy(appr(5.7,-1,mode) == 5,
|
|
'2492: appr(5.7,-1,mode) == 5');
|
|
vrfy(appr(-5.7,-1,mode) == -5,
|
|
'2493: appr(-5.7,-1,mode) == -5');
|
|
|
|
/* appr mode 13 */
|
|
mode = 13;
|
|
print '2494: mode = 13';
|
|
vrfy(appr(-5.44,0.1,mode) == -5.5,
|
|
'2495: appr(-5.44,0.1,mode) == -5.5');
|
|
vrfy(appr(5.44,0.1,mode) == 5.5,
|
|
'2496: appr(5.44,0.1,mode) == 5.5');
|
|
vrfy(appr(5.7,1,mode) == 5,
|
|
'2497: appr(5.7,1,mode) == 5');
|
|
vrfy(appr(-5.7,1,mode) == -5,
|
|
'2498: appr(-5.7,1,mode) == -5');
|
|
vrfy(appr(-5.44,-0.1,mode) == -5.4,
|
|
'2499: appr(-5.44,-0.1,mode) == -5.4');
|
|
vrfy(appr(5.44,-0.1,mode) == 5.4,
|
|
'2500: appr(5.44,-0.1,mode) == 5.4');
|
|
vrfy(appr(5.7,-1,mode) == 6,
|
|
'2501: appr(5.7,-1,mode) == 6');
|
|
vrfy(appr(-5.7,-1,mode) == -6,
|
|
'2502: appr(-5.7,-1,mode) == -6');
|
|
|
|
/* appr mode 14 */
|
|
mode = 14;
|
|
print '2503: mode = 14';
|
|
vrfy(appr(-5.44,0.1,mode) == -5.5,
|
|
'2504: appr(-5.44,0.1,mode) == -5.5');
|
|
vrfy(appr(5.44,0.1,mode) == 5.4,
|
|
'2505: appr(5.44,0.1,mode) == 5.4');
|
|
vrfy(appr(5.7,1,mode) == 6,
|
|
'2506: appr(5.7,1,mode) == 6');
|
|
vrfy(appr(-5.7,1,mode) == -5,
|
|
'2507: appr(-5.7,1,mode) == -5');
|
|
vrfy(appr(-5.44,-0.1,mode) == -5.5,
|
|
'2508: appr(-5.44,-0.1,mode) == -5.5');
|
|
vrfy(appr(5.44,-0.1,mode) == 5.4,
|
|
'2509: appr(5.44,-0.1,mode) == 5.4');
|
|
vrfy(appr(5.7,-1,mode) == 6,
|
|
'2510: appr(5.7,-1,mode) == 6');
|
|
vrfy(appr(-5.7,-1,mode) == -5,
|
|
'2511: appr(-5.7,-1,mode) == -5');
|
|
|
|
/* appr mode 15 */
|
|
mode = 15;
|
|
print '2512: mode = 15';
|
|
vrfy(appr(-5.44,0.1,mode) == -5.4,
|
|
'2513: appr(-5.44,0.1,mode) == -5.4');
|
|
vrfy(appr(5.44,0.1,mode) == 5.5,
|
|
'2514: appr(5.44,0.1,mode) == 5.5');
|
|
vrfy(appr(5.7,1,mode) == 5,
|
|
'2515: appr(5.7,1,mode) == 5');
|
|
vrfy(appr(-5.7,1,mode) == -6,
|
|
'2516: appr(-5.7,1,mode) == -6');
|
|
vrfy(appr(-5.44,-0.1,mode) == -5.4,
|
|
'2517: appr(-5.44,-0.1,mode) == -5.4');
|
|
vrfy(appr(5.44,-0.1,mode) == 5.5,
|
|
'2518: appr(5.44,-0.1,mode) == 5.5');
|
|
vrfy(appr(5.7,-1,mode) == 5,
|
|
'2519: appr(5.7,-1,mode) == 5');
|
|
vrfy(appr(-5.7,-1,mode) == -6,
|
|
'2520: appr(-5.7,-1,mode) == -6');
|
|
|
|
print '2521: Ending config rounding mode test';
|
|
}
|
|
print '035: parsed test_round()';
|
|
|
|
|
|
/*
|
|
* Test certain numeric functions extensively
|
|
*
|
|
* Test multiplication, sqrt(), exp(), ln(), power(), gcd(), complex
|
|
* power, complex exp, complex log.
|
|
*/
|
|
read -once "test2600";
|
|
print '036: read -once test2600';
|
|
define test_2600()
|
|
{
|
|
local tnum; /* test number */
|
|
local i;
|
|
|
|
print '2600: Beginning extensive numeric function test';
|
|
|
|
i = config("sqrt");
|
|
print '2601: i = config("sqrt")';
|
|
|
|
tnum = test2600(1, 2602);
|
|
|
|
i = config("sqrt", i);
|
|
print tnum++: ': i = config("sqrt", i)';
|
|
|
|
print tnum: ': Ending extensive numeric function test';
|
|
}
|
|
print '037: parsed test_2600()';
|
|
|
|
|
|
/*
|
|
* Test complex sqrt
|
|
*/
|
|
read -once "test2700";
|
|
print '038: read -once test2700';
|
|
define test_2700()
|
|
{
|
|
local tnum; /* test number */
|
|
|
|
print '2700: Beginning complex sqrt test';
|
|
|
|
tnum = test2700(1, 2701);
|
|
|
|
print tnum: ': Ending complex sqrt test';
|
|
}
|
|
print '039: parsed test_2700()';
|
|
|
|
|
|
/*
|
|
* Test matrix operations
|
|
*/
|
|
mat mat_C[2] = {1,2};
|
|
print '040: mat mat_C[2] = {1,2}';
|
|
mat_C[0] = mat_C;
|
|
print '041: C[0] = mat_C';
|
|
global mat_D;
|
|
print '042: global mat_D';
|
|
/**/
|
|
define test_matrix()
|
|
{
|
|
static mat b[4,4];
|
|
static mat binv[4,4] = {
|
|
0, 1, 0, 0, 2, -3/2, 2, -1/2, -3,
|
|
0.5, -1.0, 0.5, 1.0, 0.0, 0.0, 0.0
|
|
};
|
|
static mat c[] = { 1, 2+3i, -5+4i, 5i+6, -7i };
|
|
static mat d[-1:1, -2:2, -3:3, -4:4];
|
|
static mat A[2] = {1,2};
|
|
static mat id0[2,2] = {1,0,0,1};
|
|
static mat id1[0:2,-1:1] = {1,0,0,0,1,0,0,0,1};
|
|
static mat noid0[2,2] = {1,2,0,1};
|
|
static mat noid1[2,3] = {1,0,0,1,0,0};
|
|
static mat noid2[4] = {1,0,0,1};
|
|
static mat xp[3] = {2,3,4};
|
|
static mat yp[3] = {3,4,5};
|
|
static mat zp[3] = {-1,2,-1};
|
|
static mat X[2,2] = {1,2,3,4};
|
|
static mat Y[2,2] = {5,6,7,8};
|
|
static mat Z[2,2] = {190,232,286,352};
|
|
static mat x[] = {11,13,17,23,29};
|
|
static mat y0[] = {1,3,7,3,9};
|
|
static mat y1[] = {-9,-7,-3,-7,-1};
|
|
static mat y2[] = {-9,-7,-3,3,9};
|
|
static mat y3[] = {1,3,7,-7,-1};
|
|
static mat y4[] = {1,3,-3,3,-1};
|
|
local B;
|
|
local mat e[5,5];
|
|
local mat M[2];
|
|
local mat zero3[3];
|
|
|
|
print '2800: Beginning test_matrix';
|
|
|
|
b[0,0] = 0;
|
|
vrfy(b[0,0] == 0, '2801: b[0,0] == 0');
|
|
b[0,1] = 0;
|
|
vrfy(b[0,1] == 0, '2802: b[0,1] == 0');
|
|
b[0,2] = 0;
|
|
vrfy(b[0,2] == 0, '2803: b[0,2] == 0');
|
|
b[0,3] = 1;
|
|
vrfy(b[0,3] == 1, '2804: b[0,3] == 1');
|
|
b[1,0] = 1;
|
|
vrfy(b[1,0] == 1, '2805: b[1,0] == 1');
|
|
b[1,1] = 0;
|
|
vrfy(b[1,1] == 0, '2806: b[1,1] == 0');
|
|
b[1,2] = 0;
|
|
vrfy(b[1,2] == 0, '2807: b[1,2] == 0');
|
|
b[1,3] = 0;
|
|
vrfy(b[1,3] == 0, '2808: b[1,3] == 0');
|
|
b[2,0] = 1;
|
|
vrfy(b[2,0] == 1, '2809: b[2,0] == 1');
|
|
b[2,1] = 1;
|
|
vrfy(b[2,1] == 1, '2810: b[2,1] == 1');
|
|
b[2,2] = 1;
|
|
vrfy(b[2,2] == 1, '2811: b[2,2] == 1');
|
|
b[2,3] = 1;
|
|
vrfy(b[2,3] == 1, '2812: b[2,3] == 1');
|
|
b[3,0] = 1;
|
|
vrfy(b[3,0] == 1, '2813: b[3,0] == 1');
|
|
b[3,1] = 2;
|
|
vrfy(b[3,1] == 2, '2814: b[3,1] == 2');
|
|
b[3,2] = 4;
|
|
vrfy(b[3,2] == 4, '2815: b[3,2] == 4');
|
|
b[3,3] = 8;
|
|
vrfy(b[3,3] == 8, '2816: b[3,3] == 8');
|
|
vrfy(det(b) == -2, '2817: det(b) == -2');
|
|
vrfy(binv[0,0] == 0, '2818: binv[0,0] == 0');
|
|
vrfy(binv[0,1] == 1, '2819: binv[0,1] == 1');
|
|
vrfy(binv[0,2] == 0, '2820: binv[0,2] == 0');
|
|
vrfy(binv[0,3] == 0, '2821: binv[0,3] == 0');
|
|
vrfy(binv[1,0] == 2, '2822: binv[1,0] == 2');
|
|
vrfy(binv[1,1] == -3/2, '2823: binv[1,1] == -3/2');
|
|
vrfy(binv[1,2] == 2, '2824: binv[1,2] == 2');
|
|
vrfy(binv[1,3] == -1/2, '2825: binv[1,3] == -1/2');
|
|
vrfy(binv[2,0] == -3, '2826: binv[2,0] == -3');
|
|
vrfy(binv[2,1] == 1/2, '2827: binv[2,1] == 1/2');
|
|
vrfy(binv[2,2] == -1, '2828: binv[2,2] == -1');
|
|
vrfy(binv[2,3] == 1/2, '2829: binv[2,3] == 1/2');
|
|
vrfy(binv[3,0] == 1, '2830: binv[3,0] == 1');
|
|
vrfy(binv[3,1] == 0, '2831: binv[3,1] == 0');
|
|
vrfy(binv[3,2] == 0, '2832: binv[3,2] == 0');
|
|
vrfy(binv[3,3] == 0, '2833: binv[3,3] == 0');
|
|
vrfy(inverse(b) == binv, '2834: inverse(b) == binv');
|
|
vrfy(avg(b) == b, '2835: avg(b) == b');
|
|
vrfy(avg(binv) == binv, '2836: avg(binv) == binv');
|
|
vrfy((b+binv)/2 == avg(b,binv), '2837: (b+binv)/2 == avg(b,binv)');
|
|
vrfy(ismat(b) == 1, '2838: ismat(b) == 1');
|
|
vrfy(matsum(b) == 21, '2839: matsum(b) == 21');
|
|
vrfy(matsum(binv) == 1, '2840: matsum(binv) == 1');
|
|
vrfy(c[0] == 1, '2841: c[0] == 1');
|
|
vrfy(c[1] == 2+3i, '2842: c[1] == 2+3i');
|
|
vrfy(c[2] == -5+4i, '2843: c[2] == -5+4i');
|
|
vrfy(c[3] == 6+5i, '2844: c[3] == 6+5i');
|
|
vrfy(c[4] == -7i, '2845: c[4] == -7i');
|
|
vrfy(matsum(c) == 4+5i, '2846: matsum(c) == 4+5i');
|
|
vrfy(matdim(b) == 2, '2847: matdim(b) == 2');
|
|
vrfy(matdim(c) == 1, '2848: matdim(c) == 1');
|
|
vrfy(matdim(d) == 4, '2849: matdim(c) == 4');
|
|
vrfy(matmax(c,1) == 4, '2850: matmax(c,1) == 4');
|
|
vrfy(matmin(c,1) == 0, '2851: matmin(c,1) == 0');
|
|
vrfy(matmin(d,1) == -1, '2852: matmin(d,1) == -1');
|
|
vrfy(matmin(d,3) == -3, '2853: matmin(d,3) == -3');
|
|
vrfy(matmax(d,1) == 1, '2854: matmin(d,1) == 1');
|
|
vrfy(matmax(d,3) == 3, '2855: matmin(d,3) == 3');
|
|
vrfy(size(binv) == 16, '2856: size(binv) == 16');
|
|
vrfy(size(c) == 5, '2857: size(c) == 5');
|
|
vrfy(size(d) == 945, '2858: size(d) == 945');
|
|
vrfy(size(e) == 25, '2859: size(e) == 25');
|
|
matfill(d,1);
|
|
print '2860: matfill(d,1)';
|
|
vrfy(matsum(d) == 945, '2861: matsum(d) == 945');
|
|
matfill(e,1,0);
|
|
print '2862: matfill(e,1,0)';
|
|
vrfy(matsum(d) == 945, '2863: matsum(d) == 945');
|
|
vrfy(matsum(e) == 20, '2864: matsum(e) == 20');
|
|
vrfy(search(binv,1) == 1, '2865: search(binv,1) == 1');
|
|
vrfy(search(binv,2) == 4, '2866: search(binv,2) == 4');
|
|
vrfy(search(binv,2,4) == 4, '2867: search(binv,2,4) == 4');
|
|
vrfy(search(binv,2,5) == 6, '2868: search(binv,2,5) == 6');
|
|
vrfy(rsearch(binv,2) == 6, '2869: rsearch(binv,2) == 6');
|
|
vrfy(rsearch(binv,2,6) == 6, '2870: rsearch(binv,2,6) == 6');
|
|
vrfy(rsearch(binv,2,5) == 4, '2871: rsearch(binv,2,5) == 4');
|
|
vrfy(A[0] == 1, '2872: A[0] == 1');
|
|
vrfy(A[1] == 2, '2873: A[1] == 2');
|
|
A[0] = A;
|
|
print '2874: A[0] = A';
|
|
B = A[0];
|
|
print '2875: B = A[0]';
|
|
vrfy(B[0] == 1, '2876: B[0] == 1');
|
|
vrfy(B[1] == 2, '2877: B[1] == 2');
|
|
mat_D = mat_C[0];
|
|
print '2878: mat_D = mat_C[0]';
|
|
vrfy(mat_D[0] == 1, '2879: mat_D[0] == 1');
|
|
vrfy(mat_D[1] == 2, '2880: mat_D[1] == 2');
|
|
vrfy(quomod(15.6,5.2,M[0],M[1]) == 0,
|
|
'2881: quomod(15.6,5.2,M[0],M[1]) == 0');
|
|
vrfy(M[0] == 3, '2882: M[0] == 3');
|
|
vrfy(M[1] == 0, '2883: M[1] == 0');
|
|
vrfy(isident(id0) == 1, '2884: isident(id0) == 1');
|
|
vrfy(isident(id1) == 1, '2885: isident(id1) == 1');
|
|
vrfy(isident(noid0) == 0, '2886: isident(noid0) == 0');
|
|
vrfy(isident(noid1) == 0, '2887: isident(noid1) == 0');
|
|
vrfy(isident(noid2) == 0, '2888: isident(noid2) == 0');
|
|
vrfy(xp[0] == 2, '2889: xp[0] == 2');
|
|
vrfy(xp[1] == 3, '2890: xp[1] == 3');
|
|
vrfy(xp[2] == 4, '2891: xp[2] == 4');
|
|
vrfy(yp[0] == 3, '2892: yp[0] == 3');
|
|
vrfy(yp[1] == 4, '2893: yp[1] == 4');
|
|
vrfy(yp[2] == 5, '2894: yp[2] == 5');
|
|
vrfy(zp[0] == -1, '2895: zp[0] == -1');
|
|
vrfy(zp[1] == 2, '2896: zp[1] == 2');
|
|
vrfy(zp[2] == -1, '2897: zp[2] == -1');
|
|
vrfy(cp(xp,yp) == zp, '2898: cp(xp,yp) == zp');
|
|
vrfy(cp(yp,xp) == -zp, '2899: cp(yp,xp) == -zp');
|
|
matfill(zero3,0);
|
|
print '2900: matfill(zero3,0)';
|
|
vrfy(cp(xp,xp) == zero3, '2901: cp(xp,xp) == zero3');
|
|
vrfy(dp(xp,yp) == 38, '2902: dp(xp,yp) == 38');
|
|
vrfy(dp(yp,xp) == 38, '2903: dp(yp,xp) == 38');
|
|
vrfy(dp(zp,dp(xp,yp)*zp) == 228,'2904: dp(zp,dp(xp,yp)*zp) == 228');
|
|
vrfy(ssq(X, Y, X + Y) == Z, '2905: ssq(X, Y, X + Y) == Z');
|
|
vrfy(mod(x,10,0) == y0, '2906: mod(x,10,0) == y0');
|
|
vrfy(mod(x,10,1) == y1, '2907: mod(x,10,1) == y1');
|
|
vrfy(mod(x,10,2) == y0, '2908: mod(x,10,2) == y0');
|
|
vrfy(mod(x,10,3) == y1, '2909: mod(x,10,3) == y1');
|
|
vrfy(mod(x,10,4) == y0, '2910: mod(x,10,4) == y0');
|
|
vrfy(mod(x,10,5) == y1, '2911: mod(x,10,5) == y1');
|
|
vrfy(mod(x,10,6) == y0, '2912: mod(x,10,6) == y0');
|
|
vrfy(mod(x,10,7) == y1, '2913: mod(x,10,7) == y1');
|
|
vrfy(mod(x,10,8) == y2, '2914: mod(x,10,8) == y2');
|
|
vrfy(mod(x,10,9) == y3, '2915: mod(x,10,9) == y3');
|
|
vrfy(mod(x,10,10) == y2, '2916: mod(x,10,10) == y2');
|
|
vrfy(mod(x,10,11) == y3, '2917: mod(x,10,11) == y3');
|
|
vrfy(mod(x,10,12) == y2, '2918: mod(x,10,12) == y2');
|
|
vrfy(mod(x,10,13) == y3, '2919: mod(x,10,13) == y3');
|
|
vrfy(mod(x,10,14) == y2, '2920: mod(x,10,14) == y2');
|
|
vrfy(mod(x,10,15) == y3, '2921: mod(x,10,15) == y3');
|
|
vrfy(mod(x,10,16) == y4, '2922: mod(x,10,16) == y4');
|
|
vrfy(mod(x,10,16) == y4, '2923: mod(x,10,16) == y4');
|
|
vrfy(mod(x,10,18) == y4, '2924: mod(x,10,18) == y4');
|
|
vrfy(mod(x,10,19) == y4, '2925: mod(x,10,18) == y4');
|
|
vrfy(mod(x,10,20) == y4, '2926: mod(x,10,20) == y4');
|
|
vrfy(mod(x,10,21) == y4, '2927: mod(x,10,21) == y4');
|
|
vrfy(mod(x,10,22) == y4, '2928: mod(x,10,22) == y4');
|
|
vrfy(mod(x,10,23) == y4, '2929: mod(x,10,23) == y4');
|
|
vrfy(mod(x,10,24) == y4, '2930: mod(x,10,24) == y4');
|
|
vrfy(mod(x,10,25) == y4, '2931: mod(x,10,25) == y4');
|
|
vrfy(mod(x,10,26) == y4, '2932: mod(x,10,26) == y4');
|
|
vrfy(mod(x,10,27) == y4, '2933: mod(x,10,27) == y4');
|
|
vrfy(mod(x,10,28) == y4, '2934: mod(x,10,28) == y4');
|
|
vrfy(mod(x,10,29) == y4, '2935: mod(x,10,29) == y4');
|
|
vrfy(mod(x,10,30) == y4, '2936: mod(x,10,30) == y4');
|
|
vrfy(mod(x,10,31) == y4, '2937: mod(x,10,31) == y4');
|
|
|
|
print '2938: Ending mat_functions';
|
|
}
|
|
print '043: parsed test_matrix()';
|
|
|
|
|
|
/*
|
|
* Test string constants and comparisons
|
|
*/
|
|
define test_strings()
|
|
{
|
|
local x, y, z;
|
|
|
|
print '3000: Beginning test_strings';
|
|
|
|
x = 'string';
|
|
print "3001: x = 'string'";
|
|
y = "string";
|
|
print '3002: y = "string"';
|
|
z = x;
|
|
print '3003: z = x';
|
|
vrfy(z == "string", '3004: z == "string"');
|
|
vrfy(z != "foo", '3005: z != "foo"');
|
|
vrfy(z != 3, '3006: z != 3');
|
|
vrfy('' == "", '3007: \'\' == ""');
|
|
vrfy("a" == "a", '3008: "a" == "a"');
|
|
vrfy("c" != "d", '3009: "c" != "d"');
|
|
vrfy("" != "a", '3010: "" != "a"');
|
|
vrfy("rs" < "rt", '3011: "rs" < "rt"');
|
|
vrfy("rs" < "ss", '3012: "rs < "ss"');
|
|
vrfy("rs" <= "rs", '3013: "rs" <= "rs"');
|
|
vrfy("rs" <= "tu", '3014: "rs" <= "tu"');
|
|
vrfy("rs" > "cd", '3015: "rs" > "cd"');
|
|
vrfy("rs" >= "rs", '3016: "rs" >= "rs"');
|
|
vrfy("rs" >= "cd", '3017: "rs" >= "cd"');
|
|
vrfy("abc" > "ab", '3018: "abc" > "ab"');
|
|
|
|
print '3019: Ending test_strings';
|
|
}
|
|
print '044: parsed test_strings()';
|
|
|
|
|
|
/*
|
|
* test_matobj - test determinants of a matrix containing objects
|
|
*/
|
|
read -once "test3100";
|
|
print '045: read -once test3100';
|
|
/**/
|
|
define test_matobj()
|
|
{
|
|
local mat A[3,3] = {2, 3, 5, 7, 11, 13, 17, 19, 23};
|
|
local mat B[2,2];
|
|
|
|
print '3100: Beginning test_matobj';
|
|
|
|
vrfy(det(A) == -78, '3101: det(A) == -78');
|
|
vrfy(det(A^2) == 6084, '3102: det(A^2) == 6084');
|
|
vrfy(det(A^3) == -474552, '3103: det(A^3) == -474552');
|
|
vrfy(det(A^-1) == -1/78, '3104: det(A^-1) == -1/78');
|
|
md = 0;
|
|
print '3105: md = 0';
|
|
B[0,0] = res(2);
|
|
print '3106: B[0,0] = res(2)';
|
|
B[0,1] = res(3);
|
|
print '3107: B[0,1] = res(2)';
|
|
B[1,0] = res(5);
|
|
print '3108: B[1,0] = res(2)';
|
|
B[1,1] = res(7);
|
|
print '3109: B[1,1] = res(2)';
|
|
print '3110: md = 0';
|
|
md = 0;
|
|
vrfy(det(B) == res(-1), '3111: det(B) == res(-1)');
|
|
md = 1;
|
|
print '3112: md = 1';
|
|
vrfy(det(B) == 0, '3113: det(B) == 0');
|
|
md = 2;
|
|
print '3114: md = 2';
|
|
vrfy(det(B) == res(1), '3115: det(B) == res(1)');
|
|
md = 3;
|
|
print '3116: md = 3';
|
|
vrfy(det(B) == res(2), '3117: det(B) == res(2)');
|
|
md = 4;
|
|
print '3118: md = 4';
|
|
vrfy(det(B) == res(3), '3119: det(B) == res(3)');
|
|
md = 5;
|
|
print '3120: md = 5';
|
|
vrfy(det(B) == res(4), '3121: det(B) == res(4)');
|
|
md = 6;
|
|
print '3122: md = 6';
|
|
vrfy(det(B) == res(5), '3123: det(B) == res(5)');
|
|
md = 7;
|
|
print '3124: md = 7';
|
|
vrfy(det(B) == res(6), '3125: det(B) == res(6)');
|
|
md = 8;
|
|
print '3126: md = 8';
|
|
vrfy(det(B) == res(7), '3127: det(B) == res(7)');
|
|
md = 9;
|
|
print '3128: md = 9';
|
|
vrfy(det(B) == res(8), '3129: det(B) == res(8)');
|
|
md = 10;
|
|
print '3130: md = 10';
|
|
vrfy(det(B) == res(9), '3131: det(B) == res(9)');
|
|
md = 11;
|
|
print '3132: md = 11';
|
|
vrfy(det(B) == res(10), '3133: det(B) == res(10)');
|
|
md = 12;
|
|
print '3134: md = 12';
|
|
vrfy(det(B) == res(11), '3135: det(B) == res(11)');
|
|
md = 13;
|
|
print '3136: md = 13';
|
|
vrfy(det(B) == res(12), '3137: det(B) == res(12)');
|
|
md = 14;
|
|
print '3138: md = 14';
|
|
vrfy(det(B) == res(13), '3139: det(B) == res(13)');
|
|
md = 15;
|
|
print '3140: md = 15';
|
|
vrfy(det(B) == res(14), '3141: det(B) == res(14)');
|
|
|
|
print '3142: Ending test_matobj';
|
|
}
|
|
print '046: parsed test_matobj()';
|
|
|
|
|
|
/*
|
|
* test_poly - test the polynomial function
|
|
*/
|
|
define test_poly()
|
|
{
|
|
print '3200: Beginning test_matobj';
|
|
|
|
vrfy(poly(2,3,5,2) == 19, '3201: vrfy poly(2,3,5,2) == 19');
|
|
vrfy(poly(list(5,3,2),2) == 19,\
|
|
'3202: vrfy poly(list(5,3,2),2) == 19');
|
|
vrfy(poly(list(5,3,2)) == 5, '3203: vrfy poly(list(5,3,2)) == 5');
|
|
vrfy(poly(2) == 2, '3204: vrfy poly(2) == 2');
|
|
vrfy(poly(list(5,3,2),2,3) == 19,\
|
|
'3205: vrfy poly(list(5,3,2),2,3) == 19');
|
|
vrfy(poly(list()) == 0, '3206: vrfy poly(list()) == 0');
|
|
vrfy(poly(list(),2,3) == 0, '3207: vrfy poly(list(),2,3) == 0');
|
|
vrfy(poly(list(list(5,3,2)),7,2) == 19,\
|
|
'3208: vrfy poly(list(list(5,3,2)),7,2) == 19');
|
|
vrfy(poly(list(list(1,2,3),list(4,5),6),7) == 323,\
|
|
'3209: vrfy poly(list(list(1,2,3),list(4,5),6),7) == 323');
|
|
vrfy(poly(list(list(1,2,3),list(4,5),6),7,8) == 811,\
|
|
'3210: vrfy poly(list(list(1,2,3),list(4,5),6),7,8) == 811');
|
|
vrfy(poly(list(list(1,2,3),list(4,5),6),7,8,9) == 811,\
|
|
'3211: vrfy poly(list(list(1,2,3),list(4,5),6),7,8,9)==811');
|
|
vrfy(poly(list(5,3,2), list()) == 5,\
|
|
'3212: vrfy poly(list(5,3,2), list() == 5');
|
|
vrfy(poly(list(5,3,2), list(2)) == 19,\
|
|
'3213: vrfy poly(list(5,3,2), list(2)) == 19');
|
|
vrfy(poly(list(5,3,2), list(2,3)) == 19,\
|
|
'3214: vrfy poly(list(5,3,2), list(2,3)) == 19');
|
|
vrfy(poly(list(list(list(0,0,0,0,0,1))),2,3,4) == 4^5,\
|
|
'3215: vrfy poly(list(list(list(0,0,0,0,0,1))),2,3,4)==4^5');
|
|
vrfy(poly(list(list(list(0,0,0,0,0,1))),2,list(3,4)) == 4^5,\
|
|
'3216: vrfy poly(list(list(list(0,0,0,0,0,1))),2,list(3,4))==4^5');
|
|
|
|
print '3217: Ending test_poly';
|
|
}
|
|
print '047: parsed test_poly()';
|
|
|
|
|
|
/*
|
|
* test_det - more determinent testing
|
|
*/
|
|
read -once "test3300";
|
|
print '048: read -once test3300';
|
|
/**/
|
|
define test_det()
|
|
{
|
|
local tnum; /* test number */
|
|
local i;
|
|
|
|
print '3300: Beginning test_det';
|
|
|
|
tnum = test3300(1, 3301);
|
|
|
|
print tnum: ': Ending test_det';
|
|
}
|
|
print '049: parsed test_det()';
|
|
|
|
|
|
/*
|
|
* test_trig - trig function testing
|
|
*/
|
|
read -once "test3400";
|
|
print '050: read -once test3400';
|
|
/**/
|
|
define test_trig()
|
|
{
|
|
local tnum; /* test number */
|
|
local i;
|
|
|
|
print '3400: Beginning test_trig';
|
|
|
|
tnum = test3400(1, 3401);
|
|
|
|
print tnum: ': Ending test_trig';
|
|
}
|
|
print '051: parsed test_trig()';
|
|
|
|
|
|
/*
|
|
* test_frem - tests of the functions frem, fcnt, gcdrem
|
|
*/
|
|
read -once "test3500";
|
|
print '052: read -once test3500';
|
|
/**/
|
|
define test_frem()
|
|
{
|
|
local tnum; /* test number */
|
|
|
|
print '3500: Beginning test_frem';
|
|
|
|
tnum = test3500(1, 3501, 200, 61);
|
|
|
|
print tnum: ': Ending test_frem';
|
|
}
|
|
print '053: parsed test_frem()';
|
|
|
|
|
|
/*
|
|
* test_error - test the error() builtin
|
|
*/
|
|
define test_error()
|
|
{
|
|
local strx, e99, list1;
|
|
|
|
print '3600: Beginning test_error';
|
|
|
|
strx = "x";
|
|
print '3601: strx = "x"';
|
|
e99 = error(99);
|
|
print '3602: e99 = error(99)';
|
|
vrfy(1/0 == error(10001), '3603: 1/0 == error(10001)');
|
|
vrfy(0/0 == error(10002), '3604: 0/0 == error(10002)');
|
|
vrfy(2 + "x" == error(10003), '3605: 2 + "x" == error(10003)');
|
|
vrfy("x" - 2 == error(10004), '3606: "x" - 2 == error(10004)');
|
|
vrfy("x" * 2 == error(10005), '3607: "x" * 2 == error(10005)');
|
|
vrfy("x" / 2 == error(10006), '3608: "x" / 2 == error(10006)');
|
|
vrfy(-"x" == error(10007), '3609: -"x" == error(10007)');
|
|
vrfy("x"^2 == error(10008), '3610: "x"^2 == error(10008)');
|
|
vrfy(inverse("x")==error(10009),'3611: inverse("x") == error(10009)');
|
|
vrfy(++strx == error(10010), '3612: ++strx == error(10010)');
|
|
vrfy(strx == error(10010), '3613: strx == error(10010)');
|
|
strx = "x";
|
|
print '3614: strx = "x"';
|
|
vrfy(strx++ == "x", '3615: strx++ == "x"');
|
|
vrfy(strx == error(10010), '3616: strx == error(10010)');
|
|
strx = "x";
|
|
print '3617: strx = "x"';
|
|
vrfy(--strx == error(10011), '3618: strx == error(10011)');
|
|
vrfy(int("x") == error(10012), '3619: int("x") == error(10012)');
|
|
vrfy(frac("x") == error(10013), '3620: frac("x") == error(10013)');
|
|
vrfy(conj("x") == error(10014), '3621: conj("x") == error(10014)');
|
|
vrfy(appr("x",.1) == error(10015),
|
|
'3622: appr("x",.1) == error(10015)');
|
|
vrfy(appr(1.27,.1i) == error(10016),
|
|
'3623: appr(1.27,.1i) == error(10016)');
|
|
vrfy(appr(1.27,.1,.1) == error(10017),
|
|
'3624: appr(1.27,.1,.1) == error(10017)');
|
|
vrfy(round("x") == error(10018), '3625: round("x") == error(10018)');
|
|
vrfy(round(1.25,.1) == error(10019),
|
|
'3626: round(1.25,.1) == error(10019)');
|
|
vrfy(round(1.25,"x") == error(10019),
|
|
'3627: round(1.25,"x") == error(10019)');
|
|
vrfy(round(1.25,1,.1) == error(10020),
|
|
'3628: round(1.25,1,.1) == error(10020)');
|
|
vrfy(bround("x") == error(10021), '3629: bround("x") == error(10021)');
|
|
vrfy(bround(1.25,.1) == error(10022),
|
|
'3630: bround(1.25,.1) == error(10022)');
|
|
vrfy(bround(1.25,"x") == error(10022),
|
|
'3631: bround(1.25,"x") == error(10022)');
|
|
vrfy(bround(1.25,1,.1) == error(10023),
|
|
'3632: bround(1.25,1,.1) == error(10023)');
|
|
vrfy(sqrt("x") == error(10024), '3633: sqrt("x") == error(10024)');
|
|
vrfy(sqrt(2,"x") == error(10025),
|
|
'3634: sqrt(2,"x") == error(10025)');
|
|
vrfy(sqrt(2,0) == error(10025), '3635: sqrt(2,0) == error(10025)');
|
|
vrfy(sqrt(2,.1,.1) == error(10026),
|
|
'3636: sqrt(2,.1,.1) == error(10026)');
|
|
vrfy(root("x",3) == error(10027),
|
|
'3637: root("x",3) == error(10027)');
|
|
vrfy(root(3,"x") == error(10028),
|
|
'3638: root(3,"x") == error(10028)');
|
|
vrfy(root(3,-2) == error(10028),
|
|
'3639: root(3,-2) == error(10028)');
|
|
vrfy(root(3,0) == error(10028), '3640: root(3,0) == error(10028)');
|
|
vrfy(root(3,.1) == error(10028),
|
|
'3641: root(3,.1) == error(10028)');
|
|
vrfy(root(3,2,"x") == error(10029),
|
|
'3642: root(3,2,"x") == error(10029)');
|
|
vrfy(root(3,2,0) == error(10029),
|
|
'3643: root(3,2,0) == error(10029)');
|
|
vrfy(norm("x") == error(10030), '3644: norm("x") == error(10030)');
|
|
vrfy("x" << 2 == error(10031), '3645: "x" << 2 == error(10031)');
|
|
vrfy(1.5 << 2 == error(10031), '3646: 1.5 << 2 == error(10031)');
|
|
vrfy(3 << "x" == error(10032), '3647: 3 << "x" == error(10032)');
|
|
vrfy(3 << 1.5 == error(10032), '3648: 3 << 1.5 == error(10032)');
|
|
vrfy(3 << 2^31 == error(10032), '3649: 3 << 2^31 == error(10032)');
|
|
vrfy(scale("x",2) == error(10033),
|
|
'3650: scale("x",2) == error(10033)');
|
|
vrfy(scale(3,"x") == error(10034),
|
|
'3651: scale(3,"x") == error(10034)');
|
|
vrfy(scale(3,1.5) == error(10034),
|
|
'3652: scale(3,1.5) == error(10034)');
|
|
vrfy(scale(3,2^31) == error(10034),
|
|
'3653: scale(3,2^31) == error(10034)');
|
|
vrfy("x" ^ 3 == error(10035), '3654: "x" ^ 3 == error(10035)');
|
|
vrfy(2 ^ "x" == error(10036), '3655: 2 ^ "x" == error(10036)');
|
|
vrfy(2 ^ 2.5 == error(10036), '3656: 2 ^ 2.5 == error(10036)');
|
|
vrfy(power("x",2.1) == error(10037),
|
|
'3657: power("x",2.1) == error(10037)');
|
|
vrfy(power(2,"x") == error(10038),
|
|
'3658: power(2,"x") == error(10038)');
|
|
vrfy(power(2,2.1,"x") == error(10039),
|
|
'3659: power(2,2.1,"x") == error(10039)');
|
|
vrfy(quo("x",3) == error(10040), '3660: quo("x",3) == error(10040)');
|
|
vrfy(quo(8,"x") == error(10041), '3661: quo(8,"x") == error(10041)');
|
|
vrfy(quo(8,3,"x") == error(10042),
|
|
'3662: quo(8,3,"x") == error(10042)');
|
|
vrfy(quo(8,3,2.1) == error(10042),
|
|
'3663: quo(8,3,2.1) == error(10042)');
|
|
vrfy(mod("x",3) == error(10043), '3664: mod("x",3) == error(10043)');
|
|
vrfy(mod(8,"x") == error(10044), '3665: mod(8,"x") == error(10044)');
|
|
vrfy(mod(8,3,"x") == error(10045),
|
|
'3666: mod(8,3,"x") == error(10045)');
|
|
vrfy(mod(8,3,2.1) == error(10045),
|
|
'3667: mod(8,3,2.1) == error(10045)');
|
|
vrfy(sgn("x") == error(10046), '3668: sgn("x") == error(10046)');
|
|
vrfy(abs("x") == error(10047), '3669: abs("x") == error(10047)');
|
|
vrfy(abs(2+3i,"x") == error(10048),
|
|
'3670: abs(2+3i,"x") == error(10048)');
|
|
vrfy(abs(2+3i,0) == error(10048),
|
|
'3671: abs(2+3i,0) == error(10048)');
|
|
list1 = list(2,3,"x",4,5);
|
|
print '3672: list1 = list(2,3,"x",4,5)';
|
|
vrfy(avg(list1) == error(10003),
|
|
'3673: avg(list1) == error(10003)');
|
|
|
|
vrfy(iserror(e99)==99, '3674: iserror(e99) == 99');
|
|
vrfy(e99 + 2 == e99, '3675: e99 + 2 == e99');
|
|
vrfy(e99 - 2 == e99, '3676: e99 - 2 == e99');
|
|
vrfy(e99 * 2 == e99, '3677: e99 * 2 == e99');
|
|
vrfy(e99 / 2 == e99, '3678: e99 / 2 == e99');
|
|
vrfy(e99 // 2 == e99, '3679: e99 // 2 == e99');
|
|
vrfy(e99 % 2 == e99, '3680: e99 % 2 == e99');
|
|
vrfy(e99 ^ 2 == e99, '3681: e99 ^ 2 == e99');
|
|
vrfy(2 + e99 == e99, '3682: 2 + e99 == e99');
|
|
vrfy(2 - e99 == e99, '3683: 2 - e99 == e99');
|
|
vrfy(2 * e99 == e99, '3684: 2 * e99 == e99');
|
|
vrfy(2 / e99 == e99, '3685: 2 / e99 == e99');
|
|
vrfy(2 // e99 == e99, '3686: 2 // e99 == e99');
|
|
vrfy(2 % e99 == e99, '3687: 2 % e99 == e99');
|
|
vrfy(2 ^ e99 == e99, '3688: 2 ^ e99 == e99');
|
|
vrfy(- e99 == e99, '3689: -e99 == e99');
|
|
vrfy(inverse(e99) == e99, '3690: inverse(e99) == e99');
|
|
vrfy(++e99 == e99, '3691: ++e99 == e99');
|
|
vrfy(--e99 == e99, '3692: --e99 == e99');
|
|
vrfy(int(e99) == e99, '3693: int(e99) == e99');
|
|
vrfy(frac(e99) == e99, '3694: frac(e99) == e99');
|
|
vrfy(conj(e99) == e99, '3695: conj(e99) == e99');
|
|
vrfy(norm(e99) == e99, '3696: norm(e99) == e99');
|
|
vrfy(sgn(e99) == e99, '3697: sgn(e99) == e99');
|
|
vrfy(appr(e99,1,0) == e99, '3698: appr(e99,1,0) == e99');
|
|
vrfy(round(e99) == e99, '3699: round(e99) == e99');
|
|
vrfy(bround(e99) == e99, '3700: bround(e99) == e99');
|
|
vrfy(sqrt(e99) == e99, '3701: sqrt(e99) == e99');
|
|
|
|
print '3702: Ending test_error';
|
|
}
|
|
print '054: parsed test_error()';
|
|
|
|
|
|
/*
|
|
* test_param - test new param() functionality.
|
|
*/
|
|
define g_param() = (param(2) = param(1));
|
|
print '055: define g_param() = (param(2) = param(1))';
|
|
define h_param() = (param(1)++, param(2)--);
|
|
print '056: define h_param() = (param(1)++, param(2)--)';
|
|
/**/
|
|
global u_glob = 5;
|
|
print '057: global u_glob = 5';
|
|
global v_glob = 10;
|
|
print '058: global v_glob = 10';
|
|
vrfy(g_param(u_glob, &v_glob) == 5, '059: g_param(u_glob, &v_glob) == 5');
|
|
vrfy(u_glob == 5, '060: u_glob == 5');
|
|
vrfy(v_glob == 5, '061: v_glob == 5');
|
|
vrfy(h_param(&u_glob, &v_glob) == 5, '062: h_param(&u_glob, &v_glob) == 5');
|
|
vrfy(u_glob == 6, '063: u_glob == 6');
|
|
vrfy(v_glob == 4, '064: v_glob == 4');
|
|
/**/
|
|
define test_param()
|
|
{
|
|
local u, v;
|
|
|
|
print '3800: Beginning test_param';
|
|
|
|
u = 5;
|
|
print '3801: u = 5';
|
|
v = 10;
|
|
print '3802: v = 10';
|
|
vrfy(g_param(u, &v) == 5, '3803: g_param(u, &v) == 5');
|
|
vrfy(u == 5, '3804: u == 5');
|
|
vrfy(v == 5, '3805: v == 5');
|
|
vrfy(h_param(&u, &v) == 5, '3806: h_param(&u, &v) == 5');
|
|
vrfy(u == 6, '3807: u == 6');
|
|
vrfy(v == 4, '3808: v == 4');
|
|
|
|
print '3809: Ending test_param';
|
|
}
|
|
print '065: parsed test_param()';
|
|
|
|
|
|
/*
|
|
* test_noarg - test missing argment functionality
|
|
*/
|
|
define test_noarg()
|
|
{
|
|
local A,B,C,D;
|
|
|
|
print '3900: Beginning test_noarg';
|
|
|
|
A = list(1,,3);
|
|
print '3901: A = list(1,,3)';
|
|
vrfy(A[[0]] == 1, '3902: A[[0]] == 1');
|
|
vrfy(isnull(A[[1]]), '3903: isnull(A[[1]])');
|
|
vrfy(A[[2]] == 3, '3904: A[[2]] == 3');
|
|
vrfy(size(A) == 3, '3905: size(A) == 3');
|
|
|
|
B = list(,,);
|
|
print '3906: B = list(,,)';
|
|
vrfy(isnull(B[[0]]), '3907: isnull(B[[0]])');
|
|
vrfy(isnull(B[[1]]), '3908: isnull(B[[1]])');
|
|
vrfy(isnull(B[[2]]), '3909: isnull(B[[2]])');
|
|
vrfy(size(B) == 3, '3910: size(B) == 3');
|
|
|
|
mat C[] = {,,};
|
|
print '3911: mat C[] = {,,}';
|
|
vrfy(C[0] == 0, '3912: C[0] == 0');
|
|
vrfy(C[1] == 0, '3913: C[1] == 0');
|
|
vrfy(C[2] == 0, '3914: C[2] == 0');
|
|
vrfy(size(C) == 3, '3915: size(C) == 3');
|
|
|
|
mat D[] = { };
|
|
print '3916: mat D[] = { }';
|
|
vrfy(D[0] == 0, '3917: D[0] == 0');
|
|
vrfy(size(D) == 1, '3918: size(D) == 1');
|
|
print '3919: Ending test_noarg';
|
|
}
|
|
print '066: parsed test_noarg';
|
|
|
|
|
|
/*
|
|
* test_ptest - more tests of the functions ptest, nextcand, prevcand
|
|
*/
|
|
read -once "test4000";
|
|
print '067: read -once test4000';
|
|
/**/
|
|
define test_ptest()
|
|
{
|
|
local tnum; /* test number */
|
|
|
|
print '4000: Beginning test_ptest';
|
|
|
|
tnum = test4000(1, 4001);
|
|
|
|
print tnum: ': Ending test_ptest';
|
|
}
|
|
print '068: parsed test_ptest()';
|
|
|
|
|
|
/*
|
|
* test_redc - REDC operation tests
|
|
*/
|
|
read -once "test4100";
|
|
print '069: read -once test4100';
|
|
/**/
|
|
define test_redc()
|
|
{
|
|
local tnum; /* test number */
|
|
|
|
print '4100: Beginning test_redc';
|
|
|
|
tnum = test4100(1, 4101);
|
|
|
|
print tnum: ': Ending test_redc';
|
|
}
|
|
print '070: parsed test_redc()';
|
|
|
|
|
|
/*
|
|
* test_fileops - test various file operations
|
|
*/
|
|
define test_fileops()
|
|
{
|
|
local a, b, c, f, m, n, x, y, z;
|
|
local L = "Landon";
|
|
local C = "Curt";
|
|
local N = "Noll";
|
|
local LCN = "Landon\nCurt\nNoll\n";
|
|
|
|
print '4200: Beginning test_fileops';
|
|
|
|
/*
|
|
* fputs tests
|
|
*/
|
|
print '4201: x = rm("junk4200")';
|
|
x = rm("junk4200");
|
|
vrfy(!iserror(f = fopen("junk4200", "w+")),
|
|
'4202: !iserror(f = fopen("junk4200", "w+"))');
|
|
vrfy(!iserror(fputs(f, LCN)), '4203: !iserror(fputs(f, LCN))');
|
|
vrfy(isnull(rewind(f)), '4204: isnull(rewind(f))');
|
|
vrfy(fgetfield(f) == L, '4205: fgetfield(f) == L');
|
|
vrfy(fgetfield(f) == C, '4206: fgetfield(f) == C');
|
|
vrfy(fgetfield(f) == N, '4207: fgetfield(f) == N');
|
|
vrfy(isnull(fgetfield(f)), '4208: isnull(fgetfield(f))');
|
|
vrfy(isnull(rewind(f)), '4209: isnull(rewind(f))');
|
|
vrfy(fgetline(f) == L, '4210: fgetline(f) == L');
|
|
vrfy(fgetline(f) == C, '4211: fgetline(f) == C');
|
|
vrfy(fgetline(f) == N, '4212: fgetline(f) == N');
|
|
vrfy(isnull(fgetline(f)), '4213: isnull(fgetline(f))');
|
|
vrfy(isnull(rewind(f)), '4214: isnull(rewind(f))');
|
|
vrfy(fgets(f) == strcat(L,"\n"),'4215: fgets(f) == strcat(L,"\\n")');
|
|
vrfy(fgets(f) == strcat(C,"\n"),'4216: fgets(f) == strcat(C,"\\n")');
|
|
vrfy(fgets(f) == strcat(N,"\n"),'4217: fgets(f) == strcat(N,"\\n")');
|
|
vrfy(isnull(fgets(f)), '4218: isnull(fgets(f))');
|
|
vrfy(isnull(rewind(f)), '4219: isnull(rewind(f))');
|
|
vrfy(fgetstr(f) == LCN, '4220: fgetstr(f) == LCN');
|
|
vrfy(isnull(fclose(f)), '4221: isnull(fclose(f))');
|
|
vrfy(isnull(fclose(f)), '4222: isnull(fclose(f))');
|
|
|
|
/*
|
|
* fgetstr tests
|
|
*/
|
|
vrfy(!iserror(f = fopen("junk4200", "w+")),
|
|
'4223: !iserror(f)');
|
|
|
|
vrfy(isnull(fputstr(f, L, C, N)),
|
|
'4224: isnulll(fputstr(f, L, C, N))');
|
|
vrfy(isnull(rewind(f)), '4225: isnull(rewind(f))');
|
|
vrfy(fgetstr(f) == L, '4226: fgetstr(f) == L');
|
|
vrfy(fgetstr(f) == C, '4227: fgetstr(f) == C');
|
|
vrfy(fgetstr(f) == N, '4228: fgetstr(f) == N');
|
|
vrfy(isnull(fgetstr(f)), '4229: isnull(fgetstr(f))');
|
|
n = ftell(f);
|
|
print '4230: n = ftell(f)';
|
|
vrfy(isnull(fputs(f,L,"\n",C,"\n",N,"\n")),
|
|
'4231: isnull(fputs(f,L,"\\n",C,"\\n",N,"\\n"))');
|
|
fseek(f, n);
|
|
print '4232: fseek(f, n)';
|
|
vrfy(fgetstr(f) == LCN, '4233: fgetstr(f) == LCN');
|
|
vrfy(isnull(fclose(f)), '4234: isnull(fclose(f))');
|
|
|
|
/*
|
|
* fscanf tests
|
|
*/
|
|
a = exp(27, 1e-1000);
|
|
print '4235: a = exp(27, 1e-1000)';
|
|
b = sqrt(7 + 5i, 1e-2000);
|
|
print '4236: b = sqrt(7 + 5i, 1e-2000)';
|
|
c = config("display", 1000);
|
|
print '4237: c = config("display", 1000)';
|
|
vrfy(!iserror(f=fopen("junk4200","w+")),
|
|
'4238: !iserror(f=fopen("junk4200","w+"))');
|
|
vrfy(!iserror(fprintf(f, "%f\n\tand\n\t%r",a,b)),
|
|
'4239: !iserror(fprintf(f, "%f\\n\\tand\\n\\t%r",a,b))');
|
|
vrfy(isnull(rewind(f)), '4240: isnull(rewind(f))');
|
|
vrfy(fscanf(f,"%f and %r",x,y) == 2,
|
|
'4241: fscanf(f,"%f and %r",x,y) == 2');
|
|
vrfy(x == a && y == b, '4242: x == a && y == b');
|
|
vrfy(!iserror(freopen(f, "w+")),'4243: !iserror(freopen(f, "w+"))');
|
|
L = "Landon\n";
|
|
print '4244: L = "Landon\\n"';
|
|
C = "\tCurt\n";
|
|
print '4245: C = "\tCurt\\n"';
|
|
N = "\t\tNoll\n";
|
|
print '4246: N = "\\t\\tNoll\\n"';
|
|
vrfy(isnull(fputs(f, L, "|", C, "[", N, "]" )),
|
|
'4247: isnull(fputs(f, L, "|", C, "[", N, "]" ))');
|
|
vrfy(isnull(rewind(f)), '4248: isnull(rewind(f))');
|
|
vrfy(fscanf(f, "%[^|]%*c%[^[]%*c%[^]]", x,y,z) == 3,
|
|
'4249: fscanf(f, "%[^|]%*c%[^[]%*c%[^]]", x,y,z) == 3');
|
|
vrfy(x == L && y == C && z == N,
|
|
'4250: x == L && y == C && z == N');
|
|
vrfy(isnull(rewind(f)), '4251: isnull(rewind(f))');
|
|
vrfy(fscanf(f, "%*[^|]%*c%n%*[^[]%*c%n", m, n) == 2,
|
|
'4252: fscanf(f, "%*[^|]%*c%n%*[^[]%*c%n", m, n) == 2');
|
|
fseek(f, m);
|
|
print '4253: fseek(f, m)';
|
|
vrfy(fscanf(f, "%3c", x) == 1, '4254: fscanf(f, "%3c", x) == 1');
|
|
vrfy(x == "\tCu", '4255: x == "\tCu"');
|
|
fseek(f, n);
|
|
print '4256: fseek(f, n)';
|
|
vrfy(fscanf(f, "%s", y) == 1, '4257: fscanf(f, "%s", y) == 1');
|
|
vrfy(y == "Noll", '4258: y == "Noll"');
|
|
vrfy(isnull(fclose(f)), '4259: isnull(fclose(f))');
|
|
|
|
/*
|
|
* cleanup
|
|
*/
|
|
print '4260: x = rm("junk4200")';
|
|
x = rm("junk4200");
|
|
|
|
print '4261: Ending test_fileops';
|
|
}
|
|
print '071: parsed test_redc()';
|
|
|
|
|
|
/*
|
|
* test_matdcl - test new matrix declaration syntax
|
|
*/
|
|
mat_X0 = mat[4];
|
|
print '072: mat_X = mat[4]';
|
|
mat mat_X1, mat_X2[2], mat_X3[3];
|
|
print '073: mat mat_X1, mat_X2[2], mat_X3[3]';
|
|
mat mat_Z0, mat_Z1 [2] = {1,2};
|
|
print '074: mat mat_Z0, mat_Z1 [2] = {1,2}';
|
|
define test_matdcl()
|
|
{
|
|
local mat_Y0;
|
|
local mat mat_Y1, mat_Y2[2], mat_Y3[3];
|
|
local mat M0, M1, M2[2,2];
|
|
local i;
|
|
|
|
print '4300: Beginning test_matdcl';
|
|
|
|
vrfy(size(mat_X0) == 4, '4301: size(mat_X0) == 4');
|
|
vrfy(size(mat_X1) == 2, '4302: size(mat_X1) == 2');
|
|
vrfy(size(mat_X2) == 2, '4303: size(mat_X2) == 2');
|
|
vrfy(size(mat_X3) == 3, '4304: size(mat_X3) == 3');
|
|
vrfy(ismat(mat_X0), '4305: ismat(mat_X0)');
|
|
vrfy(ismat(mat_X1), '4306: ismat(mat_X1)');
|
|
vrfy(ismat(mat_X2), '4307: ismat(mat_X2)');
|
|
vrfy(ismat(mat_X3), '4308: ismat(mat_X3)');
|
|
mat_Y0 = mat[4];
|
|
print '4309: mat_Y0 = mat[4]';
|
|
vrfy(size(mat_Y0) == 4, '4310: size(mat_Y0) == 4');
|
|
vrfy(size(mat_Y1) == 2, '4311: size(mat_Y1) == 2');
|
|
vrfy(size(mat_Y2) == 2, '4312: size(mat_Y2) == 2');
|
|
vrfy(size(mat_Y3) == 3, '4313: size(mat_Y3) == 3');
|
|
vrfy(ismat(mat_Y0), '4314: ismat(mat_Y0)');
|
|
vrfy(ismat(mat_Y1), '4315: ismat(mat_Y1)');
|
|
vrfy(ismat(mat_Y2), '4316: ismat(mat_Y2)');
|
|
vrfy(ismat(mat_Y3), '4317: ismat(mat_Y3)');
|
|
vrfy(size(mat_Z0) == 2, '4318: size(mat_Z0) == 2');
|
|
vrfy(size(mat_Z1) == 2, '4319: size(mat_Z1) == 2');
|
|
vrfy(ismat(mat_Z0), '4320: ismat(mat_Z0)');
|
|
vrfy(ismat(mat_Z1), '4321: ismat(mat_Z1)');
|
|
vrfy(mat_Z0 == mat_Z1, '4322: mat_Z0 == mat_Z1');
|
|
vrfy(mat_Z0 == (mat[2] = {1,2}), '4323: mat_Z0 == (mat[2] = {1,2})');
|
|
vrfy(mat_Z0[0] == 1, '4324: mat_Z0[0] == 1');
|
|
vrfy(mat_Z0[1] == 2, '4325: mat_Z0[1] == 2');
|
|
mat_Z1 = {,3};
|
|
print '4326: mat_Z1 = {,3}';
|
|
vrfy(mat_Z0 != mat_Z1, '4327: mat_Z0 != mat_Z1');
|
|
vrfy(mat_Z1[0] == 1, '4328: mat_Z1[0] == 1');
|
|
vrfy(mat_Z1[1] == 3, '4329: mat_Z1[1] == 3');
|
|
mat_X3 = {2,3,5};
|
|
print '4330: mat_X3 = {2,3,5}';
|
|
mat_X3 += {3,4,5};
|
|
print '4331: mat_X3 += {3,4,5}';
|
|
vrfy(mat_X3[0] == 5, '4332: mat_X3[0] == 5');
|
|
vrfy(mat_X3[1] == 7, '4333: mat_X3[1] == 7');
|
|
vrfy(mat_X3[2] == 10, '4334: mat_X3[2] == 10');
|
|
mat_Y3 = mat_X3;
|
|
print '4335: mat_Y3 = mat_X3';
|
|
mat_Y3 -= {,1,2};
|
|
print '4336: mat_Y3 -= {0,1,}';
|
|
vrfy(mat_Y3[0] == 0, '4337: mat_Y3[0] == 0');
|
|
vrfy(mat_Y3[1] == 6, '4338: mat_Y3[1] == 6');
|
|
vrfy(mat_Y3[2] == 8, '4339: mat_Y3[2] == 8');
|
|
mat_Y3 += 2;
|
|
print '4340: mat_Y3 += 2';
|
|
vrfy(mat_Y3 == error(10003), '4341: mat_Y3 == error(10003)');
|
|
mat_Z0 += { };
|
|
print '4342: mat_Z0 += { }';
|
|
vrfy(mat_Z0[0] == 2, '4343: mat_Z0[0] == 2');
|
|
vrfy(mat_Z0[1] == 4, '4344: mat_Z0[1] == 4');
|
|
mat_Y0 = {mat_Z0, ,mat_Z1, mat_X3};
|
|
print '4345: mat_Y0 = {mat_Z0, ,mat_Z1, mat_X3}';
|
|
vrfy(size(mat_Y0) == 4, '4346: size(mat_Y0) == 4');
|
|
for (i=0; i < 4; ++i) mat_X0[i] = size(mat_Y0[i]);
|
|
print '4347: for (i=0; i < 4; ++i) mat_X0[i] = size(mat_Y0[i])';
|
|
mat_X0==(mat[4]={2,1,2,3});
|
|
print '4348: mat_X0==(mat[4]={2,1,2,3})';
|
|
vrfy(mat_Y0[0] == mat_Z0, '4349: mat_Y0[0] == mat_Z0');
|
|
vrfy(mat_Y0[1] == 0, '4350: mat_Y0[1] == 0');
|
|
vrfy(mat_Y0[2] == mat_Z1, '4351: mat_Y0[2] == mat_Z1');
|
|
vrfy(mat_Y0[3] == mat_X3, '4352: mat_Y0[3] == mat_X3');
|
|
vrfy(mat_Y0[0][0] == 2, '4353: mat_Y0[0][0] == 2');
|
|
vrfy(mat_Y0[0][1] == 4, '4354: mat_Y0[0][1] == 4');
|
|
vrfy(mat_Y0[2][0] == 1, '4355: mat_Y0[2][0] == 1');
|
|
vrfy(mat_Y0[2][1] == 3, '4356: mat_Y0[2][1] == 3');
|
|
vrfy(mat_Y0[3][0] == 5, '4357: mat_Y0[3][0] == 5');
|
|
vrfy(mat_Y0[3][1] == 7, '4358: mat_Y0[3][1] == 7');
|
|
vrfy(mat_Y0[3][2] == 10, '4359: mat_Y0[3][2] == 10');
|
|
|
|
M0 = {(mat[2]={5,17}),(mat[2]={3,4}),(mat[2]={2,3}),(mat[2]={1,2})};
|
|
print '4360: M0 = {(mat[2]={5,17}), ...}';
|
|
M1 = {(mat[2]={5,3}),(mat[2]={2,5}),(mat[2]={1,5}),(mat[2]={3,2})};
|
|
print '4361: M1 = {(mat[2]={5,3}), ...}';
|
|
M2 = M0+M1;
|
|
print '4362: M2 = M0+M1';
|
|
vrfy(M2[0,0]==(mat[2]={10,20}), '4363: M2[0,0]==(mat[2]={10,20})');
|
|
vrfy(M2[0,1]==(mat[2]={5,9}), '4364: M2[0,1]==(mat[2]={5,9})');
|
|
vrfy(M2[1,0]==(mat[2]={3,8}), '4365: M2[1,0]==(mat[2]={3,20})');
|
|
vrfy(M2[1,1]==(mat[2]={4,4}), '4366: M2[1,1]==(mat[2]={4,4})');
|
|
|
|
print '4367: Ending test_matdcl';
|
|
}
|
|
print '075: parsed test_matdcl()';
|
|
|
|
|
|
/*
|
|
* test_objmat - test combined obj and mat operations
|
|
*/
|
|
define test_objmat()
|
|
{
|
|
static obj surd P, R, S, T, U;
|
|
local mat M0[2] = {5,17};
|
|
local mat M1[2] = {3,4};
|
|
local mat M2[2,2] = {1,2,3,5};
|
|
local mat M3[2,2] = {3,5,7,11};
|
|
local mat M4[2,2] = {51,82,116,187};
|
|
local Q;
|
|
local V;
|
|
local A,B,C,M;
|
|
|
|
print '4400: Beginning test_objmat';
|
|
|
|
surd_type = -1;
|
|
print '4401: surd_type == -1';
|
|
P = {M0,M1};
|
|
print '4402: P = {M0,M1}';
|
|
vrfy(P == surd(M0,M1), '4403: P == surd(M0,M1)');
|
|
vrfy(P != surd(M1,M0), '4404: P == surd(M1,M0)');
|
|
vrfy(conj(P)==surd(M0,-M1), '4405: conj(P)==surd(M0,-M1)');
|
|
Q = surd_value(P);
|
|
print '4406: Q = surd_value(P)';
|
|
vrfy(ismat(Q), '4407: ismat(Q)');
|
|
vrfy(Q == (mat[2]={5+3i,17+4i}), '4408: Q == (mat[2]={5+3i,17+4i})');
|
|
R = {M2,M3};
|
|
print '4409: R = {M2,M3}';
|
|
vrfy(norm(R) == M4, '4410: norm(R) == M4');
|
|
vrfy(det(surd_value(R^2)) == -23-6i, \
|
|
'4411: det(surd_value(R^2)) == -23-6i');
|
|
vrfy(det(norm(R^5))==268107761663283843865, \
|
|
'4412: det(norm(R^5))==268107761663283843865');
|
|
S = {M2+M3, M2-M3};
|
|
print '4413: S = {M2+M3, M2-M3}';
|
|
T = {M2+3*M3, 5*M2-M3};
|
|
print '4414: T = {M2+3*M3, 5*M2-M3}';
|
|
U = {(M4 -= {50,80,110,180}), M4+M2};
|
|
print '4415: U = {(M4 -= {50,80,110,180}), M4+M2}';
|
|
vrfy(det(surd_value(R*S*T*U)) == 480-15040i,
|
|
'4416: det(surd_value(R*S*T*U)) == 480-15040i');
|
|
vrfy(det(surd_value(R*S+T*U)) == 78+514i,
|
|
'4417: det(surd_value(R*S+T*U)) == 78+514i');
|
|
V = norm(det(surd_value(R^5+S^5+T^5+U^5)));
|
|
print '4418: V = norm(det(surd_value(R^5+S^5+T^5+U^5)))';
|
|
vrfy(V == 41952632964892462488299378, \
|
|
'4419: V == 41952632964892462488299378');
|
|
V = norm(det(surd_value(R^5-S^5+T^5-U^5)));
|
|
print '4420: V = norm(det(surd_value(R^5-S^5+T^5-U^5)))';
|
|
vrfy(V == 40891924356202870926321650, \
|
|
'4421: V == 40891924356202870926321650');
|
|
|
|
|
|
vrfy((mat [3] = {2,3,5})+(mat[3] = {7,11,13}) == (mat[3]={9,14,18}),\
|
|
'4422: (mat [3] = {2,3,5})+(mat[3] = {7,11,13}) == (mat[3]={9,14,18})');
|
|
|
|
vrfy((mat [2,2] = {2,3,5,7})^2 == (mat[2,2] = {19, 27, 45, 64}),\
|
|
'4423: (mat [2,2] = {2,3,5,7})^2 == (mat[2,2] = {19, 27, 45, 64})');
|
|
|
|
vrfy((mat [] = {1,2,3}) == (mat[3] = {1,2,3}),
|
|
'4424: (mat [] = {1,2,3}) == (mat[3] = {1,2,3})');
|
|
|
|
mat A[3] = {2,3,5};
|
|
print '4425: mat A[3] = {2,3,5}';
|
|
mat A[3] = {A[0], A[2], A[1]};
|
|
print '4426: mat A[3] = {A[0], A[2], A[1]}';
|
|
vrfy(A == (mat[3] = {2, 5, 3}), '4427: A == (mat[3] = {2, 5, 3})');
|
|
|
|
B = mat[3] = {2,5,3};
|
|
print '4428: B = mat[3] = {2,5,3}';
|
|
vrfy(A == B, '4429: A == B');
|
|
|
|
mat A[2] = {A[1], A[2]};
|
|
print '4430: mat A[2] = {A[1], A[2]}';
|
|
vrfy(A == (mat[2] = {5, 3}), '4431: A == (mat[2] = {5, 3})');
|
|
|
|
A = B;
|
|
print '4432: A = B';
|
|
A = {A[0], A[2], A[1]};
|
|
print '4433: A = {A[0], A[2], A[1]}';
|
|
vrfy(A == (mat[3] = {2, 3, 3}), '4434: A == (mat[3] = {2, 3, 3})');
|
|
|
|
A = mat[3] = {1,2} = {,3,4};
|
|
print '4435: A = mat[3] = {1,2} = {,3,4}';
|
|
vrfy(A == (mat[3] = {1,3,4}), '4436: A == (mat[3] = {1,3,4})');
|
|
|
|
mat A[4] = {1,2,3,4};
|
|
print '4437: mat A[4] = {1,2,3,4}';
|
|
A = {,5,,6};
|
|
print '4438: A = {,5,,6}';
|
|
vrfy(A == (mat[4] = {1,5,3,6}), '4439: A == (mat[4] = {1,5,3,6})');
|
|
|
|
A = {7};
|
|
print '4440: A = {7}';
|
|
vrfy(A == (mat[4] = {7,5,3,6}), '4441: A == (mat[4] = {7,5,3,6})');
|
|
|
|
mat M[2];
|
|
print '4442: mat M[2]';
|
|
mat A, B, C [3] = {M, M, M};
|
|
print '4443: mat A, B, C [3] = {M, M, M}';
|
|
|
|
A = {{2, 3}, {5, 7}, {11, 13}};
|
|
print '4444: A = {{2, 3}, {5, 7}, {11, 13}}';
|
|
B = {{1, 2}, {3, 4}, {5, 6}};
|
|
print '4445: B = {{1, 2}, {3, 4}, {5, 6}}';
|
|
C = {{3, 5}, {8, 11}, {16, 19}};
|
|
print '4446: C = {{3, 5}, {8, 11}, {16, 19}}';
|
|
|
|
vrfy(A + B == C, '4447: A + B == C');
|
|
|
|
mat A[2][3];
|
|
print '4448: mat A[2][3]';
|
|
A = {{1, 2, 3}, {4, 5, 6}};
|
|
print '4449: A = {{1, 2, 3}, {4, 5, 6}}';
|
|
vrfy(A[0][1] == 2, '4450: A[0][1] == 2');
|
|
|
|
vrfy(A[1,0] == 4, '4451: A[1,0] == 4');
|
|
|
|
B = mat[2][3] = {{1, 2, 3}, {4, 5, 6}};
|
|
print '4452: B = mat[2][3] = {{1, 2, 3}, {4, 5, 6}}';
|
|
vrfy(A == B, '4453: A == B');
|
|
|
|
mat A[2][3] = {{1, 2, 3}, {4, 5, 6}};
|
|
print '4454: mat A[2][3] = {{1, 2, 3}, {4, 5, 6}}';
|
|
vrfy(A == B, '4455: A == B');
|
|
|
|
mat A[2][3] = {{1,2,3},4};
|
|
print '4456: mat A[2][3] = {{1,2,3},4}';
|
|
vrfy(A[0] == (mat[3] = {1,2,3}), '4457: A[0] == (mat[3] = {1,2,3})');
|
|
|
|
vrfy(A[1] == 4, '4458: A[1] == 4');
|
|
|
|
A += {{3,5,7}, 11};
|
|
print '4459: A += {{3,5,7}, 11}';
|
|
|
|
vrfy(A[0] == (mat[3]={4,7,10}), '4460: A[0] == (mat[3]={4,7,10})');
|
|
|
|
vrfy(A[1] == 15, '4461: A[1] == 15');
|
|
|
|
mat A[2,2][2,2]={{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
|
|
print '4462: mat A[2,2][2,2]={{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}}';
|
|
B = A^2;
|
|
print '4463: B = A^2';
|
|
|
|
vrfy(B[0,0] == (mat[2,2] = {118, 132, 166, 188}), \
|
|
'4464: B[0,0] == (mat[2,2] = {118, 132, 166, 188})');
|
|
|
|
print '4465: Ending test_objmat';
|
|
print;
|
|
print '4500: reserved for future expansion of test_objmat';
|
|
}
|
|
print '076: parsed test_objmat()';
|
|
|
|
|
|
/*
|
|
* test_fileop - test file operations
|
|
*/
|
|
read -once "test4600";
|
|
print '077: read -once test4600';
|
|
/**/
|
|
define test_fileop()
|
|
{
|
|
local tnum; /* test number */
|
|
|
|
print '4600: Beginning test_fileop';
|
|
|
|
tnum = test4600(1, 4601);
|
|
|
|
print tnum: ': Ending test_fileop';
|
|
}
|
|
print '078: parsed test_fileop()';
|
|
|
|
|
|
/*
|
|
* test write/read
|
|
*/
|
|
x_081 = isqrt(2e5000);
|
|
print '079: x_081 = isqrt(2e5000)'
|
|
s_x_081 = str(x_081);
|
|
print '080: s_x_081 = str(x_081)';
|
|
d_081 = rm("test082.cal");
|
|
print '081: d_081 = rm("test082.cal")';
|
|
write test082.cal;
|
|
print '082: write test082.cal';
|
|
read "./test082.cal";
|
|
print '083: read "./test082.cal"';
|
|
d_081 = rm("test082.cal");
|
|
print '084: d081 = rm("test082.cal")';
|
|
vrfy(__ == 63, '085: __ == 63');
|
|
vrfy(x_081 == isqrt(2e5000), '086: x_081 == isqrt(2e5000)');
|
|
|
|
|
|
/*
|
|
* test_charset - test the ASCII character set and \'s
|
|
*/
|
|
define test_charset()
|
|
{
|
|
print '4700: Beginning test_charset';
|
|
|
|
vrfy("\a" == char(7), '4701: "\\a" == char(7)');
|
|
vrfy("\v" == char(11), '4702: "\\v" == char(11)');
|
|
vrfy("\e" == char(27), '4703: "\\e" == char(27)');
|
|
vrfy("\\" == char(92), '4704: "\\\\" == char(92)');
|
|
vrfy("\101" == "A", '4705: "\\101" == "A"');
|
|
vrfy("\123" == char(0123), '4706: "\\123" == char(0123)');
|
|
vrfy("\123\124" == "ST", '4707: "\\123\\124" == "ST"');
|
|
vrfy("\311" == char(201), '4708: "\\311" == char(201)');
|
|
vrfy("\119" == "\t9", '4709: "\\119" == "\t9"');
|
|
vrfy("\765" == "\365", '4710: "\\765" == "\365"');
|
|
vrfy("\x61" == "a", '4711: "\\x61" == "a"');
|
|
vrfy("\x73" == "s", '4712: "\\x73" == "s"');
|
|
vrfy("\xea" == char(234), '4713: "\\xea" == char(234)');
|
|
vrfy("\x61\x62\x63" == "abc", '4714: "\\x61\\x62\\x63" == "abc"');
|
|
vrfy("\x8g" == "\bg", '4715: "\\x8g" == "\bg"');
|
|
vrfy(eval('"\\\\"') == "\\",
|
|
'4716: eval(\'"\\\\\\\\"\') == "\\\\"');
|
|
|
|
print '4717: Ending test_charset';
|
|
}
|
|
print '087: parsed test_fileop()';
|
|
|
|
|
|
/*
|
|
* test_strprintf - test strprintf calls
|
|
*/
|
|
define test_strprintf()
|
|
{
|
|
local callcfg; /* caller configuration value */
|
|
local c; /* modified configuration */
|
|
|
|
print '4800: Beginning test_strprintf';
|
|
|
|
/* setup */
|
|
callcfg = config("all");
|
|
print '4801: callcfg = config("all")';
|
|
c = config("mode", "frac");
|
|
print '4802: c = config("mode", "frac")';
|
|
c = config("outround", 24);
|
|
print '4803: c = config("outround", 24)';
|
|
c = config("display", 2);
|
|
print '4804: c = config("display", 2)';
|
|
c = config("tilde", 0);
|
|
print '4805: c = config("tilde", 0)';
|
|
c = config("leadzero", 0);
|
|
print '4806: c = config("leadzero", 0)';
|
|
c = config("fullzero", 0);
|
|
print '4807: c = config("fullzero", 0)';
|
|
|
|
/* tests with tilde == 0 */
|
|
vrfy(strprintf("%d%d", 27, 29) == "2729",
|
|
'4808: strprintf("%d%d", 27, 29) == "2729"');
|
|
vrfy(strprintf("%5d%3d", 27, 29) == " 27 29",
|
|
'4809: strprintf("%5d%3d", 27, 29) == " 27 29"; ');
|
|
vrfy(strprintf("%-5d%-3d", 27, 29) == "27 29 ",
|
|
'4810: strprintf("%-5d%-3d", 27, 29) == "27 29 "');
|
|
vrfy(strprintf("%f", 1.375) == "1.38",
|
|
'4811: strprintf("%f", 1.375) == "1.38"');
|
|
vrfy(strprintf("%f", 1.385) == "1.38",
|
|
'4812: strprintf("%f", 1.385) == "1.38"');
|
|
vrfy(strprintf("%f", .375) == ".38",
|
|
'4813: strprintf("%f", .375) == ".38"');
|
|
vrfy(strprintf("%f", .385) == ".38",
|
|
'4814: strprintf("%f", .385) == ".38"');
|
|
|
|
/* tests with tilde == 1 */
|
|
c = config("tilde", 1);
|
|
print '4815: c = config("tilde", 1)';
|
|
vrfy(strprintf("%f", 1.375) == "~1.38",
|
|
'4816: strprintf("%f", 1.375) == "~1.38"');
|
|
vrfy(strprintf("%f", 27/29) == "~.93",
|
|
'4817: strprintf("%f", 27/29) == "~.93"');
|
|
vrfy(strprintf("%r", 27/29) == "27/29",
|
|
'4818: strprintf("%r", 27/29) == "27/29"');
|
|
vrfy(strprintf("%o", 27/29) == "033/035",
|
|
'4819: strprintf("%o", 27/29) == "033/035"');
|
|
vrfy(strprintf("%x", 27/29) == "0x1b/0x1d",
|
|
'4820: strprintf("%x", 27/29) == "0x1b/0x1d"');
|
|
vrfy(strprintf("%b", 27/29) == "0b11011/0b11101",
|
|
'4821: strprintf("%b", 27/29) == "0b11011/0b11101"');
|
|
vrfy(strprintf("%e", 12345) == "~1.23e4",
|
|
'4822: strprintf("%e", 12345) == "~1.23e4"');
|
|
|
|
/* mode tests with tilde == 0 */
|
|
c = config("tilde", 0);
|
|
print '4823: c = config("tilde", 0)';
|
|
vrfy(strprintf("%e", 12345) == "1.23e4",
|
|
'4824: strprintf("%e", 12345) == "1.23e4"');
|
|
vrfy(strprintf("%.3e", 12345) == "1.234e4",
|
|
'4825: strprintf("%.3e", 12345) == "1.234e4"');
|
|
vrfy(strprintf("%e", .00012345) == "1.23e-4",
|
|
'4826: strprintf("%e", .00012345) == "1.23e-4"');
|
|
vrfy(strprintf("%d %d", 27) == "27 ",
|
|
'4827: strprintf("%d %d", 27) == "27 "');
|
|
vrfy(strprintf("%d", 27, 29) == "27",
|
|
'4828: strprintf("%d", 27, 29) == "27"');
|
|
vrfy(strprintf("%r = %f", 27/29, 27/29) == "27/29 = .93",
|
|
'4829: strprintf("%r = %f", 27/29, 27/29) == "27/29 = .93"');
|
|
vrfy(strprintf("%s", "abc") == "abc",
|
|
'4830: strprintf("%s", "abc") == "abc"');
|
|
vrfy(strprintf("%f", "abc") == "abc",
|
|
'4831: strprintf("%f", "abc") == "abc"');
|
|
vrfy(strprintf("%e", "abc") == "abc",
|
|
'4832: strprintf("%e", "abc") == "abc"');
|
|
vrfy(strprintf("%5s", "abc") == " abc",
|
|
'4833: strprintf("%5s", "abc") == " abc"');
|
|
vrfy(strprintf("%-5s", "abc") == "abc ",
|
|
'4834: strprintf("%-5s", "abc") == "abc "');
|
|
|
|
/* restore config */
|
|
c = config("all", callcfg);
|
|
print '4835: c = config("all", callcfg)';
|
|
|
|
print '4836: Ending test_strprintf';
|
|
}
|
|
print '088: parsed test_fileop()';
|
|
|
|
|
|
/*
|
|
* place holder for any print items
|
|
*/
|
|
print '100: reserved for future use';
|
|
|
|
|
|
/*
|
|
* Report the number of errors found.
|
|
*/
|
|
define count_errors()
|
|
{
|
|
if (err == 0) {
|
|
print "9998: passed all tests /\\../\\";
|
|
} else {
|
|
print "****", err, "error(s) found \\/++\\/";
|
|
}
|
|
}
|
|
print '198: parsed count_errors()';
|
|
|
|
|
|
print '199: Ending main part of regression test suite read';
|
|
|
|
|
|
print;
|
|
return test_booleans();
|
|
print;
|
|
return test_variables();
|
|
print;
|
|
return test_arithmetic();
|
|
print;
|
|
return test_config();
|
|
print;
|
|
return test_bignums();
|
|
print;
|
|
return test_functions();
|
|
print;
|
|
return _test_underscore();
|
|
print;
|
|
return test_assoc();
|
|
print;
|
|
return test_list();
|
|
print;
|
|
return test_rand();
|
|
print;
|
|
return test_mode();
|
|
print;
|
|
print '1700: Beginning read test';
|
|
value = 0;
|
|
vrfy(value == 0, '1701: value == 0');
|
|
read "test1700";
|
|
vrfy(value == 1, '1702: value == 1');
|
|
read -once "test1700";
|
|
vrfy(value == 1, '1703: value == 1');
|
|
read "test1700.cal";
|
|
vrfy(value == 2, '1704: value == 2');
|
|
read -once "test1700.cal";
|
|
vrfy(value == 2, '1705: value == 2');
|
|
read "test1700.cal";
|
|
vrfy(value == 3, '1706: value == 3');
|
|
print '1707: Ending read test';
|
|
print;
|
|
return test_obj();
|
|
print;
|
|
return test_prime();
|
|
print;
|
|
return test_lucas();
|
|
print;
|
|
return test_newop();
|
|
print;
|
|
return test_xx_incdec();
|
|
print;
|
|
return test_round();
|
|
print;
|
|
return test_2600();
|
|
print;
|
|
return test_2700();
|
|
print;
|
|
return test_matrix();
|
|
print;
|
|
return test_strings();
|
|
print;
|
|
return test_matobj();
|
|
print;
|
|
return test_poly();
|
|
print;
|
|
return test_det();
|
|
print;
|
|
return test_trig();
|
|
print;
|
|
return test_frem();
|
|
print;
|
|
return test_error();
|
|
print;
|
|
return test_param();
|
|
print;
|
|
return test_noarg();
|
|
print;
|
|
return test_ptest();
|
|
print;
|
|
return test_redc();
|
|
print;
|
|
return test_fileops();
|
|
print;
|
|
return test_matdcl();
|
|
print;
|
|
return test_objmat();
|
|
print;
|
|
return test_fileop();
|
|
print;
|
|
return test_charset();
|
|
print;
|
|
return test_strprintf();
|
|
print;
|
|
return count_errors();
|
|
print '9999: Ending regression tests';
|