Exemple #1
0
/* Return digit value or negative if not digit. Only decimal is
 * supported for now. This also fixes the base of the status iff it is
 * unset. There is no guarantee that this is called only once so the
 * code here has to be consistant. */
int digit(char c, struct number_reader* n)
{
    if ( n ) {
	if (n->base == 0) n->base = 10;

	if (c == '#') {
	    if (n->value > 0) {
		n->base = n->value;
		n->value = 0;
		return 0;
	    } else {
		return -1;
	    }
	}
    }

    if (c <= '0' + AMIN(n->base, 9) && c >= '0') return c - (int)'0';
    else if (c >= 'a' && c < 'a' + AMIN('z'-'a',n->base-9) + 1) return c - 'a' + 10;
    return -1;
}
Exemple #2
0
struct oslo_mat *
rt_nurb_calc_oslo(register int order, register const struct knot_vector *tau_kv, register struct knot_vector *t_kv, struct resource *res)

    /* old knot vector */
    /* new knot vector */

{
    register fastf_t	*t_p;
    register const fastf_t	*tau_p;
    fastf_t ah[20];
    fastf_t newknots[20];			/* new knots */
    register int  j;			/* d(j), j = 0 : # of new ctl points */
    int     mu,				/* mu:  tau[mu] <= t[j] < tau[mu+1]*/
	muprim,
	v,				/* Nu value (order of matrix) */
	p,
	iu,				/* upper bound loop counter */
	il,				/* lower bound loop counter */
	ih,
	n1;				/* upper bound of t knot vector - order*/

    fastf_t tj;

    struct oslo_mat * head, * o_ptr, *new_o;

    n1 = t_kv->k_size - order;

    t_p = t_kv->knots;
    tau_p = tau_kv->knots;

    mu = 0;				/* initialize mu */

    head = (struct oslo_mat *) bu_malloc (
	sizeof( struct oslo_mat),
	"rt_nurb_calc_oslo: oslo mat head" );

    o_ptr = head;

    for (j = 0; j < n1; j++) {
	register int  i;

	if ( j != 0 )
	{
	    new_o = (struct oslo_mat *) bu_malloc (
		sizeof( struct oslo_mat),
		"rt_nurb_calc_oslo: oslo mat struct" );

	    o_ptr->next = new_o;
	    o_ptr = new_o;
	}

	/* find the bounding mu */
	while (tau_p[mu + 1] <= t_p[j]) mu++;

	muprim = mu;

	i = j + 1;

	while ((t_p[i] == tau_p[muprim]) && i < (j + order)) {
	    i++;
	    muprim--;
	}

	ih = muprim + 1;

	for (v = 0, p = 1; p < order; p++) {
	    if (t_p[j + p] == tau_p[ih])
		ih++;
	    else
		newknots[++v - 1] = t_p[j + p];
	}

	ah[order-1] = 1.0;

	for (p = 1; p <= v; p++) {

	    fastf_t beta1;
	    int o_m;

	    beta1 = 0.0;
	    o_m = order - muprim;

	    tj = newknots[p-1];

	    if (p > muprim) {
		beta1 = ah[o_m];
		beta1 = ((tj - tau_p[0]) * beta1) /
		    (tau_p[p + order - v] - tau_p[0]);
	    }
	    i = muprim - p + 1;
	    il = AMAX (1, i);
	    i = n1 - 1 + v - p;
	    iu = AMIN (muprim, i);

	    for (i = il; i <= iu; i++) {
		fastf_t d1, d2;
		fastf_t beta;

		d1 = tj - tau_p[i];
		d2 = tau_p[i + p + order - v - 1] - tj;

		beta = ah[i + o_m - 1] / (d1 + d2);

		ah[i + o_m - 2] = d2 * beta + beta1;
		beta1 = d1 * beta;
	    }

	    ah[iu + o_m - 1] = beta1;

	    if (iu < muprim) {
		register fastf_t kkk;
		register fastf_t ahv;

		kkk = tau_p[n1 - 1 + order];
		ahv = ah[iu + o_m];
		ah[iu + o_m - 1] =
		    beta1 + (kkk - tj) *
		    ahv / (kkk - tau_p[iu + 1]);
	    }
	}

	o_ptr->o_vec = (fastf_t *) bu_malloc ( sizeof( fastf_t) * (v+1),
					       "rt_nurb_calc_oslo: oslo vector");

	o_ptr->offset = AMAX(muprim -v, 0);
	o_ptr->osize = v;

	for ( i = v, p = 0; i >= 0; i--)
	    o_ptr->o_vec[p++] =  ah[(order-1) - i];
    }

    o_ptr->next = (struct oslo_mat*) 0;
    return head;
}