../ -- 1d_design.html

updated 2005-04-08

contents:

This is just my quick reference for series approximations and mathematical functions.

Similar information can be found in:

You'll probably find the above references more understandable.

Lots of technical mathematical things here. Bit sequences. DSP. Calculus. infinite series. Etc.

"Whatever Happened to Numbers?" by Robert W. Lucky _IEEE Spectrum_ March 1994 http://www.argreenhouse.com/papers/rlucky/spectrum/numbers.shtml says that numbers are over-emphasized in school. [FIXME: does this fit better over at bignums.html ?]

"Not everything that can be counted counts, and not everything that counts can be counted."

-- Albert Einstein

See also

function approximation

DAV is most interested in "simple" approximations: very quick methods that get you within an order-of-magnitude.

I'm also interesed in "functional software compression", so occasionally I start with a program that calculates things to very high precision, and mangle it until it *still* calculates things to just as high a precision, but it takes much less ROM space (or, in some cases, the source code is much shorter ).

[FIXME: cross-link to appropriate places in data_compression.html and machine_vision.html] [FIXME: seach for ``approx'' and ``math'' and gather appropriate stuff here]

paper sizes (aspect ratio)

"Postcard Dimensions: Each card (each stamped card or postcard or each half of a double stamped card or postcard) claimed at a card rate must be:

-- http://pe.usps.com/text/dmm300/101.htm#6_3_1

local.html#pmail mentions that First-Class envelopes weighing 1 ounce or less require an additional $0.12 nonmachinable surcharge if any one of the following apply ... The length divided by height is less than 1.3 or more than 2.5 ... -- http://postcalc.usps.gov/MailpieceDimensions.asp (That's about height 89 mm to 108 mm; length 127 to 152 mm, right?)

DAV: It is good that the "logical" European standard paper and envelope sizes, based on 2^(1/2) = 1.414... , is in this "1.3 to 2.5" range of aspects ratios. Hm... what of my favorite numbers can be coerced into that aspect ratio ? Note that normal TV / computer monitor ratio (4:3 = 1.333) is acceptable, as is movie theatre and HDTV widescreen (16:9 = 1.77).

The only ISO 216 size in the the post card range is A6 (105 x 148) (close to 4x6 index card 101 x 152). The B7 (88 x 125) is a couple mm too small, B6 (125x176) is too large. The C7 (81x114) is too small, C6 (114x162) is too large. See 43folders:Hipster_Variants#Postcard_PDA.

Some related simple fractions and their inverses:

digital codes

See

[FIXME: move to massmind ?]

external links:

circular numbers

[FIXME: move to massmind]

curve fitting tools

interpolation

See vlsi.html#arithmetic for more on interpolating sin() and cos().

[FIXME: aren't there better explaination elsewhere on the web ?]

basically from ``Educated Guessing Games'' article by Don Morgan in _Embedded Systems Programming_ 2002-03 talks about linear interpolation, the Lagrange interpolator, and briefly mentions Chebyshev polynomials. Promises future articles with other ``ways to increase the speed and accuracy of interpolation using relatively small tables''

(fixing a few typographic glitches in my paper copy of the magazine)

Many times we know the value of a function at a few selected points, and we want to interpolate.

Weierstrass's theorem: if x0, x1, x2, ... xn are distinct, then for any y0, y1, y2, ... yn there exists a unique polynomial of degree n or less such that

F(x[i]) == y[i], for i = 0,1,2,...,n.

(i.e., the unique polynomial of degree n that passes through n+1 data points).

We break that function down into parts

F(x) = F0(x) + F1(x) + F2(x) + ... + Fn(x)

where each part gives exactly one sample point -- F0(x[0]) = y[0], Fn(x[n]) = y[n], etc. -- but each function is exactly equal to 0 at all other sample points x[j].

First define a polynomial that is zero for all sample points except one. In other words,

fi(x[j]) == 0, for j = 0,1,2,...,n except for i=j.

That polynomial is

fi(x) = Π(j = 0 to n; except for j=i)( x - x[j] );

At the point where x = x[i], that polynomial equals the value

fi(x[i]) = Π(j = 0 to n; except for j=i)( x[i] - x[j] );

We use this value to normalize the polynomial to give us exactly y[i] at x = x[i]:

Fi(x) = fi(x) / fi(x[i]) = Π(j = 0 to n; except for j=i)( ( x - x[j] ) / ( x[i] - x[j] ) ); 


#define n 10
WARNING: untested code

float x[n] = { .... }; // sample locations
float y[n] = { .... }; // sample values

float evaluate_lagrange( float t ){
	float sum = 0;
	for( i = 0; i < n; i++){
		float product = 1.0;
		for( j = 0; j < n; j++){
			if( i != j){
				product *= (t - x[j]) / (x[i] - x[j]);
			}
		}
		sum += product * y[i];
	}
	return(sum);
}

If we pre-calculate the intermediate products, this can run very fast. 


#define n 10
WARNING: untested code

float x[n] = { .... };
float g[n] = { .... }; // pre-computed intermediate products

float evaluate_lagrange( float t ){
	float sum = 0;
	for( i = 0; i < n; i++){
		float product = 1.0;
		for( j = 0; j < n; j++){
			if( i != j){
				product *= t - x[j];
			}
		}
		sum += product * g[i];
	}
	return(sum);
}

This gives n*n multiplies per evaluation.

fixed point function library; floating point function library; trig library

How to implement floating point multiplies, the sin() function, etc. Also has some information on "fixed point", which runs much faster than "floating point" on *some* hardware.

logarithm

fixed point logarithm for PIC. ; Input: xhi:xlo unsigned Q0.16 (modified) ; Output: x2hi:x2lo unsigned Q6.10 (implicit minus) i.e., 0 <= x < 1. http://www.piclist.com/techref/microchip/math/power/16lr-ng.htm Reduces range to 1/2 <= x < 1 then uses interpolated lookup table (17 values, 10 bit numbers). 8-bit logarithm algorithm PIC assembly source code http://www.dattalo.com/technical/software/pic/piclog.html "based on a table look-up plus first order interpolation"

Logarithms by Scott Dattalo Here's a collection of different ways to compute logarithms. http://www.dattalo.com/technical/theory/logs.html

Here's a completely different approach I've been thinking about for approximating ln(x) for large integers: since ln(x)-ln(x-1) is very roughly equal to 1/x for large x (... perhaps closer to 1/(x-1/2) = 2/(2x-1) ...) and ln(2*x) = ln(2) + ln(x), maybe it would be simple to do this: 

  float ln( unsigned int x ){

	const float ln2 = log(2);
	int powers_of_2 = 0;
	float sum = 0;


	while( 2 <= x ){

		if( x & 1 ){
			sum += 1.0 / (float)x ;
		};
		x = x >> 1;
		powers_of_2++;
	};
	return( ln2 * powers_of_2 + sum );
  }

or perhaps 

  float ln( unsigned int x ){

	const float ln2 = log(2);
	int powers_of_2 = 0;
	float sum = 0;


	while( 2 <= x ){

		if( 1 == (x & 3) ){
			sum += 1.0 / (float)x ;
			x-- ;
		};

		if( x && 1 ){
			sum -= 1.0 / (float)x ;
			x++;
		};
			

		x = x >> 1;
		powers_of_2++;
	};
	return( ln2 * powers_of_2 + sum );
  }

Hey, it gives exactly the correct answer for x = 1 and x = 2, and in fact all x = 2^n where n is a positive integer.

trig functions

arctan

ways to compute arctan, a trig function

There are a few more methods over at #trig .

integer math libraries

correlation

[FIXME: I had a brief description of the difference between simple correlation, normalized correlation, and the dot product ... Put it online here. Or, if the Mathworld description is better, just point there. ]

continued fractions

[FIXME: gather stuff I have scattered around here on this topic ...]

HAKMEM

HAKMEM

lots of fun mathematical tips and tricks ... mixed in with obsolete information. [FIXME: link to "processor agnostic"] [FIXME: fix links from other pages to #hakmem]

cubic curves (Bezier, etc.) 



[1d design ... or Visual:graphics_algorithms]
Bezier splines (cubic curves)
t ranges from 0 to +1.
x(t) = a3*t^3 + a2*t^2 + a1*t + a0
y(t) = b3*t^3 + b2*t^2 + b1*t + b0
u ranges from -1 to +1 ("symmetric cubic spline").
x(u) = c3*u^3 + c2*u^2 + c1*u + c0
y(u) = d3*u^3 + d2*u^2 + d1*u + d0
(so dx(u)/du = x'(u) = 3*c3*u^2 + 2*c2*u + c1).

The curve's initial direction from point x0,y0
starts heading directly towards the first "handle" x1,y1 ... and final direction as it hits the last point
x3,y3 is directly along the line from the second "handle" x2,y2 to x3,y3.
In equations,
we want endpoints x0, x3:
x(-1) = x0
x(+1) = x3
and we want the curve from x0 to initially head directly to x1 (in 2d), and the final directly as it hits x3 to come 
from x2 (see above):
x'(-1) = ( x1 - x0 )*3/2 = K*(x7-x0)*3/2
x'(+1) = ( x3 - x2 )*3/2 = K*(x3-x8)*3/2
It seems I could *arbitrarily* choose some constant K ...
or in other words, I can *arbitrarily* pick guide points along the line
x7 = x0 + (x1-x0)/K.
(where x7 is my "new" guide point, x1 is PostScript / Lancaster's "traditional" guide point).
(which implies
    x1 = K*x7 + (1 - K)*x0
    x2 = K*x8 + (1 - k)*x3
).
Some possible ways to pick K:
* pick K so that the midpoint of the curve (t=1/2, u=0) is centered on the line between the new guide points. (I think 
this makes recursive bezier drawing a bit faster).
* pick K so that the slope at the midpoint (c1) is exactly the same as the slope between x7 and x8. (I think this makes 
recursive bezier drawing a bit faster).
* pick K so that when guide points coincide, I get a parabola.
* pick K to make math "simple" ...
* pick K "small enough" so the curve lives inside the (convex hull) bounding box of the 4 points. (If K is too large, 
x7 is so close to x0 that the curve pokes outside the x0,x7,x8,x3 bounding box).
* ... ?

Choosing K:

....
If we then add the constraint that
force x(u=0) = c0 to equal (x8 + x7)/2,
then we find
  c0 = ( x3 + 3*x2 + 3*x1 + x0 )/8
     = ( x3 + 3*(K*x8 + (1 - k)*x3) + 3*(K*x7 + (1 - K)*x0) + x0 )/8
     = ( (4-3*K)*x3 + 3*K*x8 + 3*K*x7 + (4 - 3*K)*x0 )/8
...
so we force (4-3*K) = 0 by setting
  K = 4/3
so now
  c0 = ( x8 + x7 ) / 2.
This curve is not contained in the (convex hull) bounding box of x0,x7,x8,x3. But maybe that's OK.

Choosing K:

If choose a different constraint,
the constraint that the *slope* at the midpoint
depends only on the guide points x7 and x8 (i.e., the curve, at the midpoint,
is exactly tangent to the line between the guide points ...
the curve midpoint touches that line, but often *not*
exactly centered between x7 and x8), then
dx/du at (u=0) = c1 = ( x3 +   x2 -   x1 - x0 )*3/8 ; slope at midpoint
....
	K = 2
	x7 = x0 + (x1-x0)/K.
This seems to imply that if those x7 and x8 guide points *touch*,
i.e., if the traditional guide points make a perfect rectangle,
  x2   x1
  
  x0   x3
, then there will be "no" slope at the midpoint,
i.e., that's how to make a singularity (cusp) at the midpoint.


Choosing K:
I think
that the *closest* the bezier curve *ever* gets to the line
between x1 and x2
is 1/4 the distance between x0 and x1,
or 1/4 the distance between x2 and x3, whichever is smaller,
assuming that x0 and x3 are both on the same side of the x1-x2 line.
So I could choose
	K=4/3
	x7 = x0 + (x1-x0)/K.
and the bezeir curve would still always fall
in the x0,x7,x8,x3 bounding box. I think.





What are the max and min values of x(u) ?
Since it is a polynomial, it is *either*
* at the endpoints of the curve, *or*
* where x'(u) = 3*c3*u^2 + 2*c2*u + c1 = 0,
The second case occurs
where (if 0 == c3) u = -c1/(2*c2), or
where (if 0 != c3) u = ( -2*c2 +- ( (2*c2)^2 - 4*3*c3*c1 )^1/2 ) / (6*c3),
and -1 < u < +1.




t equation space to graph space:
x0 = a0
x1 = a0 + a1/3
midpoint = a3/8 + a2/4 + a1/2 + a0
x2 = a0 + a1*2/3 + a2/3
x3 = a0 + a1 + a2 + a3.

u equation space to graph space:
x0 = -c3 + c2 -   c1   + c0
x1 =  c3 - c2/3 - c1/3 + c0
midpoint = c0
x2 = ...
x3 =  c3 + c2 +   c1   + c0


graph space to t equation space:
a0 = x0  ; starting point
a1 = 3*( x1 - x0 ) ; initial slope. clearly this must be some K*( x1 - x0 ) to get the proper initial trajectory, but 
why K=3 ?
a2 = (x2 - 2*x1 + x0)*3 ; initial curvature
a3 = x3 - 3*x2 + 3*x1 - x0.

graph space to u equation space:
c0 = ( x3 + 3*x2 + 3*x1 + x0 )/8 ; midpoint  = (x3+x0)/2 - a2
c1 = ( x3 +   x2 -   x1 - x0 )*3/8 ; curvature at midpoint = (x3-x0)/2 - a3
c2 = ( x3 -   x2 -   x1 + x0 )*3/8
c3 = ( x3 - 3*x2 + 3*x1 - x0 )/8

u equation space to t equation space:
t = (u+1)/2
a3 =   8*c3
a2 = -12*c3 + 4*c2
a1 =   6*c3 - 4*c2 + 2*c1
a0 =    -c3 +   c2 -   c1 + c0

t equation space to u equation space:
u = 2*t - 1
c3 = a3/8
c2 = a3*3/8 + a2*1/4
c1 = a3*3/8 + a2*1/2 + a1*1/2 ; slope at midpoint
c0 = a3*1/8 + a2*1/4 + a1*1/2 + a0 ; location of midpoint

In terms of the control points,
x(t) = (x3 - 3*x2 + 3*x1 - x0)*t^3 + (3*x2 - 6*x1 + 3*x0)*t^2 + (3*x1 - 3*x0)*t + x0

By inspection, we get a perfect "vertical" parabola by making
x = a1*t + a0
y = b2*t^2 + b1*t + b0
i.e., we force all the high-order terms to zero.
In the case of y, we force the cubic term ( b3) to zero: = 0 = y3 - 3*y2 + 3*y1 - y0, or in other words,
the length 
y3-y0 is exactly three times the length of y2-y1.
To force the parabolic term (a2) to zero: 0 = x2 - 2*x1 + x0,
or in other words,
the length x2-x1 exactly equals the length x1-x0.
To force the parabolic term (c2) to zero: 0 = x3 -   x2 -   x1 + x0,
the length x1-x0 exactly equals the length x3-x2.
In the case of x, we set them both to zero, or in other words,
x3, x2, x1, x0 are precisely evenly spaced apart.
Clearly every point of this "bezier" curve exactly touches the parabola -- but
is the reverse true: if we force the t=0, t=1/3, t=2/3, t=1 points to go through
randomly selected points on some parabola
(even if they are not precisely evenly spaced apart in the x direction), will 
that bezier curve still be parabolic ?
I'm pretty sure that if we take 4 randomly selected points on some straight line
(not necessarily horizontal or vertical), the bezier curve *will* stay on that straight line.

Another form of the same equation:
x(t) = t*(x3) + (1-t)*(x0) + t*(1-t)*(...) = t*x3 + (1-t)*( t*(...) + x0 )
x(t) = t*(x3) + (1-t)*(x0) + t*(1-t)*( a3*t + U4 ) = t*x3 + (1-t)*( t*( a3*t + U4 ) + x0 )
This has exactly the same number of multiplies ... might even be faster
on architectures where t*a + (1-t)*b ("twist") is faster than 2 independent multiplies.


x(t) = t*(x3) + (1-t)*(x0) + t*(1-t)*(p(t)) = t*x3 + (1-t)*( t*(p(t)) + x0 )
forces the curve to hit the endpoints, while p(t) gives the shape of the curve between the endpoints.
various expressions for p(t):
k3*t + k2 ...
k3*(t-1/2) + k2 : ~height of midpoint (from the x0-x3 line) and slope at midpoint
k3*t + (1-t)*k2 : ~slopes at t=0 and t=1.



At the endpoints of the curve,
x(t=0) = x(u=-1) = x0
x(t=1) = x(u=+1) = x3.
dx/dt at (t=0) = a1 = ( x1 - x0 )*3
dx/dt at (t=1) =      ( x3 - x2 )*3
dx/du at (u=-1) = 3*c3-2*c2+c1 = ( x1 - x0 )*3/2
dx/du at (u=+1) = 3*c3+2*c2+c1 = ( x3 - x2 )*3/2


At the "midpoint" of the curve, where t=1/2, u=0,
x(t=1/2) = x(u=0) = c0 = ( x3 + 3*x2 + 3*x1 + x0)/8.
dx/dt at (t=1/2) = ( x3 + x2 - x1 - x0 )*3/4  (slope at midpoint)
dx/du at (u=0) = c1 = ( x3 +   x2 -   x1 - x0 )*3/8  (slope at midpoint)

(At every point in the curve,
the slope in term of u is only half the slope in terms of t, because it must climb the 
entire curve in only half the time (1 unit) with the t formulation,
compared to the (2 units) u formulation).


We get a "cusp" when dx/dt = 0 *and* dy/dt = 0.
Most splines do not have a cusp.
The cusp may be located anywhere along the spline, not just at the midpoint.

The 1/3 points:
x(t=1/3) = x(u=-1/3) = ( x3 + 6*x2 + 12*x1 + 8*x0 )/27
dx/dt at (t=1/3) = ( x3 + 3*x2 + 0*x1 - 4*x0 )/3 = (x3-x0)/3 + (x2-x0).
x(t=2/3) = x(u=+1/3) = ( 8*x3 + 12*x2 + 6*x1 + x0 )/27
dx/dt at (t=2/3) = ( 4*x3 + 0*x2 - 3*x1 - x0 )/3 = (x3-x0)/3 + (x3-x1).

Are the quarter-points interesting ?


to fully define a cubic curve (just the x(u) of the bezier curve) requires 4 numbers:
 - a0, a1, a2, a3 of the formula (one endpoint and the velocity, acceleration, and jerk).
 - endpoints x0, x1, and slope at endpoints (x1-x0), (x3-x2).
 - go through 4 given points x0, x7, x8, x3.
 - endpoints x0, x1, midpoint xm, and ... something else.




Is it possible to adjust K so that x4, x5 uniquely guide the curve,
*and* have the midpoint of the curve exactly hit (x4+x5)/2 ???

formula for length of the curve (or at least upper and lower bounds) ???

What "interesting" points lie on or near the Bezier curve ?

How to approximate circle/ellipse with bezier curves ? What is worst-case error ?
circles:
x^2 + y^2 = r^2
y = ( r^2 - x^2)^(1/2)
or
x = sin(A), y=cos(A).


How to approximate parabola with bezier curve ? (there is zero error ...
focus ... line ...)

How to approximate hyperbola with bezier curve ?

How to approximate exponential / logarithm curves with bezier ?

To approximate *any* curve given only the points ... given the points and slopes ...

How to recursively draw bezier ???




To force bezier *through* a bunch of points,
collect in groups of 4:
0th curve goes through x0, x1, x2, x3
1st curve goes through x3, x4, x5, x6
2nd curve goes through x6, x7, x8, x9
... etc.
(This method gives the odd effect of a cusp at x0, x3, x6, x9, etc. but smooth curves through the other points ...
is there a better way ?)
(yes -- see tinyboot article above)


To force a bezier *through* 4 points:
x(t=0) = x(u=-1) = x6
x(t=1/3) = x(u=-1/3) = x7
x(t=2/3) = x(u=+1/3) = x8
x(t=1) = x(u=+1) = x9
In terms of t:
a0 = x6
a1 = (-11*x6 + 18*x7 - 9*x8 + 2*x9 )/2
a2 = (  2*x6 -  5*x7 + 4*x8 -   x9 )*9/2
a3 = (   -x6 +  3*x7 - 3*x8 +   x9 )*9/2
In terms of u:
b3 = ( -x6 +  3*x7 -  3*x8 + x9 )*9/16
b2 = ( +x6 -    x7 -    x8 + x9 )*9/16
b1 = ( +x6 - 27*x7 + 27*x8 - x9 )/16
b0 = ( -x6 +  9*x7 +  9*x8 - x9 )/16



To approximate circle ... can't be done exactly.
1. break up curve into pieces.
2. approximate each piece with bezier, matching endpoints and slopes.
For any small piece of the circle (arc),
we can set the endpoints of the bezier to the endpoints of the arc,
and the guide points along a line tangent to the circle...
by symmetry, it seems best for both tangent lines to have the same length -- but how long ?
Some ways to pick a length:
* adjust so midpoint of bezier actually does intersect/touch/tangent the midpoint of the arc
* adjust so *curvature* at endpoints is correct (this is more-or-less the "smooth" option of the tinyboot cubic approximation to sin)
* adjust so *curvature* at midpoint is correct
* adjust so -1,-1/3,+1/3,+1 points of curve all touch the circle (is it possible to do this *and*
keep tangent at endpoints ?
Alas, no -- this is the "more accurate, less smooth" option of the tinyboot cubic approximation to sin)
....
adjust so midpoint of bezier actually does intersect/touch/tangent the midpoint of the arc:
to approximate upper-right quarter-circle with center of circle at 0,0,
use points
p0 = r,0
p1 = r, r*(4/3)( 3*2^(1/2) - 1 ) =~= r, r*(0.55228)
p2 = r*(4/3)( 3*2^(1/2) - 1 ), r
p3 = 0,r

to approximate bottom quarter-circle with center of circle at 0,0,
use points
p0 = -r / 2^(1/2), -r / 2^(1/2)
p1 =  , -r*( 4 - 1/2^(1/2) )/3 =~= , -r*(1.0976)
...


recursive spline drawing:
// draw spline ending at points p0 and p3, using guide points p1 and p2.
drawspline( p0, p1, p2, p3){
  // this works for p0 in 1D, 2D, 3D, etc.

  Are points "close enough together" ? then draw pixels / lines / parabolas.
  (Checking just p0 and p3 isn't enough -- sometimes p0 and p3 are on the *same* pixel,
  yet the guide points stretch the spline out into a big loop.)
  ... and return.

  Optional: Are p0, p1, p2, p3 close enough to a straight line ? Then draw a straight line and return.

  else:

  Calculate new midpoint pm:
    pm = p(t=1/2) = p(u=0) = ( p3 + 3*p2 + 3*p1 + p0 )/8.
    /*  with different K, we could just do (p2 + p1)/2. */
  Calculate offset of new guide points from new midpoint:
    d = ( p3 + p2 - p1 - p0 )/8    /*  x'(t=1/2) = ( x3 + x2 - x1 - x0 )*3/4  */
  calculate new guide point for right curve:
    p_right = pm + d               /*  x'(t=0) = ( x1 - x0 )*3, so x1 = x0 + x'(t=0)/3   */
  Calculate new guide point for left curve:
    p_left = pm - d
  recursion:
    /* to limit recursion depth, do the *smallest* one first. */
    drawspline( p0, (p0+p1)/2, p_left, pm);
    drawspline( pm, p_right, (p2+p3)/2, p3);
}


(How does this compare to the 
deCasteljau Algorithm
?
Cox de Boor recursive algorithm
?)

----

Part I: Splines http://www.cg.inf.ethz.ch/~pauly/CGC/PartI.pdf instead defines cubic curves this way:

... x(t) = b0*(1-t)^3 + 3*b1*t*(1-t)^2 + 3*b2*t^2*(1-t) + b3*t^3 Coefficients b0,...,bn are called Bezier points or control points. Set of control points defines the so-called control polygon.

Properties of Bezier-Curves:

* Affine invariance: Affine transform of all points of on the curve can be computed by the affine transform of its control points.

* Convex hull property: The curve lies in the convex hull of its control polygon. ...

Keeps mentioning a "Java Applet". Where is it ? 

----

"Explorations in
Geometric Modeling:
Parametric Curves and Surfaces"
by Kenny Hoff
COMP236 Final Project
Spring 1996
http://www.cs.unc.edu/~hoff/projects/comp236/curves/
...
includes
"Derivation of Incremental Forward-Difference Algorithm for Cubic Bezier Curves using the Taylor Series Expansion for 
Polynomial Approximation",
"Derivation of 3D Rational Curves", and
"C++ Source Code"

(# Bezier curves

    * Direct evaluation using Bernstein polynomials (with coefficient lookup tables)
    * Recursive subdivision
    * Forward-differencing (using matrix simplification)
)
(Cox de Boor recursive algorithm)

----

"De Boor's algorithm is a generalization of de Casteljau's algorithm.
It provides a fast and numerically stable way for 
finding a point on a B-spline curve given a u in the domain."
http://www.cs.mtu.edu/~shene/COURSES/cs3621/NOTES/spline/B-spline/de-Boor.html

"B-spline curves share many important properties with Bézier curves, because the former is a generalization of the 
later."
http://www.cs.mtu.edu/~shene/COURSES/cs3621/NOTES/spline/bspline-curve-prop.html
http://www.cs.mtu.edu/~shene/COURSES/cs3621/NOTES/spline/

unsorted

2002-07-25:DAV: David Cary started.

Send comments, suggestions, errors ,

errors , bug reports to

David Cary feedback.html
d.cary@ieee.org.

Return to index // end http://david.carybros.com/html/1d_design.html