def interpolate(self, points, with_derivatives=False):
if with_derivatives:
raise Exception('Option not implemented')
n_x = self.__values__.shape[0]
n_p = points.shape[1]
n_d = self.domain.d
ndim = self.domain.d
delaunay = self.delaunay
points = numpy.minimum(
points, self.domain.smax[:, None]) # only for rectangular domains
points = numpy.maximum(
points, self.domain.smin[:, None]) # only for rectangular domains
# inds_simplices = self.delaunay.find_simplex(points.T)
inds_simplices = self.find_simplex(points.T)
inside = (inds_simplices != -1)
indices = inds_simplices[inside]
transform = self.delaunay.transform[indices, :, :]
transform = numpy.rollaxis(transform, 0, 3)
vertices = self.delaunay.vertices.T[:, indices]
Tinv = transform[:ndim, :ndim, :]
r = transform[ndim, :, :]
z = points[:, inside]
from dolo.numeric.serial_operations import serial_dot
resp = np.zeros((n_x, n_p))
if with_derivatives:
dresp = numpy.zeros((n_x, n_p))
all_values_on_vertices = self.__values__[:, vertices]
for i in range(n_x):
values_on_vertices = all_values_on_vertices[i, :, :]
last_V = values_on_vertices[-1, :]
z_r = z - r
c = serial_dot(Tinv, z_r)
D = values_on_vertices[:-1, :] - last_V
resp[i, inside] = serial_dot(c, D) + last_V
if with_derivatives:
interp_dvals = serial_dot(D, Tinv)
dresp[:, inside] = interp_dvals
return [resp, dresp]
else:
return resp
def interpolate(self, points, with_derivatives=False):
if with_derivatives:
raise Exception('Option not implemented')
n_x = self.__values__.shape[0]
n_p = points.shape[1]
n_d = self.domain.d
ndim = self.domain.d
delaunay = self.delaunay
points = numpy.minimum(points, self.domain.smax[:,None]) # only for rectangular domains
points = numpy.maximum(points, self.domain.smin[:,None]) # only for rectangular domains
# inds_simplices = self.delaunay.find_simplex(points.T)
inds_simplices = self.find_simplex(points.T)
inside = (inds_simplices != -1)
indices = inds_simplices[inside]
transform = self.delaunay.transform[indices,:,:]
transform = numpy.rollaxis(transform,0,3)
vertices = self.delaunay.vertices.T[:,indices]
Tinv = transform[:ndim,:ndim,:]
r = transform[ndim,:,:]
z = points[:,inside]
from dolo.numeric.serial_operations import serial_dot
resp = np.zeros((n_x,n_p))
if with_derivatives:
dresp = numpy.zeros( (n_x, n_p) )
all_values_on_vertices = self.__values__[:, vertices]
for i in range(n_x):
values_on_vertices = all_values_on_vertices[i,:,:]
last_V = values_on_vertices[-1,:]
z_r = z-r
c = serial_dot(Tinv, z_r)
D = values_on_vertices[:-1,:] - last_V
resp[i,inside] = serial_dot(c, D) + last_V
if with_derivatives:
interp_dvals = serial_dot(D, Tinv)
dresp[:,inside] = interp_dvals
return [resp,dresp]
else:
return resp
def interpolate_1v(self, i, points):
# points = numpy.minimum(points, self.domain.smax) # only for rectangular domains
# points = numpy.maximum(points, self.domain.smin) # only for rectangular domains
# print points
zz = points
ndim = self.domain.d
delaunay = self.delaunay
nvalues_on_points = self.__values__[i,:]
from dolo.numeric.serial_operations import serial_dot
n_p = zz.shape[1]
n_x = zz.shape[0]
resp = numpy.zeros(n_p)
dresp = numpy.zeros( (n_x, n_p) )
inds_simplices = delaunay.find_simplex(zz.T)
inside = (inds_simplices != -1)
if True not in inside:
return [resp,dresp]
indices = inds_simplices[inside]
transform = delaunay.transform[indices,:,:]
transform = numpy.rollaxis(transform,0,3)
Tinv = transform[:ndim,:ndim,:]
r = transform[ndim,:,:]
vertices = delaunay.vertices.T[:,indices]
z = zz[:,inside]
values_on_vertices = nvalues_on_points[vertices]
last_V = values_on_vertices[-1,:]
D = values_on_vertices[:-1,:] - last_V
z_r = z-r
c = serial_dot(Tinv, z_r)
interp_vals = serial_dot(c, D) + last_V
interp_dvals = serial_dot(D, Tinv)
resp[inside] = interp_vals
dresp[:,inside] = interp_dvals
return [resp,dresp]
exit()
t = time.time()
for i in range(n_exp):
CC = another_multiplication(A, B)
s = time.time()
print('S.T.M. (c) ' + str(s - t))
exit()
exit()
print(abs(CC - C).max())
t = time.time()
for i in range(10):
CCC = serial_dot(A, B)
s = time.time()
print('S.D. (python) ' + str(s - t))
exit()
import numpy as np
AA = (A)
BB = (B)
t = time.time()
for i in range(10):
CCCC = sdot(AA, BB)
s = time.time()
print('S.D. (cython) ' + str(s - t))
# 4 times faster
exit()
exit()
print( abs(CC - C).max())
t = time.time()
for i in range(10):
CCC = serial_dot(A,B)
s = time.time()
print('S.D. (python) ' + str(s-t))
exit()
import numpy as np
AA = (A)
BB = (B)
t = time.time()
for i in range(10):
CCCC = sdot(AA,BB)
s = time.time()
print('S.D. (cython) ' + str(s-t))
