def discretizeBernoulliFromConditionalProbability(conditionalProbability,
conditioningDistribution,
ticks,
useSlowIntegration=True,
nodesNumber=32):
conditioningDimension = conditioningDistribution.getDimension()
if useSlowIntegration:
# Accurate but slow
integrator = ot.IteratedQuadrature()
else:
# Less accurate for non-smooth integrand but fast
ot.ResourceMap.SetAsUnsignedInteger(
"GaussLegendre-DefaultMarginalIntegrationPointsNumber",
nodesNumber)
integrator = ot.GaussLegendre(conditioningDimension)
# Add the range bounds to the given ticks
lower = list(conditioningDistribution.getRange().getLowerBound())
upper = list(conditioningDistribution.getRange().getUpperBound())
# Add the range bounds to the given ticks
lower = conditioningDistribution.getRange().getLowerBound()
upper = conditioningDistribution.getRange().getUpperBound()
expandedTicks = [0] * len(ticks)
for i in range(conditioningDimension):
expandedTicks[i] = [lower[i]] + ticks[i] + [upper[i]]
# Now perform the full discretization
lengths = [(len(t) - 1) for t in expandedTicks]
tuples = ot.Tuples(lengths).generate()
probabilitiesTrue = [0] * len(tuples)
def kernel(x):
x = np.array(x)
return conditionalProbability(x) * np.array(
conditioningDistribution.computePDF(x[:, 0:conditioningDimension]))
for i in range(len(tuples)):
tuple = tuples[i]
aConditioning = [
expandedTicks[j][tuple[j]] for j in range(conditioningDimension)
]
bConditioning = [
expandedTicks[j][tuple[j] + 1]
for j in range(conditioningDimension)
]
den = conditioningDistribution.computeProbability(
ot.Interval(aConditioning, bConditioning))
if den > 0.0:
num = integrator.integrate(
ot.PythonFunction(conditioningDimension, 1,
func_sample=kernel),
ot.Interval(aConditioning, bConditioning))[0]
probabilitiesTrue[i] = min(1.0, num / den)
probabilities = ot.Point([1.0 - p for p in probabilitiesTrue] +
probabilitiesTrue)
return probabilities
def discretizeFromConditionalDensity(conditionalDensity,
conditioningDistribution,
ticks,
useSlowIntegration=True,
nodesNumber=32):
fullDimension = conditioningDistribution.getDimension() + 1
if useSlowIntegration:
# Accurate but slow
integrator = ot.IteratedQuadrature()
else:
# Less accurate for non-smooth integrand but fast
ot.ResourceMap.SetAsUnsignedInteger(
"GaussLegendre-DefaultMarginalIntegrationPointsNumber",
nodesNumber)
integrator = ot.GaussLegendre(fullDimension)
# Add the range bounds to the given ticks
lower = list(conditioningDistribution.getRange().getLowerBound())
upper = list(conditioningDistribution.getRange().getUpperBound())
# For the conditioned variable it has to be estimated. We assume that the given
# tick range is a correct margin to get the lower and upper bounds
conditionedMin = min(ticks[fullDimension - 1])
conditionedMax = max(ticks[fullDimension - 1])
delta = conditionedMax - conditionedMin
lower = lower + [conditionedMin - delta]
upper = upper + [conditionedMax + delta]
expandedTicks = [0] * fullDimension
for i in range(fullDimension):
expandedTicks[i] = [lower[i]] + ticks[i] + [upper[i]]
# Now perform the full discretization
lengths = [(len(t) - 1) for t in expandedTicks]
tuples = ot.Tuples(lengths).generate()
probabilities = ot.Point(len(tuples))
def kernel(x):
x = np.array(x)
return conditionalDensity(x) * np.array(
conditioningDistribution.computePDF(x[:, 0:fullDimension - 1]))
for i in range(len(tuples)):
tuple = tuples[i]
aFull = [expandedTicks[j][tuple[j]] for j in range(fullDimension)]
bFull = [expandedTicks[j][tuple[j] + 1] for j in range(fullDimension)]
num = integrator.integrate(
ot.PythonFunction(fullDimension, 1, func_sample=kernel),
ot.Interval(aFull, bFull))[0]
probabilities[i] = num
return probabilities
g = ot.Graph('IteratedQuadrature example', 'x', 'y', True, 'topright')
g.add(f.draw([a, a], [b, b]))
curve = l[0].draw(a, b).getDrawable(0)
curve.setLineWidth(2)
curve.setColor('red')
g.add(curve)
curve = u[0].draw(a, b).getDrawable(0)
curve.setLineWidth(2)
curve.setColor('red')
g.add(curve)
# Evaluate the integral with high precision:
Iref = ot.IteratedQuadrature(
ot.GaussKronrod(100000, 1e-13,
ot.GaussKronrodRule(
ot.GaussKronrodRule.G11K23))).integrate(f, a, b, l, u)
# Evaluate the integral with the default GaussKronrod algorithm:
f = ot.MemoizeFunction(f)
I1 = ot.IteratedQuadrature(ot.GaussKronrod()).integrate(f, a, b, l, u)
sample1 = f.getInputHistory()
print('I1=', I1, '#evals=', sample1.getSize(), 'err=',
abs(100.0 * (1.0 - I1[0] / Iref[0])), '%')
cloud = ot.Cloud(sample1)
cloud.setPointStyle('fcircle')
cloud.setColor('green')
g.add(cloud)
f.clearHistory()
ot.SoizeGhanemFactory(ot.ComposedDistribution(marginals, copula), False),
ot.SoizeGhanemFactory(ot.ComposedDistribution(marginals, copula), True)
]
x = [0.5] * 2
kMax = 5
ot.ResourceMap.SetAsUnsignedInteger("IteratedQuadrature-MaximumSubIntervals",
2048)
ot.ResourceMap.SetAsScalar("IteratedQuadrature-MaximumError", 1.0e-6)
for soize in factories:
distribution = soize.getMeasure()
print('SoizeGhanem=', soize)
functions = list()
for k in range(kMax):
functions.append(soize.build(k))
print('SoizeGhanem(', k, ')=', functions[k].getEvaluation())
print('SoizeGhanem(', k, ')(', x, '=', functions[k](x))
M = ot.SymmetricMatrix(kMax)
for m in range(kMax):
for n in range(m + 1):
def wrapper(x):
return functions[m](x) * functions[n](
x)[0] * distribution.computePDF(x)
kernel = ot.PythonFunction(distribution.getDimension(), 1, wrapper)
value = ot.IteratedQuadrature().integrate(
kernel, distribution.getRange())[0]
if abs(value) >= 1.0e-6:
M[m, n] = value
print('M=\n', M)
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
ot.TESTPREAMBLE()
ot.RandomGenerator.SetSeed(0)
# First, compute the volume of the unit ball in R^n
a = -1.0
b = 1.0
formula = "1.0"
lower = list()
upper = list()
algo = ot.IteratedQuadrature(
ot.GaussKronrod(20, 1.0e-6, ot.GaussKronrodRule(ot.GaussKronrodRule.G3K7)))
for n in range(3):
inVars = ot.Description.BuildDefault(n + 1, "x")
inVarsBounds = inVars[0:n]
if (n > 0):
formula += "-" + inVars[n - 1] + "^2"
lower.append(
ot.SymbolicFunction(inVarsBounds, ["-sqrt(" + formula + ")"]))
upper.append(
ot.SymbolicFunction(inVarsBounds, ["sqrt(" + formula + ")"]))
integrand = ot.SymbolicFunction(inVars, ["1.0"])
value = algo.integrate(integrand, a, b, lower, upper)[0]
print("dim=", n + 1, ", volume= %.12g" % value, ", calls=",
integrand.getCallsNumber())
# Second, integrate a multi-valued function
bounds = ot.Interval([-1.0] * 3, [1.0] * 3)
ot.Log.Show(ot.Log.NONE)
# %%
# define the integrand and the bounds
a = -m.pi
b = m.pi
f = ot.SymbolicFunction(['x', 'y'], ['1+cos(x)*sin(y)'])
l = [ot.SymbolicFunction(['x'], [' 2+cos(x)'])]
u = [ot.SymbolicFunction(['x'], ['-2-cos(x)'])]
# %%
# Draw the graph of the integrand and the bounds
g = ot.Graph('Integration nodes', 'x', 'y', True, 'topright')
g.add(f.draw([a, a], [b, b]))
curve = l[0].draw(a, b).getDrawable(0)
curve.setLineWidth(2)
curve.setColor('red')
g.add(curve)
curve = u[0].draw(a, b).getDrawable(0)
curve.setLineWidth(2)
curve.setColor('red')
g.add(curve)
view = viewer.View(g)
# %%
# compute the integral value
I2 = ot.IteratedQuadrature().integrate(f, a, b, l, u)
print(I2)
plt.show()
