def uniform_hyperrectangle(data, Q_ref, bin_ratio, center_pts_per_edge=1): r""" Creates a simple function approximation of :math:`\rho_{\mathcal{D},M}` where :math:`\rho_{\mathcal{D},M}` is a uniform probability density centered at Q_ref with bin_ratio of the width of D. Since rho_D is a uniform distribution on a hyperrectanlge we should be able to represent it exactly with ``M = 3^mdim`` or rather ``len(d_distr_samples) == 3^mdim``. :param bin_ratio: The ratio used to determine the width of the uniform distributiion as ``bin_size = (data_max-data_min)*bin_ratio`` :type bin_ratio: double or list() :param int num_d_emulate: Number of samples used to emulate using an MC assumption :param data: Array containing QoI data where the QoI is mdim diminsional :type data: :class:`~numpy.ndarray` of size (num_samples, mdim) :param Q_ref: :math:`Q(\lambda_{reference})` :type Q_ref: :class:`~numpy.ndarray` of size (mdim,) :param list() center_pts_per_edge: number of center points per edge and additional two points will be added to create the bounding layer :rtype: tuple :returns: (rho_D_M, d_distr_samples, d_Tree) where ``rho_D_M`` and ``d_distr_samples`` are (mdim, M) :class:`~numpy.ndarray` and `d_Tree` is the :class:`~scipy.spatial.KDTree` for d_distr_samples """ if len(data.shape) == 1: data = np.expand_dims(data, axis=1) data_max = np.max(data, 0) data_min = np.min(data, 0) # TO-DO: Check for inputted center_pts_per_edge in case given as list # or as numpy array to see if dimensions match data space dimensions and # that positive integer values are being used. Also, create this change # elsewhere since center_pts_per_edge is only a scalar if dim(D)=1. if not isinstance(center_pts_per_edge, np.ndarray): center_pts_per_edge = np.ones((data.shape[1])) * center_pts_per_edge else: if not len(center_pts_per_edge) == data.shape[1]: center_pts_per_edge = np.ones((data.shape[1])) print 'Warning: center_pts_per_edge dimension mismatch.' print 'Using 1 in each dimension.' sur_domain = np.zeros((data.shape[1], 2)) sur_domain[:, 0] = data_min sur_domain[:, 1] = data_max points, _, rect_domain = vHist.center_and_layer1_points(center_pts_per_edge, Q_ref, bin_ratio, sur_domain) edges = vHist.edges_regular(center_pts_per_edge, Q_ref, bin_ratio, sur_domain) _, volumes, _ = vHist.histogramdd_volumes(edges, points) return vHist.simple_fun_uniform(points, volumes, rect_domain)
def uniform_hyperrectangle_binsize(data, Q_ref, bin_size, center_pts_per_edge=1): r""" Creates a simple function approximation of :math:`\rho_{\mathcal{D},M}` where :math:`\rho_{\mathcal{D},M}` is a uniform probability density centered at Q_ref with bin_size of the width of D. Since rho_D is a uniform distribution on a hyperrectanlge we should be able to represent it exactly with ``M = 3^mdim`` or rather ``len(d_distr_samples) == 3^mdim``. :param bin_size: The size used to determine the width of the uniform distribution :type bin_size: double or list() :param int num_d_emulate: Number of samples used to emulate using an MC assumption :param data: Array containing QoI data where the QoI is mdim diminsional :type data: :class:`~numpy.ndarray` of size (num_samples, mdim) :param Q_ref: :math:`Q(\lambda_{reference})` :type Q_ref: :class:`~numpy.ndarray` of size (mdim,) :param list() center_pts_per_edge: number of center points per edge and additional two points will be added to create the bounding layer :rtype: tuple :returns: (rho_D_M, d_distr_samples, d_Tree) where ``rho_D_M`` is (M,) and ``d_distr_samples`` are (M, mdim) :class:`~numpy.ndarray` and `d_Tree` is the :class:`~scipy.spatial.KDTree` for d_distr_samples """ data = util.fix_dimensions_data(data) if not isinstance(center_pts_per_edge, collections.Iterable): center_pts_per_edge = np.ones((data.shape[1],)) * center_pts_per_edge else: if not len(center_pts_per_edge) == data.shape[1]: center_pts_per_edge = np.ones((data.shape[1],)) print 'Warning: center_pts_per_edge dimension mismatch.' print 'Using 1 in each dimension.' if np.any(np.less(center_pts_per_edge, 0)): print 'Warning: center_pts_per_edge must be greater than 0' if not isinstance(bin_size, collections.Iterable): bin_size = bin_size*np.ones((data.shape[1],)) if np.any(np.less(bin_size, 0)): print 'Warning: center_pts_per_edge must be greater than 0' sur_domain = np.array([np.min(data, 0), np.max(data, 0)]).transpose() points, _, rect_domain = vHist.center_and_layer1_points_binsize\ (center_pts_per_edge, Q_ref, bin_size, sur_domain) edges = vHist.edges_regular(center_pts_per_edge, rect_domain, sur_domain) _, volumes, _ = vHist.histogramdd_volumes(edges, points) return vHist.simple_fun_uniform(points, volumes, rect_domain)
def uniform_hyperrectangle_binsize(data, Q_ref, bin_size, center_pts_per_edge=1): r""" Creates a simple function approximation of :math:`\rho_{\mathcal{D},M}` where :math:`\rho_{\mathcal{D},M}` is a uniform probability density centered at Q_ref with bin_size of the width of D. Since rho_D is a uniform distribution on a hyperrectanlge we should be able to represent it exactly with ``M = 3^mdim`` or rather ``len(d_distr_samples) == 3^mdim``. :param bin_size: The size used to determine the width of the uniform distribution :type bin_size: double or list() :param int num_d_emulate: Number of samples used to emulate using an MC assumption :param data: Array containing QoI data where the QoI is mdim diminsional :type data: :class:`~numpy.ndarray` of size (num_samples, mdim) :param Q_ref: :math:`Q(\lambda_{reference})` :type Q_ref: :class:`~numpy.ndarray` of size (mdim,) :param list() center_pts_per_edge: number of center points per edge and additional two points will be added to create the bounding layer :rtype: tuple :returns: (rho_D_M, d_distr_samples, d_Tree) where ``rho_D_M`` is (M,) and ``d_distr_samples`` are (M, mdim) :class:`~numpy.ndarray` and `d_Tree` is the :class:`~scipy.spatial.KDTree` for d_distr_samples """ data = util.fix_dimensions_data(data) if not isinstance(center_pts_per_edge, collections.Iterable): center_pts_per_edge = np.ones((data.shape[1],)) * center_pts_per_edge else: if not len(center_pts_per_edge) == data.shape[1]: center_pts_per_edge = np.ones((data.shape[1],)) print 'Warning: center_pts_per_edge dimension mismatch.' print 'Using 1 in each dimension.' if np.any(np.less(center_pts_per_edge, 0)): print 'Warning: center_pts_per_edge must be greater than 0' if not isinstance(bin_size, collections.Iterable): bin_size = bin_size*np.ones((data.shape[1],)) if np.any(np.less(bin_size, 0)): print 'Warning: center_pts_per_edge must be greater than 0' sur_domain = np.array([np.min(data, 0), np.max(data, 0)]).transpose() points, _, rect_domain = vHist.center_and_layer1_points_binsize(center_pts_per_edge, Q_ref, bin_size, sur_domain) edges = vHist.edges_regular(center_pts_per_edge, rect_domain, sur_domain) _, volumes, _ = vHist.histogramdd_volumes(edges, points) return vHist.simple_fun_uniform(points, volumes, rect_domain)
def uniform_hyperrectangle_binsize(data, Q_ref, bin_size, center_pts_per_edge=1): r""" Creates a simple function approximation of :math:`\rho_{\mathcal{D},M}` where :math:`\rho_{\mathcal{D},M}` is a uniform probability density centered at Q_ref with bin_size of the width of D. Since rho_D is a uniform distribution on a hyperrectanlge we should be able to represent it exactly with ``M = 3^mdim`` or rather ``len(d_distr_samples) == 3^mdim``. :param bin_size: The size used to determine the width of the uniform distribution :type bin_size: double or list() :param int num_d_emulate: Number of samples used to emulate using an MC assumption :param data: Array containing QoI data where the QoI is mdim diminsional :type data: :class:`~numpy.ndarray` of size (num_samples, mdim) :param Q_ref: :math:`Q(\lambda_{reference})` :type Q_ref: :class:`~numpy.ndarray` of size (mdim,) :param list() center_pts_per_edge: number of center points per edge and additional two points will be added to create the bounding layer :rtype: tuple :returns: (rho_D_M, d_distr_samples, d_Tree) where ``rho_D_M`` and ``d_distr_samples`` are (mdim, M) :class:`~numpy.ndarray` and `d_Tree` is the :class:`~scipy.spatial.KDTree` for d_distr_samples """ if len(data.shape) == 1: data = np.expand_dims(data, axis=1) data_max = np.max(data, 0) data_min = np.min(data, 0) sur_domain = np.zeros((data.shape[1], 2)) sur_domain[:, 0] = data_min sur_domain[:, 1] = data_max points, _, rect_domain = vHist.center_and_layer1_points_binsize(center_pts_per_edge, Q_ref, bin_size, sur_domain) edges = vHist.edges_regular_binsize(center_pts_per_edge, Q_ref, bin_size, sur_domain) _, volumes, _ = vHist.histogramdd_volumes(edges, points) return vHist.simple_fun_uniform(points, volumes, rect_domain)
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