void
sc_bspline_destroy (sc_bspline_t * bs)
{
if (bs->knots_owned)
sc_dmatrix_destroy (bs->knots);
if (bs->works_owned)
sc_dmatrix_destroy (bs->works);
SC_FREE (bs);
}
static void
check_matrix_multiply ()
{
sc_dmatrix_t *A, *B, *C, *D, *E, *vA;
double alpha, beta;
A = sc_dmatrix_new (3, 2);
B = sc_dmatrix_new (2, 3);
C = sc_dmatrix_new (3, 3);
A->e[0][0] = 1;
A->e[0][1] = 2;
A->e[1][0] = 3;
A->e[1][1] = 4;
A->e[2][0] = 5;
A->e[2][1] = 6;
printf ("A =\n");
sc_dmatrix_write (A, stdout);
B->e[0][0] = 1;
B->e[0][1] = 7;
B->e[0][2] = 2;
B->e[1][0] = 3;
B->e[1][1] = 5;
B->e[1][2] = 4;
printf ("B =\n");
sc_dmatrix_write (B, stdout);
alpha = 1.0;
beta = 0.0;
sc_dmatrix_multiply (SC_NO_TRANS, SC_NO_TRANS, alpha, A, B, beta, C);
printf ("C =\n");
sc_dmatrix_write (C, stdout);
D = sc_dmatrix_new (2, 3);
sc_dmatrix_multiply (SC_TRANS, SC_NO_TRANS, alpha, A, C, beta, D);
printf ("D =\n");
sc_dmatrix_write (D, stdout);
E = sc_dmatrix_new (2, 2);
sc_dmatrix_multiply (SC_NO_TRANS, SC_TRANS, alpha, D, B, beta, E);
printf ("E =\n");
sc_dmatrix_write (E, stdout);
vA = sc_dmatrix_new_view (3, 2, A);
sc_dmatrix_multiply (SC_NO_TRANS, SC_NO_TRANS, alpha, vA, B, beta, C);
printf ("C =\n");
sc_dmatrix_write (C, stdout);
sc_dmatrix_reshape (vA, 2, 3);
printf ("reshape(2, 3, vA) =\n");
sc_dmatrix_write (vA, stdout);
sc_dmatrix_destroy (vA);
sc_dmatrix_destroy (A);
sc_dmatrix_destroy (B);
sc_dmatrix_destroy (C);
sc_dmatrix_destroy (D);
sc_dmatrix_destroy (E);
}
static void
check_matrix_vector (void)
{
int i, j, k;
double d[23];
sc_dmatrix_t *A, *X3, *X4, *Y3a, *Y3b, *Y4a, *Y4b;
for (k = 0; k < 23; ++k) {
d[k] = (k + 3) * (k - 3 * k) + sqrt (2. + sin (k * 1.22345));
}
A = sc_dmatrix_new (3, 4);
X3 = sc_dmatrix_new (3, 1);
X4 = sc_dmatrix_new (1, 4);
Y3a = sc_dmatrix_new (3, 1);
Y3b = sc_dmatrix_new (1, 3);
Y4a = sc_dmatrix_new (4, 1);
Y4b = sc_dmatrix_new (1, 4);
for (i = 0; i < 3; ++i) {
X3->e[i][0] = i + 1.;
}
for (j = 0; j < 4; ++j) {
X4->e[0][j] = j + 1.;
}
k = 0;
for (i = 0; i < 3; ++i) {
for (j = 0; j < 4; ++j) {
A->e[i][j] = d[k];
k = (k + 1) % 23;
}
}
sc_dmatrix_vector (SC_NO_TRANS, SC_TRANS, SC_NO_TRANS, 1., A, X4, 0., Y3a);
sc_dmatrix_vector (SC_NO_TRANS, SC_TRANS, SC_NO_TRANS, 2., A, X4, 2., Y3a);
sc_dmatrix_vector (SC_NO_TRANS, SC_TRANS, SC_TRANS, 4., A, X4, 0., Y3b);
for (i = 0; i < 3; ++i) {
Y3b->e[0][i] -= Y3a->e[i][0];
}
sc_dmatrix_multiply (SC_NO_TRANS, SC_TRANS, 8., A, X4, -2., Y3a);
printf ("0 =\n");
sc_dmatrix_write (Y3a, stdout);
printf ("0 =\n");
sc_dmatrix_write (Y3b, stdout);
sc_dmatrix_vector (SC_TRANS, SC_NO_TRANS, SC_NO_TRANS, 1., A, X3, 0., Y4a);
sc_dmatrix_vector (SC_TRANS, SC_NO_TRANS, SC_NO_TRANS, 1., A, X3, 2., Y4a);
sc_dmatrix_vector (SC_TRANS, SC_NO_TRANS, SC_TRANS, 3., A, X3, 0., Y4b);
for (j = 0; j < 4; ++j) {
Y4b->e[0][j] -= Y4a->e[j][0];
}
sc_dmatrix_multiply (SC_TRANS, SC_NO_TRANS, 3., A, X3, -1., Y4a);
printf ("0 =\n");
sc_dmatrix_write (Y4a, stdout);
printf ("0 =\n");
sc_dmatrix_write (Y4b, stdout);
sc_dmatrix_destroy (A);
sc_dmatrix_destroy (X3);
sc_dmatrix_destroy (X4);
sc_dmatrix_destroy (Y3a);
sc_dmatrix_destroy (Y3b);
sc_dmatrix_destroy (Y4a);
sc_dmatrix_destroy (Y4b);
}
int
main (int argc, char **argv)
{
sc_MPI_Comm mpicomm;
int mpiret;
int mpisize, mpirank;
p4est_t *p4est;
p4est_connectivity_t *connectivity;
sc_dmatrix_t *vtkvec;
p4est_tree_t *tree;
sc_array_t *quadrants;
size_t zz, count;
p4est_quadrant_t *q;
int i;
#ifndef P4_TO_P8
char filename[] = "p4est_balance_face";
#else
char filename[] = "p8est_balance_edge";
#endif
p4est_vtk_context_t *context;
sc_array_t *level;
int retval;
/* initialize MPI */
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
mpicomm = sc_MPI_COMM_WORLD;
mpiret = sc_MPI_Comm_size (mpicomm, &mpisize);
SC_CHECK_MPI (mpiret);
mpiret = sc_MPI_Comm_rank (mpicomm, &mpirank);
SC_CHECK_MPI (mpiret);
sc_init (mpicomm, 1, 1, NULL, SC_LP_DEFAULT);
p4est_init (NULL, SC_LP_DEFAULT);
#ifndef P4_TO_P8
connectivity = p4est_connectivity_new_unitsquare ();
#else
connectivity = p8est_connectivity_new_unitcube ();
#endif
p4est = p4est_new_ext (mpicomm, connectivity, 0, 2, 1,
sizeof (balance_seeds_elem_t), init_fn, NULL);
p4est_refine (p4est, 1, refine_fn, init_fn);
context = p4est_vtk_context_new (p4est, filename);
p4est_vtk_context_set_scale (context, 1. - 2. * SC_EPS);
context = p4est_vtk_write_header (context);
SC_CHECK_ABORT (context != NULL, P4EST_STRING "_vtk: Error writing header");
vtkvec = sc_dmatrix_new (p4est->local_num_quadrants, P4EST_CHILDREN);
tree = p4est_tree_array_index (p4est->trees, 0);
quadrants = &(tree->quadrants);
count = quadrants->elem_count;
for (zz = 0; zz < count; zz++) {
q = p4est_quadrant_array_index (quadrants, zz);
for (i = 0; i < P4EST_CHILDREN; i++) {
vtkvec->e[zz][i] = (double)
((balance_seeds_elem_t *) (q->p.user_data))->flag;
}
}
level =
sc_array_new_data ((void *) vtkvec->e[0], sizeof (double),
count * P4EST_CHILDREN);
context =
p4est_vtk_write_point_dataf (context, 1, 0, "level", level, context);
SC_CHECK_ABORT (context != NULL,
P4EST_STRING "_vtk: Error writing point data");
sc_array_destroy (level);
retval = p4est_vtk_write_footer (context);
SC_CHECK_ABORT (!retval, P4EST_STRING "_vtk: Error writing footer");
sc_dmatrix_destroy (vtkvec);
p4est_destroy (p4est);
p4est_connectivity_destroy (connectivity);
sc_finalize ();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
int
main (int argc, char **argv)
{
sc_MPI_Comm mpicomm;
int mpiret, mpisize;
int retval, nargs;
int minpoints;
int d, p, n;
double x, y;
sc_dmatrix_t *points, *knots, *works;
sc_bspline_t *bs;
mpiret = sc_MPI_Init (&argc, &argv);
SC_CHECK_MPI (mpiret);
mpicomm = sc_MPI_COMM_WORLD;
sc_init (mpicomm, 1, 1, NULL, SC_LP_DEFAULT);
mpiret = sc_MPI_Comm_size (mpicomm, &mpisize);
SC_CHECK_MPI (mpiret);
if (mpisize != 1)
sc_abort_collective ("This program runs in serial only");
nargs = 2;
if (argc != nargs) {
SC_LERRORF ("Usage: %s <degree>\n", argv[0]);
SC_ABORT ("Usage error");
}
n = atoi (argv[1]);
SC_CHECK_ABORT (n >= 0, "Degree must be non-negative");
minpoints = sc_bspline_min_number_points (n);
SC_INFOF ("Degree %d will require at least %d points\n", n, minpoints);
d = 2;
points = sc_dmatrix_new (0, d);
p = -1;
for (;;) {
retval = scanf ("%lg %lg", &x, &y);
if (retval == d) {
++p;
sc_dmatrix_resize (points, p + 1, d);
points->e[p][0] = x;
points->e[p][1] = y;
}
else
break;
}
SC_CHECK_ABORT (p + 1 >= minpoints, "Not enough points");
SC_INFOF ("Points read %d\n", p + 1);
works = sc_bspline_workspace_new (n, d);
knots = sc_bspline_knots_new (n, points);
bs = sc_bspline_new (n, points, knots, works);
create_plot ("uniform", bs);
sc_bspline_destroy (bs);
sc_dmatrix_destroy (knots);
if (n > 0) {
knots = sc_bspline_knots_new_length (n, points);
bs = sc_bspline_new (n, points, knots, works);
create_plot ("length", bs);
check_derivatives (bs);
sc_bspline_destroy (bs);
sc_dmatrix_destroy (knots);
}
sc_dmatrix_destroy (works);
sc_dmatrix_destroy (points);
sc_finalize ();
mpiret = sc_MPI_Finalize ();
SC_CHECK_MPI (mpiret);
return 0;
}
