def bspline_integrate():
import numpy as np
import scipy.integrate as integrate
from xspline.__init__ import bspline
ok = True
# setup test problem
# -------------------------------------------------------------------------
knots = np.linspace(0.0, 1.0, 3)
degree = 1
bs = bspline(knots, degree)
# test integrate function
# -------------------------------------------------------------------------
N = 3
x = np.linspace(-1.0, 2.0, N)
a = np.repeat(-1.0, N)
my_If = bs.splineIF(a, x, 0, 2)
def func(x):
return bs.splineIF(-1.0, x, 0, 1)
tr_If = np.array([integrate.quad(func, a[i], x[i])[0] for i in range(N)])
tol = 1e-8
ok = ok and np.linalg.norm(my_If - tr_If) < tol
if not ok:
print('tr_If', tr_If)
print('my_If', my_If)
return ok
def bspline_lastDMat():
import numpy as np
from xspline.__init__ import bspline
ok = True
# setup test problem
# -------------------------------------------------------------------------
knots = np.linspace(0.0, 1.0, 3)
degree = 2
bs = bspline(knots, degree)
# test lastDMat function
# -------------------------------------------------------------------------
tr_df = np.array([
[8.0, -12.0, 4.0, 0.0],
[0.0, 4.0, -12.0, 8.0],
])
my_df = bs.lastDMat()
tol = 1e-10
ok = ok and np.linalg.norm(my_df - tr_df) < tol
if not ok:
print('tr_df', tr_df)
print('my_df', my_df)
return ok
def bspline_splineIF():
import numpy as np
from xspline.__init__ import bspline
ok = True
# setup test problem
# -------------------------------------------------------------------------
knots = np.linspace(0.0, 1.0, 3)
degree = 1
bs = bspline(knots, degree)
# test splineIF function
# -------------------------------------------------------------------------
N = 101
a = np.zeros(N)
x = np.linspace(0.0, 1.0, N)
lx = x[x < 0.5]
rx = x[x >= 0.5]
lzeros = np.zeros(lx.size)
rzeros = np.zeros(rx.size)
lones = np.ones(lx.size)
rones = np.ones(rx.size)
tr_if = np.vstack([
np.hstack([lx - lx**2, 0.25*rones]),
np.hstack([lx**2, (rx - 0.5) - (rx - 0.5)**2 + 0.25*rones]),
np.hstack([lzeros, (rx - 0.5)**2])
])
my_if = np.vstack([bs.splineIF(a, x, i, 1)
for i in range(bs.num_spline_bases)])
tol = 1e-10
ok = ok and np.linalg.norm(my_if - tr_if) < tol
if not ok:
print('tr_if', tr_if)
print('my_if', my_if)
return ok
def bspline_designIMat():
import numpy as np
from xspline.__init__ import bspline
ok = True
# setup test problem
# -------------------------------------------------------------------------
knots = np.linspace(0.0, 1.0, 3)
degree = 1
bs = bspline(knots, degree)
# test designIMat function
# -------------------------------------------------------------------------
N = 101
a = np.zeros(N)
x = np.linspace(0.0, 1.0, N)
lx = x[x < 0.5]
rx = x[x >= 0.5]
lzeros = np.zeros(lx.size)
rzeros = np.zeros(rx.size)
lones = np.ones(lx.size)
rones = np.ones(rx.size)
tr_IX = np.vstack([
np.hstack([lx - lx**2, 0.25 * rones]),
np.hstack([lx**2, (rx - 0.5) - (rx - 0.5)**2 + 0.25 * rones]),
np.hstack([lzeros, (rx - 0.5)**2])
]).T
my_IF = bs.designIMat(a, x, 1)
tol = 1e-10
ok = ok and np.linalg.norm(my_IF - tr_IX) < tol
if not ok:
print('tr_IX', tr_IX)
print('my_IF', my_IF)
return ok
def bspline_splineF():
import numpy as np
from xspline.__init__ import bspline
ok = True
# setup test problem
# -------------------------------------------------------------------------
knots = np.linspace(0.0, 1.0, 3)
degree = 1
bs = bspline(knots, degree)
# test splineF function
# -------------------------------------------------------------------------
x = np.linspace(0.0, 1.0, 101)
lx = x[x < 0.5]
rx = x[x >= 0.5]
lzeros = np.zeros(lx.size)
rzeros = np.zeros(rx.size)
lf1 = (lx - 0.5)/(0.0 - 0.5)
lf2 = (lx - 0.0)/(0.5 - 0.0)
rf1 = (rx - 1.0)/(0.5 - 1.0)
rf2 = (rx - 0.5)/(1.0 - 0.5)
tr_f = np.vstack([
np.hstack([lf1, rzeros]),
np.hstack([lf2, rf1]),
np.hstack([lzeros, rf2])
])
my_f = np.vstack([bs.splineF(x, i) for i in range(bs.num_spline_bases)])
tol = 1e-10
ok = ok and np.linalg.norm(my_f - tr_f) < tol
if not ok:
print('tr_f', tr_f)
print('my_f', my_f)
return ok
def bspline_designMat():
import numpy as np
from xspline.__init__ import bspline
ok = True
# setup test problem
# -------------------------------------------------------------------------
knots = np.linspace(0.0, 1.0, 3)
degree = 1
bs = bspline(knots, degree)
# test designMat function
# -------------------------------------------------------------------------
x = np.linspace(0.0, 1.0, 101)
lx = x[x < 0.5]
rx = x[x >= 0.5]
lzeros = np.zeros(lx.size)
rzeros = np.zeros(rx.size)
lf1 = (lx - 0.5) / (0.0 - 0.5)
lf2 = (lx - 0.0) / (0.5 - 0.0)
rf1 = (rx - 1.0) / (0.5 - 1.0)
rf2 = (rx - 0.5) / (1.0 - 0.5)
tr_X = np.vstack([
np.hstack([lf1, rzeros]),
np.hstack([lf2, rf1]),
np.hstack([lzeros, rf2])
]).T
my_X = bs.designMat(x)
tol = 1e-10
ok = ok and np.linalg.norm(my_X - tr_X) < tol
if not ok:
print('tr_X', tr_X)
print('my_X', my_X)
return ok
def bspline_splineDF():
import numpy as np
from xspline.__init__ import bspline
ok = True
# setup test problem
# -------------------------------------------------------------------------
knots = np.linspace(0.0, 1.0, 3)
degree = 1
bs = bspline(knots, degree)
# test splineDF function
# -------------------------------------------------------------------------
x = np.linspace(0.0, 1.0, 101)
lx = x[x < 0.5]
rx = x[x >= 0.5]
lzeros = np.zeros(lx.size)
rzeros = np.zeros(rx.size)
lones = np.ones(lx.size)
rones = np.ones(rx.size)
tr_df = np.vstack([
np.hstack([-2.0 * lones, rzeros]),
np.hstack([2.0 * lones, -2.0 * rones]),
np.hstack([lzeros, 2.0 * rones])
])
my_df = np.vstack(
[bs.splineDF(x, i, 1) for i in range(bs.num_spline_bases)])
tol = 1e-10
ok = ok and np.linalg.norm(my_df - tr_df) < tol
if not ok:
print('tr_df', tr_df)
print('my_df', my_df)
return ok
def bspline_designDMat():
import numpy as np
from xspline.__init__ import bspline
ok = True
# setup test problem
# -------------------------------------------------------------------------
knots = np.linspace(0.0, 1.0, 3)
degree = 1
bs = bspline(knots, degree)
# test designDMat function
# -------------------------------------------------------------------------
x = np.linspace(0.0, 1.0, 101)
lx = x[x < 0.5]
rx = x[x >= 0.5]
lzeros = np.zeros(lx.size)
rzeros = np.zeros(rx.size)
lones = np.ones(lx.size)
rones = np.ones(rx.size)
tr_DX = np.vstack([
np.hstack([-2.0 * lones, rzeros]),
np.hstack([2.0 * lones, -2.0 * rones]),
np.hstack([lzeros, 2.0 * rones])
]).T
my_DX = bs.designDMat(x, 1)
tol = 1e-10
ok = ok and np.linalg.norm(my_DX - tr_DX) < tol
if not ok:
print('tr_DX', tr_DX)
print('my_DX', my_DX)
return ok