def get_2d_cartesian_grid(num_pts_1d, ranges):
"""
Get a 2d tensor grid with equidistant points.
Parameters
----------
num_pts_1d : integer
The number of points in each dimension
ranges : np.ndarray (4)
The lower and upper bound of each dimension [lb_1,ub_1,lb_2,ub_2]
Returns
-------
grid : np.ndarray (2,num_pts_1d**2)
The points in the tensor product grid.
[x1,x2,...x1,x2...]
[y1,y1,...y2,y2...]
"""
#from math_tools_cpp import cartesian_product_double as cartesian_product
from PyDakota.math_tools import cartesian_product
x1 = np.linspace(ranges[0], ranges[1], num_pts_1d)
x2 = np.linspace(ranges[2], ranges[3], num_pts_1d)
abscissa_1d = []
abscissa_1d.append(x1)
abscissa_1d.append(x2)
grid = cartesian_product(abscissa_1d, 1)
return grid
def get_tensor_product_quadrature_rule(degrees,
num_vars,
univariate_quadrature_rules,
transform_samples=None,
density_function=None):
"""
if get error about outer product failing it may be because
univariate_quadrature rule is returning a weights array for every level,
i.e. l=0,...level
"""
degrees = np.atleast_1d(degrees)
if degrees.shape[0] == 1 and num_vars > 1:
degrees = np.array([degrees[0]] * num_vars, dtype=int)
if callable(univariate_quadrature_rules):
univariate_quadrature_rules = [univariate_quadrature_rules] * num_vars
x_1d = []
w_1d = []
for ii in range(len(univariate_quadrature_rules)):
x, w = univariate_quadrature_rules[ii](degrees[ii])
x_1d.append(x)
w_1d.append(w)
samples = cartesian_product(x_1d, 1)
weights = outer_product(w_1d)
if density_function is not None:
weights *= density_function(samples)
if transform_samples is not None:
samples = transform_samples(samples)
return samples, weights
def outer_product(input_sets):
r"""
Construct the outer product of an arbitary number of sets.
Examples
--------
.. math::
\{1,2\}\times\{3,4\}=\{1\times3, 2\times3, 1\times4, 2\times4\} =
\{3, 6, 4, 8\}
Parameters
----------
input_sets
The sets to be used in the outer product
Returns
-------
result : np.ndarray(np.prod(sizes))
The outer product of the sets.
result.dtype will be set to the first entry of the first input_set
"""
out = cartesian_product(input_sets)
return np.prod(out, axis=0)
try:
from pyapprox.cython.utilities import outer_product_pyx
# fused type does not work for np.in32, np.float32, np.int64
# so envoke cython cast
if np.issubdtype(input_sets[0][0], np.signedinteger):
return outer_product_pyx(input_sets, 1)
if np.issubdtype(input_sets[0][0], np.floating):
return outer_product_pyx(input_sets, 1.)
else:
return outer_product_pyx(input_sets, input_sets[0][0])
except:
print('outer_product extension failed')
num_elems = 1
num_sets = len(input_sets)
sizes = np.empty((num_sets), dtype=int)
for ii in range(num_sets):
sizes[ii] = len(input_sets[ii])
num_elems *= sizes[ii]
# try:
# from pyapprox.weave import c_outer_product
# return c_outer_product(input_sets)
# except:
# print ('outer_product extension failed')
result = np.empty((num_elems), dtype=type(input_sets[0][0]))
for ii in range(num_elems):
result[ii] = 1.0
multi_index = ind2sub(sizes, ii, num_elems)
for jj in range(num_sets):
result[ii] *= input_sets[jj][multi_index[jj]]
return result