# %% import openturns as ot import openturns.viewer as viewer from matplotlib import pylab as plt import math as m ot.Log.Show(ot.Log.NONE) # %% # Create a mesh N = 100 mesh = ot.RegularGrid(0.0, 1.0, N) # %% # Create the function that acts the values of the mesh h = ot.SymbolicFunction(['t', 'x1', 'x2'], ['t+x1^2+x2^2']) # %% # Create the field function f = ot.VertexValueFunction(h, mesh) # %% # Evaluate f inF = ot.Normal(2).getSample(N) outF = f(inF) # print input/output at first 10 mesh nodes txy = mesh.getVertices() txy.stack(inF) txy.stack(outF) txy[:10]
deltaT = 0.1
steps = 11
# Initialization of the TimeGrid timeGrid
timeGrid = ot.RegularGrid(Tmin, deltaT, steps)
# Creation of the Antecedent
myARMAProcess = ot.ARMA()
myARMAProcess.setTimeGrid(timeGrid)
print('myAntecedentProcess = ', myARMAProcess)
# Creation of a function
f = ot.SymbolicFunction(['t', 'x'], ['t+0.1*x^2'])
# We build a dynamical function
myFieldFunction = ot.FieldFunction(ot.VertexValueFunction(f, timeGrid))
# finally we get the compsite process
myCompositeProcess = ot.CompositeProcess(myFieldFunction, myARMAProcess)
print('myCompositeProcess = ', repr(myCompositeProcess))
# Test realization
print('One realization= ')
print(myCompositeProcess.getRealization())
# future
print('future=', myCompositeProcess.getFuture(5))
#
# Create a spatial dynamical function
# Create the function g : R^2 --> R^2
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
import math as m
ot.TESTPREAMBLE()
f = ot.SymbolicFunction(['t', 'y0', 'y1'], ['t - y0', 'y1 + t^2'])
phi = ot.VertexValueFunction(f)
solver = ot.RungeKutta(phi)
print('ODE solver=', solver)
initialState = [1.0, -1.0]
nt = 100
timeGrid = [(i**2.0) / (nt - 1.0)**2.0 for i in range(nt)]
print('time grid=', ot.Point(timeGrid))
result = solver.solve(initialState, timeGrid)
print('result=', result)
print('last value=', result[nt - 1])
t = timeGrid[nt - 1]
ref = ot.Point(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)
grid = ot.RegularGrid(0.0, 0.01, nt)
result = solver.solve(initialState, grid)
print('result=', result)
print('last value=', result[nt - 1])
t = grid.getValue(nt - 1)
ref[0] = -1.0 + t + 2.0 * m.exp(-t)
ref[1] = -2.0 + -2.0 * t - t * t + m.exp(t)
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
ot.TESTPREAMBLE()
# Create an intance
myFunc = ot.SymbolicFunction(["t", "x"], ["x + t^2"])
tg = ot.RegularGrid(0.0, 0.2, 6)
myTemporalFunc = ot.VertexValueFunction(myFunc, tg)
print("myTemporalFunc=", myTemporalFunc)
# Get the input and output description
print("myTemporalFunc input description=",
myTemporalFunc.getInputDescription())
print("myTemporalFunc output description=",
myTemporalFunc.getOutputDescription())
# Get the input and output dimension, based on description
print("myTemporalFunc input dimension=", myTemporalFunc.getInputDimension())
print("myTemporalFunc output dimension=", myTemporalFunc.getOutputDimension())
# Create a TimeSeries
data = ot.Sample(tg.getN(), myFunc.getInputDimension() - 1)
for i in range(data.getSize()):
for j in range(data.getDimension()):
data[i, j] = i * data.getDimension() + j
ts = ot.TimeSeries(tg, data)
print("input time series=", ts)
print("output time series=", myTemporalFunc(ts))
# Get the number of calls
print("called ", myTemporalFunc.getCallsNumber(), " times")
