def setUp(self): """ Set up the problem by calculating required ratios and widths. """ self.boundary_ratio_radius = 0.1 self.boundary_width_radius = self.radius*self.boundary_ratio_radius self.boundary_width = np.ones(self.center.shape) + \ 0.1*np.arange(len(self.center)) self.right = self.center + .5*self.width self.left = self.center - .5*self.width self.boundary_ratio = self.boundary_width/self.width # create a list of coordinates that are outside the domain outcoords_rect = [] outcoords_sphere = [] # create a list of coordinates that are in on the boundary of the # domain oncoords_rect = [] dim = len(self.width) for l, r, bw in zip(self.left, self.right, self.boundary_width): outcoords_rect.append(np.array([l-bw, r+bw])) outcoords_sphere.append(np.array([self.center-self.radius - self.boundary_width_radius, self.center+self.radius+self.boundary_width_radius])) oncoords_rect.append(np.array([l, r])) self.outcoords_rect = util.meshgrid_ndim(outcoords_rect) self.oncoords_rect = util.meshgrid_ndim(oncoords_rect) self.outcoords_sphere = util.meshgrid_ndim(outcoords_sphere) self.oncoords_sphere = np.row_stack((-np.eye(dim), np.eye(dim).transpose()))*self.radius+self.center print("SPHERE", self.center, self.radius, self.oncoords_sphere)
def setUp(self): """ Set up the problem by calculating required ratios and widths. """ self.boundary_ratio_radius = 0.1 self.boundary_width_radius = self.radius*self.boundary_ratio_radius self.boundary_width = np.ones(self.center.shape) + \ 0.1*np.arange(len(self.center)) self.right = self.center + .5*self.width self.left = self.center - .5*self.width self.boundary_ratio = self.boundary_width/self.width # create a list of coordinates that are outside the domain outcoords_rect = [] outcoords_sphere = [] # create a list of coordinates that are in on the boundary of the # domain oncoords_rect = [] dim = len(self.width) for l, r, bw in zip(self.left, self.right, self.boundary_width): outcoords_rect.append(np.array([l-bw, r+bw])) outcoords_sphere.append(np.array([self.center-self.radius\ -self.boundary_width_radius, self.center+self.radius+self.boundary_width_radius])) oncoords_rect.append(np.array([l, r])) self.outcoords_rect = util.meshgrid_ndim(outcoords_rect) self.oncoords_rect = util.meshgrid_ndim(oncoords_rect) self.outcoords_sphere = util.meshgrid_ndim(outcoords_sphere) self.oncoords_sphere = np.row_stack((-np.eye(dim), np.eye(dim).transpose()))*self.radius+self.center print "SPHERE", self.center, self.radius, self.oncoords_sphere
def setUp(self): """ Set up problem. """ emulated_input_samples = sample.sample_set(2) emulated_input_samples.set_domain(np.array([[0.0, 1.0], [0.0, 1.0]])) emulated_input_samples.set_values_local( util.meshgrid_ndim( (np.linspace(emulated_input_samples.get_domain()[0][0], emulated_input_samples.get_domain()[0][1], 10), np.linspace(emulated_input_samples.get_domain()[1][0], emulated_input_samples.get_domain()[1][1], 10)))) emulated_input_samples.set_probabilities_local( 1.0 / float(comm.size) * (1.0 / float(emulated_input_samples.get_values_local().shape[0])) * np.ones((emulated_input_samples.get_values_local().shape[0], ))) emulated_input_samples.set_volumes_local( 1.0 / float(comm.size) * (1.0 / float(emulated_input_samples.get_values_local().shape[0])) * np.ones((emulated_input_samples.get_values_local().shape[0], ))) emulated_input_samples.check_num() self.samples = emulated_input_samples
def setUp(self): """ Test dimension, number of samples, and that all the samples are within lambda_domain. """ lam_left = np.array([0.0, .25, .4]) lam_right = np.array([1.0, 4.0, .5]) lam_width = lam_right-lam_left self.lam_domain = np.zeros((3, 3)) self.lam_domain[:, 0] = lam_left self.lam_domain[:, 1] = lam_right num_samples_dim = 2 start = lam_left+lam_width/(2*num_samples_dim) stop = lam_right-lam_width/(2*num_samples_dim) d1_arrays = [] for l, r in zip(start, stop): d1_arrays.append(np.linspace(l, r, num_samples_dim)) self.num_l_emulate = 1000001 self.lambda_emulate = calcP.emulate_iid_lebesgue(self.lam_domain, self.num_l_emulate) self.samples = util.meshgrid_ndim(d1_arrays) self.volume_exact = 1.0/self.samples.shape[0] self.lam_vol, self.lam_vol_local, self.local_index = calcP.\ estimate_volume(self.samples, self.lambda_emulate)
def center_and_layer1_points(center_pts_per_edge, center, r_ratio, sur_domain): r""" Generates a regular grid of center points that define the voronoi tesselation of exactly the interior of a hyperrectangle centered at ``center`` with sides of length ``r_ratio*sur_width`` and the layers of voronoi cells that bound these interior cells. The resulting voronoi tesselation exactly represents the hyperrectangle. This method can also be used to tile ``sur_domain`` with points to define voronoi regions if the user sets ``r_ratio = 1``. :param list() center_pts_per_edge: number of center points per edge and additional two points will be added to create the bounding layer :param center: location of the center of the hyperrectangle :type center: :class:`numpy.ndarray` of shape (mdim,) :param r_ratio: ratio of the length of the sides of the hyperrectangle to the surrounding domain :type r_ratio: double or list() :param sur_domain: minima and maxima of each dimension defining the surrounding domain :type sur_domain: :class:`numpy.ndarray` of shape (mdim, 2) :rtype: tuple :returns: (points, interior_and_layer1) where where points is an :class:`numpy.ndarray` of shape (num_points, dim), interior_and_layer1 is a list() of dim :class:`numpy.ndarray`s of shape (center_pts_per_edge+2,). """ if np.all(np.greater(r_ratio, 1)): msg = "The hyperrectangle defined by this ratio is larger than the" msg += "original domain." print msg # determine the width of the surrounding domain sur_width = sur_domain[:, 1]-sur_domain[:, 0] # determine the hyperrectangle defined by center and r_ratio rect_width = r_ratio*sur_width rect_domain = np.empty(sur_domain.shape) rect_domain[:, 0] = center - .5*rect_width rect_domain[:, 1] = center + .5*rect_width # determine the locations of the points for the 1st bounding layer layer1_left = rect_domain[:, 0]-rect_width/(2*center_pts_per_edge) layer1_right = rect_domain[:, 1]+rect_width/(2*center_pts_per_edge) interior_and_layer1 = list() for dim in xrange(sur_domain.shape[0]): # create interior points and 1st layer int_l1 = np.linspace(layer1_left[dim], layer1_right[dim], center_pts_per_edge[dim]+2) interior_and_layer1.append(int_l1) # use meshgrid to make the hyperrectangle shells if sur_domain.shape[0] == 1: points = interior_and_layer1[0] else: points = util.meshgrid_ndim(interior_and_layer1) return (points, interior_and_layer1, rect_domain)
def test_meshgrid_ndim(): """ Tests :meth:`bet.util.meshgrid_ndim` for upto 10 vectors where each vector is equal to ``[0, 1]``. """ for i in xrange(10): x = [[0, 1] for v in xrange(i + 1)] yield compare_to_bin_rep, util.meshgrid_ndim(x)
def center_and_layer1_points_binsize(center_pts_per_edge, center, r_size, sur_domain): """ Generates a regular grid of center points that define the voronoi tesselation of exactly the interior of a hyperrectangle centered at ``center`` with sides of length ``r_size`` and the layers of voronoi cells that bound these interior cells. The resulting voronoi tesselation exactly represents the hyperrectangle. This method can also be used to tile ``sur_domain`` with points to define voronoi regions if the user sets ``r_ratio = 1``. (use binratio) :param list() center_pts_per_edge: number of center points per edge and additional two points will be added to create the bounding layer :param center: location of the center of the hyperrectangle :type center: :class:`numpy.ndarray` of shape (mdim,) :param r_size: size of the length of the sides of the hyperrectangle rect_domain to definie voronoi cells for :type r_size: double or list() :param sur_domain: minima and maxima of each dimension defining the surrounding domain. The surrounding domain is the bounded domain in the data space (i.e. the data domain). :type sur_domain: :class:`numpy.ndarray` of shape (mdim, 2) :rtype: tuple :returns: (points, interior_and_layer1, rect_domain) where where points is an :class:`numpy.ndarray` of shape (num_points, dim), interior_and_layer1 is a list() of dim :class:`numpy.ndarray`s of shape (center_pts_per_edge+2,), rect_domain is a :class:`numpy.ndarray` of shape (mdim, 2) """ # determine the hyperrectangle (rect_domain) defined by center and r_size rect_width = r_size * np.ones(sur_domain[:, 0].shape) rect_domain = np.column_stack( [center - .5 * rect_width, center + .5 * rect_width]) if np.all(np.greater(r_size, rect_width)): msg = "The hyperrectangle defined by this size is larger than the " msg += "original domain." print msg # determine the locations of the points for the 1st bounding layer layer1_left = rect_domain[:, 0] - rect_width / (2 * center_pts_per_edge) layer1_right = rect_domain[:, 1] + rect_width / (2 * center_pts_per_edge) interior_and_layer1 = list() for dim in xrange(sur_domain.shape[0]): # create interior points and 1st layer int_l1 = np.linspace(layer1_left[dim], layer1_right[dim], center_pts_per_edge[dim] + 2) interior_and_layer1.append(int_l1) # use meshgrid to make the hyperrectangle shells points = util.meshgrid_ndim(interior_and_layer1) return (points, interior_and_layer1, rect_domain)
def setUp(self): """ Set up problem. """ self.lam_domain = np.array([[0.0, 1.0], [0.0, 1.0]]) self.samples = util.meshgrid_ndim( (np.linspace(self.lam_domain[0][0], self.lam_domain[0][1], 10), np.linspace(self.lam_domain[1][0], self.lam_domain[1][1], 10))) self.P_samples = 1.0 / float( comm.size) * (1.0 / float(self.samples.shape[0])) * np.ones( (self.samples.shape[0], ))
def setUp(self): """ Set up problem. """ self.lam_domain = np.array([[0.0, 1.0], [0.0, 1.0]]) self.samples = util.meshgrid_ndim( ( np.linspace(self.lam_domain[0][0], self.lam_domain[0][1], 10), np.linspace(self.lam_domain[1][0], self.lam_domain[1][1], 10), ) ) self.P_samples = ( 1.0 / float(comm.size) * (1.0 / float(self.samples.shape[0])) * np.ones((self.samples.shape[0],)) )
def setUp(self): points = list() self.edges = list() for dim in xrange(self.mdim): points_dim = np.linspace(self.sur_domain[dim, 0], self.sur_domain[dim, 1], 4) points.append(points_dim[1:-1]) self.edges.append((points_dim[1:]+points_dim[:-1])/2.0) self.points = util.meshgrid_ndim(points) self.H, _ = np.histogramdd(self.points, self.edges, normed=True) volume = 1.0/(self.H*(2.0**self.mdim)) self.volume = volume.ravel() output = vHist.histogramdd_volumes(self.edges, self.points) self.o_H, self.o_volume, self.o_edges = output
def setUp(self): points = list() self.edges = list() for dim in xrange(self.mdim): points_dim = np.linspace(self.sur_domain[dim, 0], self.sur_domain[dim, 1], 4) points.append(points_dim[1:-1]) self.edges.append((points_dim[1:] + points_dim[:-1]) / 2.0) self.points = util.meshgrid_ndim(points) self.H, _ = np.histogramdd(self.points, self.edges, normed=True) volume = 1.0 / (self.H * (2.0**self.mdim)) self.volume = volume.ravel() output = vHist.histogramdd_volumes(self.edges, self.points) self.o_H, self.o_volume, self.o_edges = output
def setUp(self): """ Set up problem. """ self.lam_domain = np.array([[0.0, 1.0], [0.0, 1.0], [0.0, 1.0], [0.0, 1.0]]) self.samples = util.meshgrid_ndim( (np.linspace(self.lam_domain[0][0], self.lam_domain[0][1], 10), np.linspace(self.lam_domain[1][0], self.lam_domain[1][1], 10), np.linspace(self.lam_domain[1][0], self.lam_domain[1][1], 10), np.linspace(self.lam_domain[1][0], self.lam_domain[1][1], 10))) self.data = self.samples * 3.0 self.P_samples = (1.0 / float(self.samples.shape[0])) * np.ones( (self.samples.shape[0], )) self.filename = "testfigure" QoI_range = np.array([3.0, 3.0, 3.0, 3.0]) Q_ref = QoI_range * 0.5 bin_size = 0.15 * QoI_range maximum = 1 / np.product(bin_size) def ifun(outputs): """ Indicator function. :param outputs: outputs :type outputs: :class:`numpy.ndarray` of shape (N, ndim) :rtype: :class:`numpy.ndarray` of shape (N,) :returns: 0 if outside of set or positive number if inside set """ left = np.repeat([Q_ref - .5 * bin_size], outputs.shape[0], 0) right = np.repeat([Q_ref + .5 * bin_size], outputs.shape[0], 0) left = np.all(np.greater_equal(outputs, left), axis=1) right = np.all(np.less_equal(outputs, right), axis=1) inside = np.logical_and(left, right) max_values = np.repeat(maximum, outputs.shape[0], 0) return inside.astype('float64') * max_values self.rho_D = ifun self.lnums = [1, 2, 3] self.markers = [] for m in Line2D.markers: try: if len(m) == 1 and m != ' ': self.markers.append(m) except TypeError: pass self.colors = ('b', 'g', 'r', 'c', 'm', 'y', 'k')
def setUp(self): """ Set up problem. """ emulated_input_samples = sample.sample_set(2) emulated_input_samples.set_domain(np.array([[0.0,1.0],[0.0,1.0]])) emulated_input_samples.set_values_local(util.meshgrid_ndim((np.linspace(emulated_input_samples.get_domain()[0][0], emulated_input_samples.get_domain()[0][1], 10), np.linspace(emulated_input_samples.get_domain()[1][0], emulated_input_samples.get_domain()[1][1], 10)))) emulated_input_samples.set_probabilities_local(1.0/float(comm.size)*\ (1.0/float(emulated_input_samples.get_values_local().shape[0]))*\ np.ones((emulated_input_samples.get_values_local().shape[0],))) emulated_input_samples.check_num() self.samples = emulated_input_samples
def setUp(self): """ Set up problem. """ self.lam_domain = np.array([[0.0, 1.0], [0.0, 1.0], [0.0, 1.0], [0.0, 1.0]]) self.samples = util.meshgrid_ndim((np.linspace(self.lam_domain[0][0], self.lam_domain[0][1], 10), np.linspace(self.lam_domain[1][0], self.lam_domain[1][1], 10), np.linspace(self.lam_domain[1][0], self.lam_domain[1][1], 10), np.linspace(self.lam_domain[1][0], self.lam_domain[1][1], 10))) self.data = self.samples*3.0 self.P_samples = (1.0/float(self.samples.shape[0]))*np.ones((self.samples.shape[0],)) self.filename = "testfigure" QoI_range = np.array([3.0, 3.0, 3.0, 3.0]) Q_ref = QoI_range*0.5 bin_size = 0.15*QoI_range maximum = 1/np.product(bin_size) def ifun(outputs): """ Indicator function. :param outputs: outputs :type outputs: :class:`numpy.ndarray` of shape (N, ndim) :rtype: :class:`numpy.ndarray` of shape (N,) :returns: 0 if outside of set or positive number if inside set """ left = np.repeat([Q_ref-.5*bin_size], outputs.shape[0], 0) right = np.repeat([Q_ref+.5*bin_size], outputs.shape[0], 0) left = np.all(np.greater_equal(outputs, left), axis=1) right = np.all(np.less_equal(outputs, right), axis=1) inside = np.logical_and(left, right) max_values = np.repeat(maximum, outputs.shape[0], 0) return inside.astype('float64')*max_values self.rho_D = ifun self.lnums = [1, 2, 3] self.markers = [] for m in Line2D.markers: try: if len(m) == 1 and m != ' ': self.markers.append(m) except TypeError: pass self.colors = ('b', 'g', 'r', 'c', 'm', 'y', 'k')
def setUp(self): """ Set up the problem """ points = list() edges = list() self.rect_domain = np.empty((self.mdim, 2)) for dim in xrange(self.mdim): points_dim = np.linspace(self.sur_domain[dim, 0], self.sur_domain[dim, 1], 4) points.append(points_dim[1:-1]) edge = (points_dim[1:]+points_dim[:-1])/2.0 edges.append(edge) self.rect_domain[dim, :] = edge[[0, -1]] points = util.meshgrid_ndim(points) H, _ = np.histogramdd(points, edges, normed=True) volume = 1.0/(H*(2.0**self.mdim)) volumes = volume.ravel() output = vHist.simple_fun_uniform(points, volumes, self.rect_domain) self.rho_D_M, self.d_distr_samples, self.d_Tree = output
def setUp(self): """ Set up the problem """ points = list() edges = list() self.rect_domain = np.empty((self.mdim, 2)) for dim in xrange(self.mdim): points_dim = np.linspace(self.sur_domain[dim, 0], self.sur_domain[dim, 1], 4) points.append(points_dim[1:-1]) edge = (points_dim[1:] + points_dim[:-1]) / 2.0 edges.append(edge) self.rect_domain[dim, :] = edge[[0, -1]] points = util.meshgrid_ndim(points) H, _ = np.histogramdd(points, edges, normed=True) volume = 1.0 / (H * (2.0**self.mdim)) volumes = volume.ravel() output = vHist.simple_fun_uniform(points, volumes, self.rect_domain) self.rho_D_M, self.d_distr_samples, self.d_Tree = output
def test_points(self): """ Test that the points are correct. """ nptest.assert_array_almost_equal( self.points, util.meshgrid_ndim(self.interior_and_layer1))
def test_points(self): """ Test that the points are correct. """ nptest.assert_array_almost_equal(self.points, util.meshgrid_ndim(self.interior_and_layer1))
def setUp(self): """ Set up problem. """ # Create sample_set object for input_samples input_samples = sample.sample_set(4) input_samples.set_domain(np.array([[0.0, 1.0], [0.0, 1.0], [0.0, 1.0], [0.0, 1.0]])) input_samples.set_values(util.meshgrid_ndim( (np.linspace(input_samples.get_domain()[0, 0], input_samples.get_domain()[0, 1], 3), np.linspace(input_samples.get_domain()[1, 0], input_samples.get_domain()[1, 1], 3), np.linspace(input_samples.get_domain()[2, 0], input_samples.get_domain()[2, 1], 3), np.linspace(input_samples.get_domain()[3, 0], input_samples.get_domain()[3, 1], 3)))) input_samples.set_probabilities( (1.0/float(input_samples.get_values().shape[0])) * np.ones((input_samples.get_values().shape[0],))) # Check that probabilities and values arrays have same number of entries input_samples.check_num() # Create sample_set object for output_samples output_samples = sample.sample_set(4) output_samples.set_values(input_samples.get_values()*3.0) output_samples.set_domain(3.0*input_samples.get_domain()) self.disc = sample.discretization(input_samples, output_samples) self.filename = "testfigure" output_ref_datum = np.mean(output_samples.get_domain(), axis=1) bin_size = 0.15*(np.max(output_samples.get_domain(), axis=1) - np.min(output_samples.get_domain(), axis=1)) maximum = 1/np.product(bin_size) def ifun(outputs): """ Indicator function. :param outputs: outputs :type outputs: :class:`numpy.ndarray` of shape (N, ndim) :rtype: :class:`numpy.ndarray` of shape (N,) :returns: 0 if outside of set or positive number if inside set """ left = np.repeat([output_ref_datum-.5*bin_size], outputs.shape[0], 0) right = np.repeat([output_ref_datum+.5*bin_size], outputs.shape[0], 0) left = np.all(np.greater_equal(outputs, left), axis=1) right = np.all(np.less_equal(outputs, right), axis=1) inside = np.logical_and(left, right) max_values = np.repeat(maximum, outputs.shape[0], 0) return inside.astype('float64')*max_values self.rho_D = ifun self.lnums = [1, 2, 3] self.markers = [] for m in Line2D.markers: try: if len(m) == 1 and m != ' ': self.markers.append(m) except TypeError: pass self.colors = ('b', 'g', 'r', 'c', 'm', 'y', 'k')