static void
p4est_wrap_partition_unchanged (p4est_gloidx_t pre_me,
p4est_gloidx_t pre_next,
p4est_gloidx_t post_me,
p4est_gloidx_t post_next,
p4est_locidx_t * unchanged_first,
p4est_locidx_t * unchanged_length,
p4est_locidx_t * unchanged_old_first)
{
p4est_locidx_t uf, ul, uof;
p4est_gloidx_t unext;
/* consistency checks */
P4EST_ASSERT (0 <= pre_me && pre_me <= pre_next);
P4EST_ASSERT (0 <= post_me && post_me <= post_next);
/* initialize the case that no quadrants stay on this processor */
uf = ul = uof = 0;
/* check whether any quadrants stay at all, and which ones */
if (pre_me < post_next && post_me < pre_next) {
unext = SC_MIN (pre_next, post_next);
if (pre_me <= post_me) {
uof = (p4est_locidx_t) (post_me - pre_me);
ul = (p4est_locidx_t) (unext - post_me);
}
else {
uf = (p4est_locidx_t) (pre_me - post_me);
ul = (p4est_locidx_t) (unext - pre_me);
}
}
/* consistency checks */
P4EST_ASSERT (uf >= 0 && ul >= 0 && uof >= 0);
P4EST_ASSERT ((p4est_gloidx_t) uf + ul <= post_next - post_me);
P4EST_ASSERT ((p4est_gloidx_t) uof + ul <= pre_next - pre_me);
/* assign to output variables */
if (unchanged_first != NULL) {
*unchanged_first = uf;
}
if (unchanged_length != NULL) {
*unchanged_length = ul;
}
if (unchanged_old_first != NULL) {
*unchanged_old_first = uof;
}
}
int
sc_vtk_write_binary (FILE * vtkfile, char *numeric_data, size_t byte_length)
{
size_t chunks, chunksize, remaining, writenow;
size_t code_length, base_length;
uint32_t int_header;
char *base_data;
base64_encodestate encode_state;
/* VTK format used 32bit header info */
SC_ASSERT (byte_length <= (size_t) UINT32_MAX);
chunksize = (size_t) 1 << 15; /* 32768 */
int_header = (uint32_t) byte_length;
code_length = 2 * chunksize;
base_data = SC_ALLOC (char, code_length);
base64_init_encodestate (&encode_state);
base_length =
base64_encode_block ((char *) &int_header, sizeof (int_header), base_data,
&encode_state);
base_data[base_length] = '\0';
(void) fwrite (base_data, 1, base_length, vtkfile);
chunks = 0;
remaining = byte_length;
while (remaining > 0) {
writenow = SC_MIN (remaining, chunksize);
base_length = base64_encode_block (numeric_data + chunks * chunksize,
writenow, base_data, &encode_state);
base_data[base_length] = '\0';
SC_ASSERT (base_length < code_length);
(void) fwrite (base_data, 1, base_length, vtkfile);
remaining -= writenow;
++chunks;
}
base_length = base64_encode_blockend (base_data, &encode_state);
(void) fwrite (base_data, 1, base_length, vtkfile);
SC_FREE (base_data);
if (ferror (vtkfile)) {
return -1;
}
return 0;
}
static void *
sc_realloc_aligned (void *ptr, size_t alignment, size_t size)
{
/* minimum requirements on alignment */
SC_ASSERT (sizeof (char **) == sizeof (void *));
SC_ASSERT (sizeof (char **) >= sizeof (size_t));
SC_ASSERT (alignment > 0 && alignment % sizeof (void *) == 0);
SC_ASSERT (alignment == SC_MEMALIGN_BYTES);
#if defined SC_HAVE_ANY_MEMALIGN && \
(defined SC_HAVE_POSIX_MEMALIGN || defined SC_HAVE_ALIGNED_ALLOC)
/* the result is no longer aligned */
return realloc (ptr, size);
#else
{
#ifdef SC_ENABLE_DEBUG
const ptrdiff_t signalign = (const ptrdiff_t) alignment;
#endif
size_t old_size, min_size;
void *new_ptr;
/* we excluded these cases earlier */
SC_ASSERT (ptr != NULL && size > 0);
SC_ASSERT ((ptrdiff_t) ptr % signalign == 0);
/* back out the previously allocated size */
old_size = (size_t) ((char **) ptr)[-2];
/* create new memory while the old memory is still around */
new_ptr = sc_malloc_aligned (alignment, size);
/* copy data */
min_size = SC_MIN (old_size, size);
memcpy (new_ptr, ptr, min_size);
#ifdef SC_ENABLE_DEBUG
memset ((char *) new_ptr + min_size, -3, size - min_size);
#endif
/* free old memory and return new pointer */
sc_free_aligned (ptr, alignment);
return new_ptr;
}
#endif
}
static void
check_linear_id (const p4est_quadrant_t * q1, const p4est_quadrant_t * q2)
{
int l;
int comp = p4est_quadrant_compare (q1, q2);
int level = (int) SC_MIN (q1->level, q2->level);
uint64_t id1 = p4est_quadrant_linear_id (q1, level);
uint64_t id2 = p4est_quadrant_linear_id (q2, level);
p4est_quadrant_t quad, par, anc;
/* test linear id */
if (p4est_quadrant_is_ancestor (q1, q2)) {
SC_CHECK_ABORT (id1 == id2 && comp < 0, "Ancestor 1");
}
else if (p4est_quadrant_is_ancestor (q2, q1)) {
SC_CHECK_ABORT (id1 == id2 && comp > 0, "Ancestor 2");
}
else {
SC_CHECK_ABORT ((comp == 0 && id1 == id2) || (comp < 0 && id1 < id2)
|| (comp > 0 && id1 > id2), "compare");
}
/* test ancestor and parent functions */
par = quad = *q1;
for (l = quad.level - 1; l >= 0; --l) {
p4est_quadrant_parent (&par, &par);
p4est_quadrant_ancestor (&quad, l, &anc);
SC_CHECK_ABORT (p4est_quadrant_is_equal (&par, &anc), "Ancestor test A");
}
par = quad = *q2;
for (l = quad.level - 1; l >= 0; --l) {
p4est_quadrant_parent (&par, &par);
p4est_quadrant_ancestor (&quad, l, &anc);
SC_CHECK_ABORT (p4est_quadrant_is_equal (&par, &anc), "Ancestor test B");
}
}
static int
sc_bspline_find_interval (sc_bspline_t * bs, double t)
{
int i, iguess;
double t0, t1;
const double *knotse = bs->knots->e[0];
t0 = knotse[bs->n];
t1 = knotse[bs->n + bs->l];
SC_ASSERT (t >= t0 && t <= t1);
SC_ASSERT (bs->cacheknot >= bs->n && bs->cacheknot < bs->n + bs->l);
if (t >= t1) {
iguess = bs->cacheknot = bs->n + bs->l - 1;
}
else if (knotse[bs->cacheknot] <= t && t < knotse[bs->cacheknot + 1]) {
iguess = bs->cacheknot;
}
else {
const int nshift = 1;
int ileft, iright;
double tleft, tright;
ileft = bs->n;
iright = bs->n + bs->l - 1;
iguess = bs->n + (int) floor ((t - t0) / (t1 - t0) * bs->l);
iguess = SC_MAX (iguess, ileft);
iguess = SC_MIN (iguess, iright);
for (i = 0;; ++i) {
tleft = knotse[iguess];
tright = knotse[iguess + 1];
if (t < tleft) {
iright = iguess - 1;
if (i < nshift) {
iguess = iright;
}
else {
iguess = (ileft + iright + 1) / 2;
}
}
else if (t >= tright) {
ileft = iguess + 1;
if (i < nshift) {
iguess = ileft;
}
else {
iguess = (ileft + iright) / 2;
}
}
else {
if (i > 0) {
SC_LDEBUGF ("For %g needed %d search steps\n", t, i);
}
break;
}
}
bs->cacheknot = iguess;
}
SC_ASSERT (iguess >= bs->n && iguess < bs->n + bs->l);
SC_CHECK_ABORT ((knotse[iguess] <= t && t < knotse[iguess + 1]) ||
(t >= t1 && iguess == bs->n + bs->l - 1),
"Bug in sc_bspline_find_interval");
return iguess;
}
