B_Spline

Companion object B_Spline

class B_Spline extends BasisFunction with Error

The B_Spline class provides B-Spline basis functions for various orders 'm', where the order is one more than the degree. A spline function is a piecewise polynomial function where the pieces are stitched together at knots with the goal of maintaining continuity and differentiability. B-Spline basis functions form a popular form of basis functions used in Functional Data Analysis.

See also: http://web.mit.edu/hyperbook/Patrikalakis-Maekawa-Cho/node17.html -----------------------------------------------------------------------------

Linear Supertypes

Error, BasisFunction, AnyRef, Any

Known Subclasses

DB_Spline

Ordering

Alphabetic
By Inheritance

Inherited

B_Spline
Error
BasisFunction
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Instance Constructors

new B_Spline(ττ: VectoD, mMax: Int = 4, clamp: Boolean = true)
ττ
the time-points of the original knots in the time dimension
mMax
the maximum order, allowing splines orders from 1 to mMax
clamp
flag for augmenting ττ

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
val DEBUG: Boolean

Attributes
protected
def abf(m: Int)(t: VectoD): MatrixD
Obtain the value of the m-th order basis functions (all) at time 't'.
Obtain the value of the m-th order basis functions (all) at time 't'. Or alternatively, obtain the basis function by calling bf(m)(j) only. Ex: val x = bf(m)(t) retrieves the value of all the basis functions at 't'. val f = bf(m) retrieves all the basis functions.
m
the order of all the basis function
t
the time parameter

Definition Classes
BasisFunction
def abf_(m: Int = mMax)(t: Double): VectorD
Evaluate each of the τ.dim-1-many order m B-spline basis functions at t non-recursively, using an efficient dynamic programming approach.
Evaluate each of the τ.dim-1-many order m B-spline basis functions at t non-recursively, using an efficient dynamic programming approach.
Example
```
val m = 4                       // order m (degree m-1)
val t = VectorD (1, 2, 3, 4)    // original time points
val N = B_Spline (t, k)         // B_Spline instance
val z = N.abf_ (m)(t)           // vector of evaluations
println ("order k basis functions at t = z")
```
Implementation Details
Let N(m)(i) denote the i-th order k basis function evaluated at t. Then each N(m)(i) depends on the evaluation of N(m-1)(i) and N(m-1)(i+1). Here is an example, given a set of order m=4 B-spline basis functions and knot vector τ of length n:
```
N(1)(0), N(1)(1), N(1)(2), N(1)(3), ..., N(1)(n-1)
      |/       |/       |/            |/
N(2)(0), N(2)(1), N(2)(2), ..., N(2)(n-2)
      |/       |/            |/
N(3)(0), N(3)(1), ..., N(3)(n-3)
      |/            |/
N(4)(0), ..., N(4)(n-4)
```
This algorithm applies the procedure described above using O(n) storage and O(k*n) floating point operations.
m
the order of all the basis function
t
point to evaluate

Definition Classes
B_Spline → BasisFunction
See also
Carl de Boor (1978). A Practical Guide to Splines. Springer-Verlag. ISBN 3-540-90356-9.
def apply(m: Int)(j: Int)(t: Double): Double
Obtain the value of the m-th order 'j'-th basis function at time 't'.
Obtain the value of the m-th order 'j'-th basis function at time 't'. Or alternatively, obtain the basis function by calling bf(m)(j) only. Ex: val x = bf(m)(j)(t) retrieves the value of the j-th basis function at 't'. val f = bf(m)(j) retrieves the j-th basis function.
m
the order of the basis function
j
indicates which basis function
t
the time parameter

Definition Classes
BasisFunction
final def asInstanceOf[T0]: T0

Definition Classes
Any
def bb(m: Int)(j: Int)(t: Double): Double
Order 'm' B-Spline basis functions (general recurrence).
Order 'm' B-Spline basis functions (general recurrence).
m
the order of the spline function (degree = order - 1)
j
indicates which spline function
t
the time parameter
def bf(m: Int)(j: Int)(t: Double): Double
Evaluate the 'j+1'-th order m B-spline basis function at t non-recursively, using an efficient dynamic programming approach.
Evaluate the 'j+1'-th order m B-spline basis function at t non-recursively, using an efficient dynamic programming approach.
Example
```
val m = 4                       // order m (degree m-1)
val t = VectorD (1, 2, 3, 4)    // original time points
val N = B_Spline (t, k)         // B_Spline instance
val j = 0                       // spline j in N.range(m)
val z = N.bf (m)(j)(t(2))       // evaluate at t(2)
println ("order k basis function j at t(2) = z")
```
Implementation Details
Let N(m)(i) denote the i-th order k basis function evaluated at t. Then each N(m)(i) depends on the evaluation of N(m-1)(i) and N(m-1)(i+1). Here is an example, given a set of order m=4 B-spline basis functions and knot vector τ of length n:
```
N(1)(0), N(1)(1), N(1)(2), N(1)(3)
      |/       |/       |/
N(2)(0), N(2)(1), N(2)(2)
      |/       |/
N(3)(0), N(3)(1)
      |/
N(4)(0)
```
This algorithm applies the procedure described above using O(k) storage and O(k*k) floating point operations.
m
the order of the basis function
j
indicates which basis function
t
point to evaluate

Definition Classes
B_Spline → BasisFunction
See also
Carl de Boor (1978). A Practical Guide to Splines. Springer-Verlag. ISBN 3-540-90356-9.
def bf1(j: Int)(t: Double): Double
Obtain the value of the 1st order 'j'-th basis function at time 't'.
Obtain the value of the 1st order 'j'-th basis function at time 't'. Or alternatively, obtain the basis function by calling bf1(j) only. Ex: val x = bf1(j)(t) retrieves the value of the j-th basis function at 't'. val f = bf1(j) retrieves the j-th basis function.
j
indicates which basis function
t
the time parameter

Definition Classes
BasisFunction
def bf2(j: Int)(t: Double): Double
Obtain the value of the 2nd order 'j'-th basis function at time 't'.
Obtain the value of the 2nd order 'j'-th basis function at time 't'. Or alternatively, obtain the basis function by calling bf2(j) only. Ex: val x = bf2(j)(t) retrieves the value of the j-th basis function at 't'. val f = bf2(j) retrieves the j-th basis function.
j
indicates which basis function
t
the time parameter

Definition Classes
BasisFunction
def bf3(j: Int)(t: Double): Double
Obtain the value of the 3rd order 'j'-th basis function at time 't'.
Obtain the value of the 3rd order 'j'-th basis function at time 't'. Or alternatively, obtain the basis function by calling bf3(j) only. Ex: val x = bf3(j)(t) retrieves the value of the j-th basis function at 't'. val f = bf3(j) retrieves the j-th basis function.
j
indicates which basis function
t
the time parameter

Definition Classes
BasisFunction
def bf4(j: Int)(t: Double): Double
Obtain the value of the 4th order 'j'-th basis function at time 't'.
Obtain the value of the 4th order 'j'-th basis function at time 't'. Or alternatively, obtain the basis function by calling bf4(j) only. Ex: val x = bf4(j)(t) retrieves the value of the j-th basis function at 't'. val f = bf4(j) retrieves the j-th basis function.
j
indicates which basis function
t
the time parameter

Definition Classes
BasisFunction
def bfr(m: Int)(j: Int)(t: Double): Double
Adjusted order 'm' B-Spline basis functions (general recurrence).
Adjusted order 'm' B-Spline basis functions (general recurrence). These are adjusted so that the first "usable" spline is at j = 0. The valid range of usable splines is defined in range.
m
the order of the spline function (degree = order - 1)
j
indicates which spline function
t
the time parameter
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@native() @throws( ... )
def count(m: Int): Int
The number of basis functions for a specified order.
The number of basis functions for a specified order.
m
the order of the basis function

Definition Classes
BasisFunction
def dot_(m: Int)(i: Int, j: Int)(g: BasisFunction, a: Double = 0.0, b: Double = 1.0): Double
Compute the dot/inner product of 'this' basis function object and basis function 'g'.
Compute the dot/inner product of 'this' basis function object and basis function 'g'.
m
the order of the basis function
i
indicates which basis function of 'this'
j
indicates which basis function of 'g'
g
the other function
a
the start of the interval
b
the end of the interval

Definition Classes
BasisFunction
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def flaw(method: String, message: String): Unit

Definition Classes
Error
def getCache(m: Int, t: VectoD): Array[MatrixD]
Retrieves the cached design matrices
Retrieves the cached design matrices

Definition Classes
BasisFunction
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@native()
def getOrder: Int
Retrieve the order of the this B_Spline.
Retrieve the order of the this B_Spline.

Definition Classes
B_Spline → BasisFunction
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@native()
val head: Double

Attributes
protected
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
val l: Int

Attributes
protected
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val needCompute: Boolean

Attributes
protected
Definition Classes
BasisFunction
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@native()
def range(m: Int = mMax): Inclusive
Range of "usable" splines when using the bs function.
Range of "usable" splines when using the bs function. This is needed, since extra splines may be generated by the general B-spline recurrence.
m
the order of the spline

Definition Classes
B_Spline → BasisFunction
def recomputeCache: Unit
Recompute cached matrices
Recompute cached matrices

Definition Classes
BasisFunction
def size(m: Int = mMax): Int
The number of usable spline basis functions for a specified order, given the configured knot vector.
The number of usable spline basis functions for a specified order, given the configured knot vector.
m
the order of the spline

Definition Classes
B_Spline → BasisFunction
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
val tail: Double

Attributes
protected
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@native() @throws( ... )
val Φ: MatrixD

Attributes
protected
Definition Classes
BasisFunction
val Φt: MatrixD

Attributes
protected
Definition Classes
BasisFunction
val ΦtΦ: MatrixD

Attributes
protected
Definition Classes
BasisFunction
val τ: VectoD

Attributes
protected

Packages

B_Spline

Companion object B_Spline

class B_Spline extends BasisFunction with Error

Instance Constructors

Value Members

Example

Implementation Details

Example

Implementation Details

Inherited from Error

Inherited from BasisFunction

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

B_Spline 

Companion object B_Spline

class B_Spline extends BasisFunction with Error

Instance Constructors

Value Members

Example

Implementation Details

Example

Implementation Details

Inherited from Error

Inherited from BasisFunction

Inherited from AnyRef

Inherited from Any

Ungrouped

B_Spline