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())))
#! /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.)