def splrep(x,
y,
w=None,
xb=None,
xe=None,
k=3,
task=0,
s=None,
t=None,
full_output=0,
per=0,
quiet=1):
"""Find the B-spline representation of 1-D curve.
Description:
Given the set of data points (x[i], y[i]) determine a smooth spline
approximation of degree k on the interval xb <= x <= xe. The coefficients,
c, and the knot points, t, are returned. Uses the FORTRAN routine
curfit from FITPACK.
Inputs:
x, y -- The data points defining a curve y = f(x).
w -- Strictly positive rank-1 array of weights the same length as x and y.
The weights are used in computing the weighted least-squares spline
fit. If the errors in the y values have standard-deviation given by the
vector d, then w should be 1/d. Default is ones(len(x)).
xb, xe -- The interval to fit. If None, these default to x[0] and x[-1]
respectively.
k -- The order of the spline fit. It is recommended to use cubic splines.
Even order splines should be avoided especially with small s values.
1 <= k <= 5
task -- If task==0 find t and c for a given smoothing factor, s.
If task==1 find t and c for another value of the
smoothing factor, s. There must have been a previous
call with task=0 or task=1 for the same set of data
(t will be stored an used internally)
If task=-1 find the weighted least square spline for
a given set of knots, t. These should be interior knots
as knots on the ends will be added automatically.
s -- A smoothing condition. The amount of smoothness is determined by
satisfying the conditions: sum((w * (y - g))**2,axis=0) <= s where
g(x) is the smoothed interpolation of (x,y). The user can use s to
control the tradeoff between closeness and smoothness of fit. Larger
s means more smoothing while smaller values of s indicate less
smoothing. Recommended values of s depend on the weights, w. If the
weights represent the inverse of the standard-deviation of y, then a
good s value should be found in the range (m-sqrt(2*m),m+sqrt(2*m))
where m is the number of datapoints in x, y, and w.
default : s=m-sqrt(2*m) if weights are supplied.
s = 0.0 (interpolating) if no weights are supplied.
t -- The knots needed for task=-1. If given then task is automatically
set to -1.
full_output -- If non-zero, then return optional outputs.
per -- If non-zero, data points are considered periodic with period
x[m-1] - x[0] and a smooth periodic spline approximation is returned.
Values of y[m-1] and w[m-1] are not used.
quiet -- Non-zero to suppress messages.
Outputs: (tck, {fp, ier, msg})
tck -- (t,c,k) a tuple containing the vector of knots, the B-spline
coefficients, and the degree of the spline.
fp -- The weighted sum of squared residuals of the spline approximation.
ier -- An integer flag about splrep success. Success is indicated if
ier<=0. If ier in [1,2,3] an error occurred but was not raised.
Otherwise an error is raised.
msg -- A message corresponding to the integer flag, ier.
Remarks:
See splev for evaluation of the spline and its derivatives.
Example:
x = linspace(0, 10, 10)
y = sin(x)
tck = splrep(x, y)
x2 = linspace(0, 10, 200)
y2 = splev(x2, tck)
plot(x, y, 'o', x2, y2)
See also:
splprep, splev, sproot, spalde, splint - evaluation, roots, integral
bisplrep, bisplev - bivariate splines
UnivariateSpline, BivariateSpline - an alternative wrapping
of the FITPACK functions
Notes:
Based on algorithms described in:
Dierckx P. : An algorithm for smoothing, differentiation and integ-
ration of experimental data using spline functions,
J.Comp.Appl.Maths 1 (1975) 165-184.
Dierckx P. : A fast algorithm for smoothing data on a rectangular
grid while using spline functions, SIAM J.Numer.Anal.
19 (1982) 1286-1304.
Dierckx P. : An improved algorithm for curve fitting with spline
functions, report tw54, Dept. Computer Science,K.U.
Leuven, 1981.
Dierckx P. : Curve and surface fitting with splines, Monographs on
Numerical Analysis, Oxford University Press, 1993.
"""
if task <= 0:
_curfit_cache = {}
x, y = map(myasarray, [x, y])
m = len(x)
if w is None:
w = ones(m, float)
if s is None: s = 0.0
else:
w = myasarray(w)
if s is None: s = m - sqrt(2 * m)
if not len(w) == m:
raise TypeError, ' len(w)=%d is not equal to m=%d' % (len(w), m)
if (m != len(y)) or (m != len(w)):
raise TypeError, 'Lengths of the first three arguments (x,y,w) must be equal'
if not (1 <= k <= 5):
raise TypeError, 'Given degree of the spline (k=%d) is not supported. (1<=k<=5)' % (
k)
if m <= k: raise TypeError, 'm>k must hold'
if xb is None: xb = x[0]
if xe is None: xe = x[-1]
if not (-1 <= task <= 1): raise TypeError, 'task must be either -1,0, or 1'
if t is not None:
task = -1
if task == -1:
if t is None: raise TypeError, 'Knots must be given for task=-1'
numknots = len(t)
_curfit_cache['t'] = empty((numknots + 2 * k + 2, ), float)
_curfit_cache['t'][k + 1:-k - 1] = t
nest = len(_curfit_cache['t'])
elif task == 0:
if per:
nest = max(m + 2 * k, 2 * k + 3)
else:
nest = max(m + k + 1, 2 * k + 3)
t = empty((nest, ), float)
_curfit_cache['t'] = t
if task <= 0:
if per:
_curfit_cache['wrk'] = empty((m * (k + 1) + nest * (8 + 5 * k), ),
float)
else:
_curfit_cache['wrk'] = empty((m * (k + 1) + nest * (7 + 3 * k), ),
float)
_curfit_cache['iwrk'] = empty((nest, ), int32)
try:
t = _curfit_cache['t']
wrk = _curfit_cache['wrk']
iwrk = _curfit_cache['iwrk']
except KeyError:
raise TypeError, "must call with task=1 only after"\
" call with task=0,-1"
if not per:
n, c, fp, ier = dfitpack.curfit(task, x, y, w, t, wrk, iwrk, xb, xe, k,
s)
else:
n, c, fp, ier = dfitpack.percur(task, x, y, w, t, wrk, iwrk, k, s)
tck = (t[:n], c[:n], k)
if ier <= 0 and not quiet:
print _iermess[ier][0]
print "\tk=%d n=%d m=%d fp=%f s=%f" % (k, len(t), m, fp, s)
if ier > 0 and not full_output:
if ier in [1, 2, 3]:
print "Warning: " + _iermess[ier][0]
else:
try:
raise _iermess[ier][1], _iermess[ier][0]
except KeyError:
raise _iermess['unknown'][1], _iermess['unknown'][0]
if full_output:
try:
return tck, fp, ier, _iermess[ier][0]
except KeyError:
return tck, fp, ier, _iermess['unknown'][0]
else:
return tck
def splrep(x,y,w=None,xb=None,xe=None,k=3,task=0,s=None,t=None,
full_output=0,per=0,quiet=1):
"""Find the B-spline representation of 1-D curve.
Description:
Given the set of data points (x[i], y[i]) determine a smooth spline
approximation of degree k on the interval xb <= x <= xe. The coefficients,
c, and the knot points, t, are returned. Uses the FORTRAN routine
curfit from FITPACK.
Inputs:
x, y -- The data points defining a curve y = f(x).
w -- Strictly positive rank-1 array of weights the same length as x and y.
The weights are used in computing the weighted least-squares spline
fit. If the errors in the y values have standard-deviation given by the
vector d, then w should be 1/d. Default is ones(len(x)).
xb, xe -- The interval to fit. If None, these default to x[0] and x[-1]
respectively.
k -- The order of the spline fit. It is recommended to use cubic splines.
Even order splines should be avoided especially with small s values.
1 <= k <= 5
task -- If task==0 find t and c for a given smoothing factor, s.
If task==1 find t and c for another value of the
smoothing factor, s. There must have been a previous
call with task=0 or task=1 for the same set of data
(t will be stored an used internally)
If task=-1 find the weighted least square spline for
a given set of knots, t. These should be interior knots
as knots on the ends will be added automatically.
s -- A smoothing condition. The amount of smoothness is determined by
satisfying the conditions: sum((w * (y - g))**2,axis=0) <= s where
g(x) is the smoothed interpolation of (x,y). The user can use s to
control the tradeoff between closeness and smoothness of fit. Larger
s means more smoothing while smaller values of s indicate less
smoothing. Recommended values of s depend on the weights, w. If the
weights represent the inverse of the standard-deviation of y, then a
good s value should be found in the range (m-sqrt(2*m),m+sqrt(2*m))
where m is the number of datapoints in x, y, and w.
default : s=m-sqrt(2*m) if weights are supplied.
s = 0.0 (interpolating) if no weights are supplied.
t -- The knots needed for task=-1. If given then task is automatically
set to -1.
full_output -- If non-zero, then return optional outputs.
per -- If non-zero, data points are considered periodic with period
x[m-1] - x[0] and a smooth periodic spline approximation is returned.
Values of y[m-1] and w[m-1] are not used.
quiet -- Non-zero to suppress messages.
Outputs: (tck, {fp, ier, msg})
tck -- (t,c,k) a tuple containing the vector of knots, the B-spline
coefficients, and the degree of the spline.
fp -- The weighted sum of squared residuals of the spline approximation.
ier -- An integer flag about splrep success. Success is indicated if
ier<=0. If ier in [1,2,3] an error occurred but was not raised.
Otherwise an error is raised.
msg -- A message corresponding to the integer flag, ier.
Remarks:
See splev for evaluation of the spline and its derivatives.
Example:
x = linspace(0, 10, 10)
y = sin(x)
tck = splrep(x, y)
x2 = linspace(0, 10, 200)
y2 = splev(x2, tck)
plot(x, y, 'o', x2, y2)
See also:
splprep, splev, sproot, spalde, splint - evaluation, roots, integral
bisplrep, bisplev - bivariate splines
UnivariateSpline, BivariateSpline - an alternative wrapping
of the FITPACK functions
"""
if task<=0:
_curfit_cache = {}
x,y=map(myasarray,[x,y])
m=len(x)
if w is None:
w=ones(m,float)
if s is None: s = 0.0
else:
w=myasarray(w)
if s is None: s = m-sqrt(2*m)
if not len(w) == m: raise TypeError,' len(w)=%d is not equal to m=%d'%(len(w),m)
if (m != len(y)) or (m != len(w)):
raise TypeError, 'Lengths of the first three arguments (x,y,w) must be equal'
if not (1<=k<=5):
raise TypeError, 'Given degree of the spline (k=%d) is not supported. (1<=k<=5)'%(k)
if m<=k: raise TypeError, 'm>k must hold'
if xb is None: xb=x[0]
if xe is None: xe=x[-1]
if not (-1<=task<=1): raise TypeError, 'task must be either -1,0, or 1'
if t is not None:
task = -1
if task == -1:
if t is None: raise TypeError, 'Knots must be given for task=-1'
numknots = len(t)
_curfit_cache['t'] = empty((numknots + 2*k+2,),float)
_curfit_cache['t'][k+1:-k-1] = t
nest = len(_curfit_cache['t'])
elif task == 0:
if per:
nest = max(m+2*k,2*k+3)
else:
nest = max(m+k+1,2*k+3)
t = empty((nest,),float)
_curfit_cache['t'] = t
if task <= 0:
if per: _curfit_cache['wrk'] = empty((m*(k+1)+nest*(8+5*k),),float)
else: _curfit_cache['wrk'] = empty((m*(k+1)+nest*(7+3*k),),float)
_curfit_cache['iwrk'] = empty((nest,),int32)
try:
t=_curfit_cache['t']
wrk=_curfit_cache['wrk']
iwrk=_curfit_cache['iwrk']
except KeyError:
raise TypeError, "must call with task=1 only after"\
" call with task=0,-1"
if not per:
n,c,fp,ier = dfitpack.curfit(task, x, y, w, t, wrk, iwrk, xb, xe, k, s)
else:
n,c,fp,ier = dfitpack.percur(task, x, y, w, t, wrk, iwrk, k, s)
tck = (t[:n],c[:n],k)
if ier<=0 and not quiet:
print _iermess[ier][0]
print "\tk=%d n=%d m=%d fp=%f s=%f"%(k,len(t),m,fp,s)
if ier>0 and not full_output:
if ier in [1,2,3]:
print "Warning: "+_iermess[ier][0]
else:
try:
raise _iermess[ier][1],_iermess[ier][0]
except KeyError:
raise _iermess['unknown'][1],_iermess['unknown'][0]
if full_output:
try:
return tck,fp,ier,_iermess[ier][0]
except KeyError:
return tck,fp,ier,_iermess['unknown'][0]
else:
return tck
def splrep(x,y,w=None,xb=None,xe=None,k=3,task=0,s=None,t=None,
full_output=0,per=0,quiet=1):
"""
Find the B-spline representation of 1-D curve.
Given the set of data points (x[i], y[i]) determine a smooth spline
approximation of degree k on the interval xb <= x <= xe. The coefficients,
c, and the knot points, t, are returned. Uses the FORTRAN routine
curfit from FITPACK.
Parameters
----------
x, y : array_like
The data points defining a curve y = f(x).
w : array_like
Strictly positive rank-1 array of weights the same length as x and y.
The weights are used in computing the weighted least-squares spline
fit. If the errors in the y values have standard-deviation given by the
vector d, then w should be 1/d. Default is ones(len(x)).
xb, xe : float
The interval to fit. If None, these default to x[0] and x[-1]
respectively.
k : int
The order of the spline fit. It is recommended to use cubic splines.
Even order splines should be avoided especially with small s values.
1 <= k <= 5
task : {1, 0, -1}
If task==0 find t and c for a given smoothing factor, s.
If task==1 find t and c for another value of the smoothing factor, s.
There must have been a previous call with task=0 or task=1 for the same
set of data (t will be stored an used internally)
If task=-1 find the weighted least square spline for a given set of
knots, t. These should be interior knots as knots on the ends will be
added automatically.
s : float
A smoothing condition. The amount of smoothness is determined by
satisfying the conditions: sum((w * (y - g))**2,axis=0) <= s where g(x)
is the smoothed interpolation of (x,y). The user can use s to control
the tradeoff between closeness and smoothness of fit. Larger s means
more smoothing while smaller values of s indicate less smoothing.
Recommended values of s depend on the weights, w. If the weights
represent the inverse of the standard-deviation of y, then a good s
value should be found in the range (m-sqrt(2*m),m+sqrt(2*m)) where m is
the number of datapoints in x, y, and w. default : s=m-sqrt(2*m) if
weights are supplied. s = 0.0 (interpolating) if no weights are
supplied.
t : int
The knots needed for task=-1. If given then task is automatically set
to -1.
full_output : bool
If non-zero, then return optional outputs.
per : bool
If non-zero, data points are considered periodic with period x[m-1] -
x[0] and a smooth periodic spline approximation is returned. Values of
y[m-1] and w[m-1] are not used.
quiet : bool
Non-zero to suppress messages.
Returns
-------
tck : tuple
(t,c,k) a tuple containing the vector of knots, the B-spline
coefficients, and the degree of the spline.
fp : array, optional
The weighted sum of squared residuals of the spline approximation.
ier : int, optional
An integer flag about splrep success. Success is indicated if ier<=0.
If ier in [1,2,3] an error occurred but was not raised. Otherwise an
error is raised.
msg : str, optional
A message corresponding to the integer flag, ier.
Notes
-----
See splev for evaluation of the spline and its derivatives.
See Also
--------
UnivariateSpline, BivariateSpline
splprep, splev, sproot, spalde, splint
bisplrep, bisplev
References
----------
Based on algorithms described in [1], [2], [3], and [4]:
.. [1] P. Dierckx, "An algorithm for smoothing, differentiation and
integration of experimental data using spline functions",
J.Comp.Appl.Maths 1 (1975) 165-184.
.. [2] P. Dierckx, "A fast algorithm for smoothing data on a rectangular
grid while using spline functions", SIAM J.Numer.Anal. 19 (1982)
1286-1304.
.. [3] P. Dierckx, "An improved algorithm for curve fitting with spline
functions", report tw54, Dept. Computer Science,K.U. Leuven, 1981.
.. [4] P. Dierckx, "Curve and surface fitting with splines", Monographs on
Numerical Analysis, Oxford University Press, 1993.
Examples
--------
>>> x = linspace(0, 10, 10)
>>> y = sin(x)
>>> tck = splrep(x, y)
>>> x2 = linspace(0, 10, 200)
>>> y2 = splev(x2, tck)
>>> plot(x, y, 'o', x2, y2)
"""
if task<=0:
_curfit_cache = {}
x,y=map(myasarray,[x,y])
m=len(x)
if w is None:
w=ones(m,float)
if s is None: s = 0.0
else:
w=myasarray(w)
if s is None: s = m-sqrt(2*m)
if not len(w) == m: raise TypeError,' len(w)=%d is not equal to m=%d'%(len(w),m)
if (m != len(y)) or (m != len(w)):
raise TypeError, 'Lengths of the first three arguments (x,y,w) must be equal'
if not (1<=k<=5):
raise TypeError, 'Given degree of the spline (k=%d) is not supported. (1<=k<=5)'%(k)
if m<=k: raise TypeError, 'm>k must hold'
if xb is None: xb=x[0]
if xe is None: xe=x[-1]
if not (-1<=task<=1): raise TypeError, 'task must be either -1,0, or 1'
if t is not None:
task = -1
if task == -1:
if t is None: raise TypeError, 'Knots must be given for task=-1'
numknots = len(t)
_curfit_cache['t'] = empty((numknots + 2*k+2,),float)
_curfit_cache['t'][k+1:-k-1] = t
nest = len(_curfit_cache['t'])
elif task == 0:
if per:
nest = max(m+2*k,2*k+3)
else:
nest = max(m+k+1,2*k+3)
t = empty((nest,),float)
_curfit_cache['t'] = t
if task <= 0:
if per: _curfit_cache['wrk'] = empty((m*(k+1)+nest*(8+5*k),),float)
else: _curfit_cache['wrk'] = empty((m*(k+1)+nest*(7+3*k),),float)
_curfit_cache['iwrk'] = empty((nest,),int32)
try:
t=_curfit_cache['t']
wrk=_curfit_cache['wrk']
iwrk=_curfit_cache['iwrk']
except KeyError:
raise TypeError, "must call with task=1 only after"\
" call with task=0,-1"
if not per:
n,c,fp,ier = dfitpack.curfit(task, x, y, w, t, wrk, iwrk, xb, xe, k, s)
else:
n,c,fp,ier = dfitpack.percur(task, x, y, w, t, wrk, iwrk, k, s)
tck = (t[:n],c[:n],k)
if ier<=0 and not quiet:
print _iermess[ier][0]
print "\tk=%d n=%d m=%d fp=%f s=%f"%(k,len(t),m,fp,s)
if ier>0 and not full_output:
if ier in [1,2,3]:
print "Warning: "+_iermess[ier][0]
else:
try:
raise _iermess[ier][1],_iermess[ier][0]
except KeyError:
raise _iermess['unknown'][1],_iermess['unknown'][0]
if full_output:
try:
return tck,fp,ier,_iermess[ier][0]
except KeyError:
return tck,fp,ier,_iermess['unknown'][0]
else:
return tck