def CalculateSolution(Pe): # Create the TFC Class: N = 200 m = 190 nC = 2 tfc = utfc(N, nC, m, basis='LeP', x0=0., xf=1.) x = tfc.x # Get the Chebyshev polynomials H = tfc.H H0 = H(np.array([0.])) Hf = H(np.array([1.])) # Create the constraint expression and its derivatives y = lambda x, xi: np.dot(H(x), xi) + (1. - x) * (1. - np.dot(H0, xi) ) - x * np.dot(Hf, xi) yd = egrad(y) ydd = egrad(yd) L = lambda xi: ydd(x, xi) - Pe * yd(x, xi) # Calculate the solution zXi = np.zeros(H(x).shape[1]) xi, it = NLLS(zXi, L) # Create the test set: N = 1000 xTest = np.linspace(0., 1., N) err = np.abs(y(xTest, xi) - soln(xTest, Pe)) return np.max(err), np.mean(err)
def BVP_tfc(N, m, basis, iterMax, tol): ## Unpack Paramters: ********************************************************* x0 = 0. xf = np.pi ## Initial Conditions: ******************************************************* y0 = 0. yf = 0. nC = 2 # number of constraints ## Determine call tfc class needs to be 1 for ELMs if basis == 'CP' or basis == 'LeP': c = 2. / (xf - x0) elif basis == 'FS': c = 2. * np.pi / (xf - x0) else: c = 1. / (xf - x0) ## Compute true solution ytrue = lambda x: np.exp(-x) * np.sin(x) err = onp.ones_like(m) * np.nan res = onp.ones_like(m) * np.nan ## GET CHEBYSHEV VALUES: ********************************************* tfc = utfc(N, nC, int(m), basis=basis, x0=x0, xf=xf) x = tfc.x H = tfc.H H0 = H(tfc.x[0]) Hf = H(tfc.x[-1]) ## DEFINE THE ASSUMED SOLUTION: ************************************* phi1 = lambda x: (np.pi - x) / np.pi phi2 = lambda x: x / np.pi f = lambda x: np.exp(-2. * x) * np.sin(x) * (np.cos(x) - np.sin( x)) - 2. * np.exp(-x) * np.cos(x) y = lambda x, xi: np.dot(H(x), xi) + phi1(x) * (y0 - np.dot( H0, xi)) + phi2(x) * (yf - np.dot(Hf, xi)) yp = egrad(y) ypp = egrad(yp) ## DEFINE LOSS AND JACOB ******************************************** L = lambda xi: ypp(x, xi) + y(x, xi) * yp(x, xi) - f(x) ## SOLVE THE SYSTEM ************************************************* xi = onp.zeros(H(x).shape[1]) xi, _, time = NLLS(xi, L, timer=True, maxIter=iterMax) ## COMPUTE ERROR AND RESIDUAL *************************************** err = onp.linalg.norm(y(x, xi) - ytrue(x)) res = onp.linalg.norm(L(xi)) return err, res, time
def IVP2BVP(N, m, gamma, basis, iterMax, tol): ## Unpack Paramters: ********************************************************* x0 = -1. xf = 1. ## Initial Conditions: ******************************************************* y0 = -2. y0p = -2. yf = 2. nC = 2 # number of constraints ## Determine call tfc class needs to be 1 for ELMs if basis == 'CP' or basis == 'LeP': c = 2./ (xf - x0) elif basis == 'FS': c = 2. * np.pi / (xf - x0) else: c = 1./ (xf - x0) ## GET CHEBYSHEV VALUES: ********************************************* tfc = utfc(N,nC,m,basis = basis, x0=-1., xf=1.) x = tfc.x H = tfc.H dH = tfc.dH H0 = H(tfc.z[0]) Hf = H(tfc.z[-1]) H0p = dH(tfc.z[0]) ## DEFINE THE ASSUMED SOLUTION: ************************************* phi1 = lambda a: 1./(1. + 4.*gamma - gamma**2) * ( (1. + gamma) - 2.*gamma*a ) phi2 = lambda a: 1./(1. + 4.*gamma - gamma**2) * ( (1. - gamma)**2 + (1. - gamma**2)*a) phi3 = lambda a: 1./(1. + 4.*gamma - gamma**2) * ( -gamma*(gamma-3.) + 2.*gamma*a ) y = lambda x, xi: np.dot(H(x),xi) + phi1(x)*(y0 - np.dot(H0,xi)) \ + phi2(x)*(y0p - np.dot(H0p,xi)) \ + phi3(x)*(yf - np.dot(Hf,xi)) yp = egrad(y,0) ypp = egrad(yp,0) ## DEFINE LOSS AND JACOB ******************************************** L = lambda xi: ypp(x,xi) + (np.cos(3.*x**2) -3.*x + 1.)*yp(x,xi) \ + (6.*np.sin(4.*x**2) - np.exp(np.cos(3.*x)))*y(x,xi) \ - 2. * (1.-np.sin(3.*x))*(3.*x-np.pi)/(4.-x) ## SOLVE THE SYSTEM ************************************************* xi = onp.zeros(H(x).shape[1]) xi,_,_ = NLLS(xi,L,timer=True) return y(x,xi), L(xi), x
if basis == 'CP' or 'LeP': nC = 2 elif basis == 'FS': nC = 1 else: nC = 0 # number of constraints # length of time for one TFC step xstep = (xspan[1] - xspan[0]) / Nstep # !!! since this differential equation is not a explicit function of position 'x', I can get # away with contructing the tfc class such that x = [0, xstep] an imposing a constant step so # that the mapping parameter c = (zf-z0)/(xf-x0) is also constant ## construct univariate tfc class: ***************************************************************** tfc = utfc(N + 1, nC, int(m + 1), basis=basis, x0=0, xf=xstep) x = tfc.x # !!! notice I am using N+1 for the number of points. this is because I will be using the last point # of a segment 'n' for the initial conditons of the 'n+1' segment H = tfc.H dH = tfc.dH H0 = H(x[0:1]) H0p = dH(x[0:1]) ## define tfc constrained expression and derivatives: ********************************************** # switching function phi1 = lambda x: np.ones_like(x) phi2 = lambda x: x # tfc constrained expression
import jax.numpy as np from tfc import utfc from tfc.utils import egrad, MakePlot, NLLS # Constants: n = 100 nC = 2 m = 60 th0 = 0. thf = 1.3 r0 = 0. rf = 5. # Create TFC class: myTfc = utfc(n, nC, m, x0=th0, xf=thf) th = myTfc.x H = myTfc.H # Create constrained expression: g = lambda th, xi: np.dot(H(th), xi) r = lambda th,xi: g(th,xi)+\ (th-thf)/(th0-thf)*(r0-g(th0*np.ones_like(th),xi))+\ (th-th0)/(thf-th0)*(rf-g(thf*np.ones_like(th),xi)) # Create loss function: dr = egrad(r) d2r = egrad(dr) L = lambda xi: -r(th,xi)**2*(dr(th,xi)*np.tan(th)+2.*d2r(th,xi))+\ -np.tan(th)*dr(th,xi)**3+3.*r(th,xi)*dr(th,xi)**2+r(th,xi)**3 # Solve the problem:
## initial guess values: *************************************************************************** r_init = [0.79, 0.] v_init = [0., 0.42] T_init = 21.4 # !!! These initial guesses comes from the Richardson's third-order analytical method for Halo-type # periodic orbits. See: http://articles.adsabs.harvard.edu/full/1980CeMec..22..241R ## user defined parameters: ************************************************************************ N = 140 # number of discretization points m = 130 # number of basis function terms basis = 'CP' # basis function type # !!! Here we can see that a large number of basis terms is used. This is needed for this specific # problem to obtain the desirable accuracy ## construct univariate tfc class: ***************************************************************** tfc = utfc(N, 4, m, basis=basis, x0=-1., xf=1.) # !!! Note that here I didn't explicitly define nC = 4, but I had inluded the number of constraints # in my call to the utfc class H = tfc.H dH = tfc.dH H0 = H(tfc.z[0:1]) Hf = H(tfc.z[-1:]) Hp0 = dH(tfc.z[0:1]) Hpf = dH(tfc.z[-1:]) ## defined the constrained expressions: ************************************************************ z = tfc.z z0 = z[0]
import numpy as np ##################################################################### nLines = 20 N = 1000 basis = 'CP' x0 = -1. xf = 1. # Point constraints y1 = 4. * np.random.rand() - 2. y2 = 4. * np.random.rand() - 2. y3 = 4. * np.random.rand() - 2. ## DEFINE UPPER/LOWER BOUNDS: ****************************************************************** mBnd = 7 bnd = utfc(N, 0, mBnd, basis=basis, x0=x0, xf=xf) x = bnd.x fu = lambda xi: np.dot(bnd.H(x), xi) + 5. fl = lambda xi: np.dot(bnd.H(x), xi) - 5. ## DEFINE CONSTRAINED EXPRESSION: ****************************************************************** nC = 3 m = 15 tfc = utfc(N, nC, m, basis=basis, x0=x0, xf=xf) x = tfc.x x1 = tfc.x[200] x2 = tfc.x[500] x3 = tfc.x[-200]
def ytrue(a): val = onp.zeros_like(a) for i in range(0, len(a)): if a[i] <= np.pi / 2.: val[i] = - 1./5. * np.exp(np.pi - 2.*a[i]) \ + 1./2. * np.exp(np.pi/2. - a[i]) \ + (9.*np.cos(a[i]) + 7.*np.sin(a[i])) / 10. else: val[i] = np.exp(np.pi / 2. - a[i]) return val ## GET CHEBYSHEV VALUES: ********************************************* # First segment tfc1 = utfc(N, nC, m, basis=basis, x0=x0, xf=x1) xs1 = tfc1.x Hs1 = tfc1.H dHs1 = tfc1.dH H0s1 = Hs1(tfc1.x[0]) Hfs1 = Hs1(tfc1.x[-1]) Hfps1 = dHs1(tfc1.x[-1]) # Second segment tfc2 = utfc(N, nC, m, basis=basis, x0=x1, xf=xf) xs2 = tfc2.x Hs2 = tfc2.H
import numpy as onp import jax.numpy as np from jax import jit from tfc import utfc from tfc.utils import MakePlot, step # Constants: N = 101 m = 8 nC = -1 nMC = 100 # Create the TFC class: myTfc = utfc(N, nC, m, x0=-2., xf=2., basis='LeP') x = np.linspace(-2., 2., N) ind = np.argmin(np.abs(x)) H = myTfc.H m = H(x).shape[1] # Create the constrained expression: K = np.array([1., 2., 3.]) g = lambda x, xi: np.dot(H(x), xi) uslow = lambda x, n, xi: g(x, xi) + K[np.int64(n % 3)] - g(np.array([0.]), xi) u = jit(uslow) # Run the monte carlo test p = MakePlot(r'$x$', r'$y(x,n,g(x))$')
return q # Generate the constraints in u,v,w: uvwi = q2u(qi) ui = uvwi[0] vi = uvwi[1] wi = uvwi[2] uvwf = q2u(qf) uf = uvwf[0] vf = uvwf[1] wf = uvwf[2] # Create the TFC class: myTfc = utfc(N, -1, m, x0=0., xf=2., basis='FS') H = myTfc.H t = myTfc.x # Create the constrained expressions: uhat = lambda t,g: g(t)\ +(2.-t)/2.*(ui-g(np.zeros_like(t)))\ +t/2.*(uf-g(2.*np.ones_like(t))) vhat = lambda t,g: g(t)\ +(2.-t)/2.*(vi-g(np.zeros_like(t)))\ +t/2.*(vf-g(2.*np.ones_like(t))) u = lambda t,g: uhat(t,g)\ +(np.pi-uhat(t,g))*step(uhat(t,g)-np.pi)\ -uhat(t,g)*step(-uhat(t,g)) v = lambda t,g: vhat(t,g)\ +(np.pi-vhat(t,g))*step(vhat(t,g)-np.pi)\
def laneEmden_tfc(N, m, type, xspan, basis, iterMax, tol): ## Unpack Paramters: ********************************************************* x0 = xspan[0] xf = xspan[1] ## Initial Conditions: ******************************************************* y0 = 1. y0p = 0. nC = 2 # number of constraints ## Determine call tfc class needs to be 1 for ELMs if basis == 'CP' or basis == 'LeP': c = 2. / (xf - x0) elif basis == 'FS': c = 2. * np.pi / (xf - x0) else: c = 1. / (xf - x0) ## Compute true solution if type == 0: maxIter = 1 def ytrue(x): val = onp.zeros_like(x) val[0] = 1. val[1:] = 1. - 1. / 6. * x[1:]**2 return val elif type == 1: maxIter = 1 def ytrue(x): val = onp.zeros_like(x) val[0] = 1. val[1:] = np.sin(x[1:]) / x[1:] return val elif type == 5: maxIter = iterMax def ytrue(x): val = onp.zeros_like(x) val[0] = 1. val[1:] = (1. + x[1:]**2 / 3)**(-1 / 2) return val else: def ytrue(x): return np.nan * np.ones_like(x) err = np.ones_like(m) * np.nan res = np.ones_like(m) * np.nan ## GET CHEBYSHEV VALUES: ********************************************* tfc = utfc(N, nC, int(m), basis=basis, x0=x0, xf=xf) x = tfc.x H = tfc.H dH = tfc.dH H0 = H(x[0]) H0p = dH(x[0]) ## DEFINE THE ASSUMED SOLUTION: ************************************* phi1 = lambda x: np.ones_like(x) phi2 = lambda x: x y = lambda x,xi: np.dot(H(x),xi) \ + phi1(x)*(y0 - np.dot(H0,xi)) \ + phi2(x)*(y0p - np.dot(H0p,xi)) yp = egrad(y) ypp = egrad(yp) ## DEFINE LOSS AND JACOB ******************************************** L = jit(lambda xi: x * ypp(x, xi) + 2. * yp(x, xi) + x * y(x, xi)**type) ## SOLVE THE SYSTEM ************************************************* # Solve the problem xi = np.zeros(H(x).shape[1]) xi, _, time = NLLS(xi, L, timer=True, maxIter=maxIter) ## COMPUTE ERROR AND RESIDUAL *************************************** err = np.linalg.norm(y(x, xi) - ytrue(x)) res = np.linalg.norm(L(xi)) return err, res, time
def CalculateSolutionSplit(Pe): if Pe > 1e3: xpBoundL = 0. + 1.e-3 xpBoundU = 1. - 1e-3 else: xpBoundL = 0. + 1.e-1 xpBoundU = 1. - 1e-1 # Create the ToC Class: N = 200 m = 190 nC = 3 tfc = utfc(N, nC, m, basis='LeP', x0=-1., xf=1.) # Get the Chebyshev polynomials H = tfc.H dH = tfc.dH H0 = H(np.array([-1.])) Hf = H(np.array([1.])) Hd0 = dH(np.array([-1.])) Hdf = dH(np.array([1.])) # Create the constraint expression and its derivatives z = tfc.z xp = lambda xi: xi['xpHat'] + (xpBoundU - xi['xpHat']) * step(xi[ 'xpHat'] - xpBoundU) + (xpBoundL - xi['xpHat']) * step(xpBoundL - xi[ 'xpHat']) c1 = lambda xi: 2. / (xp(xi)) c2 = lambda xi: 2. / (1. - xp(xi)) x1 = lambda z, xi: (z + 1.) / c1(xi) x2 = lambda z, xi: (z + 1.) / c2(xi) + xp(xi) y1 = lambda z,xi: np.dot(H(z),xi['xi1'])+(1.-2.*z+z**2)/4.*(1.-np.dot(H0,xi['xi1']))\ +(3.+2.*z-z**2)/4.*(xi['y']-np.dot(Hf,xi['xi1']))\ +(-1.+z**2)/2.*(xi['yd']/c1(xi)-np.dot(Hdf,xi['xi1'])) ydz1 = egrad(y1, 0) yddz1 = egrad(ydz1, 0) yd1 = lambda z, xi: ydz1(z, xi) * c1(xi) ydd1 = lambda z, xi: yddz1(z, xi) * c1(xi)**2 y2 = lambda z,xi: np.dot(H(z),xi['xi2'])+(3.-2.*z-z**2)/4.*(xi['y']-np.dot(H0,xi['xi2']))\ +(1.-z**2)/2.*(xi['yd']/c2(xi)-np.dot(Hd0,xi['xi2']))\ +(1.+2.*z+z**2)/4.*(0.-np.dot(Hf,xi['xi2'])) ydz2 = egrad(y2, 0) yddz2 = egrad(ydz2, 0) yd2 = lambda z, xi: ydz2(z, xi) * c2(xi) ydd2 = lambda z, xi: yddz2(z, xi) * c2(xi)**2 # Solve the problem xi = TFCDict({ 'xi1': onp.zeros(H(z).shape[1]), 'xi2': onp.zeros(H(z).shape[1]), 'xpHat': onp.array([0.99]), 'y': onp.array([0.]), 'yd': onp.array([0.]) }) L1 = lambda xi: ydd1(z, xi) - Pe * yd1(z, xi) L2 = lambda xi: ydd2(z, xi) - Pe * yd2(z, xi) L = lambda xi: np.hstack([L1(xi), L2(xi)]) xi, it = NLLS(xi, L) # Create the test set: N = 1000 z = np.linspace(-1., 1., N) # Calculate the error and return the results X = np.hstack([x1(z, xi), x2(z, xi)]) Y = np.hstack([y1(z, xi), y2(z, xi)]) err = np.abs(Y - soln(X, Pe)) return np.max(err), np.mean(err)
mw_gas = 4.00e-3 mw_atm = 4.34e-2 # Calcualted constants: As = 4.*np.pi*Rs**2 Vs = 4./3*np.pi*Rs**3 # TFC constants: N = 100 m = 80 tol = 1.e-13 maxIter = 15 # Create the TFC Classes: tfc = utfc(N,2,m,basis='CP',x0=-1.,xf=1.) tfc1 = utfc(N,1,m,basis='CP',x0=-1.,xf=1.) x = tfc.x # Get the Chebyshev polynomials H = tfc.H H0 = H(np.array([-1.])) Hf = H(np.array([1.])) H1 = tfc1.H H10 = H1(np.array([-1.])) # Boundary conditions s0 = lambda xi: Rs*xi['beta'] z0 = lambda xi: Rs*(1.-np.cos(xi['beta'])) r0 = lambda xi: Rs*np.sin(xi['beta'])
nC = 2 # number of constraints ## problem initial conditions: ********************************************************************* tspan = [0., 1.] # time range of problem initial = np.array([-1.0, -1.0]) final = np.array([ 1.0, 1.0]) Nlines = 20 ## keep-out parameters: **************************************************************************** xbound = np.array([-0.5, 0.5]) ybound = np.array([-0.5, 0.5]) ## construct univariate tfc class: ***************************************************************** tfc = utfc(N, nC, m, basis = basis, x0=tspan[0], xf=tspan[-1]) t = tfc.x H = tfc.H H0 = H(t[0]) Hf = H(t[-1]) ## define tfc constrained expression: ************************************************************** # switching function phi1 = lambda t: (t[-1] - t) / (t[-1] - t[0]) phi2 = lambda t: (t - t[0]) / (t[-1] - t[0]) # tfc constrained expression (without inequality constraints) xhat = lambda xi: np.dot(H(t),xi) + phi1(t)*(initial[0] - np.dot(H0,xi)) \ + phi2(t)*(final[0] - np.dot(Hf,xi)) yhat = lambda xi: np.dot(H(t),xi) + phi1(t)*(initial[1] - np.dot(H0,xi)) \
alfa = 1. beta = 1. # Number of points to use N = 35 # Number of basis functions to use m = 30 # Number of constraints nCx = 2 nCu = 0 ## GET CHEBYSHEV VALUES: ********************************************* xtfc = utfc(N, nCx, m, basis='CP', x0=-1, xf=1.) utfc = utfc(N, nCu, m, basis='CP', x0=-1, xf=1.) Hx = xtfc.H Hx0 = Hx(xtfc.z[0]) Hxf = Hx(xtfc.z[-1]) Hu = utfc.H ## DEFINE THE ASSUMED SOLUTION: ************************************* z = xtfc.z z0 = z[0] zf = z[-1] phi1 = lambda a: (zf - a) / (zf - z0) phi2 = lambda a: (a - z0) / (zf - z0)
# Constants used in the differential equation: Pe = 10**6 tol = 1e-13 xI = 0. xf = 1. yi = 1. yf = 0. xpBound = 1. - 1. * 10**-6 # Create the ToC Class: N = 200 c = 1. m = 190 nC = 3 tfc = utfc(N, nC, m, basis='CP', x0=-1, xf=1.) # Get the Chebyshev polynomials H = tfc.H dH = tfc.dH H0 = H(tfc.z[0]) Hf = H(tfc.z[-1]) Hd0 = dH(tfc.z[0]) Hdf = dH(tfc.z[-1]) # Create the constraint expression and its derivatives z = tfc.z c1 = lambda xp: 2. / (xp - xI) c2 = lambda xp: 2. / (xf - xp) x1 = lambda z, xp: (z + 1.) / c1(xp) + xI
def runLaneEmden(N, m, basis, k, xf): ## user defined parameters: ************************************************************************ # N - number of discretization points # m - number of basis function terms # basis - basis function type # k - specific problem type, k >=0 (analytical solution known for k = 0, 1, and 5) ## problem initial conditions: ***************************************************************** xspan = [0., xf] # problem domain range [x0, xf], where x₀ > 0 y0 = 1. # y(x0) = 1 y0p = 0. # y'(x0) = 0 nC = 2 # number of constraints ## construct univariate tfc class: ************************************************************* tfc = utfc(N, nC, int(m), basis=basis, x0=xspan[0], xf=xspan[1]) x = tfc.x H = tfc.H dH = tfc.dH H0 = H(x[0:1]) H0p = dH(x[0:1]) ## define tfc constrained expression and derivatives: ****************************************** # switching function phi1 = lambda x: np.ones_like(x) phi2 = lambda x: x # tfc constrained expression y = lambda x, xi: np.dot(H(x), xi) + phi1(x) * (y0 - np.dot( H0, xi)) + phi2(x) * (y0p - np.dot(H0p, xi)) yp = egrad(y) ypp = egrad(yp) ## define the loss function: ******************************************************************* L = lambda xi: x * ypp(x, xi) + 2. * yp(x, xi) + x * y(x, xi)**k ## solve the problem via nonlinear least-squares *********************************************** xi = np.zeros(H(x).shape[1]) # if k==0 or k==1, the problem is linear if k == 0 or k == 1: xi, time = LS(xi, L, timer=True) iter = 1 else: xi, iter, time = NLLS(xi, L, timer=True) ## compute the error (if k = 0, 1, or 5): ****************************************************** if k == 0: ytrue = 1. - 1. / 6. * x**2 elif k == 1: ytrue = onp.ones_like(x) ytrue[1:] = np.sin(x[1:]) / x[1:] elif k == 5: ytrue = (1. + x**2 / 3)**(-1 / 2) else: ytrue = np.empty_like(x) err = np.abs(y(x, xi) - ytrue) ## compute the residual of the loss vector: **************************************************** res = np.abs(L(xi)) return x, y(x, xi), err, res
aEll = 1. bEll = 0.75 cEll = 2. n = 100 nC = 2 m = 3 x0 = 0. xf = 3. nCEs = 8 colors = qual.Plotly # Constrained expressions: myTfc = utfc(n,nC,m,x0=x0,xf=xf) t = myTfc.x H = myTfc.H g = lambda xi,t: np.dot(H(t),xi['xi']) xslow = lambda xi,t: g(xi,t)\ +(3.-t)/3.*(aEll*np.sin(xi['phi'])*np.cos(xi['th'])-g(xi,np.array([0.])))\ +t/3.*(3.+aHyp*np.sinh(xi['v'])*np.cos(xi['psi'])-g(xi,np.array([3.]))) yslow = lambda xi,t: g(xi,t)\ +(3.-t)/3.*(bEll*np.sin(xi['phi'])*np.sin(xi['th'])-g(xi,np.array([0.])))\ +t/3.*(bHyp*np.sinh(xi['v'])*np.sin(xi['psi'])-g(xi,np.array([3.]))) zslow = lambda xi,t: g(xi,t)\ +(3.-t)/3.*(cEll*np.cos(xi['phi'])-g(xi,np.array([0.])))\ +t/3.*((-1.)**step(xi['n'])*cHyp*np.cosh(xi['v'])-g(xi,np.array([3.]))) x = jit(xslow); y = jit(yslow); z = jit(zslow)
from tfc import utfc from tfc.utils import MakePlot, step onp.random.seed(0) # Constants numFuncs = 20 m = 5 n = 250 # Boundaries ub = lambda x: x / 30. * np.sin(2. * x) + 0.2 lb = lambda x: x**2 / np.exp(x) * np.cos(x) - 0.3 # Get CP myTfc = utfc(n, -1, m, basis='CP', x0=0., xf=10.) H = myTfc.H x = np.linspace(0., 8., n) m = H(x).shape[1] # Create inequality only plot g = lambda x, xi: np.dot(H(x), xi) u = jit(lambda x, xi: g(x, xi) + (ub(x) - g(x, xi)) * step(g(x, xi) - ub(x)) + (lb(x) - g(x, xi)) * step(lb(x) - g(x, xi))) def antiu(x, xi): dark = onp.array(g(x, xi)) ind = onp.where(np.logical_and(dark > lb(x), dark < ub(x)))[0] dark[ind] = np.nan return dark
maxIter = 50 ## CONSTANTS: ********************************************************* # Number of points to use N = 100 # Number of basis functions to use ms = 30 mc = 1 # Number of constraints nCx = 4 nCy = 0 ## GET CHEBYSHEV VALUES ********************************************** stfc = utfc(N, nCx, ms, basis='CP', x0=-1, xf=1.) ctfc = utfc(N, nCy, mc, basis='CP', x0=-1, xf=1.) Hs = stfc.H pHs = stfc.dH Hs0 = Hs(stfc.z[0:1]) Hsf = Hs(stfc.z[-1:]) pHs0 = pHs(stfc.z[0:1]) pHsf = pHs(stfc.z[-1:]) Hc = ctfc.H ## DEFINE THE ASSUMED SOLUTION ************************************** z = stfc.z
import numpy as onp #################################################################################################### ## user defined parameters: ************************************************************************ N = 100 # number of discretization points m = 60 # number of basis function terms basis = 'CP' # basis function type ## problem boundary conditions: ******************************************************************** xspan = [0., np.pi] y0 = 0. # y(0) = 0 yf = 0. # y(pi) = 0 nC = 2 # number of constraints ## construct univariate tfc class: ***************************************************************** tfc = utfc(N, nC, int(m), basis=basis, x0=xspan[0], xf=xspan[1]) x = tfc.x H = tfc.H H0 = H(tfc.x[0:1]) Hf = H(tfc.x[-1:]) ## define tfc constrained expression and derivatives: ********************************************** # switching functions phi1 = lambda x: (np.pi - x) / np.pi phi2 = lambda x: x / np.pi # forcing term f = lambda x: np.exp(-2. * x) * np.sin(x) * (np.cos(x) - np.sin(x) ) - 2. * np.exp(-x) * np.cos(x)