void TestExprDiff::apply01() {
Variable x("x");
Function f(x,sqr(x),"f");
Function g(x,f(3*x));
Function dg(g,Function::DIFF);
TEST_ASSERT(sameExpr(f.diff().expr(),"(2*x)"));
TEST_ASSERT(sameExpr(dg.expr(),"(3*df((3*x)))"));
}
void TestExprDiff::one_var_one_func() {
Variable x("x");
Function f(x,sqr(x)+1);
Function df(f,Function::DIFF);
CPPUNIT_ASSERT(df.expr().dim.type()==Dim::SCALAR);
CPPUNIT_ASSERT(sameExpr(df.expr(),"(2*x)")
||sameExpr(df.expr(),"([2,2]*x)"));
}
void TestExprDiff::vec02() {
Variable x(4,"x");
Function f(x,x[0]*x[3]);
Function df(f,Function::DIFF);
const ExprVector* v=dynamic_cast<const ExprVector*>(&df.expr());
CPPUNIT_ASSERT(v);
CPPUNIT_ASSERT(v->dim.type()==Dim::ROW_VECTOR);
CPPUNIT_ASSERT(sameExpr(v->arg(0),x[3]));
CPPUNIT_ASSERT(sameExpr(v->arg(3),x[0]));
}
void TestExprDiff::poly01() {
Variable x("x"),y("y");
Function f(x,y,((sqr(x)+2*x*y)+pow(y,3))+1);
Function df(f,Function::DIFF);
const ExprVector* v=dynamic_cast<const ExprVector*>(&df.expr());
TEST_ASSERT(v);
TEST_ASSERT(v->dim.type()==Dim::ROW_VECTOR);
TEST_ASSERT(sameExpr(v->arg(0),"((2*x)+(2*y))")
|| sameExpr(v->arg(0),"((2*y)+(2*x))"));
TEST_ASSERT(sameExpr(v->arg(1),"((2*x)+(3*y^2))"));
}
void TestExprSplitOcc::test07() {
const ExprSymbol& x=ExprSymbol::new_("x",Dim(1,3,1));
// several occurrences of an index (but different nodes)
const ExprNode& e1=x[0];
const ExprNode& e2=x[1];
Function f1(x,(x[0]+(-x)[1])+x[1]+e1+e2);
ExprSplitOcc eso(f1.args(),f1.expr());
const Array<const ExprSymbol>& x2=eso.get_x();
const ExprNode& y2=eso.get_y();
TEST_ASSERT(x2.size()==4);
TEST_ASSERT(sameExpr(y2,"((((x[0]+(-x_0_)[1])+x[1])+x[0]_1_)+x[1]_1_)"));
TEST_ASSERT(&eso.node(x2[0])==&x); // the "special node" (which is inserted first)
TEST_ASSERT(&eso.node(x2[1])==&x);
TEST_ASSERT(&eso.node(x2[2])==&e1);
TEST_ASSERT(&eso.node(x2[3])==&e2);
int* var;
int n=eso.var_map(var);
TEST_ASSERT(n==8);
TEST_ASSERT(var[0]==0);
TEST_ASSERT(var[1]==1);
TEST_ASSERT(var[2]==2);
TEST_ASSERT(var[3]==0);
TEST_ASSERT(var[4]==1);
TEST_ASSERT(var[5]==2);
TEST_ASSERT(var[6]==0);
TEST_ASSERT(var[7]==1);
}
void TestExprDiff::apply02() {
Variable x("x");
Function f(x,sqr(x),"f");
Function g(x,3*f(x));
Function dg(g,Function::DIFF);
TEST_ASSERT(sameExpr(dg.expr(),"(df(x)*3)"));
}
void TestExprDiff::mul02() {
Variable x("x");
const ExprVector& v1=ExprVector::new_(x,x,false);
const ExprVector& v2=ExprVector::new_(x,Interval(2,2),false);
Function f(x,transpose(v1)*v2);
Function df(f,Function::DIFF);
//CPPUNIT_ASSERT(sameExpr(df.expr(),"((x+2)+x)"));
CPPUNIT_ASSERT(sameExpr(df.expr(),"((x+x)+2)"));
}
void TestFunction::apply01() {
Variable x("x");
Variable y("y");
Function f(x,y,x+y,"f");
Interval c(1,1);
Variable z("z");
Function f2(z,f(z,c));
TEST_ASSERT(sameExpr(f2.expr(),"f(z,1)"));
}
void TestFunction::from_string01() {
try {
Function f("x","sin(x)");
TEST_ASSERT(f.nb_arg()==1);
TEST_ASSERT(sameExpr(f.expr(),"sin(x)"));
}
catch(SyntaxError& e) {
TEST_ASSERT(false);
}
}
void TestFunction::from_string04() {
try {
Function f("a","b","c","d","e","f","g","h","a+e");
TEST_ASSERT(f.nb_arg()==8);
TEST_ASSERT(sameExpr(f.expr(),"(a+e)"));
} catch(SyntaxError& e) {
TEST_ASSERT(false);
}
}
void TestFunction::from_string02() {
try {
Function f("x","y","x+y");
TEST_ASSERT(f.nb_arg()==2);
TEST_ASSERT(sameExpr(f.expr(),"(x+y)"));
} catch(SyntaxError& e) {
TEST_ASSERT(false);
}
}
void TestExprDiff::apply02() {
Variable x("x");
Function f(x,sqr(x),"f");
Function g(x,3*f(x));
Function dg(g,Function::DIFF);
// CPPUNIT_ASSERT(sameExpr(dg.expr(),"(df(x)*3)")
// ||sameExpr(dg.expr(),"(df(x)*[3,3])")
// ||sameExpr(dg.expr(),"(3*df(x))")
// ||sameExpr(dg.expr(),"([3,3]*df(x))"));
CPPUNIT_ASSERT(sameExpr(dg.expr(),"(6*x)"));
}
void TestExprDiff::apply03() {
Variable x("x"),y("y");
Function f(x,y,x*y,"f");
Function g(x,y,f(2*x,3*y));
Function dg(g,Function::DIFF);
TEST_ASSERT(sameExpr(dg.expr(),"((2*df((2*x),(3*y))[0]),(3*df((2*x),(3*y))[1]))"));
double _box[][2]={{1,1},{2,2}};
double _dg_box[][2]={{12,12},{6,6}};
IntervalVector dg_box(dg.eval_vector(IntervalVector(2,_box)));
TEST_ASSERT(dg_box==IntervalVector(2,_dg_box));
}
void TestFunction::from_string03() {
try {
Function f("x[2]","y[1][3]","x(1)+y(2)");
TEST_ASSERT(f.nb_arg()==2);
TEST_ASSERT(f.arg(0).dim.dim2==2);
TEST_ASSERT(f.arg(1).dim.dim3==3);
TEST_ASSERT(sameExpr(f.expr(),"(x[0]+y[1])"));
} catch(SyntaxError& e) {
TEST_ASSERT(false);
}
}
void TestExprDiff::apply01() {
Variable x("x");
Function f(x,sqr(x),"f");
Function g(x,f(3*x));
Function dg(g,Function::DIFF);
// CPPUNIT_ASSERT(sameExpr(f.diff().expr(),"(2*x)")
// ||sameExpr(f.diff().expr(),"([2,2]*x)"));
// CPPUNIT_ASSERT(sameExpr(dg.expr(),"(3*df((3*x)))")
// ||sameExpr(dg.expr(),"([3,3]*df((3*x)))")
// ||sameExpr(dg.expr(),"(df((3*x))*[3,3])")
// ||sameExpr(dg.expr(),"(df((3*x))*3)"));
CPPUNIT_ASSERT(sameExpr(dg.expr(),"(18*x)"));
}
void TestFunction::generate_comp01() {
const ExprSymbol& x=ExprSymbol::new_("x");
const ExprSymbol& y=ExprSymbol::new_("y");
const ExprSymbol& z=ExprSymbol::new_("z");
const ExprNode& e1=x+y-z;
const ExprNode& e2=x*z;
const ExprNode& e3=y-z;
Array<const ExprNode> v(e1, e2, e3);
const ExprVector& e=ExprVector::new_(v, false);
Function f(x,y,z,e);
TEST_ASSERT(f[0].nb_arg()==3);
TEST_ASSERT(sameExpr(f[0].expr(),"((x+y)-z)"));
TEST_ASSERT(f[1].nb_arg()==3);
TEST_ASSERT(sameExpr(f[1].expr(),"(x*z)"));
TEST_ASSERT(f[2].nb_arg()==3);
TEST_ASSERT(sameExpr(f[2].expr(),"(y-z)"));
}
void TestExprDiff::apply_mul01() {
Variable x,y;
Function f(x,y,x,"f");
Variable x3,y3;
Function g(x3,y3,y3,"g");
Variable x2("x"),y2("y");
Function h(x2,y2,f(x2,y2)*g(x2,y2));
Function dh(h,Function::DIFF);
CPPUNIT_ASSERT(sameExpr(dh.expr(),"(y,x)"));
// CPPUNIT_ASSERT(sameExpr(dh.expr(),"(((df(x,y)[0]*g(x,y))+(dg(x,y)[0]*f(x,y))),((df(x,y)[1]*g(x,y))+(dg(x,y)[1]*f(x,y))))"));
}
void TestExprSplitOcc::test03() {
const ExprSymbol& x=ExprSymbol::new_("x",Dim(1,2,1));
const ExprNode& e1=x[0];
Function f1(x,(-x)[1]+e1);
ExprSplitOcc eso(f1.args(),f1.expr());
const Array<const ExprSymbol>& x2=eso.get_x();
const ExprNode& y2=eso.get_y();
TEST_ASSERT(x2.size()==2);
TEST_ASSERT(x2[0].dim==((const ExprNode&) x).dim);
TEST_ASSERT(x2[1].dim==((const ExprNode&) x).dim);
TEST_ASSERT(sameExpr(y2,"((-x_0_)[1]+x[0])"));
TEST_ASSERT(&eso.node(x2[0])==&x);
TEST_ASSERT(&eso.node(x2[1])==&x);
int* var;
int n=eso.var_map(var);
TEST_ASSERT(n==4);
TEST_ASSERT(var[0]==0);
TEST_ASSERT(var[1]==1);
TEST_ASSERT(var[2]==0);
TEST_ASSERT(var[3]==1);
}
void TestExprSplitOcc::test04() {
const ExprSymbol& x=ExprSymbol::new_("x",Dim(1,2,1));
// same index node with several fathers
const ExprNode& e1=x[0];
Function f1(x,e1-e1);
ExprSplitOcc eso(f1.args(),f1.expr());
const Array<const ExprSymbol>& x2=eso.get_x();
const ExprNode& y2=eso.get_y();
TEST_ASSERT(x2.size()==2);
TEST_ASSERT(x2[0].dim==((const ExprNode&) x).dim);
TEST_ASSERT(x2[1].dim.is_scalar());
TEST_ASSERT(sameExpr(y2,"(x[0]-x[0]_1_)"));
TEST_ASSERT(&eso.node(x2[0])==&x);
TEST_ASSERT(&eso.node(x2[1])==&e1);
int* var;
int n=eso.var_map(var);
TEST_ASSERT(n==3);
TEST_ASSERT(var[0]==0);
TEST_ASSERT(var[1]==1);
TEST_ASSERT(var[2]==0);
}
void TestExprDiff::apply03() {
Variable x("x"),y("y");
Function f(x,y,x*y,"f");
Function g(x,y,f(2*x,3*y));
Function dg(g,Function::DIFF);
// TODO: there are actually many different equivalent expressions of
// the differential.
// What should we exactly test? Probably requires expression equivalence
// operator but this is known to be a difficult task...
// CPPUNIT_ASSERT(sameExpr(dg.expr(),"((2*df((2*x),(3*y))[0]),(3*df((2*x),(3*y))[1]))"));
//CPPUNIT_ASSERT(sameExpr(dg.expr(),"((df((2*x),(3*y))[0]*2),(df((2*x),(3*y))[1]*3))"));
CPPUNIT_ASSERT(sameExpr(dg.expr(),"((6*y),(6*x))"));
double _box[][2]={{1,1},{2,2}};
double _dg_box[][2]={{12,12},{6,6}};
IntervalVector dg_box(dg.eval_vector(IntervalVector(2,_box)));
//CPPUNIT_ASSERT(dg_box==IntervalVector(2,_dg_box));
check(dg_box,IntervalVector(2,_dg_box));
CPPUNIT_ASSERT(dg_box.is_superset(IntervalVector(2,_dg_box)));
}
void TestExprSplitOcc::test06() {
const ExprSymbol& x=ExprSymbol::new_("x",Dim(1,3,1));
// several occurrences of an index (but different nodes)
const ExprNode& e1=x[0];
Function f1(x,x[0]-x[1]+x[2]+e1);
ExprSplitOcc eso(f1.args(),f1.expr());
const Array<const ExprSymbol>& x2=eso.get_x();
const ExprNode& y2=eso.get_y();
TEST_ASSERT(x2.size()==2);
TEST_ASSERT(x2[0].dim==((const ExprNode&) x).dim);
TEST_ASSERT(sameExpr(y2,"(((x[0]-x[1])+x[2])+x[0]_1_)"));
TEST_ASSERT(&eso.node(x2[0])==&x);
TEST_ASSERT(&eso.node(x2[1])==&e1);
int* var;
int n=eso.var_map(var);
TEST_ASSERT(n==4);
TEST_ASSERT(var[0]==0);
TEST_ASSERT(var[1]==1);
TEST_ASSERT(var[2]==2);
TEST_ASSERT(var[3]==0);
}
void TestFunction::copy() {
const ExprSymbol& x=ExprSymbol::new_("x",Dim::col_vec(3));
const ExprSymbol& A=ExprSymbol::new_("A",Dim::matrix(2,3));
Function f(x,A,A*x);
Function f2(f);
TEST_ASSERT(f2.nb_nodes()==3);
TEST_ASSERT(f2.nb_arg()==2);
const ExprMul* e2=dynamic_cast<const ExprMul*>(&f2.node(0));
TEST_ASSERT(e2!=NULL);
TEST_ASSERT(sameExpr(f2.expr(),"(A*x)"));
const ExprSymbol* A2=dynamic_cast<const ExprSymbol*>(&f2.node(1));
TEST_ASSERT(A2!=NULL);
TEST_ASSERT(strcmp(A2->name,"A")==0);
TEST_ASSERT(A2->dim==A.dim);
const ExprSymbol* x2=dynamic_cast<const ExprSymbol*>(&f2.node(2));
TEST_ASSERT(strcmp(x2->name,"x")==0);
TEST_ASSERT(x2->dim==x.dim);
}
void TestExprSplitOcc::test02() {
const ExprSymbol& x=ExprSymbol::new_("x");
const ExprSymbol& y=ExprSymbol::new_("y");
Function f1(x,y,(((x+y)-(pow(x,2)*y)+y)));
ExprSplitOcc eso(f1.args(),f1.expr());
const Array<const ExprSymbol>& x2=eso.get_x();
Function f2(x2, eso.get_y());
TEST_ASSERT(sameExpr(f2.expr(),"(((x_0_+y_0_)-(x_1_^2*y_1_))+y_2_)"));
TEST_ASSERT(x2.size()==5);
TEST_ASSERT(&eso.node(x2[0])==&x);
TEST_ASSERT(&eso.node(x2[1])==&x);
TEST_ASSERT(&eso.node(x2[2])==&y);
TEST_ASSERT(&eso.node(x2[3])==&y);
TEST_ASSERT(&eso.node(x2[4])==&y);
int* var;
int n=eso.var_map(var);
TEST_ASSERT(n==5);
TEST_ASSERT(var[0]==0);
TEST_ASSERT(var[1]==0);
TEST_ASSERT(var[2]==1);
TEST_ASSERT(var[3]==1);
TEST_ASSERT(var[4]==1);
}
