def test_model(myModel, test_grad=True, x1=None, x2=None):
print('myModel = ', myModel)
spatialDimension = myModel.getSpatialDimension()
dimension = myModel.getDimension()
active = myModel.getActiveParameter()
print('active=', active)
print('parameter=', myModel.getParameter())
print('parameterDescription=', myModel.getParameterDescription())
if x1 is None and x2 is None:
x1 = ot.NumericalPoint(spatialDimension)
x2 = ot.NumericalPoint(spatialDimension)
for j in range(spatialDimension):
x1[j] = -1.0 - j
x2[j] = 3.0 + 2.0 * j
eps = 1e-5
print('myModel(', x1, ', ', x2, ')=', repr(myModel(x1, x2)))
grad = myModel.partialGradient(x1, x2)
print('dCov =', repr(grad))
if (dimension == 1):
gradfd = ot.NumericalPoint(spatialDimension)
for j in range(spatialDimension):
x1_d = ot.NumericalPoint(x1)
x1_d[j] = x1_d[j] + eps
gradfd[j] = (myModel(x1_d, x2)[0, 0] - myModel(x1, x2)[0, 0]) / eps
else:
gradfd = ot.Matrix(spatialDimension, dimension * dimension)
covarianceX1X2 = myModel(x1, x2)
# Symmetrize matrix
covarianceX1X2.getImplementation().symmetrize()
centralValue = ot.NumericalPoint(covarianceX1X2.getImplementation())
# Loop over the shifted points
for i in range(spatialDimension):
currentPoint = ot.NumericalPoint(x1)
currentPoint[i] += eps
localCovariance = myModel(currentPoint, x2)
localCovariance.getImplementation().symmetrize()
currentValue = ot.NumericalPoint(
localCovariance.getImplementation())
for j in range(currentValue.getSize()):
gradfd[i, j] = (currentValue[j] - centralValue[j]) / eps
print('dCov (FD)=', repr(gradfd))
if test_grad:
pGrad = myModel.parameterGradient(x1, x2)
precision = ot.PlatformInfo.GetNumericalPrecision()
ot.PlatformInfo.SetNumericalPrecision(4)
print('dCov/dP=', pGrad)
ot.PlatformInfo.SetNumericalPrecision(precision)
def test_model(myModel):
print("myModel = ", myModel)
spatialDimension = myModel.getSpatialDimension()
dimension = myModel.getDimension()
x1 = ot.NumericalPoint(spatialDimension)
x2 = ot.NumericalPoint(spatialDimension)
for j in range(spatialDimension):
x1[j] = -1.0 - j
x2[j] = 3.0 + 2.0 * j
eps = 1e-5
if (dimension == 1):
print("myModel(", x1, ", ", x2, ")=", myModel(x1, x2))
grad = myModel.partialGradient(x1, x2)
print("dCov =", grad)
gradfd = ot.NumericalPoint(spatialDimension)
for j in range(spatialDimension):
x1_d = ot.NumericalPoint(x1)
x1_d[j] = x1_d[j] + eps
gradfd[j] = (myModel(x1_d, x2)[0, 0] - myModel(x1, x2)[0, 0]) / eps
print("dCov (FD)=", gradfd)
else:
print("myModel(", x1, ", ", x2, ")=", repr(myModel(x1, x2)))
grad = myModel.partialGradient(x1, x2)
print("dCov =", repr(grad))
gradfd = ot.Matrix(spatialDimension, dimension * dimension)
covarianceX1X2 = myModel(x1, x2);
# Symmetrize matrix
covarianceX1X2.getImplementation().symmetrize()
centralValue = ot.NumericalPoint(covarianceX1X2.getImplementation())
# Loop over the shifted points
for i in range(spatialDimension):
currentPoint = ot.NumericalPoint(x1)
currentPoint[i] += eps
localCovariance = myModel(currentPoint, x2);
localCovariance.getImplementation().symmetrize()
currentValue = ot.NumericalPoint(localCovariance.getImplementation())
for j in range(currentValue.getSize()):
gradfd[i, j] = (currentValue[j] - centralValue[j]) / eps;
print("dCov (FD)=", repr(gradfd))
import openturns as ot
from matplotlib import pyplot as plt
from openturns.viewer import View
# Create a Box Cox transformation
myLambda = ot.NumericalPoint([0.0, 0.1, 1.0, 1.5])
graph = ot.Graph()
for i in range(myLambda.getDimension()):
myBoxCox = ot.BoxCoxTransform(myLambda[i])
graph.add(myBoxCox.draw(0.1, 2.1))
graph.setColors(['red', 'blue', 'black', 'green'])
graph.setLegends(['lambda = ' + str(lam) for lam in myLambda])
graph.setLegendPosition("bottomright")
fig = plt.figure(figsize=(8, 4))
plt.suptitle("Box Cox transformations")
axis = fig.add_subplot(111)
axis.set_xlim(auto=True)
View(graph, figure=fig, axes=[axis], add_legend=True)
sta = s * a
print('s*a=', sta)
except:
print('no scalar mul for', iname)
# try scalar div
try:
s = 5.
ads = a / s
print('a/s=', ads)
except:
print('no scalar div for', iname)
# try vec mul
try:
x = ot.NumericalPoint([6, 7])
ax = a * x
print('a*x=', ax)
except:
print('no vec mul for', iname)
try:
a3 = a**3
print('a**3=', a3)
except:
print('no pow for', iname)
for j, jname in enumerate(t_names):
b = getattr(ot, iname)(ref)
try:
ab = a * b
import openturns as ot
from matplotlib import pyplot as plt
from openturns.viewer import View
from math import sqrt
mesh = ot.IntervalMesher([256]).build(ot.Interval(-1.0, 1.0))
threshold = 0.001
factory = ot.KarhunenLoeveP1Factory(mesh, threshold)
model = ot.AbsoluteExponential(1, 1.0)
ev = ot.NumericalPoint()
modes = factory.buildAsProcessSample(model, ev)
for i in range(modes.getSize()):
modes[i] = ot.Field(mesh, modes[i].getValues() * [sqrt(ev[i])])
g = modes.drawMarginal(0)
g.setXTitle("$t$")
g.setYTitle("$\sqrt{\lambda_n}\phi_n$")
fig = plt.figure(figsize=(6, 4))
plt.suptitle("P1 approx. of KL expansion for $C(s,t)=e^{-|s-t|}$")
axis = fig.add_subplot(111)
axis.set_xlim(auto=True)
View(g, figure=fig, axes=[axis], add_legend=False)
algo.setLocalSolver(localAlgo)
print('algo=', algo)
algo.run()
result = algo.getResult()
print('x^=', printNumericalPoint(
result.getOptimalPoint(), 3))
except:
print('-- Not supported: algo=', algoName,
'inequality=', inequality, 'equality=', equality)
# FORM
f = ot.NumericalMathFunction(
["E", "F", "L", "I"], ["d"], ["-F*L^3/(3*E*I)"])
dim = f.getInputDimension()
mean = [50.0, 1.0, 10.0, 5.0]
sigma = ot.NumericalPoint(dim, 1.0)
R = ot.IdentityMatrix(dim)
distribution = ot.Normal(mean, sigma, R)
vect = ot.RandomVector(distribution)
output = ot.RandomVector(f, vect)
myEvent = ot.Event(output, ot.Less(), -3.0)
solver = ot.NLopt('LD_AUGLAG')
solver.setMaximumIterationNumber(400)
solver.setMaximumAbsoluteError(1.0e-10)
solver.setMaximumRelativeError(1.0e-10)
solver.setMaximumResidualError(1.0e-10)
solver.setMaximumConstraintError(1.0e-10)
algo = ot.FORM(solver, myEvent, mean)
algo.run()
result = algo.getResult()
print('generalized reliability index=%.6f' %
size = 100
dim = 10
R = ot.CorrelationMatrix(dim)
for i in range(dim):
for j in range(i):
R[i, j] = (i + j + 1.0) / (2.0 * dim)
mean = [2.0] * dim
sigma = [3.0] * dim
distribution = ot.Normal(mean, sigma, R)
sample = distribution.getSample(size)
sampleX = ot.NumericalSample(size, dim - 1)
sampleY = ot.NumericalSample(size, 1)
for i in range(size):
sampleY[i] = ot.NumericalPoint(1, sample[i, 0])
p = ot.NumericalPoint(dim - 1)
for j in range(dim - 1):
p[j] = sample[i, j + 1]
sampleX[i] = p
sampleZ = ot.NumericalSample(size, 1)
for i in range(size):
sampleZ[i] = ot.NumericalPoint(1, sampleY[i, 0] * sampleY[i, 0])
print("LinearModelAdjustedRSquared=",
ot.LinearModelTest.LinearModelAdjustedRSquared(sampleY, sampleZ))
print("LinearModelFisher=",
ot.LinearModelTest.LinearModelFisher(sampleY, sampleZ))
print("LinearModelResidualMean=",
ot.LinearModelTest.LinearModelResidualMean(sampleY, sampleZ))
print("LinearModelRSquared=",
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
myFunc = ot.NumericalMathFunction(
['x1', 'x2'], ['f1', 'f2', 'f3'],
['x1*sin(x2)', 'cos(x1+x2)', '(x2+1)*exp(x1-2*x2)'])
data = ot.NumericalSample(9, myFunc.getInputDimension())
point = ot.NumericalPoint(myFunc.getInputDimension())
point[0] = 0.5
point[1] = 0.5
data[0] = point
point[0] = -1
point[1] = -1
data[1] = point
point[0] = -1
point[1] = 1
data[2] = point
point[0] = 1
point[1] = -1
data[3] = point
point[0] = 1
point[1] = 1
data[4] = point
point[0] = -0.5
point[1] = -0.5
data[5] = point
point[0] = -0.5
point[1] = 0.5
data[6] = point
# Test for sampling
size = 10000
oneSample = distribution.getSample(size)
print("oneSample first=", oneSample[0], " last=", oneSample[size - 1])
print("mean=", oneSample.computeMean())
print("covariance=", oneSample.computeCovariance())
size = 100
for i in range(2):
print(
"Kolmogorov test for the generator, sample size=", size, " is ",
ot.FittingTest.Kolmogorov(distribution.getSample(size),
distribution).getBinaryQualityMeasure())
size *= 10
# Define a point
point = ot.NumericalPoint(distribution.getDimension(), 1.0)
print("Point= ", point)
# Show PDF and CDF of point
eps = 1e-5
DDF = distribution.computeDDF(point)
print("ddf =", DDF)
LPDF = distribution.computeLogPDF(point)
print("log pdf= %.12g" % LPDF)
PDF = distribution.computePDF(point)
print("pdf =%.6f" % PDF)
print("pdf (FD)=%.6f" % ((distribution.computeCDF(point + [eps]) -
distribution.computeCDF(point + [-eps])) /
(2.0 * eps)))
CDF = distribution.computeCDF(point)
print("cdf= %.12g" % CDF)
def square(self, y):
square = ot.NumericalPoint()
for i in range(len(y)):
square.add(y[i]**2)
return square
import openturns as ot
from matplotlib import pyplot as plt
from openturns.viewer import View
ot.RandomGenerator.SetSeed(0)
# Generate sample with the given plane
size = 20
dim = 2
refSample = ot.NumericalSample(size, dim)
for i in range(size):
p = ot.NumericalPoint(dim)
for j in range(dim):
p[j] = i + j
refSample[i] = p
myPlane = ot.FixedExperiment(refSample)
sample = myPlane.generate()
# Create an empty graph
graph = ot.Graph("", "x1", "x2", True, "")
# Create the cloud
cloud = ot.Cloud(sample, "blue", "fsquare", "")
# Then, draw it
graph.add(cloud)
fig = plt.figure(figsize=(4, 4))
plt.suptitle("Fixed experiment")
axis = fig.add_subplot(111)
axis.set_xlim(auto=True)
print('Continuous = ', distribution[testCase].isContinuous())
# Test for realization of distribution
oneRealization = distribution[testCase].getRealization()
print('oneRealization=', repr(oneRealization))
# Test for sampling
size = 10000
oneSample = distribution[testCase].getSample(size)
print('oneSample first=', repr(oneSample[0]), ' last=',
repr(oneSample[size - 1]))
print('mean=', repr(oneSample.computeMean()))
print('covariance=', repr(oneSample.computeCovariance()))
# Define a point
point = ot.NumericalPoint(distribution[testCase].getDimension(), 2.5)
print('Point= ', repr(point))
# Show PDF and CDF of point
eps = 1e-5
DDF = distribution[testCase].computeDDF(point)
print('ddf =', repr(DDF))
print('ddf (ref)=',
repr(referenceDistribution[testCase].computeDDF(point)))
PDF = distribution[testCase].computePDF(point)
print('pdf =%.6f' % PDF)
print('pdf (ref)=%.6f' % referenceDistribution[testCase].computePDF(point))
CDF = distribution[testCase].computeCDF(point)
# Is this distribution continuous ?
print("Continuous = ", distribution.isContinuous())
# Test for realization of distribution
oneRealization = distribution.getRealization()
print("oneRealization=", oneRealization)
# Test for sampling
size = 10000
oneSample = distribution.getSample(size)
print("oneSample first=", oneSample[0], " last=", oneSample[size - 1])
print("mean=", oneSample.computeMean())
print("covariance=", oneSample.computeCovariance())
# Define a point
point = ot.NumericalPoint(distribution.getDimension(), 1.0)
print("Point= ", point)
# Show PDF and CDF of point
eps = 1e-5
DDF = distribution.computeDDF(point)
print("ddf =", DDF)
print("ddf (FD)= %.6g" %
((distribution.computePDF(point + ot.NumericalPoint(1, eps)) -
distribution.computePDF(point + ot.NumericalPoint(1, -eps))) /
(2.0 * eps)))
LPDF = distribution.computeLogPDF(point)
print("log pdf= %.6g" % LPDF)
PDF = distribution.computePDF(point)
print("pdf =%.6g" % PDF)
print("pdf (FD)=%.6g" %
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
dim = 2
# We create an empty series
ts1 = ot.TimeSeries(0, dim)
ts1.setName('Ts1')
# We populate the empty ts
for p in range(3):
pt = ot.NumericalPoint(dim)
for i in range(dim):
pt[i] = 10. * (p + 1) + i
ts1.add(pt)
print('ts1=', ts1)
# We get the second element of the ts
secondElement = ts1[1]
print('second element=', secondElement)
# We set the third element to a valid new element
newPoint = ot.NumericalPoint(dim + 1)
for i in range(dim):
newPoint[i + 1] = 1000. * (i + 1)
ts1[2] = newPoint
print('ts1=', ts1)
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
try:
dim = 1
domain = ot.Interval([-1.0] * dim, [1.0] * dim)
basis = ot.OrthogonalProductPolynomialFactory([ot.LegendreFactory()] * dim)
basisSize = 10
experiment = ot.LHSExperiment(basis.getMeasure(), 1000)
mustScale = False
threshold = 0.01
factory = ot.KarhunenLoeveQuadratureFactory(domain, experiment, basis,
basisSize, mustScale,
threshold)
model = ot.AbsoluteExponential([1.0] * dim)
lambd = ot.NumericalPoint()
KLModes = factory.build(model, lambd)
#print("KL modes=", KLModes)
print("KL eigenvalues=", lambd)
except:
import sys
print("t_KarhunenLoeveQuadratureFactory_std.py",
sys.exc_info()[0],
sys.exc_info()[1])
import scipy as sp
import scipy.stats as st
try:
# create a scipy distribution
sp.random.seed(42)
scipy_dist = st.uniform()
# create an openturns distribution
py_dist = ot.SciPyDistribution(scipy_dist)
distribution = ot.Distribution(py_dist)
print(('distribution=%s' % str(distribution)))
print(('realization=%s' % str(distribution.getRealization())))
print(('sample=%s' % str(distribution.getSample(5))))
point = ot.NumericalPoint(1, 0.6)
print(('pdf=%s' % str(distribution.computePDF(point))))
print(('cdf=%s' % str(distribution.computeCDF(point))))
print(('mean=%s' % str(distribution.getMean())))
print(('std=%s' % str(distribution.getStandardDeviation())))
print(('skewness=%s' % str(distribution.getSkewness())))
print(('kurtosis=%s' % str(distribution.getKurtosis())))
print(('range=%s' % str(distribution.getRange())))
# create an openturns random vector
py_rv = ot.SciPyRandomVector(scipy_dist)
randomVector = ot.RandomVector(py_rv)
print(('randomVector=%s' % str(randomVector)))
print(('realization=%s' % str(randomVector.getRealization())))
print(('sample=%s' % str(randomVector.getSample(5))))
print(('mean=%s' % str(randomVector.getMean())))
print('Continuous = ', distribution[testCase].isContinuous())
# Test for realization of distribution
oneRealization = distribution[testCase].getRealization()
print('oneRealization=', repr(oneRealization))
# Test for sampling
size = 10000
oneSample = distribution[testCase].getSample(size)
print('oneSample first=', repr(oneSample[0]), ' last=',
repr(oneSample[size - 1]))
print('mean=', repr(oneSample.computeMean()))
print('covariance=', repr(oneSample.computeCovariance()))
# Define a point
point = ot.NumericalPoint(distribution[testCase].getDimension(), 2.5)
print('Point= ', repr(point))
# Show PDF and CDF of point
eps = 1e-5
DDF = distribution[testCase].computeDDF(point)
print('ddf =', repr(DDF))
print('ddf (ref)=',
repr(referenceDistribution[testCase].computeDDF(point)))
PDF = distribution[testCase].computePDF(point)
print('pdf =%.6f' % PDF)
print('pdf (ref)=%.6f' % referenceDistribution[testCase].computePDF(point))
CDF = distribution[testCase].computeCDF(point)
# Test for sampling
size = 10000
oneSample = distribution.getSample(size)
print("oneSample first=", oneSample[0], " last=", oneSample[size - 1])
print("mean=", oneSample.computeMean())
print("covariance=", oneSample.computeCovariance())
size = 100
for i in range(2):
print(
"Kolmogorov test for the generator, sample size=", size, " is ",
ot.FittingTest.Kolmogorov(distribution.getSample(size),
distribution).getBinaryQualityMeasure())
size *= 10
# Define a point
point = ot.NumericalPoint(distribution.getDimension(), 1.0)
print("Point= ", point)
# Show PDF and CDF of point
eps = 1e-5
DDF = distribution.computeDDF(point)
print("ddf =", DDF)
LPDF = distribution.computeLogPDF(point)
print("log pdf= %.12g" % LPDF)
PDF = distribution.computePDF(point)
print("pdf =%.6f" % PDF)
print("pdf (FD)=%.6f" % ((distribution.computeCDF(point + [eps]) -
distribution.computeCDF(point + [-eps])) /
(2.0 * eps)))
CDF = distribution.computeCDF(point)
print("cdf= %.12g" % CDF)
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
# linear
levelFunction = ot.NumericalMathFunction(["x1", "x2", "x3", "x4"], ["y1"],
["x1+2*x2-3*x3+4*x4"])
startingPoint = ot.NumericalPoint(4, 0.0)
bounds = ot.Interval(ot.NumericalPoint(4, -3.0), ot.NumericalPoint(4, 5.0))
algo = ot.TNC()
algo.setStartingPoint(startingPoint)
problem = ot.OptimizationProblem()
problem.setBounds(bounds)
problem.setObjective(levelFunction)
problem.setMinimization(True)
algo.setProblem(problem)
print('algo=', algo)
algo.run()
result = algo.getResult()
print('result=', result)
problem.setMinimization(False)
algo.setProblem(problem)
print('algo=', algo)
algo.run()
result = algo.getResult()
print('result=', result)
import openturns as ot
from matplotlib import pyplot as plt
from openturns.viewer import View
f = ot.NumericalMathFunction('x', 'abs(sin(x))')
a = -2.5
b = 4.5
algo = ot.GaussKronrod(
100000, 1e-13, ot.GaussKronrodRule(ot.GaussKronrodRule.G11K23))
value = algo.integrate(f, ot.Interval(a, b))[0]
ai = ot.NumericalPoint()
bi = ot.NumericalPoint()
fi = ot.NumericalSample()
ei = ot.NumericalPoint()
error = ot.NumericalPoint()
value2 = algo.integrate(f, a, b, error, ai, bi, fi, ei)[0]
ai.add(b)
g = f.draw(a, b, 512)
lower = ot.Cloud(ai, ot.NumericalPoint(ai.getDimension()))
lower.setColor("magenta")
lower.setPointStyle('circle')
g.add(lower)
fig = plt.figure(figsize=(4, 4))
plt.suptitle("GaussKronrod example")
axis = fig.add_subplot(111)
axis.set_xlim(auto=True)
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
ot.TESTPREAMBLE()
# First, build two functions from R^3->R
inVar = ['x1', 'x2', 'x3']
formula = ['x1^3 * sin(x2 + 2.5 * x3) - (x1 + x2)^2 / (1.0 + x3^2)']
functions = []
functions.append(ot.SymbolicFunction(inVar, formula))
formula = ['exp(-x1 * x2 + x3) / cos(1.0 + x2 * x3 - x1)']
functions.append(ot.SymbolicFunction(inVar, formula))
# Second, build the weights
coefficients = [0.3, 2.9]
# Third, build the function
myFunction = ot.LinearCombinationFunction(functions, coefficients)
inPoint = ot.NumericalPoint([1.2, 2.3, 3.4])
print('myFunction=', myFunction)
print('Value at ', inPoint, '=', myFunction(inPoint))
print('Gradient at ', inPoint, '=', myFunction.gradient(inPoint))
print('Hessian at ', inPoint, '=', myFunction.hessian(inPoint))
# QQPlot tests
size = 100
normal = ot.Normal(1)
sample = normal.getSample(size)
sample2 = ot.Gamma(3.0, 4.0, 0.0).getSample(size)
graph = ot.VisualTest.DrawQQplot(sample, sample2, 100)
# graph.draw('curve4.png')
view = View(graph)
# view.save('curve4.png')
view.show()
# Clouds tests
dimension = (2)
R = ot.CorrelationMatrix(dimension)
R[0, 1] = 0.8
distribution = ot.Normal(ot.NumericalPoint(dimension, 3.0),
ot.NumericalPoint(dimension, 2.0), R)
size = 100
sample2D = distribution.getSample(size)
firstSample = ot.NumericalSample(size, 1)
secondSample = ot.NumericalSample(size, 1)
for i in range(size):
firstSample[i] = ot.NumericalPoint(1, sample2D[i, 0])
secondSample[i] = ot.NumericalPoint(1, sample2D[i, 1])
graph = ot.VisualTest.DrawClouds(
sample2D,
ot.Normal(ot.NumericalPoint(dimension, 2.0),
ot.NumericalPoint(dimension, 3.0), R).getSample(size // 2))
# graph.draw('curve5.png')
view = View(graph)
# view.save('curve5.png')
ot.TruncatedDistribution.LOWER)
Zv_law = ot.Triangular(49., 50., 51.)
Zm_law = ot.Triangular(54., 55., 56.)
coll = ot.DistributionCollection([Q_law, Ks_law, Zv_law, Zm_law])
distribution = ot.ComposedDistribution(coll)
x = list(map(lambda dist: dist.computeQuantile(0.5)[0], coll))
fx = function(x)
for k in [0.0, 2.0, 5.0, 8.][0:1]:
randomVector = ot.RandomVector(distribution)
composite = ot.RandomVector(function, randomVector)
print('--------------------')
print('model flood S <', k, 'gamma=', end=' ')
print('f(', ot.NumericalPoint(x), ')=', fx)
event = ot.Event(composite, ot.Greater(), k)
for n in [100, 1000, 5000][1:2]:
for gamma1 in [0.25, 0.5, 0.75][1:2]:
algo = ot.MonteCarlo(event)
algo.setMaximumOuterSampling(100 * n)
# algo.setMaximumCoefficientOfVariation(-1.)
algo.run()
result = algo.getResult()
print(result)
algo = otads.AdaptiveDirectionalSampling(event)
algo.setMaximumOuterSampling(n)
algo.setGamma([gamma1, 1.0 - gamma1])
calls0 = function.getEvaluationCallsNumber()
algo.run()
['x1*sin(x2)', 'cos(x1+x2)', '(x2+1)*exp(x1-2*x2)'])
# Right hand side of the composition
right = ot.SymbolicFunction(
['x1', 'x2', 'x3', 'x4'],
['(x1*x1+x2^3*x1)/(2*x3*x3+x4^4+1)', 'cos(x2*x2+x4)/(x1*x1+1+x3^4)'])
# Compositon of left and right
composed = ot.ComposedFunction(left, right)
print("right=", repr(right))
print("left=", repr(left))
print("composed=", repr(composed))
# Does it work?
x = ot.NumericalPoint(right.getInputDimension(), 1.0)
y = right(x)
z = left(y)
Dy = right.gradient(x)
Dz = left.gradient(y)
print("x=", repr(x), " y=right(x)=", repr(y), " z=left(y)=", repr(z))
print("left(right(x))=", repr(composed(x)))
print("D(right)(x)=", repr(Dy), " D(left)(y)=", repr(Dz))
print(" prod=", repr(Dy * Dz))
print("D(left(right(x)))=", repr(composed.gradient(x)))
result = composed.hessian(x)
print("DD(left(right(x)))=")
for k in range(result.getNbSheets()):
for j in range(result.getNbColumns()):
for i in range(result.getNbRows()):
hmatRef = ot.HMatrix(hmat)
hmat.factorize('LLt')
# Compute A - L*L^T
hmatRef.gemm('N', 'T', -1.0, hmat, hmat, 1.0)
# Check LU factorization
hmat = factory.build(vertices, 1, False, parameters)
hmat.assembleReal(simpleAssembly, 'N')
hmat.factorize('LU')
print('rows=', hmat.getNbRows())
print('columns=', hmat.getNbColumns())
print('norm=', ot.NumericalPoint(1, hmat.norm()))
if hmatRef.norm() < 1e-10:
print('norm(A-LLt) < 1e-10')
else:
print('norm(A-LLt) =', hmatRef.norm())
print('diagonal=', hmat.getDiagonal())
print('compressionRatio= (%d, %d)' % hmat.compressionRatio())
print('fullrkRatio= (%d, %d)' % hmat.fullrkRatio())
# vector multiply
y = ot.NumericalPoint(hmat.getNbColumns())
x = [2.0] * hmat.getNbColumns()
hmat.gemv('N', 1.0, x, 3.0, y)
print('y=', y)
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
try:
mesh = ot.IntervalMesher(ot.Indices(1, 9)).build(ot.Interval(-1.0, 1.0))
factory = ot.KarhunenLoeveP1Factory(mesh, 0.0)
eigenValues = ot.NumericalPoint()
KLModes = factory.buildAsProcessSample(ot.AbsoluteExponential([1.0]),
eigenValues)
print("KL modes=", KLModes)
print("KL eigenvalues=", eigenValues)
cov1D = ot.AbsoluteExponential([1.0])
KLFunctions = factory.build(cov1D, eigenValues)
print("KL functions=", KLFunctions)
print("KL eigenvalues=", eigenValues)
R = ot.CorrelationMatrix(2, [1.0, 0.5, 0.5, 1.0])
scale = [1.0]
amplitude = [1.0, 2.0]
cov2D = ot.ExponentialModel(scale, amplitude, R)
KLFunctions = factory.build(cov2D, eigenValues)
print("KL functions=", KLFunctions)
print("KL eigenvalues=", eigenValues)
except:
import sys
print("t_KarhunenLoeveP1Factory_std.py",
sys.exc_info()[0],
sys.exc_info()[1])
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
import math as m
ot.TESTPREAMBLE()
f = ot.NumericalMathFunction(['t', 'y0', 'y1'], ['dy0', 'dy1'],
['t - y0', 'y1 + t^2'])
phi = ot.TemporalFunction(f)
solver = ot.RungeKutta(phi)
print('ODE solver=', solver)
initialState = [1.0, -1.0]
nt = 100
timeGrid = list(map(lambda i: (i**2.0) / (nt - 1.0)**2.0, range(nt)))
print('time grid=', ot.NumericalPoint(timeGrid))
result = solver.solve(initialState, timeGrid)
print('result=', result)
print('last value=', result[nt - 1])
t = timeGrid[nt - 1]
ref = ot.NumericalPoint(2)
ref[0] = -1.0 + t + 2.0 * m.exp(-t)
ref[1] = -2.0 + -2.0 * t - t * t + m.exp(t)
print('ref. value=', ref)
print('saved f2=', f2)
f1 = ot.NumericalMathFunction()
f2 = ot.NumericalMathFunction()
st = ot.Study()
st.setStorageManager(ot.XMLStorageManager(fileName))
st.load()
st.fillObject("f1", f1)
st.fillObject("f2", f2)
print('loaded f1=', f1)
print('loaded f2=', f2)
inPt = ot.NumericalPoint(2, 2.)
outPt = f1(inPt)
print(repr(outPt))
outPt = f1((10., 11.))
print(repr(outPt))
inSample = ot.NumericalSample(10, 2)
for i in range(10):
inSample[i] = ot.NumericalPoint((i, i))
print(repr(inSample))
outSample = f1(inSample)
print(repr(outSample))
outSample = f1(((100., 100.), (101., 101.), (102., 102.)))
sep = ""
else:
sep = ","
if m.fabs(point[i]) < eps:
oss += sep + format % m.fabs(point[i])
else:
oss += sep + format % point[i]
sep = ","
oss += "]"
return oss
# linear
levelFunction = ot.NumericalMathFunction(["x1", "x2", "x3", "x4"], ["y1"],
["x1+2*x2-3*x3+4*x4"])
startingPoint = ot.NumericalPoint(4, 0.0)
algo = ot.Cobyla(ot.OptimizationProblem(levelFunction, 3.0))
algo.setStartingPoint(startingPoint)
print('algo=', algo)
algo.run()
result = algo.getResult()
print('x^=', printNumericalPoint(result.getOptimalPoint(), 4))
# non-linear
levelFunction = ot.NumericalMathFunction(["x1", "x2", "x3", "x4"], ["y1"],
["x1*cos(x1)+2*x2*x3-3*x3+4*x3*x4"])
startingPoint = ot.NumericalPoint(4, 0.0)
algo = ot.Cobyla(ot.OptimizationProblem(levelFunction, 3.0))
algo.setStartingPoint(startingPoint)
algo.setMaximumIterationNumber(400)
algo.setMaximumAbsoluteError(1.0e-10)
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
import os
ot.TESTPREAMBLE()
fileName = 'myStudy.xml'
# Create a Study Object
myStudy = ot.Study()
myStudy.setStorageManager(ot.XMLStorageManager(fileName))
# Add a PersistentObject to the Study (here a NumericalPoint)
p1 = ot.NumericalPoint(3, 0.)
p1.setName("Good")
p1[0] = 10.
p1[1] = 11.
p1[2] = 12.
myStudy.add(p1)
# Add another PersistentObject to the Study (here a NumericalSample)
s1 = ot.NumericalSample(3, 2)
s1.setName("mySample")
p2 = ot.NumericalPoint(2, 0.)
p2.setName("One")
p2[0] = 100.
p2[1] = 200.
s1[0] = p2
p3 = ot.NumericalPoint(2, 0.)
