regress.cal

早期freebsd实现

	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 '015: 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 '016: 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;
	verify(ptest(a, 20), '612: primetest R19');
	a = (10^23-1) / 9;
	verify(ptest(a, 20), '613: primetest R23');
	a = 2^127 - 1;
	verify(ptest(a, 1), '614: primetest M127');
	a = 2^521 - 1;
	verify(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');
/* The following are pending consideration of the 'nearest' arg to sqrt()
	a = 2e150;
	b = 0x3206aa0707c6c1d483b62c784c9371eb507e3ab9b2d511c4bd648e52a5277fe;
	verify(sqrt(a,1) == b, '632: sqrt(a,1) == b');
	verify(sqrt(4e1000,1) == 2e500, '633: sqrt(4e1000,1) == 2e500');
 */
	print '634: Ending test_bignums';
}
print '017: parsed test_bignums()';


/*
 * Test many of the built-in functions.
 */
define test_functions()
{
	print '700: Beginning test_functions';
	verify(abs(3) == 3,    '701: abs(3) == 3');
	verify(abs(-4) == 4,   '702: abs(-4) == 4');
	verify(avg(7) == 7,    '703: avg(7) == 7');
	verify(avg(3,5) == 4,  '704: avg(3,5) == 4');
	verify(cmp(2,3) == -1, '705: cmp(2,3) == -1');
	verify(cmp(6,6) == 0,  '706: cmp(6,6) == 0');
	verify(cmp(7,4) == 1,  '707: cmp(7,4) == 1');
	verify(comb(9,9) == 1, '708: comb(9,9) == 1');
	verify(comb(5,2) == 10,'709: comb(5,2) == 10');
	verify(conj(4) == 4,   '710: conj(4) == 4');
	verify(conj(2-3i) == 2+3i, '711: conj(2-3i) == 2+3i');
	verify(den(17) == 1,   '712: den(17) == 1');
	verify(den(3/7) == 7,  '713: den(3/7) == 7');
	verify(den(-2/3) == 3, '714: den(-2/3) == 3');
	verify(digits(0) == 1, '715: digits(0) == 1');
	verify(digits(9) == 1, '716: digits(9) == 1');
	verify(digits(10) == 2,'717: digits(10) == 2');
	verify(digits(-691) == 3, '718: digits(-691) == 3');
	verify(eval('2+3') == 5, "719: eval('2+3') == 5");
	verify(fcnt(11,3) == 0,'720: fcnt(11,3) == 0');
	verify(fcnt(18,3) == 2,'721: fcnt(18,3) == 2');
	verify(fib(0) == 0,    '722: fib(0) == 0');
	verify(fib(1) == 1,    '723: fib(1) == 1');
	verify(fib(9) == 34,   '724: fib(9) == 34');
	verify(frem(12,5) == 12, '725: frem(12,5) == 12');
	verify(frem(45,3) == 5, '726: frem(45,3) == 5');
	verify(fact(0) == 1,   '727: fact(0) == 1');
	verify(fact(1) == 1,   '728: fact(1) == 1');
	verify(fact(5) == 120, '729: fact(5) == 120');
	verify(frac(3) == 0,   '730: frac(3) == 0');
	verify(frac(2/3) == 2/3, '731: frac(2/3) == 2/3');
	verify(frac(17/3) == 2/3, '732: frac(17/3) == 2/3');
	verify(gcd(0,3) == 3,  '733: gcd(0,3) == 3');
	verify(gcd(1,12) == 1, '734: gcd(1,12) == 1');
	verify(gcd(11,7) == 1, '735: gcd(11,7) == 1');
	verify(gcd(20,65) == 5, '736: gcd(20,65) == 5');
	verify(gcdrem(20,3) == 20, '737: gcdrem(20,3) == 20');
	verify(gcdrem(100,6) == 25, '738: gcdrem(100,6) == 25');
	verify(highbit(1) == 0, '739: highbit(1) == 0');
	verify(highbit(15) == 3, '740: highbit(15) == 3');
	verify(hypot(3,4) == 5, '741: hypot(3,4) == 5');
	verify(ilog(90,3) == 4, '742: ilog(90,3) == 4');
	verify(ilog10(123) == 2, '743: ilog10(123) == 2');
	verify(ilog2(17) == 4, '744: ilog2(17) == 4');
	verify(im(3) == 0,     '745: im(3) == 0');
	verify(im(2+3i) == 3,  '746: im(2+3i) == 3');
	verify(int(5) == 5,    '757: int(5) == 5');
	verify(int(19/3) == 6, '758: int(19/3) == 6');
	verify(inverse(3/2) == 2/3, '759: inverse(3/2) == 2/3');
	verify(iroot(18,2) == 4, '760: iroot(18,2) == 4');
	verify(iroot(100,3) == 4, '761: iroot(100,3) == 4');
	verify(iseven(10) == 1, '762: iseven(10) == 1');
	verify(iseven(13) == 0, '763: iseven(13) == 0');
	verify(iseven('a') == 0, "764: iseven('a') == 0");
	verify(isint(7) == 1,  '765: isint(7) == 1');
	verify(isint(19/2) == 0, '766: isint(19/2) == 0');
	verify(isint('a') == 0, "767: isint('a') == 0");
	verify(islist(3) == 0, '768: islist(3) == 0');
	verify(islist(list(2,3)) == 1, '769: islist(list(2,3)) == 1');
	verify(ismat(3) == 0, '770: ismat(3) == 0');
	verify(ismult(7,3) == 0, '771: ismult(7,3) == 0');
	verify(ismult(15,5) == 1, '772: ismult(15,5) == 1');
	verify(isnull(3) == 0, '773: isnull(3) == 0');
	verify(isnull(null()) == 1, '774: isnull(null()) == 1');
	verify(isnum(2/3) == 1, '775: isnum(2/3) == 1');
	verify(isnum('xx') == 0, "776: isnum('xx') == 0");
	verify(isobj(3) == 0, '777: isobj(3) == 0');
	verify(isodd(7) == 1, '778: isodd(7) == 1');
	verify(isodd(8) == 0, '779: isodd(8) == 0');
	verify(isodd('x') == 0, "780: isodd('a') == 0");
	verify(isqrt(27) == 5, '781: isqrt(27) == 5');
	verify(isreal(3) == 1, '782: isreal(3) == 1');
	verify(isreal('x') == 0, "783: isreal('x') == 0");
	verify(isreal(2+3i) == 0, '784: isreal(2+3i) == 0');
	verify(isstr(5) == 0,  '785: isstr(5) == 0');
	verify(isstr('foo') == 1, "786: isstr('foo') == 1");
	verify(isrel(10,14) == 0, '787: isrel(10,14) == 0');
	verify(isrel(15,22) == 1, '788: isrel(15,22) == 1');
	verify(issimple(6) == 1, '789: issimple(6) == 1');
	verify(issimple(3-2i) == 1, '790: issimple(3-2i) == 1');
	verify(issimple(list(5)) == 0, '791: issimple(list(5)) == 0');
	verify(issq(26) == 0, '792: issq(26) == 0');
	verify(issq(9/4) == 1, '793: issq(9/4) == 1');
	verify(istype(9,4) == 1, '795: istype(9,4) == 1');
	verify(istype(3,'xx') == 0, "796: istype(3,'xx') == 0");
	verify(jacobi(5,11) == 1, '797: jacobi(2,7) == 1');
	verify(jacobi(6,13) == -1, '798: jacobi(6,13) == 0');
	verify(lcm(3,4,5,6) == 60, '799: lcm(3,4,5,6) == 60');
	verify(lcmfact(8) == 840, '800: lcmfact(8) == 840');
	verify(lfactor(21,5) == 3, '801: lfactor(21,5) == 3');
	verify(lfactor(97,20) == 1, '802: lfactor(97,20) == 1');
	verify(lowbit(12) == 2, '803: lowbit(12) == 2');
	verify(lowbit(17) == 0, '804: lowbit(17) == 0');
	verify(ltol(1) == 0, '805: ltol(1) == 0');
	verify(max(3,-9,7,4) == 7, '806: max(3,-9,7,4) == 7');
	verify(meq(13,33,10) == 1, '807: meq(13,33,10) == 1');
	verify(meq(7,19,11) == 0, '808: meq(7,19,11) == 0');
	verify(min(9,5,12) == 5, '809: min(9,5,12) == 5');
	verify(minv(13,97) == 15, '810: minv(13,97) == 15');
	verify(mne(16,37,10) == 1, '811: mne(16,37,10) == 1');
	verify(mne(46,79,11) == 0, '812: mne(46,79,11) == 0');
	verify(norm(4) == 16,   '813: norm(4) == 16');
	verify(norm(2-3i) == 13, '814: norm(2-3i) == 13');
	verify(num(7) == 7,     '815: num(7) == 7');
	verify(num(11/4) == 11, '816: num(11/4) == 11');
	verify(num(-9/5) == -9, '817: num(-9/5) == -9');
	verify(char(ord('a')+2) == 'c', "818: char(ord('a')+2) == 'c'");
	verify(perm(7,3) == 210, '819: perm(7,3) == 210');
	verify(pfact(10) == 210, '820: pfact(10) == 210');
	verify(places(3/7) == -1, '821: places(3/7) == -1');
	verify(places(.347) == 3, '822: places(.347) == 3');
	verify(places(17) == 0, '823: places(17) == 0');
	verify(pmod(3,36,37) == 1, '824: pmod(3,36,37) == 1');
	verify(poly(2,3,5,2) == 19, '825; poly(2,3,5,2) == 19');
	verify(ptest(101,10) == 1, '826: ptest(101,10) == 1');
	verify(ptest(221,30) == 0, '827: ptest(221,30) == 0');
	verify(re(9) == 9,       '828: re(9) == 9');
	verify(re(-7+3i) == -7,  '829: re(-7+3i) == -7');
	verify(scale(3,4) == 48, '830: scale(3,4) == 48');
	verify(sgn(-4) == -1,    '831: sgn(-4) == -1');
	verify(sgn(0) == 0,      '832: sgn(0) == 0');
	verify(sgn(3) == 1,      '833: sgn(3) == 1');
	verify(size(7) == 1,     '834: size(7) == 1');
	verify(sqrt(121) == 11,  '835: sqrt(121) == 11');
	verify(ssq(2,3,4) == 29, '836: ssq(2,3,4) == 29');
	verify(str(45) == '45',  "837; str(45) == '45'");
	verify(strcat('a','bc','def')=='abcdef',"838; strcat('a','bc','def')=='abcdef'");
	verify(strlen('') == 0,  "839: strlen('') == 0");
	verify(strlen('abcd') == 4, "840: strlen('abcd') == 4");
	verify(substr('abcd',2,1) == 'b', "841: substr('abcd',2,1) == 'b'");
	verify(substr('abcd',3,4) == 'cd', "842: substr('abcd',3,4) == 'cd'");
	verify(substr('abcd',1,3) == 'abc', "843: substr('abcd',1,3) == 'abc'");
	verify(xor(17,17) == 0,  '844: xor(17,17) == 0');
	verify(xor(12,5) == 9,   '845: xor(12,5) == 9');
	verify(mmin(3,7) == 3, '846: mmin(3,7) == 3');
	verify(mmin(4,7) == -3, '847: mmin(4,7) == -3');
	verify(digit(123,2) == 1, '848: digit(123,2) == 1');
	verify(ismult(3/4, 1/7) == 0, '849: ismult(3/4, 1/7) == 0');
	verify(gcd(3/4, 1/7) == 1/28, '850: gcd(3/4,1/7) == 1/28');
	verify(gcd(2,3,1/2) == 1/2,	'851: gcd(2,3,1/2) == 1/2');
	verify(gcd(17,7,1/7) == 1/7,	'852: gcd(17,7,1/7) == 1/7');
	verify(gcd(2) == 2,		'853: gcd(2) == 2');
	verify(gcd(-2) == 2,		'854: gcd(-2) == 2');
	verify(floor(1.5) == 1,		'855: floor(1.5) == 1');
	verify(floor(.5) == 0,		'856: floor(.5) == 0');
	verify(floor(-.5) == -1,	'857: floor(-.5) == -1');
	verify(floor(-1.5) == -2,	'858: floor(-1.5) == -2');
	verify(ceil(1.5) == 2,		'859: floor(1.5) == 2');
	verify(ceil(.5) == 1,		'860: floor(.5) == 1');
	verify(ceil(-.5) == 0,		'861: floor(-.5) == 0');
	verify(ceil(-1.5) == -1,	'862: floor(-1.5) == -1');
	verify(frac(-7.2) == -.2,	'863: frac(-7.2) == -.2');
	verify(gcd(4, 5, 1/3) == 1/3,	'864: gcd(4, 5, 1/3) == 1/3');
	verify(ltol(7/25) == 24/25,	'865: ltol(7/25) == 24/25');
	verify(hmean(1,2,3) == 18/11,	'866: hmean(1,2,3) == 18/11');
	print '867: Ending test_functions';
}
print '018: parsed test_functions()';


/*
 * Test matrix operations
 */
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
	};

	print '900: Beginning test_matrix';

	b[0,0] = 0;
	verify(b[0,0] == 0,	'901: b[0,0] == 0');
	b[0,1] = 0;
	verify(b[0,1] == 0,	'902: b[0,1] == 0');
	b[0,2] = 0;
	verify(b[0,2] == 0,	'903: b[0,2] == 0');
	b[0,3] = 1;
	verify(b[0,3] == 1,	'904: b[0,3] == 1');
	b[1,0] = 1;
	verify(b[1,0] == 1,	'905: b[1,0] == 1');
	b[1,1] = 0;
	verify(b[1,1] == 0,	'906: b[1,1] == 0');
	b[1,2] = 0;
	verify(b[1,2] == 0,	'907: b[1,2] == 0');
	b[1,3] = 0;
	verify(b[1,3] == 0,	'908: b[1,3] == 0');
	b[2,0] = 1;
	verify(b[2,0] == 1,	'909: b[2,0] == 1');
	b[2,1] = 1;
	verify(b[2,1] == 1,	'910: b[2,1] == 1');
	b[2,2] = 1;
	verify(b[2,2] == 1,	'911: b[2,2] == 1');
	b[2,3] = 1;
	verify(b[2,3] == 1,	'912: b[2,3] == 1');
	b[3,0] = 1;
	verify(b[3,0] == 1,	'913: b[3,0] == 1');
	b[3,1] = 2;
	verify(b[3,1] == 2,	'914: b[3,1] == 2');
	b[3,2] = 4;
	verify(b[3,2] == 4,	'915: b[3,2] == 4');
	b[3,3] = 8;
	verify(b[3,3] == 8,	'916: b[3,3] == 8');
	verify(det(b) == -2,	'917: det(b) == -2');
	verify(binv[0,0] == 0,	'918: binv[0,0] == 0');
	verify(binv[0,1] == 1,	'919: binv[0,1] == 1');
	verify(binv[0,2] == 0,	'920: binv[0,2] == 0');
	verify(binv[0,3] == 0,	'921: binv[0,3] == 0');
	verify(binv[1,0] == 2,	'922: binv[1,0] == 2');
	verify(binv[1,1] == -3/2,	'923: binv[1,1] == -3/2');
	verify(binv[1,2] == 2,	'924: binv[1,2] == 2');
	verify(binv[1,3] == -1/2,	'925: binv[1,3] == -1/2');
	verify(binv[2,0] == -3,	'926: binv[2,0] == -3');
	verify(binv[2,1] == 1/2,	'927: binv[2,1] == 1/2');
	verify(binv[2,2] == -1,	'928: binv[2,2] == -1');
	verify(binv[2,3] == 1/2,	'929: binv[2,3] == 1/2');
	verify(binv[3,0] == 1,	'930: binv[3,0] == 1');
	verify(binv[3,1] == 0,	'931: binv[3,1] == 0');
	verify(binv[3,2] == 0,	'932: binv[3,2] == 0');
	verify(binv[3,3] == 0,	'933: binv[3,3] == 0');
	verify(inverse(b) == binv,	'934: inverse(b) == binv');

	print '999: Ending mat_functions';
}
print '019: parsed test_matrix()';


read -once "lucas_chk";		/* obtain our needed Lucas library */
print '020: read lucas_chk';

/*
 * Test the Lucas primality test library
 */
define test_lucas()
{
	print '1100: Beginning lucas check test';

	verify(lucas_chk(100,1) == 1,	'1101: lucas_chk(100,1) == 1');

	print '1102: Ending lucas check test';
}
print '021: parsed test_lucas()';


read -once "surd";		/* obtain our needed surd library */
print '022: read surd';

/*
 * Test objects
 */
define test_obj()
{
	static obj surd a;
	static obj surd b;

	print '1200: Beginning object test';

	surd_type = -1;
	verify(surd_type == -1,		'1201: surd_type == -1');
	a = surd(2,3);
	print				'1202: a = surd(2,3)';
	verify(a == surd(2,3),		'1203: a == surd(2,3)');
	verify(surd_value(a) == 2+3i,	'1204: surd_value(a) == 2+3i');
	verify(conj(a) == surd(2,-3),	'1205: conj(a) == surd(2,-3)');
	verify(norm(a) == 13,		'1206: norm(a) == 13');
	verify(a+1 == surd(3,3),	'1207: a+1 == surd(3,3)');
	b = surd(3,4);
	print				'1208: b = surd(3,4)';
	verify(a+b == surd(5,7),	'1209: a+b == surd(5,7)');
	verify(a-b == surd(-1,-1),	'1210: a-b == surd(-1,-1)');