void Test_maxmin_pw(CuTest * tc){ printf("Testing functions: absmax, max and min of pw \n"); // function struct Fwrap * fw = fwrap_create(1,"general-vec"); fwrap_set_fvec(fw,maxminpoly,NULL); // approximation double lb = -1.0, ub = 2.0; struct PwPolyOpts * opts = pw_poly_opts_alloc(LEGENDRE,lb,ub); opoly_t pl = piecewise_poly_approx1_adapt(opts,fw); double loc; double max = piecewise_poly_max(pl, &loc); double min = piecewise_poly_min(pl, &loc); double absmax = piecewise_poly_absmax(pl, &loc,NULL); CuAssertDblEquals(tc, 1.0, max, 1e-10); CuAssertDblEquals(tc, -1.0, min, 1e-10); CuAssertDblEquals(tc, 1.0, absmax, 1e-10); piecewise_poly_free(pl); fwrap_destroy(fw); pw_poly_opts_free(opts); }
void Test_serialize_double(CuTest * tc){ printf("doubleserialization tests and experiments \n"); printf("size of double in bytes= %zu\n",sizeof(double)); printf("DBL_MAX = %G \n",DBL_MAX); printf("DBL_MIN = %G \n",DBL_MIN); printf("DBL_EPSILON = %G\n",DBL_EPSILON); double a = 20423.231; double value; unsigned char buffer[sizeof(double)]; serialize_double(buffer,a); deserialize_double(buffer,&value); CuAssertDblEquals(tc,value,a,0.0); a = DBL_MAX; serialize_double(buffer,a); deserialize_double(buffer,&value); CuAssertDblEquals(tc,value,a,0.0); a = 0.0; serialize_double(buffer,a); deserialize_double(buffer,&value); CuAssertDblEquals(tc,value,a,0.0); }
void Test_lin_elem_exp_orth_basis(CuTest * tc) { printf("Testing function: lin_elem_exp_orth_basis\n"); double lb = -2.0; double ub = 0.2; size_t N = 100; double * x = linspace(lb,ub,N); struct LinElemExpAopts * opts = lin_elem_exp_aopts_alloc(N,x); /* double * coeff = calloc_double(N); */ le_t f[100]; for (size_t ii = 0; ii < N; ii++){ f[ii] = NULL;// lin_elem_exp_init(N,x,coeff); } lin_elem_exp_orth_basis(N,f,opts); for (size_t ii = 0; ii < N; ii++){ for (size_t jj = 0; jj < N; jj++){ double val = lin_elem_exp_inner(f[ii],f[jj]); if (ii == jj){ CuAssertDblEquals(tc,1.0,val,1e-15); } else{ CuAssertDblEquals(tc,0.0,val,1e-15); } } } for (size_t ii = 0; ii < N; ii++){ LINELEM_FREE(f[ii]); } free(x); x = NULL; /* free(coeff); coeff = NULL; */ lin_elem_exp_aopts_free(opts); }
void testVectorMalloc(CuTest* tc) { vector v = vectorMalloc(); //CuAssertTrue(tc, NULL != v); CuAssertDblEquals(tc, 0.0, v.x, DELTA); CuAssertDblEquals(tc, 0.0, v.y, DELTA); CuAssertDblEquals(tc, 0.0, v.z, DELTA); }
void Testwishart(CuTest* tc) { /*set a non-trivial location matrix*/ gsl_matrix* V = gsl_matrix_alloc(DIM, DIM); gsl_matrix_set_identity(V); gsl_matrix_scale(V, V0); for(size_t i=0; i<DIM; i++) for(size_t j=i+1; j < DIM; j++) { gsl_matrix_set(V, i, j, 1.0); gsl_matrix_set(V, j, i, 1.0); } p = mcmclib_wishart_lpdf_alloc(V, P); x = gsl_vector_alloc(DIM * DIM); gsl_matrix_view X_v = gsl_matrix_view_vector(x, DIM, DIM); gsl_matrix* X = &(X_v.matrix); gsl_matrix_set_all(X, 0.2); for(size_t i=0; i<DIM; i++) gsl_matrix_set(X, i, i, 1.0); CuAssertDblEquals(tc, -7.152627, lpdf(1.0), TOL); CuAssertDblEquals(tc, -29.549142, lpdf(0.5), TOL); CuAssertDblEquals(tc, 13.380252, lpdf(2.0), TOL); mcmclib_wishart_lpdf_free(p); gsl_vector_free(x); gsl_matrix_free(V); }
void test_sp_proj_module(CuTest* tc) { int size = 2; Image * a = sp_image_alloc(size,size,1); for(int i = 0;i<sp_image_size(a);i++){ a->image->data[i] = sp_cinit(p_drand48(),p_drand48()); } Image * exp = sp_image_alloc(size,size,1); for(int i = 0;i<sp_image_size(a);i++){ exp->image->data[i] = sp_cinit(p_drand48(),0); } for(int i = 0;i<sp_image_size(a);i++){ exp->mask->data[i] = 1; } Image * proj = sp_proj_module(a,exp,SpOutOfPlace); for(int i = 0;i<sp_image_size(a);i++){ /* Check that the magnitude is the same as the experimental */ CuAssertDblEquals(tc,sp_cabs(proj->image->data[i]),sp_cabs(exp->image->data[i]),fabs(2*REAL_EPSILON*sp_cabs(exp->image->data[i]))); /* Check that the phase is the same as the input */ CuAssertDblEquals(tc,sp_carg(proj->image->data[i]),sp_carg(a->image->data[i]),fabs(2*REAL_EPSILON*sp_carg(a->image->data[i]))); } PRINT_DONE; }
void Testiwishart(CuTest* tc) { /*set a non-trivial location matrix*/ gsl_matrix* V = gsl_matrix_alloc(DIM, DIM); gsl_matrix_set_identity(V); gsl_matrix_add_constant(V, 1.0); p = mcmclib_iwishart_lpdf_alloc(V, P); x = gsl_vector_alloc(DIM * DIM); gsl_matrix_view X_v = gsl_matrix_view_vector(x, DIM, DIM); gsl_matrix* X = &(X_v.matrix); gsl_matrix_set_identity(X); gsl_matrix_add_constant(X, 1.0); /*check for side-effects*/ double tmp = lpdf(1.0); CuAssertTrue(tc, tmp == lpdf(1.0)); CuAssertDblEquals(tc, -18.188424, lpdf(1.0), TOL); CuAssertDblEquals(tc, 49.59203, lpdf(0.5), TOL); CuAssertDblEquals(tc, -88.468878, lpdf(2.0), TOL); mcmclib_iwishart_lpdf_free(p); gsl_vector_free(x); gsl_matrix_free(V); }
void Test_pw_approx_nonnormal(CuTest * tc){ printf("Testing function: piecewise_poly_approx on (a,b)\n"); // function struct Fwrap * fw = fwrap_create(1,"general-vec"); fwrap_set_fvec(fw,Sin3xTx2,NULL); // approximation double lb=-3.0, ub=2.0; struct PwPolyOpts * opts = pw_poly_opts_alloc(LEGENDRE,lb,ub); size_t N = 15; double * pts = linspace(lb,ub,N); pw_poly_opts_set_pts(opts,N,pts); opoly_t pw = piecewise_poly_approx1(opts,fw); double lb1 = piecewise_poly_lb(pw->branches[0]); double ub1 = piecewise_poly_ub(pw->branches[0]); CuAssertDblEquals(tc,pts[0],lb1,1e-14); CuAssertDblEquals(tc,pts[1],ub1,1e-14); // compute error double abs_err; double func_norm; compute_error_vec(lb,ub,1000,pw,Sin3xTx2,NULL,&abs_err,&func_norm); double err = abs_err / func_norm; CuAssertDblEquals(tc, 0.0, err, 1e-13); fwrap_destroy(fw); POLY_FREE(pw); pw_poly_opts_free(opts); free(pts); }
void test_sorting(CuTest* tc) { double flux[] = { 50, 100, 50, 100, 20, 20, 40, 40 }; double bg[] = { 0, 10, 10, 0, 10, 0, 5, 0 }; int trueorder[] = { 4, 5, 7, 6, 2, 0, 1, 3 }; int i, N; starxy_t* s; char* infn = "/tmp/test-resort-xylist"; char* outfn = "/tmp/test-resort-xylist-out"; xylist_t* xy; xylist_t* xy2; starxy_t* s2; xy = xylist_open_for_writing(infn); CuAssertPtrNotNull(tc, xy); xylist_set_include_flux(xy, TRUE); xylist_set_include_background(xy, TRUE); if (xylist_write_primary_header(xy) || xylist_write_header(xy)) { CuFail(tc, "write header"); } N = sizeof(flux) / sizeof(double); s = starxy_new(N, TRUE, TRUE); for (i=0; i<N; i++) { starxy_setx(s, i, random()%1000); starxy_sety(s, i, random()%1000); } starxy_set_flux_array(s, flux); starxy_set_bg_array(s, bg); if (xylist_write_field(xy, s) || xylist_fix_header(xy) || xylist_fix_primary_header(xy) || xylist_close(xy)) { CuFail(tc, "close xy"); } CuAssertIntEquals(tc, 0, resort_xylist(infn, outfn, NULL, NULL, TRUE)); xy2 = xylist_open(outfn); s2 = xylist_read_field(xy2, NULL); CuAssertPtrNotNull(tc, s2); CuAssertPtrNotNull(tc, s2->x); CuAssertPtrNotNull(tc, s2->y); CuAssertPtrNotNull(tc, s2->flux); CuAssertPtrNotNull(tc, s2->background); for (i=0; i<N; i++) { CuAssertDblEquals(tc, s->x[trueorder[i]], s2->x[i], 1e-6); CuAssertDblEquals(tc, s->y[trueorder[i]], s2->y[i], 1e-6); CuAssertDblEquals(tc, s->flux[trueorder[i]], s2->flux[i], 1e-6); CuAssertDblEquals(tc, s->background[trueorder[i]], s2->background[i], 1e-6); } }
void testMag(CuTest* tc) { vector v; assign(&v, 0.0, 3.0, 4.0); CuAssertDblEquals(tc, 5.0, mag(v), DELTA); assign(&v, 1.0, 1.0, 1.0); CuAssertDblEquals(tc, sqrt(3.0), mag(v), DELTA); //vectorFree(v); }
void testAssign(CuTest* tc) { vector v; assign(&v, 1.0, 2.0, 3.0); CuAssertDblEquals(tc, 1.0, v.x, DELTA); CuAssertDblEquals(tc, 2.0, v.y, DELTA); CuAssertDblEquals(tc, 3.0, v.z, DELTA); //vectorFree(v); }
void testEvent_getBranchLength(CuTest* testCase) { cactusEventTestSetup(); CuAssertDblEquals(testCase, INT64_MAX, event_getBranchLength(rootEvent), 1.000); CuAssertDblEquals(testCase, 0.5, event_getBranchLength(internalEvent), 0.001); CuAssertDblEquals(testCase, 0.2, event_getBranchLength(leafEvent1), 0.001); CuAssertDblEquals(testCase, 1.3, event_getBranchLength(leafEvent2), 0.001); cactusEventTestTeardown(); }
void testEvent_getSubTreeBranchLength(CuTest* testCase) { cactusEventTestSetup(); CuAssertDblEquals(testCase, 2.0, event_getSubTreeBranchLength(rootEvent), 0.001); CuAssertDblEquals(testCase, 1.5, event_getSubTreeBranchLength(internalEvent), 0.001); CuAssertDblEquals(testCase, 0.0, event_getSubTreeBranchLength(leafEvent1), 0.001); CuAssertDblEquals(testCase, 0.0, event_getSubTreeBranchLength(leafEvent2), 0.001); cactusEventTestTeardown(); }
void Test_unc6(CuTest * tc) { printf("////////////////////////////////////////////\n"); printf("\t Unconstrained Test: 6\n"); size_t f1 = 5; struct UncTestProblem p = tprobs[f1]; size_t dim = unc_test_problem_get_dim(&p); struct c3Opt * opt = c3opt_alloc(BFGS,dim); c3opt_add_objective(opt,unc_test_problem_eval,&p); c3opt_set_verbose(opt,0); /* c3opt_set_gtol(opt,1e-20); */ /* c3opt_set_absxtol(opt,1e-20); */ /* c3opt_set_relftol(opt,1e-14); */ c3opt_set_maxiter(opt,400); c3opt_ls_set_maxiter(opt,1000); double * start = unc_test_problem_get_start(&p); /* printf("start\n"); */ /* dprint(2,start); */ double gerr = c3opt_check_deriv(opt,start,1e-8); CuAssertDblEquals(tc,0.0,gerr,1e-5); /* printf("gerr = %G\n",gerr); */ double val; int res = c3opt_minimize(opt,start,&val); CuAssertIntEquals(tc,1,res>=0); double * soll = unc_test_problem_get_sol(&p); //minimum double err = fabs(soll[dim]-val); if (fabs(soll[dim]) > 1){ err /= fabs(soll[dim]); } CuAssertDblEquals(tc,0.0,err,1e-4); //minimizer for (size_t ii = 0; ii < dim; ii++){ CuAssertDblEquals(tc,soll[ii],start[ii],1e-2); } printf("\t\t *True* Minimum: : %3.6E\n", soll[dim]); printf("\t\t Minimum Found: : %3.6E\n\n",val); printf("\t\t Number of Function Evaluations: %zu\n",c3opt_get_nevals(opt)); printf("\t\t Number of Gradient Evaluations: %zu\n",c3opt_get_ngvals(opt)); printf("\t\t Number of iterations: %zu\n",c3opt_get_niters(opt)); printf("////////////////////////////////////////////\n"); c3opt_free(opt); opt = NULL; }
static void test_param_flt(CuTest * tc) { struct param *par = 0; test_cleanup(); CuAssertDblEquals(tc, 13, get_param_flt(par, "foo", 13), 0.01); set_param(&par, "foo", "23.0"); set_param(&par, "bar", "42.0"); CuAssertDblEquals(tc, 23.0, get_param_flt(par, "foo", 0.0), 0.01); CuAssertDblEquals(tc, 42.0, get_param_flt(par, "bar", 0.0), 0.01); }
void testNormalize(CuTest* tc) { vector v; assign(&v, 1.0, 1.0, 1.0); normalize(&v); CuAssertDblEquals(tc, 1.0, mag(v), DELTA); assign(&v, 123.0, -321.0, 1.23); normalize(&v); CuAssertDblEquals(tc, 1.0, mag(v), DELTA); //vectorFree(v); }
void testCopy(CuTest* tc) { vector v1; vector v2; assign(&v1, 23.23, -99.32, 12334.23); copy(&v2, v1); CuAssertDblEquals(tc, v1.x, v2.x, DELTA); CuAssertDblEquals(tc, v1.y, v2.y, DELTA); CuAssertDblEquals(tc, v1.z, v2.z, DELTA); //vectorFree(v1); //vectorFree(v2); }
void testAdd(CuTest* tc) { vector v1,v2,v3; //v1 = vectorMalloc(); v2 = vectorMalloc(); v3 = vectorMalloc(); assign(&v1, 1.0, 2.0, 3.0); assign(&v2, 10.0, 20.0, 30.0); add(&v3, v1, v2); CuAssertDblEquals(tc, 11.0, v3.x, DELTA); CuAssertDblEquals(tc, 22.0, v3.y, DELTA); CuAssertDblEquals(tc, 33.0, v3.z, DELTA); //vectorFree(v1); vectorFree(v2); vectorFree(v3); }
void Test_lin_elem_exp_inner2(CuTest * tc){ printf("Testing function: lin_elem_exp_inner (2)\n"); // function struct Fwrap * fw1 = fwrap_create(1,"general-vec"); fwrap_set_fvec(fw1,powX2,NULL); struct Fwrap * fw2 = fwrap_create(1,"general-vec"); fwrap_set_fvec(fw2,TwoPowX3,NULL); double lb=-2.0,ub=3.0; size_t N1 = 10; double * p1 = linspace(lb,0.5,N1); double f[1000]; fwrap_eval(N1,p1,f,fw1); size_t N2 = 20; double * p2 = linspace(0.0,ub,N2); double g[1000]; fwrap_eval(N2,p2,g,fw2); le_t fa = lin_elem_exp_init(N1,p1,f); le_t fb = lin_elem_exp_init(N2,p2,g); double intis = lin_elem_exp_inner(fa,fb); double intis2 = lin_elem_exp_inner(fb,fa); size_t ntest = 10000000; double * xtest = linspace(lb,ub,ntest); double integral = 0.0; for (size_t ii = 0; ii < ntest; ii++){ integral += (LINELEM_EVAL(fa,xtest[ii]) * LINELEM_EVAL(fb,xtest[ii])); } integral /= (double) ntest; integral *= (ub - lb); double intshould = integral; double diff = fabs(intshould-intis)/fabs(intshould); CuAssertDblEquals(tc, 0.0, diff, 1e-6); CuAssertDblEquals(tc,intis,intis2,1e-15); free(xtest); LINELEM_FREE(fa); LINELEM_FREE(fb); free(p1); free(p2); fwrap_destroy(fw1); fwrap_destroy(fw2); }
void test_nullspace_gsl(CuTest* tc) { int i, j; gsl_matrix* A; gsl_matrix* V; gsl_matrix* U; gsl_vector* S; gsl_matrix_view vcov; double cov[4] = {-0.93390448957619598, 1.8004204750064117, 0, 0}; int M=2, N=2; A = gsl_matrix_alloc(M, N); S = gsl_vector_alloc(N); V = gsl_matrix_alloc(N, N); vcov = gsl_matrix_view_array(cov, M, N); gsl_matrix_memcpy(A, &(vcov.matrix)); gsl_linalg_SV_decomp_jacobi(A, V, S); // the U result is written to A. U = A; printf("S = ["); for (i=0; i<N; i++) printf(" %g", gsl_vector_get(S, i)); printf(" ]\n"); printf("U = ["); for (j=0; j<M; j++) { if (j) printf(" ["); for (i=0; i<N; i++) printf(" %g", gsl_matrix_get(U, j, i)); printf(" ]\n"); } printf("V = ["); for (j=0; j<N; j++) { if (j) printf(" ["); for (i=0; i<N; i++) printf(" %g", gsl_matrix_get(V, j, i)); printf(" ]\n"); } CuAssertDblEquals(tc, 0, gsl_vector_get(S, 1), 1e-6); CuAssertDblEquals(tc, 2.02822373, gsl_vector_get(S, 0), 1e-6); gsl_matrix_free(A); gsl_matrix_free(V); gsl_vector_free(S); }
void test_parse_center_gets_1_2i_neg_returns_1_2_neg(CuTest *tc) { double actual_c_re; double actual_c_im; char param[] = "-1-2i"; double delta = 0.00001; double expected_c_re = -1; double expected_c_im = -2; int result = parse_center( param, &actual_c_re, &actual_c_im ); CuAssertDblEquals(tc, expected_c_re, actual_c_re, delta); CuAssertDblEquals(tc, expected_c_im, actual_c_im, delta); }
void test_sp_proj_module_histogram(CuTest* tc) { int size = 1000; float base = 10; Image * a = sp_image_alloc(size,size,1); for(int i = 0;i<sp_image_size(a);i++){ a->image->data[i] = sp_cinit(sqrt(base)*p_drand48(),sqrt(base)*p_drand48()); } Image * exp = sp_image_alloc(size,size,1); for(int i = 0;i<sp_image_size(a);i++){ /* We have to add base to make sure the values are much above std_dev */ exp->image->data[i] = sp_cinit(base+p_drand48(),0); } for(int i = 0;i<sp_image_size(a);i++){ exp->mask->data[i] = 1; } Image * std_dev = sp_image_alloc(size,size,1); for(int i = 0;i<sp_image_size(a);i++){ /* We have to keep the standard deviation small */ std_dev->image->data[i] = sp_cinit(0.1,0); } Image * norm_sq_int = sp_image_alloc(size,size,1); Image * proj = sp_proj_module_histogram(a,exp,std_dev); for(int i = 0;i<sp_image_size(a);i++){ /* Calculate normalized square intensities */ sp_real(norm_sq_int->image->data[i]) = (sp_cabs2(exp->image->data[i])-sp_cabs2(proj->image->data[i]))/sp_real(std_dev->image->data[i]); /* Check that the phase is the same as the input */ CuAssertDblEquals(tc,sp_carg(proj->image->data[i]),sp_carg(a->image->data[i]),1e-3); } /* Check that the average normal of the normaized squared magnitudes is 0*/ double average = 0; for(int i = 0;i<sp_image_size(a);i++){ average += sp_real(norm_sq_int->image->data[i]); } average /= sp_image_size(a); double variance = 0; for(int i = 0;i<sp_image_size(a);i++){ variance += (average-sp_real(norm_sq_int->image->data[i]))*(average-sp_real(norm_sq_int->image->data[i])); } variance /= sp_image_size(a); CuAssertDblEquals(tc,average,0,1.0/size); CuAssertDblEquals(tc,variance,1,1.0/size); PRINT_DONE; }
static void checkIsValidReference(CuTest *testCase, stList *reference, double totalScore) { stList *chosenEdges = convertReferenceToAdjacencyEdges(reference); //Check that everyone has a partner. CuAssertIntEquals(testCase, nodeNumber, stList_length(chosenEdges) * 2); stSortedSet *nodes = stSortedSet_construct3((int(*)(const void *, const void *)) stIntTuple_cmpFn, (void(*)(void *)) stIntTuple_destruct); for (int64_t i = 0; i < nodeNumber; i++) { stSortedSet_insert(nodes, stIntTuple_construct1( i)); } checkEdges(chosenEdges, nodes, 1, 0); //Check that the score is correct double totalScore2 = calculateZScoreOfReference(reference, nodeNumber, zMatrix); CuAssertDblEquals(testCase, totalScore2, totalScore, 0.000001); //Check that the stubs are properly connected. stList *allEdges = stList_copy(chosenEdges, NULL); stList_appendAll(allEdges, stubs); stList_appendAll(allEdges, chains); stList *components = getComponents(allEdges); CuAssertIntEquals(testCase, stList_length(stubs), stList_length(reference)); CuAssertIntEquals(testCase, stList_length(stubs), stList_length(components)); //Cleanup stList_destruct(components); stSortedSet_destruct(nodes); stList_destruct(allEdges); stList_destruct(chosenEdges); }
void Test_c3axpy(CuTest * tc) { printf("Testing Function: c3axpy\n"); struct BoundingBox * bds = bounding_box_init_std(5); struct FunctionTrain * ft1 = function_train_cross(func1,NULL,bds,NULL,NULL,NULL); struct FunctionTrain * ft2 = function_train_cross(func2,NULL,bds,NULL,NULL,NULL); c3axpy(3.0,ft1,&ft2,1e-10); size_t ii,jj, N = 10000; double pt[5]; double sum = 0.0; for (ii = 0; ii < N; ii++) { for (jj = 0; jj < 5; jj++) { pt[jj] = randu()*2.0-1.0; } double val = func1(pt,NULL)*3.0 + func2(pt,NULL); double vala = function_train_eval(ft2,pt); double diff = val-vala; sum += pow(diff,2); } CuAssertDblEquals(tc, 0.0, sum / N, 1e-9); bounding_box_free(bds); bds = NULL; function_train_free(ft1); ft1 = NULL; function_train_free(ft2); ft2 = NULL; }
static void test_default_similarity( CuTest* tc ) { apr_pool_t* pool; lcn_similarity_t* sim; int i; LCN_TEST( apr_pool_create( &pool, main_pool ) ); LCN_TEST( lcn_default_similarity_create( &sim, pool ) ); for( i = 0; i < 256; i++ ) { CuAssertTrue( tc, test_norm_table[i] - lcn_similarity_norm_decoder( sim )[i] < 0.00001f ); CuAssertTrue( tc, lcn_similarity_norm_decoder( sim )[i] - test_norm_table[i] < 0.0001f ); } CuAssertDblEquals( tc, 0.341190, lcn_similarity_query_norm( sim, 8.590276 ), 0.00001f ); }
void Test_pw_approx_adapt_weird(CuTest * tc){ printf("Testing function: piecewise_poly_approx1_adapt on (a,b)\n"); // function struct Fwrap * fw = fwrap_create(1,"general-vec"); fwrap_set_fvec(fw,Sin3xTx2,NULL); // approximation double lb=-2.0, ub = -1.0; struct PwPolyOpts * opts = pw_poly_opts_alloc(LEGENDRE,lb,ub); opoly_t pw = piecewise_poly_approx1_adapt(opts,fw); // this is just to make sure no memory errors or segfaults size_t nbounds; double * bounds = NULL; piecewise_poly_boundaries(pw,&nbounds,&bounds,NULL); //dprint(nbounds,bounds); free(bounds); // compute error double abs_err; double func_norm; compute_error_vec(lb,ub,1000,pw,Sin3xTx2,NULL,&abs_err,&func_norm); double err = abs_err / func_norm; CuAssertDblEquals(tc, 0.0, err, 1e-13); fwrap_destroy(fw); POLY_FREE(pw); pw_poly_opts_free(opts); }
void Test_pw_flatten(CuTest * tc){ printf("Testing functions: piecewise_poly_flatten \n"); // function struct Fwrap * fw = fwrap_create(1,"general-vec"); fwrap_set_fvec(fw,pw_disc,NULL); // approximation double lb=-5.0, ub = 1.0; struct PwPolyOpts * opts = pw_poly_opts_alloc(LEGENDRE,lb,ub); pw_poly_opts_set_minsize(opts,1e-5); opoly_t pw = piecewise_poly_approx1_adapt(opts,fw); size_t nregions = piecewise_poly_nregions(pw); int isflat = piecewise_poly_isflat(pw); CuAssertIntEquals(tc,0,isflat); piecewise_poly_flatten(pw); CuAssertIntEquals(tc,nregions,pw->nbranches); isflat = piecewise_poly_isflat(pw); CuAssertIntEquals(tc,1,isflat); // compute error double abs_err; double func_norm; compute_error_vec(lb,ub,1000,pw,pw_disc,NULL,&abs_err,&func_norm); double err = abs_err / func_norm; CuAssertDblEquals(tc, 0.0, err, 1e-13); fwrap_destroy(fw); POLY_FREE(pw); pw_poly_opts_free(opts); }
void Test_pap1(CuTest * tc){ printf("Testing function: approx (1/1) \n"); // function struct Fwrap * fw = fwrap_create(1,"general-vec"); fwrap_set_fvec(fw,pap1,NULL); // approximation double lb = -5.0, ub = 5.0; struct PwPolyOpts * opts = pw_poly_opts_alloc(LEGENDRE,lb,ub); /* pw_poly_opts_set_minsize(opts,1e-1); */ /* pw_poly_opts_set_tol(opts,1e-5); */ /* pw_poly_opts_set_maxorder(opts,5); */ opoly_t pw = piecewise_poly_approx1_adapt(opts,fw); // error double abs_err; double func_norm; compute_error_vec(lb,ub,1000,pw,pap1,NULL,&abs_err,&func_norm); double err = abs_err / func_norm; CuAssertDblEquals(tc, 0.0, err, 1e-13); fwrap_destroy(fw); pw_poly_opts_free(opts); POLY_FREE(pw); }
void Test_pw_inner(CuTest * tc){ printf("Testing function: piecewise_poly_inner\n"); // function struct Fwrap * fw1 = fwrap_create(1,"general-vec"); fwrap_set_fvec(fw1,powX2,NULL); struct Fwrap * fw2 = fwrap_create(1,"general-vec"); fwrap_set_fvec(fw2,TwoPowX3,NULL); double lb = -2.0, ub = 3.0; struct PwPolyOpts * opts = pw_poly_opts_alloc(LEGENDRE,lb,ub); opoly_t cpoly = piecewise_poly_approx1_adapt(opts,fw1); opoly_t cpoly2 = piecewise_poly_approx1_adapt(opts,fw2); double intshould = (pow(ub,6) - pow(lb,6))/3; double intis = piecewise_poly_inner(cpoly,cpoly2); CuAssertDblEquals(tc, intshould, intis, 1e-10); POLY_FREE(cpoly); POLY_FREE(cpoly2); pw_poly_opts_free(opts); fwrap_destroy(fw1); fwrap_destroy(fw2); }
void Test_pw_derivative(CuTest * tc){ printf("Testing function: piecewise_poly_deriv on (a,b)\n"); // function struct Fwrap * fw = fwrap_create(1,"general-vec"); fwrap_set_fvec(fw,Sin3xTx2,NULL); // approximation double lb = -2.0, ub = -1.0; struct PwPolyOpts * opts = pw_poly_opts_alloc(LEGENDRE,lb,ub); opoly_t cpoly = piecewise_poly_approx1_adapt(opts,fw); opoly_t der = piecewise_poly_deriv(cpoly); // error double abs_err; double func_norm; compute_error(lb,ub,1000,der,funcderiv,NULL,&abs_err,&func_norm); double err = abs_err / func_norm; CuAssertDblEquals(tc, 0.0, err, 1e-13); POLY_FREE(cpoly); POLY_FREE(der); pw_poly_opts_free(opts); fwrap_destroy(fw); }