adrian
/
eigenmath
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
eigenmath/selftest.cpp

1401 lines
21 KiB
C++
Raw Permalink Blame History

#include "stdafx.h"
#include "defs.h"
extern void test_abs(void);
extern void test_arccos(void);
extern void test_arccosh(void);
extern void test_arcsin(void);
extern void test_arcsinh(void);
extern void test_arctan(void);
extern void test_arctanh(void);
extern void test_besselj(void);
extern void test_bessely(void);
extern void test_carac(void);
extern void test_ceiling(void);
extern void test_charpoly(void);
extern void test_coeff(void);
extern void test_condense(void);
extern void test_contract(void);
extern void test_convolution(void);
extern void test_cos(void);
extern void test_cosh(void);
extern void test_denominator(void);
extern void test_derivative(void);
extern void test_dirac(void);
extern void test_display(void);
extern void test_divisors(void);
extern void test_eigen(void);
extern void test_erf(void);
extern void test_erfc(void);
extern void test_expcos(void);
extern void test_expsin(void);
extern void test_factor_number(void);
extern void test_factorpoly(void);
extern void test_for(void);
extern void test_floor(void);
extern void test_fourier(void);
extern void test_gamma(void);
extern void test_heaviside(void);
extern void test_index(void);
extern void test_inner(void);
extern void test_integral(void);
extern void test_isprime(void);
extern void test_lcm(void);
extern void test_log(void);
extern void test_madd(void);
extern void test_mdiv(void);
extern void test_mgcd(void);
extern void test_mmod(void);
extern void test_mmul(void);
extern void test_mod(void);
extern void test_mpow(void);
extern void test_mprime(void);
extern void test_mroot(void);
extern void test_msub(void);
extern void test_multiply(void);
extern void test_numerator(void);
extern void test_outer(void);
extern void test_power(void);
extern void test_product(void);
extern void test_prog(void);
extern void test_rationalize(void);
extern void test_roots(void);
extern void test_scan(void);
extern void test_simplify(void);
extern void test_sgn(void);
extern void test_sin(void);
extern void test_sinh(void);
extern void test_sum(void);
extern void test_tan(void);
extern void test_tanh(void);
extern void test_taylor(void);
extern void test_tchebychevT(void);
extern void test_tchebychevU(void);
extern void test_tensor(void);
extern void test_test(void);
extern void test_trace(void);
extern void test_transpose(void);
extern void test_user_func(void);
extern void test_wedge(void);
extern void test_zero(void);
char logbuf[1000];
static FILE *logfile;
static jmp_buf jbuf;
void
selftest(void)
{
#if 0 // don't use log file
#ifdef MAC
static char buf[144];
strcpy(buf, getenv("HOME"));
strcat(buf, "/Desktop/Eigenmath.out");
logfile = fopen(buf, "w");
#else
logfile = fopen("selftest.txt", "w");
#endif
#endif
if (setjmp(jbuf))
return;
// test bignum arithmetic
test_madd();
test_msub();
test_mmul();
test_mdiv();
test_mmod();
test_mprime();
test_quickfactor();
test_mgcd();
test_mpow();
test_mroot();
test_multiply();
test_scan();
test_power();
test_factor_number();
test_test();
test_all();
test_user_func();
test_tensor();
test_abs();
test_besselj();
test_bessely();
test_carac();
test_ceiling();
test_charpoly();
test_condense();
test_contract();
test_convolution();
test_denominator();
test_derivative();
test_dirac();
test_erf();
test_erfc();
test_expcos();
test_expsin();
test_gcd();
test_factorpoly();
test_floor();
test_for();
test_fourier();
test_gamma();
test_inner();
test_lcm();
test_log();
test_mod();
test_numerator();
test_outer();
test_product();
test_prog();
test_rationalize();
test_sgn();
test_sum();
test_taylor();
test_tchebychevT();
test_tchebychevU();
test_trace();
test_transpose();
test_zero();
test_hermite();
test_laguerre();
test_legendre();
test_binomial();
test_divisors();
test_coeff();
test_sin();
test_cos();
test_tan();
test_sinh();
test_cosh();
test_tanh();
test_arcsin();
test_arcsinh();
test_arccos();
test_arccosh();
test_arctan();
test_arctanh();
test_wedge();
test_index();
test_isprime();
test_integral();
test_simplify();
test_roots();
test_eigen();
logout("OK, all tests passed.\n");
if (logfile)
fclose(logfile);
}
void
logout(char *s)
{
printstr(s);
// if (logfile)
// fprintf(logfile, "%s", s);
}
void
errout(void)
{
logout("\n");
// if (logfile)
// fclose(logfile);
longjmp(jbuf, 1);
}
int test_flag;
extern int out_count;
extern void run(char *);
char *script[] = {
"2/3",
"2/3",
"2.0/3",
"0.666667",
"2/3.0",
"0.666667",
"2.0/3.0",
"0.666667",
"-2.0/3.0",
"-0.666667",
// symbols
"a=quote(a)",
"a",
"b=quote(b)",
"b",
"c=quote(c)",
"c",
"d=quote(d)",
"d",
// scanner
"a 5", // 2nd factor is T_INTEGER
"5*a",
"a 5.0", // 2nd factor is T_DOUBLE
"5*a",
// "a \"hello\"", // 2nd factor is T_STRING
// "\"hello\"*a",
// print format
"2*1/a",
"2/a",
"-1/a",
"-1/a",
"a/b",
"a/b",
//
"2^(1/2)",
"2^(1/2)",
"r*exp(i*phi)", // sort order (see ~e in misc.c)
"r*exp(i*phi)",
// string arguments are printed with quotes
// "quote(print(a,\" \",b))",
// "print(a,\" \",b)",
// "float(2/3)",
// "0.666667",
/* from yacas to do list */
"2380105039001857 * 1260448573",
"3000000000000000000000061",
// floating point
"A=float(1000!)",
"",
#if 0
#ifdef MAC
"A",
"Inf",
"A-A",
"NaN",
"A/A",
"NaN",
#else
"A",
"inf",
"A-A",
"nan",
"A/A",
"nan",
#endif
#endif
"A=quote(A)",
"",
// divide by zero
"1/0",
"Stop: divide by zero",
"1.0/0.0",
"Stop: divide by zero",
/* sum */
"0+0",
"0",
"0+a",
"a",
"a+0",
"a",
"0+(a+b)",
"a+b",
"(a+b)+0",
"a+b",
"1+2",
"3",
"a+0",
"a",
"0+a",
"a",
"a+a",
"2*a",
"a+2*a",
"3*a",
"2*a+a",
"3*a",
"2*a+3*a",
"5*a",
"a*b+a*b",
"2*a*b",
"a*b+2*a*b",
"3*a*b",
"2*a*b+a*b",
"3*a*b",
"2*a*b+3*a*b",
"5*a*b",
"1/2*a+1/2*a",
"a",
"1/2*a*b+1/2*a*b",
"a*b",
"a+a+a",
"3*a",
"a+b+b",
"a+2*b",
"2*a+2*a",
"4*a",
"1/4*a-1/4*a",
"0",
"(a+b+c+d)-(a+b+c+d)",
"0",
/* power */
"0^0", // see ross' book, p. 129
"1",
"a^0",
"1",
"a^1",
"a",
"1^a",
"1",
"a^a",
"a^a",
"2^(1/2)",
"2^(1/2)",
// "a^(b+c)",
// "a^b*a^c",
// "a^(b+c+d)",
// "a^b*a^c*a^d",
"(a*b)^c",
"a^c*b^c",
"(a*b*c)^d",
"a^d*b^d*c^d",
"2^3",
"8",
"a^(2*a)",
"a^(2*a)",
"a^(2*a*b)",
"a^(2*a*b)",
"(a^2)^3",
"a^6",
"a^2^3",
"a^8",
/*
"12^(1/2)",
"2*3^(1/2)",
"12^(-1/2)",
"1/2*(1/3)^(1/2)",
"8^(2/3)",
"4",
"8^(-2/3)",
"1/4",
"2^(3/2)",
"2*2^(1/2)",
"(3/2)^(-1/2)",
"(2/3)^(1/2)",
"(3/4)^(1/2)",
"1/2*3^(1/2)",
"(9/4)^(1/2)",
"3/2",
"(9/4)^(3/2)",
"27/8",
"3*3^(-1/2)",
"3^(1/2)",
*/
"(a^b)^c",
"a^(b*c)",
"((a+b)^(-2))^(-1)",
// "a^2+b^2+2*a*b",
"2*a*b+a^2+b^2",
#if 0
"(-27)^(1/3)",
"-3",
#endif
// make sure scanner doesn't produce imaginary
"quote((-a/b)^(1/2))",
"(-a/b)^(1/2)",
#if 0
/* roots of large numbers */
"x=10^20",
"x",
"x^(1/2)",
"10000000000",
"x^(-1/2)",
"1/10000000000",
#endif
//-----------------------------------------------------------------------------
//
// arctan
//
//-----------------------------------------------------------------------------
#if 0
/* arctan2 */
"arctan2(0,0)",
"0",
"arctan2(0,1)",
"0",
"arctan2(0,-1)",
"pi",
"arctan2(1,0)",
"1/2*pi",
"arctan2(-1,0)",
"-1/2*pi",
/* sin */
"sin(-pi)", // -180 degrees
"0",
"sin(-pi*5/6)", // -150 degrees
"-1/2",
"sin(-3*pi/4)", // -135 degrees
"-1/2*2^(1/2)",
"sin(-2*pi/3)", // -120 degrees
"-1/2*3^(1/2)",
"sin(-pi/2)", // -90 degrees
"-1",
"sin(-pi/3)", // -60 degrees
"-1/2*3^(1/2)",
"sin(-pi/4)", // -45 degrees
"-1/2*2^(1/2)",
"sin(-pi/6)", // -30 degrees
"-1/2",
"sin(0)", // 0 degrees
"0",
"sin(pi/6)", // 30 degrees
"1/2",
"sin(pi/4)", // 45 degrees
"1/2*2^(1/2)",
"sin(pi/3)", // 60 degrees
"1/2*3^(1/2)",
"sin(pi/2)", // 90 degrees
"1",
"sin(2*pi/3)", // 120 degrees
"1/2*3^(1/2)",
"sin(3*pi/4)", // 135 degrees
"1/2*2^(1/2)",
"sin(pi*5/6)", // 150 degrees
"1/2",
"sin(pi)", // 180 degrees
"0",
"sin(pi*7/6)", // 210 degrees
"-1/2",
/* cos */
"cos(-pi)", // -180 degrees
"-1",
"cos(-pi*5/6)", // -150 degrees
"-1/2*3^(1/2)",
"cos(-pi*3/4)", // -135 degrees
"-1/2*2^(1/2)",
"cos(-pi*2/3)", // -120 degrees
"-1/2",
"cos(-pi/2)", // -90 degrees
"0",
"cos(-pi/3)", // -60 degrees
"1/2",
"cos(-pi/4)", // -45 degrees
"1/2*2^(1/2)",
"cos(-pi/6)", // -30 degrees
"1/2*3^(1/2)",
"cos(0)", // 0 degrees
"1",
"cos(pi/6)", // 30 degrees
"1/2*3^(1/2)",
"cos(pi/4)", // 45 degrees
"1/2*2^(1/2)",
"cos(pi/3)", // 60 degrees
"1/2",
"cos(pi/2)", // 90 degrees
"0",
"cos(pi*2/3)", // 120 degrees
"-1/2",
"cos(pi*3/4)", // 135 degrees
"-1/2*2^(1/2)",
"cos(pi*5/6)", // 150 degrees
"-1/2*3^(1/2)",
"cos(pi)", // 180 degrees
"-1",
#endif
//-----------------------------------------------------------------------------
//
// functions of symbols
//
//-----------------------------------------------------------------------------
"log(a)",
"log(a)",
"exp(a)",
"exp(a)",
"cos(a)",
"cos(a)",
"sin(a)",
"sin(a)",
"tan(a)",
"tan(a)",
"arccos(a)",
"arccos(a)",
"arcsin(a)",
"arcsin(a)",
"arctan(a)",
"arctan(a)",
//-----------------------------------------------------------------------------
//
// functions of floating point
//
//-----------------------------------------------------------------------------
"log(2.0)",
"0.693147",
"exp(2.0)",
"7.38906",
"cos(1.2)",
"0.362358",
"sin(1.2)",
"0.932039",
"tan(1.2)",
"2.57215",
"arccos(.12)",
"1.45051",
"arcsin(.12)",
"0.12029",
"arctan(.12)",
"0.119429",
"sqrt(-2.0)",
"1.41421*i",
/* powers of negative numbers */
#if 0
"(-1)^(2/3)",
"1",
"(-1)^(-2/3)",
"1",
"(-2)^(1/2)",
"i*2^(1/2)",
#endif
// complex numbers
"i",
"i",
"i^2",
"-1",
"1/i",
"-i",
"(1/i)^2",
"-1",
"(-1)^(1/2)",
"i",
"conj(x+i*y)",
"x-i*y",
"conj((-1)^(1/3))",
"-(-1)^(2/3)",
"conj((-1)^(2/3))",
"-(-1)^(1/3)",
"conj((-1)^(1/10))",
"-(-1)^(9/10)",
"conj((-1)^(4/3))",
"(-1)^(2/3)",
"conj((-1)^(7/3))",
"-(-1)^(2/3)",
"(3+2*i)*(1+4*i)",
"-5+14*i",
#if 0
"(-1)^(1/3)",
"1/2+1/2*i*3^(1/2)",
"a=i^(1/3)",
"a",
"a*a*a",
"i",
"a=(1/3*i)^(1/3)",
"a",
"a*a*a",
"1/3*i",
"a=(-1/3*i)^(1/3)",
"a",
"a*a*a",
"-1/3*i",
#endif
#if 0
"A=4*(a+b)",
"A",
"B=-3*(a+b)",
"B",
"C=2*(a+b)",
"C",
#endif
#if 0
"A+B+C",
"3*(a+b)",
"A+C+B",
"3*(a+b)",
"B+A+C",
"3*(a+b)",
"B+C+A",
"3*(a+b)",
"C+A+B",
"3*(a+b)",
"C+B+A",
"3*(a+b)",
#endif
"A=quote(A)",
"A",
"B=quote(B)",
"B",
//-----------------------------------------------------------------------------
//
// integral
//
//-----------------------------------------------------------------------------
"integral(a,x)",
"a*x",
"integral(a*b,x)",
"a*b*x",
"integral(x,x)",
"1/2*x^2",
"integral(a*x,x)",
"1/2*a*x^2",
"integral(a*b*x,x)",
"1/2*a*b*x^2",
"integral(a+b,x)",
"a*x+b*x",
"integral(1/x,x)",
"log(x)",
"integral(x^a,x)",
"x^(1+a)/(1+a)",
"integral(exp(x),x)",
"exp(x)",
"integral(exp(a*x),x)",
"exp(a*x)/a",
"integral(exp(a*x+b),x)",
"exp(b+a*x)/a",
"integral(x*exp(A*x^2+B),x)",
"exp(B+A*x^2)/(2*A)",
"integral(log(x),x)",
"-x+x*log(x)",
"integral(log(a*x+b),x)",
"-x+x*log(b+a*x)+b*log(b+a*x)/a",
"integral(sin(x),x)",
"-cos(x)",
"integral(cos(x),x)",
"sin(x)",
"integral(sin(x)*cos(x),x)", // 318
"1/2*sin(x)^2",
"integral(sin(a*x)*cos(a*x),x)", // 318
"sin(a*x)^2/(2*a)",
// integral w/o 2nd arg
"integral(1+x+x^2+x^3)",
"x+1/2*x^2+1/3*x^3+1/4*x^4",
//-----------------------------------------------------------------------------
//
// dsolve
//
//-----------------------------------------------------------------------------
// "dsolve(d(y(x),x)-2*x*y(x)-x,y(x),x)",
// "-1/2+C*exp(x^2)",
//-----------------------------------------------------------------------------
//
// sum of tensors
//
//-----------------------------------------------------------------------------
"((a,b),(c,d))+((1,2),(3,4))",
"((1+a,2+b),(3+c,4+d))",
// mixed rank
"(b1,b2,b3)+((a11,a12,a13),(a21,a22,a23),(a31,a32,a33))",
"(b1,b2,b3)+((a11,a12,a13),(a21,a22,a23),(a31,a32,a33))",
//----------------------------------------------------------------------------
//
// scalar times tensor
//
//-----------------------------------------------------------------------------
"c=((1,1),(1,1))",
"((1,1),(1,1))",
"a*b*c",
"((a*b,a*b),(a*b,a*b))",
"c*d*e",
"((d*e,d*e),(d*e,d*e))",
"a*b*c*d*e",
"((a*b*d*e,a*b*d*e),(a*b*d*e,a*b*d*e))",
"c=quote(c)",
"c",
// det
"det(a)",
"det(a)",
"det(((1,2),(3,4)))",
"-2",
"det(((2,3,-2,5),(6,-2,1,4),(5,10,3,-2),(-1,2,2,3)))",
"-1629",
"det(A)",
"det(A)",
"det(((A/(A-B),1),(B/(A-B),1)))",
"A/(A-B)-B/(A-B)", // add "simplify" to get 1
// make sure the sign of det is handled for row interchange
"det(((1,0,0),(0,0,1),(0,1,0)))",
"-1",
"det(((a11-x,a12),(a21,a22-x)))-(a11*a22-a11*x-a12*a21-a22*x+x^2)",
"0",
//-----------------------------------------------------------------------------
//
// adj
//
//-----------------------------------------------------------------------------
"adj(a)",
"adj(a)",
"adj(((1,2),(3,4)))",
"((4,-2),(-3,1))",
"adj(((2,3,-2,5),(6,-2,1,4),(5,10,3,-2),(-1,2,2,3)))",
"((-4,-177,-73,194),(-117,117,-99,-27),(310,-129,-44,-374),(-130,-51,71,-211))",
"adj(A)",
"adj(A)",
//-----------------------------------------------------------------------------
//
// inv
//
//-----------------------------------------------------------------------------
"inv(a)",
"inv(a)",
"invg(a)",
"invg(a)",
"inv(((1,2),(3,4)))",
"((-2,1),(3/2,-1/2))",
"inner(((1,2),(3,4)),inv(((1,2),(3,4))))",
"((1,0),(0,1))",
"inv(hilbert(3))",
"((9,-36,30),(-36,192,-180),(30,-180,180))",
"invg(hilbert(3))",
"((9,-36,30),(-36,192,-180),(30,-180,180))",
"inv(((a,a),(a,a)))",
"Stop: inverse of singular matrix",
// power of tensor
"A=((1,2),(3,4))",
"((1,2),(3,4))",
"inner(A,1/A)",
"((1,0),(0,1))",
"inner(A,A^(-1))",
"((1,0),(0,1))",
"inner(A,A)-A^2",
"((0,0),(0,0))",
"A=quote(A)",
"",
// rank
"rank(A)",
"0",
"rank(1)",
"0",
"rank((a,b))",
"1",
"rank(((a,b),(c,d)))",
"2",
// setup for vector identities
"cross(u,v) = ("
" u[2] v[3] - u[3] v[2],"
" u[3] v[1] - u[1] v[3],"
" u[1] v[2] - u[2] v[1])",
"",
"div(v) = contract(d(v,(x,y,z)),1,2)",
"",
"grad(v) = d(v,(x,y,z))",
"",
"curl(f) = ("
" d(f[3],y) - d(f[2],z),"
" d(f[1],z) - d(f[3],x),"
" d(f[2],x) - d(f[1],y))",
"",
"laplacian(f) = d(d(f,x),x) + d(d(f,y),y) + d(d(f,z),z)",
"",
//-----------------------------------------------------------------------------
//
// gradient
//
//-----------------------------------------------------------------------------
"d(f(x),x)",
"d(f(x),x)",
"d(f(x,y,z),(x,y,z))",
"(d(f(x,y,z),x),d(f(x,y,z),y),d(f(x,y,z),z))",
"d((f(x),g(x)),x)",
"(d(f(x),x),d(g(x),x))",
"grad(V())",
"(d(V(),x),d(V(),y),d(V(),z))",
//-----------------------------------------------------------------------------
//
// curl
//
//-----------------------------------------------------------------------------
"curl((X(),Y(),Z()),(x,y,z))",
"(-d(Y(),z)+d(Z(),y),d(X(),z)-d(Z(),x),-d(X(),y)+d(Y(),x))",
"curl((X(),Y(),Z()))",
"(-d(Y(),z)+d(Z(),y),d(X(),z)-d(Z(),x),-d(X(),y)+d(Y(),x))",
//-----------------------------------------------------------------------------
//
// vector identities from AMA205
//
//-----------------------------------------------------------------------------
"F=(FX(),FY(),FZ())",
"F",
"G=(GX(),GY(),GZ())",
"G",
"f=f()",
"f",
"g=g()",
"g",
"div(curl(F))",
"0",
"curl(grad(f))",
"(0,0,0)",
"div(grad(f))-laplacian(f)",
"0",
"curl(curl(F))-grad(div(F))+laplacian(F)",
"(0,0,0)",
"grad(f*g)-f*grad(g)-g*grad(f)",
"(0,0,0)",
"div(f*F)-f*div(F)-inner(grad(f),F)",
"0",
"curl(f*F)-f*curl(F)-cross(grad(f),F)",
"(0,0,0)",
"grad(inner(F,G))-inner(G,grad(F))-inner(F,grad(G))",
"(0,0,0)",
"grad(inner(F,G))-inner(grad(F),G)-inner(grad(G),F)-cross(G,curl(F))-cross(F,curl(G))",
"(0,0,0)",
"div(cross(F,G))-inner(G,curl(F))+inner(F,curl(G))",
"0",
"curl(cross(F,G))-F*div(G)+G*div(F)-inner(grad(F),G)+inner(grad(G),F)",
"(0,0,0)",
// hilbert
"det(hilbert(6))",
"1/186313420339200000",
// normalize angle
"(-1)^(8/3)",
"(-1)^(2/3)",
"(-1)^(7/3)",
"(-1)^(1/3)",
"(-1)^(5/3)",
"-(-1)^(2/3)",
"(-1)^(4/3)",
"-(-1)^(1/3)",
"(-1)^(2/3)",
"(-1)^(2/3)",
"(-1)^(1/3)",
"(-1)^(1/3)",
"(-1)^(-1/3)",
"-(-1)^(2/3)",
"(-1)^(-2/3)",
"-(-1)^(1/3)",
"(-1)^(-4/3)",
"(-1)^(2/3)",
"(-1)^(-5/3)",
"(-1)^(1/3)",
"(-1)^(-7/3)",
"-(-1)^(2/3)",
"(-1)^(-8/3)",
"-(-1)^(1/3)",
// power() can return a multiply, make sure multiply() handles it
// "-1/2*i*(-exp(-i*pi/6)+exp(i*pi/6))",
// "1/2*(-1)^(1/3)-1/2*(-1)^(2/3)",
// from the jargon file
"1000!",
"40238726007709377354370243392300398571937486421071"
"46325437999104299385123986290205920442084869694048"
"00479988610197196058631666872994808558901323829669"
"94459099742450408707375991882362772718873251977950"
"59509952761208749754624970436014182780946464962910"
"56393887437886487337119181045825783647849977012476"
"63288983595573543251318532395846307555740911426241"
"74743493475534286465766116677973966688202912073791"
"43853719588249808126867838374559731746136085379534"
"52422158659320192809087829730843139284440328123155"
"86110369768013573042161687476096758713483120254785"
"89320767169132448426236131412508780208000261683151"
"02734182797770478463586817016436502415369139828126"
"48102130927612448963599287051149649754199093422215"
"66832572080821333186116811553615836546984046708975"
"60290095053761647584772842188967964624494516076535"
"34081989013854424879849599533191017233555566021394"
"50399736280750137837615307127761926849034352625200"
"01588853514733161170210396817592151090778801939317"
"81141945452572238655414610628921879602238389714760"
"88506276862967146674697562911234082439208160153780"
"88989396451826324367161676217916890977991190375403"
"12746222899880051954444142820121873617459926429565"
"81746628302955570299024324153181617210465832036786"
"90611726015878352075151628422554026517048330422614"
"39742869330616908979684825901254583271682264580665"
"26769958652682272807075781391858178889652208164348"
"34482599326604336766017699961283186078838615027946"
"59551311565520360939881806121385586003014356945272"
"24206344631797460594682573103790084024432438465657"
"24501440282188525247093519062092902313649327349756"
"55139587205596542287497740114133469627154228458623"
"77387538230483865688976461927383814900140767310446"
"64025989949022222176590433990188601856652648506179"
"97023561938970178600408118897299183110211712298459"
"01641921068884387121855646124960798722908519296819"
"37238864261483965738229112312502418664935314397013"
"74285319266498753372189406942814341185201580141233"
"44828015051399694290153483077644569099073152433278"
"28826986460278986432113908350621709500259738986355"
"42771967428222487575867657523442202075736305694988"
"25087968928162753848863396909959826280956121450994"
"87170124451646126037902930912088908694202851064018"
"21543994571568059418727489980942547421735824010636"
"77404595741785160829230135358081840096996372524230"
"56085590370062427124341690900415369010593398383577"
"79394109700277534720000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000"
"00000000000000000000000000000000000000000000000000"
"000000000000000000",
// float
"float(2/3)",
"0.666667",
"float(hilbert(3))",
"((1,0.5,0.333333),(0.5,0.333333,0.25),(0.333333,0.25,0.2))",
"a=pi",
"a",
"float(a)",
"3.14159",
"a=exp(1)",
"a",
"float(a)",
"2.71828",
"a=quote(a)",
"a",
// test self-referencing arg
"f(x)=eval(x)+1",
"",
"f(x+1)",
"2+x",
// test indexed formal arg
"f(x)=do(x[1]=3,x)",
"",
"x=(a,b)",
"",
"f(x)",
"(3,b)",
"x",
"(a,b)",
"f=quote(f)",
"",
"x=quote(x)",
"",
// last
"a=2+3",
"",
"last",
"5",
"a=quote(a)",
"",
// equality of tensors
"testeq((1,2),(1,2))",
"true",
"testeq((1,2),(1,3))",
"false",
// the "check" function with tensor arg
"check((1,2)-(1,2))",
"",
// nil
"nil",
"nil",
};
void
test_all(void)
{
test(__FILE__, script, sizeof(script) / sizeof (char *));
}
extern char out_buf[];
extern int out_count;
void
test(char *file, char **s, int n)
{
int i;
char *t;
test_flag = 1;
for (i = 0; i < n; i++) {
logout(s[i]);
logout("\n");
if (s[i][0] == '#')
continue;
out_count = 0;
run(s[i]);
t = s[i];
while (*t && *t != '=')
t++;
if (*t == '=') {
i++;
continue;
}
out_buf[out_count] = 0;
t = out_buf;
// skip leading newlines
while (*t == '\n')
t++;
// remove trailing newlines
while (out_count && out_buf[out_count - 1] == '\n')
out_buf[--out_count] = 0;
i++;
if (strcmp(t, s[i]) == 0)
continue;
// make copy because logout clobbers out_buf
t = strdup(t);
logout("expected to get the following result:\n");
logout(s[i]);
logout("\n");
logout("got this result instead:\n");
logout(t);
logout("\n");
logout(file);
logout("\n");
free(t);
errout();
}
test_flag = 0;
}
Reference in New Issue View Git Blame Copy Permalink