def interp_matrices(self, x, beta=None, gamma=None):
"""
Calculate the matrices X, E and C for interpolation
scheme x is the point where the interpolation is
evaluated.
"""
assert x.dtype == float
N, n, p, nv, ng, d = self.N, self.n, self.p, self.nv, self.ng, self.d
if beta is None:
beta = self.beta
if gamma is None:
gamma = self.gamma
# construct the order set
order_set = _order_set(N+1, self.d)
M1 = _binomial(N+d,d) - 1
M2 = _binomial(N+d+1,d) - 1
assert len(order_set) == M2
# construct X = [Xv,Xg]
X = zeros([M1, n], dtype=float)
for i, kappa in enumerate(order_set[:M1]):
X[i,:nv] = gamma**sum(kappa) / _factorial(kappa) * \
((self.xv - x)**kappa).prod(1)
assert ng == 0
X *= beta
# construct diagonal G matrix for the Lagrange residual
Er2 = zeros(n)
for kappa in order_set[M1:]:
Eri = gamma**sum(kappa) / _factorial(kappa) * \
((self.xv - x)**kappa).prod(1)
Er2[:nv] += Eri**2
assert ng == 0
Er2 *= beta**2
# construct diagonal H matrix for measurement errors
Ee = zeros(n)
Ee[:nv] = self.dfxv
assert ng == 0
# construct E
E = sqrt(Er2 + Ee**2)
# construct C
M = _binomial(p+1,d) - 1
assert M <= len(order_set)
C = zeros([M+1, n])
C[0,:nv] = 1.0
C[0,nv:] = 0.0
for i, kappa in enumerate(order_set[:M]):
C[i+1,:nv] = ((self.xv - x)**kappa).prod(1)
assert ng == 0
return X, E, C
def interp_matrices(self, x, beta=None, gamma=None):
"""
Calculate the matrices X, E and C for interpolation
scheme x is the point where the interpolation is
evaluated.
"""
assert x.dtype == float
N, n, p, nv, ng = self.N, self.n, self.p, self.nv, self.ng
if beta is None:
beta = self.beta
if gamma is None:
gamma = self.gamma
# construct the order set
order_set = _order_set_2d(N + 1)
M1 = _binomial(N + 2, 2) - 1
M2 = _binomial(N + 3, 2) - 1
assert len(order_set) == M2
# construct X = [Xv,Xg]
X = zeros([M1, n], dtype=float)
for i, kappa in enumerate(order_set[:M1]):
X[i, :nv] = gamma ** sum(kappa) / _factorial(kappa) * ((self.xv - x) ** kappa).prod(1)
if ng > 0:
if kappa[0] > 0:
kappa_p = [kappa[0] - 1, kappa[1]]
X[i, nv : nv + ng] = gamma ** sum(kappa) / _factorial(kappa_p) * ((self.xg - x) ** kappa_p).prod(1)
if kappa[1] > 0:
kappa_p = [kappa[0], kappa[1] - 1]
X[i, nv + ng :] = gamma ** sum(kappa) / _factorial(kappa_p) * ((self.xg - x) ** kappa_p).prod(1)
X *= beta
# construct diagonal G matrix for the Lagrange residual
Er2 = zeros(n)
for kappa in order_set[M1:]:
Eri = gamma ** sum(kappa) / _factorial(kappa) * ((self.xv - x) ** kappa).prod(1)
Er2[:nv] += Eri ** 2
if ng > 0:
if kappa[0] > 0:
kappa_p = [kappa[0] - 1, kappa[1]]
Eri = gamma ** sum(kappa) / _factorial(kappa_p) * ((self.vg - x) ** kappa_p).prod(1)
Er2[nv : nv + ng] += Eri ** 2
if kappa[1] > 0:
kappa_p = [kappa[0], kappa[1] - 1]
Eri = gamma ** sum(kappa) / _factorial(kappa_p) * ((self.vg - x) ** kappa_p).prod(1)
Er2[nv + ng :] += Eri ** 2
Er2 *= beta ** 2
# construct diagonal H matrix for measurement errors
Ee = zeros(n)
Ee[:nv] = self.dfxv
if ng > 0:
Ee[nv : nv + ng] = self.dfpxg
Ee[nv + ng :] = self.dfpxg
# construct E
E = sqrt(Er2 + Ee ** 2)
# construct C
M = _binomial(p + 1, 2) - 1
assert M <= len(order_set)
C = zeros([M + 1, n])
C[0, :nv] = 1.0
C[0, nv:] = 0.0
for i, kappa in enumerate(order_set[:M]):
C[i + 1, :nv] = ((self.xv - x) ** kappa).prod(1)
if ng > 0:
kappa_p = [kappa[0] - 1, kappa[1]]
C[i + 1, nv : nv + ng] = kappa[0] * ((self.xv - x) ** kappa_p).prod(1)
kappa_p = [kappa[0], kappa[1] - 1]
C[i + 1, nv : nv + ng] = kappa[1] * ((self.xv - x) ** kappa_p).prod(1)
return X, E, C
