GaussProductExperiment¶

(Source code, png)

class GaussProductExperiment(*args)¶

Gauss product experiment.

Available constructors:

GaussProductExperiment(marginalSizes)

GaussProductExperiment(distribution)

GaussProductExperiment(distribution, marginalSizes)

Parameters:

marginalSizessequence of positive int: Numbers of nodes $s_j$ for each direction. Then, the total number of nodes generated is $\textrm{card}(I)=\prod_{j = 1}^{d_x} s_j$ . By default, the value of $s_j$ is equal to $5$ . The default marginal size is defined in the GaussProductExperiment-DefaultMarginalSize key of the ResourceMap.
distribution: Distribution $\mu$ of dimension $d_x$ with an independent copula.

Methods

`generate`()	Generate points according to the type of the experiment.
`generateWithWeights`()	Generate points and their associated weight according to the type of the experiment.
`getClassName`()	Accessor to the object's name.
`getDistribution`()	Accessor to the distribution.
`getMarginalSizes`()	Get the marginal sizes.
`getName`()	Accessor to the object's name.
`getSize`()	Accessor to the size of the generated sample.
`hasName`()	Test if the object is named.
`hasUniformWeights`()	Ask whether the experiment has uniform weights.
`isRandom`()	Accessor to the randomness of quadrature.
`setDistribution`(distribution)	Accessor to the distribution.
`setMarginalSizes`(marginalSizes)	Set the marginal sizes.
`setName`(name)	Accessor to the object's name.
`setSize`(size)	Accessor to the size of the generated sample.

See also

WeightedExperiment, TensorProductExperiment, GaussLegendre

Notes

The Gauss product experiment is a tensor product experiment which uses Gauss nodes in each direction. Using the notations of the TensorProductExperiment documentation, the number of marginal experiments is equal to $n_e = d_x$ and the dimension of each marginal experiment is $d_j=1$ for every index $j = 1, ..., n_e$ .

For each marginal, the algorithm computes the family of orthogonal polynomials depending on the marginal distribution using the StandardDistributionPolynomialFactory class. The input distribution must have an independent copula.

The GaussLegendre class provides a simple algorithm to use Gaussian quadrature with Legendre polynomials.

Polynomial exactness

The Gauss tensor product quadrature rule is exact for polynomials up to some degree. More precisely, for any $m_i \in \Nset$ , let $\mathcal{P}_{m_i}^{(1)}$ be the set of mono-variable polynomials of degree lower or equal to $m_i$ . Consider the tensor product of 1D polynomials:

$\bigotimes_{i = 1}^\inputDim \mathcal{P}_{m_i}^{(1)} = \left\{ (x_1, ..., x_\inputDim)\in\Rset^\inputDim \rightarrow \prod_{i = 1}^\inputDim p_i(x_i) \in \Rset, \quad p_i \in \mathcal{P}_{m_i}^{(1)} \right\}.$

Therefore the Gauss-Legendre tensorized quadrature is exact for all polynomials of the vector space:

$\bigotimes_{i = 1}^\inputDim \mathcal{P}_{2 s_i - 1}^{(1)}.$

Examples

>>> import openturns as ot
>>> marginal_1 = ot.Exponential()
>>> marginal_2 = ot.Triangular(-1.0, -0.5, 1.0)
>>> distribution = ot.JointDistribution([marginal_1, marginal_2])
>>> marginalSizes = [3, 2]
>>> experiment = ot.GaussProductExperiment(distribution, marginalSizes)
>>> nodes, weights = experiment.generateWithWeights()
>>> print(nodes)
    [ X0        X1        ]
0 : [  0.415775 -0.511215 ]
1 : [  2.29428  -0.511215 ]
2 : [  6.28995  -0.511215 ]
3 : [  0.415775  0.357369 ]
4 : [  2.29428   0.357369 ]
5 : [  6.28995   0.357369 ]
>>> print(weights)
[0.429018,0.168036,0.00626806,0.282075,0.110482,0.00412119]

In the following example [morokoff1995], we integrate a dimension 5 integrand with $\mathcal{U}(0, 1)$ marginal probability density functions. We use 7 nodes for each marginal, leading to a total of $7^5 = 16807$ nodes for the tensor product Gauss quadrature.

>>> import openturns as ot
>>> def g_function_py(x):
...     value = (1.0 + 1.0 / dimension) ** dimension
...     for i in range(dimension):
...         value *= x[i] ** (1.0 / dimension)
...     return [value]
>>> 
>>> dimension = 5
>>> g_function = ot.PythonFunction(dimension, 1, g_function_py)
>>> interval = ot.Interval([0.0] * dimension, [1.0] * dimension)
>>> integral = 1.0
>>> print('Exact integral = ', integral)
Exact integral =  1.0
>>> marginal_levels = [7] * dimension
>>> distribution = ot.JointDistribution([ot.Uniform(0.0, 1.0)] * dimension)
>>> experiment = ot.GaussProductExperiment(distribution, marginal_levels)
>>> nodes, weights = experiment.generateWithWeights()
>>> number_of_nodes = nodes.getSize()
>>> print('Number of nodes = ', number_of_nodes)
Number of nodes =  16807
>>> function_values = g_function(nodes).asPoint()
>>> approximate_integral = function_values.dot(weights)
>>> print('Approximate integral = ', approximate_integral)
Approximate integral =  1.0040...

__init__(*args)¶

generate()¶

Generate points according to the type of the experiment.

Returns:

sampleSample: Points $(\inputReal_i)_{i = 1, ..., \sampleSize}$ of the design of experiments. The sampling method is defined by the type of the weighted experiment.

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> myExperiment = ot.MonteCarloExperiment(ot.Normal(2), 5)
>>> sample = myExperiment.generate()
>>> print(sample)
    [ X0        X1        ]
0 : [  0.608202 -1.26617  ]
1 : [ -0.438266  1.20548  ]
2 : [ -2.18139   0.350042 ]
3 : [ -0.355007  1.43725  ]
4 : [  0.810668  0.793156 ]

generateWithWeights()¶

Generate points and their associated weight according to the type of the experiment.

Returns:

sampleSample: The points of the design of experiments. The sampling method is defined by the nature of the experiment.
weightsPoint of size $\sampleSize$: Weights $(w_i)_{i = 1, ..., \sampleSize}$ associated with the points. By default, all the weights are equal to $\frac{1}{\sampleSize}$ .

Examples

>>> import openturns as ot
>>> ot.RandomGenerator.SetSeed(0)
>>> myExperiment = ot.MonteCarloExperiment(ot.Normal(2), 5)
>>> sample, weights = myExperiment.generateWithWeights()
>>> print(sample)
    [ X0        X1        ]
0 : [  0.608202 -1.26617  ]
1 : [ -0.438266  1.20548  ]
2 : [ -2.18139   0.350042 ]
3 : [ -0.355007  1.43725  ]
4 : [  0.810668  0.793156 ]
>>> print(weights)
[0.2,0.2,0.2,0.2,0.2]