static char * test_glq_intcos()
{
double result, expected;
double angles[6];
int i, t, orders[6] = {2, 3, 5, 8, 15, 25};
GLQ *glq;
angles[0] = PI*0.1;
angles[1] = PI;
angles[2] = PI*1.2;
angles[3] = PI*1.9;
angles[4] = PI*4.3;
angles[5] = PI*6.9;
for(t = 0; t < 6; t++)
{
glq = glq_new(orders[t], 0., angles[t]);
if(glq == NULL)
{
sprintf(msg,
"(order %d, angle %g) failed to create new GLQ struct",
orders[t], angles[t]);
mu_assert(0, msg);
}
for(i = 0, result = 0; i < orders[t]; i++)
{
result += glq->weights[i]*cos(glq->nodes[i]);
}
result *= 0.5*angles[t];
expected = sin(angles[t]);
glq_free(glq);
sprintf(msg, "(order %d, angle %g) expected %f, got %f", orders[t],
angles[t], expected, result);
mu_assert_almost_equals(result, expected, pow(10, -5), msg);
}
return 0;
}
static char * test_tess2sphere_pot()
{
SPHERE sphere;
TESSEROID tess;
double radius, dist, restess, ressphere;
GLQ *glqlon, *glqlat, *glqr;
tess.density = 1000.;
tess.w = 44;
tess.e = 46;
tess.s = -1;
tess.n = 1;
tess.r1 = MEAN_EARTH_RADIUS - 100000;
tess.r2 = MEAN_EARTH_RADIUS;
glqlon = glq_new(8, tess.w, tess.e);
if(glqlon == NULL)
mu_assert(0, "GLQ allocation error");
glqlat = glq_new(8, tess.s, tess.n);
if(glqlat == NULL)
mu_assert(0, "GLQ allocation error");
glqr = glq_new(8, tess.r1, tess.r2);
if(glqr == NULL)
mu_assert(0, "GLQ allocation error");
glq_precompute_sincos(glqlat);
radius = tess.r2;
/* Make a sphere with the same mass as the tesseroid */
tess2sphere(tess, &sphere);
for(dist=1000000; dist <= 2000000; dist += 1000)
{
restess = tess_pot(tess,0,40,radius+dist,*glqlon,*glqlat,*glqr);
ressphere = sphere_pot(sphere,0,40,radius+dist);
sprintf(msg, "(distance %g m) tess = %.5f sphere = %.5f", dist,
restess, ressphere);
mu_assert_almost_equals(restess, ressphere, 0.01, msg);
}
return 0;
}
static char * test_tess_total_mass()
{
TESSEROID tesses[4] = {{1,0,360,-90,90,0,1}, {1,0,360,0,90,0,1},
{1,180,360,0,90,0,1}, {1,0,90,-90,0,0,1}};
double tvolumes[4] = {4.188790205, 2.094395102, 1.047197551, 0.523598776};
double res, expect;
int i;
res = tess_total_mass(tesses, 4);
for(expect = 0, i = 0; i < 4; i++)
{
expect += tvolumes[i];
}
sprintf(msg, "(tess %d) expected %g, got %g", i, expect, res);
mu_assert_almost_equals(res, expect, pow(10, -6), msg);
return 0;
}
static char * test_prism2sphere_gzz()
{
SPHERE sphere;
PRISM prism = {3000,-5000,5000,-5000,5000,-5000,5000,0,0,0};
double dist, resprism, ressphere;
/* Make a sphere with the same mass as the prism and put it at the origin */
prism2sphere(prism, 0, 0, 0, &sphere);
for(dist=60000; dist <= 500000; dist += 500)
{
resprism = prism_gzz(prism,0,0,-dist);
ressphere = sphere_gzz(sphere,0,90,dist);
sprintf(msg, "(distance %g m) prism = %.5f sphere = %.5f", dist,
resprism, ressphere);
mu_assert_almost_equals(resprism, ressphere, 0.001, msg);
}
return 0;
}
static char * test_prism2sphere()
{
double expect, res;
SPHERE sphere;
int i;
PRISM prisms[4] = {
{1,0,1000,0,2000,100,2000,0,0,0},
{1,-500,200,300,500,-1000,4000,0,0,0},
{1,-10000000,5000000,5000000,8000000,0,3000000,0,0,0},
{1,-1000000,50000,500000,800000,0,300000,0,0,0}};
for(i = 0; i < 4; i++)
{
prism2sphere(prisms[i], 0., 0., 0., &sphere);
res = sphere_volume(sphere);
expect = prism_volume(prisms[i]);
sprintf(msg, "(prism %d) expected volume %g, got %g", i, expect, res);
mu_assert_almost_equals(res/expect, 1., 0.001, msg);
}
return 0;
}
static char * test_tess2sphere()
{
double expect, res;
SPHERE sphere;
int i;
TESSEROID tesses[4] = {
{1,0,1,0,1,6000000,6001000},
{1,180,190,80,85,6300000,6301000},
{1,160,200,-90,-70,5500000,6000000},
{1,-10,5,-7,15,6500000,6505000}};
for(i = 0; i < 4; i++)
{
tess2sphere(tesses[i], &sphere);
res = sphere_volume(sphere);
expect = tess_volume(tesses[i]);
sprintf(msg, "(tess %d) expected volume %g, got %g", i, expect, res);
mu_assert_almost_equals(res/expect, 1., 0.01, msg);
}
return 0;
}
static char * test_tess2prism_flatten()
{
double expect, res;
PRISM prism;
int i;
TESSEROID tesses[4] = {
{1,0,1,0,1,6000000,6001000},
{1,180,190,80,85,6300000,6301000},
{1,160,200,-90,-70,5500000,6000000},
{1,-10,5,-7,15,6500000,6505000}};
for(i = 0; i < 4; i++)
{
tess2prism_flatten(tesses[i], &prism);
res = prism_volume(prism)*prism.density;
expect = tess_volume(tesses[i])*tesses[i].density;
sprintf(msg, "(tess %d) expected mass %g, got %g", i, expect, res);
mu_assert_almost_equals((double)(res - expect)/expect, 0., 0.01, msg);
}
return 0;
}
static char * test_prism_ggt_sph()
{
#define R 6378137.0
PRISM prism = {3000,-5000,5000,-5000,5000,0,5000,-7,8,R};
double res[6], expect[6];
int fix, i;
fix = 1;
prism_ggt_sph(prism, -7, 8, R + 1000, res);
expect[0] = prism_gxx(prism, 0, 0, -1000);
expect[1] = prism_gxy(prism, 0, 0, -1000);
expect[2] = prism_gxz(prism, 0, 0, -1000);
expect[3] = prism_gyy(prism, 0, 0, -1000);
expect[4] = prism_gyz(prism, 0, 0, -1000);
expect[5] = prism_gzz(prism, 0, 0, -1000);
for(i = 0; i < 6; i++)
{
sprintf(msg, "(fixture %d) cmp %d: expect %.10f got %.10f", fix, i,
expect[i], res[i]);
mu_assert_almost_equals(res[i], expect[i], 0.000000001, msg);
}
#undef R
return 0;
}
static char * test_glq_next_root()
{
double prec = pow(10, -9), root[19], initial;
int rc, i, order;
/* Test order 2 */
order = 2;
for(i = 0; i < order; i++)
{
initial = cos(PI*((order - i) - 0.25)/(order + 0.5));
rc = glq_next_root(initial, i, order, root);
sprintf(msg, "(order %d, root %d) return code %d, expected 0", order, i,
rc);
mu_assert(rc == 0, msg);
sprintf(msg, "(order %d, root %d) expected %.15f got %.15f", order, i,
o2roots[i], root[i]);
mu_assert_almost_equals(root[i], o2roots[i], prec, msg);
}
/* Test order 3 */
order = 3;
for(i = 0; i < order; i++)
{
initial = cos(PI*((order - i) - 0.25)/(order + 0.5));
rc = glq_next_root(initial, i, order, root);
sprintf(msg, "(order %d, root %d) return code %d, expected 0", order, i,
rc);
mu_assert(rc == 0, msg);
sprintf(msg, "(order %d, root %d) expected %.15f got %.15f", order, i,
o3roots[i], root[i]);
mu_assert_almost_equals(root[i], o3roots[i], prec, msg);
}
/* Test order 4 */
order = 4;
for(i = 0; i < order; i++)
{
initial = cos(PI*((order - i) - 0.25)/(order + 0.5));
rc = glq_next_root(initial, i, order, root);
sprintf(msg, "(order %d, root %d) return code %d, expected 0", order, i,
rc);
mu_assert(rc == 0, msg);
sprintf(msg, "(order %d, root %d) expected %.15f got %.15f", order, i,
o4roots[i], root[i]);
mu_assert_almost_equals(root[i], o4roots[i], prec, msg);
}
/* Test order 5 */
order = 5;
for(i = 0; i < order; i++)
{
initial = cos(PI*((order - i) - 0.25)/(order + 0.5));
rc = glq_next_root(initial, i, order, root);
sprintf(msg, "(order %d, root %d) return code %d, expected 0", order, i,
rc);
mu_assert(rc == 0, msg);
sprintf(msg, "(order %d, root %d) expected %.15f got %.15f", order, i,
o5roots[i], root[i]);
mu_assert_almost_equals(root[i], o5roots[i], prec, msg);
}
/* Test order 19 */
order = 19;
for(i = 0; i < order; i++)
{
initial = cos(PI*((order - i) - 0.25)/(order + 0.5));
rc = glq_next_root(initial, i, order, root);
sprintf(msg, "(order %d, root %d) return code %d, expected 0", order, i,
rc);
mu_assert(rc == 0, msg);
sprintf(msg, "(order %d, root %d) expected %.15f got %.15f", order, i,
o19roots[i], root[i]);
mu_assert_almost_equals(root[i], o19roots[i], prec, msg);
}
return 0;
}
static char * test_glq_set_limits()
{
double prec = pow(10, -9), unscaled[5], scaled[5], a, b, correct;
int rc, i;
GLQ glq;
glq.nodes_unscaled = unscaled;
glq.nodes = scaled;
glq.order = 2;
a = -2.54;
b = 14.9;
mu_arraycp(o2roots, glq.nodes_unscaled, glq.order);
rc = glq_set_limits(a, b, &glq);
sprintf(msg, "(order %d, a %g, b %g) return code %d, expected 0", glq.order,
a, b, rc);
mu_assert(rc == 0, msg);
for(i = 0; i < glq.order; i++)
{
correct = 8.72*o2roots[i] + 6.18;
sprintf(msg,
"(order %d, index %d, a %g, b %g) expected %.15f, got %.15f",
glq.order, i, a, b, correct, glq.nodes[i]);
mu_assert_almost_equals(glq.nodes[i], correct, prec, msg);
}
glq.order = 3;
a = 125.6;
b = 234.84;
mu_arraycp(o3roots, glq.nodes_unscaled, glq.order);
rc = glq_set_limits(a, b, &glq);
sprintf(msg, "(order %d, a %g, b %g) return code %d, expected 0", glq.order,
a, b, rc);
mu_assert(rc == 0, msg);
for(i = 0; i < glq.order; i++)
{
correct = 54.62*o3roots[i] + 180.22;
sprintf(msg,
"(order %d, index %d, a %g, b %g) expected %.15f, got %.15f",
glq.order, i, a, b, correct, glq.nodes[i]);
mu_assert_almost_equals(glq.nodes[i], correct, prec, msg);
}
glq.order = 4;
a = 3.5;
b = -12.4;
mu_arraycp(o4roots, glq.nodes_unscaled, glq.order);
rc = glq_set_limits(a, b, &glq);
sprintf(msg, "(order %d, a %g, b %g) return code %d, expected 0", glq.order,
a, b, rc);
mu_assert(rc == 0, msg);
for(i = 0; i < glq.order; i++)
{
correct = -7.95*o4roots[i] - 4.45;
sprintf(msg,
"(order %d, index %d, a %g, b %g) expected %.15f, got %.15f",
glq.order, i, a, b, correct, glq.nodes[i]);
mu_assert_almost_equals(glq.nodes[i], correct, prec, msg);
}
glq.order = 5;
a = 0.0;
b = 0.0;
mu_arraycp(o5roots, glq.nodes_unscaled, glq.order);
rc = glq_set_limits(a, b, &glq);
sprintf(msg, "(order %d, a %g, b %g) return code %d, expected 0", glq.order,
a, b, rc);
mu_assert(rc == 0, msg);
for(i = 0; i < glq.order; i++)
{
correct = 0.0;
sprintf(msg,
"(order %d, index %d, a %g, b %g) expected %.15f, got %.15f",
glq.order, i, a, b, correct, glq.nodes[i]);
mu_assert_almost_equals(glq.nodes[i], correct, prec, msg);
}
return 0;
}
static char * test_glq_nodes()
{
double prec = pow(10, -9), nodes[19];
int rc, i, order;
/* Test order 2 */
order = 2;
rc = glq_nodes(order, nodes);
sprintf(msg, "(order %d) return code %d, expected 0", order, rc);
mu_assert(rc == 0, msg);
for(i = 0; i < order; i++)
{
sprintf(msg, "(order %d, node %d) expected %.15f got %.15f", order,
i, o2roots[i], nodes[i]);
mu_assert_almost_equals(nodes[i], o2roots[i], prec, msg);
}
/* Test order 3 */
order = 3;
rc = glq_nodes(order, nodes);
sprintf(msg, "(order %d) return code %d, expected 0", order, rc);
mu_assert(rc == 0, msg);
for(i = 0; i < order; i++)
{
sprintf(msg, "(order %d, node %d) expected %.15f got %.15f", order,
i, o3roots[i], nodes[i]);
mu_assert_almost_equals(nodes[i], o3roots[i], prec, msg);
}
/* Test order 4 */
order = 4;
rc = glq_nodes(order, nodes);
sprintf(msg, "(order %d) return code %d, expected 0", order, rc);
mu_assert(rc == 0, msg);
for(i = 0; i < order; i++)
{
sprintf(msg, "(order %d, node %d) expected %.15f got %.15f", order,
i, o4roots[i], nodes[i]);
mu_assert_almost_equals(nodes[i], o4roots[i], prec, msg);
}
/* Test order 5 */
order = 5;
rc = glq_nodes(order, nodes);
sprintf(msg, "(order %d) return code %d, expected 0", order, rc);
mu_assert(rc == 0, msg);
for(i = 0; i < order; i++)
{
sprintf(msg, "(order %d, node %d) expected %.15f got %.15f", order,
i, o5roots[i], nodes[i]);
mu_assert_almost_equals(nodes[i], o5roots[i], prec, msg);
}
/* Test order 19 */
order = 19;
rc = glq_nodes(order, nodes);
sprintf(msg, "(order %d) return code %d, expected 0", order, rc);
mu_assert(rc == 0, msg);
for(i = 0; i < order; i++)
{
sprintf(msg, "(order %d, node %d) expected %.15f got %.15f", order,
i, o19roots[i], nodes[i]);
mu_assert_almost_equals(nodes[i], o19roots[i], prec, msg);
}
return 0;
}
