Datasets:

casey-martin

/

math_notebooks

like 0

<div style='background-image: url("../../share/images/header.svg") ; padding: 0px ; background-size: cover ; border-radius: 5px ; height: 250px'> <div style="float: right ; margin: 50px ; padding: 20px ; background: rgba(255 , 255 , 255 , 0.7) ; width: 50% ; height: 150px"> <div style="position: relative ; top: 50% ; transform: translatey(-50%)"> <div style="font-size: xx-large ; font-weight: 900 ; color: rgba(0 , 0 , 0 , 0.8) ; line-height: 100%">Computational Seismology</div> <div style="font-size: large ; padding-top: 20px ; color: rgba(0 , 0 , 0 , 0.5)">Discontinuous Galerkin Method with Physics based numerical flux - 1D Elastic Wave Equation </div> </div> </div> </div> This notebook is based on the paper [A new discontinuous Galerkin spectral element method for elastic waves with physically motivated numerical fluxes](https://www.geophysik.uni-muenchen.de/~gabriel/kduru_waves2017.pdf) Published in the [13th International Conference on Mathematical and Numerical Aspects of Wave Propagation](https://cceevents.umn.edu/waves-2017) ##### Authors: * Kenneth Duru * Ashim Rijal ([@ashimrijal](https://github.com/ashimrijal)) * Sneha Singh --- ## Basic Equations ## The source-free elastic wave equation in a heterogeneous 1D medium is \begin{align} \rho(x)\partial_t v(x,t) -\partial_x \sigma(x,t) & = 0\\ \frac{1}{\mu(x)}\partial_t \sigma(x,t) -\partial_x v(x,t) & = 0 \end{align} with $\rho(x)$ the density, $\mu(x)$ the shear modulus and $x = [0, L]$. At the boundaries $ x = 0, x = L$ we pose the general well-posed linear boundary conditions \begin{equation} \begin{split} B_0(v, \sigma, Z_{s}, r_0): =\frac{Z_{s}}{2}\left({1-r_0}\right){v} -\frac{1+r_0}{2} {\sigma} = 0, \quad \text{at} \quad x = 0, \\ B_L(v, \sigma, Z_{s}, r_n): =\frac{Z_{s}}{2} \left({1-r_n}\right){v} + \frac{1+r_n}{2}{\sigma} = 0, \quad \text{at} \quad x = L. \end{split} \end{equation} with the reflection coefficients $r_0$, $r_n$ being real numbers and $|r_0|, |r_n| \le 1$. Note that at $x = 0$, while $r_0 = -1$ yields a clamped wall, $r_0 = 0$ yields an absorbing boundary, and with $r_0 = 1$ we have a free-surface boundary condition. Similarly, at $x = L$, $r_n = -1$ yields a clamped wall, $r_n = 0$ yields an absorbing boundary, and $r_n = 1$ gives a free-surface boundary condition. 1) Discretize the spatial domain $x$ into $K$ elements and denote the ${k}^{th}$ element $e^k = [x_{k}, x_{k+1}]$ and the element width $\Delta{x}_k = x_{k+1}-x_{k}$. Consider two adjacent elements $e^k = [x_{k}, x_{k+1}]$ and $e^{k+1} = [x_{k+1}, x_{k+2}]$ with an interface at $x_{k+1}$. At the interface we pose the physical conditions for a locked interface \begin{align} \text{force balance}: \quad &\sigma^{-} = \sigma^{+} = \sigma, \nonumber \\ \text{no slip}: \quad & [\![ v]\!] = 0, \end{align} where $[\![ v]\!] = v^{+} - v^{-}$, and $v^{-}, \sigma^{-}$ and $v^{+}, \sigma^{+}$ are the fields in $e^k = [x_{k}, x_{k+1}]$ and $e^{k+1} = [x_{k+1}, x_{k+2}]$, respectively. 2) Within the element derive the weak form of the equation by multiplying both sides by an arbitrary test function and integrating over the element. 3) Next map the $e^k = [x_{k}, x_{k+1}]$ to a reference element $\xi = [-1, 1]$ 4) Inside the transformed element $\xi \in [-1, 1]$, approximate the solution and material parameters by a polynomial interpolant, and write \begin{equation} v^k(\xi, t) = \sum_{j = 1}^{N+1}v_j^k(t) \mathcal{L}_j(\xi), \quad \sigma^k(\xi, t) = \sum_{j = 1}^{N+1}\sigma_j^k(t) \mathcal{L}_j(\xi), \end{equation} \begin{equation} \rho^k(\xi) = \sum_{j = 1}^{N+1}\rho_j^k \mathcal{L}_j(\xi), \quad \mu^k(\xi) = \sum_{j = 1}^{N+1}\mu_j^k \mathcal{L}_j(\xi), \end{equation} where $ \mathcal{L}_j$ is the $j$th interpolating polynomial of degree $N$. If we consider nodal basis then the interpolating polynomials satisfy $ \mathcal{L}_j(\xi_i) = \delta_{ij}$. The interpolating nodes $\xi_i$, $i = 1, 2, \dots, N+1$ are the nodes of a Gauss quadrature with \begin{equation} \sum_{i = 1}^{N+1} f(\xi_i)w_i \approx \int_{-1}^{1}f(\xi) d\xi, \end{equation} where $w_i$ are quadrature weights. 5) At the element boundaries $\xi = \pm 1$, we generate $\widehat{v}^{k}(\pm 1, t)$ $\widehat{\sigma}^{k}(\pm 1, t)$ by solving a Riemann problem and constraining the solutions against interface and boundary conditions. Then numerical fluctuations $F^k(-1, t)$ and $G^k(1, t)$ are obtained by penalizing hat variables against the incoming characteristics only. 6) Finally, the flux fluctuations are appended to the semi-discrete PDE with special penalty weights and we have \begin{equation} \begin{split} \frac{d \boldsymbol{v}^k( t)}{ d t} &= \frac{2}{\Delta{x}_k} W^{-1}({\boldsymbol{\rho}}^{k})\left(Q \boldsymbol{\sigma}^k( t) - \boldsymbol{e}_{1}F^k(-1, t)- \boldsymbol{e}_{N+1}G^k(1, t)\right), \end{split} \end{equation} \begin{equation} \begin{split} \frac{d \boldsymbol{\sigma}^k( t)}{ d t} &= \frac{2}{\Delta{x}_k} W^{-1}(1/{\boldsymbol{\mu}^{k}})\left(Q \boldsymbol{v}^k( t) + \boldsymbol{e}_{1}\frac{1}{Z_{s}^{k}(-1)}F^k(-1, t)- \boldsymbol{e}_{N+1}\frac{1}{Z_{s}^{k}(1)}G^k(1, t)\right), \end{split} \end{equation} where \begin{align} \boldsymbol{e}_{1} = [ \mathcal{L}_1(-1), \mathcal{L}_2(-1), \dots, \mathcal{L}_{N+1}(-1) ]^T, \quad \boldsymbol{e}_{N+1} = [ \mathcal{L}_1(1), \mathcal{L}_2(1), \dots, \mathcal{L}_{N+1}(1) ]^T, \end{align} and \begin{align} G^k(1, t):= \frac{Z_{s}^{k}(1)}{2} \left(v^{k}(1, t)-\widehat{v}^{k}(1, t) \right) + \frac{1}{2}\left(\sigma^{k}(1, t)- \widehat{\sigma}^{k}(1, t)\right), \end{align} \begin{align} F^{k}(-1, t):= \frac{Z_{s}^{k}(-1)}{2} \left(v^{k}(-1, t)-\widehat{v}^{k}(-1, t) \right) - \frac{1}{2}\left(\sigma^{k}(-1, t)- \widehat{\sigma}^{k}(-1, t)\right). \end{align} And the weighted elemental mass matrix $W^N(a)$ and the stiffness matrix $Q^N $ are defined by \begin{align} W_{ij}(a) = \sum_{m = 1}^{N+1} w_m \mathcal{L}_i(\xi_m) {\mathcal{L}_j(\xi_m)} a(\xi_m), \quad Q_{ij} = \sum_{m = 1}^{N+1} w_m \mathcal{L}_i(\xi_m) {\mathcal{L}_j^{\prime}(\xi_m)}. \end{align} 7) Time extrapolation can be performed using any stable time stepping scheme like Runge-Kutta or ADER scheme.This notebook implements both Runge-Kutta and ADER schemes for solving the free source version of the elastic wave equation in a homogeneous media. To keep the problem simple, we use as spatial initial condition a Gauss function with half-width $\delta$ \begin{equation} v(x,t=0) = e^{-1/\delta^2 (x - x_{o})^2}, \quad \sigma(x,t=0) = 0 \end{equation} **** Exercises**** 1. Lagrange polynomial is used to interpolate the solution and the material parameters. First use polynomial degree 2 and then 6. Compare the simulation results in terms of accuracy of the solution (third and fourth figures give erros). At the end of simulation, time required to complete the simulation is also printed. Also compare the time required to complete both simulations. 2. We use quadrature rules: Gauss-Legendre-Lobatto and Gauss-Legendre. Run simulations once using Lobatto and once using Legendre rules. Compare the difference. 3. Now fix the order of polynomial to be 6, for example. Then use degree of freedom 100 and for another simulation 250. What happpens? Also compare the timre required to complete both simulations. 4. Experiment with the boundary conditions by changing the reflection coefficients $r_0$ and $r_n$. 5. You can also play around with sinusoidal initial solution instead of the Gaussian. 6. Change the time-integrator from RK to ADER. Observe if there are changes in the solution or the CFL number. Vary the polynomial order N. ```python # Parameters initialization and plotting the simulation # Import necessary routines import Lagrange import numpy as np import timeintegrate import quadraturerules import specdiff import utils import matplotlib.pyplot as plt import timeit # to check the simulation time #plt.switch_backend("TkAgg") # plots in external window plt.switch_backend("nbagg") # plots within this notebook ``` ```python # Simulation start time start = timeit.default_timer() # Tic iplot = 20 # Physical domain x = [ax, bx] (km) ax = 0.0 # (km) bx = 20.0 # (km) # Choose quadrature rules and the corresponding nodes # We use Gauss-Legendre-Lobatto (Lobatto) or Gauss-Legendre (Legendre) quadrature rule. #node = 'Lobatto' node = 'Legendre' if node not in ('Lobatto', 'Legendre'): print('quadrature rule not implemented. choose node = Legendre or node = Lobatto') exit(-1) # Polynomial degree N: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] N = 4 # Lagrange polynomial degree NP = N+1 # quadrature nodes per element if N < 1 or N > 12: print('polynomial degree not implemented. choose N>= 1 and N <= 12') exit(-1) # Degrees of freedom to resolve the wavefield deg_of_freedom = 400 # = num_element*NP # Estimate the number of elements needed for a given polynomial degree and degrees of freedom num_element = round(deg_of_freedom/NP) # = deg_of_freedom/NP # Initialize the mesh y = np.zeros(NP*num_element) # Generate num_element dG elements in the interval [ax, bx] x0 = np.linspace(ax,bx,num_element+1) dx = np.diff(x0) # element sizes # Generate Gauss quadrature nodes (psi): [-1, 1] and weights (w) if node == 'Legendre': GL_return = quadraturerules.GL(N) psi = GL_return['xi'] w = GL_return['weights']; if node == 'Lobatto': gll_return = quadraturerules.gll(N) psi = gll_return['xi'] w = gll_return['weights'] # Use the Gauss quadrature nodes (psi) generate the mesh (y) for i in range (1,num_element+1): for j in range (1,(N+2)): y[j+(N+1)*(i-1)-1] = dx[i-1]/2.0 * (psi[j-1] + 1.0) +x0[i-1] # Overide with the exact degrees of freedom deg_of_freedom = len(y); # Generate the spectral difference operator (D) in the reference element: [-1, 1] D = specdiff.derivative_GL(N, psi, w) # Boundary condition reflection coefficients r0 = 0 # r=0:absorbing, r=1:free-surface, r=-1: clamped rn = 0 # r=0:absorbing, r=1:free-surface, r=-1: clamped # Initialize the wave-fields L = 0.5*(bx-ax) delta = 0.01*(bx-ax) x0 = 0.5*(bx+ax) omega = 4.0 #u = np.sin(omega*np.pi*y/L) # Sine function u = 1/np.sqrt(2.0*np.pi*delta**2)*np.exp(-(y-x0)**2/(2.0*delta**2)) # Gaussian u = np.transpose(u) v = np.zeros(len(u)) U = np.zeros(len(u)) V = np.zeros(len(u)) print('points per wavelength: ', round(delta*deg_of_freedom/(2*L))) # Material parameters cs = 3.464 # shear wave speed (km/s) rho = 0*y + 2.67 # density (g/cm^3) mu = 0*y + rho * cs**2 # shear modulus (GPa) Zs = rho*cs # shear impedance # Time stepping parameters cfl = 0.5 # CFL number dt = (0.25/(cs*(2*N+1)))*min(dx) # time-step (s) t = 0.0 # initial time Tend = 2 # final time (s) n = 0 # counter # Difference between analyticla and numerical solutions EV = [0] # initialize errors in V (velocity) EU = [0] # initialize errors in U (stress) T = [0] # later append every time steps to this # Initialize animated plot for velocity and stress fig1 = plt.figure(figsize=(10,10)) ax1 = fig1.add_subplot(4,1,1) line1 = ax1.plot(y, u, 'r', y, U, 'k--') plt.title('numerical vs exact') plt.xlabel('x[km]') plt.ylabel('velocity [m/s]') ax2 = fig1.add_subplot(4,1,2) line2 = ax2.plot(y, v, 'r', y, V, 'k--') plt.title('numerical vs exact') plt.xlabel('x[km]') plt.ylabel('stress [MPa]') # Initialize error plot (for velocity and stress) ax3 = fig1.add_subplot(4,1,3) line3 = ax3.plot(T, EV, 'r') plt.title('relative error in particle velocity') plt.xlabel('time[t]') ax3.set_ylim([10**-5, 1]) plt.ylabel('error') ax4 = fig1.add_subplot(4,1,4) line4 = ax4.plot(T, EU, 'r') plt.ylabel('error') plt.xlabel('time[t]') ax4.set_ylim([10**-5, 1]) plt.title('relative error in stress') plt.tight_layout() plt.ion() plt.show() A = (np.linalg.norm(1/np.sqrt(2.0*np.pi*delta**2)*0.5*Zs*(np.exp(-(y+cs*(t+1*0.5)-x0)**2/(2.0*delta**2))\ - np.exp(-(y-cs*(t+1*0.5)-x0)**2/(2.0*delta**2))))) B = (np.linalg.norm(u)) # Loop through time and evolve the wave-fields using ADER time-stepping scheme of N+1 order of accuracy time_integrator = 'ADER' for t in utils.drange (0.0, Tend+dt,dt): n = n+1 # ADER time-integrator if time_integrator in ('ADER'): ADER_Wave_dG_return = timeintegrate.ADER_Wave_dG(u,v,D,NP,num_element,dx,w,psi,t,r0,rn,dt,rho,mu) u = ADER_Wave_dG_return['Hu'] v = ADER_Wave_dG_return['Hv'] # Runge-Kutta time-integrator if time_integrator in ('RK'): RK4_Wave_dG_return = timeintegrate.RK4_Wave_dG(u,v,D,NP,num_element,dx,w,psi,t,r0,rn,dt,rho,mu) u = RK4_Wave_dG_return['Hu'] v = RK4_Wave_dG_return['Hv'] # Analytical sine wave (use it when sine function is choosen above) #U = 0.5*(np.sin(omega*np.pi/L*(y+cs*(t+1*dt))) + np.sin(omega*np.pi/L*(y-cs*(t+1*dt)))) #V = 0.5*Zs*(np.sin(omega*np.pi/L*(y+cs*(t+1*dt))) - np.sin(omega*np.pi/L*(y-cs*(t+1*dt)))) # Analytical Gaussian U = 1/np.sqrt(2.0*np.pi*delta**2)*0.5*(np.exp(-(y+cs*(t+1*dt)-x0)**2/(2.0*delta**2))\ + np.exp(-(y-cs*(t+1*dt)-x0)**2/(2.0*delta**2))) V = 1/np.sqrt(2.0*np.pi*delta**2)*0.5*Zs*(np.exp(-(y+cs*(t+1*dt)-x0)**2/(2.0*delta**2))\ - np.exp(-(y-cs*(t+1*dt)-x0)**2/(2.0*delta**2))) EV.append(np.linalg.norm(V-v)/A) EU.append(np.linalg.norm(U-u)/B) T.append(t) # Updating plots if n % iplot == 0: for l in line1: l.remove() del l for l in line2: l.remove() del l for l in line3: l.remove() del l for l in line4: l.remove() del l # Display lines line1 = ax1.plot(y, u, 'r', y, U, 'k--') ax1.legend(iter(line1),('Numerical', 'Analytical')) line2 = ax2.plot(y, v, 'r', y, V, 'k--') ax2.legend(iter(line2),('Numerical', 'Analytical')) line3 = ax3.plot(T, EU, 'k--') ax3.set_yscale("log")#, nonposx='clip') line4 = ax4.plot(T, EV, 'k--') ax4.set_yscale("log")#, nonposx='clip') plt.gcf().canvas.draw() plt.ioff() plt.show() # Simulation end time stop = timeit.default_timer() print('total simulation time = ', stop - start) # print the time required for simulation print('ploynomial degree = ', N) # print the polynomial degree used print('degree of freedom = ', deg_of_freedom) # print the degree of freedom print('maximum relative error in particle velocity = ', max(EU)) # max. relative error in particle velocity print('maximum relative error in stress = ', max(EV)) # max. relative error in stress ``` ```python ```

234a4c3ae7c66228ce84555a68a11484d4aeb447

ipynb

Jupyter Notebook

notebooks/Earthquake Physics/DiscontinuousGalerkin/dg_elastic_physicalfluxes.ipynb

krischer/seismo_live_build

e4e8e59d9bf1b020e13ac91c0707eb907b05b34f

2020-07-11T10:01:39.000Z

2020-12-16T14:26:03.000Z

notebooks/Earthquake Physics/DiscontinuousGalerkin/dg_elastic_physicalfluxes.ipynb

krischer/seismo_live_build

e4e8e59d9bf1b020e13ac91c0707eb907b05b34f

notebooks/Earthquake Physics/DiscontinuousGalerkin/dg_elastic_physicalfluxes.ipynb

krischer/seismo_live_build

e4e8e59d9bf1b020e13ac91c0707eb907b05b34f

2020-11-11T05:05:41.000Z

2022-03-12T09:36:24.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

**Notebook Outline:** - [Setup with libraries](#Set-up-Cells) - [Fundamental equations for Poisson MGWR](#Fundamental-equations-for-Binomial-MGWR) - [Example Dataset](#Example-Dataset) - [Helper functions](#Helper-functions) - [Univariate example](#Univariate-example) - [Parameter check](#Parameter-check) - [Bandwidths check](#Bandwidths-check) ### Set up Cells ```python import sys sys.path.append("C:/Users/msachde1/Downloads/Research/Development/mgwr") ``` ```python import warnings warnings.filterwarnings("ignore") import pandas as pd import numpy as np from mgwr.gwr import GWR from spglm.family import Gaussian, Binomial, Poisson from mgwr.gwr import MGWR from mgwr.sel_bw import Sel_BW import multiprocessing as mp pool = mp.Pool() from scipy import linalg import numpy.linalg as la from scipy import sparse as sp from scipy.sparse import linalg as spla from spreg.utils import spdot, spmultiply from scipy import special import libpysal as ps import seaborn as sns import matplotlib.pyplot as plt from copy import deepcopy import copy from collections import namedtuple import spglm ``` ### Fundamental equations for Binomial MGWR \begin{align} l = log_b ( p / (1-p)) = ({\sum} {\beta} & _k x _{k,i}) \\ \end{align} where $x_{k,1}$ is the kth explanatory variable in place i, $𝛽_ks$ are the parameters and p is the probability such that p = P( Y = 1 ). By exponentiating the log-odds: $p / (1-p) = b^ {𝛽_0 + 𝛽_1 x_1 + 𝛽_2 x_2}$ It follows from this - the probability that Y = 1 is: $p = (b^ {𝛽_0 + 𝛽_1 x_1 + 𝛽_2 x_2}) / (b^ {𝛽_0 + 𝛽_1 x_1 + 𝛽_2 x_2} + 1)$ = $1 / (1 + b^ {- 𝛽_0 + 𝛽_1 x_1 + 𝛽_2 x_2})$ ### Example Dataset #### Clearwater data - downloaded from link: https://sgsup.asu.edu/sparc/multiscale-gwr ```python data_p = pd.read_csv("C:/Users/msachde1/Downloads/logistic_mgwr_data/landslides.csv") coords = list(zip(data_p['X'],data_p['Y'])) y = np.array(data_p['Landslid']).reshape((-1,1)) elev = np.array(data_p['Elev']).reshape((-1,1)) slope = np.array(data_p['Slope']).reshape((-1,1)) SinAspct = np.array(data_p['SinAspct']).reshape(-1,1) CosAspct = np.array(data_p['CosAspct']).reshape(-1,1) X = np.hstack([elev,slope,SinAspct,CosAspct]) x = slope X_std = (X-X.mean(axis=0))/X.std(axis=0) x_std = (x-x.mean(axis=0))/x.std(axis=0) y_std = (y-y.mean(axis=0))/y.std(axis=0) ``` ### Helper functions Hardcoded here for simplicity in the notebook workflow Please note: A separate bw_func_b will not be required when changes will be made in the repository ```python kernel='bisquare' fixed=False spherical=False search_method='golden_section' criterion='AICc' interval=None tol=1e-06 max_iter=200 X_glob=[] ``` ```python def gwr_func(y, X, bw,family=Gaussian(),offset=None): return GWR(coords, y, X, bw, family,offset,kernel=kernel, fixed=fixed, constant=False, spherical=spherical, hat_matrix=False).fit( lite=True, pool=pool) def bw_func_b(coords,y, X): selector = Sel_BW(coords,y, X,family=Binomial(),offset=None, X_glob=[], kernel=kernel, fixed=fixed, constant=False, spherical=spherical) return selector def bw_func_p(coords,y, X): selector = Sel_BW(coords,y, X,family=Poisson(),offset=off, X_glob=[], kernel=kernel, fixed=fixed, constant=False, spherical=spherical) return selector def bw_func(coords,y,X): selector = Sel_BW(coords,y,X,X_glob=[], kernel=kernel, fixed=fixed, constant=False, spherical=spherical) return selector def sel_func(bw_func, bw_min=None, bw_max=None): return bw_func.search( search_method=search_method, criterion=criterion, bw_min=bw_min, bw_max=bw_max, interval=interval, tol=tol, max_iter=max_iter, pool=pool, verbose=False) ``` ### Univariate example #### GWR model with independent variable, x = slope ```python bw_gwbr=Sel_BW(coords,y_std,x_std,family=Binomial(),constant=False).search() ``` ```python gwbr_model=GWR(coords,y_std,x_std,bw=bw_gwbr,family=Binomial(),constant=False).fit() ``` ```python bw_gwbr ``` 198.0 #### MGWR Binomial loop with one independent variable, x = slope ##### Edited multi_bw function - original function in https://github.com/pysal/mgwr/blob/master/mgwr/search.py#L167 ```python def multi_bw(init,coords,y, X, n, k, family=Gaussian(),offset=None, tol=1e-06, max_iter=200, multi_bw_min=[None], multi_bw_max=[None],rss_score=False,bws_same_times=3, verbose=False): if multi_bw_min==[None]: multi_bw_min = multi_bw_min*X.shape[1] if multi_bw_max==[None]: multi_bw_max = multi_bw_max*X.shape[1] if isinstance(family,spglm.family.Poisson): bw = sel_func(bw_func_p(coords,y,X)) optim_model=gwr_func(y,X,bw,family=Poisson(),offset=offset) err = optim_model.resid_response.reshape((-1, 1)) param = optim_model.params #This change for the Poisson model follows from equation (1) above XB = offset*np.exp(np.multiply(param, X)) elif isinstance(family,spglm.family.Binomial): bw = sel_func(bw_func_b(coords,y,X)) optim_model=gwr_func(y,X,bw,family=Binomial()) err = optim_model.resid_response.reshape((-1, 1)) param = optim_model.params #This change for the Binomial model follows from equation above XB = 1/(1+np.exp(-1*np.multiply(optim_model.params,X))) #print(XB) else: bw=sel_func(bw_func(coords,y,X)) optim_model=gwr_func(y,X,bw) err = optim_model.resid_response.reshape((-1, 1)) param = optim_model.params XB = np.multiply(param, X) bw_gwr = bw XB=XB if rss_score: rss = np.sum((err)**2) iters = 0 scores = [] delta = 1e6 BWs = [] bw_stable_counter = np.ones(k) bws = np.empty(k) try: from tqdm.auto import tqdm #if they have it, let users have a progress bar except ImportError: def tqdm(x, desc=''): #otherwise, just passthrough the range return x for iters in tqdm(range(1, max_iter + 1), desc='Backfitting'): new_XB = np.zeros_like(X) params = np.zeros_like(X) for j in range(k): temp_y = XB[:, j].reshape((-1, 1)) temp_y = temp_y + err temp_X = X[:, j].reshape((-1, 1)) #The step below will not be necessary once the bw_func is changed in the repo to accept family and offset as attributes if isinstance(family,spglm.family.Poisson): bw_class = bw_func_p(coords,temp_y, temp_X) elif isinstance(family,spglm.family.Binomial): bw_class = bw_func_b(coords,temp_y, temp_X) else: bw_class = bw_func(coords,temp_y, temp_X) if np.all(bw_stable_counter == bws_same_times): #If in backfitting, all bws not changing in bws_same_times (default 3) iterations bw = bws[j] else: bw = sel_func(bw_class, multi_bw_min[j], multi_bw_max[j]) if bw == bws[j]: bw_stable_counter[j] += 1 else: bw_stable_counter = np.ones(k) #Changed gwr_func to accept family and offset as attributes optim_model = gwr_func(temp_y, temp_X, bw,family,offset) err = optim_model.resid_response.reshape((-1, 1)) param = optim_model.params.reshape((-1, )) new_XB[:, j] = optim_model.predy.reshape(-1) params[:, j] = param bws[j] = bw num = np.sum((new_XB - XB)**2) / n den = np.sum(np.sum(new_XB, axis=1)**2) score = (num / den)**0.5 XB = new_XB if rss_score: predy = np.sum(np.multiply(params, X), axis=1).reshape((-1, 1)) new_rss = np.sum((y - predy)**2) score = np.abs((new_rss - rss) / new_rss) rss = new_rss scores.append(deepcopy(score)) delta = score BWs.append(deepcopy(bws)) if verbose: print("Current iteration:", iters, ",SOC:", np.round(score, 7)) print("Bandwidths:", ', '.join([str(bw) for bw in bws])) if delta < tol: break print("iters = "+str(iters)) opt_bws = BWs[-1] print("opt_bws = "+str(opt_bws)) return (opt_bws, np.array(BWs), np.array(scores), params, err, bw_gwr) ``` ##### Running the function with family = Binomial() ```python bw_mgwbr = multi_bw(init=None,coords=coords,y=y_std, X=x_std, n=239, k=x.shape[1], family=Binomial()) ``` iters = 1 opt_bws = [198.] ##### Running without family and offset attributes runs the normal MGWR loop ```python bw_mgwr = multi_bw(init=None, coords=coords,y=y_std, X=x_std, n=262, k=x.shape[1]) ``` iters = 1 opt_bws = [125.] ### Parameter check #### Difference in parameters from the GWR - Binomial model and MGWR Binomial model ```python (bw_mgwbr[3]==gwbr_model.params).all() ``` True The parameters are identical ### Bandwidths check ```python bw_gwbr ``` 235.0 ```python bw_mgwbr[0] ``` array([235.]) The bandwidth from both models is the same

998d672a62ef7522ab9f51475e459f43a6d5cb80

ipynb

Jupyter Notebook

Notebooks/.ipynb_checkpoints/Binomial_MGWR_univariate_check-checkpoint.ipynb

TaylorOshan/MGWR_workshop_book

4c0be5cb08dfc669c8da0d1c074f3c5052a81c0a

2021-01-21T08:30:01.000Z

2021-07-24T05:40:43.000Z

Notebooks/Binomial_MGWR_univariate_check.ipynb

TaylorOshan/MGWR_book

c59db902b34d625af4d0e1b90fbc95018a3de579

Notebooks/Binomial_MGWR_univariate_check.ipynb

TaylorOshan/MGWR_book

c59db902b34d625af4d0e1b90fbc95018a3de579

2020-07-20T19:43:36.000Z

2021-06-07T23:41:08.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Subspace **Subspace.** The set of vectors $V$ is a linear subspace of $\mathbb{R}^n \iff$ null vector $\in V$ and $V$ is closed under scalar multiplication and addition. ⚠️ *Union of subspaces is not a subspace* > The reason why this can happen is that all vector spaces, and hence subspaces too, must be closed under addition (and scalar multiplication). The union of two subspaces takes all the elements already in those spaces, and nothing more. > > In the union of subspaces $W_1$ and $W_2$ there are new combinations of vectors we can add together that we couldn't before, like $v_1 + v_2$ where $v_1 \in W_1$ and $v_2 \in W_2$. > > For example, take $W_1$ to be the $x$-axis and $W_2$ the $y$-axis, both subspaces of $\mathbb{R}^2$. Their union includes both $(3,0)$ and $(0,5)$, whose sum, $(3,5)$, is not in the union. Hence, the union is not a vector space. > > http://math.stackexchange.com/a/71875/402625 # Linear Dependence and Independence **Linearly Dependent.** A set of vectors is linearly dependent if there exists a vector in the set that *can be written as a linear combination of the others*. **Linearly Independent.** A set of vectors is linearly independent $\iff$ the only linear combination that gives the null vector is the linear combination with all coefficients equal to $0$. $$\Sigma_{i=0}^k \lambda_i v_i = 0 \iff \lambda_1 = \lambda_2 = \dots = \lambda_i = 0$$ _**Proof.**_ ($\Rightarrow$) Say there exists a linear combination of that set ($D$) that evaluates to the null vector and not all coefficients equal $0$, then there exists a linear combination $\Sigma_{i=1}^{n}\lambda_i v_i=0$ with $\lambda_i\in\mathbb{R}, v_i\in D$ and $\lambda_1\neq0$. So, $v_1=\frac{-1}{\lambda_1}\left( \Sigma_{i=2}^{n}\lambda_i v_i \right)$ and the set is linearly dependent. # Span **Span**. The *span of a given subset ($D$) of a vector space ($V$)* is *the vector space ($\text{span}(D)$) containing all possible linear combinations of the vectors in the subset ($D$)*. ##### _Example_ \begin{equation} A_1= \begin{bmatrix} 1 \\ 0 \end{bmatrix}, A_2= \begin{bmatrix} 0 \\ 1 \end{bmatrix} \end{equation} $\text{span}(\{A_1,A_2\})=\langle\{A_1,A_2\}\rangle=\text{vct}(\{A_1,A_2\})= \{\alpha_1A_1 + \alpha_2A_2\mid\alpha_1,\alpha_2\in\mathbb{R}\}$ Two 2-vectors span $\mathbb{R}^2 \iff$ they are linearly independent. $\text{span}(\{A_1,A_2\})=\mathbb{R}^2$ ##### Thoughts *Q*: If the set of 2 vectors is linearly dependent, can each one be written as a linear combination of the other? What about 3 vectors? *A*: Trivial for 2 vectors. If the set of vectors $A_1$ and $A_2$ are linearly dependent, there exists a vector in that set that can be written as a linear combination of the other. Say $A_1$ is that vector, then $A_1=\alpha A_2,$ with $\alpha\in\mathbb{F}$ and $A_2=\frac{1}{\alpha}A_1$. Analogue if $A_2$ is that vector. For 3 vectors, this isn't necessarily possible (e.g.: $\{(1,0,0),(2,0,0),(0,1,0)\}$). The set of 3 vectors is linearly dependent if (at least) one of them can be written as a linear combination of the others. # Basis & Dimension **Basis.** A set of *linearly independent* vectors that *spans a vector space* is a *basis* of that space. ⚠️ *Lemma of Steinitz* Say $(\mathbb{R},V,+)$ a vector space. Then: 1. if a subset $\subset V$ of $m$ elements exists that spans $V$, then every subset of $V$ with more than $m$ elements is linearly dependent; 2. if a subset $\subset V$ of $n$ elements exists that is linearly independent, then every subset of $V$ with less than $n$ elements cannot span $V$. **Dimension.** The *dimension of a vector space* equals the *number of elements in a (finite) basis* for that vector space. (_Notation:_ $\text{dim}_{\mathbb{R}}V$) ⚠️ Say $(\mathbb{R},V,+)$ a vector space of dimension $n$. Then: 1. every linear independent subset $\subset V$ can be extended to a basis of $V$; 2. every finite subset $\subset V$ that spans $V$ can be reduced (by removing vectors) to a basis of $V$. ```python ```

a3398163ff03b7c95028982f28b01a7b3d173e4a

ipynb

Jupyter Notebook

H3_vector_spaces.ipynb

jppgks/linear-algebra-notebooks

08ce0ad8e7a8fb65ddd872d3084d1f8946b65fe0

2016-11-30T09:55:17.000Z

2016-11-30T09:55:17.000Z

H3_vector_spaces.ipynb

jppgks/linear-algebra-notebooks

08ce0ad8e7a8fb65ddd872d3084d1f8946b65fe0

H3_vector_spaces.ipynb

jppgks/linear-algebra-notebooks

08ce0ad8e7a8fb65ddd872d3084d1f8946b65fe0

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Haverly's Pooling Problem ## Objective and Prerequisites One of the new features of Gurobi 9.0 is the addition of a bilinear solver, which enables finding the optimal solution of non-convex quadratic programming problems (i.e. QPs, QCQPs, MIQPs, and MIQCQPs). This notebook will show you how to use this feature by tackling the Haverly's Pooling Problem. To fully understand the content of this notebook, the reader should be familiar with the following: - Python. - Gurobi Python interface. - Knowledge of building mathematical optimization models. **Note:** You can download the repository containing this and other examples by clicking [here](https://github.com/Gurobi/modeling-examples/archive/master.zip). In order to run this Jupyter Notebook properly, you must have a Gurobi license. If you do not have one, you can request an [evaluation license](https://www.gurobi.com/downloads/request-an-evaluation-license/?utm_source=Github&utm_medium=website_JupyterME&utm_campaign=CommercialDataScience) as a *commercial user*, or download a [free license](https://www.gurobi.com/academia/academic-program-and-licenses/?utm_source=Github&utm_medium=website_JupyterME&utm_campaign=AcademicDataScience) as an *academic user*. --- ## Motivation The Pooling Problem is a challenging problem in the petrochemical refining, wastewater treatment and mining industries. This problem can be regarded as a generalization of the minimum-cost flow problem and the blending problem. It is indeed important because of the significant savings it can generate, so it comes at no surprise that it has been studied extensively since Haverly pointed out the non-linear structure of this problem in 1978 [3]. --- ## Problem Description The Minimum-Cost Flow Problem (MCFP) seeks to find the cheapest way of sending a certain amount of flow from a set of source nodes to a set of target nodes, possibily via transshipment nodes⁠, in a directed capacitated network. The Blending Problem is a type of MCFP with only source and target nodes, where raw materials with different attribute qualities are blended together to create end products in such a way that their attribute qualities are within tolerances. The Pooling Problem combines features of both problems, as flow streams from different sources are mixed at intermediate pools and blended again at the target nodes. The non-linearity is in fact the direct result of considering pools, as the quality of a given attribute at a pool —defined as the weighted average of the qualities of the incoming streams— is an unknown quantity and thus needs to be captured by a decision variable. We refer to this problem as the Standard Pooling Problem when the network can be represented by a tripartite graph, i.e. three disjoint sets of nodes such that no nodes within the same set are adjacent. In a nutshell, it can be stated as follows: Given a list of source nodes with raw materials containing known attribute qualities, what is the cheapest way of mixing these materials at intermediate pools so as to meet the demand and tolerances at multiple target nodes? (Gupte et al., 2017) [2]. --- ## Define Data In this example, there are three sources of oil, each of which contains a different percentage of sulfur. Given the pooling layout, these materials are to be blended in such a way to create two separate oil products. These final products have requirements on the percentage of sulfur they can contain, as well as how much of the product can be produced. Now, we define the data used in Haverly's 1978 paper: ```python import numpy as np import pandas as pd from itertools import product from gurobipy import * attrs = {'sulfur'} sources, cost, content = multidict({ "A": [6, {'sulfur': 3}], "B": [16, {'sulfur': 1}], "C": [10, {'sulfur': 2}] }) targets, price, demand, max_tol = multidict({ "X": [9, 100, {'sulfur': 2.5}], "Y": [15, 200, {'sulfur': 1.5}] }) pools = {"P"} s2p = {("A", "P"), ("B", "P")} # The function `product` deploys the Cartesian product of elements in sets A and B p2t = set(product(pools, targets)) s2t = {("C", "X"), ("C", "Y")} ``` --- ## Mathematical Formulation Mathematical programming is a declarative approach where the modeler formulates a mathematical optimization model that captures the key aspects of a complex decision problem. The Gurobi Optimizer solves such models using state-of-the-art mathematics and computer science. A mathematical optimization model has five components, namely: - Sets and indices. - Parameters. - Decision variables. - Objective function(s). - Constraints. A quadratic constraint that involves only products of disjoint pairs of variables is often called a bilinear constraint, and a model that contains bilinear constraints is often called a Bilinear Program. Bilinear constraints are a special case of non-convex quadratic constraints. This type of problems is typically solved using spatial Branch and Bound (sB&B). This algorithm explores the entire search space, so it provides a globally valid lower bound on the optimal objective value and —given enough time— it will find a globally optimal solution (subject to tolerances). The interested reader is referred to [references](#references) [1], [4] and [5]. We now present a Bilinear Program for the Standard Pooling Problem: #### Sets and Indices $G=(V,E)$: Directed graph. $i,j \in V$: Set of nodes. $(i,j) \in E \subset V \times V$: Set of edges. $N(i)^+ = \{j \in V \mid (i,j) \in E \}$: Set of successor nodes receiving outflow from node $i$. $N(j)^- = \{i \in V \mid (i,j) \in E \}$: Set of predecessor nodes sending inflow to node $i$. $k \in \text{Attrs}$: Set of attributes. $s \in \text{Sources} \subset V$: Set of source nodes, i.e. $N(s)^-= \emptyset$. $t \in \text{Targets} \subset V$: Set of target nodes, i.e. $N(t)^+= \emptyset$. $p \in \text{Pools} = V \setminus (\text{Sources} \cup \text{Targets})$: Set of pools. #### Parameters $\text{Cost}_s \in \mathbb{R}^+$: Cost of acquiring one unit of raw material at source node $s$. $\text{Content}_{s,k} \in \mathbb{R}^+$: Content of attribute $k$ in raw material at source node $s$. $\text{Price}_t \in \mathbb{R}^+$: Price for selling one unit of final blend at target node $t$. $\text{Demand}_t \in \mathbb{R}^+$: Minimum number of units required of final blend at target node $t$. $\text{Max_tol}_{t,k} \in \mathbb{R}^+$: Maximum tolerance for attribute $k$ in final blend at target node $t$. #### Decision Variables $\text{flow}_{i,j} \in [0, \text{UB}_{i,j}]$: Flow from node $i$ to node $j$. $\text{quality}_{p,k} \in \mathbb{R}^+$: Concentration of attribute $k$ at pool $p$. #### Objective Function - **Profit**: Maximize total profits. \begin{equation} \text{Max} \quad Z = \sum_{t \in \text{Targets}}{\sum_{i \in N(t)^-}{\text{Price}_t \cdot \text{flow}_{i,t}}} - \sum_{s \in \text{Sources}}{\sum_{j \in N(s)^+}{\text{Cost}_s \cdot \text{flow}_{s,j}}} \tag{0} \end{equation} #### Constraints - **Flow conservation**: Total inflow of pool $p$ must be equal to its toal outflow (nothing is stored in them). \begin{equation} \sum_{t \in N(p)^+}{\text{flow}_{p,t}} - \sum_{s \in N(p)^-}{\text{flow}_{s,p}} = 0 \quad \forall p \in \text{Pools} \tag{1} \end{equation} - **Target demand**: Total inflow of target $t$ cannot exceed maximum demand. \begin{equation} \sum_{i \in N(t)^-}{\text{flow}_{i,t}} \leq \text{Demand}_t \quad \forall t \in \text{Targets} \tag{2} \end{equation} - **Pool concentration**: Concentration of attribute $k$ at pool $p$ is expressed as the weighted average (linear blending) of the concentrations associated to the incoming flows (notice the bilinear terms on the right-hand side). \begin{equation} \sum_{s \in N(p)^-}{\text{Content}_{s,k} \cdot \text{flow}_{s,p}} = \text{quality}_{p,k} \cdot \sum_{t \in N(p)^+}{\text{flow}_{p,t}} \quad \forall (p,k) \in \text{Pools} \times \text{Attrs} \tag{3} \end{equation} - **Target tolerances**: Concentration of attribute $k$ at target $t$ is also the result of linear blending, and must be within tolerances (notice the bilinear terms on the second expression of the left-hand side). \begin{equation} \sum_{s \in N(t)^- \cap \text{Sources}}{\text{Content}_{s,k} \cdot \text{flow}_{s,t}}+ \sum_{p \in N(t)^- \cap \text{Pools}}{\text{quality}_{p,k} \cdot \text{flow}_{p,t}} \leq \text{Max_tol}_{t,k} \cdot \sum_{i \in N(t)^-}{\text{flow}_{i,t}} \quad \forall (t,k) \in \text{Targets} \times \text{Attrs} \tag{4} \end{equation} --- ## Python Implementation Solving Bilinear Programs with Gurobi is as easy as configuring the global parameter `nonConvex`. When setting this parameter to a value of 2, non-convex quadratic problems are solved by means of translating them into bilinear form and applying spatial Branch and Bound (sB&B). ```python haverly = Model("Pooling") # Set global parameters haverly.params.nonConvex = 2 # Declare decision variables # flow ik = haverly.addVars(s2t, name="Source2Target") ij = haverly.addVars(s2p, name="Source2Pool") jk = haverly.addVars(p2t, name="Pool2Target") # quality prop = haverly.addVars(pools, attrs, name="Proportion") # Deploy constraint sets # 1. Flow conservation haverly.addConstrs((ij.sum('*',j) == jk.sum(j,'*') for j in pools), name="Flow_conservation") # 2. Target demand haverly.addConstrs((ik.sum('*',k) + jk.sum('*',k) <= demand[k] for k in targets), name="Target_demand") # 3. Pool concentration haverly.addConstrs((quicksum(content[i][attr]*ij[i,j] for i in sources if (i,j) in s2p) == prop[j,attr]*jk.sum(j,'*') for j in pools for attr in attrs), name="Pool_concentration") # 4. Target (max) tolerances haverly.addConstrs((quicksum(content[i][attr]*ik[i,k] for i in sources if (i,k) in s2t) + quicksum(prop[j,attr]*jk[j,k] for j in pools if (j,k) in p2t) <= max_tol[k][attr]*(ik.sum('*',k) + jk.sum('*',k)) for k in targets for attr in max_tol[k].keys()), name="Target_max_tolerances") # Deploy Objective Function # 0. Total profit obj = quicksum(price[k]*(ik.sum('*',k) + jk.sum('*',k)) for k in targets) \ - quicksum(cost[i]*(ij.sum(i,'*') + ik.sum(i,'*')) for i in sources) haverly.setObjective(obj, GRB.MAXIMIZE) # Find the optimal solution haverly.optimize() ``` Using license file /Users/orojuan/gurobi.lic Set parameter TokenServer to value Juans-MacBook-Pro-3.local Changed value of parameter nonConvex to 2 Prev: -1 Min: -1 Max: 2 Default: -1 Gurobi Optimizer version 9.0.0 build v9.0.0rc2 (mac64) Optimize a model with 3 rows, 7 columns and 8 nonzeros Model fingerprint: 0x777f4d01 Model has 3 quadratic constraints Coefficient statistics: Matrix range [1e+00, 1e+00] QMatrix range [1e+00, 1e+00] QLMatrix range [5e-01, 3e+00] Objective range [1e+00, 2e+01] Bounds range [0e+00, 0e+00] RHS range [1e+02, 2e+02] Continuous model is non-convex -- solving as a MIP. Found heuristic solution: objective -0.0000000 Presolve time: 0.00s Presolved: 16 rows, 10 columns, 34 nonzeros Presolved model has 4 bilinear constraint(s) Variable types: 10 continuous, 0 integer (0 binary) Root relaxation: objective 2.100000e+03, 4 iterations, 0.00 seconds Nodes | Current Node | Objective Bounds | Work Expl Unexpl | Obj Depth IntInf | Incumbent BestBd Gap | It/Node Time 0 0 2100.00000 0 3 -0.00000 2100.00000 - - 0s 0 0 2100.00000 0 3 -0.00000 2100.00000 - - 0s 0 0 1937.83784 0 3 -0.00000 1937.83784 - - 0s 0 0 1921.35002 0 4 -0.00000 1921.35002 - - 0s 0 0 1921.23235 0 4 -0.00000 1921.23235 - - 0s 0 0 1921.17768 0 4 -0.00000 1921.17768 - - 0s 0 2 1921.17768 0 4 -0.00000 1921.17768 - - 0s * 6 6 2 321.5204987 1882.20468 485% 3.0 0s * 12 4 3 346.2144981 1846.72927 433% 2.4 0s * 14 4 4 348.0276050 1846.72927 431% 3.1 0s * 22 10 5 355.0833492 1778.85855 401% 3.0 0s * 23 5 5 363.4227077 1778.85855 389% 2.9 0s * 24 5 6 363.6955948 1778.85855 389% 2.9 0s * 25 5 6 370.7666965 1778.85855 380% 2.8 0s * 26 5 7 372.0510296 1778.85855 378% 2.8 0s * 32 2 7 377.9877375 1746.46493 362% 2.5 0s * 34 2 8 380.1494347 1746.46493 359% 2.4 0s * 36 4 8 383.8453897 1746.46493 355% 2.5 0s * 40 5 9 387.9905769 1715.10036 342% 2.5 0s * 41 5 9 390.8479187 1715.10036 339% 2.4 0s * 45 5 10 395.5742065 1684.76584 326% 2.4 0s * 47 5 10 397.5729772 1684.76584 324% 2.3 0s * 52 7 12 399.9188266 1684.76584 321% 2.3 0s * 60 2 16 399.9999622 1655.46244 314% 2.2 0s * 70 2 18 400.0000031 1627.19132 307% 2.1 0s Cutting planes: RLT: 3 Explored 105 nodes (257 simplex iterations) in 0.06 seconds Thread count was 8 (of 8 available processors) Solution count 10: 400 400 399.919 ... 377.988 Optimal solution found (tolerance 1.00e-04) Best objective 4.000000031377e+02, best bound 4.000000031377e+02, gap 0.0000% ### Analysis Let's see the optimal flows found: ```python def _print_table(rows, columns, variables): table = pd.DataFrame(columns=columns, index=rows, data=0.0) for row, col in variables.keys(): value = variables[row, col].x if abs(value) > 1e-6: table.loc[row, col] = np.round(value, 1) print(table) def print_solution(): print("Flows from Sources to Targets") _print_table(sources.copy(), targets.copy(), ik) print("Flows from Pools to Targets") _print_table(pools.copy(), targets.copy(), jk) print("Flows from Sources to Pools") _print_table(sources.copy(), pools.copy(), ij) ``` ```python print_solution() ``` Flows from Sources to Targets X Y A 0.0 0.0 B 0.0 0.0 C 0.0 100.0 Flows from Pools to Targets X Y P 0.0 100.0 Flows from Sources to Pools P A 0.0 B 100.0 C 0.0 --- ## Changing the Data We now consider how the optimal solution changes by modifying some parameters in the model. ### Increasing Demand The maximum demand of product $\text{X}$ increased from 100 to 600: ```python dem_x = haverly.getConstrByName("Target_demand[X]") dem_x.setAttr("rhs", 600) haverly.optimize() ``` Gurobi Optimizer version 9.0.0 build v9.0.0rc2 (mac64) Optimize a model with 3 rows, 7 columns and 8 nonzeros Model fingerprint: 0xf2ff1488 Model has 3 quadratic constraints Variable types: 7 continuous, 0 integer (0 binary) Coefficient statistics: Matrix range [1e+00, 1e+00] QMatrix range [1e+00, 1e+00] QLMatrix range [5e-01, 3e+00] Objective range [1e+00, 2e+01] Bounds range [0e+00, 0e+00] RHS range [2e+02, 6e+02] MIP start from previous solve produced solution with objective 324 (0.01s) MIP start from previous solve produced solution with objective 526.694 (0.02s) MIP start from previous solve produced solution with objective 599.488 (0.02s) MIP start from previous solve produced solution with objective 599.976 (0.02s) MIP start from previous solve produced solution with objective 600 (0.02s) MIP start from previous solve produced solution with objective 600 (0.03s) Loaded MIP start from previous solve with objective 600 Presolve time: 0.00s Presolved: 16 rows, 10 columns, 34 nonzeros Presolved model has 4 bilinear constraint(s) Variable types: 10 continuous, 0 integer (0 binary) Root relaxation: objective 3.600000e+03, 4 iterations, 0.00 seconds Nodes | Current Node | Objective Bounds | Work Expl Unexpl | Obj Depth IntInf | Incumbent BestBd Gap | It/Node Time 0 0 3600.00000 0 3 600.00000 3600.00000 500% - 0s 0 0 3600.00000 0 3 600.00000 3600.00000 500% - 0s 0 0 3381.81818 0 4 600.00000 3381.81818 464% - 0s 0 0 3230.76924 0 3 600.00000 3230.76924 438% - 0s 0 0 3217.40285 0 4 600.00000 3217.40285 436% - 0s 0 0 3207.95528 0 4 600.00000 3207.95528 435% - 0s 0 2 3207.95528 0 4 600.00000 3207.95528 435% - 0s * 126 5 54 600.0000064 600.70747 0.12% 3.5 0s Cutting planes: RLT: 3 Explored 141 nodes (472 simplex iterations) in 0.06 seconds Thread count was 8 (of 8 available processors) Solution count 6: 600 600 599.976 ... 324 Optimal solution found (tolerance 1.00e-04) Best objective 6.000000063584e+02, best bound 6.000000063584e+02, gap 0.0000% ```python print_solution() ``` Flows from Sources to Targets X Y A 0.0 0.0 B 0.0 0.0 C 300.0 0.0 Flows from Pools to Targets X Y P 300.0 0.0 Flows from Sources to Pools P A 300.0 B 0.0 C 0.0 ### Decreasing Cost The price of extracting crude oil from source $\text{B}$ decreased from $\$16$ to $\$13$: ```python dem_x.setAttr("rhs", 100) # reinstate the model to its initial state ij["B", "P"].obj = -13 # the coefficient is negative since we're modifying a cost haverly.optimize() ``` Gurobi Optimizer version 9.0.0 build v9.0.0rc2 (mac64) Optimize a model with 3 rows, 7 columns and 8 nonzeros Model fingerprint: 0x94aace23 Model has 3 quadratic constraints Variable types: 7 continuous, 0 integer (0 binary) Coefficient statistics: Matrix range [1e+00, 1e+00] QMatrix range [1e+00, 1e+00] QLMatrix range [5e-01, 3e+00] Objective range [1e+00, 2e+01] Bounds range [0e+00, 0e+00] RHS range [1e+02, 2e+02] MIP start from previous solve produced solution with objective -14.0625 (0.01s) MIP start from previous solve produced solution with objective -0 (0.02s) MIP start from previous solve produced solution with objective 1.88255 (0.03s) MIP start from previous solve produced solution with objective 721.662 (0.03s) MIP start from previous solve produced solution with objective 726.254 (0.03s) Loaded MIP start from previous solve with objective 726.254 Presolve time: 0.00s Presolved: 16 rows, 10 columns, 34 nonzeros Presolved model has 4 bilinear constraint(s) Variable types: 10 continuous, 0 integer (0 binary) Root relaxation: objective 2.100000e+03, 4 iterations, 0.00 seconds Nodes | Current Node | Objective Bounds | Work Expl Unexpl | Obj Depth IntInf | Incumbent BestBd Gap | It/Node Time 0 0 2100.00000 0 3 726.25404 2100.00000 189% - 0s 0 0 2100.00000 0 3 726.25404 2100.00000 189% - 0s 0 0 1935.80379 0 3 726.25404 1935.80379 167% - 0s 0 0 1919.29441 0 4 726.25404 1919.29441 164% - 0s 0 0 1918.94856 0 4 726.25404 1918.94856 164% - 0s 0 0 1918.78695 0 4 726.25404 1918.78695 164% - 0s 0 2 1918.78695 0 4 726.25404 1918.78695 164% - 0s * 4 6 2 740.2106233 1900.53786 157% 2.8 0s * 10 4 3 750.0000000 1844.51703 146% 2.6 0s Cutting planes: RLT: 3 Explored 49 nodes (143 simplex iterations) in 0.08 seconds Thread count was 8 (of 8 available processors) Solution count 7: 750 740.211 726.254 ... -14.0625 Optimal solution found (tolerance 1.00e-04) Best objective 7.500000000000e+02, best bound 7.500000000000e+02, gap 0.0000% ```python print_solution() ``` Flows from Sources to Targets X Y A 0.0 0.0 B 0.0 0.0 C 0.0 0.0 Flows from Pools to Targets X Y P 0.0 200.0 Flows from Sources to Pools P A 50.0 B 150.0 C 0.0 --- ## Conclusion This notebook showed how easy it is to solve Bilinear Programs using Gurobi. The Haverly's pooling problem is indeed a simple instance of the Standard Pooling Problem, as it considers only one attribute. It was modeled using what the literature calls the P-Formulation, where the number of bilinear terms is proportional to the number of attributes. For intances with more specifications, it may be worth considering using alternative formulations —such as the Q-Formulation— to improve the performance of the optimization process. The Jupyter Notebook `Standard Pooling Problem` presents and compares both formulations with a more challenging scenario. --- ## References 1. Dombrowski, J. (2015, June 07). McCormick envelopes. Retrieved from https://optimization.mccormick.northwestern.edu/index.php/McCormick_envelopes 2. Gupte, A., Ahmed, S., Dey, S. S., & Cheon, M. S. (2017). Relaxations and discretizations for the pooling problem. Journal of Global Optimization, 67(3), 631-669. 3. Haverly, C. A. (1978). Studies of the behavior of recursion for the pooling problem. Acm sigmap bulletin, (25), 19-28. 4. Liberti, L. (2008). Introduction to global optimization. Ecole Polytechnique. 5. Zhuang E. (2015, June 06). Spatial branch and bound method. Retrieved from https://optimization.mccormick.northwestern.edu/index.php/Spatial_branch_and_bound_method Copyright © 2019 Gurobi Optimization, LLC

63ec521c2c160a2316e904a0ac8ff705b095bf9d

ipynb

Jupyter Notebook

haverly/haverly.ipynb

Zhong-HY/modeling-examples

66355938dde764a320f0a6a70a9e5a69c696a18f

haverly/haverly.ipynb

Zhong-HY/modeling-examples

66355938dde764a320f0a6a70a9e5a69c696a18f

haverly/haverly.ipynb

Zhong-HY/modeling-examples

66355938dde764a320f0a6a70a9e5a69c696a18f

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python import numpy as np from scipy import optimize ``` Starting with an initial flow over a horizontal surface where $M_1 = 2.2$, an oblique shock forms at an angle of $\theta = 35^{\circ}$, which deflects the flow by the angle $\delta$. The flow now has Mach number $M_2$. To satisfy the boundary condition of the surface, the oblique shock reflects at an angle $\beta$ from the surface, which deflects the flow back to the horizontal direction with a flow at a Mach number of $M_3$. What is the angle of reflection ($\beta$)? How do the strengths of each shock compare? First, let's determine the deflection angle of the first oblique shock using \begin{equation} \tan \delta = 2 (\cot \theta) \left[ \frac{M_1^2 \sin^2 \theta - 1}{M_1^2 (\gamma + \cos 2\theta) + 2}\right] \end{equation} ```python # known values gamma = 1.4 M1 = 2.2 theta = np.radians(35.0) # convert from degrees to radians delta = np.arctan( 2 * (1 / np.tan(theta)) * (M1**2 * np.sin(theta)**2 - 1) / (M1**2 * (gamma + np.cos(2*theta)) + 2) ) print(f'Deflection angle: {np.degrees(delta):.3}') ``` Deflection angle: 9.21 Now we can determine the conditions after the oblique shock, using \begin{equation} M_{1n} = M_1 \sin \theta \end{equation} and \begin{equation} M_{2n}^2 = \frac{M_{1n}^2 + \frac{2}{\delta-1}}{\frac{2\gamma}{\gamma-1} M_{1n}^2 - 1} \end{equation} ```python M1n = M1 * np.sin(theta) M2n = np.sqrt((M1n**2 + (2/(gamma - 1))) / (M1n**2 * (2*gamma)/(gamma - 1) - 1)) M2 = M2n / np.sin(theta - delta) print(f'M_2 = {M2:.3}') ``` M_2 = 1.85 Now, the reflected oblique shock must turn the flow back to the horizontal direction to satisfy flow tangency with the wall, so $\delta_2 = \delta$. We can thus determine the angle of the second shock, $\theta_2$: ```python def oblique(theta, M1, delta, gamma): return ( np.tan(delta) - 2 * (1 / np.tan(theta)) * (M1**2 * np.sin(theta)**2 - 1) / (M1**2 * (gamma + np.cos(2*theta)) + 2) ) root = optimize.root_scalar(oblique, # function we are solving args=(M2, delta, gamma), # give range for weak shocks bracket=[np.radians(0.0001), np.radians(45.0)] ) theta_2 = root.root print(f'theta_2 = {np.degrees(theta_2):.3} degrees') ``` theta_2 = 41.7 degrees **But** this shock angle is defined with respect to the flow direction in the middle region, so $\beta = \theta_2 - \delta$: ```python beta = theta_2 - delta print(f'beta = {np.degrees(beta):.3} degrees') ``` beta = 32.5 degrees Thus, the angle of reflection $\beta$ is **smaller** than the angle of incidence $\theta = 35^{\circ}$. Regarding the shock strength, we can compare the normal Mach numbers of the flow prior to each shock: ```python print(f'M1n = {M1n:.4}') M3n = M2 * np.sin(theta_2) print(f'M2n = {M3n:.4}') ``` M1n = 1.262 M2n = 1.233 We can see that the second shock occurs at a smaller Mach number, so it is **weaker**.

f43ce2b9dded71a17c27009fd4a2c533689b90f3

ipynb

Jupyter Notebook

oblique_shock.ipynb

kyleniemeyer/gasdynamics

50dce7a030daa2757aa55cf6c9a5ae66d079ab72

2019-10-17T18:21:23.000Z

2021-08-17T19:30:07.000Z

oblique_shock.ipynb

kyleniemeyer/gasdynamics

50dce7a030daa2757aa55cf6c9a5ae66d079ab72

oblique_shock.ipynb

kyleniemeyer/gasdynamics

50dce7a030daa2757aa55cf6c9a5ae66d079ab72

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Week 10 of Introduction to Biological System Design ## Compiling Chemical Reaction Network Models for Biological Systems ### Ayush Pandey Pre-requisite: To get the best out of this notebook, make sure that you have basic understanding of chemical reaction networks and ordinary differential equations (ODE). Further, we also use Hill functions to build models of biological systems. Refer to the [E164 class material](pages.hmc.edu/pandey/) for background on any topics in this notebook. This notebook discusses a Python package called [BioCRNpyler](https://github.com/BuildACell/BioCRNPyler) (pronounced Bio-Compiler) that can be used to compile chemical reaction network models for biological systems. Disclaimer: The content in this notebook is taken from the BioCRNpyler Github examples. Copyright: Build-A-Cell. Package Authors: William Poole, Ayush Pandey, Andrey Shur, Zoltan Tuza, and Richard M. Murray ## Building Chemical Reaction Networks (CRNs) Directly with BioCRNpyler ### What is a CRN? A CRN is a widely established model of chemistry and biochemistry. * A set of species $S$ * A set of reactions $R$ interconvert species $I_r$ to $O_r$ \begin{align} \\ I \xrightarrow[]{\rho(s)} O \\ \end{align} * $I$ and $O$ are multisets of species $S$. * $\rho(s): S \to \mathbb{R}$ is a function that determines how fast the reaction occurs. ```python # Running this notebook for the first time? # Make sure you have biocrnpyler installed in your environment. # To install biocrnpyler uncomment the following and run: # !pip install biocrnpyler ``` ```python #Import everything from biocrnpyler from biocrnpyler import * ``` C:\Users\apand\AppData\Local\Continuum\anaconda3\lib\site-packages\pandas\compat\_optional.py:138: UserWarning: Pandas requires version '2.7.0' or newer of 'numexpr' (version '2.6.9' currently installed). warnings.warn(msg, UserWarning) ## Combining Species and Reactions into a CRN The following code defines a species called 'S' made out of material 'material'. Species can also have attributes to help identify them. Note that Species with the same name, but different materials or attributes are considered different species in terms of the reactions they participate in. S = Species('name', material_type = 'material', attributes = []) The collowing code produces a reaction R R = Reaction(Inputs, Outputs, k) here Inputs and Outputs must both be a list of Species. the parameter k is the rate constant of the reaction. By default, propensities in BioCRNpyler are massaction: ### $\rho(S) = k \Pi_{s} s^{I_s}$ Note: for stochastic models mass action propensities are $\rho(S) = k \Pi_{s} s!/(s - I_s)!$. Massaction reactions can be made reversible with the k_rev keyword: R_reversible = Reaction(Inputs, Outputs, k, k_rev = krev) is the same as two reactions: R = Reaction(Inputs, Outputs, k) Rrev = Reaction(Outputs, Inputs, krev) Finally, a CRN can be made by combining species and reactions: CRN = ChemicalReactionNetwork(species = species, reactions = reactions, initial_condition_dict = {}) Here, initial_condition_dict is an optional dictionary to store the initial values of different species. initial_condition_dict = {Species:value} Species without an initial condition will default to 0. ### An example: ```python #Example: Model the CRN consisting of: A --> 2B, # 2B <--> B + C where C has the same name as B but a new material A = Species("A", material_type = "m1", attributes = ["attribute"]) B = Species("B", material_type = "m1") C = Species("B", material_type = "m2") D = Species("D") print("Species can be printed to show"\ "their string representation:", A, B, C, D) #Reaction Rates k1 = 3. k2 = 1.4 k2rev = 0.15 #Reaciton Objects R1 = Reaction.from_massaction([A], [B, B], k_forward = k1, k_reverse = 0.9) R2 = Reaction.from_massaction([B], [C, D], k_forward = k2) print("\nReactions can be printed as well:\n", R1,"\n", R2) #create an initial condition so A has a non-zero value initial_concentration_dict = {A:10} #Make a CRN CRN = ChemicalReactionNetwork(species = [A, B, C, D], reactions = [R1, R2], initial_concentration_dict = initial_concentration_dict) #CRNs can be printed in two different ways print("\nDirectly printing a CRN shows the string"\ "representation of the species used in BioCRNpyler:") print(CRN) print("\nCRN.pretty_print(...) is a function that prints"\ "a more customizable version of the CRN, but doesn't"\ "show the proper string representation of species.") print(CRN.pretty_print(show_materials = True, show_rates = True, show_attributes = True)) ``` Species can be printed to showtheir string representation: m1_A_attribute m1_B m2_B D Reactions can be printed as well: m1[A(attribute)] <--> 2m1[B] m1[B] --> m2[B]+D Directly printing a CRN shows the stringrepresentation of the species used in BioCRNpyler: Species = m1_A_attribute, m1_B, m2_B, D Reactions = [ m1[A(attribute)] <--> 2m1[B] m1[B] --> m2[B]+D ] CRN.pretty_print(...) is a function that printsa more customizable version of the CRN, but doesn'tshow the proper string representation of species. Species(N = 4) = { m1[A(attribute)] (@ 10), D (@ 0), m2[B] (@ 0), m1[B] (@ 0), } Reactions (2) = [ 0. m1[A(attribute)] <--> 2m1[B] Kf=k_forward * m1_A_attribute Kr=k_reverse * m1_B^2 k_forward=3.0 k_reverse=0.9 1. m1[B] --> m2[B]+D Kf=k_forward * m1_B k_forward=1.4 ] ### CRNs can be saved as SBML and simulated To save a CRN as SBML: CRN.write_sbml_file("file_name.xml") To simulate a CRN with biosrape: Results, Model = CRN_expression.simulate_with_bioscrape(timepoints, initial_condition_dict = x0) Where x0 is a dictionary: x0 = {species_name:initial_value} ```python # To simulate the CRN, install Bioscrape, a Python-based simulator # Uncomment the following line to install Bioscrape # !pip install bioscrape ``` ```python #Saving and simulating a CRN CRN.write_sbml_file("build_crns_directly.xml") try: import bioscrape import numpy as np import pylab as plt import pandas as pd #Initial conditions can be set with a dictionary: x0 = {A:120} #Timepoints to simulate over timepoints = np.linspace(0, 1, 100) #This function can also take a filename keyword to # save the file at the same time R = CRN.simulate_with_bioscrape_via_sbml(timepoints = timepoints, initial_condition_dict = x0) #Check to ensure simulation worked #Results are in a Pandas Dictionary and can be accessed # via string-names of species plt.plot(R['time'], R[str(A)], label = "A") plt.plot(R['time'], R[str(B)], label = "B") plt.plot(R['time'], R[str(C)], "--", label = "C") plt.plot(R['time'], R[str(D)],":", label = "D") plt.xlabel('Time') plt.ylabel('Species') plt.legend() except ModuleNotFoundError: print("Plotting Modules not installed.") ``` ## Hill Functions with BioCRNpyler ### HillPositive: $\rho(s) = k \frac{s_1^n}{K^n+s_1^n}$ Requried parameters: rate constant "k", offset "K", hill coefficient "n", hill species "s1". ```python #create the propensity R = Species("R") hill_pos = HillPositive(k=1, s1=R, K=5, n=2) #create the reaction r_hill_pos = Reaction([A], [B], propensity_type = hill_pos) #print the reaction print(r_hill_pos.pretty_print()) ``` m1[A(attribute)] --> m1[B] Kf = k R^n / ( K^n + R^n ) k=1 K=5 n=2 ### HillNegative: $\rho(s) = k \frac{1}{K^n+s_1^n}$ Requried parameters: rate constant "k", offset "K", hill coefficient "n", hill species "s1". ```python #create the propensity R = Species("R") hill_neg = HillPositive(k=1, s1=R, K=5, n=2) #create the reaction r_hill_neg = Reaction([A], [B], propensity_type = hill_neg) #print the reaction print(r_hill_neg.pretty_print()) ``` m1[A(attribute)] --> m1[B] Kf = k R^n / ( K^n + R^n ) k=1 K=5 n=2 ### ProportionalHillPositive: $\rho(s, d) = k d \frac{s_1^n}{K^n + s_1^n}$ Requried parameters: rate constant "k", offset "K", hill coefficient "n", hill species "s1", proportional species "d" ```python #create the propensity R = Species("R") D = Species("D") prop_hill_pos = ProportionalHillPositive(k=1, s1=R, K=5, n=2, d = D) #create the reaction r_prop_hill_pos = Reaction([A], [B], propensity_type = prop_hill_pos) #print the reaction print(r_prop_hill_pos.pretty_print()) ``` m1[A(attribute)] --> m1[B] Kf = k D R^n / ( K^n + R^n ) k=1 K=5 n=2 ### ProportionalHillNegative: $\rho(s, d) = k d \frac{1}{K^n + s_1^n}$ Requried parameters: rate constant "k", offset "K", hill coefficient "n", hill species "s1", proportional species "d" ```python #create the propensity R = Species("R") D = Species("D") prop_hill_neg = ProportionalHillNegative(k=1, s1=R, K=5, n=2, d = D) #create the reaction r_prop_hill_neg = Reaction([A], [B], propensity_type = prop_hill_neg) #print the reaction print(r_prop_hill_neg.pretty_print()) ``` m1[A(attribute)] --> m1[B] Kf = k D / ( 1 + (R/K)^2 ) k=1 K=5 n=2 ### General Propensity: $\rho(s) = $ function of your choice For general propensities, the function must be written out as a string with all species and parameters declared. ```python #create species # create some parameters - note that parameters will be discussed in the next lecture k1 = ParameterEntry("k1", 1.11) k2 = ParameterEntry("k2", 2.22) S = Species("S") #type the string as a rate then declare teh species and parameters general = GeneralPropensity(f'k1*2 - k2/{S}^2', propensity_species=[S], propensity_parameters=[k1, k2]) r_general = Reaction([A, B], [], propensity_type = general) print(r_general.pretty_print()) ``` m1[A(attribute)]+m1[B] --> k1*2 - k2/S^2 k1=1.11 k2=2.22 ## Next week: ### 1. Compiling CRNs with Enzymes Catalysis and Binding ### 2. DNA Assemblies gene expression transcription and translation ### 3. Promoters Transcriptional Regulation and Gene Regulatory Networks ### 4. Simulating and Analyzing SBML models

8efdca74ef0870d08f6de6dfcbc58c5707093197

ipynb

Jupyter Notebook

reading/week10_compiling_crn_models.ipynb

BioSysDesign/E164

69f6236de2d8172e541a5b56f7807d4767f20979

reading/week10_compiling_crn_models.ipynb

BioSysDesign/E164

69f6236de2d8172e541a5b56f7807d4767f20979

reading/week10_compiling_crn_models.ipynb

BioSysDesign/E164

69f6236de2d8172e541a5b56f7807d4767f20979

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, C.D. Cooper, G.F. Forsyth. # Riding the wave ## Numerical schemes for hyperbolic PDEs Welcome back! This is the second notebook of *Riding the wave: Convection problems*, the third module of ["Practical Numerical Methods with Python"](https://openedx.seas.gwu.edu/courses/course-v1:MAE+MAE6286+2017/about). The first notebook of this module discussed conservation laws and developed the non-linear traffic equation. We learned about the effect of the wave speed on the stability of the numerical method, and on the CFL number. We also realized that the forward-time/backward-space difference scheme really has many limitations: it cannot deal with wave speeds that move in more than one direction. It is also first-order accurate in space and time, which often is just not good enough. This notebook will introduce some new numerical schemes for conservation laws, continuing with the traffic-flow problem as motivation. ## Red light! Let's explore the behavior of different numerical schemes for a moving shock wave. In the context of the traffic-flow model of the previous notebook, imagine a very busy road and a red light at $x=4$. Cars accumulate quickly in the front, where we have the maximum allowed density of cars between $x=3$ and $x=4$, and there is an incoming traffic of 50% the maximum allowed density $(\rho = 0.5\rho_{\rm max})$. Mathematically, this is: $$ \begin{equation} \rho(x,0) = \left\{ \begin{array}{cc} 0.5 \rho_{\rm max} & 0 \leq x < 3 \\ \rho_{\rm max} & 3 \leq x \leq 4 \\ \end{array} \right. \end{equation} $$ Let's find out what the initial condition looks like. ```python import numpy from matplotlib import pyplot %matplotlib inline ``` ```python # Set the font family and size to use for Matplotlib figures. pyplot.rcParams['font.family'] = 'serif' pyplot.rcParams['font.size'] = 16 ``` ```python def rho_red_light(x, rho_max): """ Computes the "red light" initial condition with shock. Parameters ---------- x : numpy.ndaray Locations on the road as a 1D array of floats. rho_max : float The maximum traffic density allowed. Returns ------- rho : numpy.ndarray The initial car density along the road as a 1D array of floats. """ rho = rho_max * numpy.ones_like(x) mask = numpy.where(x < 3.0) rho[mask] = 0.5 * rho_max return rho ``` ```python # Set parameters. nx = 81 # number of locations on the road L = 4.0 # length of the road dx = L / (nx - 1) # distance between two consecutive locations nt = 40 # number of time steps to compute rho_max = 10.0 # maximum taffic density allowed u_max = 1.0 # maximum speed traffic # Get the road locations. x = numpy.linspace(0.0, L, num=nx) # Compute the initial traffic density. rho0 = rho_red_light(x, rho_max) ``` ```python # Plot the initial traffic density. fig = pyplot.figure(figsize=(6.0, 4.0)) pyplot.xlabel(r'$x$') pyplot.ylabel(r'$\rho$') pyplot.grid() line = pyplot.plot(x, rho0, color='C0', linestyle='-', linewidth=2)[0] pyplot.xlim(0.0, L) pyplot.ylim(4.0, 11.0) pyplot.tight_layout() ``` The question we would like to answer is: **How will cars accumulate at the red light?** We will solve this problem using different numerical schemes, to see how they perform. These schemes are: * Lax-Friedrichs * Lax-Wendroff * MacCormack Before we do any coding, let's think about the equation a little bit. The wave speed $u_{\rm wave}$ is $-1$ for $\rho = \rho_{\rm max}$ and $\rho \leq \rho_{\rm max}/2$, making all velocities negative. We should see a solution moving left, maintaining the shock geometry. #### Figure 1. The exact solution is a shock wave moving left. Now to some coding! First, let's define some useful functions and prepare to make some nice animations later. ```python def flux(rho, u_max, rho_max): """ Computes the traffic flux F = V * rho. Parameters ---------- rho : numpy.ndarray Traffic density along the road as a 1D array of floats. u_max : float Maximum speed allowed on the road. rho_max : float Maximum car density allowed on the road. Returns ------- F : numpy.ndarray The traffic flux along the road as a 1D array of floats. """ F = rho * u_max * (1.0 - rho / rho_max) return F ``` Before we investigate different schemes, let's create the function to update the Matplotlib figure during the animation. ```python from matplotlib import animation from IPython.display import HTML ``` ```python def update_plot(n, rho_hist): """ Update the line y-data of the Matplotlib figure. Parameters ---------- n : integer The time-step index. rho_hist : list of numpy.ndarray objects The history of the numerical solution. """ fig.suptitle('Time step {:0>2}'.format(n)) line.set_ydata(rho_hist[n]) ``` ## Lax-Friedrichs scheme Recall the conservation law for vehicle traffic, resulting in the following equation for the traffic density: $$ \begin{equation} \frac{\partial \rho}{\partial t} + \frac{\partial F}{\partial x} = 0 \end{equation} $$ $F$ is the *traffic flux*, which in the linear traffic-speed model is given by: $$ \begin{equation} F = \rho u_{\rm max} \left(1-\frac{\rho}{\rho_{\rm max}}\right) \end{equation} $$ In the time variable, the natural choice for discretization is always a forward-difference formula; time invariably moves forward! $$ \begin{equation} \frac{\partial \rho}{\partial t}\approx \frac{1}{\Delta t}( \rho_i^{n+1}-\rho_i^n ) \end{equation} $$ As is usual, the discrete locations on the 1D spatial grid are denoted by indices $i$ and the discrete time instants are denoted by indices $n$. In a convection problem, using first-order discretization in space leads to excessive numerical diffusion (as you probably observed in [Lesson 1 of Module 2](https://nbviewer.jupyter.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/02_spacetime/02_01_1DConvection.ipynb)). The simplest approach to get second-order accuracy in space is to use a central difference: $$ \begin{equation} \frac{\partial F}{\partial x} \approx \frac{1}{2\Delta x}( F_{i+1}-F_{i-1}) \end{equation} $$ But combining these two choices for time and space discretization in the convection equation has catastrophic results! The "forward-time, central scheme" (FTCS) is **unstable**. (Go on: try it; you know you want to!) The Lax-Friedrichs scheme was proposed by Lax (1954) as a clever trick to stabilize the forward-time, central scheme. The idea was to replace the solution value at $\rho^n_i$ by the average of the values at the neighboring grid points. If we do that replacement, we get the following discretized equation: $$ \begin{equation} \frac{\rho_i^{n+1}-\frac{1}{2}(\rho^n_{i+1}+\rho^n_{i-1})}{\Delta t} = -\frac{F^n_{i+1}-F^n_{i-1}}{2 \Delta x} \end{equation} $$ Take a careful look: the difference formula no longer uses the value at $\rho^n_i$ to obtain $\rho^{n+1}_i$. The stencil of the Lax-Friedrichs scheme is slightly different than that for the forward-time, central scheme. #### Figure 2. Stencil of the forward-time/central scheme. #### Figure 3. Stencil of the Lax-Friedrichs scheme. This numerical discretization is **stable**. Unfortunately, substituting $\rho^n_i$ by the average of its neighbors introduces a first-order error. _Nice try, Lax!_ To implement the scheme in code, we need to isolate the value at the next time step, $\rho^{n+1}_i$, so we can write a time-stepping loop: $$ \begin{equation} \rho_i^{n+1} = \frac{1}{2}(\rho^n_{i+1}+\rho^n_{i-1}) - \frac{\Delta t}{2 \Delta x}(F^n_{i+1}-F^n_{i-1}) \end{equation} $$ The function below implements Lax-Friedrichs for our traffic model. All the schemes in this notebook are wrapped in their own functions to help with displaying animations of the results. This is also good practice for developing modular, reusable code. In order to display animations, we're going to hold the results of each time step in the variable `rho`, a 2D array. The resulting array `rho_n` has `nt` rows and `nx` columns. ```python def lax_friedrichs(rho0, nt, dt, dx, bc_values, *args): """ Computes the traffic density on the road at a certain time given the initial traffic density. Integration using Lax-Friedrichs scheme. Parameters ---------- rho0 : numpy.ndarray The initial traffic density along the road as a 1D array of floats. nt : integer The number of time steps to compute. dt : float The time-step size to integrate. dx : float The distance between two consecutive locations. bc_values : 2-tuple of floats The value of the density at the first and last locations. args : list or tuple Positional arguments to be passed to the flux function. Returns ------- rho_hist : list of numpy.ndarray objects The history of the car density along the road. """ rho_hist = [rho0.copy()] rho = rho0.copy() for n in range(nt): # Compute the flux. F = flux(rho, *args) # Advance in time using Lax-Friedrichs scheme. rho[1:-1] = (0.5 * (rho[:-2] + rho[2:]) - dt / (2.0 * dx) * (F[2:] - F[:-2])) # Set the value at the first location. rho[0] = bc_values[0] # Set the value at the last location. rho[-1] = bc_values[1] # Record the time-step solution. rho_hist.append(rho.copy()) return rho_hist ``` ### Lax-Friedrichs with $\frac{\Delta t}{\Delta x}=1$ We are now all set to run! First, let's try with CFL=1 ```python # Set the time-step size based on CFL limit. sigma = 1.0 dt = sigma * dx / u_max # time-step size # Compute the traffic density at all time steps. rho_hist = lax_friedrichs(rho0, nt, dt, dx, (rho0[0], rho0[-1]), u_max, rho_max) ``` ```python # Create an animation of the traffic density. anim = animation.FuncAnimation(fig, update_plot, frames=nt, fargs=(rho_hist,), interval=100) # Display the video. HTML(anim.to_html5_video()) ``` ##### Think * What do you see in the animation above? How does the numerical solution compare with the exact solution (a left-traveling shock wave)? * What types of errors do you think we see? * What do you think of the Lax-Friedrichs scheme, so far? ### Lax-Friedrichs with $\frac{\Delta t}{\Delta x} = 0.5$ Would the solution improve if we use smaller time steps? Let's check that! ```python # Set the time-step size based on CFL limit. sigma = 0.5 dt = sigma * dx / u_max # time-step size # Compute the traffic density at all time steps. rho_hist = lax_friedrichs(rho0, nt, dt, dx, (rho0[0], rho0[-1]), u_max, rho_max) ``` ```python # Create an animation of the traffic density. anim = animation.FuncAnimation(fig, update_plot, frames=nt, fargs=(rho_hist,), interval=100) # Display the video. HTML(anim.to_html5_video()) ``` ##### Dig deeper Notice the strange "staircase" behavior on the leading edge of the wave? You may be interested to learn more about this: a feature typical of what is sometimes called "odd-even decoupling." Last year we published a collection of lessons in Computational Fluid Dynamics, called _CFD Python_, where we discuss [odd-even decoupling](https://nbviewer.jupyter.org/github/barbagroup/CFDPython/blob/14b56718ac1508671de66bab3fe432e93cb59fcb/lessons/19_Odd_Even_Decoupling.ipynb). * How does this solution compare with the previous one, where the Courant number was $\frac{\Delta t}{\Delta x}=1$? ## Lax-Wendroff scheme The Lax-Friedrichs method uses a clever trick to stabilize the central difference in space for convection, but loses an order of accuracy in doing so. First-order methods are just not good enough for convection problems, especially when you have sharp gradients (shocks). The Lax-Wendroff (1960) method was the _first_ scheme ever to achieve second-order accuracy in both space and time. It is therefore a landmark in the history of computational fluid dynamics. To develop the Lax-Wendroff scheme, we need to do a bit of work. Sit down, grab a notebook and grit your teeth. We want you to follow this derivation in your own hand. It's good for you! Start with the Taylor series expansion (in the time variable) about $\rho^{n+1}$: $$ \begin{equation} \rho^{n+1} = \rho^n + \frac{\partial\rho^n}{\partial t} \Delta t + \frac{(\Delta t)^2}{2}\frac{\partial^2\rho^n}{\partial t^2} + \ldots \end{equation} $$ For the conservation law with $F=F(\rho)$, and using our beloved chain rule, we can write: $$ \begin{equation} \frac{\partial \rho}{\partial t} = -\frac{\partial F}{\partial x} = -\frac{\partial F}{\partial \rho} \frac{\partial \rho}{\partial x} = -J \frac{\partial \rho}{\partial x} \end{equation} $$ where $$ \begin{equation} J = \frac{\partial F}{\partial \rho} = u _{\rm max} \left(1-2\frac{\rho}{\rho_{\rm max}} \right) \end{equation} $$ is the _Jacobian_ for the traffic model. Next, we can do a little trickery: $$ \begin{equation} \frac{\partial F}{\partial t} = \frac{\partial F}{\partial \rho} \frac{\partial \rho}{\partial t} = J \frac{\partial \rho}{\partial t} = -J \frac{\partial F}{\partial x} \end{equation} $$ In the last step above, we used the differential equation of the traffic model to replace the time derivative by a spatial derivative. These equivalences imply that $$ \begin{equation} \frac{\partial^2\rho}{\partial t^2} = \frac{\partial}{\partial x} \left( J \frac{\partial F}{\partial x} \right) \end{equation} $$ Let's use all this in the Taylor expansion: $$ \begin{equation} \rho^{n+1} = \rho^n - \frac{\partial F^n}{\partial x} \Delta t + \frac{(\Delta t)^2}{2} \frac{\partial}{\partial x} \left(J\frac{\partial F^n}{\partial x} \right)+ \ldots \end{equation} $$ We can now reorganize this and discretize the spatial derivatives with central differences to get the following discrete equation: $$ \begin{equation} \frac{\rho_i^{n+1} - \rho_i^n}{\Delta t} = -\frac{F^n_{i+1}-F^n_{i-1}}{2 \Delta x} + \frac{\Delta t}{2} \left(\frac{(J \frac{\partial F}{\partial x})^n_{i+\frac{1}{2}}-(J \frac{\partial F}{\partial x})^n_{i-\frac{1}{2}}}{\Delta x}\right) \end{equation} $$ Now, approximate the rightmost term (inside the parenthesis) in the above equation as follows: \begin{equation} \frac{J^n_{i+\frac{1}{2}}\left(\frac{F^n_{i+1}-F^n_{i}}{\Delta x}\right)-J^n_{i-\frac{1}{2}}\left(\frac{F^n_i-F^n_{i-1}}{\Delta x}\right)}{\Delta x}\end{equation} Then evaluate the Jacobian at the midpoints by using averages of the points on either side: \begin{equation}\frac{\frac{1}{2 \Delta x}(J^n_{i+1}+J^n_i)(F^n_{i+1}-F^n_i)-\frac{1}{2 \Delta x}(J^n_i+J^n_{i-1})(F^n_i-F^n_{i-1})}{\Delta x}.\end{equation} Our equation now reads: \begin{align} &\frac{\rho_i^{n+1} - \rho_i^n}{\Delta t} = -\frac{F^n_{i+1}-F^n_{i-1}}{2 \Delta x} + \cdots \\ \nonumber &+ \frac{\Delta t}{4 \Delta x^2} \left( (J^n_{i+1}+J^n_i)(F^n_{i+1}-F^n_i)-(J^n_i+J^n_{i-1})(F^n_i-F^n_{i-1})\right) \end{align} Solving for $\rho_i^{n+1}$: \begin{align} &\rho_i^{n+1} = \rho_i^n - \frac{\Delta t}{2 \Delta x} \left(F^n_{i+1}-F^n_{i-1}\right) + \cdots \\ \nonumber &+ \frac{(\Delta t)^2}{4(\Delta x)^2} \left[ (J^n_{i+1}+J^n_i)(F^n_{i+1}-F^n_i)-(J^n_i+J^n_{i-1})(F^n_i-F^n_{i-1})\right] \end{align} with \begin{equation}J^n_i = \frac{\partial F}{\partial \rho} = u_{\rm max} \left(1-2\frac{\rho^n_i}{\rho_{\rm max}} \right).\end{equation} Lax-Wendroff is a little bit long. Remember that you can use \ slashes to split up a statement across several lines. This can help make code easier to parse (and also easier to debug!). ```python def jacobian(rho, u_max, rho_max): """ Computes the Jacobian for our traffic model. Parameters ---------- rho : numpy.ndarray Traffic density along the road as a 1D array of floats. u_max : float Maximum speed allowed on the road. rho_max : float Maximum car density allowed on the road. Returns ------- J : numpy.ndarray The Jacobian as a 1D array of floats. """ J = u_max * (1.0 - 2.0 * rho / rho_max) return J ``` ```python def lax_wendroff(rho0, nt, dt, dx, bc_values, *args): """ Computes the traffic density on the road at a certain time given the initial traffic density. Integration using Lax-Wendroff scheme. Parameters ---------- rho0 : numpy.ndarray The initial traffic density along the road as a 1D array of floats. nt : integer The number of time steps to compute. dt : float The time-step size to integrate. dx : float The distance between two consecutive locations. bc_values : 2-tuple of floats The value of the density at the first and last locations. args : list or tuple Positional arguments to be passed to the flux and Jacobien functions. Returns ------- rho_hist : list of numpy.ndarray objects The history of the car density along the road. """ rho_hist = [rho0.copy()] rho = rho0.copy() for n in range(nt): # Compute the flux. F = flux(rho, *args) # Compute the Jacobian. J = jacobian(rho, *args) # Advance in time using Lax-Wendroff scheme. rho[1:-1] = (rho[1:-1] - dt / (2.0 * dx) * (F[2:] - F[:-2]) + dt**2 / (4.0 * dx**2) * ((J[1:-1] + J[2:]) * (F[2:] - F[1:-1]) - (J[:-2] + J[1:-1]) * (F[1:-1] - F[:-2]))) # Set the value at the first location. rho[0] = bc_values[0] # Set the value at the last location. rho[-1] = bc_values[1] # Record the time-step solution. rho_hist.append(rho.copy()) return rho_hist ``` Now that's we've defined a function for the Lax-Wendroff scheme, we can use the same procedure as above to animate and view our results. ### Lax-Wendroff with $\frac{\Delta t}{\Delta x}=1$ ```python # Set the time-step size based on CFL limit. sigma = 1.0 dt = sigma * dx / u_max # time-step size # Compute the traffic density at all time steps. rho_hist = lax_wendroff(rho0, nt, dt, dx, (rho0[0], rho0[-1]), u_max, rho_max) ``` ```python # Create an animation of the traffic density. anim = animation.FuncAnimation(fig, update_plot, frames=nt, fargs=(rho_hist,), interval=100) # Display the video. HTML(anim.to_html5_video()) ``` Interesting! The Lax-Wendroff method captures the sharpness of the shock much better than the Lax-Friedrichs scheme, but there is a new problem: a strange wiggle appears right at the tail of the shock. This is typical of many second-order methods: they introduce _numerical oscillations_ where the solution is not smooth. Bummer. ### Lax-Wendroff with $\frac{\Delta t}{\Delta x} =0.5$ How do the oscillations at the shock front vary with changes to the CFL condition? You might think that the solution will improve if you make the time step smaller ... let's see. ```python # Set the time-step size based on CFL limit. sigma = 0.5 dt = sigma * dx / u_max # time-step size # Compute the traffic density at all time steps. rho_hist = lax_wendroff(rho0, nt, dt, dx, (rho0[0], rho0[-1]), u_max, rho_max) ``` ```python # Create an animation of the traffic density. anim = animation.FuncAnimation(fig, update_plot, frames=nt, fargs=(rho_hist,), interval=100) # Display the video. HTML(anim.to_html5_video()) ``` Eek! The numerical oscillations got worse. Double bummer! Why do we observe oscillations with second-order methods? This is a question of fundamental importance! ## MacCormack Scheme The numerical oscillations that you observed with the Lax-Wendroff method on the traffic model can become severe in some problems. But actually the main drawback of the Lax-Wendroff method is having to calculate the Jacobian in every time step. With more complicated equations (like the Euler equations), calculating the Jacobian is a large computational expense. Robert W. MacCormack introduced the first version of his now-famous method at the 1969 AIAA Hypervelocity Impact Conference, held in Cincinnati, Ohio, but the paper did not at first catch the attention of the aeronautics community. The next year, however, he presented at the 2nd International Conference on Numerical Methods in Fluid Dynamics at Berkeley. His paper there (MacCormack, 1971) was a landslide. MacCormack got a promotion and continued to work on applications of his method to the compressible Navier-Stokes equations. In 1973, NASA gave him the prestigious H. Julian Allen award for his work. The MacCormack scheme is a two-step method, in which the first step is called a _predictor_ and the second step is called a _corrector_. It achieves second-order accuracy in both space and time. One version is as follows: $$ \begin{equation} \rho^*_i = \rho^n_i - \frac{\Delta t}{\Delta x} (F^n_{i+1}-F^n_{i}) \ \ \ \ \ \ \text{(predictor)} \end{equation} $$ $$ \begin{equation} \rho^{n+1}_i = \frac{1}{2} (\rho^n_i + \rho^*_i - \frac{\Delta t}{\Delta x} (F^*_i - F^{*}_{i-1})) \ \ \ \ \ \ \text{(corrector)} \end{equation} $$ If you look closely, it appears like the first step is a forward-time/forward-space scheme, and the second step is like a forward-time/backward-space scheme (these can also be reversed), averaged with the first result. What is so cool about this? You can compute problems with left-running waves and right-running waves, and the MacCormack scheme gives you a stable method (subject to the CFL condition). Nice! Let's try it. ```python def maccormack(rho0, nt, dt, dx, bc_values, *args): """ Computes the traffic density on the road at a certain time given the initial traffic density. Integration using MacCormack scheme. Parameters ---------- rho0 : numpy.ndarray The initial traffic density along the road as a 1D array of floats. nt : integer The number of time steps to compute. dt : float The time-step size to integrate. dx : float The distance between two consecutive locations. bc_values : 2-tuple of floats The value of the density at the first and last locations. args : list or tuple Positional arguments to be passed to the flux function. Returns ------- rho_hist : list of numpy.ndarray objects The history of the car density along the road. """ rho_hist = [rho0.copy()] rho = rho0.copy() rho_star = rho.copy() for n in range(nt): # Compute the flux. F = flux(rho, *args) # Predictor step of the MacCormack scheme. rho_star[1:-1] = (rho[1:-1] - dt / dx * (F[2:] - F[1:-1])) # Compute the flux. F = flux(rho_star, *args) # Corrector step of the MacCormack scheme. rho[1:-1] = 0.5 * (rho[1:-1] + rho_star[1:-1] - dt / dx * (F[1:-1] - F[:-2])) # Set the value at the first location. rho[0] = bc_values[0] # Set the value at the last location. rho[-1] = bc_values[1] # Record the time-step solution. rho_hist.append(rho.copy()) return rho_hist ``` ### MacCormack with $\frac{\Delta t}{\Delta x} = 1$ ```python # Set the time-step size based on CFL limit. sigma = 1.0 dt = sigma * dx / u_max # time-step size # Compute the traffic density at all time steps. rho_hist = maccormack(rho0, nt, dt, dx, (rho0[0], rho0[-1]), u_max, rho_max) ``` ```python # Create an animation of the traffic density. anim = animation.FuncAnimation(fig, update_plot, frames=nt, fargs=(rho_hist,), interval=100) # Display the video. HTML(anim.to_html5_video()) ``` ### MacCormack with $\frac{\Delta t}{\Delta x}= 0.5$ Once again, we ask: how does the CFL number affect the errors? Which one gives better results? You just have to try it. ```python # Set the time-step size based on CFL limit. sigma = 0.5 dt = sigma * dx / u_max # time-step size # Compute the traffic density at all time steps. rho_hist = maccormack(rho0, nt, dt, dx, (rho0[0], rho0[-1]), u_max, rho_max) ``` ```python # Create an animation of the traffic density. anim = animation.FuncAnimation(fig, update_plot, frames=nt, fargs=(rho_hist,), interval=100) # Display the video. HTML(anim.to_html5_video()) ``` ##### Dig Deeper You can also obtain a MacCormack scheme by reversing the predictor and corrector steps. For shocks, the best resolution will occur when the difference in the predictor step is in the direction of propagation. Try it out! Was our choice here the ideal one? In which case is the shock better resolved? ##### Challenge task In the *red light* problem, $\rho \geq \rho_{\rm max}/2$, making the wave speed negative at all points . You might be wondering why we introduced these new methods; couldn't we have just used a forward-time/forward-space scheme? But, what if $\rho_{\rm in} < \rho_{\rm max}/2$? Now, a whole region has negative wave speeds and forward-time/backward-space is unstable. * How do Lax-Friedrichs, Lax-Wendroff and MacCormack behave in this case? Try it out! * As you decrease $\rho_{\rm in}$, what happens to the velocity of the shock? Why do you think that happens? ## References * Peter D. Lax (1954), "Weak solutions of nonlinear hyperbolic equations and their numerical computation," _Commun. Pure and Appl. Math._, Vol. 7, pp. 159–193. * Peter D. Lax and Burton Wendroff (1960), "Systems of conservation laws," _Commun. Pure and Appl. Math._, Vol. 13, pp. 217–237. * R. W. MacCormack (1969), "The effect of viscosity in hypervelocity impact cratering," AIAA paper 69-354. Reprinted on _Journal of Spacecraft and Rockets_, Vol. 40, pp. 757–763 (2003). Also on _Frontiers of Computational Fluid Dynamics_, edited by D. A. Caughey, M. M. Hafez (2002), chapter 2: [read on Google Books](http://books.google.com/books?id=QBsnMOz_8qcC&lpg=PA27&ots=uqCeuH1U6S&lr&pg=PA27#v=onepage&q&f=false). * R. W. MacCormack (1971), "Numerical solution of the interaction of a shock wave with a laminar boundary layer," _Proceedings of the 2nd Int. Conf. on Numerical Methods in Fluid Dynamics_, Lecture Notes in Physics, Vol. 8, Springer, Berlin, pp. 151–163. --- ###### The cell below loads the style of the notebook. ```python from IPython.core.display import HTML css_file = '../../styles/numericalmoocstyle.css' HTML(open(css_file, 'r').read()) ``` <link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'> <link href='http://fonts.googleapis.com/css?family=Arvo:400,700,400italic' rel='stylesheet' type='text/css'> <link href='http://fonts.googleapis.com/css?family=PT+Mono' rel='stylesheet' type='text/css'> <link href='http://fonts.googleapis.com/css?family=Shadows+Into+Light' rel='stylesheet' type='text/css'> <link href='http://fonts.googleapis.com/css?family=Nixie+One' rel='stylesheet' type='text/css'> <link href='https://fonts.googleapis.com/css?family=Source+Code+Pro' rel='stylesheet' type='text/css'> <style> @font-face { font-family: "Computer Modern"; src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf'); } #notebook_panel { /* main background */ background: rgb(245,245,245); } div.cell { /* set cell width */ width: 750px; } div #notebook { /* centre the content */ background: #fff; /* white background for content */ width: 1000px; margin: auto; padding-left: 0em; } #notebook li { /* More space between bullet points */ margin-top:0.8em; } /* draw border around running cells */ div.cell.border-box-sizing.code_cell.running { border: 1px solid #111; } /* Put a solid color box around each cell and its output, visually linking them*/ div.cell.code_cell { background-color: rgb(256,256,256); border-radius: 0px; padding: 0.5em; margin-left:1em; margin-top: 1em; } div.text_cell_render{ font-family: 'Alegreya Sans' sans-serif; line-height: 140%; font-size: 125%; font-weight: 400; width:600px; margin-left:auto; margin-right:auto; } /* Formatting for header cells */ .text_cell_render h1 { font-family: 'Nixie One', serif; font-style:regular; font-weight: 400; font-size: 45pt; line-height: 100%; color: rgb(0,51,102); margin-bottom: 0.5em; margin-top: 0.5em; display: block; } .text_cell_render h2 { font-family: 'Nixie One', serif; font-weight: 400; font-size: 30pt; line-height: 100%; color: rgb(0,51,102); margin-bottom: 0.1em; margin-top: 0.3em; display: block; } .text_cell_render h3 { font-family: 'Nixie One', serif; margin-top:16px; font-size: 22pt; font-weight: 600; margin-bottom: 3px; font-style: regular; color: rgb(102,102,0); } .text_cell_render h4 { /*Use this for captions*/ font-family: 'Nixie One', serif; font-size: 14pt; text-align: center; margin-top: 0em; margin-bottom: 2em; font-style: regular; } .text_cell_render h5 { /*Use this for small titles*/ font-family: 'Nixie One', sans-serif; font-weight: 400; font-size: 16pt; color: rgb(163,0,0); font-style: italic; margin-bottom: .1em; margin-top: 0.8em; display: block; } .text_cell_render h6 { /*use this for copyright note*/ font-family: 'PT Mono', sans-serif; font-weight: 300; font-size: 9pt; line-height: 100%; color: grey; margin-bottom: 1px; margin-top: 1px; } .CodeMirror{ font-family: "Source Code Pro"; font-size: 90%; } .alert-box { padding:10px 10px 10px 36px; margin:5px; } .success { color:#666600; background:rgb(240,242,229); } </style>

a54310ae786ab6c5c8c9a4e7404d9e6a23efc791

ipynb

Jupyter Notebook

lessons/03_wave/03_02_convectionSchemes.ipynb

Fluidentity/numerical-mooc

083bbe9dc923b0ada6db2ebfbe13392fb66c6fbc

lessons/03_wave/03_02_convectionSchemes.ipynb

Fluidentity/numerical-mooc

083bbe9dc923b0ada6db2ebfbe13392fb66c6fbc

lessons/03_wave/03_02_convectionSchemes.ipynb

Fluidentity/numerical-mooc

083bbe9dc923b0ada6db2ebfbe13392fb66c6fbc

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# The One-Dimensional Particle in a Box ## &#x1f945; Learning Objectives - Determine the energies and eigenfunctions of the particle-in-a-box. - Learn how to normalize a wavefunction. - Learn how to compute expectation values for quantum-mechanical operators. - Learn the postulates of quantum mechanics ## Cyanine Dyes Cyanine dye molecules are often modelled as one-dimension particles in a box. To understand why, start by thinking classically. You learn in organic chemistry that electrons can more “freely” along alternating double bonds. If this is true, then you can imagine that the electrons can more from one Nitrogen to the other, almost without resistance. On the other hand, there are sp³-hybridized functional groups attached to the Nitrogen atom, so once the electron gets to Nitrogen atom, it has to turn around and go back whence it came. A very, very, very simple model would be to imagine that the electron is totally free between the Nitrogen atoms, and totally forbidden from going much beyond the Nitrogen atoms. This suggests modeling these systems a potential energy function like: $$ V(x) = \begin{cases} +\infty & x\leq 0\\ 0 & 0\lt x \lt a\\ +\infty & a \leq x \end{cases} $$ where $a$ is the length of the box. A reasonable approximate formula for $a$ is $$ a = \left(5.67 + 2.49 (k + 1)\right) \cdot 10^{-10} \text{ m} $$ ## Postulate: The squared magnitude of the wavefunction is proportional to probability What is the interpretation of the wavefunction? The Born postulate indicates that the squared magnitude of the wavefunction is proportional to the probability of observing the system at that location. E.g., if $\psi(x)$ is the wavefunction for an electron as a function of $x$, then $$ p(x) = |\psi(x)|^2 $$ is the probability of observing an electron at the point $x$. This is called the Born Postulate. ## The Wavefunctions of the Particle in a Box (boundary conditions) The nice thing about this “particle in a box” model is that it is easy to solve the time-independent Schrödinger equation in this case. Because there is no chance that the particle could ever “escape” an infinite box like this (such an electron would have infinite potential energy!), $|\psi(x)|^2$ must equal zero outside the box. Therefore the wavefunction can only be nonzero inside the box. In addition, the wavefunction should be zero at the edges of the box, because otherwise the wavefunction will not be continuous. So we should have a wavefunction like $$ \psi(x) = \begin{cases} 0& x\le 0\\ \text{?????} & 0 < x < a\\ 0 & a \le x \end{cases} $$ ## Postulate: The wavefunction of a system is determined by solving the Schr&ouml;dinger equation How do we find the wavefunction for the particle-in-a-box or, for that matter, any other system? The wavefunction can be determined by solving the time-independent (when the potential is time-independent) or time-dependent (when the potential is time-dependent) Schr&ouml;dinger equation. ## The Wavefunctions of the Particle in a Box (solution) To find the wavefunctions for a system, one solves the Schr&ouml;dinger equation. For a particle of mass $m$ in a one-dimensional box, the (time-independent) Schr&ouml;dinger equation is: $$ \left(-\frac{\hbar^2}{2m} \frac{d^2}{dx^2} + V(x) \right)\psi_n(x) = E_n \psi_n(x) $$ where $$ V(x) = \begin{cases} +\infty & x\leq 0\\ 0 & 0\lt x \lt a\\ +\infty & a \leq x \end{cases} $$ We already deduced that $\psi(x) = 0$ except when the electron is inside the box ($0 < x < a$), so we only need to consider the Schr&ouml;dinger equation inside the box: $$ \left(-\frac{\hbar^2}{2m} \frac{d^2}{dx^2} \right)\psi_n(x) = E_n \psi_n(x) $$ There are systematic ways to solve this equation, but let's solve it by inspection. That is, we need to know: > Question: What function(s), when differentiated twice, are proportional to themselves? This suggests that the eigenfunctions of the 1-dimensional particle-in-a-box must be some linear combination of sine and cosine functions, $$ \psi_n(x) = A \sin(cx) + B \cos(dx) $$ We know that the wavefunction must be zero at the edges of the box, $\psi(0) = 0$ and $\psi(a) = 0$. These are called the *boundary conditions* for the problem. Examining the first boundary condition, $$ 0 = \psi(0) = A \sin(0) + B \cos(0) = 0 + B $$ indicates that $B=0$. The second boundary condition $$ 0 = \psi(a) = A \sin(ca) $$ requires us to recall that $\sin(x) = 0$ whenever $x$ is an integer multiple of $\pi$. So $c=n\pi$ where $n=1,2,3,\ldots$. The wavefunction for the particle in a box is thus, $$ \psi_n(x) = A_n \sin\left(\tfrac{n \pi x}{a}\right) \qquad \qquad n=1,2,3,\ldots $$ ## Normalization of Wavefunctions As seen in the previous section, if a wavefunction solves the Schr&ouml;dinger equation, any constant multiple of the wavefunction also solves the Schr&ouml;dinger equation, $$ \hat{H} \psi(x) = E \psi(x) \quad \longleftrightarrow \quad \hat{H} \left(A\psi(x)\right) = E \left(A\psi(x)\right) $$ Owing to the Born postulate, the complex square of the wavefunction can be interpreted as probability. Since the probability of a particle being at *some* point in space is one, we can define the normalization constant, $A$, for the wavefunction through the requirement that: $$ \int_{-\infty}^{\infty} \left|\psi(x)\right|^2 dx = 1. $$ In the case of a particle in a box, this is: $$ \begin{align} 1 &= \int_{-\infty}^{\infty} \left|\psi_n(x)\right|^2 dx \\ &= \int_0^a \psi_n(x) \psi_n^*(x) dx \\ &= \int_0^a A_n \sin\left(\tfrac{n \pi x}{a}\right) \left(A_n \sin\left(\tfrac{n \pi x}{a}\right) \right)^* dx \\ &= \left|A_n\right|^2\int_0^a \sin^2\left(\tfrac{n \pi x}{a}\right) dx \end{align} $$ To evaluate this integral, it is useful to remember some [trigonometric identities](https://en.wikipedia.org/wiki/List_of_trigonometric_identities). (You can learn more about how I remember trigonometric identities [here](../linkedFiles/TrigIdentities.md).) The specific identity we need here is $\sin^2 x = \tfrac{1}{2}(1-\cos 2x)$: $$ \begin{align} 1 &= \left|A_n\right|^2\int_0^a \sin^2\left(\tfrac{n \pi x}{a}\right) \,dx \\ &= \left|A_n\right|^2\int_0^a \tfrac{1}{2}\left(1-\cos \left(\tfrac{2n \pi x}{a}\right)\right) \,dx \\ &=\tfrac{\left|A_n\right|^2}{2} \left( \int_0^a 1 \,dx - \int_0^a \cos \left(\tfrac{2n \pi x}{a}\right)\,dx \right) \\ &=\tfrac{\left|A_n\right|^2}{2} \left( \left[ x \right]_0^a - \left[\frac{-a}{2 n \pi}\sin \left(\tfrac{2n \pi x}{a}\right) \right]_0^a \right) \\ &=\tfrac{\left|A_n\right|^2}{2} \left( a - 0 \right) \end{align} $$ So $$ \left|A_n\right|^2 = \tfrac{2}{a} $$ Note that this does not completely determine $A_n$. For example, any of the following normalization constants are allowed, $$ A_n = \sqrt{\tfrac{2}{a}} = - \sqrt{\tfrac{2}{a}} = i \sqrt{\tfrac{2}{a}} = -i \sqrt{\tfrac{2}{a}} $$ In general, any [square root of unity](https://en.wikipedia.org/wiki/Root_of_unity) can be used, $$ A_n = \left(\cos(\theta) \pm i \sin(\theta) \right) \sqrt{\tfrac{2}{a}} $$ where $k$ is any real number. The arbitrariness of the *phase* of the wavefunction is an important feature. Because the wavefunction can be imaginary (e.g., if you choose $A_n = i \sqrt{\tfrac{2}{a}}$), it is obvious that the wavefunction is not an observable property of a system. **The wavefunction is only a mathematical tool for quantum mechanics; it is not a physical object.** Summarizing, the (normalized) wavefunction for a particle with mass $m$ confined to a one-dimensional box with length $a$ can be written as: $$ \psi_n(x) = \sqrt{\tfrac{2}{a}} \sin\left(\tfrac{n \pi x}{a}\right) \qquad \qquad n=1,2,3,\ldots $$ Note that in this case, the normalization condition is the same for all $n$; that is an unusual property of the particle-in-a-box wavefunction. While this normalization convention is used 99% of the time, there are some cases where it is more convenient to make a different choice for the amplitude of the wavefunctions. I say this to remind you that normalization the wavefunction is something we do for convenience; it is not required by physics! ## Normalization Check One advantage of using Jupyter is that we can easily check our (symbolic) mathematics. Let's confirm that the wavefunction is normalized by evaluating, $$ \int_0^a \left| \psi_n(x) \right|^2 \, dx $$ ```python # Execute this code block to import required objects. # Note: The numpy library from autograd is imported, which behaves the same as # importing numpy directly. However, to make automatic differentiation work, # you should NOT import numpy directly by `import numpy as np`. import autograd.numpy as np from autograd import elementwise_grad as egrad # import numpy as np from scipy.integrate import trapz, quad from scipy import constants import ipywidgets as widgets import matplotlib.pyplot as plt # set the size of the plot # plt.rcParams['figure.figsize'] = [10, 5] ``` ```python # Define a function for the wavefunction def compute_wavefunction(x, n, a): """Compute 1-dimensional particle-in-a-box wave-function value(s). Parameters ---------- x: float or np.ndarray Position of the particle. n: int Quantum number value. a: float Length of the box. """ # check argument n if not (isinstance(n, int) and n > 0): raise ValueError("Argument n should be a positive integer.") # check argument a if a <= 0.0: raise ValueError("Argument a should be positive.") # check argument x if not (isinstance(x, float) or hasattr(x, "__iter__")): raise ValueError("Argument x should be a float or an array!") # compute wave-function value = np.sqrt(2 / a) * np.sin(n * np.pi * x / a) # set wave-function values out of the box equal to zero if hasattr(x, "__iter__"): value[x > a] = 0.0 value[x < 0] = 0.0 else: if x < 0.0 or x > a: value = 0.0 return value # Define a function for the wavefunction squared def compute_probability(x, n, a): """Compute 1-dimensional particle-in-a-box probablity value(s). See `compute_wavefunction` parameters. """ return compute_wavefunction(x, n, a)**2 #This next bit of code just prints out the normalization error def check_normalization(a, n): #check the computed values of the moments against the analytic formula normalization,error = quad(compute_probability, 0, a, args=(n, a)) print("Normalization of wavefunction = ", normalization) #Principle quantum number: n = 1 #Box length: a = 1 check_normalization(a, n) ``` Normalization of wavefunction = 1.0000000000000002 ## The Energies of the Particle in a Box How do we compute the energy of a particle in a box? All we need to do is substitute the eigenfunctions of the Hamiltonian, $\psi_n(x)$ back into the Schr&ouml;dinger equation to determine the eigenenergies, $E_n$. That is, from $$ \hat{H} \psi_n(x) = E_n \psi_n(x) $$ we deduce $$ \begin{align} -\frac{\hbar^2}{2m} \frac{d^2}{dx^2} \left( A_n \sin \left( \frac{n \pi x}{a}\right) \right) &= E_n \left( A_n \sin \left( \frac{n \pi x}{a}\right) \right) \\ -A_n \frac{\hbar^2}{2m} \frac{d}{dx} \left( \frac{n \pi}{a} \cos \left( \frac{n \pi x}{a}\right) \right) &= E_n \left( A_n \sin \left( \frac{n \pi x}{a}\right) \right) \\ A_n \frac{\hbar^2}{2m} \left( \frac{n \pi}{a} \right)^2 \sin \left( \frac{n \pi x}{a}\right) &= E_n \left( A_n \sin \left( \frac{n \pi x}{a}\right) \right) \\ \frac{\hbar^2 n^2 \pi^2}{2ma^2} &= E_n \end{align} $$ Using the definition of $\hbar$, we can rearrange this to: $$ \begin{align} E_n &= \frac{\hbar^2 n^2 \pi^2}{2ma^2} \qquad \qquad n=1,2,3,\ldots\\ &= \frac{h^2 n^2}{8ma^2} \end{align} $$ Notice that only certain energies are allowed. This is a fundamental principle of quantum mechanics, and it is related to the "waviness" of particles. Certain "frequencies" are resonant, and other "frequencies" cannot be observed. *The **only** energies that can be observed for a particle-in-a-box are the ones given by the above formula.* ## Zero-Point Energy Na&iuml;vely, you might expect that the lowest-energy state of a particle in a box has zero energy. (The potential in the box is zero, after all, so shouldn't the lowest-energy state be the state with zero kinetic energy? And if the kinetic energy were zero and the potential energy were zero, then the total energy would be zero.) But this doesn't happen. It turns out that you can never "stop" a quantum particle; it always has a zero-point motion, typically a resonant oscillation about the lowest-potential-energy location(s). Indeed, the more you try to confine a particle to stop it, the bigger its kinetic energy becomes. This is clear in the particle-in-a-box, which has only kinetic energy. There the (kinetic) energy increases rapidly, as $a^{-2}$, as the box becomes smaller: $$ T_n = E_n = \frac{h^2n^2}{8ma^2} $$ The residual energy in the electronic ground state is called the **zero-point energy**, $$ E_{\text{zero-point energy}} = \frac{h^2}{8ma^2} $$ The existence of the zero-point energy, and the fact that zero-point kinetic energy is always positive, is a general feature of quantum mechanics. > **Zero-Point Energy Principle:** Let $V(x)$ be a nonnegative potential. The ground-state energy is always greater than zero. More generally, for any potential that is bound from below, $$ V_{\text{min}}= \min_x V(x) $$ the ground-state energy of the system satisfies $E_{\text{zero-point energy}} > V_{\text{min}}$. >Nuance: There is a tiny mathematical footnote here; there are some $V(x)$ for which there are *no* bound states. In such cases, e.g., $V(x) = \text{constant}$, it is possible for $E = V_{\text{min}}$.) ## Atomic Units Because Planck's constant and the electron mass are tiny numbers, it is often useful to use [atomic units](https://en.wikipedia.org/wiki/Hartree_atomic_units) when performing calculations. We'll learn more about atomic units later but, for now, we only need to know that, in atomic units, $\hbar$, the mass of the electron, $m_e$, the charge of the electron, $e$, and the average (mean) distance of an electron from the nucleus in the Hydrogen atom, $a_0$, are all defined to be equal to 1.0 in atomic units. $$ \begin{align} \hbar &= \frac{h}{2 \pi} = 1.0545718 \times 10^{-34} \text{ J s}= 1 \text{ a.u.} \\ m_e &= 9.10938356 \times 10^{-31} \text{ kg} = 1 \text{ a.u.} \\ e &= 1.602176634 \times 10^-19 \text{ C} = 1 \text{ a.u.} \\ a_0 &= 5.291772109 \times 10^{-11} \text{ m} = 1 \text{ Bohr} = 1 \text{ a.u.} \end{align} $$ The unit of energy in atomic units is called the Hartree, $$ E_h =4.359744722 \times 10^{-18} \text{ J} = 1 \text{ Hartree} = 1 \text{ a.u.} $$ and the ground-state (zero-point) energy of the Hydrogen atom is $-\tfrac{1}{2} E_h$. We can now define functions for the eigenenergies of the 1-dimensional particle in a box: ```python # Define a function for the energy of a particle in a box # with length a and quantum number n [in atomic units!] # The length is input in Bohr (atomic units) def compute_energy(n, a): "Compute 1-dimensional particle-in-a-box energy." return n**2 * np.pi**2 / (2 * a**2) # Define a function for the energy of an electron in a box # with length a and quantum number n [in SI units!]. # The length is input in meters. def compute_energy_si(n, a): "Compute 1-dimensional particle-in-a-box energy." return n**2 * constants.h**2 / (8 * constants.m_e* a**2) #Define variable for atomic unit of length in meters a0 = constants.value('atomic unit of length') #This next bit of code just prints out the energy in atomic and SI units def print_energy(a, n): print(f'The energy of an electron in a box of length {a:.2f} a.u. with ' f'quantum number {n} is {compute_energy(n, a):.2f} a.u..') print(f'The energy of an electron in a box of length {a*a0:.2e} m with ' f'quantum number {n} is {compute_energy_si(n, a*a0):.2e} Joules.') #Principle quantum number: n = 1 #Box length: a = 0.1 print_energy(a, n) ``` The energy of an electron in a box of length 0.10 a.u. with quantum number 1 is 493.48 a.u.. The energy of an electron in a box of length 5.29e-12 m with quantum number 1 is 2.15e-15 Joules. #### &#x1f4dd; Exercise: Write a function that returns the length, $a$, of a box for which the lowest-energy-excitation of the ground state, $n = 1 \rightarrow n=2$, corresponds to the system absorbing light with a given wavelength, $\lambda$. The input is $\lambda$; the output is $a$. ## Postulate: The wavefunction contains all the physically meaningful information about a system. While the wavefunction is not itself observable, all observable properties of a system can be determined from the wavefunction. However, just because the wavefunction encapsulates all the *observable* properties of a system does not mean that it contains *all information* about a system. In quantum mechanics, some things are not observable. Consider that for the ground ($n=1$) state of the particle in a box, the root-mean-square average momentum, $$ \bar{p}_{rms} = \sqrt{2m \cdot T} = \sqrt{(2m)\frac{h^2n^2}{8ma^2}} = \frac{hn}{2a} $$ increases as you squeeze the box. That is, the more you try to constrain the particle in space, the faster it moves. You can't "stop" the particle no matter how hard you squeeze it, so it's impossible to exactly know where the particle is located. You can only determine its *average* position. ## Postulate: Observable Quantities Correspond to Linear, Hermitian Operators. The *correspondence* principle says that for every classical observable there is a linear, Hermitian, operator that allows computation of the quantum-mechanical observable. An operator, $\hat{C}$ is linear if for any complex numbers $a$ and $b$, and any wavefunctions $\psi_1(x)$ and $\psi_2(x)$, $$ \hat{C} \left(a \psi_1(x,t) + b \psi_2(x,t) \right) = a \hat{C} \psi_1(x,t) + b \hat{C} \psi_2(x,t) $$ Similarly, an operator is Hermitian if it satisfies the relation, $$ \int \psi_1^*(x,t) \hat{C} \psi_2(x,t) \, dx = \int \left( \hat{C}\psi_1(x,t) \right)^* \psi_2(x,t) \, dx $$ or, equivalently, $$ \int \psi_1^*(x,t) \left( \hat{C} \psi_2(x,t) \right) \, dx = \int \psi_2(x,t)\left( \hat{C} \psi_1(x,t) \right)^* \, dx $$ That is for a linear operator, the linear operator applied to a sum of wavefunctions is equal to the sum of the linear operators directly applied to the wavefunctions separately, and the linear operator applied to a constant times a wavefunction is the constant times the linear operator applied directly to the wavefunction. A Hermitian operator can apply forward (towards $\psi_2(x,t)$) or backwards (towards $\psi_1(x,t)$). This is very useful, because sometimes it is much easier to apply an operator in one direction. We've already been introduced to the quantum-mechanical operators for the momentum, $$ \hat{p} = -i \hbar \tfrac{d}{dx} $$ and the kinetic energy, $$ \hat{T} = -\tfrac{\hbar^2}{2m} \tfrac{d^2}{dx^2} $$ These operators are linear because the derivative of a sum is the sum of the derivatives, and the derivative of a constant times a function is that constant times the derivative of the function. These operators are also Hermitian. For example, to show that the momentum operator is Hermitian: $$ \begin{align} \int_{-\infty}^{\infty} \psi_1^*(x,t) \hat{p} \psi_2(x,t) dx &= \int_{-\infty}^{\infty} \psi_1^*(x,t) \left( -i \hbar \tfrac{d}{dx} \right) \psi_2(x,t) dx \\ &= -i \hbar \int_{-\infty}^{\infty} \tfrac{d}{dx} \left(\psi_1^*(x,t)\psi_2(x,t) \right) - \left( \psi_2(x,t) \tfrac{d}{dx} \psi_1^*(x,t)\right) dx \end{align} $$ Here we used the product rule for derivatives, $f(x)\tfrac{dg}{dx} = \tfrac{d f(x) g(x)}{dx} - g(x) \tfrac{df}{dx}$. Using the fundamental theorem of calculus and the fact the probability of observing a particle at $\pm \infty$ is zero, and therefore the wavefunctions at infinity are also zero, one knows that $$ \int_{-\infty}^{\infty} \tfrac{d}{dx} \left(\psi_1^*(x,t)\psi_2(x,t) \right) = \left[ \psi_1^*(x,t)\psi_2(x,t)\right]_{-\infty}^{\infty} = 0 $$ Therefore the above equation can be simplified to $$ \begin{align} \int_{-\infty}^{\infty} \psi_1^*(x,t) \hat{p} \psi_2(x,t) dx &=i \hbar \int_{-\infty}^{\infty} \psi_2(x,t) \tfrac{d}{dx} \psi_1^*(x,t) dx \\ &= \int_{-\infty}^{\infty} \psi_2(x,t) i \hbar \tfrac{d}{dx} \psi_1^*(x,t) dx \\ &= \int_{-\infty}^{\infty} \psi_2(x,t) \left( -i \hbar \tfrac{d}{dx} \psi_1^*(x,t)\right) dx \\ &= \int_{-\infty}^{\infty} \psi_2(x,t) \left( \hat{p} \psi_1(x,t)\right)^* dx \end{align} $$ The expectation value of the momentum of a particle-in-a-box is always zero. This is intuitive, since electrons (on average) are neither moving to the right nor to the left inside the box: if they were, then the box itself would need to be moving. Indeed, for any real wavefunction, the average momentum is always zero. This follows directly from the previous derivation with $\psi_1^*(x,t) = \psi_2(x,t)$. Thus: $$ \begin{align} \int_{-\infty}^{\infty} \psi_2(x,t) \hat{p} \psi_2(x,t) dx &=i \hbar \int_{-\infty}^{\infty} \psi_2(x,t) \tfrac{d}{dx} \psi_2(x,t) dx \\ &=-i \hbar \int_{-\infty}^{\infty} \psi_2(x,t) \left( \tfrac{d}{dx} \psi_2(x,t)\right) dx \\ &= 0 \end{align} $$ The last line follows because the only number that is equal to its negative is zero. (That is, $x=-x$ if and only if $x=0$.) It is a subtle feature that the eigenfunctions of a real-valued Hamiltonian operator can always be chosen to be real-valued themselves, so their average momentum is clearly zero. We often denote quantum-mechanical expectation values with the shorthand, $$ \langle \hat{p} \rangle =0 $$ The momentum-squared of the particle-in-a-box is easily computed from the kinetic energy, $$ \langle \hat{p}^2 \rangle = \int_0^a \psi_n(x) \hat{p}^2 \psi_n(x) dx = \int_0^a \psi_n(x) \left(2m\hat{T}\right) \psi_n(x) dx = 2m E_n = \frac{h^2n^2}{4a^2} $$ Intuitively, since the box is symmetric about $x=\tfrac{a}{2}$, the particle has equal probability of being in the first-half and the second-half of the box. So the average position is expected to be $$ \langle x \rangle =\tfrac{a}{2} $$ We can confirm this by explicit integration, $$ \begin{align} \langle x \rangle &= \int_0^a \psi_n^*(x)\, x \,\psi_n(x) dx \\ &= \int_0^a \left(\sqrt{\tfrac{2}{a}} \sin\left(\tfrac{n \pi x}{a} \right)\right) x \left(\sqrt{\tfrac{2}{a}}\sin\left(\tfrac{n \pi x}{a} \right)\right) dx \\ &= \tfrac{2}{a} \int_0^a x \sin^2\left(\tfrac{n \pi x}{a} \right) dx \\ &= \tfrac{2}{a} \left[ \tfrac{x^2}{4} - x \tfrac{\sin \tfrac{2n \pi x}{a}}{\tfrac{4 n \pi}{a}} - \tfrac{\cos \tfrac{2n \pi x}{a}}{\tfrac{8 n^2 \pi^2}{a^2}} \right]_0^a \\ &= \tfrac{2}{a} \left[ \tfrac{a^2}{4} - 0 - 0 \right] \\ &= \tfrac{a}{2} \end{align} $$ Similarly, we expect that the expectation value of $\langle x^2 \rangle$ will be proportional to $a^2$. We can confirm this by explicit integration, $$ \begin{align} \langle x^2 \rangle &= \int_0^a \psi_n^*(x)\, x^2 \,\psi_n(x) dx \\ &= \int_0^a \left(\sqrt{\tfrac{2}{a}} \sin\left(\tfrac{n \pi x}{a} \right)\right) x^2 \left(\sqrt{\tfrac{2}{a}}\sin\left(\tfrac{n \pi x}{a} \right)\right) dx \\ &= \tfrac{2}{a} \int_0^a x^2 \sin^2\left(\tfrac{n \pi x}{a} \right) dx \\ &= \tfrac{2}{a} \left[ \tfrac{x^3}{6} - x^2 \tfrac{\sin \tfrac{2n \pi x}{a}}{\tfrac{4 n \pi}{a}} - x \tfrac{\cos \tfrac{2n \pi x}{a}}{\tfrac{4 n^2 \pi^2}{a^2}} - \tfrac{\sin \tfrac{2n \pi x}{a}}{\tfrac{8 n^3 \pi^3}{a^3}} \right]_0^a \\ &= \tfrac{2}{a} \left[ \tfrac{a^3}{6} - 0 - \tfrac{a}{{\tfrac{4 n^2 \pi^2}{a^2}}} - 0 \right] \\ &= \tfrac{2}{a} \left[ \tfrac{a^3}{6} - \tfrac{a^3}{4 n^2 \pi^2} \right] \\ &= a^2\left[ \tfrac{1}{3} - \tfrac{1}{2 n^2 \pi^2} \right] \end{align} $$ We can verify these formulas by explicit integration. ```python #Compute <x^power>, the expectation value of x^power def compute_moment(x, n, a, power): """Compute the x^power moment of the 1-dimensional particle-in-a-box. See `compute_wavefunction` parameters. """ return compute_probability(x, n, a)*x**power #This next bit of code just prints out the values. def check_moments(a, n): #check the computed values of the moments against the analytic formula avg_r,error = quad(compute_moment, 0, a, args=(n, a, 1)) avg_r2,error = quad(compute_moment, 0, a, args=(n, a, 2)) print(f"<r> computed = {avg_r:.5f}") print(f"<r> analytic = {a/2:.5f}") print(f"<r^2> computed = {avg_r2:.5f}") print(f"<r^2> analytic = {a**2*(1/3 - 1./(2*n**2*np.pi**2)):.5f}") #Principle quantum number: n = 1 #Box length: a = 1 check_moments(a, n) ``` <r> computed = 0.50000 <r> analytic = 0.50000 <r^2> computed = 0.28267 <r^2> analytic = 0.28267 ## Heisenberg Uncertainty Principle The previous example gives a first example of the more general [Heisenberg Uncertainty Principle](https://en.wikipedia.org/wiki/Uncertainty_principle). One specific manifestation of the Heisenberg Uncertaity Principle is that the variance of the position, $\sigma_x^2 = \langle x^2 \rangle - \langle x \rangle^2$, times the variance of the momentum. $\sigma_p^2 = \langle \hat{p}^2 \rangle - \langle \hat{p} \rangle^2$ is greater than $\tfrac{\hbar^2}{4}$. We can verify this formula for the particle in a box. $$ \begin{align} \tfrac{\hbar^2}{4} &\le \sigma_x^2 \sigma_p^2 \\ &= \left( a^2\left[ \tfrac{1}{3} - \tfrac{1}{2 n^2 \pi^2} \right] - \tfrac{a^2}{4} \right) \left( \frac{h^2n^2}{4a^2} - 0 \right) \\ &= \left( a^2\left[ \tfrac{1}{3} - \tfrac{1}{2 n^2 \pi^2} \right] - \tfrac{a^2}{4} \right) \left( \frac{\hbar^2 \pi^2 n^2}{a^2} \right) \\ &= \hbar^2 \pi^2 n^2 \left(\tfrac{1}{12} - \tfrac{1}{2 n^2 \pi^2} \right) \end{align} $$ The right-hand-side gets larger and larger as $n$ increases, so the largest value occurs where: $$ \begin{align} \tfrac{\hbar^2}{4} &\le \hbar^2 \pi^2 \left(\tfrac{1}{12} - \tfrac{1}{2 \pi^2} \right) \\ &= 0.32247 \hbar^2 \end{align} $$ ## Double-Checking the Energy of a Particle-in-a-Box To check the energy of the particle in a box, we can compute the kinetic energy density, then integrate it over all space. That is, we define: $$ \tau_n(x) = \psi_n^*(x) \left(-\tfrac{\hbar^2}{2m}\tfrac{d^2}{dx^2}\right) \psi_n(x) $$ and then the kinetic energy (which is the energy for the particle in a box) is $$ T_n = \int_0^a \tau_n(x) dx $$ > *Note:* In fact there are several different equivalent definitions of the kinetic energy density, but this is not very important in an introductory quantum chemistry course. All of the kinetic energy densities give the same total kinetic energy. However, because the kinetic energy density, $\tau(x)$, represents the kinetic energy of a particle at the point $x$, and it is impossible to know the momentum (or the momentum-squared, ergo the kinetic energy) exactly at a given point in space according to the Heisenberg uncertainty principle), there can be no unique definition for $\tau(x)$. ```python #The next few lines just set up the sliders for setting parameters. #Principle quantum number slider: def compute_wavefunction_derivative(x, n, a, order=1): """Compute 1-dimensional particle-in-a-box kinetic energy density. """ if not (isinstance(order, int) and n > 0): raise ValueError("Argument order is expected to be a positive integer!") def wavefunction(x): v = np.sqrt(2 / a) * np.sin(n * np.pi * x / a) return v # compute derivative deriv = egrad(wavefunction) for _ in range(order - 1): deriv = egrad(deriv) # return zero for x values out of the box deriv = deriv(x) # deriv[x < 0] = 0.0 # deriv[x > a] = 0.0 if hasattr(x, "__iter__"): deriv[x > a] = 0.0 deriv[x < 0] = 0.0 else: if x < 0.0 or x > a: deriv = 0.0 return deriv def compute_kinetic_energy_density(x, n, a): """Compute 1-dimensional particle-in-a-box kinetic energy density. See `compute_wavefunction` parameters. """ # evaluate wave-function and its 2nd derivative w.r.t. x wf = compute_wavefunction(x, n, a) d2 = compute_wavefunction_derivative(x, n, a, order=2) return -0.5 * wf * d2 #This next bit of code just prints out the values. def check_energy(a, n): #check the computed values of the moments against the analytic formula ke,error = quad(compute_kinetic_energy_density, 0, a, args=(n, a)) energy = compute_energy(n, a) print(f"The energy computed by integrating the k.e. density is {ke:.5f}") print(f"The energy computed directly is {energy:.5f}") #Principle quantum number: n = 1 #Box length: a = 17 check_energy(a, n) ``` The energy computed by integrating the k.e. density is 0.01708 The energy computed directly is 0.01708 ## Visualizing the Particle-in-a-Box Wavefunctions, Probabilities, etc. In the next code block, the wavefunction, probability density, derivative, second-derivative, and kinetic energy density for the particle-in-a-box are shown. Notice that the kinetic-energy-density is proportional to the probability density, and that the first and second derivatives are not zero at the edge of the box, but the wavefunction and probability density are. It's useful to change the parameters in the below figures to build your intuition for the particle-in-a-box. ```python #This next bit of code makes the plots and prints out the energy def make_plots(a, n): #check the computed values of the moments against the analytic formula energy = compute_energy(n, a) print(f"The energy computed directly is {energy:.5f}") # sample x coordinates x = np.arange(-0.6, a + 0.6, 0.01) # evaluate wave-function & probability wf = compute_wavefunction(x, n, a) pr = compute_probability(x, n, a) # evaluate 1st & 2nd derivative of wavefunction w.r.t. x d1 = compute_wavefunction_derivative(x, n, a, order=1) d2 = compute_wavefunction_derivative(x, n, a, order=2) # evaluate kinetic energy density kin = compute_kinetic_energy_density(x, n, a) #print("Integrate KED = ", trapz(kin, x)) # set the size of the plot plt.rcParams['figure.figsize'] = [15, 10] plt.rcParams['font.family'] = 'DejaVu Sans' plt.rcParams['font.serif'] = ['Times New Roman'] plt.rcParams['mathtext.fontset'] = 'stix' plt.rcParams['xtick.labelsize'] = 15 plt.rcParams['ytick.labelsize'] = 15 # define four subplots fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2) fig.suptitle(f'a={a} n={n} E={compute_energy(n, a):.4f} a.u.', fontsize=35, fontweight='bold') # plot 1 ax1.plot(x, wf, linestyle='--', label=r'$\psi(x)$', linewidth=3) ax1.plot(x, pr, linestyle='-', label=r'$\|\psi(x)\|^2$', linewidth=3) ax1.legend(frameon=False, fontsize=20) ax1.set_xlabel('x coordinates', fontsize=20) # plot 2 ax2.plot(x, d1, linewidth=3, c='k') ax2.set_xlabel('x coordinates', fontsize=20) ax2.set_ylabel(r'$\frac{d\psi(x)}{dx}$', fontsize=30, rotation=0, labelpad=25) # plot 3 ax3.plot(x, d2, linewidth=3, c='g', ) ax3.set_xlabel('x coordinates', fontsize=20) ax3.set_ylabel(r'$\frac{d^2\psi(x)}{dx^2}$', fontsize=25, rotation=0, labelpad=25) # plot 4 ax4.plot(x, kin, linewidth=3, c='r') ax4.set_xlabel('x coordinates', fontsize=20) ax4.set_ylabel('Kinetic Energy Density', fontsize=16) # adjust spacing between plots plt.subplots_adjust(left=0.125, bottom=0.1, right=0.9, top=0.9, wspace=0.35, hspace=0.35) #Show Plot plt.show() #Principle quantum number slider: n = 1 #Box length slider: a = 1 make_plots(a, n) ``` ## &#x1fa9e; Self-Reflection - Can you think of other physical or chemical systems where the particle-in-a-box Hamiltonian would be appropriate? - Can you think of another property density, besides the kinetic energy density, that cannot be uniquely defined in quantum mechanics? ## &#x1f914; Thought-Provoking Questions - How would the wavefunction and ground-state energy change if you made a small change in the particle-in-a-box Hamiltonian, so that the right-hand-side of the box was a little higher than the left-hand-side? - Any system with a zero-point energy of zero is classical. Why? - How would you compute the probability of observing an electron at the center of a box if the box contained 2 electrons? If it contained 4 electrons? If it contained 8 electrons? The probability of observing an electron at the center of a box with 3 electrons is sometimes *lower* than the probability of observing an electron at the center of a box with 2 electrons. Why? - Demonstrate that the kinetic energy operator is linear and Hermitian. - What is the lowest-energy excitation energy for the particle-in-a-box? - Suppose you wanted to design a one-dimensional box containing a single electron that absorbed blue light? How long would the box be? ## &#x2753; Knowledge Tests - Questions about the Particle-in-a-Box and related concepts. [GitHub Classroom Link](https://classroom.github.com/a/1Y48deKP) ## &#x1f469;&#x1f3fd;&#x200d;&#x1f4bb; Assignments - Compute and understand expectation values by computing moments of the particle-in-a-box [assignment](https://github.com/McMasterQM/PinBox-Moments/blob/main/moments.ipynb). [Github classroom link]https://classroom.github.com/a/9yzWI5Vt. - This [assignment](https://github.com/McMasterQM/Sudden-Approximation/blob/main/SuddenPinBox.ipynb) on the sudden approximation provides an introduction to time-dependent phenomena. [Github classroom link](https://classroom.github.com/a/yBzABlb-). ## &#x1f501; Recapitulation - Write the Hamiltonian, time-independent Schr&ouml;dinger equation, eigenfunctions, and eigenvalues for the one-dimensional particle in a box. - Play around with the eigenfunctions and eigenenergies of the particle-in-a-box to build intuition for them. - How would you compute the uncertainty in $x^4$? - Practice your calculus by explicitly computing, using integration by parts, $\langle x \rangle$ and $\langle x^2 \rangle$. This can be implemented in a [Jupyter notebook](x4_mocked.ipynb). ## &#x1f52e; Next Up... - Postulates of Quantum Mechanics - Multielectron particle-in-a-box. - Multidimensional particle-in-a-box. - Harmonic Oscillator ## &#x1f4da; References My favorite sources for this material are: - [Randy's book](https://github.com/PaulWAyers/IntroQChem/blob/main/documents/DumontBook.pdf) has an excellent treatment of the particle-in-a-box model, including several extensions to the material covered here. (Chapter 3) - Also see my (pdf) class [notes](https://github.com/PaulWAyers/IntroQChem/blob/main/documents/PinBox.pdf). - Also see my notes on the [mathematical structure of quantum mechanics](https://github.com/PaulWAyers/IntroQChem/blob/main/documents/LinAlgAnalogy.pdf). - [Davit Potoyan's](https://www.chem.iastate.edu/people/davit-potoyan) Jupyter-book covers the particle-in-a-box in [chapter 4](https://dpotoyan.github.io/Chem324/intro.html) are especially relevant here. - D. A. MacQuarrie, Quantum Chemistry (University Science Books, Mill Valley California, 1983) - [An excellent explanation of the link to the spectrum of cyanine dyes](https://pubs.acs.org/doi/10.1021/ed084p1840) - Chemistry Libre Text: [one dimensional](https://chem.libretexts.org/Bookshelves/Physical_and_Theoretical_Chemistry_Textbook_Maps/Map%3A_Physical_Chemistry_for_the_Biosciences_(Chang)/11%3A_Quantum_Mechanics_and_Atomic_Structure/11.08%3A_Particle_in_a_One-Dimensional_Box) and [multi-dimensional](https://chem.libretexts.org/Bookshelves/Physical_and_Theoretical_Chemistry_Textbook_Maps/Supplemental_Modules_(Physical_and_Theoretical_Chemistry)/Quantum_Mechanics/05.5%3A_Particle_in_Boxes/Particle_in_a_3-Dimensional_box) - [McQuarrie and Simon summary](https://chem.libretexts.org/Bookshelves/Physical_and_Theoretical_Chemistry_Textbook_Maps/Map%3A_Physical_Chemistry_(McQuarrie_and_Simon)/03%3A_The_Schrodinger_Equation_and_a_Particle_in_a_Box) There are also some excellent wikipedia articles: - [Particle in a Box](https://en.wikipedia.org/wiki/Particle_in_a_box) - [Particle on a Ring](https://en.wikipedia.org/wiki/Particle_in_a_ring) - [Postulates of Quantum Mechanics](https://en.wikipedia.org/wiki/Mathematical_formulation_of_quantum_mechanics#Postulates_of_quantum_mechanics) ```python ```

10d5fed85c4fc358fc01c1bc77d5d0741ec61380

ipynb

Jupyter Notebook

book/ParticleIn1DBox.ipynb

RichRick1/IntroQM2022

91a37b630b9b83c76c972ee2e958a13640b1a37f

2022-02-08T18:42:37.000Z

2022-02-21T19:33:46.000Z

book/ParticleIn1DBox.ipynb

RichRick1/IntroQM2022

91a37b630b9b83c76c972ee2e958a13640b1a37f

2022-01-26T18:45:29.000Z

2022-03-04T20:32:52.000Z

book/ParticleIn1DBox.ipynb

RichRick1/IntroQM2022

91a37b630b9b83c76c972ee2e958a13640b1a37f

2022-02-08T17:56:55.000Z

2022-03-03T08:30:53.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Projet EDP : Ecoulement de gel hydroalcoolique avec l'équation de Stockes ( En cas de problème sur l'exécution du code ou avec les images, merci de me contacter : matthieu.briet@student-cs.fr ### Introduction La crise sanitaire actuelle nous pousse à utiliser de plus en plus des gels hydroalcoolique parfois sous forme de bouteille avant de rentrer dans des magasins par exemple. Cependant, il arrive qu'une partie du gel hydroalcoolique durcisse et forme un dépôt solide dans l'embout de sortie ce qui projète une partie du gel un peu partout et parfois même sur nos vêtements ou nos chaussures. On se demande alors s'il est possible d'expliquer ou de prédire ces "jets" de gel hydroalcoolique non souhaités. On se propose de simuler l'écoulement du gel dans cette partie de la bouteille : ### Modélisation On s'intéresse ici à la résolution du problème de Stockes qui permet de décrire l'écoulement d'un fluide visqueux incompressible dans un lieu étoit où les effets visqueux prédominent sur les effets inertiels. Ces équations sont données par : \begin{equation} \begin {cases} -\nu \Delta \vec u -\vec {grad } ~p= \vec f \text { sur le domaine } \Omega \\ div ~\vec u =0 \text { sur le domaine } \Omega ~\text{(c'est la condition d'incompressibilité)}\\ \vec u=0 ~\text{sur la frontière} ~\partial \Omega ~\text{(conditions de bords de type Dirichlet homogène)} \end{cases} \end{equation} avec \begin{equation} \begin{cases} \Omega ~\text{le domaine d'étude qui sera spécifié plus tard}\\ \vec u ~\text{le champ de vitesse}\\ p ~\text{la pression}\\ \vec f ~\text{ la densité de force }\\ \nu >0 ~\text{la viscosité cinématique du fluide } \end{cases} \end{equation} Grâce au cours d'EDP associé à quelques recherches (car ici on a deux équation à cause de la condition d'incompressibilité), on peut écrire la formulation faible du problème qui s'obtient en multipliant par une fonction test et en intégrant : \begin{equation} \begin{cases} \int_\Omega \nabla u .\nabla \Phi +\frac{1}{\nu}.\int_\Omega \nabla p .\Phi = \frac{1}{\nu}. \int_\Omega f.\Phi \\ \int_\Omega div(u).q=0 \end{cases} \end{equation} avec $\Phi$ et $q$ des fonctions tests. Ecrivons à présent la formulation variationnelle du problème avec : \begin{equation} \begin{array}{l|rcl} a : & W \times W \longrightarrow \mathbf{R} \\ & ((u,p),(\Phi,q)) & \longmapsto \int_{\Omega} \nabla u .\nabla \Phi +\frac{1}{\nu}. \nabla p .\Phi+div(u).q \end{array} \end{equation} avec $W= U \times P $ tel que $u\in U $ et $p\in P$ et \begin{equation} \begin{array}{l|rcl} l: & W \longrightarrow \mathbf{R} \\ & (\Phi,q) & \longmapsto \frac{1}{\nu}.\int_{\Omega} f.\Phi \end{array} \end{equation} On cherche alors à résoudre le problème : Trouver $(u,p)\in W $ tel que $ \forall (\Phi,q) \in W , a((u,p),(\Phi,q)) =l((\Phi,q))$ On peut ensuite montrer que a est une forme bilinéaire continue et coercive et que l est une forme continue et donc qu'il existe une unique solution au problème.On se propose par la suite de résoudre ce problème numériquement avec FeniCS. Il nous reste à présent à spécifier les valeurs prisent pour notre étude : \begin{equation} \begin{cases} \nu= 3500 mm^{2}/s \text{ (viscosité cinématique du gel)}\\ u_{0} = 0.1 m/s \text{ (vitesse initiale du gel)}\\ p_{sortie}= 1 bar \\ \end{cases} \end{equation} ### Etude numérique avec FeniCS <p style="color:red;"> Chargement des modules </p> ```python from dolfin import * from fenics import * import matplotlib.pyplot as plt from mshr import * from __future__ import print_function import random ``` <p style="color:red;"> Définition des constantes </p> ```python # définir les constantes ici nx=10 ny=10 X1=0 Y1=2 X2=1.5 Y2=3 X3=1.5 Y3=2 X4=3 Y4=2.5 nbre_pts=50 nu=0.035 ``` <p style="color:red;"> Définition du maillage </p> ```python rectangle1=Rectangle(Point(X1,Y1),Point(X2,Y2)) rectangle2=Rectangle((Point(X3,Y3)),Point(X4,Y4)) mon_maillage=generate_mesh(rectangle1+rectangle2,nbre_pts) plt.figure(1) plot(mon_maillage,title="mesh ") ``` <p style ="color:red;"> Définition de l'espace de travail </p> ```python U=VectorElement("Lagrange",mon_maillage.ufl_cell(),2) # pour des raisons de stabilité la vitesse ne peux pas être modélisés par des elements finis P1 P=FiniteElement("Lagrange",mon_maillage.ufl_cell(),1) W=FunctionSpace(mon_maillage,U*P) # W.sub(0) pour les vitesses et W.sub(1) pour les pressions ``` <p style ="color:red;"> Condition aux limites </p> ```python tol=1e-14 def condition_gauche(x,on_boundary): return on_boundary and (x[0]<X1+tol and (x[1]<3+tol or x[1]>2-tol)) def condition_droite(x,on_boundary): return on_boundary and (x[0]>X4-tol) def condition_haut_bas(x,on_boundary): return on_boundary and ((x[1]<tol+2) or (x[1]>3-tol and (x[0]<1.5+tol or x[0]>-tol)) or (x[1]>2.5-tol and (x[0]<3+tol or x[0]>1.5-tol))) #le gel entre dans le bec du flacon avec une pression p p_sortie=Constant(1e5) bc_pression=DirichletBC(W.sub(1),p_sortie,condition_droite) #on applique la pression sur l'espace des pressions ici W(1) #vitesse nulle sur les bords horizontaux et sur le bord vertical v0=Expression(("0.0","0.0"),degree=2) bcV0_haut_bas=DirichletBC(W.sub(0),v0,condition_haut_bas) vitesse_entree=0.1 gel_entree=Expression((str(vitesse_entree),"0.0"),degree=2) bc_gel_entree=DirichletBC(W.sub(0),gel_entree,condition_gauche) bc_total=[bc_pression,bcV0_haut_bas,bc_gel_entree] ``` <p style ="color:red;"> Formulation variationnelle </p> ```python u,p=TrialFunctions(W) v,q= TestFunctions(W) f=Constant((0.0,0.0)) a= inner(grad(u),grad(v))*dx+1/nu*inner(v,grad(p))*dx+1/nu*q*div(u)*dx l=1/nu*inner(f,v)*dx ``` <p style ="color:red;"> Résolution du système </p> ```python u=Function(W) solve(a==l,u,bc_total) u_f=u.split()[0] plot(u_f,title="vitesse",scale=2) ``` On voit ici un écoulement normal du gel dans le bec distributeur avec une forte accélération de la vitesse du fluide dans le goulot. Ceci correspond à l'effet Venturi observé en mécanique des fluides et notre fluide à donc ici un comportement assez classique sans perturbation de l'écoulement par un quelconque dépot. On remarque bien sur la simulation précédente que la vitesse du fluide est nulle sur les bords et donc logiquement plus importante sur la ligne médiane de notre écoulement. ### Prise en compte d'un paramètre aléatoire ```python Ox1=2.7 Oy1=2 Ox2=2.9 Oy2=random.uniform(2,2.5) ``` ```python rectangle1=Rectangle(Point(X1,Y1),Point(X2,Y2)) rectangle2=Rectangle((Point(X3,Y3)),Point(X4,Y4)) obstacle= Rectangle(Point(Ox1,Oy1),Point(Ox2,Oy2)) mon_maillage2=generate_mesh(rectangle1+rectangle2-obstacle,nbre_pts) plt.figure(2) plot(mon_maillage2,title="mesh2") ``` ```python U=VectorElement("Lagrange",mon_maillage2.ufl_cell(),2) # pour des raisons de stabilité la vitesse ne peux pas être modélisés par des elements finis P1 P=FiniteElement("Lagrange",mon_maillage2.ufl_cell(),1) W=FunctionSpace(mon_maillage2,U*P) # W.sub(0) pour les vitesses et W.sub(1) pour les pressions tol=1e-14 def condition_gauche(x,on_boundary): return on_boundary and (x[0]<X1+tol) def condition_droite(x,on_boundary): return on_boundary and (x[0]>X4-tol) def condition_haut_bas(x,on_boundary): return on_boundary and ((x[1]<tol+2) or (x[1]>3-tol and (x[0]<1.5+tol or x[0]>-tol)) or (x[1]>2.5-tol and (x[0]<3+tol or x[0]>1.5-tol))) def condition_obstacle(x,on_boundary): return on_boundary and x[0]<Ox2+tol and x[0]>Ox1-tol and x[1]<Oy2+tol and x[1]>Oy1-tol #le gel entre dans le bec du flacon avec une pression p p_sortie=Constant(1e5) bc_pression=DirichletBC(W.sub(1),p_sortie,condition_droite) #on applique la pression sur l'espace des pressions ici W(1) #vitesse nulle sur les bords horizontaux et sur le bord vertical et sur l'obstacle v0=Expression(("0.0","0.0"),degree=2) bcV0_haut_bas=DirichletBC(W.sub(0),v0,condition_haut_bas) bc_obstacle=DirichletBC(W.sub(0),v0,condition_obstacle) #vecteur vitesse pour le gel en sortie vitesse_entree=0.1 gel_sortie=Expression((str(vitesse_entree),"0.0"),degree=2) bc_gel_entree=DirichletBC(W.sub(0),gel_sortie,condition_gauche) bc_total=[bc_pression,bcV0_haut_bas,bc_obstacle,bc_gel_entree] u,p=TrialFunctions(W) v,q= TestFunctions(W) f=Constant((0.0,0.0)) a= inner(grad(u),grad(v))*dx+1/nu*inner(v,grad(p))*dx+1/nu*q*div(u)*dx l=1/nu*inner(f,v)*dx u=Function(W) solve(a==l,u,bc_total) u_f=u.split()[0] p=u.split()[1] plot(u_f,title="vitesse",scale=2) ``` Dans le cas avec un dépôt solide de taille variable( composante aléatoire ici ou on fait varier la position et donc la taille du dépôt solide), on remarque la perturbation de notre écoulement et des vecteurs vitesses qui partent dans une direction " non colinéaire" à l'écoulement (je vous conseille de lancer le code plusieurs fois afin de voir les changements liés à la taille du dépôt solide). Le comportement de notre fluide a donc été perturbé et ceci peut expliquer la projection de fluide dans des directions non souhaitées. On pourrait ensuite s'intéresser dans un autre projet à la force exercée sur ce dépôt solide et à son évolution au fur et à mesure des utilisations ( evacuation de ce dernier peut être) et donc déterminer le moment où l'écoulement redevient "normal" c'est à dire sans projection. Pour avoir fait l'expérience de mon côté, le dépot solide s'évacuait avec environ 5 utilisations de gel hydroalcoolique(Ce gel ne fut pas gâché pour l'expérience). De plus un début de dépôt solide pouvait être observé dans ma bouteille en environ 3h30. Evidemment toutes ces données peuvent varier en fonction du type de gel, sa composition, les conditions de température et de pression et la force exercée sur la bouteille pour faire sortir le gel. ### Bibliographie: https://fr.wikipedia.org/wiki/Écoulement_de_Stokes http://www.iecl.univ-lorraine.fr/~Jean-Francois.Scheid/Enseignement/polyNS2017_18.pdf https://courses.ex-machina.ma/downloads/gm-2/s7/M_E_F/EFM_Stokes.pdf https://fenicsproject.org/olddocs/dolfin/1.3.0/python/demo/documented/stokes-iterative/python/documentation.html ```python ```

56c77bcb1f87164f79a3342d3d02b6eb0ab7e820

ipynb

Jupyter Notebook

PJT_EDP_Briet.ipynb

MatthBriet/Projet_EDP

3628d18a8357a01b58c879b1adfbcdcee9e2764d

PJT_EDP_Briet.ipynb

MatthBriet/Projet_EDP

3628d18a8357a01b58c879b1adfbcdcee9e2764d

PJT_EDP_Briet.ipynb

MatthBriet/Projet_EDP

3628d18a8357a01b58c879b1adfbcdcee9e2764d

Qwen/Qwen-72B

1. YES 2. YES

__label__fra_Latn

# Derivación numérica Aunque la derivada de una función se puede obtener algorítmicamente de manera analítica, los algoritmos numéricos que usemos pueden depender de muchas derivadas o no pueden acceder a otra cosa más que la función original. Así, comúnmente utilizaremos una aproximación numérica de la derivada en lugar de el valor real. ## Preludio matemático: series de Taylor Sea $f:\mathbb{R} \to \mathbb{R}$ diferenciable $k$ veces en un punto $a$. Entonces : $$ f(x) = f(a) + f'(a)(x-a)+ \frac{f''(a)}{2!} (x-a)^2 + \ldots + \frac{f^{(k)}(a)}{k!}(x-a)^k + R_{k}(x) $$ Y $R_{k}(x)$ cumple que \begin{equation} \lim_{x\to a} \frac{R_{k}(x)}{(x-a)^k} = 0 \quad \left( R_k(x) \sim (x-a)^{k+1}\right) \label{eq1} \end{equation} En forma aproximada, se cumple que: $$ f(x) \approx f(a) + f'(a)(x-a)+ \frac{f''(a)}{2!} (x-a)^2 + \ldots + \frac{f^{(k)}(a)}{k!}(x-a)^k $$ ### Forma explícita de $R_k(x)$ Utilizando el teorema del punto medio, podemos expresar a $R_k(x)$ como $$ R_k(x) = \frac{f^{(k+1)}(\xi)}{(k+1)!} (x-a)^{k+1} $$ Con $\xi$ un número real **fijo** entre $x$ y $a$. Con esta expresión, es claro que se la condición de $\lim_{x\to a} \frac{R_{k}(x)}{(x-a)^k} = 0 $ se cumple. ### Reescribir el teorema: Sustitución: $x-a = h \implies x = a+h$ $$ f(a+h) = f(a) + f'(a)(h)+ \frac{f''(a)}{2!} (h)^2 + \ldots + \frac{f^{(k)}(a)}{k!}(h)^k + R_{k}(a+h) $$ Y $R_{k}(a+h)$ cumple que $$ \lim_{h\to 0} \frac{R_{k}(a+h)}{h^k} = 0 \quad \left( R_k(a+h) \sim h^{k+1}\right) $$ ## ¿Cómo aproximar la derivada? $$ f'(a) = \lim_{h\to 0 } \frac{f(a+h) - f(a)}{h} $$ **No podemos hacer limites en la computadora**. ¿Qué hacemos? Fijamos un valor de $h$ muy pequeño y aproximamos el valor. Una aproximación de **diferencias finitas** ## Preludio computacional: funciones como objetos Aunque en clases pasadas hemos entendido a las funciones como un objeto abstracto, podemos tratarlas como un objeto con un tipo definido arbitrario. Por ahora no podemos explicar profundamente cuál es el tipo de una función, así que solo procederemos a utilizarlas como un objeto: asignar una función a una variable, dársela a otra función como argumento, etc. ```julia # ejemplo de asignación function f(x) return sin(3*x^2) end ``` f (generic function with 1 method) ```julia println(f(45)) # asigno a la variable `g` la función representada por `f` g = f # `g` me imprime el mismo valor que `f` al evaluarla println(g(45)) ``` -0.7447712875753175 -0.7447712875753175 ```julia # ejemplo de utilizar una función como argumento de otra función function evaluarEn3(func) return func(3) end ``` evaluarEn3 (generic function with 1 method) ```julia println(evaluarEn3(sin)) println(sin(3)) ``` 0.1411200080598672 0.1411200080598672 ```julia println(evaluarEn3(exp)) println(exp(3)) ``` 20.085536923187668 20.085536923187668 ## Funciones unidimensionales ### Primera aproximación: diferencia hacia adelante (forward difference) Sea $h > 0$, $h << a$ $$ f(a+h) = f(a) + f'(a)h + R_{1}(a+h) $$ Despejo la derivada: $$ f'(a) = \frac{f(a+h)-f(a)}{h} - \frac{R_{1}(a+h)}{h} \approx \frac{f(a+h)-f(a)}{h} $$ $$ \lim_{h \to 0} \frac{R_1(a+h)}{h} = 0 $$ Notemos que el error absoluto de nuestra aproximación ($f'(a) - \frac{f(a+h) - f(a)}{h}$) está dado por el término $ \frac{R_1 (a+h)}{h}$, el cuál sabemos que es proporcional a $h$ (ya que $R_1(a+h) \sim h^2$) ## Notación: En la clase de complejidad, introducimos la notación $\mathcal{O}(f(n))$ para decir que la complejidad temporal o espacial de un algoritmo está acotada superiormente por una función de la forma $C \cdot f(n)$. En **análisis numérico**, esa misma notación se utiliza para los errores numéricos. En el caso de la diferencia hacia adelante, por la forma del error absoluto, sabemos que este es $\mathcal{O}(h)$ En general, cuando el **error de aproximación** es proporcional a $h^p$, decimos que nuestro algoritmo numérico es de clase $\mathcal{O}(h^p)$ Pueden consultar más información sobre estas notaciones [en este link](https://courses.engr.illinois.edu/cs357/fa2019/references/ref-2-error/) ```julia using Plots ``` ```julia function primera(x) return sin(2*pi*x) end ``` primera (generic function with 1 method) ```julia xs = range(0,stop=1,length=100) ys = [primera(x) for x in xs] plot(xs,ys,title="funcion a derivar") ``` Quiero implementar la aproximación $$ f'(a) = \frac{f(a+h) - f(a)}{h} $$ ```julia # esta función me calcula la derivada de f en un punto a usando la diferencia hacia adelante con un valor de h function difAdelante(f,a,h) return (f(a+h) - f(a)) / h end ``` difAdelante (generic function with 1 method) Sabemos que $$ primera'(x) = (\sin{2\pi x})' = 2 \pi \cos{2 \pi x} $$ Podemos comparar el resultado numérico con el analítico ```julia # derivada analítica de la funcion `primera` function dprimera(x) return 2*pi*cos(2*pi*x) end ``` dprimera (generic function with 1 method) ```julia println(difAdelante(primera,0,0.01)) println(dprimera(0)) # ver el error absoluto println(abs(dprimera(0)-difAdelante(primera,0,0.01))) ``` 6.279051952931337 6.283185307179586 0.004133354248248899 ```julia # cambiando el valor de $h$ la aproximación cambia h = 0.001 println(difAdelante(primera,0,h)) println(dprimera(0)) # ver el error absoluto println(abs(dprimera(0)-difAdelante(primera,0,h))) ``` 6.283143965558951 6.283185307179586 4.134162063529345e-5 ```julia # ver la derivada como función xs = range(0,stop=1,length=101) ys1 = [dprimera(x) for x in xs] h = 0.001 ys2 = [difAdelante(primera,x,h) for x in xs] plot(xs,ys1,label="Valor analítico",title="Derivada") plot!(xs,ys2,label="Diferencia hacia adelante") ``` ## Ejercicios 1. Realiza una gráfica en la que compares la derivada analítica de la función $f(x) = \sin{x} \cdot \cos{x}$ con la obtenida por diferencia hacia adelante. Toma como dominio el intervalo $[-\pi,\pi]$ 2. Para la función del inciso anterior, fija un valor de $x$, y gráfica, el error absoluto entre la derivada analítica y la numérica como función de $h$ ¿Qué observas? ¿Es lo esperado? Utiliza la escala log-log si es necesario. #### ¿Qué otras aproximaciones hay? ### Segunda aproximación: diferencia hacia atrás (backwards difference) Sea $h > 0$, $h << a$ $$ f(a-h) = f(a) + f'(a)(-h) + R_{1}(a-h) $$ Despejo la derivada: $$ f'(a) = \frac{f(a-h)-f(a)}{-h} - \frac{R_{1}(a-h)}{-h} = \frac{f(a)-f(a-h)}{h} + \frac{R_{1}(a-h)}{h} $$ Obtenemos entonces: $$ f'(a) \approx \frac{f(a)-f(a-h)}{h} $$ $$ \lim_{h \to 0} \frac{R_1(a-h)}{h} = 0 $$ ## Ejercicios 3. Define una función llamada `diferenciaAtras(f,a,h)` que aproxime la derivada de $f$ en a, $f'(a)$, utilizando una diferencia hacia atras de orden $h$ ### Tercera aproximación: diferencia centrada (central difference) Primero expandimos $f(a+h)$ y $f(a-h)$ en polinomio de taylor de orden 2: $$ f(a+h) = f(a) + f'(a) h + \frac{f''(a)}{2!} h^2 + R_2 (a+h) $$ $$ \begin{split} f(a-h) &= f(a) + f'(a)(- h) + \frac{f''(a)}{2!} (-h)^2 + R_2 (a-h) \\ &= f(a) - f'(a)h + \frac{f''(a)}{2!} h^2 + R_2 (a-h) \end{split} $$ Podemos restar ambas aproximaciones: $$ \begin{split} f(a+h) - f(a-h) &= (f(a) - f(a)) + (f'(a)h - (-f'(a) h)) + (\frac{f''(a)}{2!} h^2 - \frac{f''(a)}{2!} h^2) + (R_2(a+h) - R_2(a-h)) \\ &= 2 f'(a) h + (R_2(a+h) - R_2(a-h)) \end{split} $$ Despejo la derivada: $$ f'(a) = \frac{f(a+h) - f(a-h)}{2h} - \frac{R_2(a+h) - R_2(a-h)}{2h} \approx \frac{f(a+h) - f(a-h)}{2h} $$ $$ \lim_{h \to 0} \frac{R_2(a+h) - R_2(a-h)}{2h} = 0 $$ ## Ejercicios: 4. Define una función llamada `diferenciaCentrada(f,a,h)` que aproxime la derivada de $f$ en a, $f'(a)$, utilizando una diferencia centrada de orden $h$ Para las siguientes funciones, realiza dos gráficas: una en la que compares las derivadas obtenidas analíticamente, con diferencia hacia adelante, diferencia hacia atrás y diferencia centrada, Y otra gráfica en la que analices el error absoluto como función de $h$ para un punto fijo. Puedes escoger el dominio de la primera gráfica 5. $f_1(x) = 10x^2 + 6x - 1$ 6. $f_2(x) = \sin{\left( \cos{(6x+2)} \right)}$ 7. $f_3(x) = 2^{x \cdot \sin{x}}$ ```julia function ejer7(x) return 2^(x*sin(x)) end ``` ```julia using Plots ``` ```julia function difCentrada(f,a,h) return (f(a+h) - f(a-h))/(2*h) end ``` ## Derivadas de orden superior Podemos seguir el mismo esquema para obtener aproximaciones de las derivadas de orden más grande. Esto no es un proceso simple, pero para orden 2 podemos hacerlo de manera muy sencilla. ## Ejercicios 8. Suma las expansiones en serie de taylor a orden 2 de $f(a+h)$ y $f(a-h) $ para obtener una expresión para la segunda derivada $f''(a)$. ¿Cuál es su error de aproximación? 9. Comprueba el error de aproximación obtenido al analizar el error absoluto en la segunda derivada de la función $\sin{(6x^2+1)}$ en un punto fijo del intervalo $[1,3]$ ## Funciones multidimensionales Podemos también utilizar diferencias finitas para aproximar las derivadas parciales de una función $f:\mathbb{R^n} \to \mathbb{R}$. Hacer expresiones de las derivadas de orden superior se vuelve complicado ya que hay que hacer expansiones de Taylor multidimensionales, pero para las primeras derivadas parciales basta recordar la definición $$ \frac{\partial f}{\partial x_k} (a_1, \ldots, a_n) = \lim_{h \to 0} \frac{f(a_1, \ldots, a_k + h, \ldots, a_n) - f(a_1, \ldots, a_k, \ldots, a_n)}{h} $$ ## Ejercicios 10. Define una función `devParcial(f,i,A,h)`, donde $f:\mathbb{R^n} \to \mathbb{R}$ es una función multivariada, que toma como argumento un solo arreglo, $A$ es un arreglo de longitud $n$ e $1\leq i \leq n$ es un natural, que te regrese la derivdad parcial $\frac{\partial f}{\partial x_i} (A)$. Pruebala con alguna función de tu elección. 11. Sea $g:\mathbb{R}^2 \to \mathbb{R}$, obtén una expresión de diferencias finitas para la derivada curzada $\frac{\partial^2 g}{\partial x \partial y}$. ¿Cuál es el orden de su error? ## La visión general: Existe una manera de derivar aproximaciones de diferencias finitas arbitrarias que sean $\mathcal{O}(h^p)$ para el $p \in \mathbb{N}$ que yo quiera. Ese método escapa al alcance del curso, pero lo pueden consultar en el libro de LeVeque. Existe también una manera de calcular las derivadas de manera exacta, llamada **diferenciación automática**. No veremos ese tema pues requiere de conocimientos más avanzados de programación. ```julia ```

61cfdfccc40c472872d5105808fbd9a2e5b1bb82

ipynb

Jupyter Notebook

files/fiscomp_2020-4/material/clase06.ipynb

sayeg84/sayeg84.github.io

18f2e36dd7252603fad8f7093dc5aa00fc721be4

files/fiscomp_2020-4/material/clase06.ipynb

sayeg84/sayeg84.github.io

18f2e36dd7252603fad8f7093dc5aa00fc721be4

files/fiscomp_2020-4/material/clase06.ipynb

sayeg84/sayeg84.github.io

18f2e36dd7252603fad8f7093dc5aa00fc721be4

Qwen/Qwen-72B

1. YES 2. YES

__label__spa_Latn

```python %reset -f ``` ```python from sympy import * ``` ```python init_printing() ``` ## Define variables ```python x,y,z = symbols('x y z') ``` ```python f = sin(x) ``` ## Differentiate ```python diff(f,x) ``` ## Integrate ```python integrate(f, x) ``` ```python integrate(f, [x,0,pi]) ``` ```python ```

84ddd304ab58bf6e24c61f8e59f38a8b7d20ae60

ipynb

Jupyter Notebook

sympy/Untitled.ipynb

krajit/krajit.github.io

221c8bcdf0612b3ae28c827809aa309ea6a7b0c2

2018-09-29T07:40:07.000Z

2022-02-28T22:17:04.000Z

sympy/Untitled.ipynb

krajit/krajit.github.io

221c8bcdf0612b3ae28c827809aa309ea6a7b0c2

2019-08-26T08:42:47.000Z

2019-08-26T09:48:21.000Z

sympy/Untitled.ipynb

krajit/krajit.github.io

221c8bcdf0612b3ae28c827809aa309ea6a7b0c2

2017-09-09T23:32:09.000Z

2020-01-28T21:11:39.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__yue_Hant

# Lecture 4 ## Differentiation II: ### Product, Chain and Quotient Rules ```python import numpy as np import sympy as sp sp.init_printing() ################################################## ##### Matplotlib boilerplate for consistency ##### ################################################## from ipywidgets import interact from ipywidgets import FloatSlider from matplotlib import pyplot as plt %matplotlib inline from IPython.display import set_matplotlib_formats set_matplotlib_formats('svg') global_fig_width = 10 global_fig_height = global_fig_width / 1.61803399 font_size = 12 plt.rcParams['axes.axisbelow'] = True plt.rcParams['axes.edgecolor'] = '0.8' plt.rcParams['axes.grid'] = True plt.rcParams['axes.labelpad'] = 8 plt.rcParams['axes.linewidth'] = 2 plt.rcParams['axes.titlepad'] = 16.0 plt.rcParams['axes.titlesize'] = font_size * 1.4 plt.rcParams['figure.figsize'] = (global_fig_width, global_fig_height) plt.rcParams['font.sans-serif'] = ['Computer Modern Sans Serif', 'DejaVu Sans', 'sans-serif'] plt.rcParams['font.size'] = font_size plt.rcParams['grid.color'] = '0.8' plt.rcParams['grid.linestyle'] = 'dashed' plt.rcParams['grid.linewidth'] = 2 plt.rcParams['lines.dash_capstyle'] = 'round' plt.rcParams['lines.dashed_pattern'] = [1, 4] plt.rcParams['xtick.labelsize'] = font_size plt.rcParams['xtick.major.pad'] = 4 plt.rcParams['xtick.major.size'] = 0 plt.rcParams['ytick.labelsize'] = font_size plt.rcParams['ytick.major.pad'] = 4 plt.rcParams['ytick.major.size'] = 0 ################################################## ``` ## Wake Up Exercise When $y = ax^n$, $y' = a n x^{n-1}$. So find $y'(x)$, when: (a) $y = 6$ (b) $y = x$ (c) $y = 13x -1$ (d) $y = \sqrt{x^7}$ (e) $y = -\frac{2}{x}$ ## Linear approximation and the derivative By definition, the derivative of a function $f(x)$ is $f'(x) = \lim_{h \rightarrow 0} \frac{f(x+h) - f(x)}{h}$ This means that for small $h$, this expression approximates the derivative. By rearranging this, we have $f(x + h) \approx f(x) + h f'(x)$ In other words, $f(x+h)$ can be approximated by starting at $f(x)$ and moving a distance $h$ along the tangent $f'(x)$. ### Example Estimate $\sqrt{5218}$ To do this, we first need an $f(x)$ that is easy to calculate, and close to 5218. For this we can take that $70^2 = 4900$. To calculate the approximation, we need $\;f'(x)\;$, where $\;f(x) = \sqrt{x}\;$. $$f'(x) = \frac{1}{2 \sqrt{x}}$$ $$f'(x) = \frac{1}{2 \sqrt{x}}$$ Since 5218 = 4900 + 318, we can set $x = 4900$ and $h = 318$. Using the approximation, we have: $f(5218) \approx f(4900) + 318 \times f'(4900)$ $f(5218) \approx 70 + 318 \times \frac{1}{140} \approx 72.27$ $\sqrt{5218} = 72.2357252$ - not a bad appriximation! ## Standard derivatives It's useful to know the derivatives of all the standard functions, and some basic rules. $\frac{d}{dx} (x^n) = n x^{n-1}$ $\frac{d}{dx} (\sin x) = \cos x$ $\frac{d}{dx} (\cos x) = -\sin x$ $\frac{d}{dx} (e^x) = e^x$ To understand the derivative of sin and cos, consider their graphs, and when they are changing positively (increasing), negatively (decreasing) or not at all (no rate of change). ```python x = np.linspace(0, 8, 100) y_1 = np.sin(x) y_2 = np.cos(x) plt.plot(x, y_1, label = 'sin(x)') plt.plot(x, y_2, label = 'cos(x)') plt.legend() ``` ## Other Differentiation Rules ## Differentiation of sums, and scalar multiples: $(f(x) \pm g(x))' = f'(x) \pm g'(x)$ $(a f(x))' = a f'(x) $ ## Differentiation of products While differentiating sums, and scalar multiples is straightforward, differentiating products is more complex $(f(x) g(x) )' \neq f'(x) g'(x)$ $(f(x) g(x) )' = f'(x) g(x) + g'(x) f(x)$ ### Example To illustrate that this works, consider $y = (2x^3 - 1)(3x^3 + 2x)$ If we expand this out, we have that $y = 6x^6 + 4x^4 - 3x^3 - 2x$ From this, clearly, $y' = 36 x^5 + 16x^3 - 9 x^2 - 2$ To use the product rule, instead we say $y = f \times g$, where $f = 2x^3 - 1$, and $g = 3x^3 + 2x$. Therefore $f'(x) = 6x^2$ $g'(x) = 9x^2 + 2$ $y' = f'g + g'f = 6x^2 (3x^3 + 2x) + (9x^2 + 2)(2x^3 - 1)$ $y' = 18x^5 + 12x^3 + 18x^5 + 4x^3 - 9x^2 - 2 = 36x^5 + 16x^3 - 9x^2 - 2$ So both rules produce the same result. While for simple examples the product rule requires more work, as functions get more complex it saves a lot of time. ## Differentiating a function of a function - The Chain Rule One of the most useful rules is differentiating a function that has another function inside it $y = f(g(x))$. For this we use the chain rule: $y = f(g(x))$ $y'(x) = f'(g(x))\; g'(x) = \frac{df}{dg} \frac{dg}{dx}$ ### Example 1: $y = (5x^2 + 2)^4$ We can write this as $y = g^4$, where $g = 5x^2 + 2$. Given this, we have that $\frac{dy}{dg} = 4g^3 = 4(5x^2 + 2)^3$ $\frac{dg}{dx} = 10x$ This means that $\frac{dy}{dx} = \frac{dy}{dg} \frac{dg}{dx} = 4 (5x^2 + 2)^3 10 x = 40 x (5x^3 + 2)^3$ This extends infinitely to nested functions, meaning $\frac{d}{dx}(a(b(c)) = \frac{d a}{d b} \frac{d}{dx} (b(c)) = \frac{d a}{db} \frac{d b}{dc}\frac{dc}{dx}$ ## Differentiating the ratio of two functions - The Quotient Rule If $y(x) = \frac{f(x)}{g(x)}$, then by using the product rule, and setting $h(x) = (g(x))^{-1}$, we can show that $y'(x) = \frac{f'g - g'f}{g^2}$ ### Example $y = \frac{3x-1}{4x + 2}$ $f = 3x - 1, \rightarrow f' = 3$ $g = 4x + 2, \rightarrow g' = 4$ $y' = \frac{f'g - g'f}{g^2} = \frac{3(4x+2) - 4(3x-1)}{(4x+2)^2}$ $y' = \frac{12x + 6 - 12 x + 4}{(4x+2)^2} = \frac{10}{(4x+2)^2}$ ## Differentiating inverses - implicit differentiation For any function $y = f(x)$, with a well defined inverse $f^{-1}(x)$ (not to be confused with $(f(x))^{-1})$), we have by definition that $x = f^{-1}(f(x)) = f^{-1}(y)$. This means that we can apply the chain rule $\frac{d}{dx}(x) = \frac{d}{dx}(f^{-1}(y)) = \frac{d}{dy}(f^{-1}(y)) \frac{dy}{dx}$ But since $\frac{d}{dx}(x) = 1$ $\frac{d}{dy}(f^{-1}(y)) = \frac{1}{\frac{dy}{dx}}$ ### Example: $y = ln(x)$ If $y = ln(x)$, this means that $f^{-1}(y) = e^y = x$ By definition ($f^{-1}(y))' = e^y$, as $e^y$ doesn't change under differentiation. This means that $\frac{d}{dx}(ln(x)) = \frac{1}{\frac{d}{dy}(f^{-1}(y))} = \frac{1}{e^y}$ But since $y = ln(x)$: $\frac{d}{dx}(ln(x)) = \frac{1}{e^{ln(x)}} = \frac{1}{x}$ ### Example - Differentiating using sympy. In Python, there is a special package for calculating derivatives symbolically, called sympy. This can quickly and easily calculate derivatives (as well as do all sorts of other analytic calculations). ```python import sympy as sp x = sp.symbols('x') #This creates a variable x, which is symbolically represented as the string x. # Calculate the derivative of x^2 sp.diff(x**2, x) ``` ```python sp.diff(sp.cos(x), x) ``` ```python f = (x+1)**3 * sp.cos(x**2 - 5) sp.diff(f,x) ``` ```python f = (x+1)**3 * (x-2)**2 * (x**2 + 4*x + 1)**4 sp.diff(f, x) ``` ```python sp.expand(sp.diff(f, x)) # expand out in polynomial form ``` You can look at the documentation for Sympy to see many other possibilities (e.g. we will use Sympy to do symbolic integration later on in this course) - https://docs.sympy.org/latest/index.html Try out Sympy to verify your pen & paper answers to the problem sheets

2f0015316c698bbc0b7543c8931e81b185ebc02d

ipynb

Jupyter Notebook

lectures/lecture-04-differentiation-02.ipynb

SABS-R3/2020-essential-maths

5a53d60f1e8fdc04b7bb097ec15800a89f67a047

2021-11-27T12:07:13.000Z

2021-11-27T12:07:13.000Z

lectures/lecture-04-differentiation-02.ipynb

SABS-R3/2021-essential-maths

8a81449928e602b51a4a4172afbcd70a02e468b8

lectures/lecture-04-differentiation-02.ipynb

SABS-R3/2021-essential-maths

8a81449928e602b51a4a4172afbcd70a02e468b8

2020-10-30T17:34:52.000Z

2020-10-30T17:34:52.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Introduction to orthogonal coordinates In $\mathbb{R}^3$, we can think that each point is given by the intersection of three surfaces. Thus, we have three families of curved surfaces that intersect each other at right angles. These surfaces are orthogonal locally, but not (necessarily) globally, and are defined by $$u_1 = f_1(x, y, z)\, ,\quad u_2 = f_2(x, y, z)\, ,\quad u_3=f_3(x, y, z) \, .$$ These functions should be invertible, at least locally, and we can also write $$x = x(u_1, u_2, u_3)\, ,\quad y = y(u_1, u_2, u_3)\, ,\quad z = z(u_1, u_2, u_3)\, ,$$ where $x, y, z$ are the usual Cartesian coordinates. The curve defined by the intersection of two of the surfaces gives us one of the coordinate curves. ## Scale factors Since we are interested in how these surface intersect each other locally, we want to express differential vectors in terms of the coordinates. Thus, the differential for the position vector ($\mathbf{r}$) is given by $$\mathrm{d}\mathbf{r} = \frac{\partial\mathbf{r}}{\partial u_1}\mathrm{d}u_1 + \frac{\partial\mathbf{r}}{\partial u_2}\mathrm{d}u_2 + \frac{\partial\mathbf{r}}{\partial u_3}\mathrm{d}u_3\, , $$ or $$\mathrm{d}\mathbf{r} = \sum_{i=1}^3 \frac{\partial\mathbf{r}}{\partial u_i}\mathrm{d}u_i\, .$$ The factor $\partial \mathbf{r}/\partial u_i$ is a non-unitary vector that takes into account the variation of $\mathbf{r}$ in the direction of $u_i$, and is then tangent to the coordinate curve $u_i$. We can define a normalized basis $\hat{\mathbf{e}}_i$ using $$\frac{\partial\mathbf{r}}{\partial u_i} = h_i \hat{\mathbf{e}}_i\, .$$ The coefficients $h_i$ are functions of $u_i$ and we call them _scale factors_. They are really important since they allow us to _measure_ distances while we move along our coordinates. We would need them to define vector operators in orthogonal coordinates. When the coordinates are not orthogonal we would need to use the [metric tensor](https://en.wikipedia.org/wiki/Metric_tensor), but we are going to restrict ourselves to orthogonal systems. Hence, we have the following $$\begin{align} &h_i = \left|\frac{\partial\mathbf{r}}{\partial u_i}\right|\, ,\\ &\hat{\mathbf{e}}_i = \frac{1}{h_i} \frac{\partial \mathbf{r}}{\partial u_i}\, . \end{align}$$ ## Curvilinear coordinates available The following coordinate systems are available: - Cartesian; - Cylindrical; - Spherical; - Parabolic cylindrical; - Parabolic; - Paraboloidal; - Elliptic cylindrical; - Oblate spheroidal; - Prolate spheroidal; - Ellipsoidal; - Bipolar cylindrical; - Toroidal; - Bispherical; and - Conical. To obtain the transformation for a given coordinate system we can use the function `transform_coords` in the `vector` module. ```python import sympy as sym from continuum_mechanics import vector ``` First, we define the variables for the coordinates $(u, v, w)$. ```python sym.init_printing() u, v, w = sym.symbols("u v w") ``` And, we compute the coordinates for the **parabolic** system using ``transform_coords``. The first parameter is a string defining the coordinate system and the second is a tuple with the coordinates. ```python vector.transform_coords("parabolic", (u, v, w)) ``` The scale factors for the coordinate systems mentioned above are availabe. We can compute them for bipolar cylindrical coordinates. The coordinates are defined by $$\begin{align} &x = a \frac{\sinh\tau}{\cosh\tau - \cos\sigma}\, ,\\ &y = a \frac{\sin\sigma}{\cosh\tau - \cos\sigma}\, ,\\ &z = z\, , \end{align}$$ and have the following scale factors $$h_\sigma = h_\tau = \frac{a}{\cosh\tau - \cos\sigma}\, ,$$ and $h_z = 1$. ```python sigma, tau, z, a = sym.symbols("sigma tau z a") z = sym.symbols("z") scale = vector.scale_coeff_coords("bipolar_cylindrical", (sigma, tau, z), a=a) scale ``` Finally, we can compute vector operators for different coordinates. The Laplace operator for the bipolar cylindrical system is given by $$ \nabla^2 \phi = \frac{1}{a^2} \left( \cosh \tau - \cos\sigma \right)^{2} \left( \frac{\partial^2 \phi}{\partial \sigma^2} + \frac{\partial^2 \phi}{\partial \tau^2} \right) + \frac{\partial^2 \phi}{\partial z^2}\, ,$$ and we can compute it using the function ``lap``. For this function, the first parameter is the expression that we want to compute the Laplacian for, the second parameter is a tuple with the coordinates and the third parameter is a tuple with the scale factors. ```python phi = sym.symbols("phi", cls=sym.Function) lap = vector.lap(phi(sigma, tau, z), coords=(sigma, tau, z), h_vec=scale) sym.simplify(lap) ```

37ad4501c97e4936a62f91748c39070b383beb66

ipynb

Jupyter Notebook

docs/tutorials/curvilinear_coordinates.ipynb

nicoguaro/continuum_mechanics

f8149b69b8461784f6ed721294cd1a49ffdfa3d7

2018-12-09T15:02:51.000Z

2022-02-16T09:28:38.000Z

docs/tutorials/curvilinear_coordinates.ipynb

nicoguaro/continuum_mechanics

f8149b69b8461784f6ed721294cd1a49ffdfa3d7

2019-05-06T16:31:50.000Z

2022-03-31T21:21:03.000Z

docs/tutorials/curvilinear_coordinates.ipynb

nicoguaro/continuum_mechanics

f8149b69b8461784f6ed721294cd1a49ffdfa3d7

2020-01-29T10:03:52.000Z

2022-02-25T19:34:37.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

## 1. A Numerical Solution to The Heat Equation *By Parnian Kassraie* *** *** *For solving this problem you don't need to know anything outside the course's syllabus. But if you are interested and you haven't passed Engineering Mathematics yet, you can read about the Heat Equation from [here.](https://en.wikipedia.org/wiki/Heat_equation)* ```latex %%latex \begin{equation} \frac{\partial^{2} T}{\partial x^{2}}+\frac{\partial^{2} T}{\partial y^{2}}=0 \\ x,y\in[0,10] \\ T(x,10)=100,\space T(x,0)=T(0,y)=T(10,y)=0 \\ \end{equation} ``` \begin{equation} \frac{\partial^{2} T}{\partial x^{2}}+\frac{\partial^{2} T}{\partial y^{2}}=0 \\ x,y\in[0,10] \\ T(x,10)=100,\space T(x,0)=T(0,y)=T(10,y)=0 \\ \end{equation} In this problem, we want to solve the heat equation for a square metal plate. As stated above, the edges are kept at constant tempretures and we are solving the problem in the steady state. ### 1.1 Discretizing the Equation *** We have to choose a finite number of points inside the metal square and calculate the tempreture for each of these points. In other words, we break the continues intervals, $x,y\in[0,10]$ and set $x,y$ to be : $$x=n\Delta x, \space y = m \Delta y: \space \space n,m\in \mathbb{N},\space \text{and} \space n,m \leq K$$ * a) Set $\Delta x, \Delta y$. ```python Deltax = Deltay = ``` * b) Write the heat equation for discrete coordinates. ```latex %%latex \begin{equation} .... \end{equation} ``` * c) We define $T_i,_j = T(x_i,y_j)$ Where $x_i = i\Delta x,\space y_j=j\Delta y$. Write $T_i,_j$ using only: $ T_{i+1,j}, T_{i-1,j},T_{i,j+1},T_{i,j-1}$ ```latex %%latex \begin{equation} .... \end{equation} ``` ### 1.2 Solving The Discrete Equation *** * a) We should choose an intial value for each of the points to solve the equation iteratively. Wisely choose constant value for all the points inside the metal square! ```python T0 = ``` * b) State why you chose the value above. (Bonus point for wiser choices) * c) Using what you have calculated, write a program that solves the given PDE. ```python # Import Packages: #Initialize the rest of the variables: # Write the iterative code that solves the equation: ``` ### 1.3 Ploting The Results --- * a) Plot the steady state solution using a heatmap. Your result should look like [this](https://github.com/svarthafnyra/Numercial-Methods-for-Understanding-Stock-Market/blob/master/untitled.png), with a higher resolution of course. ```python ```

4854c52a575babc8fd894768ba2f71d8d0876844

ipynb

Jupyter Notebook

PyHW.ipynb

svarthafnyra/Fun-with-Data

3a7b49f49f1e7aad6587bdac47b6bb315b54dc20

PyHW.ipynb

svarthafnyra/Fun-with-Data

3a7b49f49f1e7aad6587bdac47b6bb315b54dc20

PyHW.ipynb

svarthafnyra/Fun-with-Data

3a7b49f49f1e7aad6587bdac47b6bb315b54dc20

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python import numpy as np from scipy.integrate import odeint import numpy as np from sympy import symbols,sqrt,sech,Rational,lambdify,Matrix,exp,cosh,cse,simplify,cos,sin from sympy.vector import CoordSysCartesian from theano.scalar.basic_sympy import SymPyCCode from theano import function from theano.scalar import floats from IRI import * from Symbolic import * from ENUFrame import ENU import astropy.coordinates as ac import astropy.units as au import astropy.time as at class Fermat(object): def __init__(self,nFunc=None,neFunc=None,frequency = 120e6, type = 'r'): self.frequency = frequency#Hz self.type = type if nFunc is not None: self.nFunc = nFunc self.neFunc = self.n2ne(nFunc) self.eulerLambda, self.jacLambda = self.generateEulerEqnsSym(self.nFunc) return if neFunc is not None: self.neFunc = neFunc self.nFunc = self.ne2n(neFunc) self.eulerLambda, self.jacLambda = self.generateEulerEqnsSym(self.nFunc) return def ne2n(self,neFunc): '''Analytically turn electron density to refractive index. Assume ne in m^-3''' self.neFunc = neFunc #wp = 5.63e4*np.sqrt(ne/1e6)/2pi#Hz^2 m^3 lightman p 226 fp2 = 8.980**2 * neFunc self.nFunc = sqrt(Rational(1) - fp2/self.frequency**2) return self.nFunc def n2ne(self,nFunc): """Get electron density in m^-3 from refractive index""" self.nFunc = nFunc self.neFunc = (Rational(1) - nFunc**2)*self.frequency**2/8.980**2 return self.neFunc def euler(self,pr,ptheta,pphi,r,theta,phi,s): N = np.size(pr) euler = np.zeros([7,N]) i = 0 while i < 7: euler[i,:] = self.eulerLambda[i](pr,ptheta,pphi,r,theta,phi,s) i += 1 return euler def eulerODE(self,y,r): '''return prdot,pphidot,pthetadot,rdot,phidot,thetadot,sdot''' e = self.euler(y[0],y[1],y[2],y[3],y[4],z,y[5]).flatten() return e def jac(self,pr,ptheta,pphi,r,theta,phi,s): N = np.size(px) jac = np.zeros([7,7,N]) i = 0 while i < 7: j = 0 while j < 7: jac[i,j,:] = self.jacLambda[i][j](pr,pphi,ptheta,r,phi,theta,s) j += 1 i += 1 return jac def jacODE(self,y,z): '''return d ydot / d y''' j = self.jac(y[0],y[1],y[2],y[3],y[4],z,y[5]).reshape([7,7]) #print('J:',j) return j def generateEulerEqnsSym(self,nFunc=None): '''Generate function with call signature f(t,y,*args) and accompanying jacobian jac(t,y,*args), jac[i,j] = d f[i] / d y[j]''' if nFunc is None: nFunc = self.nFunc r,phi,theta,pr,pphi,ptheta,s = symbols('r phi theta pr pphi ptheta s') if self.type == 'r': sdot = sqrt(Rational(1) + (ptheta / r / pr)**Rational(2) + (pphi / r / sin(theta) / pr)**Rational(2)) prdot = nFunc.diff('r')*sdot + nFunc/sdot * ((ptheta/r/pr)**Rational(2)/r + (pphi/r /sin(theta)/pr)**Rational(2)/r) pthetadot = nFunc.diff('theta')*sdot + nFunc/sdot * cos(theta) /sin(theta) *(pphi/r/sin(theta))**Rational(2) pphidot = nFunc.diff('phi')*sdot rdot = Rational(1) thetadot = ptheta/pr/r**Rational(2) phidot = pphi/pr/(r*sin(theta))**Rational(2) if self.type == 's': sdot = Rational(1) prdot = nFunc.diff('r') + (ptheta**Rational(2) + (pphi/sin(theta))**Rational(2))/nFunc/r**Rational(3) pthetadot = nFunc.diff('theta') + cos(theta) / sin(theta)**Rational(3) * (pphi/r)**Rational(2)/nFunc pphidot = nFunc.diff('phi') rdot = pr/nFunc thetadot = ptheta/nFunc/r**Rational(2) phidot = pphi/nFunc/(r*sin(theta))**Rational(2) eulerEqns = (prdot,pthetadot,pphidot,rdot,thetadot,phidot,sdot) euler = [lambdify((pr,ptheta,pphi,r,theta,phi,s),eqn,"numpy") for eqn in eulerEqns] self.eulerLambda = euler jac = [] for eqn in eulerEqns: #print([eqn.diff(var) for var in (px,py,pz,x,y,z,s)]) jac.append([lambdify((pr,ptheta,pphi,r,theta,phi,s),eqn.diff(var),"numpy") for var in (pr,ptheta,pphi,r,theta,phi,s)]) self.jacLambda = jac return self.eulerLambda, self.jacLambda def integrateRay(self,x0,direction,tmax,N=100): '''Integrate rays from x0 in initial direction where coordinates are (r,theta,phi)''' direction /= np.linalg.norm(direction) r0,theta0,phi0 = x0 rdot0,thetadot0,phi0 = direction sdot = np.sqrt(rdot**2 + r0**2 * (thetadot0**2 + np.sin(theta0)**2 * phidot0**2)) pr0 = rdot/sdot ptheta0 = r0**2 * thetadot/sdot pphi0 = (r0 * np.sin(theta0))**2/sdot * phidot init = [pr0,ptheta0,pphi0,r0,theta0,phi0,0] if self.type == 'r': tarray = np.linspace(r0,tmax,N) if self.type == 's': tarray = np.linspace(0,tmax,N) #print("Integrating from {0} in direction {1} until {2}".format(x0,direction,tmax)) Y,info = odeint(self.eulerODE, init, tarray, Dfun = self.jacODE, col_deriv = 0, full_output=1) r = Y[:,3] theta = Y[:,4] phi = Y[:,5] s = Y[:,6] return r,theta,phi,s def testSweep(): import pylab as plt x,y,z = symbols('x y z') sol = SolitonModel(4) sol.generateSolitonModel() neFunc = sol.solitonModel f = Fermat(neFunc = neFunc) n = f.nFunc theta = np.linspace(-np.pi/4.,np.pi/4.,5) rays = [] for t in theta: origin = ac.SkyCoord(0*au.km,0*au.km,0*au.km,frame=sol.enu).transform_to('itrs').cartesian.xyz.to(au.km).value direction = ac.SkyCoord(np.cos(t+np.pi/2.),0,np.sin(t+np.pi/2.),frame=sol.enu).transform_to('itrs').cartesian.xyz.value x,y,z,s = integrateRay(origin,direction,f,origin[2],7000) rays.append({'x':x,'y':y,'z':z}) #plt.plot(x,z) plotFuncCube(n.subs({'t':0}), *getSolitonCube(sol),rays=rays) #plt.show() def testSmoothify(): octTree = OctTree([0,0,500],dx=100,dy=100,dz=1000) octTree = subDivide(octTree) octTree = subDivide(octTree) s = SmoothVoxel(octTree) model = s.smoothifyOctTree() plotCube(model ,-50.,50.,-50.,50.,0.,1000.,N=128,dx=None,dy=None,dz=None) if __name__=='__main__': #testSquare() testSweep() #testSmoothify() #testcseLam() ``` ```python ```

d9812952884bd5d32fb2e44880e5d20c760d9d61

ipynb

Jupyter Notebook

src/ionotomo/notebooks/FermatPrincipleSpherical.ipynb

Joshuaalbert/IonoTomo

9f50fbac698d43a824dd098d76dce93504c7b879

2017-06-22T08:47:07.000Z

2021-07-01T12:33:02.000Z

src/ionotomo/notebooks/FermatPrincipleSpherical.ipynb

Joshuaalbert/IonoTomo

9f50fbac698d43a824dd098d76dce93504c7b879

2019-04-03T15:21:19.000Z

2019-04-03T15:48:31.000Z

src/ionotomo/notebooks/FermatPrincipleSpherical.ipynb

Joshuaalbert/IonoTomo

9f50fbac698d43a824dd098d76dce93504c7b879

2020-03-01T16:20:00.000Z

2020-07-07T15:09:02.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__kor_Hang

# Tutorial rápido de Python para Matemáticos &copy; Ricardo Miranda Martins, 2022 - http://www.ime.unicamp.br/~rmiranda/ ## Índice 1. [Introdução](1-intro.html) 2. [Python é uma boa calculadora!](2-calculadora.html) [(código fonte)](2-calculadora.ipynb) 3. [Resolvendo equações](3-resolvendo-eqs.html) [(código fonte)](3-resolvendo-eqs.ipynb) 4. [Gráficos](4-graficos.html) [(código fonte)](4-graficos.ipynb) 5. [Sistemas lineares e matrizes](5-lineares-e-matrizes.html) [(código fonte)](5-lineares-e-matrizes.ipynb) 6. **[Limites, derivadas e integrais](6-limites-derivadas-integrais.html)** [(código fonte)](6-limites-derivadas-integrais.ipynb) 7. [Equações diferenciais](7-equacoes-diferenciais.html) [(código fonte)](7-equacoes-diferenciais.ipynb) # Limites Conhece aquela famosa piadinha? "Tudo tem limites, menos $1/x$ com $x\rightarrow 0$." Matemáticos tem um senso de humor bem peculiar. O Python sabe muito bem trabalhar com limites, graças ao pacote SymPy. Não é nada recomendável calcular limites fazendo "tabelinhas" ou "aproximações", então o pacote de cálculo simbólico é o ideal. Para calcular $$\lim_{x\rightarrow a} f(x)$$ o comando é ```sp.limit(f,x,a)```. A variável $x$ precisa anter ser definida. ```python import sympy as sp x = sp.symbols('x') sp.limit(x**2,x,2) ``` Bom, não vamos ficar usando o Python para calcular limites que sabemos calcular de cabeça, só substituindo os valores né? Vamos a alguns mais complicados. Por exemplo, que tal calcular $$\lim_{x\rightarrow 0} \dfrac{\sin(x)}{x}?$$ ```python sp.limit(sp.sin(x)/x,x,0) ``` Isso significa que as funções $f(x)=\sin(x)$ e $g(x)=x$ são muito parecidas, para valores pequenos de $x$. Vamos fazer um gráfico para conferir isso: ```python import numpy as np import matplotlib.pyplot as plt x = np.linspace(-0.5, 0.5, 100) y = np.sin(x) plt.plot(x, y) plt.plot(x, x) ``` E os limites que não existem? Também podem ser calculados! ```python import sympy as sp x = sp.symbols('x') sp.limit(1/(x-2),x,2) ``` Podemos calcular também limites com $x\rightarrow\infty$. No SymPy, o símbolo para infinito é ```oo```, lembrando do prefixo ```sp```. Sugestivo, não? ```python sp.limit(1/x,x,sp.oo) ``` Podemos ainda calcular limites laterais no Python, usando os símboos ```+``` ou ```-``` no comando. ```python sp.limit(1/x, x, 0, '+') ``` ```python sp.limit(1/x, x, 0, '-') ``` Já vamos começar a falar sobre derivadas, mas podemos calculá-las pela definição, usando limites. Abaixo faremos um exemplo disso. ```python import sympy as sp x, h = sp.symbols('x h', real=True) f=x**2 fh=f.subs(x,x+h) sp.limit( (fh-f)/h , h, 0) ``` O Python trabalha muito bem com funções definidas por partes. Abaixo fazemos um exemplo disso. ```python import sympy as sp x = sp.symbols('x', real=True) g=sp.Piecewise((x**2+1, x<1),(3*x, x>1)) ``` ```python sp.limit(g,x,1,'-') ``` ```python sp.limit(g,x,1,'+') ``` Aviso importante: o Python não é muito bom com funções definidas por partes, tome cuidado com os resultados. # Derivadas Se você já fez um curso de cálculo, deve ter percebido que derivação é um processo extremamente mecânico. Não é difícil implementar um "derivador formal". O Python calcula derivadas de funções de uma ou mais variáveis de forma muito eficiente. Novamente vamos usar o SymPy. Sem mais delongas vamos calcular a derivada de $f(x)=x^2+x$ com respeito à função $x$. ```python import sympy as sp x = sp.symbols('x') f=x**2+x sp.diff(f,x) ``` Foi rápido, né? A função pode ser muito mais complicada, como por exemplo $g(x)=e^{x^3+x}+1/x$. ```python g=sp.exp(x**3+x)+1/x sp.diff(g,x) ``` As funções podem ser de mais que uma variável: ```python y = sp.symbols('y') h=sp.cos(x*y)+(3*x+y)/(y**2+1) ``` ```python # derivada em x sp.diff(h,x) ``` ```python # derivada em y sp.diff(h,x) ``` ```python # derivada mista, em x depois em y sp.diff(h,x,y) ``` Claro que as derivadas de ordem superior também podem ser pedidas de forma iterada: ```python sp.diff(sp.diff(h,x),y) ``` Para derivadas de ordem superior, também é fácil. Abaixo calculamos a derivada de terceira ordem de $h(x,y)$ com respeito a $x$ ```python sp.diff(h,x,x,x) ``` Se você quer a derivada em um ponto, pode usar o ```subs``` para avaliar a derivada nesse ponto: ```python sp.diff(h,x).subs(x,0).subs(y,0) ``` Claro que a função precisa estar definida no ponto, ou coisas podem dar errado.. ```python sp.diff(g,x).subs(x,0).subs(y,0) ``` ## Expansão em séries Uma importante aplicação das derivadas é o cálculo da expansão em série de Taylor. O SymPy tem dois comandos para isso, o ```fps``` e o ```series```. Vamos testá-los com a função $f(x)=x\cos(x)$. ```python import sympy as sp x = sp.symbols('x') f=x*sp.cos(x) ``` ```python # calculando a expansao formal de f em serie de potencias # com respeito aa variavel x, no ponto x=0, e truncando # em ordem 10 usando o fps fn=sp.fps(f,x,0).truncate(10) display(fn) ``` ```python # o comando series tambem funciona: a sintaxe é # series(f(x),x,x0,k), onde x0 fm=sp.series(f,x,0,20).as_expr() display(fm) ``` Se você não está ligando o nome à pessoa, uma aplicação interessante das séries de potências de uma função é poder calcular aproximações de valores de uma função $f(x)$ que não permite cálculos "diretos". Por exemplo, não sabemos calcular diretamente $e^2$, mas usando a série da exponencial, podemos aproximar esse valor tão bem quanto quisermos. Vamos usar o sufixo ```removeO``` para remover da série de Taylor a parte que tem os termos em $O(n)$. ```python import sympy as sp x = sp.symbols('x') g = sp.exp(x) gk = sp.series(g,x,0,10).removeO() gk.subs(x,2) ``` Portanto, $20947/2835$ é uma boa aproximação racional para $e^2$. Bom, o que estamos fazendo é uma coisa totalmente sem propósito, já que estamos fazendo isso no computador e um simples comando poderia calcular. Mas é aquele famoso "toy problem". Só por curiosidade, note que: ```python 20947//2835 ``` Portanto, $e^2$ está perto de 7. Como bônus, se você decorar a série abaixo, poderá tirar aquela onda no churrasco do fim de ano e calcular aproximações para $e^x$ para valores de $x$ próximos de $0$. Certamente, vai ser um sucesso. ```python sp.series(g,x,0,20).as_expr().removeO() ``` # Integrais E chegamos nas integrais. O integrador do SymPy é muito rápido e eficiente, e é o companheiro que gostaríamos de ter na hora da prova de cálculo. Resolver uma integral no Python é muito fácil: o comando é ```integrate(f,x)``` ou ```integrate(f,(x,a,b))``` se for uma integral definida, com $x\in[a,b]$. ```python import sympy as sp x = sp.symbols('x') f=x**2 sp.integrate(f,x) ``` ```python import sympy as sp x = sp.symbols('x') g=x*sp.exp(x) sp.integrate(g,x) ``` ```python import sympy as sp x = sp.symbols('x') h=sp.exp(x)*sp.cos(x) sp.integrate(h,x) ``` Bom, como você percebeu, o SymPy teria perdido $0.1$ em cada integral anterior - esqueceu a constante de integração.. coisa feia, Python. Alguns exemplos de integrais definidas: ```python p=x**3+x sp.integrate(p,(x,0,1)) ``` ```python # vamos tentar enganar o python? q=1/(x-2) sp.integrate(q,(x,0,3)) ``` Garoto esperto.. O Python também consegue calcular integrais impróprias, lembrando que o símbolo ```oo``` é usado para "infinito". Atenção: se você tem menos que 18 anos, não execute o próximo comando!! ```python sp.integrate(sp.exp(-x**2), (x, 0, sp.oo)) ``` Mais um exemplo de integral imprópria: ```python sp.integrate(1/(x**(6)), (x, 1,sp.oo)) ``` A integração de funções de várias variávies, principalmente se o domínio for um retângulo, também pode ser feita sem problemas no Python: ```python x, y, a, b, c, d = sp.symbols("x y a b c d") f = x*y sp.integrate(f, (y, a, b), (x, c, d)) ``` Também podemos integrar sobre regiões um pouco mais gerais, as chamadas regiões de tipo I/tipo II, ou regiões $R_x$ ou $R_y$: ```python x, y, a, b, c, d = sp.symbols("x y a b c d") f = x**2+y sp.integrate(f, (y, 0, x+1), (x, 0, 1)) ``` ## Somas de Riemann Na primeira aula de integrais, começamos com integrais definidas, fazendo umas figuras sobre somas de Riemann. Acredite em mim: é complicado fazer isso manualmente, pois os cálculos são complicados e os desenhos são chatos de fazer. Que tal usar o Python pra facilitar nossa vida? Facilitará tanto o trabalho do professor quanto do aluno, que entenderá melhor. A implementação abaixo foi adaptada do Mathematical Python [(nesse site)](https://personal.math.ubc.ca/~pwalls/math-python/integration/riemann-sums/). ```python import numpy as np import matplotlib.pyplot as plt # originamente, a função foi definida com a definicao lambda, # que de fato é mais simples nesse caso - caso queira saber # mais sobre ela, leia aqui: # https://stackabuse.com/lambda-functions-in-python/ # f = lambda x : x**2 # definindo a função def f(x): return x**2 # intervalo a = 0; b = 10; # numero de retangulos N = 10 n = 10 # Use n*N+1 points to plot the function smoothly # discretizando variáveis x = np.linspace(a,b,N+1) y = f(x) X = np.linspace(a,b,n*N+1) Y = f(X) # iniciando plot plt.figure(figsize=(15,5)) plt.subplot(1,3,1) plt.plot(X,Y,'b') x_left = x[:-1] y_left = y[:-1] plt.plot(x_left,y_left,'b.',markersize=10) plt.bar(x_left,y_left,width=(b-a)/N,alpha=0.2,align='edge',edgecolor='b') plt.title('Soma de Riemann com base na esquerda'.format(N)) plt.show() ``` ```python ```

7cf27dbb03ddb8e8765f4ea307e44e1259d2296d

ipynb

Jupyter Notebook

6-limites-derivadas-integrais.ipynb

rmiranda99/tutorial-math-python

6fe211f9cd0b8b93d4a0543a690ca124fee6a8b2

6-limites-derivadas-integrais.ipynb

rmiranda99/tutorial-math-python

6fe211f9cd0b8b93d4a0543a690ca124fee6a8b2

6-limites-derivadas-integrais.ipynb

rmiranda99/tutorial-math-python

6fe211f9cd0b8b93d4a0543a690ca124fee6a8b2

Qwen/Qwen-72B

1. YES 2. YES

__label__por_Latn

# Variablen Wenn Sie ein neues Jupyter Notebook erstellen, wählen Sie `Python 3.6` als Typ des Notebooks aus. Innerhalb des Notebooks arbeiten Sie dann mit Python in der Version 3.6. Um zu verstehen, welche Bedeutung Variablen haben, müssen Sie also Variablen in Python 3.6 verstehen. In Python ist eine Variable ein Kurzname für einen Speicherbereich, in den Daten abgelegt werden können. Auf diese Daten kann dann unter dem Namen der Variablen zugegriffen werden. Dies haben wir prinzipiell bereits in den ersten Übungen durchgeführt. Beispiele: `d_i = 20 # Innendurchmesser eines Rohres` Den Name einer Variablen muss eindeutig sein. Er darf nicht mit einer Ziffer beginnen und darf keine Operationszeichen wie `'+', '-', '*', ':', '^'` oder `'#'` enthalten. Soll einer Variablen ein Wert zugewiesen werden, so geschieht das mittels des Gleichheitszeichens, siehe oben. Das `'#'`-Zeichen leitet einen Kommentar ein. Alles, was nach diesem Zeichen folgt, hat einen rein informativen Charakter aber wird von Python ignoriert. Sobald eine Variable angelegt ist, kann diese in Berechnungen verwendet werden, z.B. ```python import math ``` ```python d_i = 20e-3 # Innendurchmesser eines Rohres in m A_i = math.pi*d_i**2/4 # Lichter Querschnitt in m**2 ``` In einer Zelle dürfen mehrere Operationen stehen, siehe oben. Eine Zelle kann eine Ausgabe haben. Das ist dann immer das Ergebnis der Letzten Operation. In der oben stehenden Zelle steht als letztes eine Wertzuweisung `A_i = ...`, die keine Ausgabe erzeugt. Um interaktiv arbeiten zu können, sollte man nicht zu lange Berechnungen in einzelnen Zellen durchführen. Statt dessen sollte man nach wenigen sinnvollen Schritten Zwischenergebnisse anzeigen, um den Gang der Arbeit nachvollziehen zu können. Stellt man einen Fehler fest, so können Werte geändert und die Zelle erneut ausgeführt werden. Um das Ergebnis der oben durchgeführten Berechnung anzuzeigen, kann man die zuletzt erzeugte Variable aufrufen. Die Zelle sähe dann so aus: ```python d_i = 20e-3 # Innendurchmesser eines Rohres in m A_i = math.pi*d_i**2/4 # Lichter Querschnitt in m**2 A_i ``` Variablen haben einen Typ, den man sich durch die Funktion `type(variable)` anzeigen kann, z.B.: ```python type(A_i) ``` # Aufgabe Untersuchen Sie, welchen Typ die Variablen `a=1` `x=5.0` `Name = 'Bernd'` und `Punkt = (3,4)` haben. Untersuchen Sie, welche Auswirkung der Befehl `2*Name` mit dem oben definierten Namen hat. Welche Auswirkung hat analog `2*Punkt`? Stellen Sie eine Vermutung auf, welchen Typ das Produkt `a*x` und die Summe `a+x` mit den oben festgelegten Werten von `a` und `x` haben und überprüfen Sie diese. Um die Anwendungen in der Mathematik nicht aus den Augen zu verlieren, bearbeiten Sie die folgende Aufgabe: # Aufgabe Berechnen Sie das Gewicht von 250m Kupferrohr CU15$\times$1 in kg. Entnehmen Sie dafür die Dichte $\varrho$ von Kupfer ihrem Tabellenbuch. Die Zusammenhänge sind durch die folgenden Formeln gegeben: \begin{align} A &= \dfrac{\pi\,(d_a^2 - d_i^2)}{4} \\[2ex] V &= A\, l \\[2ex] m &= \varrho\, V \end{align} ```python import math ``` ```python # Ihre Lösung beginnt hier ```

677a1e10b2fc6f7c511a776fde7a147943fc807d

ipynb

Jupyter Notebook

src/03-Variablen.ipynb

w-meiners/anb-first-steps

6cb3583f77ae853922acd86fa9e48e9cf5188596

src/03-Variablen.ipynb

w-meiners/anb-first-steps

6cb3583f77ae853922acd86fa9e48e9cf5188596

src/03-Variablen.ipynb

w-meiners/anb-first-steps

6cb3583f77ae853922acd86fa9e48e9cf5188596

Qwen/Qwen-72B

1. YES 2. YES

__label__deu_Latn

# Laboratório 2: Mofo e Fungicida ### Referente ao capítulo 6 Nesse laboratório, seja $x(t)$ a concentração de mofo que queremos reduzir em um período de tempo fixo. Assumiremos que $x$ tenha crescimento com taxa $r$ e capacidade de carga $M.$ Seja $u(t)$ o fungicida que reduz a população em $u(t)x(t).$ Assim $$ x'(t) = r(M - x(t)) - u(t)x(t), x(0) = x_0 > 0 $$ O efeito do mofo e do fungicida são negativos para as pessoas ao redor e, por isso, queremos minimizar ambos. Assim, nosso objetivo será $$ \min_u \int_0^T Ax(t)^2 + u(t)^2 dt $$ tal que $A$ é o parâmetro que balanceia a importância dos termos do funcional, isto é, quanto mais o seu valor, mais importância em minimizar $x$. **Resultado de existência:** $f(t,x,u) = Ax^2 + u^2 \implies f_{xx}(t,x,u) = 2A, f_{uu}(t,x,u) = 2$, logo $f$ é continuamente diferenciável nas três variáveis e convexa em $x$ e $u$. $g(t,x,u) = r(M - x(t)) - u(t)x(t) \implies g_{xx} = g_{uu} = 0$ e, de mesma forma é continuamente diferenciável e convexa em $x$ e $u$. Assim, após encontrarmos $\lambda$ que satisfaça as condições necessárias, temos um resultado de existência, caso a integral seja finita. ## Condições Necessárias ### Hamiltoniano $$ H = Ax^2 + u^2 + \lambda(r(M - x) - ux) $$ ### Condição de otimalidade $$ 0 = H_u = 2u - \lambda x \implies u^{*}(t) = \frac{1}{2}\lambda(t)x(t) $$ ### Equação adjunta $$ \lambda '(t) = - H_x = -2Ax(t) + \lambda(t)(r + u(t)) $$ ### Condição de transversalidade $$ \lambda(T) = 0 $$ Deveríamos verificar que $\lambda(t) \ge 0$, mas isso não é feito aqui. Observe que formamos um sistema não linear de equações diferenciais, que tornam a solução analítica muito mais complexa. Por isso, vamos resolver esse problema de forma iterativa. ### Importanto as bibliotecas ```python import numpy as np import matplotlib.pyplot as plt from scipy.integrate import solve_ivp import sympy as sp import sys sys.path.insert(0, '../pyscripts/') from optimal_control_class import OptimalControl ``` Com a biblioteca `sympy`, de matemática simbólica, é possível obter as condições necessárias sem fazer contas. Para isso, vamos escrever o Hamiltoniano com uma expressão simbólica. ```python x_sp,u_sp,lambda_sp, r_sp, A_sp, M_sp = sp.symbols('x u lambda r A M') H = A_sp*x_sp**2 + u_sp**2 + lambda_sp*(r_sp*(M_sp - x_sp) - u_sp*x_sp) H ``` $\displaystyle A x^{2} + \lambda \left(r \left(M - x\right) - u x\right) + u^{2}$ Assim podemos conseguir suas derivadas e, portanto, as condições necessárias ```python print('H_x = {}'.format(sp.diff(H,x_sp))) print('H_u = {}'.format(sp.diff(H,u_sp))) print('H_lambda = {}'.format(sp.diff(H,lambda_sp))) ``` H_x = 2*A*x + lambda*(-r - u) H_u = -lambda*x + 2*u H_lambda = r*(M - x) - u*x Podemos resolver a equação $H_u = 0$, mas esse passo é importante conferir manualmente também. ```python eq = sp.Eq(sp.diff(H,u_sp), 0) sp.solve(eq,u_sp) ``` [lambda*x/2] Dessa vez vamos utilizar uma classe escrita em Python que codifica o algoritmo apresentado no Capítulo 5 e no Laboratório 1. Primeiro precisamos definir as equações importantes das condições necessárias. É importante escrever no formato descrito nesse notebook. `par` é um dicionário com os parâmetros específicos do modelo. ```python parameters = {'r': None, 'M': None, 'A': None} diff_state = lambda t, x, u, par: par['r']*(par['M'] - x) - u*x # Derivada de x diff_lambda = lambda t, x, u, lambda_, par: -2*par['A']*x + lambda_*(par['r'] + u) # Derivada de lambda_ update_u = lambda t, x, lambda_, par: 0.5*lambda_*x # Atualiza u através de H_u = 0 ``` ## Aplicando a classe ao exemplo Vamos fazer algumas exeperimentações. Sinta-se livre para variar os parâmetros ao final do notebook. ```python problem = OptimalControl(diff_state, diff_lambda, update_u) ``` ```python x0 = 1 T = 5 parameters['r'] = 0.3 parameters['M'] = 10 parameters['A'] = 1 ``` ```python t,x,u,lambda_ = problem.solve(x0, T, parameters, h = 0.001) ax = problem.plotting(t,x,u,lambda_) ``` O controle inicialmente aumenta até atingir um valor constante, da mesma forma que o estado. Dizemos que eles estão em equilíbrio. Eventualmente o controle decresce a 0. Note que o estado não decresce e isso acontece pela ponderação equivalente que damos aos efeitos negativo do mofo e do fungicida. Por isso, podemos sugerir um aumento em $A$. ```python parameters['A'] = 10 ``` ```python t,x,u,lambda_ = problem.solve(x0, T, parameters, h = 0.001) ax = problem.plotting(t,x,u,lambda_) ``` Aqui o uso de fungicida é muito maior. Como gostaríamos, a quantidade de mofo também é menor em sua constante, porém no final do intervalo, quando a quantidade do fungicida diminui, o nível de mofo cresce consideravelmente. Para fins de comparação, podemos visualizar a diferença de quando $u \equiv 0$ do controle ótimo. Para isso, temos que fazer a integração da derivada de $x$ no intervalo. ```python integration = solve_ivp(fun = diff_state, t_span = (0,T), y0 = (x0,), t_eval = np.linspace(0,T,len(u)), args = (0,parameters)) ``` ```python plt.plot(t, x, integration.t, integration.y[0]) plt.title('Comparação da quantidade mofo') plt.legend(['Controle ótimo', 'Sem controle']) plt.grid(alpha = 0.5) ``` ## Experimentação Descomente a célula a seguir e varie os parâmetros para ver seus efeitos: 1. Aumentar $r$ para ver o crescimento mais rápido do mofo. Como o controle vai se comportar? 2. Variar $T$ faz alguma diferença? Como é essa diferença? 3. Variar $M$, a capacidade de carga, gera que efeito no estado? ```python #x0 = 1 #T = 5 #parameters['r'] = 0.3 #parameters['M'] = 10 #parameters['A'] = 1 # #t,x,u,lambda_ = problem.solve(x0, T, parameters, h = 0.001) #roblem.plotting(t,x,u,lambda_) ``` ### Este é o final do notebook

a98189579c32fa33c9f981f6b3bfeab8fc22fb12

ipynb

Jupyter Notebook

notebooks/.ipynb_checkpoints/Laboratory2-checkpoint.ipynb

lucasmoschen/optimal-control-biological

642a12b6a3cb351429018120e564b31c320c44c5

2021-11-03T16:27:39.000Z

2021-11-03T16:27:39.000Z

notebooks/.ipynb_checkpoints/Laboratory2-checkpoint.ipynb

lucasmoschen/optimal-control-biological

642a12b6a3cb351429018120e564b31c320c44c5

notebooks/.ipynb_checkpoints/Laboratory2-checkpoint.ipynb

lucasmoschen/optimal-control-biological

642a12b6a3cb351429018120e564b31c320c44c5

Qwen/Qwen-72B

1. YES 2. YES

__label__por_Latn

# Symbolic Regression This example combines neural differential equations with regularised evolution to discover the equations $\frac{\mathrm{d} x}{\mathrm{d} t}(t) = \frac{y(t)}{1 + y(t)}$ $\frac{\mathrm{d} y}{\mathrm{d} t}(t) = \frac{-x(t)}{1 + x(t)}$ directly from data. **References:** This example appears as an example in: ```bibtex @phdthesis{kidger2021on, title={{O}n {N}eural {D}ifferential {E}quations}, author={Patrick Kidger}, year={2021}, school={University of Oxford}, } ``` Whilst drawing heavy inspiration from: ```bibtex @inproceedings{cranmer2020discovering, title={{D}iscovering {S}ymbolic {M}odels from {D}eep {L}earning with {I}nductive {B}iases}, author={Cranmer, Miles and Sanchez Gonzalez, Alvaro and Battaglia, Peter and Xu, Rui and Cranmer, Kyle and Spergel, David and Ho, Shirley}, booktitle={Advances in Neural Information Processing Systems}, publisher={Curran Associates, Inc.}, year={2020}, } @software{cranmer2020pysr, title={PySR: Fast \& Parallelized Symbolic Regression in Python/Julia}, author={Miles Cranmer}, publisher={Zenodo}, url={http://doi.org/10.5281/zenodo.4041459}, year={2020}, } ``` This example is available as a Jupyter notebook [here](https://github.com/patrick-kidger/diffrax/blob/main/examples/symbolic_regression.ipynb). ```python import tempfile from typing import List import equinox as eqx # https://github.com/patrick-kidger/equinox import jax import jax.numpy as jnp import optax # https://github.com/deepmind/optax import pysr # https://github.com/MilesCranmer/PySR import sympy # Note that PySR, which we use for SymbolicRegression, uses Julia as a backend. # You'll need to install a recent version of Julia if you don't have one. # (And can get funny errors if you have a too-old version of Julia already.) # You may also need to restart Python after running `pysr.install()` the first time. pysr.silence_julia_warning() pysr.install(quiet=True) ``` Now for a bunch of helpers. We'll use these in a moment; skip over them for now. ```python def quantise(expr, quantise_to): if isinstance(expr, sympy.Float): return expr.func(round(float(expr) / quantise_to) * quantise_to) elif isinstance(expr, sympy.Symbol): return expr else: return expr.func(*[quantise(arg, quantise_to) for arg in expr.args]) class SymbolicFn(eqx.Module): fn: callable parameters: jnp.ndarray def __call__(self, x): # Dummy batch/unbatching. PySR assumes its JAX'd symbolic functions act on # tensors with a single batch dimension. return jnp.squeeze(self.fn(x[None], self.parameters)) class Stack(eqx.Module): modules: List[eqx.Module] def __call__(self, x): return jnp.stack([module(x) for module in self.modules], axis=-1) def expr_size(expr): return sum(expr_size(v) for v in expr.args) + 1 def _replace_parameters(expr, parameters, i_ref): if isinstance(expr, sympy.Float): i_ref[0] += 1 return expr.func(parameters[i_ref[0]]) elif isinstance(expr, sympy.Symbol): return expr else: return expr.func( *[_replace_parameters(arg, parameters, i_ref) for arg in expr.args] ) def replace_parameters(expr, parameters): i_ref = [-1] # Distinctly sketchy approach to making this conversion. return _replace_parameters(expr, parameters, i_ref) ``` Now for the main program, which we can run with `main()`. We discuss what's happening at each step in the comments -- read on: ```python def main( symbolic_dataset_size=2000, symbolic_num_populations=100, symbolic_population_size=20, symbolic_migration_steps=4, symbolic_mutation_steps=30, symbolic_descent_steps=50, pareto_coefficient=2, fine_tuning_steps=500, fine_tuning_lr=3e-3, quantise_to=0.01, ): # # First obtain a neural approximation to the dynamics. # We begin by running the previous example. # # Runs the Neural ODE example. # This defines the variables `ts`, `ys`, `model`. print("Training neural differential equation.") %run neural_ode.ipynb # # Now symbolically regress across the learnt vector field, to obtain a Pareto # frontier of symbolic equations, that trades loss against complexity of the # equation. Select the "best" from this frontier. # print("Symbolically regressing across the vector field.") vector_field = model.func.mlp # noqa: F821 dataset_size, length_size, data_size = ys.shape # noqa: F821 in_ = ys.reshape(dataset_size * length_size, data_size) # noqa: F821 in_ = in_[:symbolic_dataset_size] out = jax.vmap(vector_field)(in_) with tempfile.TemporaryDirectory() as tempdir: symbolic_regressor = pysr.PySRRegressor( niterations=symbolic_migration_steps, ncyclesperiteration=symbolic_mutation_steps, populations=symbolic_num_populations, npop=symbolic_population_size, optimizer_iterations=symbolic_descent_steps, optimizer_nrestarts=1, procs=1, verbosity=0, tempdir=tempdir, temp_equation_file=True, output_jax_format=True, ) symbolic_regressor.fit(in_, out) best_equations = symbolic_regressor.get_best() expressions = [b.sympy_format for b in best_equations] symbolic_fns = [ SymbolicFn(b.jax_format["callable"], b.jax_format["parameters"]) for b in best_equations ] # # Now the constants in this expression have been optimised for regressing across # the neural vector field. This was good enough to obtain the symbolic expression, # but won't quite be perfect -- some of the constants will be slightly off. # # To fix this we now plug our symbolic function back into the original dataset # and apply gradient descent. # print("Optimising symbolic expression.") symbolic_fn = Stack(symbolic_fns) flat, treedef = jax.tree_flatten( model, is_leaf=lambda x: x is model.func.mlp # noqa: F821 ) flat = [symbolic_fn if f is model.func.mlp else f for f in flat] # noqa: F821 symbolic_model = jax.tree_unflatten(treedef, flat) @eqx.filter_grad def grad_loss(symbolic_model): vmap_model = jax.vmap(symbolic_model, in_axes=(None, 0)) pred_ys = vmap_model(ts, ys[:, 0]) # noqa: F821 return jnp.mean((ys - pred_ys) ** 2) # noqa: F821 optim = optax.adam(fine_tuning_lr) opt_state = optim.init(eqx.filter(symbolic_model, eqx.is_inexact_array)) @eqx.filter_jit def make_step(symbolic_model, opt_state): grads = grad_loss(symbolic_model) updates, opt_state = optim.update(grads, opt_state) symbolic_model = eqx.apply_updates(symbolic_model, updates) return symbolic_model, opt_state for _ in range(fine_tuning_steps): symbolic_model, opt_state = make_step(symbolic_model, opt_state) # # Finally we round each constant to the nearest multiple of `quantise_to`. # trained_expressions = [] for module, expression in zip(symbolic_model.func.mlp.modules, expressions): expression = replace_parameters(expression, module.parameters.tolist()) expression = quantise(expression, quantise_to) trained_expressions.append(expression) print(f"Expressions found: {trained_expressions}") ``` ```python main() ```

85b477be66dee5b2c2b83bb2e7b5ae3fadbf4d4e

ipynb

Jupyter Notebook

examples/symbolic_regression.ipynb

FedericoV/diffrax

98b010242394491fea832e77dc94f456b48495fa

examples/symbolic_regression.ipynb

FedericoV/diffrax

98b010242394491fea832e77dc94f456b48495fa

examples/symbolic_regression.ipynb

FedericoV/diffrax

98b010242394491fea832e77dc94f456b48495fa

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python from __future__ import print_function import sisl import numpy as np import matplotlib.pyplot as plt %matplotlib inline ``` In this analysis example we will show how to plot the wavefunction for a periodic system (the same scheme may be used to plot molecular orbitals). The basic principle of plotting the real-space wave functions may be written as this (for a given $\mathbf k$-point): \begin{equation} \psi_i(\mathbf k, \mathbf r) = \sum_\nu e^{i\mathbf k \cdot \mathbf r_\nu}c_{i\nu}\phi_\nu(\mathbf r - \mathbf r_\nu), \end{equation} where $c_{i\nu}=\langle\tilde\phi_\nu|\psi_i\rangle$ is the coefficient for the $i$th eigenstate and $\nu$ basis orbital and $\phi_\nu(\mathbf r - \mathbf r_\nu)$ is the basis orbital $\nu$ centered at $\mathbf r_\nu$. `sisl` will in most cases, automatically read the necessary information from a Siesta run to be able to construct the $\phi_\nu$ basis functions in real-space. If the basis-information is not available `sisl` will inform you when trying to calculate real-space quantities. In this example we will calculate the eigenstates for a given $\mathbf k$-point for graphene and plot a cut through the real-space wavefunction at a fixed distance above the graphene plane. ## Exercises 1. Run Siesta. 2. Read in the Hamiltonian using the `RUN.fdf` file, see e.g. [S 1](../S_01/run.ipynb). 3. Calculate the eigenstate for the $\Gamma$-point (see. `Hamiltonian.eigenstate`) 4. Read the entry about the `EigenstateElectron` in the [sisl](http://zerothi.github.io/sisl/docs/latest/api-generated/sisl.physics.html#electrons-electron). Figure out which method you should use in order to calculate the real-space wavefunction. Use the below method (`plot_grid`) to plot a cut through the wavefunction grid. *HINT*: this may be a useful grid `grid = Grid(0.05, sc=H.geometry.sc)` 5. If you **don't** see a warning like this: info:0: SislInfo: wavefunction: summing 18 different state coefficients, will continue silently! then you have done it correctly! Look in the documentation and figure out how to take a *sub*set of the eigenstates and only plot a single one of them on the grid. This is important since otherwise you are plotting the super-position of all eigenstates at the $\mathbf k$-point. *HINT*: If you have VMD/XCrySDen on your laptop it may be *fun* to plot the real-space quantities using cube files, if you want, figure out how to save the `Grid` into a cube/xsf file. 6. Try and *play* with the supercell you pass to the `Grid` initialization and plot the wavefunction for different sizes of the grid. What do you see for increasing size of grids? Are there any periodicites, if so, what is the periodicity and why? 7. Calculate the eigenstates such that the wavefunctions has a periodicity of $3$ along the first lattice vector and $2$ along the second lattice vector (only plot one of the eigenstates) *HINT*: $e^{i\mathbf k \cdot \mathbf R}$ ```python def plot_grid(grid, plane_dist=1): """ Plot the grid in either 1 (real-only) or 2 (complex wavefunction) graphs A cut through the grid will be plotted corresponding to `plane_dist` above the z-coordinate """ z_index = grid.index(plane_dist, 2) x, y = np.mgrid[:grid.shape[0], :grid.shape[1]] dcell = grid.dcell x, y = x * dcell[0, 0] + y * dcell[1, 0], x * dcell[0, 1] + y * dcell[1, 1] if grid.dtype in [np.complex64, np.complex128]: fig, axs = plt.subplots(1, 2, figsize=(15, 5)) axs[0].contourf(x, y, grid.grid[:, :, z_index].real) im = axs[1].contourf(x, y, grid.grid[:, :, z_index].imag) for ax in axs: ax.set_xlabel(r'$x$ [Ang]'); ax.set_ylabel(r'$y$ [Ang]') axs[0].set_title('Real part') axs[1].set_title('Imaginary part') else: fig, ax = plt.subplots(1, 1) ; axs = [ax] axs = [ax] im = ax.contourf(x, y, grid.grid[:, :, z_index]) ax.set_xlabel(r'$x$ [Ang]'); ax.set_ylabel(r'$y$ [Ang]') # Also plot the atomic coordinates try: xyz = grid.geometry.xyz for ax in axs: ax.scatter(xyz[:, 0], xyz[:, 1], 50, 'k', alpha=.6) except: pass fig.colorbar(im); ``` ```python # Add code here to 1) read in Hamiltonian with basis orbitals, 2) calculate the eigenstate for a given k-point, # 3) create a grid to plot the wavefunction on and 4) plot the grid using the above method ``` ```python ```

6fd15e919fe13f51ca4b4d17dca31df7717756f6

ipynb

Jupyter Notebook

ts-tbt-sisl-tutorial-master/S_03/run.ipynb

rwiuff/QuantumTransport

5367ca2130b7cf82fefd4e2e7c1565e25ba68093

2021-09-25T14:05:45.000Z

2021-09-25T14:05:45.000Z

ts-tbt-sisl-tutorial-master/S_03/run.ipynb

rwiuff/QuantumTransport

5367ca2130b7cf82fefd4e2e7c1565e25ba68093

2020-03-31T03:17:38.000Z

2020-03-31T03:17:38.000Z

ts-tbt-sisl-tutorial-master/S_03/run.ipynb

rwiuff/QuantumTransport

5367ca2130b7cf82fefd4e2e7c1565e25ba68093

2020-01-27T10:27:51.000Z

2020-06-17T10:18:18.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Eisntein Tensor calculations using Symbolic module ```python import numpy as np import pytest import sympy from sympy import cos, simplify, sin, sinh, tensorcontraction from einsteinpy.symbolic import EinsteinTensor, MetricTensor, RicciScalar sympy.init_printing() ``` ### Defining the Anti-de Sitter spacetime Metric ```python syms = sympy.symbols("t chi theta phi") t, ch, th, ph = syms m = sympy.diag(-1, cos(t) ** 2, cos(t) ** 2 * sinh(ch) ** 2, cos(t) ** 2 * sinh(ch) ** 2 * sin(th) ** 2).tolist() metric = MetricTensor(m, syms) ``` ### Calculating the Einstein Tensor (with both indices covariant) ```python einst = EinsteinTensor.from_metric(metric) einst.tensor() ```

c722970826c908ce91ed41926c7dc64c5f9e02e7

ipynb

Jupyter Notebook

docs/source/examples/Einstein_Tensor_symbolic_calculation.ipynb

Varunvaruns9/einsteinpy

befc0879c65a53b811e7d6a9ec47675ae28a08c5

2019-03-08T16:13:56.000Z

2019-03-08T16:13:56.000Z

docs/source/examples/Einstein_Tensor_symbolic_calculation.ipynb

Varunvaruns9/einsteinpy

befc0879c65a53b811e7d6a9ec47675ae28a08c5

docs/source/examples/Einstein_Tensor_symbolic_calculation.ipynb

Varunvaruns9/einsteinpy

befc0879c65a53b811e7d6a9ec47675ae28a08c5

2022-03-19T18:46:13.000Z

2022-03-19T18:46:13.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

<h1><center> Computation of the modified equation of a numerical scheme (univariate PDE evolution equation)</center></h1> <center> Olivier Pannekoucke <br> 2020 # Introduction In this illustration we compute the modified equation assowiated with the Euler discretization and the centered discretization of the advection equation $$(1)\quad \partial_t u + c \partial_x u =0$$ whose numerical scheme is $$(2)\quad u^{q+1}_k = u_k^q - c \delta t \frac{u^q_{k+1}-u^q_{k-1}}{2\delta x}$$ where $u^q_k$ stands for a numerical approximation of $u(q\delta t,k\delta x)$. ## Application to the Euler time scheme applied on the advection #### Import of modules & functions ```python from modequation import ModifiedEquation import sympy from sympy import symbols, Derivative, Function, Eq ``` ```python c = sympy.symbols('c') coordinates = sympy.symbols('t x') t, x = coordinates dt, dx = sympy.symbols('dt dx') u = Function('u')(*coordinates) ``` ```python u_qp=u.subs(t,t+dt) u_kp=u.subs(x,x+dx) u_km=u.subs(x,x-dx) ``` #### Definition of the time schemes First we define the numerical schemes as an equation (`sympy.Eq`) $$(3)\quad \frac{u^{q+1}_k-u_k^q }{\delta t} = - c \frac{u^q_{k+1}-u^q_{k-1}}{2\delta x}$$ ```python euler_centered_scheme = Eq( (u_qp-u)/dt, -c * (u_kp-u_km)/(2*dx)) ``` #### Computation of the modified equations ```python euler_centered = ModifiedEquation(euler_centered_scheme,u, order =3) ``` ```python euler_centered.consistant_equation ``` $\displaystyle \frac{\partial}{\partial t} u{\left(t,x \right)} = - c \frac{\partial}{\partial x} u{\left(t,x \right)}$ ```python euler_centered.modified_equation ``` $\displaystyle \frac{\partial}{\partial t} u{\left(t,x \right)} = - c \frac{\partial}{\partial x} u{\left(t,x \right)} - \frac{c dx^{2} \frac{\partial^{3}}{\partial x^{3}} u{\left(t,x \right)}}{6} - \frac{c^{2} dt \frac{\partial^{2}}{\partial x^{2}} u{\left(t,x \right)}}{2} + O\left(dx^{3}\right) + O\left(dt^{3}\right)$

b7a5068b3b2b37714893bc47f872d9628bd04b1e

ipynb

Jupyter Notebook

euler-centered-modified-equation.ipynb

opannekoucke/modified-equation

11a0f18b24e3142a65976048e385e9def54628fd

euler-centered-modified-equation.ipynb

opannekoucke/modified-equation

11a0f18b24e3142a65976048e385e9def54628fd

euler-centered-modified-equation.ipynb

opannekoucke/modified-equation

11a0f18b24e3142a65976048e385e9def54628fd

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

<center> <h1> ILI285 - Computación Científica I / INF285 - Computación Científica </h1> <h2> Roots of 1D equations </h2> <h2> <a href="#acknowledgements"> [S]cientific [C]omputing [T]eam </a> </h2> <h2> Version: 1.32</h2> </center> ## Table of Contents * [Introduction](#intro) * [Bisection Method](#bisection) * [Cobweb Plot](#cobweb) * [Fixed Point Iteration](#fpi) * [Newton Method](#nm) * [Wilkinson Polynomial](#wilkinson) * [Acknowledgements](#acknowledgements) ```python import numpy as np import matplotlib.pyplot as plt import sympy as sym %matplotlib inline from ipywidgets import interact from ipywidgets import widgets sym.init_printing() from scipy import optimize ``` <div id='intro' /> ## Introduction Hello again! In this document we're going to learn how to find a 1D equation's solution using numerical methods. First, let's start with the definition of a root: <b>Definition</b>: The function $f(x)$ has a <b>root</b> in $x = r$ if $f(r) = 0$. An example: Let's say we want to solve the equation $x + \log(x) = 3$. We can rearrange the equation: $x + \log(x) - 3 = 0$. That way, to find its solution we can find the root of $f(x) = x + \log(x) - 3$. Now let's study some numerical methods to solve these kinds of problems. Defining a function $f(x)$ ```python f = lambda x: x+np.log(x)-3 ``` Finding $r$ using sympy ```python y = sym.Symbol('y') fsym = lambda y: y+sym.log(y)-3 r_all=sym.solve(sym.Eq(fsym(y), 0), y) r=r_all[0].evalf() print(r) print(r_all) ``` 2.20794003156932 [LambertW(exp(3))] ```python def find_root_manually(r=2.0): x = np.linspace(1,3,1000) plt.figure(figsize=(8,8)) plt.plot(x,f(x),'b-') plt.grid() plt.ylabel('$f(x)$',fontsize=16) plt.xlabel('$x$',fontsize=16) plt.title('What is r such that $f(r)='+str(f(r))+'$? $r='+str(r)+'$',fontsize=16) plt.plot(r,f(r),'k.',markersize=20) plt.show() interact(find_root_manually,r=(1e-5,3,1e-3)) ``` interactive(children=(FloatSlider(value=2.0, description='r', max=3.0, min=1e-05, step=0.001), Output()), _dom… <function __main__.find_root_manually(r=2.0)> <div id='bisection' /> ## Bisection Method The bisection method finds the root of a function $f$, where $f$ is a **continuous** function. If we want to know if this has a root, we have to check if there is an interval $[a,b]$ for which $f(a)\cdot f(b) < 0$. When these 2 conditions are satisfied, it means that there is a value $r$, between $a$ and $b$, for which $f(r) = 0$. To summarize how this method works, start with the aforementioned interval (checking that there's a root in it), and split it into two smaller intervals $[a,c]$ and $[c,b]$. Then, check which of the two intervals contains a root. Keep splitting each "eligible" interval until the algorithm converges or the tolerance is surpassed. ```python def bisect(f, a, b, tol=1e-8): fa = f(a) fb = f(b) i = 0 # Just checking if the sign is not negative => not root necessarily if np.sign(f(a)*f(b)) >= 0: print('f(a)f(b)<0 not satisfied!') return None #Printing the evolution of the computation of the root print(' i | a | c | b | fa | fc | fb | b-a') print('----------------------------------------------------------------------------------------') while(b-a)/2 > tol: c = (a+b)/2. fc = f(c) print('%2d | %.7f | %.7f | %.7f | %.7f | %.7f | %.7f | %.7f' % (i+1, a, c, b, fa, fc, fb, b-a)) # Did we find the root? if fc == 0: print('f(c)==0') break elif np.sign(fa*fc) < 0: b = c fb = fc else: a = c fa = fc i += 1 xc = (a+b)/2. return xc ``` ```python ## Finding a root of cos(x). What about if you change the interval? #f = lambda x: np.cos(x) ## Another function #f = lambda x: x**3-2*x**2+(4/3)*x-(8/27) ## Computing the cubic root of 7. #f = lambda x: x**3-7 #bisect(f,0,2) f = lambda x: x*np.exp(x)-3 #f2 = lambda x: np.cos(x)-x bisect(f,0,3,tol=1e-13) ``` It's very important to define a concept called **convergence rate**. This rate shows how fast the convergence of a method is at a specified point. The convergence rate for the bisection is always 0.5 because this method uses the half of the interval for each iteration. <div id='cobweb' /> ## Cobweb Plot ```python def cobweb(x,g=None): min_x = np.amin(x) max_x = np.amax(x) plt.figure(figsize=(10,10)) ax = plt.axes() plt.plot(np.array([min_x,max_x]),np.array([min_x,max_x]),'b-') for i in np.arange(x.size-1): delta_x = x[i+1]-x[i] head_length = np.abs(delta_x)*0.04 arrow_length = delta_x-np.sign(delta_x)*head_length ax.arrow(x[i], x[i], 0, arrow_length, head_width=1.5*head_length, head_length=head_length, fc='k', ec='k') ax.arrow(x[i], x[i+1], arrow_length, 0, head_width=1.5*head_length, head_length=head_length, fc='k', ec='k') if g!=None: y = np.linspace(min_x,max_x,1000) plt.plot(y,g(y),'r') plt.title('Cobweb diagram') plt.grid(True) plt.show() ``` <div id='fpi' /> ## Fixed Point Iteration To learn about the Fixed-Point Iteration we will first learn about the concept of Fixed Point. A Fixed Point of a function $g$ is a real number $r$, where $g(r) = r$ The Fixed-Point Iteration is based in the Fixed Point concept and works like this to find the root of a function: \begin{equation} x_{0} = initial\_guess \\ x_{i+1} = g(x_{i})\end{equation} To find an equation's solution using this method you'll have to move around some things to rearrange the equation in the form $x = g(x)$. That way, you'll be iterating over the funcion $g(x)$, but you will **not** find $g$'s root, but $f(x) = g(x) - x$ (or $f(x) = x - g(x)$)'s root. In our following example, we'll find the solution to $f(x) = x - \cos(x)$ by iterating over the funcion $g(x) = \cos(x)$. ```python def fpi(g, x0, k, flag_cobweb=False): x = np.empty(k+1) x[0] = x0 error_i = np.nan print(' i | x(i) | x(i+1) ||x(i+1)-x(i)| | e_i/e_{i-1}') print('--------------------------------------------------------------') for i in range(k): x[i+1] = g(x[i]) error_iminus1 = error_i error_i = abs(x[i+1]-x[i]) print('%2d | %.10f | %.10f | %.10f | %.10f' % (i,x[i],x[i+1],error_i,error_i/error_iminus1)) if flag_cobweb: cobweb(x,g) return x[-1] ``` ```python g = lambda x: np.cos(x) fpi2(g, 2, 20, True) ``` Let's quickly explain the Cobweb Diagram we have here. The <font color="blue">blue</font> line is the function $x$ and the <font color="red">red</font> is the function $g(x)$. The point in which they meet is $g$'s fixed point. In this particular example, we start at <font color="blue">$y = x = 1.5$</font> (the top right corner) and then we "jump" **vertically** to <font color="red">$y = \cos(1.5) \approx 0.07$</font>. After this, we jump **horizontally** to <font color="blue">$x = \cos(1.5) \approx 0.07$</font>. Then, we jump again **vertically** to <font color="red">$y = \cos\left(\cos(1.5)\right) \approx 0.997$</font> and so on. See the pattern here? We're just iterating over $x = \cos(x)$, getting closer to the center of the diagram where the fixed point resides, in $x \approx 0.739$. It's very important to mention that the algorithm will converge only if the rate of convergence $S < 1$, where $S = \left| g'(r) \right|$. If you want to use this method, you'll have to construct $g(x)$ starting from $f(x)$ accordingly. In this example, $g(x) = \cos(x) \Rightarrow g'(x) = -\sin(x)$ and $|-\sin(0.739)| \approx 0.67$. ### Another example. Source: https://divisbyzero.com/2008/12/18/sharkovskys-theorem/amp/?__twitter_impression=true ```python g = lambda x: -(3/2)*x**2+(11/2)*x-2 gp = lambda x: -3*x+11/2 a=-1/2.7 g2 = lambda x: x+a*(x-g(x)) #x=np.linspace(2,3,100) #plt.plot(x,gp(x),'-') #plt.plot(x,gp(x)*0+1,'r-') #plt.plot(x,gp(x)*0-1,'g-') #plt.grid(True) #plt.show() fpi(g2, 2.45, 12, True) ``` <div id='nm' /> ## Newton's Method For this method, we want to iteratively find some function $f(x)$'s root, that is, the number $r$ for which $f(r) = 0$. The algorithm is as follows: \begin{equation} x_0 = initial\_guess \end{equation} \begin{equation} x_{i+1} = x_i - \cfrac{f(x_i)}{f'(x_i)} \end{equation} which means that you won't be able to find $f$'s root if $f'(r) = 0$. In this case, you would have to use the modified version of this method, but for now let's focus on the unmodified version first. Newton's (unmodified) method is said to have quadratic convergence. ```python def newton_method(f, fp, x0, rel_error=1e-8, m=1): #Initialization of hybrid error and absolute hybrid_error = 100 error_i = np.inf print('i | x(i) | x(i+1) | |x(i+1)-x(i)| | e_i/e_{i-1} | e_i/e_{i-1}^2') print('----------------------------------------------------------------------------------------') #Iteration counter i = 1 while (hybrid_error > rel_error and hybrid_error < 1e12 and i < 1e4): #Newton's iteration x1 = x0-m*f(x0)/fp(x0) #Checking if root was found if f(x1) == 0.0: hybrid_error = 0.0 break #Computation of hybrid error hybrid_error = abs(x1-x0)/np.max([abs(x1),1e-12]) #Computation of absolute error error_iminus1 = error_i error_i = abs(x1-x0) #Increasing counter i += 1 #Showing some info print("%d | %.10f | %.10f | %.20f | %.10f | %.10f" % (i, x0, x1, error_i, error_i/error_iminus1, error_i/(error_iminus1**2))) #Updating solution x0 = x1 #Checking if solution was obtained if hybrid_error < rel_error: return x1 elif i>=1e4: print('Newton''s Method diverged. Too many iterations!!') return None else: print('Newton''s Method diverged!') return None ``` ```python f = lambda x: np.sin(x) fp = lambda x: np.cos(x) # the derivative of f newton_method(f, fp, 3.1,rel_error=1e-14) ``` ```python f = lambda x: x**2 fp = lambda x: 2*x # the derivative of f newton_method(f, fp, 3.1,rel_error=1e-2, m=2) ``` <div id='wilkinson' /> ## Wilkinson Polynomial https://en.wikipedia.org/wiki/Wilkinson%27s_polynomial **Final question: Why is the root far far away from $16$?** ```python x = sym.symbols('x', reals=True) W=1 for i in np.arange(1,21): W*=(x-i) W # Printing W nicely ``` ```python # Expanding the Wilkinson polynomial We=sym.expand(W) We ``` ```python # Just computiong the derivative Wep=sym.diff(We,x) Wep ``` ```python # Lamdifying the polynomial to be used with sympy P=sym.lambdify(x,We) Pp=sym.lambdify(x,Wep) ``` ```python # Using scipy function to compute a root root = optimize.newton(P,16) print(root) ``` <div id='acknowledgements' /> # Acknowledgements * _Material created by professor Claudio Torres_ (`ctorres@inf.utfsm.cl`) _and assistants: Laura Bermeo, Alvaro Salinas, Axel Simonsen and Martín Villanueva. DI UTFSM. March 2016._ v1.1. * _Update April 2020 - v1.32 - C.Torres_ : Re-ordering the notebook. # Propose Classwork Build a FPI such that given $x$ computes $\displaystyle \frac{1}{x}$. Write down your solution below or go and see the [solution](#sol1) ```python print('Please try to think and solve before you see the solution!!!') ``` # In class ### From the textbook ```python g1 = lambda x: 1-x**3 g2 = lambda x: (1-x)**(1/3) g3 = lambda x: (1+2*x**3)/(1+3*x**2) fpi(g3, 0.5, 10, True) ``` ```python g1p = lambda x: -3*x**2 g2p = lambda x: -(1/3)*(1-x)**(-2/3) g3p = lambda x: ((1+3*x**2)*(6*x**2)-(1+2*x**3)*6*x)/((1+3*x**2)**2) r=0.6823278038280194 print(g3p(r)) ``` ### Adding another implementation of FPI including and extra column for analyzing quadratic convergence ```python def fpi2(g, x0, k, flag_cobweb=False): x = np.empty(k+1) x[0] = x0 error_i = np.inf print(' i | x(i) | x(i+1) ||x(i+1)-x(i)| | e_i/e_{i-1} | e_i/e_{i-1}^2') print('-----------------------------------------------------------------------------') for i in range(k): x[i+1] = g(x[i]) error_iminus1 = error_i error_i = abs(x[i+1]-x[i]) print('%2d | %.10f | %.10f | %.10f | %.10f | %.10f' % (i,x[i],x[i+1],error_i,error_i/error_iminus1,error_i/(error_iminus1**2))) if flag_cobweb: cobweb(x,g) return x[-1] ``` Which function shows quadratic convergence? Why? ```python g1 = lambda x: (4./5.)*x+1./x g2 = lambda x: x/2.+5./(2*x) g3 = lambda x: (x+5.)/(x+1) fpi2(g1, 3.0, 30, True) ``` ### Building a FPI to compute the cubic root of 7 ```python # What is 'a'? Can we find another 'a'? a = -3*(1.7**2) print(a) ``` ```python f = lambda x: x**3-7 g = lambda x: f(x)/a+x r=fpi(g, 1.7, 14, True) print(f(r)) ``` ### Playing with some roots ```python f = lambda x: 8*x**4-12*x**3+6*x**2-x fp = lambda x: 32*x**3-36*x**2+12*x-1 x = np.linspace(-1,1,1000) plt.figure(figsize=(10,10)) plt.title('What are we seeing with the semiloigy plot? Is this function differentiable?') plt.semilogy(x,np.abs(f(x)),'b-') plt.semilogy(x,np.abs(fp(x)),'r-') plt.grid() plt.ylabel('$f(x)$',fontsize=16) plt.xlabel('$x$',fontsize=16) plt.show() ``` ```python r=newton_method(f, fp, 0.3, rel_error=1e-8, m=1) print([r,f(r)]) # Is this showing quadratic convergence? If not, can you fix it? ``` # Solutions <div id='sol1' /> Problem: Build a FPI such that given $x$ computes $\displaystyle \frac{1}{x}$ ```python # We are finding the 1/a # Solution code: a = 2.1 g = lambda x: 2*x-a*x**2 gp = lambda x: 2-2*a*x r=fpi2(g, 0.7, 7, flag_cobweb=True) print([r,1/a]) # Are we seeing quadratic convergence? ``` ### What is this plot telling us? ```python xx=np.linspace(0.2,0.8,1000) plt.figure(figsize=(10,10)) plt.plot(xx,g(xx),'-',label=r'$g(x)$') plt.plot(xx,gp(xx),'r-',label=r'$gp(x)$') plt.plot(xx,xx,'g-',label=r'$x$') plt.plot(xx,0*xx+1,'k--') plt.plot(xx,0*xx-1,'k--') plt.legend(loc='best') plt.grid() plt.show() ``` # In-Class 20200420 ```python g = lambda x: (x**2-1.)/2. gh = lambda x: x+0.7*(x-g(x)) #fpi(g, 2, 15, True) fpi2(gh, 0, 15, True) ``` # In-Class 20200423 ```python g1 = lambda x: np.cos(x) g2 = lambda x: np.cos(x)**2 g3 = lambda x: np.sin(x) g4 = lambda x: 1-5*x+(15/2)*x**2-(5/2)*x**3 # (0,1) y (1,2) interact(lambda x0, n: fpi2(g4, x0, n, True),x0=widgets.FloatSlider(min=0, max=3, step=0.01, value=0), n=widgets.IntSlider(min=10, max=100, step=1, value=10)) ``` ```python ```

d4700a7da8ab0ff2e34cbace88bd018ccbb33691

ipynb

Jupyter Notebook

SC1/04_roots_of_1D_equations.ipynb

maxaubel/Scientific-Computing

57a04b5d3e3f7be2fe9b06127f7e569659698656

2017-06-05T21:01:15.000Z

2022-03-17T12:51:55.000Z

SC1/04_roots_of_1D_equations.ipynb

maxaubel/Scientific-Computing

57a04b5d3e3f7be2fe9b06127f7e569659698656

SC1/04_roots_of_1D_equations.ipynb

maxaubel/Scientific-Computing

57a04b5d3e3f7be2fe9b06127f7e569659698656

2017-10-02T21:21:30.000Z

2022-03-23T02:23:22.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

<a href="https://colab.research.google.com/github/Jun-629/20MA573/blob/master/src/Hw4_Monotonicity_in_volatility.ipynb" target="_parent"></a> - __Suppose $f$ is convex and $X$ is submartingale, prove that $g(t) = \mathbb E[f(X_t)]$ is increasing.__ __Pf:__ Assuming that $X_n$ is a submartingale with respect to the filtration $\{\mathcal{F_n}\}_{n\in\mathbb{N}}$, which means that $$\mathbb E[X_t] \ge \mathbb E[X_s], \forall t \ge s$$ Now, assuming that $X_n \ge 0$ for all n and $f(x) = -x$, which is a convex function. Then we will have \begin{equation} \begin{aligned} \mathbb E[f(X_t) - f(X_s) | \mathcal{F_s}] &= \mathbb E[-X_t - (-X_s)| \mathcal{F_s}] \\ &= X_s - \mathbb E[X_t| \mathcal{F_s}] \\ &\le 0, \forall t \ge s. \end{aligned} \end{equation} This shows that $g(t) = \mathbb E[f(X_t)]$ is strictly decreasing instead of increasing, which means that this is a counter example of the proof. On the other hand, if the function $f$ is given by the condition that it is increasing, then we will have the inequality as follows by Jensen's Inequality, $$\mathbb E[f(X_t)|\mathcal{F_s}] \ge f(\mathbb E[X_t|\mathcal{F_s}]) \ge f(X_s), \forall t \ge s$$ then by taking expectation of both sides, we will have the following inequality by the property of conditional expectation: $$\mathbb E[f(X_t)] = \mathbb E[\mathbb E[f(X_t)|\mathcal{F_s}]] \ge \mathbb E[f(X_s)], \forall t \ge s$$ Therefore, $g(t) = \mathbb E[f(X_t)]$ is increasing. __Q.E.D__ - __Let $t \mapsto e^{-rt}S_t$ be a martingale, then prove that $C(t) = \mathbb E[e^{-rt}(S_t - K)^+]$ is increasing.__ __Pf:__ Assuming that $e^{-rt}S_t$ is a martingale with respect to the filtration $\{\mathcal{F_n}\}_{n\in\mathbb{N}}$, which means $$\mathbb E[e^{-rt}S_t|\mathcal{F_s}] = e^{-rs}S_s, \forall t \ge s.$$ Since $f(x) = x^+$ is convex function, then \begin{equation} \begin{split} \mathbb E[e^{-rt}(S_t - K)^+|\mathcal{F_s}] &\ge (\mathbb E[e^{-rt}(S_t - K)|\mathcal{F_s}])^+ \\ &= e^{-rs}(S_s-K)^+ \\ \end{split} \end{equation} ##Can not solve by this since $S_t$ is a random variable When $S_t \leq K$, then $$\mathbb E[e^{-rt}(S_t - K)^+|\mathcal{F_s}] = 0.$$ when $S_t > K$, then \begin{equation} \begin{split} \mathbb E[e^{-rt}(S_t - K)^+|\mathcal{F_s}] &= \mathbb E[e^{-rt}(S_t-K)|\mathcal{F_s}]\\ &= \mathbb E[e^{-rt}S_t - K(e^{-rt}-e^{-rs}+e^{-rs})|\mathcal{F_s}] \\ &= e^{-rs}(S_s - K) - K \mathbb E[e^{-rt} - e^{-rs}|\mathcal{F_s}] \\ &\ge e^{-rs}(S_s - K) \\ &\ge e^{-rs}(S_s - K)^+. \end{split} \end{equation} Thus,$$\mathbb E[e^{-rt}(S_t - K)^+|\mathcal{F_s}] \ge e^{-rs}(S_s - K)^+, \forall t \ge s.$$ Therefore, by taking expectation of both sides, we will have $$\mathbb E[e^{-rt}(S_t - K)^+] = \mathbb E[ \mathbb E[e^{-rt}(S_t - K)^+|\mathcal{F_s}]] \ge \mathbb E[e^{-rs}(S_s - K)^+], \forall t \ge s,$$ which shows that $C(t) = \mathbb E[e^{-rt}(S_t - K)^+]$ is increasing. __Q.E.D__ - __Suppose $r = 0$ and $S$ is martingale, prove that $P(t) = \mathbb E [(S_t - K)^-]$ is increasing.__ __Pf:__ Assuming that $S_t$ is a martingale with respect to the filtration $\{\mathcal{F_n}\}_{n\in\mathbb{N}}$, which means $$\mathbb E[S_t|\mathcal{F_s}] = S_s, \forall t \ge s.$$ When $S_t \ge K$, then $$\mathbb E[(S_t - K)^-|\mathcal{F_s}] = 0.$$ when $S_t < K$, then \begin{equation} \begin{split} \mathbb E[(S_t - K)^-|\mathcal{F_s}] &= \mathbb E[K - S_t|\mathcal{F_s}]\\ &= K - S_s \\ &\ge (S_s - K)^-. \end{split} \end{equation} Thus,$$\mathbb E[(S_t - K)^-|\mathcal{F_s}] \ge (S_s - K)^-, \forall t \ge s.$$ Therefore, by taking expectation of both sides, we will have $$\mathbb E[(S_t - K)^-] = \mathbb E[ \mathbb E[(S_t - K)^-|\mathcal{F_s}]] \ge \mathbb E[(S_s - K)^-], \forall t \ge s,$$ which shows that $P(t) = \mathbb E[(S_t - K)^-]$ is increasing. __Q.E.D__

d645512c3fa2fe1f975ef21f6d146f4b43b1bcb5

ipynb

Jupyter Notebook

src/Hw4_Monotonicity_in_volatility.ipynb

Jun-629/20MA573

addad663d2dede0422ae690e49b230815aea4c70

src/Hw4_Monotonicity_in_volatility.ipynb

Jun-629/20MA573

addad663d2dede0422ae690e49b230815aea4c70

src/Hw4_Monotonicity_in_volatility.ipynb

Jun-629/20MA573

addad663d2dede0422ae690e49b230815aea4c70

2020-02-05T21:42:08.000Z

2020-02-05T21:42:08.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

<table> <tr align=left><td> <td>Text provided under a Creative Commons Attribution license, CC-BY. All code is made available under the FSF-approved MIT license. (c) Kyle T. Mandli</td> </table> ```python from __future__ import print_function %matplotlib inline import numpy import matplotlib.pyplot as plt import warnings import sympy sympy.init_printing() ``` # Root Finding and Optimization Our goal in this section is to develop techniques to approximate the roots of a given function $f(x)$. That is find solutions $x$ such that $f(x)=0$. At first glance this may not seem like a meaningful exercise, however, this problem arises in a wide variety of circumstances. For example, suppose that you are trying to find a solution to the equation $$ x^2 + x = \alpha\sin{x}. $$ where $\alpha$ is a real parameter. Simply rearranging, the expression can be rewritten in the form $$ f(x) = x^2 + x -\alpha\sin{x} = 0. $$ Determining the roots of the function $f(x)$ is now equivalent to determining the solution to the original expression. Unfortunately, a number of other issues arise. In particular, with non-linear equations, there may be multiple solutions, or no real solutions at all. The task of approximating the roots of a function can be a deceptively difficult thing to do. For much of the treatment here we will ignore many details such as existence and uniqueness, but you should keep in mind that they are important considerations. **GOAL:** For this section we will focus on multiple techniques for efficiently and accurately solving the fundamental problem $f(x)=0$ for functions of a single variable. ### Objectives * Understand the general rootfinding problem as $f(x)=0$ * Understand the equivalent formulation as a fixed point problem $x = g(x)$ * Understand fixed point iteration and its stability analysis * Understand definitions of convergence and order of convergence * Understand practical rootfinding algorithms and their convergence * Bisection * Newton's method * Secant method * Hybrid methods and scipy.optimize routines (root_scalar) * Understand basic Optimization routines * Parabolic Interpolation * Golden Section Search * scipy.optimize routines (minimize_scalar and minimize) ### Example: Future Time Annuity Can I ever retire? $$ A = \frac{P}{(r / m)} \left[ \left(1 + \frac{r}{m} \right)^{m \cdot n} - 1 \right ] $$ * $A$ total value after $n$ years * $P$ is payment amount per compounding period * $m$ number of compounding periods per year * $r$ annual interest rate * $n$ number of years to retirement #### Question: For a fix monthly Payment $P$, what does the minimum interest rate $r$ need to be so I can retire in 20 years with \$1M. Set $P = \frac{\$18,000}{12} = \$1500, \quad m=12, \quad n=20$. $$ A = \frac{P}{(r / m)} \left[ \left(1 + \frac{r}{m} \right)^{m \cdot n} - 1 \right ] $$ ```python def total_value(P, m, r, n): """Total value of portfolio given parameters Based on following formula: A = \frac{P}{(r / m)} \left[ \left(1 + \frac{r}{m} \right)^{m \cdot n} - 1 \right ] :Input: - *P* (float) - Payment amount per compounding period - *m* (int) - number of compounding periods per year - *r* (float) - annual interest rate - *n* (float) - number of years to retirement :Returns: (float) - total value of portfolio """ return P / (r / float(m)) * ( (1.0 + r / float(m))**(float(m) * n) - 1.0) P = 1500.0 m = 12 n = 20.0 r = numpy.linspace(0.05, 0.15, 100) goal = 1e6 fig = plt.figure(figsize=(8,6)) axes = fig.add_subplot(1, 1, 1) axes.plot(r, total_value(P, m, r, 10),label='10 years',linewidth=2) axes.plot(r, total_value(P, m, r, 15),label='15 years',linewidth=2) axes.plot(r, total_value(P, m, r, n),label='20 years',linewidth=2) axes.plot(r, numpy.ones(r.shape) * goal, 'r--') axes.set_xlabel("r (interest rate)", fontsize=16) axes.set_ylabel("A (total value)", fontsize=16) axes.set_title("When can I retire?",fontsize=18) axes.ticklabel_format(axis='y', style='sci', scilimits=(-1,1)) axes.set_xlim((r.min(), r.max())) axes.set_ylim((total_value(P, m, r.min(), 10), total_value(P, m, r.max(), n))) axes.legend(loc='best') axes.grid() plt.show() ``` ## Fixed Point Iteration How do we go about solving this? Could try to solve at least partially for $r$: $$ A = \frac{P}{(r / m)} \left[ \left(1 + \frac{r}{m} \right)^{m \cdot n} - 1 \right ] ~~~~ \Rightarrow ~~~~~$$ $$ r = \frac{P \cdot m}{A} \left[ \left(1 + \frac{r}{m} \right)^{m \cdot n} - 1 \right ] ~~~~ \Rightarrow ~~~~~$$ $$ r = g(r)$$ or $$ g(r) - r = 0$$ #### Plot these $$ r = g(r) = \frac{P \cdot m}{A} \left[ \left(1 + \frac{r}{m} \right)^{m \cdot n} - 1 \right ]$$ ```python def g(P, m, r, n, A): """Reformulated minimization problem Based on following formula: g(r) = \frac{P \cdot m}{A} \left[ \left(1 + \frac{r}{m} \right)^{m \cdot n} - 1 \right ] :Input: - *P* (float) - Payment amount per compounding period - *m* (int) - number of compounding periods per year - *r* (float) - annual interest rate - *n* (float) - number of years to retirement - *A* (float) - total value after $n$ years :Returns: (float) - value of g(r) """ return P * m / A * ( (1.0 + r / float(m))**(float(m) * n) - 1.0) P = 1500.0 m = 12 n = 20.0 r = numpy.linspace(0.00, 0.1, 100) goal = 1e6 fig = plt.figure(figsize=(16,6)) axes = fig.add_subplot(1, 2, 1) axes.plot(r, g(P, m, r, n, goal),label='$g(r)$') axes.plot(r, r, 'r--',label='$r$') axes.set_xlabel("r (interest rate)",fontsize=16) axes.set_ylabel("$g(r)$",fontsize=16) axes.set_title("Minimum rate for a 20 year retirement?",fontsize=18) axes.set_ylim([0, 0.12]) axes.ticklabel_format(axis='y', style='sci', scilimits=(-1,1)) axes.set_xlim((0.00, 0.1)) axes.set_ylim((g(P, m, 0.00, n, goal), g(P, m, 0.1, n, goal))) axes.legend(fontsize=14) axes.grid() axes = fig.add_subplot(1, 2, 2) axes.plot(r, g(P, m, r, n, goal)-r,label='$r - g(r)$') axes.plot(r, numpy.zeros(r.shape), 'r--',label='$0$') axes.set_xlabel("r (interest rate)",fontsize=16) axes.set_ylabel("residual",fontsize=16) axes.set_title("Minimum rate for a 20 year retirement?",fontsize=18) axes.ticklabel_format(axis='y', style='sci', scilimits=(-1,1)) axes.set_xlim((0.00, 0.1)) axes.legend(fontsize=14) axes.grid() plt.show() ``` ### Question: A single root $r>0$ clearly exists around $r=0.088$. But how to find it? One option might be to take a guess say $r_0 = 0.088$ and form the iterative scheme $$ \begin{align} r_1 &= g(r_0)\\ r_2 &= g(r_1)\\ &\vdots \\ r_{k} &= g(r_{k-1})\\ \end{align} $$ and hope this converges as $k\rightarrow\infty$ (or faster) ### Easy enough to code ```python r = 0.088 K = 20 for k in range(K): print(r) r = g(P,m,r,n,goal) ``` ### Example 2: Let $f(x) = x - e^{-x}$, solve $f(x) = 0$ Equivalent to $x = e^{-x}$ or $x = g(x)$ where $g(x) = e^{-x}$ ```python x = numpy.linspace(0.2, 1.0, 100) fig = plt.figure(figsize=(16,6)) axes = fig.add_subplot(1, 2, 1) axes.plot(x, numpy.exp(-x), 'r',label='g(x)=exp(-x)$') axes.plot(x, x, label='$x$') axes.set_xlabel("$x$",fontsize=16) axes.legend() plt.grid() f = lambda x : x - numpy.exp(-x) axes = fig.add_subplot(1, 2, 2) axes.plot(x, f(x),label='$f(x) = x - g(x)$') axes.plot(x, numpy.zeros(x.shape), 'r--',label='$0$') axes.set_xlabel("$x$",fontsize=16) axes.set_ylabel("residual",fontsize=16) axes.ticklabel_format(axis='y', style='sci', scilimits=(-1,1)) axes.legend(fontsize=14) axes.grid() plt.show() plt.show() ``` #### Again, consider the iterative scheme set $x_0$ then compute $$ x_k = g(x_{k-1})\quad \mathrm{for}\quad k=1,2,3\ldots $$ or again in code ```python x = x0 for i in range(N): x = g(x) ``` ```python x = numpy.linspace(0.2, 1.0, 100) fig = plt.figure(figsize=(8,6)) axes = fig.add_subplot(1, 1, 1) axes.plot(x, numpy.exp(-x), 'r',label='$g(x)=exp(-x)$') axes.plot(x, x, 'b',label='$x$') axes.set_xlabel("x",fontsize=16) axes.legend(fontsize=14) x = 0.4 print('\tx\t exp(-x)\t residual') for steps in range(6): residual = numpy.abs(numpy.exp(-x) - x) print("{:12.7f}\t{:12.7f}\t{:12.7f}".format(x, numpy.exp(-x), residual)) axes.plot(x, numpy.exp(-x),'kx') axes.text(x+0.01, numpy.exp(-x)+0.01, steps, fontsize="15") x = numpy.exp(-x) plt.grid() plt.show() ``` ### Example 3: Let $f(x) = \ln x + x$ and solve $f(x) = 0$ or $x = -\ln x$. Note that this problem is equivalent to $x = e^{-x}$. ```python x = numpy.linspace(0.1, 1.0, 100) fig = plt.figure(figsize=(8,6)) axes = fig.add_subplot(1, 1, 1) axes.plot(x, -numpy.log(x), 'r',label='$g(x)=-\log(x)$') axes.plot(x, x, 'b',label='$x$') axes.set_xlabel("x",fontsize=16) axes.set_ylabel("f(x)",fontsize=16) axes.set_ylim([0, 1.5]) axes.legend(loc='best',fontsize=14) x = 0.55 print('\tx\t -log(x)\t residual') for steps in range(5): residual = numpy.abs(numpy.log(x) + x) print("{:12.7f}\t{:12.7f}\t{:12.7f}".format(x, -numpy.log(x), residual)) axes.plot(x, -numpy.log(x),'kx') axes.text(x + 0.01, -numpy.log(x) + 0.01, steps, fontsize="15") x = -numpy.log(x) plt.grid() plt.show() ``` ### These are equivalent problems! Something is awry... ## Analysis of Fixed Point Iteration Existence and uniqueness of fixed point problems *Existence:* Assume $g \in C[a, b]$, if the range of the mapping $y = g(x)$ satisfies $y \in [a, b] ~~ \forall ~~ x \in [a, b]$ then $g$ has a fixed point in $[a, b]$. ```python x = numpy.linspace(0.0, 1.0, 100) # Plot function and intercept fig = plt.figure(figsize=(8,6)) axes = fig.add_subplot(1, 1, 1) axes.plot(x, numpy.exp(-x), 'r',label='$g(x)$') axes.plot(x, x, 'b',label='$x$') axes.set_xlabel("x",fontsize=16) axes.legend(loc='best',fontsize=14) axes.set_title('$g(x) = e^{-x}$',fontsize=24) # Plot domain and range axes.plot(numpy.ones(x.shape) * 0.4, x, '--k') axes.plot(numpy.ones(x.shape) * 0.8, x, '--k') axes.plot(x, numpy.ones(x.shape) * numpy.exp(-0.4), '--k') axes.plot(x, numpy.ones(x.shape) * numpy.exp(-0.8), '--k') axes.plot(x, numpy.ones(x.shape) * 0.4, '--',color='gray',linewidth=.5) axes.plot(x, numpy.ones(x.shape) * 0.8, '--',color='gray',linewidth=.5) axes.set_xlim((0.0, 1.0)) axes.set_ylim((0.0, 1.0)) plt.show() ``` ```python x = numpy.linspace(0.1, 1.0, 100) fig = plt.figure(figsize=(8,6)) axes = fig.add_subplot(1, 1, 1) axes.plot(x, -numpy.log(x), 'r',label='$g(x)$') axes.plot(x, x, 'b',label='$x$') axes.set_xlabel("x",fontsize=16) axes.set_xlim([0.1, 1.0]) axes.set_ylim([0.1, 1.0]) axes.legend(loc='best',fontsize=14) axes.set_title('$g(x) = -\ln(x)$',fontsize=24) # Plot domain and range axes.plot(numpy.ones(x.shape) * 0.4, x, '--k') axes.plot(numpy.ones(x.shape) * 0.8, x, '--k') axes.plot(x, numpy.ones(x.shape) * -numpy.log(0.4), '--k') axes.plot(x, numpy.ones(x.shape) * -numpy.log(0.8), '--k') axes.plot(x, numpy.ones(x.shape) * 0.4, '--',color='gray',linewidth=.5) axes.plot(x, numpy.ones(x.shape) * 0.8, '--',color='gray',linewidth=.5) plt.show() ``` *Uniqueness:* Additionally, suppose $g'(x)$ is defined on $x \in [a, b]$ and $\exists K < 1$ such that $$ |g'(x)| \leq K < 1 \quad \forall \quad x \in (a,b) $$ then $g$ has a unique fixed point $P \in [a,b]$ ```python x = numpy.linspace(0.4, 0.8, 100) fig = plt.figure(figsize=(8,6)) axes = fig.add_subplot(1, 1, 1) axes.plot(x, numpy.abs(-numpy.exp(-x)), 'r') axes.plot(x, numpy.ones(x.shape), 'k--') axes.set_xlabel("$x$",fontsize=18) axes.set_ylabel("$|g\,'(x)|$",fontsize=18) axes.set_ylim((0.0, 1.1)) axes.set_title("$g(x) = e^{-x}$",fontsize=20) axes.grid() plt.show() ``` *Asymptotic convergence*: Behavior of fixed point iterations $$x_{k+1} = g(x_k)$$ Assume that a fixed point $x^\ast$ exists, such that $$ x^\ast = g(x^\ast) $$ Then define $$ x_{k+1} = x^\ast + e_{k+1} \quad \quad x_k = x^\ast + e_k $$ substituting $$ x^\ast + e_{k+1} = g(x^\ast + e_k) $$ Evaluate $$ g(x^\ast + e_k) $$ Taylor expand $g(x)$ about $x^\ast$ and substitute $$x = x_k = x^\ast + e_k$$ $$ g(x^\ast + e_k) = g(x^\ast) + g'(x^\ast) e_k + \frac{g''(x^\ast) e_k^2}{2} + O(e_k^3) $$ from our definition $$x^\ast + e_{k+1} = g(x^\ast + e_k)$$ we have $$ x^\ast + e_{k+1} = g(x^\ast) + g'(x^\ast) e_k + \frac{g''(x^\ast) e_k^2}{2} + O(e_k^3) $$ Note that because $x^* = g(x^*)$ these terms cancel leaving $$e_{k+1} = g'(x^*) e_k + \frac{g''(x^*) e_k^2}{2}$$ So if $|g'(x^*)| \leq K < 1$ we can conclude that $$|e_{k+1}| = K |e_k|$$ which shows convergence. Also note that $K$ is related to $|g'(x^*)|$. ### Convergence of iterative schemes Given any iterative scheme where $$|e_{k+1}| = C |e_k|^n$$ If $C < 1$ and: - $n=1$ then the scheme is **linearly convergent** - $n=2$ then the scheme is **quadratically convergent** - $n > 1$ the scheme can also be called **superlinearly convergent** If $C > 1$ then the scheme is **divergent** ### Examples Revisited * Example 1: $$ g(x) = e^{-x}\quad\mathrm{with}\quad x^* \approx 0.56 $$ $$|g'(x^*)| = |-e^{-x^*}| \approx 0.56$$ * Example 2: $$g(x) = - \ln x \quad \text{with} \quad x^* \approx 0.56$$ $$|g'(x^*)| = \frac{1}{|x^*|} \approx 1.79$$ * Example 3: The retirement problem $$ r = g(r) = \frac{P \cdot m}{A} \left[ \left(1 + \frac{r}{m} \right)^{m \cdot n} - 1 \right ] $$ ```python r, P, m, A, n = sympy.symbols('r P m A n') g_sym = P * m / A * ((1 + r /m)**(m * n) - 1) g_sym ``` ```python g_prime = g_sym.diff(r) g_prime ``` ```python r_star = 0.08985602484084668 print("g'(r*) = ", g_prime.subs({P: 1500.0, m: 12, n:20, A: 1e6, r: r_star})) print("g(r*) - r* = {}".format(g_sym.subs({P: 1500.0, m: 12, n:20, A: 1e6, r: r_star}) - r_star)) ``` * Example 3: The retirement problem $$ r = g(r) = \frac{P \cdot m}{A} \left[ \left(1 + \frac{r}{m} \right)^{m \cdot n} - 1 \right ] $$ ```python f = sympy.lambdify(r, g_prime.subs({P: 1500.0, m: 12, n:20, A: 1e6})) g = sympy.lambdify(r, g_sym.subs({P: 1500.0, m: 12, n:20, A: 1e6})) r = numpy.linspace(-0.01, 0.1, 100) fig = plt.figure(figsize=(7,5)) fig.set_figwidth(2. * fig.get_figwidth()) axes = fig.add_subplot(1, 2, 1) axes.plot(r, g(r),label='$g(r)$') axes.plot(r, r, 'r--',label='$r$') axes.set_xlabel("r (interest rate)",fontsize=14) axes.set_ylabel("$g(r)$",fontsize=14) axes.set_title("Minimum rate for a 20 year retirement?",fontsize=14) axes.set_ylim([0, 0.12]) axes.ticklabel_format(axis='y', style='sci', scilimits=(-1,1)) axes.set_xlim((0.00, 0.1)) axes.set_ylim(g(0.00), g(0.1)) axes.legend() axes.grid() axes = fig.add_subplot(1, 2, 2) axes.plot(r, f(r)) axes.plot(r, numpy.ones(r.shape), 'k--') axes.plot(r_star, f(r_star), 'ro') axes.plot(0.0, f(0.0), 'ro') axes.set_xlim((-0.01, 0.1)) axes.set_xlabel("$r$",fontsize=14) axes.set_ylabel("$g'(r)$",fontsize=14) axes.grid() plt.show() ``` ## Better ways for root-finding/optimization If $x^*$ is a fixed point of $g(x)$ then $x^*$ is also a *root* of $f(x^*) = g(x^*) - x^*$ s.t. $f(x^*) = 0$. For instance: $$f(r) = r - \frac{m P}{A} \left [ \left (1 + \frac{r}{m} \right)^{m n} - 1 \right ] =0 $$ or $$f(r) = A - \frac{m P}{r} \left [ \left (1 + \frac{r}{m} \right)^{m n} - 1 \right ] =0 $$ ## Classical Methods - Bisection (linear convergence) - Newton's Method (quadratic convergence) - Secant Method (super-linear) ## Combined Methods - RootSafe (Newton + Bisection) - Brent's Method (Secant + Bisection) ### Bracketing and Bisection A **bracket** is an interval $[a,b]$ that contains at least one zero or minima/maxima of interest. In the case of a zero the bracket should satisfy $$ \text{sign}(f(a)) \neq \text{sign}(f(b)). $$ In the case of minima or maxima we need $$ \text{sign}(f'(a)) \neq \text{sign}(f'(b)) $$ **Theorem**: Let $$ f(x) \in C[a,b] \quad \text{and} \quad \text{sign}(f(a)) \neq \text{sign}(f(b)) $$ then there exists a number $$ c \in (a,b) \quad \text{s.t.} \quad f(c) = 0. $$ (proof uses intermediate value theorem) **Example**: The retirement problem again. For fixed $A, P, m, n$ $$ f(r) = A - \frac{P}{(r / m)} \left[ \left(1 + \frac{r}{m} \right)^{m \cdot n} - 1 \right ] $$ ```python P = 1500.0 m = 12 n = 20.0 A = 1e6 r = numpy.linspace(0.05, 0.1, 100) f = lambda r, A, m, P, n: A - m * P / r * ((1.0 + r / m)**(m * n) - 1.0) fig = plt.figure(figsize=(8, 6)) axes = fig.add_subplot(1, 1, 1) axes.plot(r, f(r, A, m, P, n), 'b') axes.plot(r, numpy.zeros(r.shape),'r--') axes.set_xlabel("r", fontsize=16) axes.set_ylabel("f(r)", fontsize=16) axes.ticklabel_format(axis='y', style='sci', scilimits=(-1,1)) axes.grid() a = 0.075 b = 0.095 axes.plot(a, f(a, A, m, P, n), 'ko') axes.plot([a, a], [0.0, f(a, A, m, P, n)], 'k--') axes.plot(b, f(b, A, m, P, n), 'ko') axes.plot([b, b], [f(b, A, m, P, n), 0.0], 'k--') plt.show() ``` Basic bracketing algorithms shrink the bracket while ensuring that the root/extrema remains within the bracket. What ways could we "shrink" the bracket so that the end points converge to the root/extrema? #### Bisection Algorithm Given a bracket $[a,b]$ and a function $f(x)$ - 1. Initialize with bracket 2. Iterate 1. Cut bracket in half and check to see where the zero is 2. Set bracket to new bracket based on what direction we went ##### basic code ```python def bisection(f,a,b,tol): c = (a + b)/2. f_a = f(a) f_b = f(b) f_c = f(c) for step in range(1, MAX_STEPS + 1): if numpy.abs(f_c) < tol: break if numpy.sign(f_a) != numpy.sign(f_c): b = c f_b = f_c else: a = c f_a = f_c c = (a + b)/ 2.0 f_c = f(c) return c ``` ### Some real code ```python # real code with standard bells and whistles def bisection(f,a,b,tol = 1.e-6): """ uses bisection to isolate a root x of a function of a single variable f such that f(x) = 0. the root must exist within an initial bracket a < x < b returns when f(x) at the midpoint of the bracket < tol Parameters: ----------- f: function of a single variable f(x) of type float a: float left bracket a < x b: float right bracket x < b Note: the signs of f(a) and f(b) must be different to insure a bracket tol: float tolerance. Returns when |f((a+b)/2)| < tol Returns: -------- x: float midpoint of final bracket x_array: numpy array history of bracket centers (for plotting later) Raises: ------- ValueError: if initial bracket is invalid Warning: if number of iterations exceed MAX_STEPS """ MAX_STEPS = 1000 # initialize c = (a + b)/2. c_array = [ c ] f_a = f(a) f_b = f(b) f_c = f(c) # check bracket if numpy.sign(f_a) == numpy.sign(f_b): raise ValueError("no bracket: f(a) and f(b) must have different signs") # Loop until we reach the TOLERANCE or we take MAX_STEPS for step in range(1, MAX_STEPS + 1): # Check tolerance - Could also check the size of delta_x # We check this first as we have already initialized the values # in c and f_c if numpy.abs(f_c) < tol: break if numpy.sign(f_a) != numpy.sign(f_c): b = c f_b = f_c else: a = c f_a = f_c c = (a + b)/2. f_c = f(c) c_array.append(c) if step == MAX_STEPS: warnings.warn('Maximum number of steps exceeded') return c, numpy.array(c_array) ``` ```python # set up function as an inline lambda function P = 1500.0 m = 12 n = 20.0 A = 1e6 f = lambda r: A - m * P / r * ((1.0 + r / m)**(m * n) - 1.0) # Initialize bracket a = 0.07 b = 0.10 ``` ```python # find root r_star, r_array = bisection(f, a, b, tol=1e-8) print('root at r = {}, f(r*) = {}, {} steps'.format(r_star,f(r_star),len(r_array))) ``` ```python r = numpy.linspace(0.05, 0.11, 100) # Setup figure to plot convergence fig = plt.figure(figsize=(8,6)) axes = fig.add_subplot(1, 1, 1) axes.plot(r, f(r), 'b') axes.plot(r, numpy.zeros(r.shape),'r--') axes.set_xlabel("r", fontsize=16) axes.set_ylabel("f(r)", fontsize=16) # axes.set_xlim([0.085, 0.091]) axes.ticklabel_format(axis='y', style='sci', scilimits=(-1,1)) axes.plot(a, f(a), 'ko') axes.plot([a, a], [0.0, f(a)], 'k--') axes.text(a, f(a), str(0), fontsize="15") axes.plot(b, f(b), 'ko') axes.plot([b, b], [f(b), 0.0], 'k--') axes.text(b, f(b), str(1), fontsize="15") axes.grid() # plot out the first N steps N = 5 for k,r in enumerate(r_array[:N]): # Plot iteration axes.plot(r, f(r),'kx') axes.text(r, f(r), str(k + 2), fontsize="15") axes.plot(r_star, f(r_star), 'go', markersize=10) axes.set_title('Bisection method: first {} steps'.format(N), fontsize=20) plt.show() ``` What is the smallest tolerance that can be achieved with this routine? Why? ```python # find root r_star, r_array = bisection(f, a, b, tol=1e-8 ) print('root at r = {}, f(r*) = {}, {} steps'.format(r_star,f(r_star),len(r_array))) ``` ```python # this might be useful print(numpy.diff(r_array)) ``` #### Convergence of Bisection Generally have $$ |e_{k+1}| = C |e_k|^n $$ where we need $C < 1$ and $n > 0$. Letting $\Delta x_k$ be the width of the $k$th bracket we can then estimate the error with $$ e_k \approx \Delta x_k $$ and therefore $$ e_{k+1} \approx \frac{1}{2} \Delta x_k. $$ Due to the relationship then between $x_k$ and $e_k$ we then know $$ |e_{k+1}| = \frac{1}{2} |e_k| $$ so therefore the method is linearly convergent. ### Newton's Method (Newton-Raphson) - Given a bracket, bisection is guaranteed to converge linearly to a root - However bisection uses almost no information about $f(x)$ beyond its sign at a point - Can we do "better"? <font color='red'>Newton's method</font>, *when well behaved* can achieve quadratic convergence. **Basic Ideas**: There are multiple interpretations we can use to derive Newton's method * Use Taylor's theorem to estimate a correction to minimize the residual $f(x)=0$ * A geometric interpretation that approximates $f(x)$ locally as a straight line to predict where $x^*$ might be. * As a special case of a fixed-point iteration Perhaps the simplest derivation uses Taylor series. Consider an initial guess at point $x_k$. For arbitrary $x_k$, it's unlikely $f(x_k)=0$. However we can hope there is a correction $\delta_k$ such that at $$ x_{k+1} = x_k + \delta_k $$ and $$ f(x_{k+1}) = 0 $$ expanding in a Taylor series around point $x_k$ $$ f(x_k + \delta_k) \approx f(x_k) + f'(x_k) \delta_k + O(\delta_k^2) $$ substituting into $f(x_{k+1})=0$ and dropping the higher order terms gives $$ f(x_k) + f'(x_k) \delta_k =0 $$ substituting into $f(x_{k+1})=0$ and dropping the higher order terms gives $$ f(x_k) + f'(x_k) \delta_k =0 $$ or solving for the correction $$ \delta_k = -f(x_k)/f'(x_k) $$ which leads to the update for the next iteration $$ x_{k+1} = x_k + \delta_k $$ or $$ x_{k+1} = x_k -f(x_k)/f'(x_k) $$ rinse and repeat, as it's still unlikely that $f(x_{k+1})=0$ (but we hope the error will be reduced) ### Algorithm 1. Initialize $x = x_0$ 1. While ( $f(x) > tol$ ) - solve $\delta = -f(x)/f'(x)$ - update $x \leftarrow x + \delta$ ### Geometric interpretation By truncating the taylor series at first order, we are locally approximating $f(x)$ as a straight line tangent to the point $f(x_k)$. If the function was linear at that point, we could find its intercept such that $f(x_k+\delta_k)=0$ ```python P = 1500.0 m = 12 n = 20.0 A = 1e6 r = numpy.linspace(0.05, 0.11, 100) f = lambda r, A=A, m=m, P=P, n=n: \ A - m * P / r * ((1.0 + r / m)**(m * n) - 1.0) f_prime = lambda r, A=A, m=m, P=P, n=n: \ -P*m*n*(1.0 + r/m)**(m*n)/(r*(1.0 + r/m)) \ + P*m*((1.0 + r/m)**(m*n) - 1.0)/r**2 # Initial guess x_k = 0.06 # Setup figure to plot convergence fig = plt.figure(figsize=(8,6)) axes = fig.add_subplot(1, 1, 1) axes.plot(r, f(r), 'b') axes.plot(r, numpy.zeros(r.shape),'r--') # Plot x_k point axes.plot([x_k, x_k], [0.0, f(x_k)], 'k--') axes.plot(x_k, f(x_k), 'ko') axes.text(x_k, -5e4, "$x_k$", fontsize=16) axes.plot(x_k, 0.0, 'xk') axes.text(x_k, f(x_k) + 2e4, "$f(x_k)$", fontsize=16) axes.plot(r, f_prime(x_k) * (r - x_k) + f(x_k), 'k') # Plot x_{k+1} point x_k = x_k - f(x_k) / f_prime(x_k) axes.plot([x_k, x_k], [0.0, f(x_k)], 'k--') axes.plot(x_k, f(x_k), 'ko') axes.text(x_k, 1e4, "$x_{k+1}$", fontsize=16) axes.plot(x_k, 0.0, 'xk') axes.text(0.0873, f(x_k) - 2e4, "$f(x_{k+1})$", fontsize=16) axes.set_xlabel("r",fontsize=16) axes.set_ylabel("f(r)",fontsize=16) axes.set_title("Newton-Raphson Steps",fontsize=18) axes.ticklabel_format(axis='y', style='sci', scilimits=(-1,1)) axes.grid() plt.show() ``` If we simply approximate the derivative $f'(x_k)$ with its finite difference approximation $$ f'(x_k) \approx \frac{0 - f(x_k)}{x_{k+1} - x_k} $$ we can rearrange to find $x_{k+1}$ as $$ x_{k+1} = x_k - \frac{f(x_k)}{f'(x_k)} $$ which is the classic Newton-Raphson iteration ### Some code ```python def newton(f,f_prime,x0,tol = 1.e-6): """ uses newton's method to find a root x of a function of a single variable f Parameters: ----------- f: function f(x) returns type: float f_prime: function f'(x) returns type: float x0: float initial guess tolerance: float Returns when |f(x)| < tol Returns: -------- x: float final iterate x_array: numpy array history of iteration points Raises: ------- Warning: if number of iterations exceed MAX_STEPS """ MAX_STEPS = 200 x = x0 x_array = [ x0 ] for k in range(1, MAX_STEPS + 1): x = x - f(x) / f_prime(x) x_array.append(x) if numpy.abs(f(x)) < tol: break if k == MAX_STEPS: warnings.warn('Maximum number of steps exceeded') return x, numpy.array(x_array) ``` ### Set the problem up ```python P = 1500.0 m = 12 n = 20.0 A = 1e6 f = lambda r, A=A, m=m, P=P, n=n: \ A - m * P / r * ((1.0 + r / m)**(m * n) - 1.0) f_prime = lambda r, A=A, m=m, P=P, n=n: \ -P*m*n*(1.0 + r/m)**(m*n)/(r*(1.0 + r/m)) \ + P*m*((1.0 + r/m)**(m*n) - 1.0)/r**2 ``` ### and solve ```python x0 = 0.06 x, x_array = newton(f, f_prime, x0, tol=1.e-8) print('x = {}, f(x) = {}, Nsteps = {}'.format(x, f(x), len(x_array))) print(f_prime(x)*numpy.finfo('float').eps) ``` ```python r = numpy.linspace(0.05, 0.10, 100) # Setup figure to plot convergence fig = plt.figure(figsize=(16,6)) axes = fig.add_subplot(1, 2, 1) axes.plot(r, f(r), 'b') axes.plot(r, numpy.zeros(r.shape),'r--') for n, x in enumerate(x_array): axes.plot(x, f(x),'kx') axes.text(x, f(x), str(n), fontsize="15") axes.set_xlabel("r", fontsize=16) axes.set_ylabel("f(r)", fontsize=16) axes.set_title("Newton-Raphson Steps", fontsize=18) axes.grid() axes.ticklabel_format(axis='y', style='sci', scilimits=(-1,1)) axes = fig.add_subplot(1, 2, 2) axes.semilogy(numpy.arange(len(x_array)), numpy.abs(f(x_array)), 'bo-') axes.grid() axes.set_xlabel('Iterations', fontsize=16) axes.set_ylabel('Residual $|f(r)|$', fontsize=16) axes.set_title('Convergence', fontsize=18) plt.show() ``` What is the smallest tolerance that can be achieved with this routine? Why? ### Example: $$f(x) = x - e^{-x}$$ $$f'(x) = 1 + e^{-x}$$ $$x_{k+1} = x_k - \frac{f(x_k)}{f'(x_k)} = x_k - \frac{x_k - e^{-x_k}}{1 + e^{-x_k}}$$ #### setup in sympy ```python x = sympy.symbols('x') f = x - sympy.exp(-x) f_prime = f.diff(x) f, f_prime ``` #### and solve ```python f = sympy.lambdify(x,f) f_prime = sympy.lambdify(x,f_prime) x0 = 0. x, x_array = newton(f, f_prime, x0, tol = 1.e-9) print('x = {}, f(x) = {}, Nsteps = {}'.format(x, f(x), len(x_array))) ``` ```python xa = numpy.linspace(-1,1,100) fig = plt.figure(figsize=(16,6)) axes = fig.add_subplot(1,2,1) axes.plot(xa,f(xa),'b') axes.plot(xa,numpy.zeros(xa.shape),'r--') axes.plot(x,f(x),'go', markersize=10) axes.plot(x0,f(x0),'kx',markersize=10) axes.grid() axes.set_xlabel('x', fontsize=16) axes.set_ylabel('f(x)', fontsize=16) axes.set_title('$f(x) = x - e^{-x}$', fontsize=18) axes = fig.add_subplot(1, 2, 2) axes.semilogy(numpy.arange(len(x_array)), numpy.abs(f(x_array)), 'bo-') axes.grid() axes.set_xlabel('Iterations', fontsize=16) axes.set_ylabel('Residual $|f(r)|$', fontsize=16) axes.set_title('Convergence', fontsize=18) plt.show() ``` ### Asymptotic Convergence of Newton's Method Newton's method can be also considered a fixed point iteration $$x_{k+1} = g(x_k)$$ with $g(x) = x - \frac{f(x)}{f'(x)}$ Again if $x^*$ is the fixed point and $e_k$ the error at iteration $k$: $$x_{k+1} = x^* + e_{k+1} \quad \quad x_k = x^* + e_k$$ Taylor Expansion around $x^*$ $$ x^* + e_{k+1} = g(x^* + e_k) = g(x^*) + g'(x^*) e_k + \frac{g''(x^*) e_k^2}{2!} + O(e_k^3) $$ Note that as before $x^*$ and $g(x^*)$ cancel: $$e_{k+1} = g'(x^*) e_k + \frac{g''(x^*) e_k^2}{2!} + \ldots$$ What about $g'(x^*)$ though? $$\begin{aligned} g(x) &= x - \frac{f(x)}{f'(x)} \\ g'(x) & = 1 - \frac{f'(x)}{f'(x)} + \frac{f(x) f''(x)}{(f'(x))^2} = \frac{f(x) f''(x)}{(f'(x))^2} \end{aligned}$$ which evaluated at $x = x^*$ becomes $$ g'(x^*) = \frac{f(x^*)f''(x^*)}{f'(x^*)^2} = 0 $$ since $f(x^\ast) = 0$ by definition (assuming $f''(x^\ast)$ and $f'(x^\ast)$ are appropriately behaved). Back to our expansion we have again $$ e_{k+1} = g'(x^*) e_k + \frac{g''(x^*) e_k^2}{2!} + \ldots $$ which simplifies to $$ e_{k+1} = \frac{g''(x^*) e_k^2}{2!} + \ldots $$ which leads to $$ |e_{k+1}| < \left | \frac{g''(x^*)}{2!} \right | |e_k|^2 $$ Newton's method is therefore quadratically convergent where the constant is controlled by the second derivative. #### Example: Convergence for a non-simple root Consider our first problem $$ f(x) = x^2 + x - \sin(x) $$ the case is, unfortunately, not as rosey. Why might this be? #### Setup the problem ```python f = lambda x: x*x + x - numpy.sin(x) f_prime = lambda x: 2*x + 1. - numpy.cos(x) x0 = .9 x, x_array = newton(f, f_prime, x0, tol= 1.e-16) print('x = {}, f(x) = {}, Nsteps = {}'.format(x, f(x), len(x_array))) ``` ```python xa = numpy.linspace(-2,2,100) fig = plt.figure(figsize=(16,6)) axes = fig.add_subplot(1,2,1) axes.plot(xa,f(xa),'b') axes.plot(xa,numpy.zeros(xa.shape),'r--') axes.plot(x,f(x),'go', markersize=10) axes.plot(x0,f(x0),'kx', markersize=10) axes.grid() axes.set_xlabel('x', fontsize=16) axes.set_ylabel('f(x)', fontsize=16) axes.set_title('$f(x) = x^2 +x - sin(x)$', fontsize=18) axes = fig.add_subplot(1, 2, 2) axes.semilogy(numpy.arange(len(x_array)), numpy.abs(f(x_array)), 'bo-') axes.grid() axes.set_xlabel('Iterations', fontsize=16) axes.set_ylabel('Residual $|f(r)|$', fontsize=16) axes.set_title('Convergence', fontsize=18) plt.show() ``` ### Convergence appears linear, can you show this?: $$f(x) = x^2 + x -\sin (x)$$ ### Example: behavior of Newton with multiple roots $f(x) = \sin (2 \pi x)$ $$x_{k+1} = x_k - \frac{\sin (2 \pi x_k)}{2 \pi \cos (2 \pi x_k)}= x_k - \frac{1}{2 \pi} \tan (2 \pi x_k)$$ ```python x = numpy.linspace(0, 2, 1000) f = lambda x: numpy.sin(2.0 * numpy.pi * x) f_prime = lambda x: 2.0 * numpy.pi * numpy.cos(2.0 * numpy.pi * x) x_kp = lambda x: x - f(x)/f_prime(x) fig = plt.figure(figsize=(16,6)) axes = fig.add_subplot(1, 2, 1) axes.plot(x, f(x),'b') axes.plot(x, f_prime(x), 'r') axes.set_xlabel("x") axes.set_ylabel("y") axes.set_title("Comparison of $f(x)$ and $f'(x)$") axes.set_ylim((-2,2)) axes.set_xlim((0,2)) axes.plot(x, numpy.zeros(x.shape), 'k--') x_k = 0.3 axes.plot([x_k, x_k], [0.0, f(x_k)], 'ko') axes.plot([x_k, x_k], [0.0, f(x_k)], 'k--') axes.plot(x, f_prime(x_k) * (x - x_k) + f(x_k), 'k') x_k = x_k - f(x_k) / f_prime(x_k) axes.plot([x_k, x_k], [0.0, f(x_k)], 'ko') axes.plot([x_k, x_k], [0.0, f(x_k)], 'k--') axes = fig.add_subplot(1, 2, 2) axes.plot(x, f(x),'b') axes.plot(x, x_kp(x), 'r') axes.set_xlabel("x") axes.set_ylabel("y") axes.set_title("Comparison of $f(x)$ and $x_{k+1}(x)$",fontsize=18) axes.set_ylim((-2,2)) axes.set_xlim((0,2)) axes.plot(x, numpy.zeros(x.shape), 'k--') plt.show() ``` ### Basins of Attraction Given a point $x_0$ can we determine if Newton-Raphson converges and to **which root** it converges to? A *basin of attraction* $X$ for Newton's methods is defined as the set such that $\forall x \in X$ Newton iterations converges to the same root. Unfortunately this is far from a trivial thing to determine and even for simple functions can lead to regions that are complicated or even fractal. ```python # calculate the basin of attraction for f(x) = sin(2\pi x) x_root = numpy.zeros(x.shape) N_steps = numpy.zeros(x.shape) for i,xk in enumerate(x): x_root[i], x_root_array = newton(f, f_prime, xk) N_steps[i] = len(x_root_array) ``` ```python y = numpy.linspace(-2,2) X,Y = numpy.meshgrid(x,y) X_root = numpy.outer(numpy.ones(y.shape),x_root) plt.figure(figsize=(8, 6)) plt.pcolor(X, Y, X_root,vmin=-5, vmax=5,cmap='seismic') cbar = plt.colorbar() cbar.set_label('$x_{root}$', fontsize=18) plt.plot(x, f(x), 'k-') plt.plot(x, numpy.zeros(x.shape),'k--', linewidth=0.5) plt.xlabel('x', fontsize=16) plt.title('Basins of Attraction: $f(x) = \sin{2\pi x}$', fontsize=18) #plt.xlim(0.25-.1,0.25+.1) plt.show() ``` ### Fractal Basins of Attraction If $f(x)$ is complex (for $x$ complex), then the basins of attraction can be beautiful and fractal Plotted below are two fairly simple equations which demonstrate the issue: 1. $f(x) = x^3 - 1$ 2. Kepler's equation $\theta - e \sin \theta = M$ ```python f = lambda x: x**3 - 1 f_prime = lambda x: 3 * x**2 N = 1001 x = numpy.linspace(-2, 2, N) X, Y = numpy.meshgrid(x, x) R = X + 1j * Y for i in range(30): R = R - f(R) / f_prime(R) roots = numpy.roots([1., 0., 0., -1]) fig = plt.figure() fig.set_figwidth(fig.get_figwidth() * 2) fig.set_figheight(fig.get_figheight() * 2) axes = fig.add_subplot(1, 1, 1, aspect='equal') #axes.contourf(X, Y, numpy.sign(numpy.imag(R))*numpy.abs(R),vmin = -10, vmax = 10) axes.contourf(X, Y, R, vmin = -8, vmax= 8.) axes.scatter(numpy.real(roots), numpy.imag(roots)) axes.set_xlabel("Real") axes.set_ylabel("Imaginary") axes.set_title("Basin of Attraction for $f(x) = x^3 - 1$") axes.grid() plt.show() ``` ```python def f(theta, e=0.083, M=1): return theta - e * numpy.sin(theta) - M def f_prime(theta, e=0.083): return 1 - e * numpy.cos(theta) N = 1001 x = numpy.linspace(-30.5, -29.5, N) y = numpy.linspace(-17.5, -16.5, N) X, Y = numpy.meshgrid(x, y) R = X + 1j * Y for i in range(30): R = R - f(R) / f_prime(R) fig = plt.figure() fig.set_figwidth(fig.get_figwidth() * 2) fig.set_figheight(fig.get_figheight() * 2) axes = fig.add_subplot(1, 1, 1, aspect='equal') axes.contourf(X, Y, R, vmin = 0, vmax = 10) axes.set_xlabel("Real") axes.set_ylabel("Imaginary") axes.set_title("Basin of Attraction for $f(x) = x - e \sin x - M$") plt.show() ``` #### Other Issues Need to supply both $f(x)$ and $f'(x)$, could be expensive Example: FTV equation $f(r) = A - \frac{m P}{r} \left[ \left(1 + \frac{r}{m} \right )^{m n} - 1\right]$ Can use symbolic differentiation (`sympy`) ### Secant Methods Is there a method with the convergence of Newton's method but without the extra derivatives? What way would you modify Newton's method so that you would not need $f'(x)$? Given $x_k$ and $x_{k-1}$ represent the derivative as the approximation $$f'(x) \approx \frac{f(x_k) - f(x_{k-1})}{x_k - x_{k-1}}$$ Combining this with the Newton approach leads to $$x_{k+1} = x_k - \frac{f(x_k) (x_k - x_{k-1}) }{f(x_k) - f(x_{k-1})}$$ This leads to superlinear convergence and not quite quadratic as the exponent on the convergence is $\approx 1.7$. Alternative interpretation, fit a line through two points and see where they intersect the x-axis. $$(x_k, f(x_k)) ~~~~~ (x_{k-1}, f(x_{k-1})$$ $$y = \frac{f(x_k) - f(x_{k-1})}{x_k - x_{k-1}} (x - x_k) + b$$ $$b = f(x_{k-1}) - \frac{f(x_k) - f(x_{k-1})}{x_k - x_{k-1}} (x_{k-1} - x_k)$$ $$ y = \frac{f(x_k) - f(x_{k-1})}{x_k - x_{k-1}} (x - x_k) + f(x_k)$$ Now solve for $x_{k+1}$ which is where the line intersects the x-axies ($y=0$) $$0 = \frac{f(x_k) - f(x_{k-1})}{x_k - x_{k-1}} (x_{k+1} - x_k) + f(x_k)$$ $$x_{k+1} = x_k - \frac{f(x_k) (x_k - x_{k-1})}{f(x_k) - f(x_{k-1})}$$ #### Secant Method $$x_{k+1} = x_k - \frac{f(x_k) (x_k - x_{k-1})}{f(x_k) - f(x_{k-1})}$$ ```python P = 1500.0 m = 12 n = 20.0 A = 1e6 r = numpy.linspace(0.05, 0.11, 100) f = lambda r, A=A, m=m, P=P, n=n: \ A - m * P / r * ((1.0 + r / m)**(m * n) - 1.0) # Initial guess x_k = 0.07 x_km = 0.06 fig = plt.figure(figsize=(8,6)) axes = fig.add_subplot(1, 1, 1) axes.plot(r, f(r), 'b') axes.plot(r, numpy.zeros(r.shape),'r--') axes.plot(x_k, 0.0, 'ko') axes.plot(x_k, f(x_k), 'ko') axes.plot([x_k, x_k], [0.0, f(x_k)], 'k--') axes.plot(x_km, 0.0, 'ko') axes.plot(x_km, f(x_km), 'ko') axes.plot([x_km, x_km], [0.0, f(x_km)], 'k--') axes.plot(r, (f(x_k) - f(x_km)) / (x_k - x_km) * (r - x_k) + f(x_k), 'k') x_kp = x_k - (f(x_k) * (x_k - x_km) / (f(x_k) - f(x_km))) axes.plot(x_kp, 0.0, 'ro') axes.plot([x_kp, x_kp], [0.0, f(x_kp)], 'r--') axes.plot(x_kp, f(x_kp), 'ro') axes.set_xlabel("r", fontsize=16) axes.set_ylabel("f(r)", fontsize=14) axes.set_title("Secant Method", fontsize=18) axes.ticklabel_format(axis='y', style='sci', scilimits=(-1,1)) axes.grid() plt.show() ``` What would the algorithm look like for such a method? #### Algorithm Given $f(x)$, a `TOLERANCE`, and a `MAX_STEPS` 1. Initialize two points $x_0$, $x_1$, $f_0 = f(x_0)$, and $f_1 = f(x_1)$ 2. Loop for k=2, to `MAX_STEPS` is reached or `TOLERANCE` is achieved 1. Calculate new update $$x_{2} = x_1 - \frac{f(x_1) (x_1 - x_{0})}{f(x_1) - f(x_{0})}$$ 2. Check for convergence and break if reached 3. Update parameters $x_0 = x_1$, $x_1 = x_{2}$, $f_0 = f_1$ and $f_1 = f(x_1)$ #### Some Code ```python def secant(f, x0, x1, tol = 1.e-6): """ uses a linear secant method to find a root x of a function of a single variable f Parameters: ----------- f: function f(x) returns type: float x0: float first point to initialize the algorithm x1: float second point to initialize the algorithm x1 != x0 tolerance: float Returns when |f(x)| < tol Returns: -------- x: float final iterate x_array: numpy array history of iteration points Raises: ------- ValueError: if x1 is too close to x0 Warning: if number of iterations exceed MAX_STEPS """ MAX_STEPS = 200 if numpy.isclose(x0, x1): raise ValueError('Initial points are too close (preferably should be a bracket)') x_array = [ x0, x1 ] for k in range(1, MAX_STEPS + 1): x2 = x1 - f(x1) * (x1 - x0) / (f(x1) - f(x0)) x_array.append(x2) if numpy.abs(f(x2)) < tol: break x0 = x1 x1 = x2 if k == MAX_STEPS: warnings.warn('Maximum number of steps exceeded') return x2, numpy.array(x_array) ``` ### Set the problem up ```python P = 1500.0 m = 12 n = 20.0 A = 1e6 r = numpy.linspace(0.05, 0.11, 100) f = lambda r, A=A, m=m, P=P, n=n: \ A - m * P / r * ((1.0 + r / m)**(m * n) - 1.0) ``` ### and solve ```python x0 = 0.06 x1 = 0.07 x, x_array = secant(f, x0, x1, tol= 1.e-7) print('x = {}, f(x) = {}, Nsteps = {}'.format(x, f(x), len(x_array))) ``` ```python r = numpy.linspace(0.05, 0.10, 100) # Setup figure to plot convergence fig = plt.figure(figsize=(16,6)) axes = fig.add_subplot(1, 2, 1) axes.plot(r, f(r), 'b') axes.plot(r, numpy.zeros(r.shape),'r--') for n, x in enumerate(x_array): axes.plot(x, f(x),'kx') axes.text(x, f(x), str(n), fontsize="15") axes.set_xlabel("r", fontsize=16) axes.set_ylabel("f(r)", fontsize=16) axes.set_title("Secant Method Steps", fontsize=18) axes.grid() axes.ticklabel_format(axis='y', style='sci', scilimits=(-1,1)) axes = fig.add_subplot(1, 2, 2) axes.semilogy(numpy.arange(len(x_array)), numpy.abs(f(x_array)), 'bo-') axes.grid() axes.set_xlabel('Iterations', fontsize=16) axes.set_ylabel('Residual $|f(r)|$', fontsize=16) axes.set_title('Convergence', fontsize=18) plt.show() ``` #### Comments - Secant method as shown is equivalent to linear interpolation - Can use higher order interpolation for higher order secant methods - Convergence is not quite quadratic - Not guaranteed to converge - Does not preserve brackets - Almost as good as Newton's method if your initial guess is good. ### Hybrid Methods Combine attributes of methods with others to make one great algorithm to rule them all (not really) #### Goals 1. Robustness: Given a bracket $[a,b]$, maintain bracket 1. Efficiency: Use superlinear convergent methods when possible #### Options - Methods requiring $f'(x)$ - NewtSafe (RootSafe, Numerical Recipes) - Newton's Method within a bracket, Bisection otherwise - Methods not requiring $f'(x)$ - Brent's Algorithm (zbrent, Numerical Recipes) - Combination of bisection, secant and inverse quadratic interpolation - `scipy.optimize` package **new** root_scalar ```python from scipy.optimize import root_scalar #root_scalar? ``` ### Set the problem up (again) ```python def f(r,A,m,P,n): return A - m * P / r * ((1.0 + r / m)**(m * n) - 1.0) def f_prime(r,A,m,P,n): return (-P*m*n*(1.0 + r/m)**(m*n)/(r*(1.0 + r/m)) + P*m*((1.0 + r/m)**(m*n) - 1.0)/r**2) A = 1.e6 m = 12 P = 1500. n = 20. ``` Try Brent's method ```python a = 0.07 b = 0.1 sol = root_scalar(f,args=(A,m,P,n), bracket=(a, b), method='brentq') print(sol) ``` Try Newton's method ```python sol = root_scalar(f,args=(A,m,P,n), x0=.07, fprime=f_prime, method='newton') print(sol) ``` ```python # Try something else ``` ## Optimization (finding extrema) I want to find the extrema of a function $f(x)$ on a given interval $[a,b]$. A few approaches: - Interpolation Algorithms: Repeated parabolic interpolation - Bracketing Algorithms: Golden-Section Search (linear) - Hybrid Algorithms ### Interpolation Approach Successive parabolic interpolation - similar to secant method Basic idea: Fit polynomial to function using three points, find its minima, and guess new points based on that minima 1. What do we need to fit a polynomial $p_n(x)$ of degree $n \geq 2$? 2. How do we construct the polynomial $p_2(x)$? 3. Once we have constructed $p_2(x)$ how would we find the minimum? #### Algorithm Given $f(x)$ and $[x_0,x_1]$ - Note that unlike a bracket these will be a sequence of better approximations to the minimum. 1. Initialize $x = [x_0, x_1, (x_0+x_1)/2]$ 1. Loop 1. Evaluate function $f(x)$ at the three points 1. Find the quadratic polynomial that interpolates those points: $$p(x) = p_0 x^2 + p_1 x + p_2$$ 3. Calculate the minimum: $$p'(x) = 2 p_0 x + p_1 = 0 \quad \Rightarrow \quad x^\ast = -p_1 / (2 p_0)$$ 1. New set of points $x = [x_1, (x_0+x_1)/2, x^\ast]$ 1. Check tolerance ### Demo ```python def f(t): """Simple function for minimization demos""" return -3.0 * numpy.exp(-(t - 0.3)**2 / (0.1)**2) \ + numpy.exp(-(t - 0.6)**2 / (0.2)**2) \ + numpy.exp(-(t - 1.0)**2 / (0.2)**2) \ + numpy.sin(t) \ - 2.0 ``` ```python x0, x1 = 0.5, 0.2 x = numpy.array([x0, x1, (x0 + x1)/2.]) p = numpy.polyfit(x, f(x), 2) parabola = lambda t: p[0]*t**2 + p[1]*t + p[2] t_min = -p[1]/2./p[0] ``` ```python MAX_STEPS = 100 TOLERANCE = 1e-4 t = numpy.linspace(0., 2., 100) fig = plt.figure(figsize=(8,6)) axes = fig.add_subplot(1, 1, 1) axes.plot(t, f(t), label='$f(t)$') axes.set_xlabel("t (days)") axes.set_ylabel("People (N)") axes.set_title("Decrease in Population due to SPAM Poisoning") axes.plot(x[0], f(x[0]), 'ko') axes.plot(x[1], f(x[1]), 'ko') axes.plot(x[2], f(x[2]), 'ko') axes.plot(t, parabola(t), 'r--', label='parabola') axes.plot(t_min, parabola(t_min), 'ro' ) axes.plot(t_min, f(t_min), 'k+') axes.legend(loc='best') axes.set_ylim((-5, 0.0)) axes.grid() plt.show() ``` ### Rinse and repeat ```python MAX_STEPS = 100 TOLERANCE = 1e-4 x = numpy.array([x0, x1, (x0 + x1) / 2.0]) fig = plt.figure(figsize=(8,6)) axes = fig.add_subplot(1, 1, 1) axes.plot(t, f(t)) axes.set_xlabel("t (days)") axes.set_ylabel("People (N)") axes.set_title("Decrease in Population due to SPAM Poisoning") axes.plot(x[0], f(x[0]), 'ko') axes.plot(x[1], f(x[1]), 'ko') success = False for n in range(1, MAX_STEPS + 1): axes.plot(x[2], f(x[2]), 'ko') poly = numpy.polyfit(x, f(x), 2) axes.plot(t, poly[0] * t**2 + poly[1] * t + poly[2], 'r--') x[0] = x[1] x[1] = x[2] x[2] = -poly[1] / (2.0 * poly[0]) if numpy.abs(x[2] - x[1]) / numpy.abs(x[2]) < TOLERANCE: success = True break if success: print("Success!") print(" t* = %s" % x[2]) print(" f(t*) = %s" % f(x[2])) print(" number of steps = %s" % n) else: print("Reached maximum number of steps!") axes.set_ylim((-5, 0.0)) axes.grid() plt.show() ``` #### Some Code ```python def parabolic_interpolation(f, bracket, tol = 1.e-6): """ uses repeated parabolic interpolation to refine a local minimum of a function f(x) this routine uses numpy functions polyfit and polyval to fit and evaluate the quadratics Parameters: ----------- f: function f(x) returns type: float bracket: array array [x0, x1] containing an initial bracket that contains a minimum tolerance: float Returns when relative error of last two iterates < tol Returns: -------- x: float final estimate of the minima x_array: numpy array history of iteration points Raises: ------- Warning: if number of iterations exceed MAX_STEPS """ MAX_STEPS = 100 x = numpy.zeros(3) x[:2] = bracket x[2] = (x[0] + x[1])/2. x_array = [ x[2] ] for k in range(1, MAX_STEPS + 1): poly = numpy.polyfit(x, f(x), 2) x[0] = x[1] x[1] = x[2] x[2] = -poly[1] / (2.0 * poly[0]) x_array.append(x[2]) if numpy.abs(x[2] - x[1]) / numpy.abs(x[2]) < tol: break if k == MAX_STEPS: warnings.warn('Maximum number of steps exceeded') return x[2], numpy.array(x_array) ``` #### set up problem ```python bracket = numpy.array([0.5, 0.2]) x, x_array = parabolic_interpolation(f, bracket, tol = 1.e-6) print("Extremum f(x) = {}, at x = {}, N steps = {}".format(f(x), x, len(x_array))) ``` ```python t = numpy.linspace(0, 2, 200) fig = plt.figure(figsize=(8,6)) axes = fig.add_subplot(1, 1, 1) axes.plot(t, f(t)) axes.plot(x_array, f(x_array),'ro') axes.plot(x, f(x), 'go') axes.set_xlabel("t (days)") axes.set_ylabel("People (N)") axes.set_title("Decrease in Population due to SPAM Poisoning") axes.grid() plt.show() ``` ### Bracketing Algorithm (Golden Section Search) Given $f(x) \in C[x_0,x_3]$ that is convex (concave) over an interval $x \in [x_0,x_3]$ reduce the interval size until it brackets the minimum (maximum). Note that we no longer have the $x=0$ help we had before so bracketing and doing bisection is a bit trickier in this case. In particular choosing your initial bracket is important! #### Bracket Picking Say we start with a bracket $[x_0, x_3]$ and pick two new points $x_1 < x_2 \in [x_0, x_3]$. We want to pick a new bracket that guarantees that the extrema exists in it. We then can pick this new bracket with the following rules: - If $f(x_1) < f(x_2)$ then we know the minimum is between $x_0$ and $x_2$. - If $f(x_1) > f(x_2)$ then we know the minimum is between $x_1$ and $x_3$. ```python f = lambda x: x**2 fig = plt.figure() fig.set_figwidth(fig.get_figwidth() * 2) fig.set_figheight(fig.get_figheight() * 2) search_points = [-1.0, -0.5, 0.75, 1.0] axes = fig.add_subplot(2, 2, 1) x = numpy.linspace(search_points[0] - 0.1, search_points[-1] + 0.1, 100) axes.plot(x, f(x), 'b') for (i, point) in enumerate(search_points): axes.plot(point, f(point),'or') axes.text(point + 0.05, f(point), str(i)) axes.plot(0, 0, 'sk') axes.set_xlim((search_points[0] - 0.1, search_points[-1] + 0.1)) axes.set_title("$f(x_1) < f(x_2) \Rightarrow [x_0, x_2]$") search_points = [-1.0, -0.75, 0.5, 1.0] axes = fig.add_subplot(2, 2, 2) x = numpy.linspace(search_points[0] - 0.1, search_points[-1] + 0.1, 100) axes.plot(x, f(x), 'b') for (i, point) in enumerate(search_points): axes.plot(point, f(point),'or') axes.text(point + 0.05, f(point), str(i)) axes.plot(0, 0, 'sk') axes.set_xlim((search_points[0] - 0.1, search_points[-1] + 0.1)) axes.set_title("$f(x_1) > f(x_2) \Rightarrow [x_1, x_3]$") search_points = [-1.0, 0.25, 0.75, 1.0] axes = fig.add_subplot(2, 2, 3) x = numpy.linspace(search_points[0] - 0.1, search_points[-1] + 0.1, 100) axes.plot(x, f(x), 'b') for (i, point) in enumerate(search_points): axes.plot(point, f(point),'or') axes.text(point + 0.05, f(point), str(i)) axes.plot(0, 0, 'sk') axes.set_xlim((search_points[0] - 0.1, search_points[-1] + 0.1)) axes.set_title("$f(x_1) < f(x_2) \Rightarrow [x_0, x_2]$") search_points = [-1.0, -0.75, -0.25, 1.0] axes = fig.add_subplot(2, 2, 4) x = numpy.linspace(search_points[0] - 0.1, search_points[-1] + 0.1, 100) axes.plot(x, f(x), 'b') for (i, point) in enumerate(search_points): axes.plot(point, f(point),'or') axes.text(point + 0.05, f(point), str(i)) axes.plot(0, 0, 'sk') axes.set_xlim((search_points[0] - 0.1, search_points[-1] + 0.1)) axes.set_title("$f(x_1) > f(x_2) \Rightarrow [x_1, x_3]$") plt.show() ``` #### Picking Brackets and Points Again say we have a bracket $[x_0,x_3]$ and suppose we have two new search points $x_1$ and $x_2$ that separates $[x_0,x_3]$ into two new overlapping brackets. Define: the length of the line segments in the interval \begin{aligned} a &= x_1 - x_0, \\ b &= x_2 - x_1,\\ c &= x_3 - x_2 \\ \end{aligned} and the total bracket length \begin{aligned} d &= x_3 - x_0. \\ \end{aligned} ```python f = lambda x: (x - 0.25)**2 + 0.5 phi = (numpy.sqrt(5.0) - 1.) / 2.0 x = [-1.0, None, None, 1.0] x[1] = x[3] - phi * (x[3] - x[0]) x[2] = x[0] + phi * (x[3] - x[0]) fig = plt.figure(figsize=(8, 6)) axes = fig.add_subplot(1, 1, 1) t = numpy.linspace(-2.0, 2.0, 100) axes.plot(t, f(t), 'k') # First set of intervals axes.plot([x[0], x[1]], [0.0, 0.0], 'g',label='a') axes.plot([x[1], x[2]], [0.0, 0.0], 'r', label='b') axes.plot([x[2], x[3]], [0.0, 0.0], 'b', label='c') axes.plot([x[0], x[3]], [2.5, 2.5], 'c', label='d') axes.plot([x[0], x[0]], [0.0, f(x[0])], 'g--') axes.plot([x[1], x[1]], [0.0, f(x[1])], 'g--') axes.plot([x[1], x[1]], [0.0, f(x[1])], 'r--') axes.plot([x[2], x[2]], [0.0, f(x[2])], 'r--') axes.plot([x[2], x[2]], [0.0, f(x[2])], 'b--') axes.plot([x[3], x[3]], [0.0, f(x[3])], 'b--') axes.plot([x[0], x[0]], [2.5, f(x[0])], 'c--') axes.plot([x[3], x[3]], [2.5, f(x[3])], 'c--') points = [ (x[0] + x[1])/2., (x[1] + x[2])/2., (x[2] + x[3])/2., (x[0] + x[3])/2. ] y = [ 0., 0., 0., 2.5] labels = [ 'a', 'b', 'c', 'd'] for (n, point) in enumerate(points): axes.text(point, y[n] + 0.1, labels[n], fontsize=15) for (n, point) in enumerate(x): axes.plot(point, f(point), 'ok') axes.text(point, f(point)+0.1, n, fontsize='15') axes.set_xlim((search_points[0] - 0.1, search_points[-1] + 0.1)) axes.set_ylim((-1.0, 3.0)) plt.show() ``` For **Golden Section Search** we require two conditions: - The two new possible brackets are of equal length. i.e $[x_0, x_2] = [x_1, x_3]$ or $$ a + b = b + c $$ or simply $a = c$ ```python f = lambda x: (x - 0.25)**2 + 0.5 phi = (numpy.sqrt(5.0) - 1.) / 2.0 x = [-1.0, None, None, 1.0] x[1] = x[3] - phi * (x[3] - x[0]) x[2] = x[0] + phi * (x[3] - x[0]) fig = plt.figure(figsize=(8, 6)) axes = fig.add_subplot(1, 1, 1) t = numpy.linspace(-2.0, 2.0, 100) axes.plot(t, f(t), 'k') # First set of intervals axes.plot([x[0], x[1]], [0.0, 0.0], 'g',label='a') axes.plot([x[1], x[2]], [0.0, 0.0], 'r', label='b') axes.plot([x[2], x[3]], [0.0, 0.0], 'b', label='c') axes.plot([x[0], x[3]], [2.5, 2.5], 'c', label='d') axes.plot([x[0], x[0]], [0.0, f(x[0])], 'g--') axes.plot([x[1], x[1]], [0.0, f(x[1])], 'g--') axes.plot([x[1], x[1]], [0.0, f(x[1])], 'r--') axes.plot([x[2], x[2]], [0.0, f(x[2])], 'r--') axes.plot([x[2], x[2]], [0.0, f(x[2])], 'b--') axes.plot([x[3], x[3]], [0.0, f(x[3])], 'b--') axes.plot([x[0], x[0]], [2.5, f(x[0])], 'c--') axes.plot([x[3], x[3]], [2.5, f(x[3])], 'c--') points = [ (x[0] + x[1])/2., (x[1] + x[2])/2., (x[2] + x[3])/2., (x[0] + x[3])/2. ] y = [ 0., 0., 0., 2.5] labels = [ 'a', 'b', 'c', 'd'] for (n, point) in enumerate(points): axes.text(point, y[n] + 0.1, labels[n], fontsize=15) for (n, point) in enumerate(x): axes.plot(point, f(point), 'ok') axes.text(point, f(point)+0.1, n, fontsize='15') axes.set_xlim((search_points[0] - 0.1, search_points[-1] + 0.1)) axes.set_ylim((-1.0, 3.0)) plt.show() ``` - The ratio of segment lengths is the same for every level of recursion so the problem is self-similar i.e. $$ \frac{b}{a} = \frac{c}{a + b} $$ These two requirements will allow maximum reuse of previous points and require adding only one new point $x^*$ at each iteration. ```python f = lambda x: (x - 0.25)**2 + 0.5 phi = (numpy.sqrt(5.0) - 1.) / 2.0 x = [-1.0, None, None, 1.0] x[1] = x[3] - phi * (x[3] - x[0]) x[2] = x[0] + phi * (x[3] - x[0]) fig = plt.figure() fig.set_figwidth(fig.get_figwidth() * 2) axes = [] axes.append(fig.add_subplot(1, 2, 1)) axes.append(fig.add_subplot(1, 2, 2)) t = numpy.linspace(-2.0, 2.0, 100) for i in range(2): axes[i].plot(t, f(t), 'k') # First set of intervals axes[i].plot([x[0], x[2]], [0.0, 0.0], 'g') axes[i].plot([x[1], x[3]], [-0.2, -0.2], 'r') axes[i].plot([x[0], x[0]], [0.0, f(x[0])], 'g--') axes[i].plot([x[2], x[2]], [0.0, f(x[2])], 'g--') axes[i].plot([x[1], x[1]], [-0.2, f(x[1])], 'r--') axes[i].plot([x[3], x[3]], [-0.2, f(x[3])], 'r--') for (n, point) in enumerate(x): axes[i].plot(point, f(point), 'ok') axes[i].text(point, f(point)+0.1, n, fontsize='15') axes[i].set_xlim((search_points[0] - 0.1, search_points[-1] + 0.1)) axes[i].set_ylim((-1.0, 3.0)) # Left new interval x_new = [x[0], None, x[1], x[2]] x_new[1] = phi * (x[1] - x[0]) + x[0] #axes[0].plot([x_new[0], x_new[2]], [1.5, 1.5], 'b') #axes[0].plot([x_new[1], x_new[3]], [1.75, 1.75], 'c') #axes[0].plot([x_new[0], x_new[0]], [1.5, f(x_new[0])], 'b--') #axes[0].plot([x_new[2], x_new[2]], [1.5, f(x_new[2])], 'b--') #axes[0].plot([x_new[1], x_new[1]], [1.75, f(x_new[1])], 'c--') #axes[0].plot([x_new[3], x_new[3]], [1.75, f(x_new[3])], 'c--') axes[0].plot(x_new[1], f(x_new[1]), 'ko') axes[0].text(x_new[1], f(x_new[1]) + 0.1, "*", fontsize='15') for i in range(4): axes[0].text(x_new[i], -0.5, i, color='g',fontsize='15') # Right new interval x_new = [x[1], x[2], None, x[3]] x_new[2] = (x[2] - x[1]) * phi + x[2] #axes[1].plot([x_new[0], x_new[2]], [1.25, 1.25], 'b') #axes[1].plot([x_new[1], x_new[3]], [1.5, 1.5], 'c') #axes[1].plot([x_new[0], x_new[0]], [1.25, f(x_new[0])], 'b--') #axes[1].plot([x_new[2], x_new[2]], [1.25, f(x_new[2])], 'b--') #axes[1].plot([x_new[1], x_new[1]], [1.5, f(x_new[2])], 'c--') #axes[1].plot([x_new[3], x_new[3]], [1.5, f(x_new[3])], 'c--') axes[1].plot(x_new[2], f(x_new[2]), 'ko') axes[1].text(x_new[2], f(x_new[2]) + 0.1, "*", fontsize='15') for i in range(4): axes[1].text(x_new[i], -0.5, i, color='r',fontsize='15') axes[0].set_title('Choose left bracket', fontsize=18) axes[1].set_title('Choose right bracket', fontsize=18) plt.show() ``` As the first rule implies that $a = c$, we can substitute into the second rule to yield $$ \frac{b}{a} = \frac{a}{a + b} $$ or inverting and rearranging $$ \frac{a}{b} = 1 + \frac{b}{a} $$ if we let the ratio $b/a = x$, then $$ x + 1 = \frac{1}{x} \quad \text{or} \quad x^2 + x - 1 = 0 $$ $$ x^2 + x - 1 = 0 $$ has a single positive root for $$ x = \frac{\sqrt{5} - 1}{2} = \varphi = 0.6180339887498949 $$ where $\varphi$ is related to the "golden ratio" (which in most definitions is given by $1+\varphi$, but either work as $ 1+\varphi = 1/\varphi $ ) Subsequent proportionality implies that the distances between the 4 points at one iteration is proportional to the next. We can now use all of our information to find the points $x_1$ and $x_2$ given any overall bracket $[x_0, x_3]$ Given $b/a = \varphi$, $a = c$, and the known width of the bracket $d$ it follows that $$ d = a + b + c = (2 + \phi)a $$ or $$ a = \frac{d}{2 + \varphi} = \frac{\varphi}{1 + \varphi} d$$ by the rather special properties of $\varphi$. We could use this result immediately to find \begin{align} x_1 &= x_0 + a \\ x_2 &= x_3 - a \\ \end{align} Equivalently, you can show that $$a + b = (1 + \varphi)a = \varphi d$$ so \begin{align} x_1 &= x_3 - \varphi d \\ x_2 &= x_0 + \varphi d \\ \end{align} ```python f = lambda x: (x - 0.25)**2 + 0.5 phi = (numpy.sqrt(5.0) - 1.) / 2.0 x = [-1.0, None, None, 1.0] x[1] = x[3] - phi * (x[3] - x[0]) x[2] = x[0] + phi * (x[3] - x[0]) fig = plt.figure(figsize=(8, 6)) axes = fig.add_subplot(1, 1, 1) t = numpy.linspace(-2.0, 2.0, 100) axes.plot(t, f(t), 'k') # First set of intervals axes.plot([x[0], x[1]], [0.0, 0.0], 'g',label='a') axes.plot([x[1], x[2]], [0.0, 0.0], 'r', label='b') axes.plot([x[2], x[3]], [0.0, 0.0], 'b', label='c') axes.plot([x[0], x[3]], [2.5, 2.5], 'c', label='d') axes.plot([x[0], x[0]], [0.0, f(x[0])], 'g--') axes.plot([x[1], x[1]], [0.0, f(x[1])], 'g--') axes.plot([x[1], x[1]], [0.0, f(x[1])], 'r--') axes.plot([x[2], x[2]], [0.0, f(x[2])], 'r--') axes.plot([x[2], x[2]], [0.0, f(x[2])], 'b--') axes.plot([x[3], x[3]], [0.0, f(x[3])], 'b--') axes.plot([x[0], x[0]], [2.5, f(x[0])], 'c--') axes.plot([x[3], x[3]], [2.5, f(x[3])], 'c--') points = [ (x[0] + x[1])/2., (x[1] + x[2])/2., (x[2] + x[3])/2., (x[0] + x[3])/2. ] y = [ 0., 0., 0., 2.5] labels = [ 'a', 'b', 'c', 'd'] for (n, point) in enumerate(points): axes.text(point, y[n] + 0.1, labels[n], fontsize=15) for (n, point) in enumerate(x): axes.plot(point, f(point), 'ok') axes.text(point, f(point)+0.1, n, fontsize='15') axes.set_xlim((search_points[0] - 0.1, search_points[-1] + 0.1)) axes.set_ylim((-1.0, 3.0)) plt.show() ``` #### Algorithm 1. Initialize bracket $[x_0,x_3]$ 1. Initialize points $x_1 = x_3 - \varphi (x_3 - x_0)$ and $x_2 = x_0 + \varphi (x_3 - x_0)$ 1. Loop 1. Evaluate $f_1$ and $f_2$ 1. If $f_1 < f_2$ then we pick the left interval for the next iteration 1. and otherwise pick the right interval 1. Check size of bracket for convergence $x_3 - x_0 <$ `TOLERANCE` 1. calculate the appropriate new point $x^*$ ($x_1$ on left, $x_2$ on right) ```python def golden_section(f, bracket, tol = 1.e-6): """ uses golden section search to refine a local minimum of a function f(x) this routine uses numpy functions polyfit and polyval to fit and evaluate the quadratics Parameters: ----------- f: function f(x) returns type: float bracket: array array [x0, x3] containing an initial bracket that contains a minimum tolerance: float Returns when | x3 - x0 | < tol Returns: -------- x: float final estimate of the midpoint of the bracket x_array: numpy array history of midpoint of each bracket Raises: ------- ValueError: If initial bracket is < tol or doesn't appear to have any interior points that are less than the outer points Warning: if number of iterations exceed MAX_STEPS """ MAX_STEPS = 100 phi = (numpy.sqrt(5.0) - 1.) / 2.0 x = [ bracket[0], None, None, bracket[1] ] delta_x = x[3] - x[0] x[1] = x[3] - phi * delta_x x[2] = x[0] + phi * delta_x # check for initial bracket fx = f(numpy.array(x)) bracket_min = min(fx[0], fx[3]) if fx[1] > bracket_min and fx[2] > bracket_min: raise ValueError("interval does not appear to include a minimum") elif delta_x < tol: raise ValueError("interval is already smaller than tol") x_mid = (x[3] + x[0])/2. x_array = [ x_mid ] for k in range(1, MAX_STEPS + 1): f_1 = f(x[1]) f_2 = f(x[2]) if f_1 < f_2: # Pick the left bracket x_new = [x[0], None, x[1], x[2]] delta_x = x_new[3] - x_new[0] x_new[1] = x_new[3] - phi * delta_x else: # Pick the right bracket x_new = [x[1], x[2], None, x[3]] delta_x = x_new[3] - x_new[0] x_new[2] = x_new[0] + phi * delta_x x = x_new x_array.append((x[3] + x[0])/ 2.) if numpy.abs(x[3] - x[0]) < tol: break if k == MAX_STEPS: warnings.warn('Maximum number of steps exceeded') return x_array[-1], numpy.array(x_array) ``` ```python def f(t): """Simple function for minimization demos""" return -3.0 * numpy.exp(-(t - 0.3)**2 / (0.1)**2) \ + numpy.exp(-(t - 0.6)**2 / (0.2)**2) \ + numpy.exp(-(t - 1.0)**2 / (0.2)**2) \ + numpy.sin(t) \ - 2.0 ``` ```python x, x_array = golden_section(f,[0.2, 0.5], 1.e-4) print('t* = {}, f(t*) = {}, N steps = {}'.format(x, f(x), len(x_array)-1)) ``` ```python t = numpy.linspace(0, 2, 200) fig = plt.figure(figsize=(8, 6)) axes = fig.add_subplot(1, 1, 1) axes.plot(t, f(t)) axes.grid() axes.set_xlabel("t (days)") axes.set_ylabel("People (N)") axes.set_title("Decrease in Population due to SPAM Poisoning") axes.plot(x_array, f(x_array),'ko') axes.plot(x_array[0],f(x_array[0]),'ro') axes.plot(x_array[-1],f(x_array[-1]),'go') plt.show() ``` ## Scipy Optimization Scipy contains a lot of ways for optimization. But a convenenient interface for minimization of functions of a single variable is `scipy.optimize.minimize_scalar` For optimization or constrained optimization for functions of more than one variable, see `scipy.optimized.minimize` ```python from scipy.optimize import minimize_scalar #minimize_scalar? ``` ### Try some different methods ```python sol = minimize_scalar(f, bracket=(0.2, 0.25, 0.5), method='golden') print(sol) ``` ```python sol = minimize_scalar(f, method='brent') print(sol) ``` ```python sol = minimize_scalar(f, bounds=(0.,0.5), method='bounded') print(sol) ```

cea1f6eb2c7e763d93a45dfadc40fd7b90ac3c39

ipynb

Jupyter Notebook

05_root_finding_optimization.ipynb

mspieg/intro-numerical-methods

d267a075c95acfed6bbcbe91951a05539be61311

2020-09-10T13:01:06.000Z

2022-01-20T15:05:30.000Z

05_root_finding_optimization.ipynb

AinsleyChen/intro-numerical-methods

2eda74cccbed5c0d4c57e24c3f4c96a1aa741f08

05_root_finding_optimization.ipynb

AinsleyChen/intro-numerical-methods

2eda74cccbed5c0d4c57e24c3f4c96a1aa741f08

2020-01-21T16:08:37.000Z

2022-01-21T12:46:56.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Series ```python import pandas as pd from oeis.sequence import OEIS_Sequence from matplotlib import pyplot as plt ``` ```python plt.plot(Sequence.terms) plt.title(Sequence.description) plt.show() ``` ```python def formula_latex(k, floor=True): latex = r"$$\left\lfloor\frac{n^2}{" + str(k) + r"}\right\rfloor$$" if not floor: latex = latex.replace("floor", "ceil") return latex ``` ```python def oeis_md_link(id_): return f'[{id_}]({OEIS_URL}{id_})' ``` ```python SEQ_LIST = ['A000290', 'A007590', 'A000212', 'A002620', 'A118015', 'A056827', 'A056834', 'A130519', 'A056838', 'A056865'] ``` ```python series_table = pd.DataFrame(columns= ['k', 'Secuencia', 'Fórmula', 'Descripción', 'Términos']) MAX_TERMS = 15 for num, id_ in enumerate(SEQ_LIST): Seq = OEIS_Sequence(id_) series_table = series_table.append({'k': num + 1, 'Secuencia': oeis_md_link(id_), 'Fórmula': formula_latex(num + 1), 'Descripción': Seq.description, 'Términos': Seq.terms[:MAX_TERMS] }, ignore_index=True) ``` ```python series_table ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>k</th> <th>Secuencia</th> <th>Fórmula</th> <th>Descripción</th> <th>Términos</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>1</td> <td>[A000290](http://oeis.org/A000290)</td> <td>$$\left\lfloor\frac{n^2}{1}\right\rfloor$$</td> <td>The squares: a(n) = n^2.</td> <td>[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121,...</td> </tr> <tr> <th>1</th> <td>2</td> <td>[A007590](http://oeis.org/A007590)</td> <td>$$\left\lfloor\frac{n^2}{2}\right\rfloor$$</td> <td>a(n) = floor(n^2/2).</td> <td>[0, 0, 2, 4, 8, 12, 18, 24, 32, 40, 50, 60, 72...</td> </tr> <tr> <th>2</th> <td>3</td> <td>[A000212](http://oeis.org/A000212)</td> <td>$$\left\lfloor\frac{n^2}{3}\right\rfloor$$</td> <td>a(n) = floor(n^2/3).</td> <td>[0, 0, 1, 3, 5, 8, 12, 16, 21, 27, 33, 40, 48,...</td> </tr> <tr> <th>3</th> <td>4</td> <td>[A002620](http://oeis.org/A002620)</td> <td>$$\left\lfloor\frac{n^2}{4}\right\rfloor$$</td> <td>Quarter-squares: floor(n/2)*ceiling(n/2). Equi...</td> <td>[0, 0, 1, 2, 4, 6, 9, 12, 16, 20, 25, 30, 36, ...</td> </tr> <tr> <th>4</th> <td>5</td> <td>[A118015](http://oeis.org/A118015)</td> <td>$$\left\lfloor\frac{n^2}{5}\right\rfloor$$</td> <td>a(n) = floor(n^2/5).</td> <td>[0, 0, 0, 1, 3, 5, 7, 9, 12, 16, 20, 24, 28, 3...</td> </tr> <tr> <th>5</th> <td>6</td> <td>[A056827](http://oeis.org/A056827)</td> <td>$$\left\lfloor\frac{n^2}{6}\right\rfloor$$</td> <td>a(n) = floor(n^2/6).</td> <td>[0, 0, 0, 1, 2, 4, 6, 8, 10, 13, 16, 20, 24, 2...</td> </tr> <tr> <th>6</th> <td>7</td> <td>[A056834](http://oeis.org/A056834)</td> <td>$$\left\lfloor\frac{n^2}{7}\right\rfloor$$</td> <td>a(n) = floor(n^2/7).</td> <td>[0, 0, 0, 1, 2, 3, 5, 7, 9, 11, 14, 17, 20, 24...</td> </tr> <tr> <th>7</th> <td>8</td> <td>[A130519](http://oeis.org/A130519)</td> <td>$$\left\lfloor\frac{n^2}{8}\right\rfloor$$</td> <td>a(n) = Sum_{k=0..n} floor(k/4). (Partial sums ...</td> <td>[0, 0, 0, 0, 1, 2, 3, 4, 6, 8, 10, 12, 15, 18,...</td> </tr> <tr> <th>8</th> <td>9</td> <td>[A056838](http://oeis.org/A056838)</td> <td>$$\left\lfloor\frac{n^2}{9}\right\rfloor$$</td> <td>a(n) = floor(n^2/9).</td> <td>[0, 0, 0, 1, 1, 2, 4, 5, 7, 9, 11, 13, 16, 18,...</td> </tr> <tr> <th>9</th> <td>10</td> <td>[A056865](http://oeis.org/A056865)</td> <td>$$\left\lfloor\frac{n^2}{10}\right\rfloor$$</td> <td>a(n) = floor(n^2/10).</td> <td>[0, 0, 0, 0, 1, 2, 3, 4, 6, 8, 10, 12, 14, 16,...</td> </tr> </tbody> </table> </div> ```python # Tabla en markdown para incluir en el capítulo print(series_table.to_markdown(index=False)) ``` | k | Secuencia | Fórmula | Descripción | Términos | |----:|:-----------------------------------|:--------------------------------------------|:----------------------------------------------------------------------|:--------------------------------------------------------------| | 1 | [A000290](http://oeis.org/A000290) | $$\left\lfloor\frac{n^2}{1}\right\rfloor$$ | The squares: a(n) = n^2. | [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196] | | 2 | [A007590](http://oeis.org/A007590) | $$\left\lfloor\frac{n^2}{2}\right\rfloor$$ | a(n) = floor(n^2/2). | [0, 0, 2, 4, 8, 12, 18, 24, 32, 40, 50, 60, 72, 84, 98] | | 3 | [A000212](http://oeis.org/A000212) | $$\left\lfloor\frac{n^2}{3}\right\rfloor$$ | a(n) = floor(n^2/3). | [0, 0, 1, 3, 5, 8, 12, 16, 21, 27, 33, 40, 48, 56, 65] | | 4 | [A002620](http://oeis.org/A002620) | $$\left\lfloor\frac{n^2}{4}\right\rfloor$$ | Quarter-squares: floor(n/2)*ceiling(n/2). Equivalently, floor(n^2/4). | [0, 0, 1, 2, 4, 6, 9, 12, 16, 20, 25, 30, 36, 42, 49] | | 5 | [A118015](http://oeis.org/A118015) | $$\left\lfloor\frac{n^2}{5}\right\rfloor$$ | a(n) = floor(n^2/5). | [0, 0, 0, 1, 3, 5, 7, 9, 12, 16, 20, 24, 28, 33, 39] | | 6 | [A056827](http://oeis.org/A056827) | $$\left\lfloor\frac{n^2}{6}\right\rfloor$$ | a(n) = floor(n^2/6). | [0, 0, 0, 1, 2, 4, 6, 8, 10, 13, 16, 20, 24, 28, 32] | | 7 | [A056834](http://oeis.org/A056834) | $$\left\lfloor\frac{n^2}{7}\right\rfloor$$ | a(n) = floor(n^2/7). | [0, 0, 0, 1, 2, 3, 5, 7, 9, 11, 14, 17, 20, 24, 28] | | 8 | [A130519](http://oeis.org/A130519) | $$\left\lfloor\frac{n^2}{8}\right\rfloor$$ | a(n) = Sum_{k=0..n} floor(k/4). (Partial sums of A002265.) | [0, 0, 0, 0, 1, 2, 3, 4, 6, 8, 10, 12, 15, 18, 21] | | 9 | [A056838](http://oeis.org/A056838) | $$\left\lfloor\frac{n^2}{9}\right\rfloor$$ | a(n) = floor(n^2/9). | [0, 0, 0, 1, 1, 2, 4, 5, 7, 9, 11, 13, 16, 18, 21] | | 10 | [A056865](http://oeis.org/A056865) | $$\left\lfloor\frac{n^2}{10}\right\rfloor$$ | a(n) = floor(n^2/10). | [0, 0, 0, 0, 1, 2, 3, 4, 6, 8, 10, 12, 14, 16, 19] | ```python for k, seq in enumerate(SEQ_LIST): lst = SEQ_LIST.copy() del lst[k] print(k, seq, lst) ``` 0 A000290 ['A007590', 'A000212', 'A002620', 'A118015', 'A056827', 'A056834', 'A130519', 'A056838', 'A056865'] 1 A007590 ['A000290', 'A000212', 'A002620', 'A118015', 'A056827', 'A056834', 'A130519', 'A056838', 'A056865'] 2 A000212 ['A000290', 'A007590', 'A002620', 'A118015', 'A056827', 'A056834', 'A130519', 'A056838', 'A056865'] 3 A002620 ['A000290', 'A007590', 'A000212', 'A118015', 'A056827', 'A056834', 'A130519', 'A056838', 'A056865'] 4 A118015 ['A000290', 'A007590', 'A000212', 'A002620', 'A056827', 'A056834', 'A130519', 'A056838', 'A056865'] 5 A056827 ['A000290', 'A007590', 'A000212', 'A002620', 'A118015', 'A056834', 'A130519', 'A056838', 'A056865'] 6 A056834 ['A000290', 'A007590', 'A000212', 'A002620', 'A118015', 'A056827', 'A130519', 'A056838', 'A056865'] 7 A130519 ['A000290', 'A007590', 'A000212', 'A002620', 'A118015', 'A056827', 'A056834', 'A056838', 'A056865'] 8 A056838 ['A000290', 'A007590', 'A000212', 'A002620', 'A118015', 'A056827', 'A056834', 'A130519', 'A056865'] 9 A056865 ['A000290', 'A007590', 'A000212', 'A002620', 'A118015', 'A056827', 'A056834', 'A130519', 'A056838'] ```python V = ['A000290', 'A007590', 'A000212', 'A002620', 'A118015', 'A056827', 'A056834', 'A130519', 'A056865'] ``` ```python txt = "" for x in V: txt = txt + ", " + x txt ``` ', A000290, A007590, A000212, A002620, A118015, A056827, A056834, A130519, A056865' ```python from math import floor def f(n, k): return floor((n ** 2) / k) ``` ```python lst = [] acc = 0 for n in range(20): acc += f(n, 2) lst.append(acc) ``` ```python print(lst) ``` [0, 0, 2, 6, 14, 26, 44, 68, 100, 140, 190, 250, 322, 406, 504, 616, 744, 888, 1050, 1230] ```python lista = [] for n in range(20): lista.append(floor((2 * (n ** 3) + 3 * (n ** 2) - 2 * n)/12)) ``` ```python print(lista) ``` [0, 0, 2, 6, 14, 26, 44, 68, 100, 140, 190, 250, 322, 406, 504, 616, 744, 888, 1050, 1230] ```python from sympy import Sum, symbols, simplify ``` ```python i, k, n = symbols('i k n', integer=True) simplify(Sum((i ** 2) / k , (i, 1, n)).doit()) ``` $\displaystyle \frac{n \left(2 n^{2} + 3 n + 1\right)}{6 k}$ ```python ```

d3f4991d356c73a7439e08e3a39cd9062f7e5544

ipynb

Jupyter Notebook

code/01-Intro/oeis.ipynb

EnriquePH/Libro_Bestiario_Mates

77347cbf5fd9e4c6f7d52c671e29c8d6781b0bb7

code/01-Intro/oeis.ipynb

EnriquePH/Libro_Bestiario_Mates

77347cbf5fd9e4c6f7d52c671e29c8d6781b0bb7

code/01-Intro/oeis.ipynb

EnriquePH/Libro_Bestiario_Mates

77347cbf5fd9e4c6f7d52c671e29c8d6781b0bb7

Qwen/Qwen-72B

1. YES 2. YES

__label__krc_Cyrl

--- author: Nathan Carter (ncarter@bentley.edu) --- This answer assumes you have imported SymPy as follows. ```python from sympy import * # load all math functions init_printing( use_latex='mathjax' ) # use pretty math output ``` Sequences are typically written in terms of an independent variable $n$, so we will tell SymPy to use $n$ as a symbol, then define our sequence in terms of $n$. We define a term of an example sequence as $a_n=\frac{1}{n+1}$, then build a sequence from that term. The code `(n,0,oo)` means that $n$ starts counting at $n=0$ and goes on forever (with `oo` being the SymPy notation for $\infty$). ```python var( 'n' ) # use n as a symbol a_n = 1 / ( n + 1 ) # formula for a term seq = sequence( a_n, (n,0,oo) ) # build the sequence seq ``` $\displaystyle \left[1, \frac{1}{2}, \frac{1}{3}, \frac{1}{4}, \ldots\right]$ You can ask for specific terms in the sequence, or many terms in a row, as follows. ```python seq[20] ``` $\displaystyle \frac{1}{21}$ ```python seq[:10] ``` $\displaystyle \left[ 1, \ \frac{1}{2}, \ \frac{1}{3}, \ \frac{1}{4}, \ \frac{1}{5}, \ \frac{1}{6}, \ \frac{1}{7}, \ \frac{1}{8}, \ \frac{1}{9}, \ \frac{1}{10}\right]$ You can compute the limit of a sequence, $$ \lim_{n\to\infty} a_n. $$ ```python limit( a_n, n, oo ) ``` $\displaystyle 0$

55b5054f556e227c9801fc25b6839e806570a76e

ipynb

Jupyter Notebook

database/tasks/How to define a mathematical sequence/Python, using SymPy.ipynb

nathancarter/how2data

7d4f2838661f7ce98deb1b8081470cec5671b03a

database/tasks/How to define a mathematical sequence/Python, using SymPy.ipynb

nathancarter/how2data

7d4f2838661f7ce98deb1b8081470cec5671b03a

database/tasks/How to define a mathematical sequence/Python, using SymPy.ipynb

nathancarter/how2data

7d4f2838661f7ce98deb1b8081470cec5671b03a

2021-07-18T19:01:29.000Z

2022-03-29T06:47:11.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# The standard deb model The standard DEB model, in the energy formulation, contains four dynamic state variables: reserve energy $E$, structure volume $V$, maturity energy $E_M$ and reproduction buffer energy $E_R$: \begin{eqnarray} \frac{dE}{dt} &=& \dot{p}_A - \dot{p}_C\\ \frac{dV}{dt} &=& \frac{\dot{p}_G}{[E_G]}\\ \frac{dE_H}{dt} &=& \dot{p}_R (1 - H(E_H - E^p_H))\\ \frac{dE_R}{dt} &=& \dot{p}_R H(E_H - E^p_H) \end{eqnarray} In this coupled set of ODEs, four fluxes appear: \begin{eqnarray} \dot{p}_A &=& f(X)\{\dot{p}_{Am}\}V^{2/3}\\ \dot{p}_C &=& E \left( \frac{[E_G]\dot{v}V^{2/3} + \dot{p}_S}{\kappa E + [E_G]V} \right)\\ \dot{p}_G &=& \kappa\dot{p}_C - \dot{p}_S\\ \dot{p}_R &=& (1-\kappa)\dot{p}_C - \dot{p}_J\\ \end{eqnarray} Here, two additional loss fluxes appear, somatic maintenance $\dot{p}_S$ and maturity maintenance $\dot{p}_J$: \begin{eqnarray} \dot{p}_S &=& [\dot{p}_M]V - \{\dot{p}_T\}V^{2/3}\\ \dot{p}_J &=& \dot{k}_JE_H \end{eqnarray} ```python %matplotlib inline #Import packages we need import numpy as np import matplotlib.pyplot as plt import seaborn as sns #Import deb modules import deb import deb_compound_pars import deb_aux #Configure plotting sns.set_context('notebook') sns.set_style('white') ``` ## The 12 primary parameters Also include temperature parameters here for now ```python deb.get_deb_params_pandas() ``` <div> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>Min</th> <th>Max</th> <th>Value</th> <th>Dimension</th> <th>Units</th> <th>Description</th> </tr> </thead> <tbody> <tr> <th>Fm</th> <td>2.220446e-16</td> <td>NaN</td> <td>6.500000</td> <td>l L**-2 t**-1</td> <td></td> <td>Specific searching rate</td> </tr> <tr> <th>kappaX</th> <td>2.220446e-16</td> <td>1.0</td> <td>0.800000</td> <td>-</td> <td></td> <td>Assimilation efficiency</td> </tr> <tr> <th>pAm</th> <td>2.220446e-16</td> <td>NaN</td> <td>530.000000</td> <td>e L**-2 t**-1</td> <td></td> <td>max specific assimilation rate</td> </tr> <tr> <th>v</th> <td>2.220446e-16</td> <td>NaN</td> <td>0.020000</td> <td>L t**-1</td> <td>cm/d</td> <td>Energy conductance</td> </tr> <tr> <th>kappa</th> <td>2.220446e-16</td> <td>1.0</td> <td>0.800000</td> <td>-</td> <td></td> <td>Allocation fraction to soma</td> </tr> <tr> <th>kappaR</th> <td>2.220446e-16</td> <td>1.0</td> <td>0.950000</td> <td>-</td> <td></td> <td>Reproduction efficiency</td> </tr> <tr> <th>pM</th> <td>2.220446e-16</td> <td>NaN</td> <td>18.000000</td> <td>e L**-3 t**-1</td> <td>J/d/cm**3</td> <td>Volume-specific somatic maintenance cost</td> </tr> <tr> <th>pT</th> <td>0.000000e+00</td> <td>NaN</td> <td>0.000000</td> <td>e L**-1 t**-1</td> <td></td> <td>Surface-specific somatic maintenance cost</td> </tr> <tr> <th>kJ</th> <td>2.220446e-16</td> <td>NaN</td> <td>0.002000</td> <td>t**-1</td> <td></td> <td>Maturity maintenance rate coefficient</td> </tr> <tr> <th>EG</th> <td>2.220446e-16</td> <td>NaN</td> <td>4184.000000</td> <td>e L**-3</td> <td></td> <td>Specific cost for structure</td> </tr> <tr> <th>EbH</th> <td>2.220446e-16</td> <td>NaN</td> <td>0.000001</td> <td>e</td> <td></td> <td>Maturity at birth</td> </tr> <tr> <th>EpH</th> <td>2.220446e-16</td> <td>NaN</td> <td>843.600000</td> <td>e</td> <td></td> <td>Maturity at puberty</td> </tr> <tr> <th>TA</th> <td>2.220446e-16</td> <td>NaN</td> <td>6000.000000</td> <td>T</td> <td>K</td> <td>Arrhenius temperature</td> </tr> <tr> <th>Ts</th> <td>2.220446e-16</td> <td>NaN</td> <td>293.100000</td> <td>T</td> <td>K</td> <td>Reference temperature</td> </tr> </tbody> </table> </div> ## Forward solve test Solve the standard DEB model equations (four state variables) ```python #Instantiate DEB model with constant food level (must be a function though) f = lambda t: 1.0 dm = deb.DEBStandard({'f': f}) #Integrate the DEB equations, 20000 days y0 = [1000, 1, 0, 0] # Initial state t = np.linspace(0, 20000, 100) # Time points dm.predict(y0, t) # Predict #Plot the state variable dynamics. Dashed line indicated implied maximum structural length. fig = dm.plot_state() ``` ## Real-world predictions with auxillary data and equations Organism physical length [cm] \begin{equation} L_w = \frac{L}{\delta_M} = \frac{\sqrt[3]{V}}{\delta_M} \end{equation} Organism total (dry) weight [g] is the sum of reserve, structure (and reproduction buffer) weights: \begin{equation} W_W = w_VM_V + w_EM_E \end{equation} Organism physical volume \begin{equation} V_w = V + (E + E_R)\frac{w_E}{d_E\bar{\mu}_E} \end{equation} ### Supporting parameter relationships See pps. 81 - 83 i DEB3. Structural mass [mol]: \begin{equation} M_V = [M_V]V = \frac{d_V}{w_V}V \end{equation} Reserve mass [mol]: \begin{equation} M_E = \frac{E}{\bar{\mu}_E} \end{equation} Number of C-atoms per unit of structural volume [mol/cm$^3$] \begin{equation} [M_V] = \frac{d_V}{w_V} \end{equation} #### Food function Functional (food) response: \begin{equation} f(X) = \frac{X}{K+X} \end{equation} Half saturation coefficient \begin{equation} K = \frac{\{\dot{J}_{XAm}\}}{\{\dot{F}_m \}} = \frac{\{\dot{p}_{Am} \}}{\kappa_X\{\dot{F}_m \}\bar{\mu}_X} \end{equation} ### Parameter values that must be specified These equations requires the specification of three scalar parameters: | Description | Unit | Symbol | Typical value | |----------------------------------------|:-------:|:-------------:|:-------------------:| | Specific chemical potential of reserve | J/mol | $\bar{\mu}_E$ | 550 000 (addchem.m) | | Specific chemical potential of food | J/mol | $\bar{\mu}_X$ | 525 000 (addchem.m) | | C-molar weight of water-free structure | g/mol | $w_V$ | 24.6 (DEB3 ex) | | C-molar weight of water-free reserve | g/mol | $w_E$ | 23.0 (get_pars2.m) | | Specific density of dry structure | g/cm$^3$| $d_V$ | 0.1 | | Specific density of reserve | g/cm$^3$| $d_V$ | dV (addchem.m) | | Shape factor | - | $\delta_M$ | 0.9 (made up) | ```python aux = deb_aux.AuxPars(dm) fig = aux.plot_observables() plt.tight_layout() ``` ## Implied compound parameter ```python deb_compound_pars.calculate_compound_pars(dm.params) ``` <div> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>Min</th> <th>Max</th> <th>Value</th> <th>Dimension</th> <th>Unit</th> <th>Description</th> </tr> </thead> <tbody> <tr> <th>Em</th> <td>0.0</td> <td>NaN</td> <td>26500.000000</td> <td>e L**-3</td> <td>J/m</td> <td>Max reserve density</td> </tr> <tr> <th>g</th> <td>0.0</td> <td>NaN</td> <td>0.197358</td> <td>-</td> <td>-</td> <td>Energy investment ration</td> </tr> <tr> <th>Lm</th> <td>0.0</td> <td>NaN</td> <td>23.555556</td> <td>l</td> <td>m</td> <td>Maximum structural length</td> </tr> <tr> <th>kM</th> <td>0.0</td> <td>NaN</td> <td>0.004302</td> <td>t**-1</td> <td>1/d</td> <td>Somatic maintenance rate</td> </tr> <tr> <th>kappaG</th> <td>0.0</td> <td>NaN</td> <td>0.800000</td> <td>-</td> <td>-</td> <td>Fraction of growth energy fixed in structure</td> </tr> </tbody> </table> </div> # Testing food functions ```python #Periodic food function flist = [lambda t: 1/2*(1+np.sin(t/2000.)**2), lambda t: 0*t + 1.0] fig, ax = plt.subplots(2, 2, figsize=(8, 8)) ax = ax.flatten() ax2 = ax[0].twinx() for f in flist: dm = deb.DEBStandard({'f': f}) y0 = [0, 1, 0, 0] t = np.linspace(0, 20000, 100) dm.predict(y0, t) fig = dm.plot_state(fig=fig) ax2.plot(t, [f(ti) for ti in t], '--') fig2, ax = plt.subplots(1, 3, figsize=(12, 4)) aux = deb_aux.AuxPars(dm) _ = aux.plot_observables(fig=fig2) fig2.tight_layout() ax2.set_ylim(-1, 1.5) fig.tight_layout() ```

fef446b2f82d26db4e82b206b669fffa2bbfc4f7

ipynb

Jupyter Notebook

my-first-deb.ipynb

nepstad/pydebtest

e1409d0c5cd19d72a045a81eaa6ac1bcba77acc9

2017-05-30T18:27:47.000Z

2017-05-30T18:27:47.000Z

my-first-deb.ipynb

nepstad/pydebtest

e1409d0c5cd19d72a045a81eaa6ac1bcba77acc9

my-first-deb.ipynb

nepstad/pydebtest

e1409d0c5cd19d72a045a81eaa6ac1bcba77acc9

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python import sympy as sym import numpy as np ``` ```python def rotationGlobalX(alpha): return np.array([[1,0,0],[0,np.cos(alpha),-np.sin(alpha)],[0,np.sin(alpha),np.cos(alpha)]]) def rotationGlobalY(beta): return np.array([[np.cos(beta),0,np.sin(beta)], [0,1,0],[-np.sin(beta),0,np.cos(beta)]]) def rotationGlobalZ(gamma): return np.array([[np.cos(gamma),-np.sin(gamma),0],[np.sin(gamma),np.cos(gamma),0],[0,0,1]]) def rotationLocalX(alpha): return np.array([[1,0,0],[0,np.cos(alpha),np.sin(alpha)],[0,-np.sin(alpha),np.cos(alpha)]]) def rotationLocalY(beta): return np.array([[np.cos(beta),0,-np.sin(beta)], [0,1,0],[np.sin(beta),0,np.cos(beta)]]) def rotationLocalZ(gamma): return np.array([[np.cos(gamma),np.sin(gamma),0],[-np.sin(gamma),np.cos(gamma),0],[0,0,1]]) ``` ```python from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt import numpy as np %matplotlib notebook plt.rcParams['figure.figsize']=10,10 coefs = (1, 3, 15) # Coefficients in a0/c x**2 + a1/c y**2 + a2/c z**2 = 1 # Radii corresponding to the coefficients: rx, ry, rz = 1/np.sqrt(coefs) # Set of all spherical angles: u = np.linspace(0, 2 * np.pi, 30) v = np.linspace(0, np.pi, 30) # Cartesian coordinates that correspond to the spherical angles: # (this is the equation of an ellipsoid): x = rx * np.outer(np.cos(u), np.sin(v)) y = ry * np.outer(np.sin(u), np.sin(v)) z = rz * np.outer(np.ones_like(u), np.cos(v)) fig = plt.figure(figsize=plt.figaspect(1)) # Square figure ax = fig.add_subplot(111, projection='3d') xr = np.reshape(x, (1,-1)) yr = np.reshape(y, (1,-1)) zr = np.reshape(z, (1,-1)) RX = rotationGlobalX(np.pi/3) RY = rotationGlobalY(np.pi/3) RZ = rotationGlobalZ(np.pi/3) Rx = rotationLocalX(np.pi/3) Ry = rotationLocalY(np.pi/3) Rz = rotationLocalZ(np.pi/3) rRotx = RZ@RY@RX@np.vstack((xr,yr,zr)) print(np.shape(rRotx)) # Plot: ax.plot_surface(np.reshape(rRotx[0,:],(30,30)), np.reshape(rRotx[1,:],(30,30)), np.reshape(rRotx[2,:],(30,30)), rstride=4, cstride=4, color='b') # Adjustment of the axes, so that they all have the same span: max_radius = max(rx, ry, rz) for axis in 'xyz': getattr(ax, 'set_{}lim'.format(axis))((-max_radius, max_radius)) plt.show() ``` <IPython.core.display.Javascript object> (3, 900) ```python coefs = (1, 3, 15) # Coefficients in a0/c x**2 + a1/c y**2 + a2/c z**2 = 1 # Radii corresponding to the coefficients: rx, ry, rz = 1/np.sqrt(coefs) # Set of all spherical angles: u = np.linspace(0, 2 * np.pi, 30) v = np.linspace(0, np.pi, 30) # Cartesian coordinates that correspond to the spherical angles: # (this is the equation of an ellipsoid): x = rx * np.outer(np.cos(u), np.sin(v)) y = ry * np.outer(np.sin(u), np.sin(v)) z = rz * np.outer(np.ones_like(u), np.cos(v)) fig = plt.figure(figsize=plt.figaspect(1)) # Square figure ax = fig.add_subplot(111, projection='3d') xr = np.reshape(x, (1,-1)) yr = np.reshape(y, (1,-1)) zr = np.reshape(z, (1,-1)) RX = rotationGlobalX(np.pi/3) RY = rotationGlobalY(np.pi/3) RZ = rotationGlobalZ(np.pi/3) Rx = rotationLocalX(np.pi/3) Ry = rotationLocalY(np.pi/3) Rz = rotationLocalZ(np.pi/3) rRotx = RY@RX@np.vstack((xr,yr,zr)) print(np.shape(rRotx)) # Plot: ax.plot_surface(np.reshape(rRotx[0,:],(30,30)), np.reshape(rRotx[1,:],(30,30)), np.reshape(rRotx[2,:],(30,30)), rstride=4, cstride=4, color='b') # Adjustment of the axes, so that they all have the same span: max_radius = max(rx, ry, rz) for axis in 'xyz': getattr(ax, 'set_{}lim'.format(axis))((-max_radius, max_radius)) plt.show() ``` <IPython.core.display.Javascript object> (3, 900) ```python np.sin(np.arccos(0.7)) ``` 0.71414284285428498 ```python print(RZ@RY@RX) ``` [[ 0.25 -0.0580127 0.96650635] [ 0.4330127 0.89951905 -0.0580127 ] [-0.8660254 0.4330127 0.25 ]] ```python import sympy as sym sym.init_printing() ``` ```python a,b,g = sym.symbols('alpha, beta, gamma') ``` ```python RX = sym.Matrix([[1,0,0],[0,sym.cos(a),-sym.sin(a)],[0,sym.sin(a),sym.cos(a)]]) RY = sym.Matrix([[sym.cos(b),0,sym.sin(b)],[0,1,0],[-sym.sin(b),0,sym.cos(b)]]) RZ = sym.Matrix([[sym.cos(g),-sym.sin(g),0],[sym.sin(g),sym.cos(g),0],[0,0,1]]) RX,RY,RZ ``` ```python R = RZ@RY@RX R ``` ```python mm = np.array([2.71, 10.22, 26.52]) lm = np.array([2.92, 10.10, 18.85]) fh = np.array([5.05, 41.90, 15.41]) mc = np.array([8.29, 41.88, 26.52]) ajc = (mm + lm)/2 kjc = (fh + mc)/2 ``` ```python i = np.array([1,0,0]) j = np.array([0,1,0]) k = np.array([0,0,1]) v1 = kjc - ajc v1 = v1 / np.sqrt(v1[0]**2+v1[1]**2+v1[2]**2) v2 = (mm-lm) - ((mm-lm)@v1)*v1 v2 = v2/ np.sqrt(v2[0]**2+v2[1]**2+v2[2]**2) v3 = k - (k@v1)*v1 - (k@v2)*v2 v3 = v3/ np.sqrt(v3[0]**2+v3[1]**2+v3[2]**2) ``` ```python v1 ``` array([ 0.12043275, 0.99126617, -0.05373394]) ```python R = np.array([v1,v2,v3]) RGlobal = R.T RGlobal ``` array([[ 0.12043275, -0.02238689, 0.99246903], [ 0.99126617, 0.05682604, -0.11900497], [-0.05373394, 0.99813307, 0.02903508]]) ```python alpha = np.arctan2(RGlobal[2,1],RGlobal[2,2])*180/np.pi alpha ``` ```python beta = np.arctan2(-RGlobal[2,0],np.sqrt(RGlobal[2,1]**2+RGlobal[2,2]**2))*180/np.pi beta ``` ```python gamma = np.arctan2(RGlobal[1,0],RGlobal[0,0])*180/np.pi gamma ``` ```python R2 = np.array([[0, 0.71, 0.7],[0,0.7,-0.71],[-1,0,0]]) R2 ``` array([[ 0. , 0.71, 0.7 ], [ 0. , 0.7 , -0.71], [-1. , 0. , 0. ]]) ```python alpha = np.arctan2(R[2,1],R[2,2])*180/np.pi alpha ``` ```python gamma = np.arctan2(R[1,0],R[0,0])*180/np.pi gamma ``` ```python beta = np.arctan2(-R[2,0],np.sqrt(R[2,1]**2+R[2,2]**2))*180/np.pi beta ``` ```python R = RY@RZ@RX R ``` ```python alpha = np.arctan2(-R2[1,2],R2[1,1])*180/np.pi alpha ``` ```python gamma = 0 ``` ```python beta = 90 ``` ```python import sympy as sym ``` ```python sym.init_printing() ``` ```python a,b,g = sym.symbols('alpha, beta, gamma') ``` ```python RX = sym.Matrix([[1,0,0],[0,sym.cos(a), -sym.sin(a)],[0,sym.sin(a), sym.cos(a)]]) RY = sym.Matrix([[sym.cos(b),0, sym.sin(b)],[0,1,0],[-sym.sin(b),0, sym.cos(b)]]) RZ = sym.Matrix([[sym.cos(g), -sym.sin(g), 0],[sym.sin(g), sym.cos(g),0],[0,0,1]]) RX,RY,RZ ``` ```python ``` ```python RXYZ = RZ*RY*RX RXYZ ``` ```python RZXY = RZ*RX*RY RZXY ``` ```python ```

77cfccd29f47940dc64b804f9797123856ad0568

ipynb

Jupyter Notebook

notebooks/elipsoid3DRotMatrix1.ipynb

tallesmedeiros/BMC

2f5ccad4a58ffc00d5372970a605352f18cfe1b9

2022-03-15T14:50:42.000Z

2022-03-15T14:50:42.000Z

notebooks/elipsoid3DRotMatrix1.ipynb

tallesmedeiros/BMC

2f5ccad4a58ffc00d5372970a605352f18cfe1b9

notebooks/elipsoid3DRotMatrix1.ipynb

tallesmedeiros/BMC

2f5ccad4a58ffc00d5372970a605352f18cfe1b9

Qwen/Qwen-72B

1. YES 2. YES

__label__kor_Hang

This file is part of the pyMOR project (http://www.pymor.org). Copyright 2013-2020 pyMOR developers and contributors. All rights reserved. License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause) # Heat equation example ## Analytic problem formulation We consider the heat equation on the segment $[0, 1]$, with dissipation on both sides, heating (input) $u$ on the left, and measurement (output) $\tilde{y}$ on the right: $$ \begin{align*} \partial_t T(z, t) & = \partial_{zz} T(z, t), & 0 < z < 1,\ t > 0, \\ \partial_z T(0, t) & = T(0, t) - u(t), & t > 0, \\ \partial_z T(1, t) & = -T(1, t), & t > 0, \\ \tilde{y}(t) & = T(1, t), & t > 0. \end{align*} $$ ## Import modules ```python import numpy as np import scipy.linalg as spla import scipy.integrate as spint import matplotlib.pyplot as plt from pymor.basic import * from pymor.core.config import config from pymor.reductors.h2 import OneSidedIRKAReductor from pymor.core.logger import set_log_levels set_log_levels({'pymor.algorithms.gram_schmidt.gram_schmidt': 'WARNING'}) ``` ## Assemble LTIModel ### Discretize problem ```python p = InstationaryProblem( StationaryProblem( domain=LineDomain([0.,1.], left='robin', right='robin'), diffusion=ConstantFunction(1., 1), robin_data=(ConstantFunction(1., 1), ExpressionFunction('(x[...,0] < 1e-10) * 1.', 1)), outputs=(('l2_boundary', ExpressionFunction('(x[...,0] > (1 - 1e-10)) * 1.', 1)),) ), ConstantFunction(0., 1), T=3. ) fom, _ = discretize_instationary_cg(p, diameter=1/100, nt=100) print(fom) ``` ### Visualize solution for constant input of 1 ```python fom.visualize(fom.solve()) ``` ### Convert to LTIModel ```python lti = fom.to_lti() print(lti) ``` ## System analysis ```python poles = lti.poles() fig, ax = plt.subplots() ax.plot(poles.real, poles.imag, '.') ax.set_title('System poles') plt.show() ``` ```python w = np.logspace(-2, 3, 100) fig, ax = plt.subplots() lti.mag_plot(w, ax=ax) ax.set_title('Magnitude plot of the full model') plt.show() ``` ```python hsv = lti.hsv() fig, ax = plt.subplots() ax.semilogy(range(1, len(hsv) + 1), hsv, '.-') ax.set_title('Hankel singular values') plt.show() ``` ```python print(f'FOM H_2-norm: {lti.h2_norm():e}') if config.HAVE_SLYCOT: print(f'FOM H_inf-norm: {lti.hinf_norm():e}') print(f'FOM Hankel-norm: {lti.hankel_norm():e}') ``` ## Balanced Truncation (BT) ```python r = 5 bt_reductor = BTReductor(lti) rom_bt = bt_reductor.reduce(r, tol=1e-5) ``` ```python err_bt = lti - rom_bt print(f'BT relative H_2-error: {err_bt.h2_norm() / lti.h2_norm():e}') if config.HAVE_SLYCOT: print(f'BT relative H_inf-error: {err_bt.hinf_norm() / lti.hinf_norm():e}') print(f'BT relative Hankel-error: {err_bt.hankel_norm() / lti.hankel_norm():e}') ``` ```python poles = rom_bt.poles() fig, ax = plt.subplots() ax.plot(poles.real, poles.imag, '.') ax.set_title('Poles of the BT reduced model') plt.show() ``` ```python fig, ax = plt.subplots() lti.mag_plot(w, ax=ax) rom_bt.mag_plot(w, ax=ax, linestyle='dashed') ax.set_title('Magnitude plot of the full and BT reduced model') plt.show() ``` ```python fig, ax = plt.subplots() err_bt.mag_plot(w, ax=ax) ax.set_title('Magnitude plot of the BT error system') plt.show() ``` ## LQG Balanced Truncation (LQGBT) ```python r = 5 lqgbt_reductor = LQGBTReductor(lti) rom_lqgbt = lqgbt_reductor.reduce(r, tol=1e-5) ``` ```python err_lqgbt = lti - rom_lqgbt print(f'LQGBT relative H_2-error: {err_lqgbt.h2_norm() / lti.h2_norm():e}') if config.HAVE_SLYCOT: print(f'LQGBT relative H_inf-error: {err_lqgbt.hinf_norm() / lti.hinf_norm():e}') print(f'LQGBT relative Hankel-error: {err_lqgbt.hankel_norm() / lti.hankel_norm():e}') ``` ```python poles = rom_lqgbt.poles() fig, ax = plt.subplots() ax.plot(poles.real, poles.imag, '.') ax.set_title('Poles of the LQGBT reduced model') plt.show() ``` ```python fig, ax = plt.subplots() lti.mag_plot(w, ax=ax) rom_lqgbt.mag_plot(w, ax=ax, linestyle='dashed') ax.set_title('Magnitude plot of the full and LQGBT reduced model') plt.show() ``` ```python fig, ax = plt.subplots() err_lqgbt.mag_plot(w, ax=ax) ax.set_title('Magnitude plot of the LGQBT error system') plt.show() ``` ## Bounded Real Balanced Truncation (BRBT) ```python r = 5 brbt_reductor = BRBTReductor(lti, 0.34) rom_brbt = brbt_reductor.reduce(r, tol=1e-5) ``` ```python err_brbt = lti - rom_brbt print(f'BRBT relative H_2-error: {err_brbt.h2_norm() / lti.h2_norm():e}') if config.HAVE_SLYCOT: print(f'BRBT relative H_inf-error: {err_brbt.hinf_norm() / lti.hinf_norm():e}') print(f'BRBT relative Hankel-error: {err_brbt.hankel_norm() / lti.hankel_norm():e}') ``` ```python poles = rom_brbt.poles() fig, ax = plt.subplots() ax.plot(poles.real, poles.imag, '.') ax.set_title('Poles of the BRBT reduced model') plt.show() ``` ```python fig, ax = plt.subplots() lti.mag_plot(w, ax=ax) rom_brbt.mag_plot(w, ax=ax, linestyle='dashed') ax.set_title('Magnitude plot of the full and BRBT reduced model') plt.show() ``` ```python fig, ax = plt.subplots() err_brbt.mag_plot(w, ax=ax) ax.set_title('Magnitude plot of the BRBT error system') plt.show() ``` ## Iterative Rational Krylov Algorithm (IRKA) ```python r = 5 irka_reductor = IRKAReductor(lti) rom_irka = irka_reductor.reduce(r) ``` ```python fig, ax = plt.subplots() ax.semilogy(irka_reductor.conv_crit, '.-') ax.set_title('Distances between shifts in IRKA iterations') plt.show() ``` ```python err_irka = lti - rom_irka print(f'IRKA relative H_2-error: {err_irka.h2_norm() / lti.h2_norm():e}') if config.HAVE_SLYCOT: print(f'IRKA relative H_inf-error: {err_irka.hinf_norm() / lti.hinf_norm():e}') print(f'IRKA relative Hankel-error: {err_irka.hankel_norm() / lti.hankel_norm():e}') ``` ```python poles = rom_irka.poles() fig, ax = plt.subplots() ax.plot(poles.real, poles.imag, '.') ax.set_title('Poles of the IRKA reduced model') plt.show() ``` ```python fig, ax = plt.subplots() lti.mag_plot(w, ax=ax) rom_irka.mag_plot(w, ax=ax, linestyle='dashed') ax.set_title('Magnitude plot of the full and IRKA reduced model') plt.show() ``` ```python fig, ax = plt.subplots() err_irka.mag_plot(w, ax=ax) ax.set_title('Magnitude plot of the IRKA error system') plt.show() ``` ## Two-Sided Iteration Algorithm (TSIA) ```python r = 5 tsia_reductor = TSIAReductor(lti) rom_tsia = tsia_reductor.reduce(r) ``` ```python fig, ax = plt.subplots() ax.semilogy(tsia_reductor.conv_crit, '.-') ax.set_title('Distances between shifts in TSIA iterations') plt.show() ``` ```python err_tsia = lti - rom_tsia print(f'TSIA relative H_2-error: {err_tsia.h2_norm() / lti.h2_norm():e}') if config.HAVE_SLYCOT: print(f'TSIA relative H_inf-error: {err_tsia.hinf_norm() / lti.hinf_norm():e}') print(f'TSIA relative Hankel-error: {err_tsia.hankel_norm() / lti.hankel_norm():e}') ``` ```python poles = rom_tsia.poles() fig, ax = plt.subplots() ax.plot(poles.real, poles.imag, '.') ax.set_title('Poles of the TSIA reduced model') plt.show() ``` ```python fig, ax = plt.subplots() lti.mag_plot(w, ax=ax) rom_tsia.mag_plot(w, ax=ax, linestyle='dashed') ax.set_title('Magnitude plot of the full and TSIA reduced model') plt.show() ``` ```python fig, ax = plt.subplots() err_tsia.mag_plot(w, ax=ax) ax.set_title('Magnitude plot of the TSIA error system') plt.show() ``` ## One-Sided IRKA ```python r = 5 one_sided_irka_reductor = OneSidedIRKAReductor(lti, 'V') rom_one_sided_irka = one_sided_irka_reductor.reduce(r) ``` ```python fig, ax = plt.subplots() ax.semilogy(one_sided_irka_reductor.conv_crit, '.-') ax.set_title('Distances between shifts in one-sided IRKA iterations') plt.show() ``` ```python fig, ax = plt.subplots() osirka_poles = rom_one_sided_irka.poles() ax.plot(osirka_poles.real, osirka_poles.imag, '.') ax.set_title('Poles of the one-sided IRKA ROM') plt.show() ``` ```python err_one_sided_irka = lti - rom_one_sided_irka print(f'One-sided IRKA relative H_2-error: {err_one_sided_irka.h2_norm() / lti.h2_norm():e}') if config.HAVE_SLYCOT: print(f'One-sided IRKA relative H_inf-error: {err_one_sided_irka.hinf_norm() / lti.hinf_norm():e}') print(f'One-sided IRKA relative Hankel-error: {err_one_sided_irka.hankel_norm() / lti.hankel_norm():e}') ``` ```python fig, ax = plt.subplots() lti.mag_plot(w, ax=ax) rom_one_sided_irka.mag_plot(w, ax=ax, linestyle='dashed') ax.set_title('Magnitude plot of the full and one-sided IRKA reduced model') plt.show() ``` ```python fig, ax = plt.subplots() err_one_sided_irka.mag_plot(w, ax=ax) ax.set_title('Magnitude plot of the one-sided IRKA error system') plt.show() ``` ## Transfer Function IRKA (TF-IRKA) Applying Laplace transformation to the original PDE formulation, we obtain a parametric boundary value problem $$ \begin{align*} s \hat{T}(z, s) & = \partial_{zz} \hat{T}(z, s), \\ \partial_z \hat{T}(0, s) & = \hat{T}(0, s) - \hat{u}(s), \\ \partial_z \hat{T}(1, s) & = -\hat{T}(1, s), \\ \hat{\tilde{y}}(s) & = \hat{T}(1, s), \end{align*} $$ where $\hat{T}$, $\hat{u}$, and $\hat{\tilde{y}}$ are respectively Laplace transforms of $T$, $u$, and $\tilde{y}$. We assumed the initial condition to be zero ($T(z, 0) = 0$). The parameter $s$ is any complex number in the region convergence of the Laplace tranformation. Inserting $\hat{T}(z, s) = c_1 \exp\left(\sqrt{s} z\right) + c_2 \exp\left(-\sqrt{s} z\right)$, from the boundary conditions we get a system of equations $$ \begin{align*} \left(\sqrt{s} - 1\right) c_1 - \left(\sqrt{s} + 1\right) c_2 + \hat{u}(s) & = 0, \\ \left(\sqrt{s} + 1\right) \exp\left(\sqrt{s}\right) c_1 - \left(\sqrt{s} - 1\right) \exp\left(-\sqrt{s}\right) c_2 & = 0. \end{align*} $$ We can solve it using `sympy` and then find the transfer function ($\hat{\tilde{y}}(s) / \hat{u}(s)$). ```python import sympy as sy sy.init_printing() sy_s, sy_u, sy_c1, sy_c2 = sy.symbols('s u c1 c2') sol = sy.solve([(sy.sqrt(sy_s) - 1) * sy_c1 - (sy.sqrt(sy_s) + 1) * sy_c2 + sy_u, (sy.sqrt(sy_s) + 1) * sy.exp(sy.sqrt(sy_s)) * sy_c1 - (sy.sqrt(sy_s) - 1) * sy.exp(-sy.sqrt(sy_s)) * sy_c2], [sy_c1, sy_c2]) y = sol[sy_c1] * sy.exp(sy.sqrt(sy_s)) + sol[sy_c2] * sy.exp(-sy.sqrt(sy_s)) sy_tf = sy.simplify(y / sy_u) sy_tf ``` Notice that for $s = 0$, the expression is of the form $0 / 0$. ```python sy.limit(sy_tf, sy_s, 0) ``` ```python sy_dtf = sy_tf.diff(sy_s) sy_dtf ``` ```python sy.limit(sy_dtf, sy_s, 0) ``` We can now form the transfer function system. ```python def H(s): if s == 0: return np.array([[1 / 3]]) else: return np.array([[complex(sy_tf.subs(sy_s, s))]]) def dH(s): if s == 0: return np.array([[-13 / 54]]) else: return np.array([[complex(sy_dtf.subs(sy_s, s))]]) tf = TransferFunction(lti.input_space, lti.output_space, H, dH) print(tf) ``` Here we compare it to the discretized system, by magnitude plot, $\mathcal{H}_2$-norm, and $\mathcal{H}_2$-distance. ```python tf_lti_diff = tf - lti fig, ax = plt.subplots() tf_lti_diff.mag_plot(w, ax=ax) ax.set_title('Distance between PDE and discretized transfer function') plt.show() ``` ```python print(f'TF H_2-norm = {tf.h2_norm():e}') print(f'LTI H_2-norm = {lti.h2_norm():e}') ``` ```python print(f'TF-LTI relative H_2-distance = {tf_lti_diff.h2_norm() / tf.h2_norm():e}') ``` TF-IRKA finds a reduced model from the transfer function. ```python tf_irka_reductor = TFIRKAReductor(tf) rom_tf_irka = tf_irka_reductor.reduce(r) ``` ```python fig, ax = plt.subplots() tfirka_poles = rom_tf_irka.poles() ax.plot(tfirka_poles.real, tfirka_poles.imag, '.') ax.set_title('Poles of the TF-IRKA ROM') plt.show() ``` Here we compute the $\mathcal{H}_2$-distance from the original PDE model to the TF-IRKA's reduced model and to the IRKA's reduced model. ```python err_tf_irka = tf - rom_tf_irka print(f'TF-IRKA relative H_2-error = {err_tf_irka.h2_norm() / tf.h2_norm():e}') ``` ```python err_irka_tf = tf - rom_irka print(f'IRKA relative H_2-error (from TF) = {err_irka_tf.h2_norm() / tf.h2_norm():e}') ```

381c188e320a24f0c783dd4e6040ed84ae2ec908

ipynb

Jupyter Notebook

notebooks/heat.ipynb

weslowrie/pymor

badb5078b2394162d04a1ebfefe9034b889dac64

notebooks/heat.ipynb

weslowrie/pymor

badb5078b2394162d04a1ebfefe9034b889dac64

notebooks/heat.ipynb

weslowrie/pymor

badb5078b2394162d04a1ebfefe9034b889dac64

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Composition A deep neural network is simply a composition of (parametrized) processing nodes. Composing two nodes $g$ and $f$ gives yet another node $h = f \cdot g$, or $h(x) = f(g(x))$. We can also evaluate two nodes in parallel and express the result as the concatenation of the two outputs, $h(x) = (f(x), g(x))$. As such we can also view a deep nerual network as a single processing node where we have collected all the inputs together (into a single input) and collected all the outputs together (into a single output). This is how deep learning frameworks, such as PyTorch, process data through neural networks. This tutorial explores the idea of composition using the `ddn.basic` package. Each processing node in the package is assumed to take a single (vector) input and produce a single (vector) output as presented in the ["Deep Declarative Networks: A New Hope"](https://arxiv.org/abs/1909.04866) paper, so we have to merge and split vectors as we process data through the network. ```python %matplotlib inline ``` ## Example: Matching means We will develop an example of modifying two vector inputs so that their means match. Our network first computes the mean of each vector, then computes their square difference. Back-propagating to reduce the square difference will modify the vectors such that their means are equal. The network can be visualized as ``` .------. .------. | | x_1 ---| mean |--- mu_1 ---| | '------' | | .---------. | diff |--- (mu_1 - mu_2) ---| 1/2 sqr |--- y .------. | | '---------' x_2 ---| mean |--- mu_2 ---| | '------' | | '------' ``` Viewing the network as a single node we have ``` .-------------------------------------------------------------------------. | .------. | | .------. | | | | x_1 ---| mean |--- mu_1 ---| | | | / '------' | | .---------. | x ---|-< | diff |--- (mu_1 - mu_2) ---| 1/2 sqr |---|--- y | \ .------. | | '---------' | | x_2 ---| mean |--- mu_2 ---| | | | '------' | | | | '------' | .-------------------------------------------------------------------------' ``` Note here each of $x_1$ and $x_2$ is an $n$-dimensional vector. So $x = (x_1, x_2) \in \mathbb{R}^{2n}$. We now develop the code for this example, starting with the upper and lower branches of the network. ```python import sys sys.path.append("../") from ddn.basic.node import * from ddn.basic.sample_nodes import * from ddn.basic.robust_nodes import * from ddn.basic.composition import * # construct n-dimensional vector inputs n = 10 x_1 = np.random.randn(n, 1) x_2 = np.random.randn(n, 1) x = np.vstack((x_1, x_2)) # create upper and lower branches upperBranch = ComposedNode(SelectNode(2*n, 0, n-1), RobustAverage(n, 'quadratic')) lowerBranch = ComposedNode(SelectNode(2*n, n), RobustAverage(n, 'quadratic')) ``` Here we construct each branch by composing a `SelectNode`, which chooses the appropriate subvector $x_1$ or $x_2$ for the branch, with a `RobustAverage` node, which computes the mean. To make sure things are working so far we evaluate the upper and lower branches, each now expressed as a single composed processing node, and compare their outputs to the mean of $x_1$ and $x_2$, respectively. ```python mu_1, _ = upperBranch.solve(x) mu_2, _ = lowerBranch.solve(x) print("upper branch: {} vs {}".format(mu_1, np.mean(x_1))) print("lower branch: {} vs {}".format(mu_2, np.mean(x_2))) ``` upper branch: [0.35571504] vs 0.3557150433275785 lower branch: [-0.2411335] vs -0.2411335017597908 Continuing the example, we now run the upper and lower branches in parallel (to produce $(\mu_1, \mu_2) \in \mathbb{R}^2$) and write a node to take the difference between the two elements of the resulting vector. ```python # combine the upper and lower branches meansNode = ParallelNode(upperBranch, lowerBranch) # node for computing mu_1 - mu_2 class DiffNode(AbstractNode): """Computes the difference between elements in a 2-dimensional vector.""" def __init__(self): super().__init__(2, 1) def solve(self, x): assert len(x) == 2 return x[0] - x[1], None def gradient(self, x, y=None, ctx=None): return np.array([1.0, -1.0]) # now put everything together into a network (super declarative node) network = ComposedNode(ComposedNode(meansNode, DiffNode()), SquaredErrorNode(1)) # print the initial (half) squared difference between the means y, _ = network.solve(x) print(y) ``` 0.17811409288645474 Now let's optimize $x_1$ and $x_2$ so as to make their means equal. ```python import scipy.optimize as opt import matplotlib.pyplot as plt x_init = x.copy() y_init, _ = network.solve(x_init) history = [y_init] result = opt.minimize(lambda xk: network.solve(xk)[0], x_init, args=(), method='L-BFGS-B', jac=lambda xk: network.gradient(xk), options={'maxiter': 1000, 'disp': False}, callback=lambda xk: history.append(network.solve(xk)[0])) # plot results plt.figure() plt.semilogy(history, lw=2) plt.xlabel("iter."); plt.ylabel("error") plt.title("Example: Matching means") plt.show() # print final vectors and their means x_final = result.x print(x_final[0:n]) print(x_final[n:]) print(np.mean(x_final[0:n])) print(np.mean(x_final[n:])) ``` ## Mathematics To understand composition mathematically, consider the following network, ``` .---. .---| f |---. / '---' \ .---. x --< >--| h |--- y \ .---. / '---' '---| g |---' '---' ``` We can write the function as $y = h(f(x), g(x))$. Let's assume that $x$ is an $n$-dimensional vector, $f : \mathbb{R}^n \to \mathbb{R}^p$, $g : \mathbb{R}^m \to \mathbb{R}^q$, and $h : \mathbb{R}^{p+q} \to \mathbb{R}^m$. This implies that the output, $y$, is an $m$-dimensional vector. We can write the derivative as $$ \begin{align} \text{D}y(x) &= \text{D}_{F}h(f, g) \text{D}f(x) + \text{D}_{G}h(f, g) \text{D}g(x) \\ &= \begin{bmatrix} \text{D}_F h & \text{D}_G h \end{bmatrix} \begin{bmatrix} \text{D}f \\ \text{D}g \end{bmatrix} \end{align} $$ where the first matrix on the right-hand-side has size $m \times (p + q)$ and the second matrix has size $(p + q) \times n$, giving an $m \times n$ matrix for $\text{D}y(x)$ as expected. Moreover, we can treat the parallel branch as a single node in the graph computing $(f(x), g(x)) \in \mathbb{R}^{p+q}$. Note that none of this is specific to deep declarative nodes---it is a simple consequence of the rules of differentiation and applies to both declarative and imperative nodes. We can, however, also think about composition of the objective function within the optimization problem defining a declarative node. ## Composed Objectives within Declarative Nodes Consider the following parametrized optimization problem $$ \begin{align} y(x) &= \text{argmin}_{u \in \mathbb{R}} h(f(x, u), g(x, u)) \end{align} $$ for $x \in \mathbb{R}$. From Proposition 4.3 of the ["Deep Declarative Networks: A New Hope"](https://arxiv.org/abs/1909.04866) paper we have $$ \begin{align} \frac{dy}{dx} &= -\left(\frac{\partial^2 h(f(x, y), g(x, y))}{\partial y^2}\right)^{-1} \frac{\partial^2 h(f(x, y), g(x, y))}{\partial x \partial y} \end{align} $$ when the various partial derivatives exist. Expanding the derivatives we have $$ \begin{align} \frac{\partial h(f(x, y), g(x, y))}{\partial y} &= \frac{\partial h}{\partial f} \frac{\partial f}{\partial y} + \frac{\partial h}{\partial g} \frac{\partial g}{\partial y} \\ \frac{\partial^2 h(f(x, y), g(x, y))}{\partial y^2} &= \frac{\partial^2 h}{\partial y \partial f} \frac{\partial f}{\partial y} + \frac{\partial h}{\partial f} \frac{\partial^2 f}{\partial y^2} + \frac{\partial^2 h}{\partial y \partial g} \frac{\partial g}{\partial y} + \frac{\partial h}{\partial g} \frac{\partial^2 g}{\partial y^2} \\ &= \begin{bmatrix} \frac{\partial^2 h}{\partial y \partial f} \\ \frac{\partial^2 f}{\partial y^2} \\ \frac{\partial^2 h}{\partial y \partial g} \\ \frac{\partial^2 g}{\partial y^2} \end{bmatrix}^T \begin{bmatrix} \frac{\partial f}{\partial y} \\ \frac{\partial h}{\partial f} \\ \frac{\partial g}{\partial y} \\ \frac{\partial h}{\partial g} \end{bmatrix} \\ \frac{\partial^2 h(f(x, y), g(x, y))}{\partial x \partial y} &= \begin{bmatrix} \frac{\partial^2 h}{\partial x \partial f} \\ \frac{\partial^2 f}{\partial x \partial y} \\ \frac{\partial^2 h}{\partial x \partial g} \\ \frac{\partial^2 g}{\partial x \partial y} \end{bmatrix}^T \begin{bmatrix} \frac{\partial f}{\partial y} \\ \frac{\partial h}{\partial f} \\ \frac{\partial g}{\partial y} \\ \frac{\partial h}{\partial g} \end{bmatrix} \end{align} $$ As a special case, when $f: (x, u) \mapsto x$ and $g: (x, u) \mapsto u$ we have $$ \begin{align} \frac{\partial^2 h(f(x, y), g(x, y))}{\partial y^2} &= \begin{bmatrix} \frac{\partial^2 h}{\partial y \partial f} \\ 0 \\ \frac{\partial^2 h}{\partial y \partial g} \\ 0 \end{bmatrix}^T \begin{bmatrix} 0 \\ \frac{\partial h}{\partial f} \\ 1 \\ \frac{\partial h}{\partial g} \end{bmatrix} &= \frac{\partial^2 h}{\partial y^2} \\ \frac{\partial^2 h(f(x, y), g(x, y))}{\partial x \partial y} &= \begin{bmatrix} \frac{\partial^2 h}{\partial x \partial f} \\ 0 \\ \frac{\partial^2 h}{\partial x \partial g} \\ 0 \end{bmatrix}^T \begin{bmatrix} 0 \\ \frac{\partial h}{\partial f} \\ 1 \\ \frac{\partial h}{\partial g} \end{bmatrix} &= \frac{\partial^2 h}{\partial x \partial y} \end{align} $$ which gives the standard result, as it should. ```python ```

e6874217f4a010af89bcd04ebf607f1d01fdf9b2

ipynb

Jupyter Notebook

tutorials/06_composition.ipynb

pmorerio/ddn

68e44e3ccfbeed285a78bf75cc778802dd15890e

2019-09-08T05:22:43.000Z

2022-03-31T06:13:43.000Z

tutorials/06_composition.ipynb

pmorerio/ddn

68e44e3ccfbeed285a78bf75cc778802dd15890e

2020-09-15T06:59:23.000Z

2021-12-27T04:15:19.000Z

tutorials/06_composition.ipynb

pmorerio/ddn

68e44e3ccfbeed285a78bf75cc778802dd15890e

2019-09-15T08:34:45.000Z

2022-01-04T04:48:54.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Pg. 332 #29, 41, 53, 71, 73, 83, 87, 89, 93, 101, 102 --- Eric Nguyen 20 Dec 2018 ``` import numpy as np import matplotlib.pyplot as plt ``` ### *Find each logarithm*. *Round to six decimal places.* #### 29. $\ln{5894}$ ``` ans29 = round(np.log(5894), 6) ans29 ``` #### Answer 29: > $8.68169$ ### *Solve for $t$*. #### 41. $e^{-0.02t} = 0.06$ $$ \begin{align} e^{-0.02t} &= 0.06 \\ -0.02t &= \ln{0.06} \\ t &= \frac{\ln{0.06}}{-0.02} \end{align} $$ ``` ans41 = np.log(0.06) / (-0.02) ans41 ``` ``` # Verify np.power(np.e, -0.02 * ans41) ``` #### Answer 41: > $t = 140.670536$ ### *Differentiate*. #### 53. $y = \ln{\frac{x^2}{4}} \left(\text{Hint:} \ln{\frac{A}{B}} = \ln{A} - \ln{B}\right)$ $$ \begin{align} y &= \ln{x^2} - \ln{4} \\ y' &= \frac{2x}{x^2} \\ &= \frac{2}{x} \end{align} $$ ``` def pltfn(fn, xlim = (-10, 10), smoothness = 100, color = False): xp = np.linspace(xlim[0], xlim[1], smoothness) if (color): plt.plot(xp, fn(xp), color = color) else: plt.plot(xp, fn(xp)) qtn53 = lambda x: np.log(np.power(x, 2) / 4) ans53 = lambda x: 2 / x pltfn(qtn53) pltfn(ans53) ``` #### Answer 53: > $y' = \dfrac{2}{x}$ #### 59. $g(x) = e^x \ln{x^2}$ $$\begin{align} g'(x) &= \frac{d}{dx} e^x \cdot \frac{d}{dx} \ln{x^2} \\ &= e^x \cdot \frac{2}{x} \\ &= \frac{2e^x}{x} \end{align}$$ ``` qtn59 = lambda x: np.power(np.e, x) * np.log(np.power(x, 2)) ans59 = lambda x: (2 * np.power(np.e, x)) / x pltfn(qtn59, (5, 10)) pltfn(ans59, (5, 10)) ``` #### Answer 59: > $g'(x) = \dfrac{2e^x}{x}$ #### 71. Find the equation of the line tangent to the graph of $y = (\ln{x})^2$ at $x = 3$. $$\begin{align} y' &= 2 \cdot (\ln{x}) \cdot \frac{1}{x} \\ &= \frac{2\ln{x}}{x} \\ y &= f(x) \\ g(x) &= f'\left(a\right)\left(x-a\right)+f\left(a\right) \quad &\text{Tangent line equation.} \\ f'(3) &= \frac{2\ln{3}}{3} \quad &\text{Find the slope.} \\ &\approx 0.732408 \\ f(3) &\approx 1.206949 \\ g(x) &= 0.732408(x - 3) + 1.206949 \\ \end{align}$$ ``` fn71 = lambda x: np.power(np.log(x), 2) dfn71 = lambda x: (2 * np.log(x)) / x ``` ``` slope71 = (2 * np.log(3)) / 3 slope71 ``` ``` fn71(3) ``` ``` ans71 = lambda x: slope71 * (x - 3) + fn71(3) pltfn(fn71, (0.5, 5)) pltfn(dfn71, (0.5, 5)) pltfn(ans71, (0.5, 5)) ``` #### Answer 71: > $g(x) = 0.732408(x - 3) + 1.206949$ #### 73. <span style="color: #0af">Advertising.</span>&emsp;A model for consumers' response to advertising is given by $$ N(a) = 2000 + 500 \ln{a}, \quad a \geq 1,$$ #### where $N(a)$ is the number of units sold and $a$ is the amount spent on advertising, in thousands of dollars. #### a) How many units were sold after spending $\$1000$ on advertising? ``` fn73 = lambda a: 2000 + 500 * np.log(a) fn73(1000) ``` #### Answer 73a: > $N(1000) \approx 5453$ #### b) Find $N'(a)$ and $N'(10)$. $$\begin{align} N'(a) &= \frac{500}{a} \\ \end{align}$$ ``` dfn73 = lambda a: 500 / a dfn73(10) ``` ``` pltfn(fn73, (0.25, 5)) pltfn(dfn73, (0.25, 5)) ``` ``` pltfn(dfn73, (8, 12), color="green") plt.scatter(10, dfn73(10), color="green") ``` #### c) Find the maximum and minimum values, if they exist. $$\begin{align} N'(a) &= \frac{500}{a} \\ 0 &= \frac{500}{a} & \text{Find the zeroes.} \\ 0 &\neq 500 \end{align}$$ #### Answer 73c: > There are no minimum or maximum values. #### d) Find $\underset{a\to\infty}{\lim} N'(a)$. Discuss whether it makes sense to continue to spend more and more dollars on advertising. $$\begin{align} \underset{a\to\infty}{\lim} N'(a) &= \frac{500}{\infty} \\ \underset{a\to\infty}{\lim} N'(a) &= 0 \end{align}$$ #### Answer 73d: > It does not make sense to spend more and more dollars on advertising, in thousands of dollars, as the effect of advertising rapidly diminishes for each thousand of dollars spent. #### 83. <span style="color: #0af">Forgetting.</span>&emsp;Students in a zoology class took a final exam. They took equivalent forms of the exam at monthly intervals thereafter. After $t$ months, the average score $S(t)$, as a percentage was found to be given by $$ S(t) = 78 - 15 \ln{\left(t + 1\right)}, \quad t \geq 0. $$ #### a) What was the average score when they initially took the test, $t = 0$? ``` fn83 = lambda t: 78 - 15 * np.log(t + 1) pltfn(fn83, (0, 200)) ans83a = fn83(0) ans83a ``` #### Answer 83a: > $S(0) = 78.0$ #### b) What was the average score after 4 months? ``` ans83b = fn83(4) ans83b ``` #### Answer 83b: > $S(4) \approx 53.858$ #### c) What was the average score after 24 months? ``` ans83c = fn83(24) ans83c ``` #### Answer 83c: > $S(24) \approx 29.727$ #### d) What percentage of their original answers did the students retain after 2 years (24 months)? ``` ans83c / ans83a ``` 0.38098541829457677 #### Answer 83d: > $38.1\%$ #### e) Find $S'(t)$. $$\begin{align} S(t) &= 78 - 15 \ln{\left(t + 1\right)}, & t \geq 0 \\ S'(t) &= -15 \cdot \frac{1}{t + 1}, & t \geq 0 \\ &= \frac{-15}{t + 1}, & t \geq 0 \end{align}$$ ``` dfn83 = lambda t: -15 / (t + 1) pltfn(fn83, (0, 200)) pltfn(dfn83, (0, 200)) ``` #### f) Find the maximum and minimum values, if they exist. $$\begin{align} S'(t) &= \frac{-15}{t + 1} \\ 0 &= \frac{-15}{t + 1} \\ 0 &\neq -15 \end{align}$$ #### Answer 83f: > There are no maximum or minimum values. ### *Solve for $t$*. #### 87. $P = P_0e^{-kt}$ $$\begin{align} \frac{P}{P_0} &= e^{-kt} \\ \ln{\left(\frac{P}{P_0}\right)} &= -kt \\ t &= \frac{\ln{\left(\frac{P}{P_0}\right)}}{-k} \end{align}$$ ### *Differentiate*. #### 93. $f(t) = \ln{\dfrac{1 - t}{1 + t}}$ #### Answer 93: $$\begin{align} f(t) &= \ln{\left(1 - t \right)} - \ln{\left(1 + t\right)} \\ f'(t) &= \frac{-1}{1 - t} - \frac{1}{1 + t} \\ f'(t) &= \frac{-\left(1 + t\right)}{\left(1 - t\right)\left(1 + t\right)} - \frac{\left(1 - t\right)}{\left(1 + t\right)\left(1 - t\right)} \\ f'(t) &= \frac{-1 - t - 1 + t}{\left(1 - t\right)\left(1 + t\right)} \\ f'(t) &= \frac{-2}{\left(1 - t\right)\left(1 + t\right)} \\ \end{align}$$ #### 101. $f(x) = \ln{\dfrac{1 + \sqrt{x}}{1 - \sqrt{x}}}$ #### Answer 101: $$\begin{align} f(x) &= \ln{\left(1 + \sqrt{x}\right)} - \ln{\left(1 - \sqrt{x}\right)} \\ \frac{d}{dx} \sqrt{x} &= \frac{1}{2\sqrt{x}} \\ f'(x) &= \frac{\frac{1}{2\sqrt{x}}}{1 + \sqrt{x}} - \frac{-\frac{1}{2\sqrt{x}}}{1 - \sqrt{x}} \\ f'(x) &= \frac{1}{\left(2\sqrt{x}\right)\left(1 + \sqrt{x}\right)} + \frac{1}{\left(2\sqrt{x}\right)\left(1 - \sqrt{x}\right)} \\ f'(x) &= \frac{\left(1 - \sqrt{x}\right)}{\left(2\sqrt{x}\right)\left(1 + \sqrt{x}\right)\left(1 - \sqrt{x}\right)} + \frac{\left(1 + \sqrt{x}\right)}{\left(2\sqrt{x}\right)\left(1 - \sqrt{x}\right)\left(1 + \sqrt{x}\right)} \\ f'(x) &= \frac{2}{\left(2\sqrt{x}\right)\left(1 + \sqrt{x}\right)\left(1 - \sqrt{x}\right)} \\ f'(x) &= \frac{1}{\sqrt{x}\left(1 - \sqrt{x}\right)\left(1 + \sqrt{x}\right)} \\ f'(x) &= \frac{1}{\sqrt{x}\left(1 - x\right)} \\ \end{align}$$ #### 102. $f(x) = \ln{\left(\ln{x}\right)}^3$ #### Answer 102: $$\begin{align} f(x) &= 3 \ln{\left(\ln{x}\right)} \\ f'(x) &= \frac{\frac{3}{x}}{\ln{x}} \\ f'(x) &= \frac{3}{x\ln{x}} \end{align}$$

a22cb2f3ff24a984f5196cd771571186513e8167

ipynb

Jupyter Notebook

2018-12/2018-12-20.ipynb

airicbear/calculus-homework

a765d3ba35b2b3794b9b2cce038152682eeb2cb8

2018-12/2018-12-20.ipynb

airicbear/calculus-homework

a765d3ba35b2b3794b9b2cce038152682eeb2cb8

2019-02-04T07:00:05.000Z

2019-02-09T01:17:25.000Z

2018-12/2018-12-20.ipynb

airicbear/calculus-homework

a765d3ba35b2b3794b9b2cce038152682eeb2cb8

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Expectation–maximization algorithm # Purpose * Understand how the EM-algorithm works to estimate parameters # Methodology * Implement a simple EM-algorithm # Setup ```python # %load imports.py ## Local packages: %matplotlib inline %load_ext autoreload %autoreload 2 %config Completer.use_jedi = False ## (To fix autocomplete) ## External packages: import pandas as pd pd.options.display.max_rows = 999 pd.options.display.max_columns = 999 pd.set_option("display.max_columns", None) import numpy as np import os import matplotlib.pyplot as plt #if os.name == 'nt': # plt.style.use('presentation.mplstyle') # Windows import plotly.express as px import plotly.graph_objects as go import seaborn as sns import sympy as sp from sympy.physics.mechanics import (dynamicsymbols, ReferenceFrame, Particle, Point) from sympy.physics.vector.printing import vpprint, vlatex from IPython.display import display, Math, Latex from src.substitute_dynamic_symbols import run, lambdify import pyro import sklearn import pykalman from statsmodels.sandbox.regression.predstd import wls_prediction_std import statsmodels.api as sm from scipy.integrate import solve_ivp ## Local packages: from src.data import mdl from src.symbols import * from src.parameters import * import src.symbols as symbols from src import prime_system from src.models import regression from src.visualization.regression import show_pred from src.visualization.plot import track_plot ## Load models: # (Uncomment these for faster loading): import src.models.vmm_linear as vmm from src.data.case_0 import ship_parameters, df_parameters, ps, ship_parameters_prime from src.data.transform import transform_to_ship from scipy.stats import norm import filterpy.stats as stats from filterpy.common import Q_discrete_white_noise from filterpy.kalman import KalmanFilter from numpy import sum ``` ## Generate some data ```python t_ = np.linspace(0,10,11) k_ = 1 x = k_*t_ z = x + np.random.normal(scale=0.5, size=len(t_)) fig,ax=plt.subplots() ax.plot(t_,x, label='real') ax.plot(t_,z, 'o', label='measurement') ax.legend(); ``` ```python F = 2 # Guessing for i in range(5): F = sum(x[1:] - F*x[0:-1])/sum(x**2) print(F) ``` ```python ``` ```python len(x[0:-1]) ``` ```python len(x[1:]) ``` ```python F ``` ```python ```

f4567bee0391585574891c6ab3dba4296ae25a19

ipynb

Jupyter Notebook

notebooks/15.20_EM-algorithm.ipynb

martinlarsalbert/wPCC

16e0d4cc850d503247916c9f5bd9f0ddb07f8930

notebooks/15.20_EM-algorithm.ipynb

martinlarsalbert/wPCC

16e0d4cc850d503247916c9f5bd9f0ddb07f8930

notebooks/15.20_EM-algorithm.ipynb

martinlarsalbert/wPCC

16e0d4cc850d503247916c9f5bd9f0ddb07f8930

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

## Classical Mechanics - Week 9 ### Last Week: - We saw how a potential can be used to analyze a system - Gained experience with plotting and integrating in Python ### This Week: - We will study harmonic oscillations using packages - Further develope our analysis skills - Gain more experience wtih sympy ```python # Let's import packages, as usual import numpy as np import matplotlib.pyplot as plt import sympy as sym sym.init_printing(use_unicode=True) ``` Let's analyze a spring using sympy. It will have mass $m$, spring constant $k$, angular frequency $\omega_0$, initial position $x_0$, and initial velocity $v_0$. The motion of this harmonic oscillator is described by the equation: eq 1.) $m\ddot{x} = -kx$ This can be solved as eq 2.) $x(t) = A\cos(\omega_0 t - \delta)$, $\qquad \omega_0 = \sqrt{\dfrac{k}{m}}$ Use SymPy below to plot this function. Set $A=2$, $\omega_0 = \pi/2$ and $\delta = \pi/4$. (Refer back to ***Notebook 7*** if you need to review plotting with SymPy.) ```python # Plot for equation 2 here A, omega0, t, delta = sym.symbols('A, omega_0, t, delta') x=A*sym.cos(omega0*t-delta) x ``` ```python x1 = sym.simplify(x.subs({A:2, omega0:sym.pi/2, delta:sym.pi/4})) x1 ``` ```python sym.plot(x1,(t,0,10), title='position vs time',xlabel='t',ylabel='x') ``` ## Q1.) Calculate analytically the initial conditions, $x_0$ and $v_0$, and the period of the motion for the given constants. Is your plot consistent with these values? &#9989; Double click this cell, erase its content, and put your answer to the above question here. ####### Possible answers ####### Initial position $x_0=2\cos(-\pi/4)=\sqrt{2}$. Initial velocity $v_0=-2(\pi/2)\sin(-\pi/4)=\pi/\sqrt{2}$. The period is $2\pi/(\pi/2)=4$. The initial position and the period are easily seen to agree with these values. The initial velocity is positive and the initial slope looks like it agrees. ####### Possible answers ####### #### Now let's make plots for underdamped, critically-damped, and overdamped harmonic oscillators. Below are the general equations for these oscillators: - Underdamped, $\beta < \omega_0$ : eq 3.) $x(t) = A e^{-\beta t}cos(\omega ' t) + B e^{-\beta t}sin(\omega ' t)$ , $\omega ' = \sqrt{\omega_0^2 - \beta^2}$ ___________________________________ - Critically-damped, $\beta = \omega_0$: eq 4.) $x(t) = Ae^{-\beta t} + B t e^{-\beta t}$ ___________________________________ - Overdamped, $\beta > \omega_0$: eq 5.) $x(t) = Ae^{-\left(\beta + \sqrt{\beta^2 - \omega_0^2}\right)t} + Be^{-\left(\beta - \sqrt{\beta^2 - \omega_0^2}\right)t}$ _______________________ In the cells below use SymPy to create the Position vs Time plots for these three oscillators. Use $\omega_0=\pi/2$ as before, and then choose an appropriate value of $\beta$ for the three different damped oscillator solutions. Play around with the variables, $A$, $B$, and $\beta$, to see how different values affect the motion and if this agrees with your intuition. ```python # Put your code for graphing Underdamped here A, B, omega0, beta, t = sym.symbols('A, B, omega_0, beta, t') omegap=sym.sqrt(omega0**2-beta**2) x=sym.exp(-beta*t)*(A*sym.cos(omegap*t)+B*sym.sin(omegap*t)) x ``` ```python x1 = sym.simplify(x.subs({A:0, B:2, omega0:sym.pi/2, beta:sym.pi/40})) sym.plot(x1,(t,0,30), title='Underdamped Oscillator',xlabel='t',ylabel='x') ``` ```python # Put your code for graphing Critical here A, B, omega0, beta, t = sym.symbols('A, B, omega_0, beta, t') x=sym.exp(-beta*t)*(A+B*t) x ``` ```python x1 = sym.simplify(x.subs({A:0, B:2, omega0:sym.pi/2, beta:sym.pi/2})) sym.plot(x1,(t,0,30), title='Critically-damped Oscillator',xlabel='t',ylabel='x') ``` ```python # Put your code for graphing Overdamped here A, B, omega0, beta, t = sym.symbols('A, B, omega_0, beta, t') beta1=beta+sym.sqrt(beta**2-omega0**2) beta2=beta-sym.sqrt(beta**2-omega0**2) x=A*sym.exp(-beta1*t)+B*sym.exp(-beta2*t) x ``` ```python x1 = sym.simplify(x.subs({A:-2, B:2, omega0:sym.pi/2, beta:sym.pi})) sym.plot(x1,(t,0,30), title='Overdamped Oscillator',xlabel='t',ylabel='x') ``` ## Q2.) How would you compare the 3 different oscillators? &#9989; Double click this cell, erase its content, and put your answer to the above question here. ####### Possible answers ####### Underdamped: Oscillations, with amplititude decreasing over time Critical Damping: No oscillations. Curve dies the fastest of the three (for fixed $\omega_0$). Overdamped: No oscillations. Curve dies slower than critically damped case. ####### Possible answers ####### # Here's another simple harmonic system, the pendulum. The equation of motion for the pendulum is: eq 6.) $ml\dfrac{d^2\theta}{dt^2} + mg \sin(\theta) = 0$, where $v=l\dfrac{d\theta}{dt}$ and $a=l\dfrac{d^2\theta}{dt^2}$ In the small angle approximation $\sin\theta\approx\theta$, so this can be written: eq 7.) $\dfrac{d^2\theta}{dt^2} = -\dfrac{g}{l}\theta$ We then find the period of the pendulum to be $T = \dfrac{2\pi}{\sqrt{l/g}}$ and the angle at any given time (if released from rest) is given by $\theta = \theta_0\cos{\left(\sqrt{\dfrac{g}{l}} t\right)}$. Let's use Euler's Forward method to solve equation (7) for the motion of the pendulum in the small angle approximation, and compare to the analytic solution. First, let's graph the analytic solution for $\theta$. Go ahead and graph using either sympy, or the other method we have used, utilizing these variables: - $t:(0s,50s)$ - $\theta_0 = 0.5$ radians - $l = 40$ meters ```python # Plot the analytic solution here l=40 g=9.81 theta0, omega0, t = sym.symbols('theta_0, omega_0, t') theta = theta0*sym.cos(omega0*t) theta1 = sym.simplify(theta.subs({omega0:(g/l)**0.5,theta0:0.5})) sym.plot(theta1,(t,0,50),title='Pendulum Oscillation, Small Angle Approximation',xlabel='time (s)',ylabel='Theta (radians)') plt.show() ``` ```python # The same analytic plot, but now using matplotlib # This is easier for comparing with the Euler's method calculation ti=0 tf=50 dt=0.001 t=np.arange(ti,tf,dt) theta0=0.5 l=40 g=9.81 omega0=np.sqrt(g/l) theta=theta0*np.cos(omega0*t) plt.grid() plt.xlabel("Time (s)") plt.ylabel("Theta (radians)") plt.title("Theta (radians) vs Time (s), small angle approximation") plt.plot(t,theta) plt.show() ``` Now, use Euler's Forward method to obtain a plot of $\theta$ as a function of time $t$ (in the small angle approximation). Use eq (7) to calculate $\ddot{\theta}$ at each time step. Try varying the time step size to see how it affects the Euler's method solution. ```python # Perform Euler's Method Here theta1=np.zeros(len(t)) theta1[0]=theta0 dtheta=0 ddtheta=-omega0**2*theta1[0] for i in range(len(t)-1): theta1[i+1] = theta1[i] + dtheta*dt dtheta += ddtheta*dt ddtheta = -omega0**2*theta1[i+1] import matplotlib.patches as mpatches plt.grid() plt.xlabel("Time (s)") plt.ylabel("Theta (radians)") plt.title("Theta (radians) vs Time (s), small angle approximation") blue_patch = mpatches.Patch(color = 'b', label = 'analytic') red_patch = mpatches.Patch(color = 'r', label = 'Euler method') plt.legend(handles=[blue_patch,red_patch],loc='lower left') plt.plot(t,theta1,color='r') plt.plot(t,theta,color='b') plt.show() ``` You should have found that if you chose the time step size small enough, then the Euler's method solution was indistinguishable from the analytic solution. We can now trivially modify this, to solve for the pendulum **exactly**, without using the small angle approximation. The exact equation for the acceleration is eq 8.) $\dfrac{d^2\theta}{dt^2} = -\dfrac{g}{l}\sin\theta$. Modify your Euler's Forward method calculation to use eq (8) to calculate $\ddot{\theta}$ at each time step in the cell below. ```python theta2=np.zeros(len(t)) theta2[0]=theta0 dtheta=0 ddtheta=-omega0**2*np.sin(theta2[0]) for i in range(len(t)-1): theta2[i+1] = theta2[i] + dtheta*dt dtheta += ddtheta*dt ddtheta = -omega0**2*np.sin(theta2[i+1]) plt.grid() plt.xlabel("Time (s)") plt.ylabel("Theta (radians)") plt.title("Theta (radians) vs Time (s)") blue_patch = mpatches.Patch(color = 'b', label = 'small angle approximation') red_patch = mpatches.Patch(color = 'r', label = 'EXACT') plt.legend(handles=[blue_patch,red_patch],loc='lower left') plt.plot(t,theta2,color='r') plt.plot(t,theta1,color='b') plt.show() ``` # Q3.) What time step size did you use to find agreement between Euler's method and the analytic solution (in the small angle approximation)? How did the exact solution differ from the small angle approximation? &#9989; Double click this cell, erase its content, and put your answer to the above question here. ####### Possible answers ####### A time step of 0.001 was sufficient so that Euler's method and the analytic formula were indistinguishable in the plots (for small angle approximation). (Different time steps could be found, depending on how closely one compared the plots.) The exact pendulum solution has a slightly longer period than the small angle approximation (in agreement with what we learned last week.) ####### Possible answers ####### ### Now let's do something fun: In class we found that the 2-dimensional anisotropic harmonic motion can be solved as eq 8a.) $x(t) = A_x \cos(\omega_xt)$ eq 8b.) $y(t) = A_y \cos(\omega_yt - \delta)$ If $\dfrac{\omega_x}{\omega_y}$ is a rational number (*i.e,* a ratio of two integers), then the trajectory repeats itself after some amount of time. The plots of $x$ vs $y$ in this case are called Lissajous figures (after the French physicists Jules Lissajous). If $\dfrac{\omega_x}{\omega_y}$ is not a rational number, then the trajectory does not repeat itself, but it still shows some very interesting behavior. Let's make some x vs y plots below for the 2-d anisotropic oscillator. First, recreate the plots in Figure 5.9 of Taylor. (Hint: Let $A_x=A_y$. For the left plot of Figure 5.9, let $\delta=\pi/4$ and for the right plot, let $\delta=0$.) Next, try other rational values of $\dfrac{\omega_x}{\omega_y}$ such as 5/6, 19/15, etc, and using different phase angles $\delta$. Finally, for non-rational $\dfrac{\omega_x}{\omega_y}$, what does the trajectory plot look like if you let the length of time to be arbitrarily long? \[For these parametric plots, it is preferable to use our original plotting method, *i.e.* using `plt.plot()`, as introduced in ***Notebook 1***.\] ```python # Plot the Lissajous curves here Ax=1 Ay=1 omegay=1 ti=0 tf=10 dt=0.1 t=np.arange(ti,tf,dt) r=2 delta=np.pi/4 omegax=r*omegay X=Ax*np.cos(omegax*t) Y=Ay*np.cos(omegay*t-delta) plt.plot(X,Y) ``` ```python ti=0 tf=24.1 dt=0.1 t=np.arange(ti,tf,dt) r=np.sqrt(2) delta=0 omegax=r*omegay X=Ax*np.cos(omegax*t) Y=Ay*np.cos(omegay*t-delta) plt.plot(X,Y) ``` ```python ti=0 tf=50 dt=0.1 t=np.arange(ti,tf,dt) r=5/6 delta=np.pi/2 omegax=r*omegay X=Ax*np.cos(omegax*t) Y=Ay*np.cos(omegay*t-delta) plt.plot(X,Y) ``` ```python ti=0 tf=100 dt=0.1 t=np.arange(ti,tf,dt) r=19/15 delta=np.pi/2 omegax=r*omegay X=Ax*np.cos(omegax*t) Y=Ay*np.cos(omegay*t-delta) plt.plot(X,Y) ``` ```python ti=0 tf=1000 dt=0.1 t=np.arange(ti,tf,dt) r=np.sqrt(2) delta=0 omegax=r*omegay X=Ax*np.cos(omegax*t) Y=Ay*np.cos(omegay*t-delta) plt.plot(X,Y) ``` # Q4.) What are some observations you make as you play with the variables? What happens for non-rational $\omega_x/\omega_y$ if you let the oscillator run for a long time? &#9989; Double click this cell, erase its content, and put your answer to the above question here. ####### Possible answers ####### For rational $\omega_x/\omega_y = n/m$ the curve closes. In general, the larger $n$ and $m$ (with no common factors) the longer it takes the curve to close. For non-rational $\omega_x/\omega_y$, the curve essentially fills in the entire rectangle if you let it run to long enough time. ####### Possible answers ####### # Notebook Wrap-up. Run the cell below and copy-paste your answers into their corresponding cells. ```python from IPython.display import HTML HTML( """ """ ) ``` # Well that's that, another Notebook! It's now been 10 weeks of class You've been given lots of computational and programing tools these past few months. These past two weeks have been practicing these tools and hopefully you are understanding how some of these pieces add up. Play around with the code and see how it affects our systems of equations. Solve the Schrodinger Equation for the Helium atom. Figure out the unifying theory. The future is limitless!

a73a1c51df951f48c17577fb37b8e487ad74b29b

ipynb

Jupyter Notebook

doc/AdminBackground/PHY321/CM_Jupyter_Notebooks/Answers/CM_Notebook9_Answers.ipynb

Shield94/Physics321

9875a3bf840b0fa164b865a3cb13073aff9094ca

2020-01-09T17:41:16.000Z

2022-03-09T00:48:58.000Z

doc/AdminBackground/PHY321/CM_Jupyter_Notebooks/Answers/CM_Notebook9_Answers.ipynb

Shield94/Physics321

9875a3bf840b0fa164b865a3cb13073aff9094ca

2020-01-08T03:47:53.000Z

2020-12-15T15:02:57.000Z

doc/AdminBackground/PHY321/CM_Jupyter_Notebooks/Answers/CM_Notebook9_Answers.ipynb

Shield94/Physics321

9875a3bf840b0fa164b865a3cb13073aff9094ca

2020-01-10T20:40:55.000Z

2022-02-11T20:28:41.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

We are answering questions in <cite data-cite="bibtex_lane2019online">(Lane, 2019)</cite> The first question we answer is on how to find the smallest absolute difference for the set of numbers $S=\left\{2,3,4,9,16\right\}$ ```python s=[2,3,4,9,16] result=[] for i in range(10,1,-1): sum=0 for j in s: sum += abs(j-i) result.append((i,sum)) result.sort(key=lambda x: x[1]) print("The number that gives the smallest absolute difference is %d. The sum of absolute differences is %d." % (result[0][0],result[0][1])) ``` The number that gives the smallest absolute difference is 4. The sum of absolute differences is 20. We can generalize the logic in the cell above into a that operates on a list of numbers. Let us make the convention that we enumerate the elements $s_j \in S$ starting with $0$, so if $S$ has three elements then $S=\left\{s_0,s_1,s_2\right\}.$ We know the number we should need to subtract from the elements of $s_j \in S$ should be \begin{equation} \underset{i} {\mathrm{argmin}} \sum_{j=0}^{\left|S\right|-1} \left|s_j-i\right|. \label{equ:argmin-1} \end{equation} We do not claim this range to search is optimal, but we show that we can choose a range that is guaranteed to find the value of $i$ that minimizes the expression above. Let $s_{\text{max}}=\text{max}\left(S\right)$ be the largest element in $S$, and let $s_{\text{min}}=\text{min}\left(S\right)$ be the smallest element in $S$. Then the value of $i$ that satisfies equation \ref{equ:argmin-1} is in the closed interval $\left[ s_{\text{min}}, s_{\text{max}} \right].$ To see why this is so, if we use any number $k$ less than the smallest element $s_{\text{min}}$ or greater than the largest element $s_{\text{max}}$ then we are adding at least $\left|s_{\text{min}}-k\right|$ or $\left|s_{\text{max}}-k\right|$ unnecessarily to every term in the sum. ```python def find_min_abs_diff_val(s): """ returns the integer that when subtracted from every element of s gives the smallest sum of the absolute values of all the differences. for clarification see the section titled, "Smallest Absolute Deviation," in http://onlinestatbook.com/2/summarizing_distributions/what_is_ct.html """ s.sort() s_min=s[0] s_max=s[len(s)-1] result=[] for i in range(s_min, s_max, 1): sum=0 for j in s: sum += abs(j-i) result.append((i,sum)) result.sort(key=lambda x: x[1]) return result[0][0] print(find_min_abs_diff(s)) ``` 4

078fd1a35bbc73b87465f579d1fd9f2d3a1d32e2

ipynb

Jupyter Notebook

ch-3/smallest-absolute-difference.ipynb

jhancock1975/online-status-book-exercises

70059beffc7f8b2ce84a4bb5c6bcbaf8eda339fa

ch-3/smallest-absolute-difference.ipynb

jhancock1975/online-status-book-exercises

70059beffc7f8b2ce84a4bb5c6bcbaf8eda339fa

ch-3/smallest-absolute-difference.ipynb

jhancock1975/online-status-book-exercises

70059beffc7f8b2ce84a4bb5c6bcbaf8eda339fa

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Monte Carlo Markov Chain ## Christina Lee ## Category: Numerics ### Monte Carlo Physics Series * [Monte Carlo: Calculation of Pi](../Numerics_Prog/Monte-Carlo-Pi.ipynb) * [Monte Carlo Markov Chain](../Numerics_Prog/Monte-Carlo-Markov-Chain.ipynb) * [Monte Carlo Ferromagnet](../Prerequisites/Monte-Carlo-Ferromagnet.ipynb) * [Phase Transitions](../Prerequisites/Phase-Transitions.ipynb) ### Intro If you didn't check it out already, take a look at the post that introduces using random numbers in calculations. Any such simulation is a <i>Monte Carlo</i> simulation. The most used kind of Monte Carlo simulation is a <i>Markov Chain</i>, also known as a random walk, or drunkard's walk. A Markov Chain is a series of steps where * each new state is chosen probabilistically * the probabilities only depend on the current state (no memory) Imagine a drunkard trying to walk. At any one point, they could progress either left or right rather randomly. Also, just because they had been traveling in a straight line so far does not guarantee they will continue to do. They've just had extremely good luck. We use Markov Chains to <b>approximate probability distributions</b>. To create a good Markov Chain, we need * <b> Ergodicity</b>: All states can be reached * <b> Global Balance</b>: A condition that ensures the proper equilibrium distribution ### The Balances Let $\pi_i$ be the probability that a particle is at site $i$, and $p_{ij}$ be the probability that a particle moves from $i$ to $j$. Then Global Balance can be written as, \begin{equation} \sum\limits_j \pi_i p_{i j} = \sum\limits_j \pi_j p_{j i} \;\;\;\;\; \forall i. \end{equation} In non-equation terms, this says the amount of "chain" leaving site $i$ is the same as the amount of "chain" entering site $i$ for every site in equilibrium. There is no flow. Usually though, we actually want to work with a stricter rule than Global Balance, <b> Detailed Balance </b>, written as \begin{equation} \pi_i p_{i j} = \pi_j p_{j i}. \end{equation} Detailed Balance further constricts the transition probabilities we can assign and makes it easier to design an algorithm. Almost all MCMC algorithms out there use detailed balance, and only lately have certain applied mathematicians begun looking at breaking detailed balance to increase efficiency in certain classes of problems. ### Today's Test Problem I will let you know now; this might be one of the most powerful numerical methods you could ever learn. I was going to put down a list of applications, but the only limit to such a list is your imagination. Today though, we will not be trying to predict stock market crashes, calculate the PageRank of a webpage, or calculate the entropy a quantum spin liquid at zero temperature. We just want to calculate an uniform probability distribution, and look at how Monte Carlo Markov Chains behave. * We will start with an $l\times l$ grid * Our chain starts somewhere in that grid * We can then move up, down, left or right equally * If we hit an edge, we come out the opposite side <i>(toroidal boundary conditions)</i> <b>First question!</b> Is this ergodic? Yes! Nothing stops us from reaching any location. <b>Second question!</b> Does this obey detailed balance? Yes! In equilibrium, each block has a probability of $\pi_i = \frac{1}{l^2}$, and can travel to any of its 4 neighbors with probability of $p_{ij} = \frac{1}{4}$. For any two neighbors \begin{equation} \frac{1}{l^2}\frac{1}{4} = \frac{1}{l^2}\frac{1}{4}, \end{equation} and if they are not neighbors, \begin{equation} 0 = 0. \end{equation} ```julia using Statistics using Plots gr() ``` Plots.GRBackend() ```julia # This is just the equivalent of `mod` # for using in an array that indexes from 1. function armod(i,j) return (mod(i-1+j,j)+1) end ``` armod (generic function with 1 method) ```julia # input the size of the grid l=5; n=l^2; ``` ```julia function Transition(i) #randomly chose up, down, left or right d=rand(1:4); if d==1 #if down return armod(i-l,n); elseif d==2 #if left row=convert(Int,floor((i-1)/l)); return armod(i-1,l)+l*row; elseif d==3 #if right row=convert(Int,floor((i-1)/l)); return armod(i+1,l)+l*row; else # otherwise up return armod(i+l,n); end end ``` Transition (generic function with 1 method) ```julia # The centers of blocks. # Will be using for pictoral purposes pos=zeros(Float64,2,n); pos[1,:]=[floor((i-1)/l) for i in 1:n].+0.5; pos[2,:]=[mod(i-1,l) for i in 1:n].+0.5; ``` ```julia # How many timesteps tn=2000; # Array of timesteps ti=Array{Int64,1}() # Array of errors err=Array{Float64,1}() # Stores current location, initialized randomly current=rand(1:n); # Stores last location, used for pictoral purposes last=current; #Keeps track of where chain went Naccumulated=zeros(Int64,l,l); # put in our first point # can index 2d array as 1d Naccumulated[current]+=1; ``` ```julia for ii in 1:tn last=current; # Determine the new point current=Transition(current); Naccumulated[current]+=1; # add new time steps and error points push!(ti,ii) push!(err,std(Naccumulated/ii)) end ``` When I was using an old version and pyplot I created this video of the state at each time point. https://www.youtube.com/watch?v=gxX3Fu1uuCs ```julia heatmap(Naccumulated/tn .- 1/l^2) ``` ```julia scatter(ti,log10.(err), markerstrokewidth=0) plot!(xlabel="Step" ,ylabel="Log10 std" ,title="Error for a $l x$l") ``` So, after running the above code and trying to figure out how it works (mostly plotting stuff), go back and study some properties of the system. * How long does it take to forget it's initial position? * How does the behaviour change with system size? * How long would you have to go to get a certain accuracy? (especially if you didn't know what distribution you where looking for) So hopefully you enjoyed this tiny introduction to an incredibly rich subject. Feel free to explore all the nooks and crannies to really understand the basics of this kind of simulation, so you can gain more control over the more complex simulations. Monte Carlo simulations are as much of an art as a science. You need to live them, love them, and breathe them till you find out exactly why they are behaving like little kittens that can finally jump on top of your countertops, or open your bedroom door at 1am. For all their misbehaving, you love the kittens anyway. @ARTICLE{1970Bimka..57...97H, title = "{Monte Carlo Sampling Methods using Markov Chains and their Applications}", journal = {Biometrika, Vol.~57, No.~1, p.~97-109, 1970}, year = 1970, month = apr, volume = 57, pages = {97-109}, doi = {10.1093/biomet/57.1.97}, adsurl = {http://adsabs.harvard.edu/abs/1970Bimka..57...97H}, adsnote = {Provided by the SAO/NASA Astrophysics Data System} } ```julia ```

20df515a7c6d9b11f21021158d72eb3a8bda002a

ipynb

Jupyter Notebook

Numerics_Prog/Monte-Carlo-Markov-Chain.ipynb

albi3ro/M4

ccd27d4b8b24861e22fe806ebaecef70915081a8

2015-11-15T08:47:04.000Z

2022-02-25T10:47:12.000Z

Numerics_Prog/Monte-Carlo-Markov-Chain.ipynb

albi3ro/M4

ccd27d4b8b24861e22fe806ebaecef70915081a8

2016-02-23T12:18:26.000Z

2019-09-14T07:14:26.000Z

Numerics_Prog/Monte-Carlo-Markov-Chain.ipynb

albi3ro/M4

ccd27d4b8b24861e22fe806ebaecef70915081a8

2016-02-24T03:08:22.000Z

2022-03-10T18:57:19.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```julia ] activate . ``` [Vandermonde matrix:](https://en.wikipedia.org/wiki/Vandermonde_matrix) \begin{align}V=\begin{bmatrix}1&\alpha _{1}&\alpha _{1}^{2}&\dots &\alpha _{1}^{n-1}\\1&\alpha _{2}&\alpha _{2}^{2}&\dots &\alpha _{2}^{n-1}\\1&\alpha _{3}&\alpha _{3}^{2}&\dots &\alpha _{3}^{n-1}\\\vdots &\vdots &\vdots &\ddots &\vdots \\1&\alpha _{m}&\alpha _{m}^{2}&\dots &\alpha _{m}^{n-1}\end{bmatrix}\end{align} ```julia using PyCall ``` ```julia np = pyimport("numpy") ``` PyObject <module 'numpy' from 'C:\\Users\\carsten\\Anaconda3\\lib\\site-packages\\numpy\\__init__.py'> ```julia np.vander(1:5, increasing=true) ``` 5×5 Array{Int32,2}: 1 1 1 1 1 1 2 4 8 16 1 3 9 27 81 1 4 16 64 256 1 5 25 125 625 The source code for this function is [here](https://github.com/numpy/numpy/blob/v1.16.1/numpy/lib/twodim_base.py#L475-L563). It calls `np.multiply.accumulate` which is implemented in C [here](https://github.com/numpy/numpy/blob/deea4983aedfa96905bbaee64e3d1de84144303f/numpy/core/src/umath/ufunc_object.c#L3678). However, this code doesn't actually perform the computation, it basically only checks types and stuff. The actual kernel that gets called is [here](https://github.com/numpy/numpy/blob/deea4983aedfa96905bbaee64e3d1de84144303f/numpy/core/src/umath/loops.c.src#L1742). This isn't even C code but a template for C code which is used to generate type specific kernels. Overall, this setup only supports a limited set of types, like `Float64`, `Float32`, and so forth. Here is a simple Julia implementation (taken from [Steve's Julia intro](https://web.mit.edu/18.06/www/Fall17/1806/julia/Julia-intro.pdf)) ```julia function vander(x::AbstractVector{T}, n=length(x)) where T m = length(x) V = Matrix{T}(undef, m, n) for j = 1:m V[j,1] = one(x[j]) end for i= 2:n for j = 1:m V[j,i] = x[j] * V[j,i-1] end end return V end ``` vander (generic function with 2 methods) ```julia vander(1:5) ``` 5×5 Array{Int64,2}: 1 1 1 1 1 1 2 4 8 16 1 3 9 27 81 1 4 16 64 256 1 5 25 125 625 # A quick benchmark ```julia using BenchmarkTools, Plots ``` ```julia ns = exp10.(range(1, 4, length=30)); ``` ```julia tnp = Float64[] tjl = Float64[] for n in ns x = 1:n |> collect push!(tnp, @belapsed np.vander($x) samples=3 evals=1) push!(tjl, @belapsed vander($x) samples=3 evals=1) end ``` ```julia plot(ns, tnp./tjl, m=:circle, xscale=:log10, xlab="matrix size", ylab="NumPy time / Julia time", legend=:false) ``` ```julia savefig("vandermonde.pdf") savefig("vandermonde.svg") savefig("vandermonde.png") ``` Note that the clean and concise Julia implementation is beating the numpy implementation for small and is on-par for large matrix sizes! At the same time, the Julia code is generic and works for arbitrary types! ```julia vander(Int32[4, 8, 16, 32]) ``` 4×4 Array{Int32,2}: 1 4 16 64 1 8 64 512 1 16 256 4096 1 32 1024 32768 ```julia vander(["this", "is", "a", "test"]) ``` 4×4 Array{String,2}: "" "this" "thisthis" "thisthisthis" "" "is" "isis" "isisis" "" "a" "aa" "aaa" "" "test" "testtest" "testtesttest" ```julia vander([true, false, false, true]) ``` 4×4 Array{Bool,2}: true true true true true false false false true false false false true true true true ```julia ```

f914ce46e8f7b810739c0e8b28f512dca498c2a1

ipynb

Jupyter Notebook

playground/vandermonde/vandermonde.ipynb

crstnbr/JuliaWorkshop19

17a19bd100fcaf1c20b577af7af943061b8a157c

2019-07-26T20:02:31.000Z

2021-08-06T08:12:15.000Z

playground/vandermonde/vandermonde.ipynb

mattborghi/JuliaWorkshop19

ae4fc28e52e8fc0fd9abdf6359a72b0bb5fe61f3

2019-07-25T14:24:54.000Z

2019-10-25T17:37:37.000Z

playground/vandermonde/vandermonde.ipynb

mattborghi/JuliaWorkshop19

ae4fc28e52e8fc0fd9abdf6359a72b0bb5fe61f3

2019-08-09T18:26:12.000Z

2021-08-08T00:05:50.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Physics 256 ## Physics of Baseball ```python import style style._set_css_style('../include/bootstrap.css') ``` ## Last Time ### [Notebook Link: 14_ProjectileMotion.ipynb](./14_ProjectileMotion.ipynb) - projectile motion for a cannon shell with air resistance - building a simple targetting algorithm ## Today - 3D motion of a pitched baseball ## Setting up the Notebook ```python import matplotlib.pyplot as plt import numpy as np %matplotlib inline plt.style.use('../include/notebook.mplstyle'); %config InlineBackend.figure_format = 'svg' ``` ## Converting Units ```python import scipy.constants as constants def convert(value,unit1,unit2): '''Convert value in unit1 to unit2''' # the converter conv = {'ft->m':constants.foot,'in->m':constants.inch,'mph->m/s':constants.mph} # make a copy and perform reverse conversions cpy_conv = dict(conv) for key, val in cpy_conv.items(): units = key.split('->') conv[units[-1]+'->'+units[0]] = 1.0/val # perform the conversion key = '%s->%s'%(unit1,unit2) if key in conv: return value*conv[key] else: print('Unit conversion %s not possible.' %key) ``` ## Drag Coefficient of a Baseball The empirical form (from wind-tunnel and simulation measurements) is given by: \begin{equation} \frac{C\rho A}{m} \equiv \frac{B_2}{m} = 0.0039 + \frac{0.0058}{1+\exp{[(v-v_d)/\Delta}]} \end{equation} where $v_c \simeq 35~{\rm m/s}$ and $\Delta \simeq 5~{\rm m/s}$. ```python def B2om(v): '''The drag Coefficient of a baseball. v in m/s ''' vd = 35.0 # m/s Δ = 5.0 # m/s return 0.0039 + 0.0058/(1.0 + np.exp((v-vd)/Δ)) ``` ```python v = np.linspace(0,200,1000) plt.plot(v,B2om(convert(v,'mph','m/s'))*convert(1.0,'m','ft')) plt.xlabel('Ball Speed [mph]') plt.ylabel('Drag Coefficient [1/ft]') ``` ## Equation of Motion for a Spinning Baseball Taking our coordinate system origin at the pitching rubber with $x$ pointing towards home plate, $y$ pointing up and $z$ towards third base, the total force on a spinning ball is given by: \begin{equation} \vec{F} = \vec{F}_{\rm g} + \vec{F}_{\rm drag} + \vec{F}_{\rm magnus}. \end{equation} where the Magnus force is: \begin{equation} \vec{F}_{\rm magnus} = S_0 \vec{\omega} \times \vec{v} \end{equation} with the direction of $\vec{\omega}$ determined by the right-hand-rule and $S_0$ is related to the solid angular average of the drage coefficient $C$. This can be decomposed into the following 3D equation of motion: \begin{align} \frac{d v_x}{dt} &= -\frac{B_2}{m} v v_x \\ \frac{d v_y}{dt} &= -g \\ \frac{d v_z}{dt} &= - \frac{S_0}{m} \omega v_x \end{align} which can be iterated using the Euler method to find the trajectory of the ball. ```python from scipy.constants import g,pi π = pi # the time step Δt = 0.001 # s # the dimensionless angular drag factor S0om = 4.1E-4 # the angular velocity ω = 1900 * 2*π / 60 # rad/s # initial conditions (convert everything to SI) vx,vy,vz = convert(100,'mph','m/s'),0.0,0.0 r = [[0.0,convert(6.0+10.0/12.0,'ft','m'),0.0]] print(r[-1][0]) while r[-1][0] <= convert(60.5,'ft','m'): v = np.sqrt(vx**2 + vy**2 + vz**2) vx -= B2om(v)*v*vx*Δt vy -= g*Δt vz -= S0om*vx*ω*Δt r.append([r[-1][0]+vx*Δt,r[-1][1]+vy*Δt,r[-1][2]+vz*Δt]) # convert the result to feet r = np.array(r) r = convert(r,'m','ft') # Plot the resulting trajectory fig, ax = plt.subplots(2, sharex=True) fig.subplots_adjust(hspace=0.1) # the x-y plane ax[0].plot(r[:,0],r[:,1]) ax[0].set_ylabel('y [ft]') # the y-z plane ax[1].plot(r[:,0],r[:,2]) ax[1].set_ylabel('z [ft]') ax[1].set_xlabel('x [ft]') ax[1].set_xlim(0,60.5); ``` ### Looking in 3D ```python import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D fig = plt.figure(figsize=(15,6)) ax = fig.add_subplot(111, projection='3d') ax.plot(r[:,0], r[:,2], r[:,1], linewidth=3) ax.dist = 12 ax.set_xlabel('x [ft]') ax.set_ylabel('z [ft]') ax.set_zlabel('y [ft]') ax.set_zlim3d(0,7) ax.set_xlim3d(0,60.5) ax.xaxis.labelpad=30 ax.yaxis.labelpad=30 ax.zaxis.labelpad=15 #ax.view_init(0, -90) ``` ## The Knuckleball ```python def Fknuck(θ): '''The lateral acceleration on a knucleball in m/s^2''' from scipy.constants import g Fom = 0.5*g*(np.sin(4.0*θ) - 0.25*np.sin(8.0*θ) + \ 0.08*np.sin(12.0*θ) - 0.025*np.sin(16.0*θ)) return Fom ``` ```python θ = np.linspace(0,2*π,1000) plt.plot(θ,Fknuck(θ)) plt.xlim(0,2*π); plt.xlabel('θ [rad]') plt.ylabel(r'$F/m\ [{\rm m/s^2}]$') ``` ```python ```

a7c709182b98d0b83313b58f02203a2a9aa96f4a

ipynb

Jupyter Notebook

4-assets/BOOKS/Jupyter-Notebooks/Overflow/15_Baseball.ipynb

impastasyndrome/Lambda-Resource-Static-Assets

7070672038620d29844991250f2476d0f1a60b0a

4-assets/BOOKS/Jupyter-Notebooks/Overflow/15_Baseball.ipynb

impastasyndrome/Lambda-Resource-Static-Assets

7070672038620d29844991250f2476d0f1a60b0a

4-assets/BOOKS/Jupyter-Notebooks/Overflow/15_Baseball.ipynb

impastasyndrome/Lambda-Resource-Static-Assets

7070672038620d29844991250f2476d0f1a60b0a

2021-11-05T07:48:26.000Z

2021-11-05T07:48:26.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Casing design affects frac geometry and economics _Ohm Devani_ NOTE: This project will focus on relative economic uplift between 2 casing designs in similar geology. ## Contents 1. Model inputs 2. Base case - define per-frac endpoints (min rate defined by dfit initiation rate, max rate defined by hhp of fleet, water volume/frac) - economic constants (pump charge, water cost 3. Economic sensitivities 1. Frac surface area (PKN) vs rate; 2 series for different casing sizes - \$ cost/surface area vs rate vs (y-axis 2) surface area - Talk about impact of other variables: stress shadow, additional height growth in absence of frac barriers, better proppant/fluid distribution between clusters 2. Frac pump time vs rate vs $ cost/stage (y2) ### Model parameters 0.7 psi/ft frac gradient 1.0 connate water SG Horizontal well Midpoint lateral TVD 10,000 ft Scenario A: 7" 32# T-95 intermediate casing to 9000 ft (6.094" ID) 4 1/2" 11.6# P-110 liner to 20000 ft (4" ID) Scenario B: 5 1/2" 17# P-110 casing to 20000 ft (4.892" ID) 60 bbl/ft ignore proppant 7000 psi target surface pressure 2000 psi target NWB friction ### Pipe friction estimates Hazen-Williams for pipe friction SPE 146674 correlation and adjustment for friction reduction ```python def hwfriclosspsi(cfactor,ratebpm,pipeidinch,lengthft): hyddiam = 4*(3.14159*(pipeidinch/2)**2)/(2*3.14169*pipeidinch/2) hwfriclosspsi = 0.2083*((100/cfactor)**1.852)*((ratebpm*42)**1.852)/(hyddiam**4.8655)*.433*lengthft/100 return hwfriclosspsi def freduction(pipeidinch,ratebpm): velocftpersec = (5.615*144/60)*ratebpm/(3.14159*(pipeidinch/2)**2) fr = 6.2126*velocftpersec**0.5858 if fr<25: fr=25 elif fr>85: fr=85 return fr ``` ```python import pandas as pd import matplotlib.pyplot as plt import matplotlib.ticker as mtick bpmrange=list(range(0, 150)) adjfac=0.1 #sceAfric = [hwfriclosspsi(120,i,6.094,9000)*(1-freduction(6.094,i)/100)*adjfac+hwfriclosspsi(120,i,4,11000)*(1-freduction(4,i)/100)*adjfac for i in bpmrange] #sceBfric = [hwfriclosspsi(120,i,4.892,20000)*(1-freduction(4.892,i)/100)*adjfac for i in bpmrange] sceAfric = [hwfriclosspsi(120,i,6.094,9000)*adjfac+hwfriclosspsi(120,i,4,11000)*adjfac for i in bpmrange] sceBfric = [hwfriclosspsi(120,i,4.892,20000)*adjfac for i in bpmrange] ``` ### BHTP & Net Fracture Pressure Ozesen, Ahsen. ANALYSIS OF INSTANTANEOUS SHUT-IN PRESSURE IN SHALE OIL AND GAS RESERVOIRS. 2017. Penn State U, Masters Thesis. https://etda.libraries.psu.edu/files/final_submissions/15314. ```python surfpress=7000 tvd=10000 nwbfriction=1000 fracgradient=0.70 def nfp(bhtp,nwbfric,fracgrad,tvd): nfp = bhtp-nwbfric-fracgrad*tvd return nfp bhtpA = [surfpress-i+0.433*tvd for i in sceAfric] bhtpB = [surfpress-i+0.433*tvd for i in sceBfric] nfpA = [nfp(i,nwbfriction,fracgradient,tvd) for i in bhtpA] nfpB = [nfp(i,nwbfriction,fracgradient,tvd) for i in bhtpB] plt.plot(bpmrange, bhtpA, label = "4 1/2\" liner", linestyle="-.") plt.plot(bpmrange, bhtpB, label = "5 1/2\" casing", linestyle=":") plt.ylim(bottom=0) plt.grid(color='k', linestyle='-', linewidth=0.25) plt.xlabel('Pumping Rate [bpm]') plt.ylabel('BHP [psi]') plt.legend() plt.show() plt.plot(bpmrange, nfpA, label = "4 1/2\" liner", linestyle="-.") plt.plot(bpmrange, nfpB, label = "5 1/2\" casing", linestyle=":") plt.ylim(bottom=0) plt.grid(color='k', linestyle='-', linewidth=0.25) plt.xlabel('Pumping Rate [bpm]') plt.ylabel('Pressure available to fracture [psi]') plt.legend() plt.show() #print(nfpA) #print(nfpB) #print(nfpA.index(57.58718507850335)) #print(nfpB.index(21.654318992093977)) ``` Under these constraints, the 5 1/2" casing designs supports a maximum pump rate of 107 bpm, which is 25 bpm higher than the 4 1/2" liner design's max pump rate of 82 bpm. Below, I calculate the time and cost savings from this added rate over a range of pumped volumes. HHP (hp) = Surface Treating Pressure (psi) x Rate (bpm) / 40.8 Indicative pricing estimates for a 45,000 hhp frac spread, and typical pricing are $6-8,000/hr. Plot below shows a typical frac spread will have more HHP than is required at even the highest rate. https://www.danielep.com/news-observations/3-14-21-dep-industry-observations-frac-engine-supply-frac-newbuilds-sand-thoughts-and-q4-earnings/ https://markets.businessinsider.com/news/stocks/fracking-fluid-end-market-size-to-reach-us-678-million-in-2025-says-stratview-research-1029144444 ```python def hhp(stp,rate): hhp=stp*rate/40.8 return hhp plt.plot(bpmrange, [hhp(surfpress,i) for i in bpmrange], label = "Required HHP") plt.ylim(bottom=0, top=50000) plt.axhline(y=45000, color='r', linestyle='--', label = "Available HHP") plt.grid(color='k', linestyle='-', linewidth=0.25) plt.xlabel('Pumping Rate [bpm]') plt.ylabel('HHP required') plt.legend() plt.show() ``` For simplicity, I'm only considering the hourly pumping cost and neglecting other costs like diesel. The plot below shows pumping cost vs total volume for the two casing designs pumping at max rates which retain a few hundred psi of net frac pressure (80 vs 105). ```python volumerange=list(range(400, 800)) pumpcost=8000 #$8000/hr amaxrate=80 bmaxrate=105 acost=[pumpcost*1000*i/(amaxrate*60) for i in volumerange] bcost=[pumpcost*1000*i/(bmaxrate*60) for i in volumerange] fig, ax = plt.subplots() ax.plot(volumerange,acost, label = "4 1/2\" liner", linestyle="-.") ax.plot(volumerange,bcost, label = "5 1/2\" casing", linestyle=":") ax.plot(volumerange, [a_i - b_i for a_i, b_i in zip(acost, bcost)], label = "Cost Savings", linestyle="-.", color='g') plt.ylim(bottom=0) ax.grid(color='k', linestyle='-', linewidth=0.25) plt.xlabel('Total Volume [MBBL]') plt.ylabel('Pumping Cost [$]') fmt = '${x:,.0f}' tick = mtick.StrMethodFormatter(fmt) ax.yaxis.set_major_formatter(tick) plt.legend() plt.show() ``` ### Economic sensitivities 5 1/2" max rate is approx. 30% greater than 4 1/2" liner's max rate. Fracture surface area as a function of rate is a convolved problem requiring a simulator; I suppose a range of 0%-15% oil IP30 uplift for the range of 105-80bpm, respectively. Economic variables: - 75% NRI - $50 flat net oil price - Harmonic decline - 800 MBBL water pumped Production for 4 1/2" scenario: - 800 bopd IP (24.3 MBO/mo) - 800 MBO EUR over 30 years - Ignoring water, gas Production for 5 1/2" scenario: - Variable IP - 800 MBO EUR over 30 years - Ignoring water, gas ```python import numpy as np #from sympy.solvers import solve #from sympy import Symbol from sympy import log #def solvedi(np,qi,t): # di = Symbol('di',real=True) # solvedi=solve(np/log(qi/(qi/(1+di*t)))-(qi/di),di) # return solvedi #adeclinerate_monthly = solvedi(800000,36500,360) #print(N(adeclinerate_monthly[0])) #print(N(solvedi(1000000,30000,600))) ip=800 eur=800000 months=360 def brutedi(np,qi,t): calcerror=-1 di=0.01 while calcerror<0: calcerror=np-((qi/di)*log(qi/(qi/(1+di*t)))) if calcerror>0: break else: di=di+0.0001 #print(di) return di #adeclinerate_monthly = brutedi(800000,36500,360) ipuplift=np.linspace(0,0.15,num=16) col2=(ipuplift+1)*ip col3=np.zeros(col2.size) i=0 while i<col2.size: col3[i]=brutedi(eur,col2[i]*30.4,months) i+=1 #print(col2) #print(col3) ``` ```python def harmonictotal(qi,di,t): harmonictotal=((qi/di)*log(qi/(qi/(1+di*t)))) return harmonictotal def pv30yr(netoilprice,nri,ip,initd,discrate): cumarray=np.zeros(360) casharray=np.zeros(360) ipmonth=ip*30.4 discratemonth=discrate/12 j=0 while j<casharray.size: if j==0: cumarray[j]=harmonictotal(ipmonth,initd,1) casharray[j]=cumarray[j]*netoilprice*nri else: cumarray[j]=harmonictotal(ipmonth,initd,j+1) casharray[j]=(cumarray[j]-cumarray[j-1])*netoilprice*nri j+=1 #print(cumarray) #print(casharray) #print(cumarray[cumarray.size-1]) pv30yr=np.npv(discratemonth,casharray) return pv30yr ``` ```python netprice=50 netri=0.75 discountrate=0.10 totalpumpedvolume=800000 #print(pv30yr(netprice,netri,920,.137,0)) col4=np.zeros(col2.size) colincpv=np.zeros(col2.size) i=0 while i<col4.size: col4[i]=pv30yr(netprice,netri,col2[i],col3[i],discountrate) i+=1 i=0 while i<colincpv.size: colincpv[i]=col4[i]-col4[0] i+=1 #print(colincpv) ``` C:\Users\User\Anaconda3\lib\site-packages\ipykernel_launcher.py:22: DeprecationWarning: numpy.npv is deprecated and will be removed from NumPy 1.20. Use numpy_financial.npv instead (https://pypi.org/project/numpy-financial/). ```python pumpratearray=np.linspace(105,80,num=16) pumpsavings=np.zeros(pumpratearray.size) i=0 while i<pumpsavings.size: if pumpratearray[i] == amaxrate: pumpsavings[i]=0 else: pumpsavings[i]=pumpcost*(-(totalpumpedvolume/(pumpratearray[i]*60))+(totalpumpedvolume/(amaxrate*60))) i+=1 #print(pumpsavings) ``` [317460.31746032 301075.2688172 284153.00546448 266666.66666667 248587.57062147 229885.05747126 210526.31578947 190476.19047619 169696.96969697 148148.14814815 125786.16352201 102564.1025641 78431.37254902 53333.33333333 27210.88435374 0. ] ```python farray = np.column_stack((ipuplift, col2)) #ip bopd farray = np.column_stack((farray, col3)) #di farray = np.column_stack((farray, colincpv)) farray = np.column_stack((farray, pumpratearray)) finalarray = np.column_stack((farray, pumpsavings)) #print(finalarray[:,5]) finaldf = pd.DataFrame(finalarray, columns = ['IP_uplift','IP_BOPD','Di_monthly','Acceration_PV','Pump_Rate','Pump_Savings']) finaldf['Total_PV'] = finaldf['Acceration_PV'] + finaldf['Pump_Savings'] #print(finaldf) ``` ```python fig, ax = plt.subplots() ax.plot(finaldf['Pump_Rate'],finaldf['Total_PV'], label = "5 1/2\" casing", linestyle=":", color='g') plt.ylim(bottom=0, top=500000) ax.grid(color='k', linestyle='-', linewidth=0.25) plt.xlabel('Total Volume [MBBL]') plt.ylabel('Pumping Cost [$]') fmt = '${x:,.0f}' tick = mtick.StrMethodFormatter(fmt) ax.yaxis.set_major_formatter(tick) plt.legend() plt.show() ``` ```python ```

64339c3d399c4dd1cc39bf395ac8a57a3b76de17

ipynb

Jupyter Notebook

comp-cost.ipynb

energydevohm/completion-cost-study

d836390c4eb4f19781882feefd94e5ad79ec32af

comp-cost.ipynb

energydevohm/completion-cost-study

d836390c4eb4f19781882feefd94e5ad79ec32af

comp-cost.ipynb

energydevohm/completion-cost-study

d836390c4eb4f19781882feefd94e5ad79ec32af

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Sinais exponenciais Neste notebook avaliaremos os sinais exponenciais do tipo \begin{equation} x(t) = A \ \mathrm{e}^{a \ t} \end{equation} Estamos interessados em 3 casos: 1. $A \ \in \ \mathbb{R}$ e $a \ \in \ \mathbb{R}$ - As exponenciais reais. 2. $A \ \in \ \mathbb{C}$ e $a \ \in \ \mathbb{C}, \ \mathrm{Re}\left\{a\right\} = 0$ - As exponenciais complexas. 3. $A \ \in \ \mathbb{C}$ e $a \ \in \ \mathbb{C}, \ \mathrm{Re}\left\{a\right\} < 0$ ```python # importar as bibliotecas necessárias import numpy as np import matplotlib.pyplot as plt ``` ## 1. $A \ \in \ \mathbb{R}$ e $a \ \in \ \mathbb{R}$ - As exponenciais reais. ```python # Sinal t = np.linspace(-1, 5, 1000) # vetor temporal A = 1 a = -5 xt = A*np.exp(a*t) # Figura plt.figure() plt.title('Exponencial real') plt.plot(t, xt, '-b', linewidth = 2, label = 'Exp. Real') plt.legend(loc = 'best') plt.grid(linestyle = '--', which='both') plt.xlabel('Tempo [s]') plt.ylabel('Amplitude [-]') plt.tight_layout() plt.show() ``` ## 2. $A \ \in \ \mathbb{C}$ e $a \ \in \ \mathbb{C}, \ \mathrm{Re}\left\{a\right\} = 0$ - As exponenciais complexas. Temos grande interesse neste caso. Ele está relacionado ao sinal \begin{equation} x(t) = A \ \mathrm{cos}(2 \pi f t - \phi) = A \ \mathrm{cos}(\omega t - \phi). \end{equation} A relação de Euler nos diz que: \begin{equation} \mathrm{cos}(\omega t - \phi) = \mathrm{Re}\left\{\mathrm{e}^{\mathrm{j}(\omega t-\phi)} \right\} . \end{equation} Assim, o sinal $x(t)$ torna-se: \begin{equation} x(t) = A \ \mathrm{cos}(\omega t - \phi) = A\mathrm{Re}\left\{\mathrm{e}^{\mathrm{j}(\omega t-\phi)} \right\} = \mathrm{Re}\left\{A \mathrm{e}^{\mathrm{j}(\omega t-\phi)} \right\} \end{equation} \begin{equation} x(t) = \mathrm{Re}\left\{A\mathrm{e}^{-\mathrm{j}\phi} \ \mathrm{e}^{\mathrm{j}\omega t} \right\} \end{equation} em que $\tilde{A} = A\mathrm{e}^{-\mathrm{j}\phi}$ é a amplitude complexa do cosseno e contêm as informações de magnitude, $A$, e fase, $\phi$. ```python # Sinal t = np.linspace(-2, 2, 1000) # vetor temporal A = 1.5 phi = 0 A = A*np.exp(-1j*phi) f=1 w = 2*np.pi*f a = 1j*w xt = np.real(A*np.exp(a*t)) # Figura plt.figure() plt.title('Exponencial complexa') plt.plot(t, xt, '-b', linewidth = 2, label = 'Exp. complexa') plt.legend(loc = 'upper right') plt.grid(linestyle = '--', which='both') plt.xlabel('Tempo [s]') plt.ylabel('Amplitude [-]') plt.ylim((-2, 2)) plt.xlim((t[0], t[-1])) plt.tight_layout() plt.show() ``` 3. $A \ \in \ \mathbb{C}$ e $a \ \in \ \mathbb{C}, \ \mathrm{Re}\left\{a\right\} < 0$ Neste caso, se $a \ \in \ \mathbb{C}$ e $\mathrm{Re}\left\{a\right\} < 0$, teremos um sinal oscilatório, cuja amplitude decai com o tempo. É típico de um sistema massa-mola-amortecedor. ```python # Sinal t = np.linspace(0, 5, 1000) # vetor temporal A = 1.5 phi = 0.3 A = A*np.exp(-1j*phi) f=1 w = 2*np.pi*f a = -0.5+1j*w xt = np.real(A*np.exp(a*t)) # Figura plt.figure() plt.title('Exponencial complexa vom decaimento') plt.plot(t, xt, '-b', linewidth = 2, label = 'Exp. complexa com decaimento') plt.legend(loc = 'upper right') plt.grid(linestyle = '--', which='both') plt.xlabel('Tempo [s]') plt.ylabel('Amplitude [-]') plt.ylim((-2, 2)) plt.xlim((0, t[-1])) plt.tight_layout() plt.show() ``` ## Exponenciais complexas em sinais discretos Retomamos agora as exponenciais complexas e discretas. Lembramos que para um sinal contínuo, $x(t)=\mathrm{e}^{\mathrm{j} \omega t}$, a taxa de oscilação aumenta quando $\omega$ aumenta. Para sinais discretos do tipo \begin{equation} x[n] = \mathrm{e}^{\mathrm{j} \omega n} \end{equation} veremos um aumento da taxa de oscilação para $0 \leq \omega < \pi$ e uma diminuição da taxa de oscilação para $\pi \leq \omega \leq 2 \pi$. Isto se relacionará depois com a amostragem de sinais. Veremos que para amostrar um sinal corretamente (representar bem suas componentes de frequência), precisaremos usar uma taxa de amostragem que seja pelo menos o dobro da maior frequência contida no sinal a ser amostrado. ```python omega = [0, np.pi/8, np.pi/4, np.pi/2, np.pi, 3*np.pi/2, 7*np.pi/4, 15*np.pi/8, 2*np.pi]#np.linspace(0, 2*np.pi, 9) # Frequencias angulares n = np.arange(50) # amostras plt.figure(figsize=(15,10)) for jw,w in enumerate(omega): xn = np.real(np.exp(1j*w*n)) plt.subplot(3,3,jw+1) plt.stem(n, xn, '-b', label = r'$\omega$ = {:.3} [rad/s]'.format(float(w)), basefmt=" ", use_line_collection= True) plt.legend(loc = 'upper right') plt.grid(linestyle = '--', which='both') plt.xlabel('Amostra [-]') plt.ylabel('Amplitude [-]') plt.ylim((-1.5, 1.5)) plt.tight_layout() plt.show() ```

2403e82a16f5776c818907980d72a15399ede1da

ipynb

Jupyter Notebook

Aula 6 - Sinais exponenciais/sinais exponenciais.ipynb

RicardoGMSilveira/codes_proc_de_sinais

e6a44d6322f95be3ac288c6f1bc4f7cfeb481ac0

2020-10-01T20:59:33.000Z

2021-07-27T22:46:58.000Z

Aula 6 - Sinais exponenciais/sinais exponenciais.ipynb

RicardoGMSilveira/codes_proc_de_sinais

e6a44d6322f95be3ac288c6f1bc4f7cfeb481ac0

Aula 6 - Sinais exponenciais/sinais exponenciais.ipynb

RicardoGMSilveira/codes_proc_de_sinais

e6a44d6322f95be3ac288c6f1bc4f7cfeb481ac0

2020-10-15T12:08:22.000Z

2021-04-12T12:26:53.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__por_Latn

# Implementation details: deriving expected moment dynamics $$ \def\n{\mathbf{n}} \def\x{\mathbf{x}} \def\N{\mathbb{\mathbb{N}}} \def\X{\mathbb{X}} \def\NX{\mathbb{\N_0^\X}} \def\C{\mathcal{C}} \def\Jc{\mathcal{J}_c} \def\DM{\Delta M_{c,j}} \newcommand\diff{\mathop{}\!\mathrm{d}} \def\Xc{\mathbf{X}_c} \newcommand{\muset}[1]{\dot{\{}#1\dot{\}}} $$ This notebook walks through what happens inside `compute_moment_equations()`. We restate the algorithm outline, adding code snippets for each step. This should help to track down issues when, unavoidably, something fails inside `compute_moment_equations()`. ```python # initialize sympy printing (for latex output) from sympy import init_printing init_printing() # import functions and classes for compartment models from compartor import * from compartor.compartments import ito, decomposeMomentsPolynomial, getCompartments, getDeltaM, subsDeltaM, get_dfMdt_contrib ``` We only need one transition class. We use "coagulation" from the coagulation-fragmentation example ```python D = 1 # number of species x = Content('x') y = Content('y') transition_C = Transition(Compartment(x) + Compartment(y), Compartment(x + y), name = 'C') k_C = Constant('k_C') g_C = 1 Coagulation = TransitionClass(transition_C, k_C, g_C) transition_classes = [Coagulation] display_transition_classes(transition_classes) ``` $\displaystyle \begin{align} \left[x\right] + \left[y\right]&\overset{h_{C}}{\longrightarrow}\left[x + y\right] && h_{C} = \frac{k_{C} \left(n{\left(y \right)} - \delta_{x y}\right) n{\left(x \right)}}{\delta_{x y} + 1} \end{align}$ $$ \def\n{\mathbf{n}} \def\x{\mathbf{x}} \def\N{\mathbb{\mathbb{N}}} \def\X{\mathbb{X}} \def\NX{\mathbb{\N_0^\X}} \def\C{\mathcal{C}} \def\Jc{\mathcal{J}_c} \def\DM{\Delta M_{c,j}} \newcommand\diff{\mathop{}\!\mathrm{d}} \def\Xc{\mathbf{X}_c} \newcommand{\muset}[1]{\dot{\{}#1\dot{\}}} $$ For a compartment population $\n \in \NX$ evolving stochastically according to stoichiometric equations from transition classes $\C$, we want to find an expression for $$ \frac{\diff}{\diff t}\left< f(M^\gamma, M^{\gamma'}, \ldots) \right> $$ in terms of expectations of population moments $M^\alpha, M^{\beta}, \ldots$ ```python fM = Moment(0)**2 display(fM) ``` ### (1) From the definition of the compartment dynamics, we have $$ \diff M^\gamma = \sum_{c \in \C} \sum_{j \in \Jc} \DM^\gamma \diff R_{c,j} $$ We apply Ito's rule to derive $$ \diff f(M^\gamma, M^{\gamma'}, \ldots) = \sum_{c \in \C} \sum_{j \in \Jc} \left( f(M^\gamma + \DM^\gamma, M^{\gamma'} + \DM^{\gamma'}, \ldots) - f(M^\gamma, M^{\gamma'}, \ldots) \right) \diff R_{c,j} $$ Assume, that $f(M^\gamma, M^{\gamma'}, \ldots)$ is a polynomial in $M^{\gamma^i}$ with $\gamma^i \in \N_0^D$. Then $\diff f(M^\gamma, M^{\gamma'}, \ldots)$ is a polynomial in $M^{\gamma^k}, \DM^{\gamma^l}$ with $\gamma^k, \gamma^l \in \N_0^D$, that is, $$ \diff f(M^\gamma, M^{\gamma'}, \ldots) = \sum_{c \in \C} \sum_{j \in \Jc} \sum_{q=1}^{n_q} Q_q(M^{\gamma^k}, \DM^{\gamma^l}) \diff R_{c,j} $$ where $Q_q(M^{\gamma^k}, \DM^{\gamma^l})$ are monomials in $M^{\gamma^k}, \DM^{\gamma^l}$. ```python dfM = ito(fM) dfM ``` ### (2) Let's write $Q_q(M^{\gamma^k}, \DM^{\gamma^l})$ as $$ Q_q(M^{\gamma^k}, \DM^{\gamma^l}) = k_q \cdot \Pi M^{\gamma^k} \cdot \Pi M^{\gamma^k} $$ where $k_q$ is a constant, $\Pi M^{\gamma^k}$ is a product of powers of $M^{\gamma^k}$, and $\Pi \DM^{\gamma^l}$ is a product of powers of $\DM^{\gamma^l}$. Analogous to the derivation in SI Appendix S.3, we arrive at the expected moment dynamics $$ \frac{\diff\left< f(M^\gamma, M^{\gamma'}, \ldots) \right>}{\diff t} = \sum_{c \in \C} \sum_{q=1}^{n_q} \left< \sum_{j \in \Jc} k_q \cdot \Pi M^{\gamma^k} \cdot \Pi \DM^{\gamma^k} \cdot h_{c,j}(\n) \right> $$ ```python monomials = decomposeMomentsPolynomial(dfM) monomials ``` ### (3) Analogous to SI Appendix S.4, the contribution of class $c$, monomial $q$ to the expected dynamics of $f(M^\gamma, M^{\gamma'}, \ldots)$ is $$ \begin{align} \frac{\diff\left< f(M^\gamma, M^{\gamma'}, \ldots) \right>}{\diff t} &= \left< {\large\sum_{j \in \Jc}} k_q \cdot \Pi M^{\gamma^k} \cdot \Pi \DM^{\gamma^l} \cdot h_{c,j}(\n) \right> \\ &= \left< {\large\sum_{\Xc}} w(\n; \Xc) \cdot k_c \cdot k_q \cdot \Pi M^{\gamma^k} \cdot g_c(\Xc) \cdot \left< \Pi \DM^{\gamma^l} \;\big|\; \Xc \right> \right> \end{align} $$ ```python c = 0 # take the first transition class q = 1 # ... and the second monomial tc = transition_classes[c] transition, k_c, g_c, pi_c = tc.transition, tc.k, tc.g, tc.pi (k_q, pM, pDM) = monomials[q] ``` First we compute the expression $$ l(\n; \Xc) = k_c \cdot k_q \cdot \Pi(M^{\gamma^k}) \cdot g_c(\Xc) \cdot \left< \Pi \DM^{\gamma^l} \;\big|\; \Xc \right> $$ We start by computing the $\DM^{\gamma^l}$ from reactants and products of the transition ... ```python reactants = getCompartments(transition.lhs) products = getCompartments(transition.rhs) DM_cj = getDeltaM(reactants, products, D) DM_cj ``` ... and then substituting this expression into every occurence of $\DM^\gamma$ in `pDM` (with the $\gamma$ in `DM_cj` set appropriately). ```python pDMcj = subsDeltaM(pDM, DM_cj) print('pDM = ') display(pDM) print('pDMcj = ') display(pDMcj) ``` Then we compute the conditional expectation of the result. ```python cexp = pi_c.conditional_expectation(pDMcj) cexp ``` Finally we multiply the conditional expectation with the rest of the terms: * $k_c$, and $g_c(\Xc)$ from the specification of `transition[c]`, and * $k_q$, and $\Pi(M^{\gamma^k})$ from `monomials[q]`. ```python l_n_Xc = k_c * k_q * pM * g_c * cexp l_n_Xc ``` ### (4) Let's consider the expression $A = \sum_{\Xc} w(\n; \Xc) \cdot l(\n; \Xc)$ for the following cases of reactant compartments: $\Xc = \emptyset$, $\Xc = \muset{\x}$, and $\Xc = \muset{\x, \x'}$. (1) $\Xc = \emptyset$: Then $w(\n; \Xc) = 1$, and $$ A = l(\n) $$ (2) $\Xc = \muset{\x}$: Then $w(\n; \Xc) = \n(\x)$, and $$ A = \sum_{\x \in \X} \n(\x) \cdot l(\n; \muset{\x}) $$ (3) $\Xc = \muset{\x, \x'}$: Then $$ w(\n; \Xc) = \frac{\n(\x)\cdot(\n(\x')-\delta_{\x,\x'})} {1+\delta_{\x,\x'}}, $$ and $$ \begin{align} A &= \sum_{\x \in \X} \sum_{\x' \in \X} \frac{1}{2-\delta_{\x,\x'}} \cdot w(\n; \Xc) \cdot l(\n; \muset{\x, \x'}) \\ &= \sum_{\x \in \X} \sum_{\x' \in \X} \frac{\n(\x)\cdot(\n(\x')-\delta_{\x,\x'})}{2} \cdot l(\n; \muset{\x, \x'}) \\ &= \sum_{\x \in \X} \sum_{\x' \in \X} \n(\x)\cdot\n(\x') \cdot \frac{1}{2}l(\n; \muset{\x, \x'}) \: - \: \sum_{\x \in \X} \n(\x) \cdot \frac{1}{2}l(\n; \muset{\x, \x}) \end{align} $$ ### (5) Now let $$ l(\n; \Xc) = k_c \cdot k_q \cdot \Pi(M^{\gamma^k}) \cdot g_c(\Xc) \cdot \left< \Pi \DM^{\gamma^l} \;\big|\; \Xc \right> $$ Plugging in the concrete $\gamma^l$ and expanding, $l(\n; \Xc)$ is a polynomial in $\Xc$. Monomials are of the form $k \x^\alpha$ or $k \x^\alpha \x'^\beta$ with $\alpha, \beta \in \N_0^D$. (Note that occurences of $\Pi M^{\gamma^k}$ are part of the constants $k$.) Consider again the different cases of reactant compartments $\Xc$: (1) $\Xc = \emptyset$: $$ \frac{\diff\left< f(M^\gamma, M^{\gamma'}, \ldots) \right>}{\diff t} = \left<l(\n)\right> $$ (2) $\Xc = \muset{\x}$: $$ \frac{\diff\left< f(M^\gamma, M^{\gamma'}, \ldots) \right>}{\diff t} = \left<R(l(\n; \muset{\x})\right> $$ where $R$ replaces all $k \x^\alpha$ by $k M^\alpha$. (3) $\Xc = \muset{\x, \x'}$: $$ \frac{\diff\left< f(M^\gamma, M^{\gamma'}, \ldots) \right>}{\diff t} = \frac{1}{2}\left<R'(l(\n; \muset{\x, \x'})\right> \: - \: \frac{1}{2}\left<R(l(\n; \muset{\x, \x})\right> $$ where $R'$ replaces all $k \x^\alpha \X'^\beta$ by $k M^\alpha M^\beta$, and again $R$ replaces all $k \x^\alpha$ by $k M^\alpha$. All this (the case destinction and replacements) is done in the function `get_dfMdt_contrib()`. ```python dfMdt = get_dfMdt_contrib(reactants, l_n_Xc, D) dfMdt ``` ### (6) Finally, sum over contributions from all $c$, $q$ for the total $$ \frac{\diff\left< f(M^\gamma, M^{\gamma'}, \ldots) \right>}{\diff t} $$

81bc79131d91c87554f1d99056a9a66de96d9141

ipynb

Jupyter Notebook

(EXTRA) Implementation details.ipynb

zechnerlab/Compartor

93c1b0752b6fdfffddd4f1ac6b9631729eae9a95

2021-02-10T15:56:02.000Z

2021-02-10T15:56:02.000Z

(EXTRA) Implementation details.ipynb

zechnerlab/Compartor

93c1b0752b6fdfffddd4f1ac6b9631729eae9a95

(EXTRA) Implementation details.ipynb

zechnerlab/Compartor

93c1b0752b6fdfffddd4f1ac6b9631729eae9a95

2021-12-05T11:24:22.000Z

2021-12-05T11:24:22.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Linear regression Linear regression is the simplest linear method used for modelling the relationship between the independent variables and the dependent ones. It tries to estimate it by finding a line which is as close as possible to all the data points. \begin{equation} y=ax+b \end{equation} #### Boston housing example [Boston housing](https://www.kaggle.com/c/boston-housing) is a very simple dataset built from some statistical data of the houses of Boston suburbs and the median prices (in $1000s) of owner-occupied homes for each zone. ```python import pandas as pd import numpy as np import matplotlib.pyplot as plt from sklearn.datasets import load_boston # Loading the dataset with pandas boston_data = load_boston() boston_housing_df = pd.DataFrame(boston_data.data,columns=boston_data.feature_names) boston_housing_df["MEDV"] = boston_data.target boston_housing_df.head() ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>CRIM</th> <th>ZN</th> <th>INDUS</th> <th>CHAS</th> <th>NOX</th> <th>RM</th> <th>AGE</th> <th>DIS</th> <th>RAD</th> <th>TAX</th> <th>PTRATIO</th> <th>B</th> <th>LSTAT</th> <th>MEDV</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>0.00632</td> <td>18.0</td> <td>2.31</td> <td>0.0</td> <td>0.538</td> <td>6.575</td> <td>65.2</td> <td>4.0900</td> <td>1.0</td> <td>296.0</td> <td>15.3</td> <td>396.90</td> <td>4.98</td> <td>24.0</td> </tr> <tr> <th>1</th> <td>0.02731</td> <td>0.0</td> <td>7.07</td> <td>0.0</td> <td>0.469</td> <td>6.421</td> <td>78.9</td> <td>4.9671</td> <td>2.0</td> <td>242.0</td> <td>17.8</td> <td>396.90</td> <td>9.14</td> <td>21.6</td> </tr> <tr> <th>2</th> <td>0.02729</td> <td>0.0</td> <td>7.07</td> <td>0.0</td> <td>0.469</td> <td>7.185</td> <td>61.1</td> <td>4.9671</td> <td>2.0</td> <td>242.0</td> <td>17.8</td> <td>392.83</td> <td>4.03</td> <td>34.7</td> </tr> <tr> <th>3</th> <td>0.03237</td> <td>0.0</td> <td>2.18</td> <td>0.0</td> <td>0.458</td> <td>6.998</td> <td>45.8</td> <td>6.0622</td> <td>3.0</td> <td>222.0</td> <td>18.7</td> <td>394.63</td> <td>2.94</td> <td>33.4</td> </tr> <tr> <th>4</th> <td>0.06905</td> <td>0.0</td> <td>2.18</td> <td>0.0</td> <td>0.458</td> <td>7.147</td> <td>54.2</td> <td>6.0622</td> <td>3.0</td> <td>222.0</td> <td>18.7</td> <td>396.90</td> <td>5.33</td> <td>36.2</td> </tr> </tbody> </table> </div> There are several features in the dataset: * **crim** per capita crime rate by town. * **zn** proportion of residential land zoned for lots over 25,000 sq.ft. * **indus** proportion of non-retail business acres per town. * **chas** Charles River dummy variable (= 1 if tract bounds river; 0 otherwise). * **nox** nitrogen oxides concentration (parts per 10 million). * **rm** average number of rooms per dwelling. * **age** proportion of owner-occupied units built prior to 1940. * **dis** weighted mean of distances to five Boston employment centres. * **rad** index of accessibility to radial highways. * **tax** full-value property-tax rate per \$10000 * **ptratio** pupil-teacher ratio by town. * **black** 1000(Bk - 0.63)^2 where Bk is the proportion of blacks by town. * **lstat** lower status of the population (percent). * **medv** median value of owner-occupied homes in \$1000s. The target variable $y$ is called *medv*. #### 2D linear regression For the simplicity, we'll consider a 2D example and try to predict the *medv* (median value), given *crim* (per capita crime rate). Let's take a look at the data in the first place. ```python boston_housing_df.plot(x="CRIM", y="MEDV", kind="scatter") from sklearn.linear_model import LinearRegression # Create an instance of LinearRegression and find the coeffs linear_regression = LinearRegression() linear_regression.fit(X=boston_housing_df[["CRIM"]], y=boston_housing_df["MEDV"]) linear_regression.coef_, linear_regression.intercept_ ``` We can try to draw the linear regression $y$ using matplotlib. In the code below we take the MEDV features as $y$ and CRIM as $x$. ```python # Create a polynomial to be drawn on the plot coefficients = np.append(linear_regression.coef_, linear_regression.intercept_) polynomial = np.poly1d(coefficients) # Calculate the values for a selected range x_values = np.linspace(0, boston_housing_df["CRIM"].max()) y_values = polynomial(x_values) # Display a scatter plot: crim vs medv and regressed line boston_housing_df.plot(x="CRIM", y="MEDV", kind="scatter") plt.plot(x_values, y_values, color="red", linestyle="dashed") from sklearn.metrics import mean_squared_error y_pred = linear_regression.predict(boston_housing_df[["CRIM"]]) y_true = boston_housing_df["MEDV"] mean_squared_error(y_true, y_pred) ``` ### Multidimensional linear regression An intuitive selection of the possibile predictor did not help to perform a regression of the median value in the area properly. For a low crime rate it looks better, but when it comes to really high crime rate, the predicted value is negative. For the purposes of selecting predictors, we may consider the variables which have the highest correlation with the target variable. ```python # Calculate the Pearson correlation coefficients boston_housing_df.corr()["MEDV"] ``` CRIM -0.388305 ZN 0.360445 INDUS -0.483725 CHAS 0.175260 NOX -0.427321 RM 0.695360 AGE -0.376955 DIS 0.249929 RAD -0.381626 TAX -0.468536 PTRATIO -0.507787 B 0.333461 LSTAT -0.737663 MEDV 1.000000 Name: MEDV, dtype: float64 The absolute value of correlation coefficients is highest for *rm* (0.689598) and *lstat* (-0.738600). That means, these values are possibly the best predictors for the target variable and we can consider them in a 3D regression. ```python from mpl_toolkits.mplot3d import Axes3D # Display 3D scatter: rm, lstat vs medv fig = plt.figure() ax = fig.add_subplot(111, projection="3d") ax.scatter(boston_housing_df["RM"], boston_housing_df["LSTAT"], boston_housing_df["MEDV"], c="blue") plt.show() ``` Let's find the coefficiencies and build a linear regression instance. ```python linear_regression = LinearRegression() linear_regression.fit(X=boston_housing_df[["RM", "LSTAT"]], y=boston_housing_df["MEDV"]) linear_regression.coef_, linear_regression.intercept_ ``` (array([ 5.09478798, -0.64235833]), -1.358272811874489) For a three-dimensional case we need to calculate three values. We get three coeffiencies that are used to get the $z$ values. ```python # Calculate coefficients of 2d polynomial coefficients = np.append(linear_regression.coef_, linear_regression.intercept_) # Calculate the values for a selected range x = np.linspace(0, boston_housing_df["RM"].max()) y = np.linspace(0, boston_housing_df["LSTAT"].max()) x_values, y_values = np.meshgrid(x, y) z_values = coefficients[0] * x_values + coefficients[1] * y_values + coefficients[2] # Display 3D scatter: rm, lstat vs medv and regressed line fig = plt.figure() ax = fig.add_subplot(111, projection="3d") ax.scatter(boston_housing_df["RM"], boston_housing_df["LSTAT"], boston_housing_df["MEDV"], c="blue") ax.plot_surface(x_values, y_values, z_values, linewidth=0.2, color="red", alpha=0.5) angle=30 ax.view_init(30, angle) plt.show() ``` The prediction of linear regression can be done with the ``predict`` method. The cost function of a linear regression is calculated with mean squared error function. ```python y_pred = linear_regression.predict(boston_housing_df[["RM", "LSTAT"]]) y_true = boston_housing_df["MEDV"] mean_squared_error(y_true, y_pred) ``` 30.51246877729947 # Linear regression under the hood To understand the method in more details we use a simple example of humans heights and weights values. ```python heights = np.array([188, 181, 197, 168, 167, 187, 178, 194, 140, 176, 168, 192, 173, 142, 176]).reshape(-1, 1) weights = np.array([141, 106, 149, 59, 79, 136, 65, 136, 52, 87, 115, 140, 82, 69, 121]).reshape(-1, 1) ``` For comparison, we use the linear regression available in sklearn library. ```python from sklearn import linear_model import numpy as np regr = linear_model.LinearRegression() regr.fit(heights, weights) ``` LinearRegression() As in the previous example, we can plot the slope. ```python plt.scatter(heights, weights,color='g') plt.plot(heights, regr.predict(heights),color='k') plt.show() ``` The coeffieciencies are calculated as: ```python print(regr.coef_) print(regr.intercept_) ``` [[1.61814247]] [-180.92401772] If we calcualte the $y$ value for $x=150$: ```python plt.scatter(heights, weights,color='g') plt.plot(heights, regr.predict(heights),color='k') x= 150 y = 61.797 plt.scatter(x, y,color='r') plt.show() ``` ## Linear regression from scratch And now we can use the data set to implement the linear regression from scratch. ```python x = heights.reshape(15,1) y = weights.reshape(15,1) ``` We should add the bias column before doing the calculation. ```python x = np.append(x, np.ones((15,1)), axis = 1) ``` The equation for calculating the weights is \begin{equation} (X^{T}X)^{-1}X^{T}y \end{equation} ```python w = np.dot(np.linalg.inv(np.dot(np.transpose(x),x)),np.dot(np.transpose(x),y)) ``` The weitghs we can as the output are exaclty the same as we get using sklearn implementation of the linear regression method. ```python w ``` array([[ 1.61814247], [-180.92401772]]) To make the prediction a bit easier, we can implement a short function where the arguments are: - inputs - feature $x$ of objects, - w - weights, - b - bias. The calculation is easy and use the linear regression equation $y=wx+b$. ```python def reg_predict(inputs, w, b): results = [] for inp in inputs: results.append(inp*w+b) return results ``` Finally, we can plot the predicted values using the function above. ```python plt.scatter(heights.flatten(), weights.flatten(),color='g') plt.plot(heights.flatten(), reg_predict(heights.flatten(), w[0], w[1]) ,color='k') x1 = 150 y = reg_predict([x1], w[0], w[1])[0] plt.scatter(x1, y,color='r') plt.show() ``` ```python reg_predict(x.flatten(), w[1], w[0]) ``` [array([-34012.0971882]), array([-179.30587525]), array([-32745.62906419]), array([-179.30587525]), array([-35640.41334765]), array([-179.30587525]), array([-30393.61683388]), array([-179.30587525]), array([-30212.69281616]), array([-179.30587525]), array([-33831.17317049]), array([-179.30587525]), array([-32202.85701104]), array([-179.30587525]), array([-35097.6412945]), array([-179.30587525]), array([-25327.74433782]), array([-179.30587525]), array([-31841.00897561]), array([-179.30587525]), array([-30393.61683388]), array([-179.30587525]), array([-34735.79325907]), array([-179.30587525]), array([-31298.23692246]), array([-179.30587525]), array([-25689.59237325]), array([-179.30587525]), array([-31841.00897561]), array([-179.30587525])] # Ridge regression Ridge regression use a regularizer and the equation is a bit more complex compare to the regular linear regression: \begin{equation} \sum_{i=1}^{M}(y_{i}-\sum_{j=0}^{p}w_{j}\dot x_{ij})^{2} + \lambda\sum_{j=0}^{p}w^{2}_{j}. \end{equation} We have an additional parameter $\lambda$ that is known in sklearn as $\alpha$. It's the regularizer that together with $w^{2}_{j}$ is known as the L2 regularizator. ```python from sklearn.linear_model import Ridge alpha = 0.1 heights1 = np.asmatrix(np.c_[np.ones((15,1)), heights]) ridge_regression = Ridge(alpha=alpha, fit_intercept=False) ridge_regression.fit(X=heights1, y=weights) ridge_regression.coef_, ridge_regression.intercept_ ``` (array([[-101.72397081, 1.16978757]]), 0.0) Similar to the regular linear regression, the slope can be drawn as below. ```python plt.scatter(heights, weights,color='g') plt.plot(heights, ridge_regression.predict(heights1),color='k') x = 150 y = reg_predict([150], ridge_regression.coef_[0][1], ridge_regression.coef_[0][0])[0] plt.scatter(x, y,color='r') y = ridge_regression.coef_[0][1] * 150 + ridge_regression.coef_[0][0] plt.show() ``` For $x_{1}=150$ the result is a bit different compared to the regression without the regularization. ```python y = ridge_regression.coef_[0][1] * 150 + ridge_regression.coef_[0][0] print(y) ``` 73.74416542365165 We can write the equation in a matrix-way as: \begin{equation} (X^{T}X+\alpha\dot W)^{-1}X^{T}y \end{equation} ```python y = weights x = np.asmatrix(np.c_[np.ones((15,1)),heights]) I = np.identity(2) alpha = 0.1 w = np.linalg.inv(x.T*x + alpha * I)*x.T*y ``` The weights are calculated same as in case of sklearn. ```python w=np.array(w).ravel() print(w) ``` [-101.72397081 1.16978757] The plot looks as below. We see the the slope start with higer $y$ values compared to the regular linear regression. ```python plt.scatter(heights, weights, color='g') plt.plot(heights, reg_predict(heights.flatten(), w[1], w[0]),color='k') x1= 150 y = x1*w[1]+w[0] plt.scatter(x1, y,color='r') plt.show() ``` # Lasso regression Lasso regression uses the L1 regularization. The equation is very similar to the Ridge one, but instead of $w^{2}$ we use the magnitude of $w$. \begin{equation} \sum_{i=1}^{M}(y_{i}-\sum_{j=0}^{p}w_{j}\dot x_{ij})^{2} + \lambda\sum_{j=0}^{p}|w_{j}|. \end{equation} ```python from sklearn.linear_model import Lasso alpha = 0.1 lasso_regression = Lasso(alpha=alpha) lasso_regression.fit(X=heights, y=weights) lasso_regression.coef_, lasso_regression.intercept_ ``` (array([1.61776499]), array([-180.8579086])) ```python plt.scatter(heights, weights,color='g') plt.plot(heights, lasso_regression.predict(heights),color='k') plt.show() ``` ```python ```

8370582d7a523ae4b2d22edcf7bd4110bc2d6ff0

ipynb

Jupyter Notebook

ML1/linear/021_Linear_regression.ipynb

DevilWillReign/ML2022

cb4cc692e9f0e178977fb5e1d272e581b30f998d

ML1/linear/021_Linear_regression.ipynb

DevilWillReign/ML2022

cb4cc692e9f0e178977fb5e1d272e581b30f998d

ML1/linear/021_Linear_regression.ipynb

DevilWillReign/ML2022

cb4cc692e9f0e178977fb5e1d272e581b30f998d

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Find worst cases \begin{equation} \begin{array}{rl} \mathcal{F}_L =& \dfrac{4 K I H r}{Q_{in}(1+f)}\\ u_{c} =& \dfrac{-KI\mathcal{F}_L}{\theta \left(\mathcal{F}_L+1\right)}\\ \tau =& -\dfrac{r}{|u_{c}|}\\ C_{\tau,{\rm decay}}=& C_0 \exp{\left(-\lambda \tau \right)}\\ C_{\tau,{\rm filtr}}=& C_0 \exp{\left(-k_{\rm att} \tau \right)}\\ C_{\tau,{\rm dilut}} =& C_{in} \left( \dfrac{Q_{in}}{u_c \Delta y \Delta z} \right)\\ C_{\tau,{\rm both}} =& \dfrac{C_{\rm in}Q_{\rm in}}{u_c \Delta y H \theta} \exp{\left(-\lambda\dfrac{r}{|u_c|}\right)} \end{array} \end{equation} ```python %reset -f import numpy as np import matplotlib.pyplot as plt import matplotlib from os import system import os from matplotlib.gridspec import GridSpec from drawStuff import * import jupypft.attachmentRateCFT as CFT import jupypft.plotBTC as BTC ''' GLOBAL CONSTANTS ''' PI = 3.141592 THETA = 0.35 ``` ```python def flowNumber(): return (4.0*K*I*H*r) / (Qin*(1+f)) def uChar(): '''Interstitial water velocity''' return -(K*I*flowNumber())/(THETA*(flowNumber() + 1)) def tChar(): return -r/uChar() def cDecay(): return C0 * np.exp(-decayRate * tChar()) def cAttach(): return C0 * np.exp(-attchRate * tChar()) def cDilut(): return (C0 * Qin) / (-uChar() * delY * delZ * THETA) def cBoth(): return (C0 * Qin) / (-uChar() * delY * delZ * THETA) * np.exp(-decayRate * tChar()) def cTrice(): return (C0 * Qin) / (-uChar() * delY * delZ * THETA) * np.exp(-(decayRate+attchRate) * tChar()) def findSweet(): deltaConc = np.abs(cBoth() - np.max(cBoth())) return np.argmin(deltaConc) ``` ```python K = 10**-2 Qin = 0.24/86400 f = 10 H = 20 r = 40 I = 0.001 C0 = 1.0 qabs = np.abs(uChar()*THETA) kattDict = dict( dp = 1.0E-7, dc = 2.0E-3, q = qabs, theta = THETA, visco = 0.0008891, rho_f = 999.79, rho_p = 1050.0, A = 5.0E-21, T = 10. + 273.15, alpha = 0.01) decayRate = 3.5353E-06 attchRate,_ = CFT.attachmentRate(**kattDict) delY,delZ = 1.35,H ``` ```python print("Nondim Flow = {:.2E}".format(flowNumber())) print("Charac. Vel = {:.2E} m/s".format(uChar())) print("Charac. time = {:.2E} s".format(tChar())) ``` Nondim Flow = 1.05E+03 Charac. Vel = -2.85E-05 m/s Charac. time = 1.40E+06 s ```python print("Rel concenc. due decay = {:.2E}".format(cDecay())) print("Rel conc. due dilution = {:.2E}".format(cDilut())) print("Rel conc. due attachmt = {:.2E}".format(cAttach())) print("Rel conc. due both eff = {:.2E}".format(cBoth())) print("Rel conc. due three ef = {:.2E}".format(cTrice())) ``` Rel concenc. due decay = 7.05E-03 Rel conc. due dilution = 1.03E-02 Rel conc. due attachmt = 4.42E-05 Rel conc. due both eff = 7.26E-05 Rel conc. due three ef = 3.21E-09 # Plot v. 1 I = 10**np.linspace(-5,0,num=100) cDec = cDecay() cDil = cDilut() cAtt = cAttach() cBot = cBoth() cAll = cTrice() i = findSweet() worstC = cBot[i] worstI = I[i] fig, axs = plt.subplots(2,2,sharex=True, sharey=False,\ figsize=(12,8),gridspec_kw={"height_ratios":[1,4],"hspace":0.04,"wspace":0.35}) bbox = dict(boxstyle='round', facecolor='mintcream', alpha=0.90) arrowprops = dict( arrowstyle="->", connectionstyle="angle,angleA=90,angleB=40,rad=5") fontdict = dict(size=12) annotation = \ r"$\bf{-\log(C/C_0)} = $" + "{:.1f}".format(-np.log10(worstC)) + \ "\n@" + r" $\bf{I} = $" + "{:.1E}".format(worstI) information = \ r"$\bf{K}$" + " = {:.1E} m/s".format(K) + "\n"\ r"$\bf{H}$" + " = {:.1f} m".format(H) + "\n"\ r"$\bf{r}$" + " = {:.1f} m".format(r) + "\n"\ r"$\bf{Q_{in}}$" + " = {:.2f} m³/d".format(Qin*86400) + "\n"\ r"$\bf{f}$" + " = {:.1f}".format(f) + "\n"\ r"$\bf{\lambda}$" + " = {:.2E} 1/s".format(decayRate) ######################################### # Ax1 - Relative concentration ax = axs[1,0] ax.plot(I,cDec,label="Due decay",lw=3,ls="dashed",alpha=0.8) ax.plot(I,cDil,label="Due dilution",lw=3,ls="dashed",alpha=0.8) ax.plot(I,cAtt,label="Due attachment",lw=2,ls="dashed",alpha=0.6) ax.plot(I,cBot,label="Decay + dilution",lw=3,c='k',alpha=0.9) ax.plot(I,cAll,label="Overall effect",lw=3,c='gray',alpha=0.9) ax.set(xscale="log",yscale="log") ax.set(xlim=(1.0E-4,1.0E-1),ylim=(1.0E-10,1)) ax.legend(loc="lower left",shadow=True) ax.annotate(annotation,(worstI,worstC), xytext=(0.05,0.85), textcoords='axes fraction', bbox=bbox, arrowprops=arrowprops) ax.text(0.65,0.05,information,bbox=bbox,transform=ax.transAxes) ax.set_xlabel("Water table gradient\n$I$ [m/m]",fontdict=fontdict) ax.set_ylabel("Relative Concentration\n$C/C_0$ [-]",fontdict=fontdict) #################################### # Ax2 - log-removals ax = axs[1,1] ax.plot(I,-np.log10(cDec),label="Due decay",lw=3,ls="dashed",alpha=0.8) ax.plot(I,-np.log10(cDil),label="Due dilution",lw=3,ls="dashed",alpha=0.8) ax.plot(I,-np.log10(cAtt),label="Due attachment",lw=2,ls="dashed",alpha=0.6) ax.plot(I,-np.log10(cBot),label="Decay + dilution",lw=3,c='k',alpha=0.9) ax.plot(I,-np.log10(cAll),label="Overall effect",lw=3,c='gray',alpha=0.9) ax.set(xscale="log") ax.set(xlim=(1.0E-4,1.0E-1),ylim=(0,10)) ax.legend(loc="upper left",shadow=True) ax.annotate(annotation,(worstI,-np.log10(worstC)), xytext=(0.65,0.55), textcoords='axes fraction', bbox=bbox, arrowprops=arrowprops) ax.text(0.65,0.70,information,bbox=bbox,transform=ax.transAxes) ax.set_xlabel("Water table gradient\n$I$ [m/m]",fontdict=fontdict) ax.set_ylabel("log-reductions\n$-\log(C/C_0)$ [-]",fontdict=fontdict) #################################### #Flow number for ax in axs[0,:]: ax.plot(I,flowNumber(),label="flowNumber",lw=3,c="gray") ax.axhline(y=1.0) ax.set_xscale("log") ax.set_yscale("log") ax.xaxis.set_tick_params(which="both",labeltop='on',top=True,bottom=False) ax.set_ylabel("Nondim. flow number\n$\mathcal{F}_L$ [-]") ####################################< #Line worst case scenario for axc in axs: for ax in axc: ax.axvline(x=I[i], lw=1, ls="dashed", c="red",alpha=0.5) plt.show() # v.2 With PFLOTRAN result ```python listOfFiles = os.listdir("LittleValidation_MASSBALANCES") listOfFiles.sort() IPFLO = [float(s[9:16]) for s in listOfFiles] CPFLO = BTC.get_endConcentrations( "LittleValidation_MASSBALANCES", indices={'t':"Time [d]",\ 'q':"ExtractWell Water Mass [kg/d]",\ 'm':"ExtractWell Vaq [mol/d]" }, normalizeWith=dict(t=1.0,q=kattDict['rho_f']/1000.,m=1.0)) ``` NumExpr defaulting to 8 threads. ```python listOfFiles = os.listdir("LittleValidation_MASSBALANCES_Att") listOfFiles.sort() IPFLO2 = [float(s[8:15]) for s in listOfFiles] CPFLO2 = BTC.get_endConcentrations( "LittleValidation_MASSBALANCES_Att", indices={'t':"Time [d]",\ 'q':"ExtractWell Water Mass [kg/d]",\ 'm':"ExtractWell Vaq [mol/d]" }, normalizeWith=dict(t=1.0,q=kattDict['rho_f']/1000.,m=1.0)) ``` ```python # Theoretical stuff I = 10**np.linspace(-5,0,num=100) cDec = cDecay() cDil = cDilut() cAtt = cAttach() cBot = cBoth() cAll = cTrice() i = findSweet() worstC = cBot[i] worstI = I[i] ``` fig, axs = plt.subplots(2,2,sharex=True, sharey=False,\ figsize=(10,8),gridspec_kw={"height_ratios":[1,10],"hspace":0.04,"wspace":0.02}) bbox = dict(boxstyle='round', facecolor='mintcream', alpha=0.90) arrowprops = dict( arrowstyle="->", connectionstyle="angle,angleA=90,angleB=40,rad=5") fontdict = dict(size=12) annotation = \ r"$\bf{-\log(C/C_0)} = $" + "{:.1f}".format(-np.log10(worstC)) + \ "\n@" + r" $\bf{I} = $" + BTC.sci_notation(worstI) information = \ r"$\bf{K} = $" + BTC.sci_notation(K) + " m/s\n"\ r"$\bf{H}$" + " = {:.1f} m".format(H) + "\n"\ r"$\bf{r}$" + " = {:.1f} m".format(r) + "\n"\ r"$\bf{Q_{in}}$" + " = {:.2f} m³/d".format(Qin*86400) + "\n"\ r"$\bf{f}$" + " = {:.1f}".format(f) + "\n"\ r"$\bf{\lambda_{\rm aq}} = $" + BTC.sci_notation(decayRate) + " s⁻¹\n"\ r"$\bf{k_{\rm att}} = $" + BTC.sci_notation(attchRate) + " s⁻¹" #################################### # Ax2 - log-removals ax = axs[1,0] symbols=dict(dil="\u25A2",dec="\u25B3",att="\u25CE") ax.plot(I,-np.log10(cDil),\ label="Due dilution " + symbols['dil'],\ lw=3,ls="dashed",alpha=0.6,c='crimson') ax.plot(I,-np.log10(cDec),\ label="Due decay " + symbols['dec'],\ lw=3,ls="dashed",alpha=0.6,c='indigo') ax.plot(I,-np.log10(cAtt),\ label="Due attachment " + symbols['att'],\ lw=2,ls="dashed",alpha=0.5,c='olive') ax.plot(I,-np.log10(cBot),\ label=symbols['dil'] + " + " + symbols['dec'],\ lw=3,c='k',alpha=0.9,zorder=2) ax.plot(I,-np.log10(cAll),\ label=symbols['dil'] + " + " + symbols['dec'] + " + " + symbols['att'],\ lw=2,c='gray',alpha=0.9,zorder=2) ax.set(xscale="log") ax.set(xlim=(1.0E-4,1.0E-1),ylim=(0,9.9)) ax.legend(loc="upper right",shadow=True,ncol=1,\ title="Potential flow prediction",title_fontsize=11) ax.annotate(annotation,(worstI,-np.log10(worstC)), xytext=(0.65,0.55), textcoords='axes fraction', bbox=bbox, arrowprops=arrowprops) ax.set_xlabel("Water table gradient\n$I$ [m/m]",fontdict=fontdict) ax.set_ylabel("log-reductions\n$-\log(C/C_0)$ [-]",fontdict=fontdict) #################################### # Ax2 - log-removals ax = axs[1,1] ax.plot(I,-np.log10(cBot), lw=3,c='k',alpha=0.9) ax.plot(IPFLO,-np.log10(CPFLO),zorder=2,\ label= symbols['dil'] + " + " + symbols['dec'],\ lw=0,ls='dotted',c='k',alpha=0.9,\ marker="$\u25CA$",mec='k',mfc='k',ms=10) ax.plot(I,-np.log10(cAll),\ lw=2,c='gray',alpha=0.9) ax.plot(IPFLO2,-np.log10(CPFLO2),zorder=2,\ label= symbols['dil'] + " + " + symbols['dec'] + " + " + symbols['att'],\ lw=0,ls='dotted',c='gray',alpha=0.9,\ marker="$\u2217$",mec='gray',mfc='gray',ms=10) ##### ax.set(xscale="log") ax.set(xlim=(1.0E-4,9.0E-2),ylim=(0,9.9)) ax.legend(loc="lower left",shadow=True,ncol=1,\ labelspacing=0.4,mode=None,\ title="PFLOTRAN run",title_fontsize=11) ax.set_xlabel("Water table gradient\n$I$ [m/m]",fontdict=fontdict) ax.yaxis.tick_right() ax.text(0.60,0.70,information,bbox=bbox,transform=ax.transAxes) ax.text(I[i],0.5,"Worst\ncase",\ ha='center',va='center',weight='semibold',\ bbox=dict(boxstyle='square', fc='white', ec='red')) #################################### #Flow number ax = axs[0,0] ax.plot(I,flowNumber(),label="flowNumber",lw=3,c="gray") #ax.axhline(y=1.0) ax.set_xscale("log") ax.set_yscale("log") ax.xaxis.set_tick_params(which="both",labeltop='on',top=False,bottom=False) #ax.set_ylabel("Nondim. flow number\n$\mathcal{F}_L$ [-]") ####################################< #Line worst case scenario axs[0,0].axvline(x=I[i], lw=2, ls="dotted", c="red",alpha=0.5) axs[1,0].axvline(x=I[i], lw=2, ls="dotted", c="red",alpha=0.5) axs[1,1].axvline(x=I[i], lw=2, ls="dotted", c="red",alpha=0.5) ############################### # Information box ax = axs[0,1] ax.axis('off') plt.show() ```python fig, axs = plt.subplots(1,1,figsize=(5,5)) fontdict = dict(size=12) lines = {} information = \ r"$\bf{K} = $" + BTC.sci_notation(K) + " m/s\n"\ r"$\bf{H}$" + " = {:.1f} m".format(H) + "\n"\ r"$\bf{r}$" + " = {:.1f} m".format(r) + "\n"\ r"$\bf{Q_{in}}$" + " = {:.2f} m³/d".format(Qin*86400) + "\n"\ r"$\bf{f}$" + " = {:.1f}".format(f) + "\n"\ r"$\bf{\lambda_{\rm aq}} = $" + BTC.sci_notation(decayRate) + " s⁻¹"\ #################################### # Ax2 - log-removals ax = axs lines['Dilution'] = ax.plot(I,-np.log10(cDil),\ label="Due dilution",\ lw=3,ls="dashed",alpha=0.99,c='#f1a340') lines['Decay'] = ax.plot(I,-np.log10(cDec),\ label="Due decay",\ lw=3,ls="dashdot",alpha=0.99,c='#998ec3') #ax.plot(I,-np.log10(cAtt),\ # label="Due attachment " + symbols['att'],\ # lw=2,ls="dashed",alpha=0.5,c='olive') lines['Both'] = ax.plot(I,-np.log10(cBot),\ label="Combined effect",\ lw=3,c='k',alpha=0.9,zorder=2) #ax.plot(I,-np.log10(cAll),\ # label=symbols['dil'] + " + " + symbols['dec'] + " + " + symbols['att'],\ # lw=2,c='gray',alpha=0.9,zorder=2) lines['PFLOT'] = ax.plot(IPFLO,-np.log10(CPFLO),zorder=2,\ label= "BIOPARTICLE model",\ lw=0,ls='dotted',c='k',alpha=0.9,\ marker="$\u25CA$",mec='k',mfc='k',ms=10) ax.set(xscale="log") ax.set(xlim=(5.0E-5,5.0E-1),ylim=(-0.5,9.9)) ax.set_xlabel("Water table gradient\n$I$ [m/m]",fontdict=fontdict) ax.set_ylabel("log-reductions\n$-\log(C/C_0)$ [-]",fontdict=fontdict) ## Legend whitebox = ax.scatter([1],[1],c="white",marker="o",s=1,alpha=0) handles = [lines['PFLOT'][0], lines['Both'][0]] labels = [lines['PFLOT'][0].get_label(), "PF model"] plt.legend(handles, labels, loc="upper right",ncol=1,\ edgecolor='gray',facecolor='mintcream',labelspacing=1) ##aNNOTATIONS rotang = -1.0 bbox = dict(boxstyle='square', fc='w', ec='#998ec3',lw=1.5) ax.text(0.85,0.10,'Inactivation',ha='center',va='center', fontsize=11,rotation=rotang,bbox=bbox,transform=ax.transAxes) rotang = 21.0 bbox = dict(boxstyle='square', fc='w', ec='#f1a340',lw=1.5) ax.text(0.12,0.21,'Dilution',ha='center',va='center', fontsize=11,rotation=rotang,bbox=bbox,transform=ax.transAxes) rotang = -0.0 bbox = dict(boxstyle='square', fc='k', ec=None,lw=0.0) ax.text(0.55,0.45,'Combined',c='w',ha='center',va='center',weight='bold', fontsize=11,rotation=rotang,bbox=bbox,transform=ax.transAxes) bbox = dict(boxstyle='round,pad=0.5,rounding_size=0.3', fc='whitesmoke', alpha=0.90,ec='whitesmoke') #ax.text(0.60,0.64,information,bbox=bbox,transform=ax.transAxes,fontsize=10) fig.savefig(fname="SweetpointOnlyDecay.png",transparent=False,dpi=300,bbox_inches="tight") #plt.show() ``` ```python fig, axs = plt.subplots(1,1,figsize=(5,5)) fontdict = dict(size=12) lines = {} information = \ r"$\bf{K} = $" + BTC.sci_notation(K) + " m/s\n"\ r"$\bf{H}$" + " = {:.1f} m".format(H) + "\n"\ r"$\bf{r}$" + " = {:.1f} m".format(r) + "\n"\ r"$\bf{Q_{in}}$" + " = {:.2f} m³/d".format(Qin*86400) + "\n"\ r"$\bf{f}$" + " = {:.1f}".format(f) + "\n"\ r"$\bf{\lambda_{\rm aq}} = $" + BTC.sci_notation(decayRate) + " s⁻¹\n"\ r"$\bf{k_{\rm att}} = $" + BTC.sci_notation(attchRate) + " s⁻¹" #################################### # Ax2 - log-removals ax = axs lines['Dilution'] = ax.plot(I,-np.log10(cDil),\ label="Due dilution",\ lw=3,ls="dashed",alpha=0.99,c='#f1a340') lines['Decay'] = ax.plot(I,-np.log10(cDec),\ label="Due decay",\ lw=3,ls="dashdot",alpha=0.99,c='#998ec3') lines['Attach'] = ax.plot(I,-np.log10(cAtt),\ label="Due attachment",\ lw=3,ls="dotted",alpha=0.95,c='#4dac26') #lines['Both'] = ax.plot(I,-np.log10(cBot),\ # label="Combined effect",\ # lw=3,c='k',alpha=0.9,zorder=2) lines['Both'] = ax.plot(I,-np.log10(cAll),\ label="Combined\neffect",\ lw=3,c='#101613',alpha=0.99,zorder=2) lines['PFLOT'] = ax.plot(IPFLO2,-np.log10(CPFLO2),zorder=2,\ label= "BIOPARTICLE model",\ lw=0,ls='dotted',c='k',alpha=0.9,\ marker="$\u2217$",mec='gray',mfc='k',ms=10) ax.set(xscale="log") ax.set(xlim=(5.0E-5,5.0E-1),ylim=(-0.5,9.9)) ax.set_xlabel("Water table gradient\n$I$ [m/m]",fontdict=fontdict) ax.set_ylabel("log-reductions\n$-\log(C/C_0)$ [-]",fontdict=fontdict) ## Legend whitebox = ax.scatter([1],[1],c="white",marker="o",s=1,alpha=0) handles = [lines['PFLOT'][0], lines['Both'][0]] labels = [lines['PFLOT'][0].get_label(), "PF model"] plt.legend(handles, labels, loc="upper right",ncol=1,\ edgecolor='gray',facecolor='mintcream',labelspacing=1) ##aNNOTATIONS rotang = -82.0 bbox = dict(boxstyle='square', fc='w', ec='#998ec3',lw=1.5) ax.text(0.12,0.85,'Inactivation',c='k',fontweight='normal',ha='center',va='center', fontsize=11,rotation=rotang,bbox=bbox,transform=ax.transAxes) rotang = 21.0 bbox = dict(boxstyle='square', fc='w', ec='#f1a340',lw=1.5) ax.text(0.12,0.21,'Dilution',ha='center',va='center', fontsize=11,rotation=rotang,bbox=bbox,transform=ax.transAxes) rotang = -1.5 bbox = dict(boxstyle='square', fc='w', ec='#4dac26',ls='-',lw=1.5) ax.text(0.85,0.10,'Filtration',ha='center',va='center', fontsize=11,rotation=rotang,bbox=bbox,transform=ax.transAxes) rotang = -0.0 bbox = dict(boxstyle='square', fc='#101613', ec='#101613') ax.text(0.65,0.52,'Combined',c='w',ha='center',va='center',weight='bold', fontsize=11,rotation=rotang,bbox=bbox,transform=ax.transAxes) bbox = dict(boxstyle='round,pad=0.5,rounding_size=0.3', fc='whitesmoke', alpha=0.90,ec='whitesmoke') #ax.text(0.60,0.58,information,bbox=bbox,transform=ax.transAxes,fontsize=10) fig.savefig(fname="SweetpointAllConsidered.png",transparent=False,dpi=300,bbox_inches="tight") plt.show() ``` # v.3 Together as filtration is assumed fig, axs = plt.subplots(1,2,figsize=(10,5)) bbox = dict(boxstyle='round,pad=0.5,rounding_size=0.3', facecolor='mintcream', alpha=0.90) fontdict = dict(size=12) lines = {} information = \ "Parameters:\n" + \ r"$\bf{K} = $" + BTC.sci_notation(K) + " m/s\n"\ r"$\bf{H}$" + " = {:.1f} m".format(H) + "\n"\ r"$\bf{r}$" + " = {:.1f} m".format(r) + "\n"\ r"$\bf{Q_{in}}$" + " = {:.2f} m³/d".format(Qin*86400) + "\n"\ r"$\bf{f}$" + " = {:.1f}".format(f) + "\n"\ r"$\bf{\lambda_{\rm aq}} = $" + BTC.sci_notation(decayRate) + " s⁻¹"\ #################################### # Ax2 - log-removals ax = axs[0] lines['Dilution'] = ax.plot(I,-np.log10(cDil),\ label="Due dilution",\ lw=3,ls="dashed",alpha=0.99,c='#f1a340') lines['Decay'] = ax.plot(I,-np.log10(cDec),\ label="Due decay",\ lw=3,ls="dashdot",alpha=0.99,c='#998ec3') #ax.plot(I,-np.log10(cAtt),\ # label="Due attachment " + symbols['att'],\ # lw=2,ls="dashed",alpha=0.5,c='olive') lines['Both'] = ax.plot(I,-np.log10(cBot),\ label="Combined effect",\ lw=3,c='k',alpha=0.9,zorder=2) #ax.plot(I,-np.log10(cAll),\ # label=symbols['dil'] + " + " + symbols['dec'] + " + " + symbols['att'],\ # lw=2,c='gray',alpha=0.9,zorder=2) lines['PFLOT'] = ax.plot(IPFLO,-np.log10(CPFLO),zorder=2,\ label= "PFLOTRAN results",\ lw=0,ls='dotted',c='k',alpha=0.9,\ marker="$\u25CA$",mec='k',mfc='k',ms=10) ax.set(xscale="log") ax.set(xlim=(5.0E-5,5.0E-1),ylim=(0,9.9)) ax.text(1.04,0.55,information,bbox=bbox,transform=ax.transAxes) ax.set_xlabel("Water table gradient\n$I$ [m/m]",fontdict=fontdict) ax.set_ylabel("log-reductions\n$-\log(C/C_0)$ [-]",fontdict=fontdict) ## Legend whitebox = ax.scatter([1],[1],c="white",marker="o",s=1,alpha=0) handles = [whitebox, lines['Dilution'][0], lines['Decay'][0], lines['Both'][0], whitebox, lines['PFLOT'][0]] labels = ['PF model', lines['Dilution'][0].get_label(), lines['Decay'][0].get_label(), lines['Both'][0].get_label(), '', lines['PFLOT'][0].get_label(),] plt.legend(handles, labels, loc="center left",ncol=1,bbox_to_anchor=(1.01,0.25),\ edgecolor='k',facecolor='mintcream',labelspacing=1) bbox = dict(boxstyle='round,pad=0.5,rounding_size=0.3', facecolor='mintcream', alpha=0.90) fontdict = dict(size=12) lines = {} information = \ "Parameters:\n" + \ r"$\bf{K} = $" + BTC.sci_notation(K) + " m/s\n"\ r"$\bf{H}$" + " = {:.1f} m".format(H) + "\n"\ r"$\bf{r}$" + " = {:.1f} m".format(r) + "\n"\ r"$\bf{Q_{in}}$" + " = {:.2f} m³/d".format(Qin*86400) + "\n"\ r"$\bf{f}$" + " = {:.1f}".format(f) + "\n"\ r"$\bf{\lambda_{\rm aq}} = $" + BTC.sci_notation(decayRate) + " s⁻¹\n"\ r"$\bf{k_{\rm att}} = $" + BTC.sci_notation(attchRate) + " s⁻¹" #################################### # Ax2 - log-removals ax = axs[1] lines['Dilution'] = ax.plot(I,-np.log10(cDil),\ label="Due dilution",\ lw=3,ls="dashed",alpha=0.99,c='#f1a340') lines['Decay'] = ax.plot(I,-np.log10(cDec),\ label="Due decay",\ lw=3,ls="dashdot",alpha=0.99,c='#998ec3') lines['Attach'] = ax.plot(I,-np.log10(cAtt),\ label="Due attachment",\ lw=3,ls="dotted",alpha=0.95,c='#4dac26') #lines['Both'] = ax.plot(I,-np.log10(cBot),\ # label="Combined effect",\ # lw=3,c='k',alpha=0.9,zorder=2) lines['Both'] = ax.plot(I,-np.log10(cAll),\ label="Combined effect",\ lw=3,c='k',alpha=0.99,zorder=2) lines['PFLOT'] = ax.plot(IPFLO2,-np.log10(CPFLO2),zorder=2,\ label= "PFLOTRAN results",\ lw=0,ls='dotted',c='k',alpha=0.9,\ marker="$\u2217$",mec='gray',mfc='k',ms=10) ax.set(xscale="log") ax.set(xlim=(5.0E-5,5.0E-1),ylim=(0,9.9)) ax.text(1.04,0.55,information,bbox=bbox,transform=ax.transAxes) ax.set_xlabel("Water table gradient\n$I$ [m/m]",fontdict=fontdict) ax.set_ylabel("log-reductions\n$-\log(C/C_0)$ [-]",fontdict=fontdict) ## Legend whitebox = ax.scatter([1],[1],c="white",marker="o",s=1,alpha=0) handles = [whitebox, lines['Dilution'][0], lines['Decay'][0], lines['Attach'][0], lines['Both'][0], whitebox, lines['PFLOT'][0]] labels = ['PF model', lines['Dilution'][0].get_label(), lines['Decay'][0].get_label(), lines['Attach'][0].get_label(), lines['Both'][0].get_label(), '', lines['PFLOT'][0].get_label(),] plt.legend(handles, labels, loc="center left",ncol=1,bbox_to_anchor=(1.01,0.25),\ edgecolor='k',facecolor='mintcream',labelspacing=1) plt.show() ____ # Find the worst case ## >> Geometric parameters $H$ and $r$ K = 10**-2 Qin = 0.24/86400 f = 10 C0 = 1.0 decayRate = 3.5353E-06 Harray = np.array([2.,5.,10.,20.,50.]) rarray = np.array([5.,10.,40.,100.]) Iarray = 10**np.linspace(-5,0,num=100) Ci = np.zeros([len(rarray),len(Harray)]) Ii = np.zeros([len(rarray),len(Harray)]) FLi = np.zeros([len(rarray),len(Harray)]) for hi,H in enumerate(Harray): for ri,r in enumerate(rarray): i = findSweet() worstC = -np.log10(cBoth()[i]) worstGradient = Iarray[i] worstFlowNumber = flowNumber()[i] Ci[ri,hi] = worstC Ii[ri,hi] = worstGradient FLi[ri,hi] = worstFlowNumbermyLabels={"Title": { 0: r"$\bf{-\log (C_{\tau}/C_0)}$", 1: r"$\bf{I}$ (%)", 2: r"$\log(\mathcal{F}_L)$"}, "Y": "Aquifer thickness\n$\\bf{H}$ (m)", "X": "Setback distance\n$\\bf{r}$ (m)"} threeHeatplots(data={"I":Ii.T,"C":Ci.T,"FL":FLi.T},\ xlabel=Harray,ylabel=rarray,myLabels=myLabels); ## >>Well parameters K = 10**-2 H = 20 r = 40 C0 = 1.0 decayRate = 3.5353E-06 Qin_array = np.array([0.24,1.0,10.0,100.])/86400. f_array = np.array([1,10.,100.,1000.,10000.]) Iarray = 10**np.linspace(-5,0,num=100) Ci = np.zeros([len(Qin_array),len(f_array)]) Ii = np.zeros([len(Qin_array),len(f_array)]) FLi = np.zeros([len(Qin_array),len(f_array)]) for fi,f in enumerate(f_array): for qi,Qin in enumerate(Qin_array): i = findSweet() worstC = -np.log10(cBoth()[i]) worstGradient = Iarray[i] worstFlowNumber = flowNumber()[i] Ci[qi,fi] = worstC Ii[qi,fi] = worstGradient FLi[qi,fi] = worstFlowNumber ### Plot heatmap myLabels={"Title": { 0: r"$\bf{-\log (C_{\tau}/C_0)}$", 1: r"$\bf{I}$ (%)", 2: r"$\log(\mathcal{F}_L)$"}, "Y": "Extraction to injection ratio\n$\\bf{f}$ (-)", "X": "Injection flow rate\n$\\bf{Q_{in}}$ (m³/d)"} threeHeatplots(data={"I":Ii.T,"C":Ci.T,"FL":FLi.T},\ xlabel=f_array,ylabel=np.round(Qin_array*86400,decimals=2),myLabels=myLabels); ## Hydraulic conductivity Qin = 0.24/86400 f = 10 C0 = 1.0 decayRate = 3.5353E-06 Karray = 10.**np.array([-1.,-2.,-3.,-4.,-5.]) rarray = np.array([5.,10.,40.,100.]) Iarray = 10**np.linspace(-5,0,num=100) Ci = np.zeros([len(rarray),len(Karray)]) Ii = np.zeros([len(rarray),len(Karray)]) FLi = np.zeros([len(rarray),len(Karray)]) for ki,K in enumerate(Karray): for ri,r in enumerate(rarray): i = findSweet() worstC = -np.log10(cBoth()[i]) worstGradient = Iarray[i] worstFlowNumber = flowNumber()[i] Ci[ri,ki] = worstC Ii[ri,ki] = worstGradient FLi[ri,ki] = worstFlowNumber ### Plot heatmap myLabels={"Title": { 0: r"$\bf{-\log (C_{\tau}/C_0)}$", 1: r"$\bf{I}$ (%)", 2: r"$\log(\mathcal{F}_L)$"}, "Y": "Hydraulic conductivity\n$\\bf{K}$ (m/s)", "X": "Setback distance\n$\\bf{r}$ (m)"} threeHeatplots(data={"I":Ii.T,"C":Ci.T,"FL":FLi.T},\ xlabel=Karray,ylabel=rarray,myLabels=myLabels);K = 10**-2 H = 20 f = 10 C0 = 1.0 decayRate = 3.5353E-06 Qin_array = np.array([0.24,1.0,10.0,100.])/86400. rarray = np.array([5.,10.,40.,100.]) Iarray = 10**np.linspace(-5,0,num=100) Ci = np.zeros([len(rarray),len(Qin_array)]) Ii = np.zeros([len(rarray),len(Qin_array)]) FLi = np.zeros([len(rarray),len(Qin_array)]) for qi,Qin in enumerate(Qin_array): for ri,r in enumerate(rarray): i = findSweet() worstC = -np.log10(cBoth()[i]) worstGradient = Iarray[i] worstFlowNumber = flowNumber()[i] Ci[ri,qi] = worstC Ii[ri,qi] = worstGradient FLi[ri,qi] = worstFlowNumber myLabels={"Title": { 0: r"$\bf{-\log (C_{\tau}/C_0)}$", 1: r"$\bf{I}$ (%)", 2: r"$\log(\mathcal{F}_L)$"}, "Y": "Injection flow rate\n$\\bf{Q_{in}}$ (m³/d)", "X": "Setback distance\n$\\bf{r}$ (m)"} threeHeatplots(data={"I":Ii.T,"C":Ci.T,"FL":FLi.T},\ ylabel=rarray,xlabel=np.round(Qin_array*86400,decimals=2),myLabels=myLabels);K = 10**-2 H = 20 f = 10 C0 = 1.0 decayRate = 1.119E-5 Qin_array = np.array([0.24,1.0,10.0,100.])/86400. rarray = np.array([5.,10.,40.,100.]) Iarray = 10**np.linspace(-5,0,num=100) Ci = np.zeros([len(rarray),len(Qin_array)]) Ii = np.zeros([len(rarray),len(Qin_array)]) FLi = np.zeros([len(rarray),len(Qin_array)]) for qi,Qin in enumerate(Qin_array): for ri,r in enumerate(rarray): i = findSweet() worstC = -np.log10(cBoth()[i]) worstGradient = Iarray[i] worstFlowNumber = flowNumber()[i] Ci[ri,qi] = worstC Ii[ri,qi] = worstGradient FLi[ri,qi] = worstFlowNumber myLabels={"Title": { 0: r"$\bf{-\log (C_{\tau}/C_0)}$", 1: r"$\bf{I}$ (%)", 2: r"$\log(\mathcal{F}_L)$"}, "Y": "Injection flow rate\n$\\bf{Q_{in}}$ (m³/d)", "X": "Setback distance\n$\\bf{r}$ (m)"} threeHeatplots(data={"I":Ii.T,"C":Ci.T,"FL":FLi.T},\ ylabel=rarray,xlabel=np.round(Qin_array*86400,decimals=2),myLabels=myLabels); ## PLOTRAN SIMULATION RESULTS minI = np.array([0.00046667, 0.0013 , 0.0048 , 0.012 , 0.00046667, 0.0013 , 0.0048 , 0.012 , 0.00053333, 0.0013 , 0.0048 , 0.012 , 0.00056667, 0.0021 , 0.0053 , 0.012 ]) minC = np.array([2.2514572 , 2.62298917, 3.14213329, 3.51421485, 1.64182175, 2.00913676, 2.52461269, 2.89537637, 0.74130696, 1.0754177 , 1.55071976, 1.90646243, 0.18705258, 0.39222131, 0.73428991, 1.00387133])Qin_array = np.array([0.24,1.0,10.0,100.])/86400. rarray = np.array([5.,10.,40.,100.]) Iarray = 10**np.linspace(-5,0,num=100) Ci = np.zeros([len(rarray),len(Qin_array)]) Ii = np.zeros([len(rarray),len(Qin_array)]) FLi = np.zeros([len(rarray),len(Qin_array)]) i = 0 for qi,Qin in enumerate(Qin_array): for ri,r in enumerate(rarray): worstC = minC[i] worstGradient = minI[i] Ci[ri,qi] = worstC Ii[ri,qi] = worstGradient i += 1 myLabels={"Title": { 0: r"$\bf{-\log (C_{\tau}/C_0)}$", 1: r"$\bf{I}$ (%)", 2: r"$\log(\mathcal{F}_L)$"}, "Y": "Injection flow rate\n$\\bf{Q_{in}}$ (m³/d)", "X": "Setback distance\n$\\bf{r}$ (m)"} threeHeatplots(data={"I":Ii.T,"C":Ci.T,"FL":Ii.T},\ ylabel=rarray,xlabel=np.round(Qin_array*86400,decimals=2),myLabels=myLabels); ```python ```

a177476a37fedabc31c1305b99307bc4db604baf

ipynb

Jupyter Notebook

notebooks/Concepts/Find worst case (1).ipynb

edsaac/bioparticle

67e191329ef191fc539b290069524b42fbaf7e21

notebooks/Concepts/Find worst case (1).ipynb

edsaac/bioparticle

67e191329ef191fc539b290069524b42fbaf7e21

2020-09-25T23:31:21.000Z

2020-09-25T23:31:21.000Z

notebooks/Concepts/Find worst case (1).ipynb

edsaac/VirusTransport_RxSandbox

67e191329ef191fc539b290069524b42fbaf7e21

2021-09-30T05:00:58.000Z

2021-09-30T05:00:58.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__yue_Hant

# Population coding (Pouget et al., 2010) A response of a cell can be characterized by an "encoding model" of the stimulus ($s$): \begin{align} r_{i} = f_{i}(s) + n_{i} \end{align} in which $n$ represents a noise term assumed to follow a normal distribution with a variance proportional to the mean value, $f_{i}(s)$. When the model ("tuning function") is assumed to be gaussian (note to self: is this only for "circular properties" like orientation/motion direction?), it can be written as: \begin{align} f_{i}(s) = ke^{-(s - s_{i})^{2}/2\sigma^{2}} \end{align} ```python import numpy as np import matplotlib.pyplot as plt import seaborn as sns %matplotlib inline def gaussian_model(s, si=100, k=1, sigma=5): """ Computes average activity of cell in response to stimulus `s` given the preferred value `si` and scaling faction `k` and width `sigma`. """ return k * np.exp(-(s - si) ** 2 / (2 * sigma ** 2)) vals = gaussian_model(np.arange(200)) plt.figure(figsize=(8, 3)) plt.plot(vals) plt.xlabel('Stimulus/feature value %s' % '$s_{i}$') plt.ylabel('Activity (a.u.)') sns.despine() plt.show() ``` Now, suppose we have 64 cells that fire according to differently tuned tuning functions: ```python true_si = np.linspace(-180, 180, 64) true_activity = gaussian_model(s=40, si=true_si, sigma=20) + np.random.normal(0, 0.1, size=true_si.size) plt.scatter(true_si, true_activity) plt.title('Activity of 64 neurons') sns.despine() plt.show() ``` ```python np.exp(5) ``` 148.4131591025766

0b48949c9c68e41163bb566f7d458b7915b27938

ipynb

Jupyter Notebook

population_coding.ipynb

lukassnoek/random_notebooks

d7df507ce2b6949726c29de0022aae2d0dc583ac

2018-05-28T13:45:11.000Z

2021-08-31T11:41:34.000Z

population_coding.ipynb

lukassnoek/random_notebooks

d7df507ce2b6949726c29de0022aae2d0dc583ac

population_coding.ipynb

lukassnoek/random_notebooks

d7df507ce2b6949726c29de0022aae2d0dc583ac

2018-05-28T13:46:05.000Z

2018-06-11T15:25:59.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Chapter 3: Linear Regression - **Chapter 3 from the book [An Introduction to Statistical Learning](https://www.statlearning.com/).** - **By Gareth James, Daniela Witten, Trevor Hastie and Rob Tibshirani.** - **Pages from $120$ to $121$** - **By [Mosta Ashour](https://www.linkedin.com/in/mosta-ashour/)** **Exercises:** - **[1.](#1)** - **[2.](#2)** - **[3.](#3)** - **[4.](#4)** - **[5.](#5)** - **[6.](#6)** - **[7.](#7)** # <span style="font-family:cursive;color:#0071bb;"> 3.7 Exercises </span> ## <span style="font-family:cursive;color:#0071bb;"> Conceptual </span> <a id='1'></a> ### $1.$ Describe the null hypotheses to which the $\text{p-values}$ given in Table 3.4 correspond. Explain what conclusions you can draw based on these p-values. Your explanation should be phrased in terms of <span style="font-family:cursive;color:red;"> $sales, TV, radio,$ </span> and <span style="font-family:cursive;color:red;"> $newspaper,$ </span> rather than in terms of the coefficients of the linear model. - **The null hypothesis in this case are:** - That there is no relationship between amount spent on $TV, radio, newspaper$ advertising and $Sales$ $$H_{0}^{(TV)}: \beta_1 = 0$$ $$H_{0}^{(radio)}: \beta_2 = 0$$ $$H_{0}^{(newspaper)}: \beta_3 = 0$$ - From the **p-values** above, it does appear that $TV$ and $radio$ have a significant impact on sales and not $newspaper$. - The **p-values** given in table 3.4 suggest that we **can reject** the null hypotheses for $TV$ and $newspaper$ and we **can't reject** the null hypothesis for $newspaper$. - It seems likely that there is a relationship between TV ads and Sales, and radio ads and sales and not $newspaper$. <a id='2'></a> ### $2.$ Carefully explain the differences between the $\text{KNN}$ classifier and $\text{KNN}$ regression methods. - **$\text{KNN}$ classifier methods** - Attempts to predict the **class** to which the output variable belong by computing the local probability and determines a decision boundary `"typically used for qualitative response, classification problems"`. - **$\text{KNN}$ regression methods** - Tries to predict the **value** of the output variable by using a local average `"typically used for quantitative response, regression problems"`. <a id='3'></a> ### $3.$ Suppose we have a data set with five predictors, $X_1 = GPA$, $X_2 = IQ$, $X_3 = Gender$ (1 for Female and 0 for Male), $X_4 = \text{Interaction between GPA and IQ}$, and $X_5 = \text{Interaction between GPA and Gender}$. The response is starting salary after graduation (in thousands of dollars). Suppose we use least squares to fit the model, and get $\hat{β_0} = 50, \hat{β_1} = 20 , \hat{β_2} = 0.07 , \hat{β_3} = 35 , \hat{β_4} = 0.01 , \hat{β_5} = −10$ . **$(a)$** Which answer is correct, and why? - $i.$ For a fixed value of IQ and GPA, males earn more on average than females. - $ii.$ For a fixed value of IQ and GPA, females earn more on average than males. - **$iii.$ For a fixed value of IQ and GPA, males earn more on average than females provided that the GPA is high enough.** - $iv.$ For a fixed value of IQ and GPA, females earn more on average than males provided that the GPA is high enough. ### Answer: - The least square line is given by: $$\hat{y}=50+20GPA+0.07IQ+35Gender+0.01GPA×IQ−10GPA×Gender$$ - For males: $$\hat{y}=50+20GPA+0.07IQ+0.01GPA×IQ$$ - For females: $$\hat{y}=85+10GPA+0.07IQ+0.01GPA×IQ$$ - So the starting salary for females is higher than Males by `$35`, but on average males earn more than females if GPA is higher than 3.5: $$50 + 20GPA \geq 85 + 10GPA$$ $$10GPA \geq 35$$ $$GPA \geq 3.5$$ - **Answer iii. is the correct one** **(b)** Predict the salary of a **female** with **IQ of 110** and a **GPA of 4.0** ```python gpa, iq, gender = 4, 110, 1 ls = 50 + 20*gpa + 0.07*iq + 35*gender + 0.01*gpa*iq + (-10*gpa*gender) print('$', ls * 1000) ``` $ 137100.0 **$(c)$** **True or false:** Since the coefficient for the $GPA/IQ$ interaction term is very small, there is very little evidence of an interaction effect. Justify your answer. - **False**. the interaction effect might be small but to verify if the $GPA/IQ$ has an impact on the quality of the model we need to test the null hypothesis $H_0:\hat{\beta_4}=0$ and look at the **p-value** associated with the $\text{t-statistic}$ or the $\text{F-statistic}$ to reject or not reject the null hypothesis. <a id='4'></a> ### $4.$ I collect a set of data (n = 100 observations) containing a single predictor and a quantitative response. I then fit a linear regression model to the data, as well as a separate cubic regression, i.e. $Y = β_0 + β_1X + β_2X^2 + β_3X^3 + \epsilon$ **$(a)$** Suppose that the true relationship between $X$ and $Y$ is linear, i.e. $Y = β_0 + β_1X + ε$. Consider the training residual sum of squares ($RSS$) for the linear regression, and also the training $RSS$ for the cubic regression. Would we expect one to be lower than the other, would we expect them to be the same, or is there not enough information to tell? Justify your answer. - Without knowing more details about the training data, it is difficult to know which training $RSS$ is lower between linear or cubic. - However, We would expect the training $RSS$ for the **cubic model to be lower than the linear model** because it is more flexible which allows it to fit more closely variance in the training data despite the true relationship between $X$ and $Y$ is linear. **$(b)$** Answer (a) using test rather than training $RSS$. - We would expect the test $RSS$ for the **linear model to be lower than the cubic model** because The cubic model is more flexible, and so is likely to overfit the training data and would have more error than the linear regression. **$(c)$** Suppose that the true relationship between $X$ and $Y$ is not linear, but we don't know how far it is from linear. Consider the training $RSS$ for the linear regression, and also the training $RSS$ for the cubic regression. Would we expect one to be lower than the other, would we expect them to be the same, or is there not enough information to tell? Justify your answer. - We would expect the training $RSS$ for the **cubic model to be lower than the linear model** because because of the cubic model flexibility. **$(d)$** Answer (c) using test rather than training RSS. - **There is not enough information to tell.** - **Cubic would be lower if:** - The true relationship between $X$ and $Y$ is not linear and there is low noise in our training data. - **Linear would be lower if:** - The relationship is only slightly non-linear or the noise in our training data is high. <a id='5'></a> ### $5.$ Consider the fitted values that result from performing linear regression without an intercept. In this setting, the i-th fitted value takes the form: $$\hat{y_i} = x_i \hat{\beta},$$ $where$ $$\hat{\beta} = \bigg(\sum_{i=1}^{n}x_i y_i\bigg) \bigg/ \bigg(\sum_{i'=1}^{n}x_{i'}^2\bigg)$$ Show that we can write $$\hat{y_i} = \sum_{i'=1}^n a_{i'} y_{i'}$$ What is $a_{i'}$? *Note: We interpret this result by saying that the fitted values from linear regression are linear combinations of the response values.* $$\hat{y_i} = x_i \frac{\sum_{i=1}^{n}x_i y_i} {\sum_{i'=1}^{n} x_{i'}^2}$$ $$\hat{y_i} = \frac{\sum_{i'=1}^{n}x_i x_i' } {\sum_{i''=1}^{n} x_{i''}^2}y_i$$ - $Where$ $$\hat{y_i} = \sum_{i'=1}^n a_{i'} y_{i'}$$ - $So$ $$a_{i'} = \frac{x_i x_i' } {\sum_{i''=1}^{n} x_{i''}^2}$$ <a id='6'></a> ### $6.$ Using $(3.4)$, argue that in the case of simple linear regression, the least squares line always passes through the point $(\bar{x}, \bar{y})$. The least square line equation is $\hat{y}=\hat{\beta}_0+\hat{\beta}_1 x$, prove that when $x=\bar{x}$, $\hat{y} = \bar{y}$ $\text{When } x=\bar{x}$ $$\hat{y}=\hat{\beta}_0+\hat{\beta}_1 \bar{x}$$ $Where$ $$\hat{\beta}_0 = \bar{y} - \hat{\beta}_1 \bar{x}$$ $So$ $$\hat{y}=\bar{y} - \hat{\beta}_1 \bar{x}+\hat{\beta}_1 x$$ $$\hat{y}=\bar{y}$$ <a id='7'></a> ### $7.$ It is claimed in the text that in the case of simple linear regression of $Y$ onto $X$, the $R^2$ statistic $(3.17)$ is equal to the square of the correlation between $X$ and $Y$ (3.18). Prove that this is the case. For simplicity, you may assume that $\bar{x} = \bar{y}= 0$. **Proposition**: Prove that in case of simple linear regression: $$ y = \beta_0 + \beta_1 x + \varepsilon $$ the $R^2$ is equal to correlation between $X$ and $Y$ squared, e.g.: $$ R^2 = corr^2(x, y) $$ We'll be using the following definitions to prove the above proposition. **Def**: $$ R^2 = 1- \frac{RSS}{TSS} $$ **Def**: $$ RSS = \sum (y_i - \hat{y}_i)^2 \label{RSS} $$ **Def**: $$ TSS = \sum (y_i - \bar{y})^2 \label{TSS} $$ **Def**: $$ \begin{align} corr(x, y) &= \frac{\sum (x_i - \bar{x}) (y_i - \bar{y})} {\sigma_x \sigma_y} \\ \sigma_x^2 &= \sum (x_i - \bar{x})^2 \\ \sigma_y^2 &= \sum (y_i - \bar{y})^2 \end{align} $$ **Proof**: Substitute defintions of TSS and RSS into $R^2$: $$ R^2 = 1-\frac{\sum (y_i - \hat{y}_i)^2} {\sum y_i^2} $$ Recall that: $$ \begin{align} \hat{\beta}_0 &= \bar{y} - \hat{\beta}_1 \bar{x} \label{beta0} \\ \hat{\beta}_1 &= \frac{\sum (x_i - \bar{x})(y_i - \bar{y})} {\sum (x_i - \bar{x})^2} \end{align} $$ Substitute the expression for $\hat{\beta}_0$ into $\hat{y}_i$: And with $\bar{x} = \bar{y} = 0$ $$ \begin{align} \hat{y}_i &= \hat{\beta}_1 x_i \\ \hat{y}_i &= \frac{\sum x_i y_i} {\sum x_i^2} \end{align} $$ $Then$ $$ \begin{align} R^2 &= 1-\frac{\sum (y_i - \frac{\sum x_i y_i} {\sum x_i^2})^2} {\sum y_i^2}\\ &= \frac{\sum{y_i^2} -2\sum y_i (\frac{\sum x_i y_i} {\sum x_i^2})x_i+\sum(\frac{\sum x_i y_i} {\sum x_i^2})^2 x_i^2)} {\sum y_i^2}\\ &= \frac{\frac{2(\sum x_i y_i)^2}{\sum x_i^2} - \frac{(\sum x_i y_i)^2}{\sum x_i^2}}{\sum y_i^2}\\ &= \frac{(\sum x_i y_i)^2}{\sum x_i^2 \sum y_i^2} \end{align} $$ $ \text{with } \bar{x} = \bar{y} = 0$ $ \begin{align} corr(x, y) &= \frac{\sum x_i y_i} {\sum x_i^2 \sum y_i^2} = R^2 \end{align} $ ## Done!

c6ebbb18afb794aaf3ca5d40e74dd5810524fe50

ipynb

Jupyter Notebook

Notebooks/3_7_0_Linear_Regression_Conceptual.ipynb

MostaAshour/ISL-in-python

87255625066f88d5d4625d045bdc6427a4ad9193

Notebooks/3_7_0_Linear_Regression_Conceptual.ipynb

MostaAshour/ISL-in-python

87255625066f88d5d4625d045bdc6427a4ad9193

Notebooks/3_7_0_Linear_Regression_Conceptual.ipynb

MostaAshour/ISL-in-python

87255625066f88d5d4625d045bdc6427a4ad9193

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Fractal drum Nori Parelius This project was a part of an exam in Computational Physics that I took in May 2015. At the time I used Fortran to solve it, but I have since rewritten it in Matlab and now Python. The project is about finding the eigenvalues and eigenvectors of a "fractal drum" - a thin membrane stretched on a frame with a fractal shaped border. The fractal is a square Koch fractal. Oscillations of this drum's membrane follow the wave equation \begin{equation} \nabla^2 u=\frac{1}{v^2}\frac{\partial^2 u}{\partial t^2}, \end{equation} with $u$ being the displacement, $v$ velocity and $t$ time. The value of $u$ at the boundary (where the membrane is attached to the frame) is always 0. Fourier transforming the wave equation over time gives the Helmholtz equation: \begin{equation} -\nabla^2U(\vec{x},\omega)=\frac{\omega^2}{v^2}U(\vec{x},\omega), \quad \rm{in}\ \Omega, \end{equation} where $U$ is the Fourier transform of $u$ and $\omega$ is angular frequency. And for the Dirichlet boundary condition $u=0$ \begin{equation} U(\vec{x},\omega)=0, \quad \rm{on}\ \partial \Omega \end{equation} Using a finite difference approximation for the Laplacian operator, the Helmholtz equation is transformed into a form \begin{equation} LU=\frac{\omega^2}{v^2}U \end{equation} where $L$ is a matrix generated from the Laplacian operator and taking into account the boundary conditions and $U$ is a vector containing the displacements for each point within the boundary. This equation is an eigenvalue problem which means that matrix $L$ can be used to find eigenvalues $\omega^2/v^2$ and corresponding eigenvectors $U$ for which the equation is true. To find the eigenvalues, several steps have to be taken. First the shape of the fractal boundary has to be generated and positioned onto a spatial grid so that all the corners in the boundary fall onto grid points. Then it is necessary to find out which grid points are within the boundary and which are outside, as only the points inside will be a part of the vector $U$ from the eigenvalue problem. The matrix $L$ is then generated from the finite difference scheme for the Laplace operator and using the boundary conditions. The last step is to solve the eigenvalue problem. ## 1. Creating the fractal border on a grid ### Importing libraries ```python import numpy as np import scipy as sc import matplotlib.pyplot as plt %matplotlib inline ``` ### Making the fractal shape The fractal border is created by first defining a square, given by the coordinates of its corners. Function FRACTAL takes the coordinates of two points and creates a Koch square fractal from the line. It returnes the coordinates of the corners of this fractal. Function FRACTALIZE then uses function FRACTAL to do this for several connected lines, such as the starting square. The function FRACTALIZE applies the "fractalization" f_level times. ```python # length of the side L_side=4.0 # position of top left corner LT=[5.0,9.0] # number of times the initial square will be "fractalized" f_level=2 ``` ```python # Initializing the square corners=np.zeros((5,2)) corners[0,:]=LT corners[1,:]=[corners[0,0]+L_side,corners[0,1]] corners[2,:]=[corners[0,0]+L_side,corners[0,1]-L_side] corners[3,:]=[corners[0,0],corners[0,1]-L_side] corners[4,:]=corners[0,:] plt.plot(corners[:,0],corners[:,1]) ``` ```python def fractal(A,B): ''' FUNCTION FRACTAL takes as input the coordinates of two points A and B, 2D only, and they should either have the same x or y coordinate. And returns an array of points that give the Koch fractal shape ''' f=np.zeros((9,2)); f[0,:]=A f[8,:]=B if abs(A[0]-B[0]) > abs(A[1]-B[1]): # horizontal c=1.0 else: # vertical c=-1.0 # Points on the line connecting A and B step=1; # how far from A we are stepping, for first point 1 step, then 2 for i in [1,4,7]: # which point in f it is for coor in range(2): # which coordinate, x or y f[i,coor]=A[coor]+step*(B[coor]-A[coor])/4.0 step=step+1 # Points on the line to one direction step=1; for i in range(2,4,1): f[i,0]=A[0]+step*(B[0]-A[0])/4.0+c*(B[1]-A[1])/4.0 f[i,1]=A[1]+step*(B[1]-A[1])/4.0+c*(B[0]-A[0])/4.0 step=step+1 # Points on the line to the other direction step=2; for i in range(5,7,1): f[i,0]=A[0]+step*(B[0]-A[0])/4.0-c*(B[1]-A[1])/4.0 f[i,1]=A[1]+step*(B[1]-A[1])/4.0-c*(B[0]-A[0])/4.0 step=step+1 return f ``` #### Example of a Koch fractal ```python new_fractal=fractal(corners[0,:],corners[1,:]) plt.plot(new_fractal[:,0],new_fractal[:,1]) ``` ```python def fractalize(corners,f_level): ''' Function that takes an array containing coordinates of corners of a closed shape (first and last corner the same) and fractalizes each segment f_level number of times ''' for k in range(f_level): n_sides=corners.shape[0]-1; corn=np.zeros((8*(n_sides-1)+9,2)) corn[0,:]=corners[0,:] for i in range(1,n_sides+1): corn_new=fractal(corners[i-1,:],corners[i,:]) corn[(8*(i-1)):(8*i+1),:]=corn_new corners=corn return corners ``` #### Fractalizing ```python f=fractalize(corners,f_level) fig, axes=plt.subplots(nrows=1,ncols=3,figsize=(12,3)) axes[0].plot(corners[:,0],corners[:,1]) axes[1].plot(fractalize(corners,1)[:,0],fractalize(corners,1)[:,1]) axes[2].plot(f[:,0],f[:,1]) for ax in axes: ax.set_aspect('equal') ``` ### Grid to put the drum on I created a square lattice that the border will be positioned on. This lattice is the minimum size necessary to cover the whole border structure. This means that the edge of the lattice is further out from the initial square box. This grid offset depends on $l$. For each $l$ the fractal border is moved outside by $L\_side/4$ where length is the length of the side at previous $l$. This adds up to $L\_side/4+L\_side/4^2+L\_side/4^3+...L\_side/4^f\_level$, where $L\_side$ is the length of the side of the initial box. One grid constant $\delta$ was added to the offset. Grid constant $\delta$ was chosen depending on the desired $f\_level$. If each corner of the fractal border is supposed to fall onto a grid point for any $f\_level<f\_level_{max}$ then \begin{equation} \delta=\frac{L\_side}{4^{f\_level_{max}}}. \end{equation} In addition, for $f\_level=1$ with this grid spacing (meaning corners on the grid but no additional grid points between them), there would be only one point within the boundaries. For $f\_level>1$ this is not the case any more, but I have anyway defined a variable which allows to add grid points so that the grid is more dense than the corners of fractal shape. \begin{equation} \delta=\frac{L\_side}{4^{f\_level_{max}}(points\_between+1)}, \end{equation} where $n_{points\_between}$ is the number of added points between, not including, the corners. As a result, I had to make a routine that would add these points to my array of corners and create an array containing all the edge points. ```python # Grid parameters # number of grid points between corner points points_between=1 # With each iteration, the border grows by 1/4 of L_side grid_offset=np.sum(L_side/4**(np.arange(1,f_level+1))) # Step of the grid, so that points between fall on it too delta= L_side/(4**f_level)/(points_between+1) # Origin of the grid, with the offset and with adding one point at the edge grid_origin=[LT[0]-grid_offset-delta,LT[1]+grid_offset+delta] # Number of grid points in both directions n_grid=int((L_side+2*grid_offset+2*delta)/delta+1) ``` #### Adding more points between the corners, on the grid ```python def fill_edges(corners,MP): ''' Function that takes the corners and adds a given number (MP) of points between them, to fill out all the grid points that have an edge ''' n_points=corners.shape[0] n_sides=n_points-1 edges=np.zeros((n_points+n_sides*MP,2)) for i in range(n_sides): for coor in range(2): # x y coordinates edges[((MP+1)*i):((MP+1)*(i+1)+1),coor]=corners[i,coor]+(corners[i+1,coor]-corners[i,coor])/(MP+1)*range(MP+2) return edges ``` ```python # Filling in the edges edges=fill_edges(f,points_between) plt.plot(edges[:,0],edges[:,1],marker='o') ``` ## Identifying border, inside and outside grid points To know which points are inside and which points are outside, I have created a mask, a two dimensional array of the same size as the grid, that for each point given its position in the array $mask(i,j)$ holds a value defining whether the point is in, out or on the border of the drum. The $mask$ for boundary points is -1, for points outside it is -2 and for points inside it holds the index of the point - from 0 to # points inside -1. ```python # Grid x=grid_origin[0]+delta*np.arange(n_grid) y=grid_origin[1]-delta*np.arange(n_grid) ``` First function MASK_EDGES sets in the first step all the mask to -2. Next, using the coordinates(x, y) of the edge points the $mask$ is set to -1 for these edge points. The positions (i, j) of these points in the $mas$k were found by rearranging the equation that generated the physical coordinates x and y, \begin{equation} x=A_x+(i-1)\delta \quad \rm{and}\ y=A_y-(j-1)\delta. \end{equation} Where $A_x$ and $A_y$ are the x and y coordinates of the top left corner of the grid. ```python def mask_edges(n_grid,delta,LeftTop,edges): ''' FUNCTION MASK_EDGES creates an array the size of the grid (n_grid) and puts its value to -1 everywhere, except for the points that belong to the edges, which are 0, this is calculated by using the (x,y) coordinates of the edges give in edges x=LTx+(i-1)delta --> i=(x-LTx)/delta +1 y=LTy-(j-1)delta --> j=-(y-LTy)/delta +1 ''' me=-2*np.ones((n_grid,n_grid)) for point in range(edges.shape[0]-1): me[int((edges[point,0]-LeftTop[0])/delta), int((LeftTop[1]-edges[point,1])/delta)]=0 return me ``` Function INSIDE cycles through each of the points of the grid checking whether the point is inside the polygon.The algorithm consists of deciding how many times a horizontal line passing through the point in question crosses a side of the polygon on the left and on the right of the point. If the number of intersections to the left and to the right is odd, than the point is inside the polygon. This procedure does not give clear results for the points that are right on the boundary, but these points are already known from the initial mask returned by MASK_EDGES. ```python def point_in_polygon(e,P): ''' FUNCTION POINT_IN_POLYGON takes as input the coordinates of the edge points and the coordinates of the point in question P and returns a boolean p depending on whether the point is inside the polygon or not. Using the number of times a horizontal line passing through the point crosses some segment ''' x=P[0] y=P[1] p=False n_corners=e.shape[0]-1 j=n_corners-1 for i in range(n_corners): #it is horizontally between the end points if e[i,1]<y and e[j,1] >= y or e[j,1]<y and e[i,1]>=y: #whether x is right of the segment if e[i,0]+(y-e[i,1])/(e[j,1]-e[i,1])*(e[j,0]-e[i,0])<x: p=not p j=i return p ``` ```python def inside(edges,x,y,mask): ''' FUNCTION INSIDE takes the edge points, the x and y points of the grid and the mask with the edges being 0, rest being -1. It uses point_in_polygon to find out if the point is in or out and then sets insides to numbers 1 and upwards (counting them), edge to 0 and outside to -1 ''' n_grid=x.shape[0] me=np.zeros((n_grid,n_grid)) n_inside=0 for i in range(n_grid): for j in range(n_grid): # Find if it's in (1) or out (0) me[i,j]=point_in_polygon(edges,[x[i],y[j]]) # If it's out, set it to -2, # if it's in, number it and count it if me[i,j]==0: # out me[i,j]=-2 # If it corresponds to an edge point, set it to -1 if mask[i,j]==-1: me[i,j]=-1 else: # in # If it corresponds to an edge point, set it to -1 if mask[i,j]==-1: me[i,j]=-1 else: me[i,j]=n_inside; n_inside=n_inside+1; return me,n_inside ``` ```python from matplotlib import cm # First all -1, edges 0 mask1=mask_edges(n_grid,delta,grid_origin,edges) X, Y = np.meshgrid(x, y) fig, ax = plt.subplots() ax.pcolormesh(X,Y,mask1,cmap=cm.coolwarm) ``` ```python mask,n_in=inside(edges,x,y,mask1) fig, ax = plt.subplots() ax.contourf(X,Y,mask) ``` ```python ``` ### The Laplacian matrix By using a Taylor expansion on the Laplace operator, we get \begin{equation} -\nabla^2u(x,y) \approx \frac{1}{\delta^2}(4u(x,y)-u(x-\delta,y)-u(x+\delta,y)-u(x,y-\delta)-u(x,y+\delta)). \end{equation} Applying this to the discretized x and y, with step $\delta$ leads to the 5-point central finite difference approximation of the Laplace, and this gives for our eigenvalue matrix equation ($LU=\frac{\omega^2}{v^2}U$): \begin{equation} 4u_{i,j}-u_{i-1,j}-u_{i+1,j}-u_{i,j-1}-u_{i,j+1}=\omega^2/v^2\ \delta^2 u_{i,j}. \end{equation} This equation can be turned into a matrix equation \begin{equation} \frac{1}{\delta^2}L\ V=\frac{\omega^2}{v^2}V, \end{equation} where $V=[V_k]$ is a vector that holds values $u_{i,j}$ for i,j such that the corresponding point is within the fractal boundary, and $L$ is a matrix that has the value 4 on its diagonal and up to four times the value -1 in each row i, depending on whether the neigbouring points of $u_{i,i}$ are inside the boundary, or not. This means that the matrix $L$ has to be constructed with the shape of the boundary taken into account. To construct the matrix, I have created an array $n2grid$ that allows to turn the index of the drum point (the number held by the $mask$) into its position on the grid. ```python # Vector containing the grid coordinates of each point on the inside, n2grid=np.zeros((n_in,2)) for i in range(n_grid): for j in range(n_grid): if mask[i,j]>=0: n2grid[int(mask[i,j]),:]=[i,j] ``` ```python def matrix_laplace(mask,n2grid,n_in,delta): ''' FUNCTION LAP_MAT returns the Laplacian matrix for the points inside the drum ''' mat_lap=np.zeros((n_in,n_in)) for i in range(n_in): # one row of the laplacian at a time mat_lap[i,i]=4.0/delta**2 # the diagonal is 4 for ii in [-1,1]: if mask[int(n2grid[i,0]+ii),int(n2grid[i,1])]>=0: # if the neighbour at x+-1 is inside the drum mat_lap[i,int(mask[int(n2grid[i,0]+ii),int(n2grid[i,1])])]=-1.0/delta**2 if mask[int(n2grid[i,0]),int(n2grid[i,1]+ii)]>=0: # same for y dir mat_lap[i,int(mask[int(n2grid[i,0]),int(n2grid[i,1]+ii)])]=-1.0/delta**2 return mat_lap ``` ```python # Creating the Laplacian laplace=matrix_laplace(mask,n2grid,n_in,delta) ``` ### Solving the eigenvalue problem ```python # Getting the eigenvalues and eigenvectors eigenval,evec=np.linalg.eig(laplace) # Sorting them from lowest to largest idx = eigenval.argsort() eigenval = eigenval[idx] evec = evec[:,idx] ``` ```python # First five eigenvalues print(eigenval[0:4]) ``` [4.27736565 8.42218947 8.42218947 8.74559167] ```python U=np.zeros((n_grid,n_grid,5)) for n in range(5): for i in range(n_in): U[int(n2grid[i,0]),int(n2grid[i,1]),n]=evec[i,n] ``` ### The plots of the first 5 vibrational modes The following plots show the first five eigenvectors plotted onto the grid. These represent the displacement of each drum points, so we are basically looking at how the drum membrane would physically move. The real life vibration would be a combination of these and other modes. ```python from mpl_toolkits.mplot3d import Axes3D fig=plt.figure(figsize=(5,25)) X, Y = np.meshgrid(x, y) # Plot the surface. for i in range(5): ax[i]= fig.add_subplot(5,1,i+1, projection='3d') ax[i].plot_surface(X, Y, U[:,:,i],rstride=1,cstride=1, cmap=cm.YlOrRd, linewidth=0, antialiased=False,alpha=0.5) ax[i].plot_surface(X,Y,0.001*mask1,rstride=1,cstride=1,cmap=cm.Blues,linewidth=0, antialiased=False,alpha=0.5) ax[i].set_xlabel("X") ax[i].set_ylabel("Y") ax[i].set_zlabel("U") ``` ```python ``` ```python ```

1898c47ea4930716f400fc8a643fd3be6227d52a

ipynb

Jupyter Notebook

fractal drum.ipynb

nori-parelius/fractal-drum

92c3c816a0d7a4dc6634e4bc82621e05052cce9b

fractal drum.ipynb

nori-parelius/fractal-drum

92c3c816a0d7a4dc6634e4bc82621e05052cce9b

fractal drum.ipynb

nori-parelius/fractal-drum

92c3c816a0d7a4dc6634e4bc82621e05052cce9b

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Нотация Денавита-Хартенберга ```python from sympy import * def rz(a): return Matrix([ [cos(a), -sin(a), 0, 0], [sin(a), cos(a), 0, 0], [0, 0, 1, 0], [0, 0, 0, 1] ]) def ry(a): return Matrix([ [cos(a), 0, sin(a), 0], [0, 1, 0, 0], [-sin(a), 0, cos(a), 0], [0, 0, 0, 1] ]) def rx(a): return Matrix([ [1, 0, 0, 0], [0, cos(a), -sin(a), 0], [0, sin(a), cos(a), 0], [0, 0, 0, 1] ]) def trs(x, y, z): return Matrix([ [1, 0, 0, x], [0, 1, 0, y], [0, 0, 1, z], [0, 0, 0, 1] ]) def vec(x, y, z): return Matrix([ [x], [y], [z], [1] ]) ``` Если соединить матрицы и винтовое исчисление, одним из результатов будет нотация Денавита-Хартенберга. Она подразумевает четыре последовательных преобразовния: $$ DH(\theta, d, \alpha, a) = R_z(\theta) T_z(d) R_x(\alpha) T_z(a) $$ ```python def dh(theta, d, alpha, a): return rz(theta) * trs(0, 0, d) * rx(alpha) * trs(a, 0, 0) ``` ```python theta, d, alpha, a = symbols("theta_i, d_i, alpha_i, a_i") simplify(dh(theta, d, alpha, a)) ``` DH-параметры описывают последовательные - поворот вокруг оси $Z$ - $\theta$ - смещение вдоль оси $Z$ - $d$ - поворот вокруг новой оси $X$ - $\alpha$ - смещение вдоль новой оси $X$ - $r$ Обобщенные координаты выбираются так, чтобы попадать на вращение вокруг / смещение вдоль оси $Z$.

35dff3d0c15a3fd12a87713c721c51843dc68a5b

ipynb

Jupyter Notebook

3 - DH notation.ipynb

red-hara/jupyter-dh-notation

0ffd305b3e67ce7dd3c20f2d1c719b53251dbf58

3 - DH notation.ipynb

red-hara/jupyter-dh-notation

0ffd305b3e67ce7dd3c20f2d1c719b53251dbf58

3 - DH notation.ipynb

red-hara/jupyter-dh-notation

0ffd305b3e67ce7dd3c20f2d1c719b53251dbf58

Qwen/Qwen-72B

1. YES 2. YES

__label__krc_Cyrl

# Improving predictive models using non-spherical Gaussian priors Based on the CNN abstract of [Nunez-Elizalde, Huth, & Gallant](https://www2.securecms.com/CCNeuro/docs-0/5928d71e68ed3f844e8a256f.pdf). ``` import numpy as np import matplotlib.pyplot as plt import seaborn as sns from scipy.stats import pearsonr from scipy.linalg import toeplitz from sklearn.model_selection import KFold from sklearn.linear_model import Ridge, RidgeCV, LinearRegression from sklearn.preprocessing import StandardScaler from sklearn.pipeline import Pipeline from tqdm import tqdm_notebook %matplotlib inline ``` First, let's generate some data with 100 ($N$) samples and 500 ($K$) features. We'll generate the true parameters ($\beta$), for which we'll calculate the covariance matrix ($\Sigma$). ``` N, K = 100, 500 X = np.random.normal(0, 1, (N, K)) X = np.c_[np.ones(N), X] mu_betas = np.zeros(K+1) cov_betas = 0.99**toeplitz(np.arange(0, K+1)) betas = np.random.multivariate_normal(mu_betas, cov_betas).T plt.figure(figsize=(10, 5)) plt.subplot(1, 2, 1) plt.imshow(cov_betas) plt.title(r'$\mathrm{true\ cov}[\beta]$') plt.subplot(1, 2, 2) plt.plot(betas) plt.title(r'$\mathrm{true}\ \beta$') sns.despine() plt.show() noise = np.random.normal(0, 1, size=N) y = X.dot(betas) + noise ``` ### Standard linear regression (no regularization) ``` folds = KFold(n_splits=10) pipe = Pipeline([ ('scaler', StandardScaler()), ('model', LinearRegression()) ]) scores = np.zeros(10) for i, (train_idx, test_idx) in enumerate(folds.split(X, y)): pipe.fit(X[train_idx], y[train_idx]) scores[i] = pipe.score(X[test_idx], y[test_idx]) print(scores, end='\n\n') print("R2: %3f. (%.3f)" % (scores.mean(), scores.std())) ``` [-0.17506196 -0.20438521 0.69783125 -0.34696657 0.36056441 0.34926236 -0.50402675 0.05336731 0.13129403 0.30056921] R2: 0.066245. (0.354) ### Ridge ``` folds = KFold(n_splits=10) pipe = Pipeline([ ('scaler', StandardScaler()), ('model', RidgeCV(alphas=[0.001, 0.01, 0.1, 1, 10, 100, 1000])) ]) scores = np.zeros(10) for i, (train_idx, test_idx) in enumerate(folds.split(X, y)): pipe.fit(X[train_idx], y[train_idx]) preds = pipe.predict(X[test_idx]) scores[i] = pipe.score(X[test_idx], y[test_idx]) print(scores, end='\n\n') print("R2: %3f. (%.3f)" % (scores.mean(), scores.std())) ``` [-0.05012806 -0.29239414 0.50244766 -0.15503275 0.31898809 0.29825579 -0.37950182 -0.04080342 0.13129442 0.25450183] R2: 0.058763. (0.274) ### Tikhonov The traditional solution for Tikhonov regression, for any design matrix $X$ and reponse vector $y$, is usually written as follows: \begin{align} \hat{\beta} = (X^{T}X + \lambda C^{T}C)^{-1}X^{T}y \end{align} in which $C$ represents the penalty matrix (i.e., $\Sigma^{-\frac{1}{2}}$) and $\lambda$ the regularization parameter. In this formulation, the prior on the model is that $\beta$ is distributed with zero mean and $(\lambda C^{T}C)^{-1}$ covariance. Alternatively, the estimation of the parameters ($\beta$) can be written as: \begin{align} \hat{\beta} = C^{-1}(A^{T}A + \lambda I)^{-1}X^{T}y \end{align} with $A$ defined as: \begin{align} A = XC^{-1} \end{align} Let's define a scikit-learn style class for generic Tikhonov regression: ``` from scipy.linalg import sqrtm from sklearn.base import BaseEstimator, RegressorMixin from scipy.linalg import svd class Tikhonov(BaseEstimator, RegressorMixin): def __init__(self, sigma, lambd=1.): self.sigma = sigma self.lambd = lambd def fit(self, X, y, sample_weight=None): sig = self.sigma self.coef_ = np.linalg.inv(X.T @ X + self.lambd * np.linalg.inv(sig)) @ X.T @ y return self def predict(self, X, y=None): return X.dot(self.coef_) class Tikhonov2(BaseEstimator, RegressorMixin): def __init__(self, sigma, lambd=1.): self.sigma = sigma self.lambd = lambd self.C = sqrtm(self.sigma) def fit(self, X, y, sample_weight=None): A = X @ self.C I = np.eye(X.shape[1]) self.coef_ = np.linalg.inv(A.T @ A + self.lambd * I) @ A.T @ y return self def predict(self, X, y=None): A = X.dot(self.C) return A.dot(self.coef_) ``` Now, let's run our (cross-validated) Tikhonov regression: ``` from sklearn.model_selection import GridSearchCV folds = KFold(n_splits=10) tik2 = Tikhonov(sigma=cov_betas) gs = GridSearchCV(estimator=tik2, param_grid=dict(lambd=[0.01, 0.1, 1, 10, 100]), cv=3) pipe = Pipeline([ ('scaler', StandardScaler()), ('model', gs) ]) scores = np.zeros(10) for i, (train_idx, test_idx) in tqdm_notebook(enumerate(folds.split(X, y))): pipe.fit(X[train_idx], y[train_idx]) preds = pipe.predict(X[test_idx]) scores[i] = pipe.score(X[test_idx], y[test_idx]) print(scores, end='\n\n') print("R2: %3f. (%.3f)" % (scores.mean(), scores.std())) plt.plot(betas) plt.plot(gs.best_estimator_.coef_) ``` ``` from sklearn.model_selection import GridSearchCV folds = KFold(n_splits=10) tik2 = Tikhonov2(sigma=cov_betas) gs = GridSearchCV(estimator=tik2, param_grid=dict(lambd=[0.01, 0.1, 1, 10, 100]), cv=3) pipe = Pipeline([ ('scaler', StandardScaler()), ('model', gs) ]) scores = np.zeros(10) for i, (train_idx, test_idx) in tqdm_notebook(enumerate(folds.split(X, y))): pipe.fit(X[train_idx], y[train_idx]) preds = pipe.predict(X[test_idx]) scores[i] = pipe.score(X[test_idx], y[test_idx]) print(scores, end='\n\n') print("R2: %3f. (%.3f)" % (scores.mean(), scores.std())) plt.plot(betas) plt.plot(tik2.C @ gs.best_estimator_.coef_) ``` ## Banded ridge ``` N, K = 200, 500 X = np.random.normal(0, 1, (N, K)) X = np.c_[np.ones(N), X] mu_betas = np.zeros(K+1) I = np.eye(K+1) lambdas = np.r_[1, np.repeat([1, 2], repeats=K//2)].astype(float) cov_betas = lambdas ** -2 * I betas = np.random.multivariate_normal(mu_betas, cov_betas).T plt.figure(figsize=(10, 5)) plt.subplot(1, 2, 1) plt.imshow(cov_betas) plt.title(r'$\mathrm{true\ cov}[\beta]$') plt.subplot(1, 2, 2) plt.plot(betas) plt.title(r'$\mathrm{true}\ \beta$') sns.despine() plt.show() noise = np.random.normal(0, 1, size=N) y = X.dot(betas) + noise ``` ``` class BandedRidge(BaseEstimator, RegressorMixin): def __init__(self, lambd, lambdas): self.lambd = lambd self.lambdas = lambdas def fit(self, X, y, sample_weight=None): I = np.eye(X.shape[1]) I[np.diag_indices_from(I)] = self.lambdas ** 2 self.coef_ = np.linalg.inv(X.T @ X + self.lambd * I) @ X.T @ y return self def predict(self, X, y=None): return X.dot(self.coef_) ``` ``` folds = KFold(n_splits=10) br = BandedRidge(lambd=1, lambdas=lambdas) gs = GridSearchCV(estimator=br, param_grid=dict(lambd=[0.001, 0.01, 0.1, 1, 10, 100, 1000]), cv=3) pipe = Pipeline([ ('scaler', StandardScaler()), ('model', gs) ]) scores = np.zeros(10) for i, (train_idx, test_idx) in tqdm_notebook(enumerate(folds.split(X, y))): pipe.fit(X[train_idx], y[train_idx]) preds = pipe.predict(X[test_idx]) scores[i] = pipe.score(X[test_idx], y[test_idx]) print(scores, end='\n\n') print("R2: %3f. (%.3f)" % (scores.mean(), scores.std())) plt.plot(betas) plt.plot(gs.best_estimator_.coef_) ``` vs. Ridge: ``` folds = KFold(n_splits=10) pipe = Pipeline([ ('scaler', StandardScaler()), ('model', RidgeCV(alphas=[0.01, 0.1, 1, 10, 100, 1000])) ]) scores = np.zeros(10) for i, (train_idx, test_idx) in enumerate(folds.split(X, y)): pipe.fit(X[train_idx], y[train_idx]) preds = pipe.predict(X[test_idx]) scores[i] = pipe.score(X[test_idx], y[test_idx]) print(scores, end='\n\n') print("R2: %3f. (%.3f)" % (scores.mean(), scores.std())) plt.plot(betas) plt.plot(pipe.named_steps['model'].coef_) ``` and standard LR: ``` folds = KFold(n_splits=10) pipe = Pipeline([ ('scaler', StandardScaler()), ('model', LinearRegression()) ]) scores = np.zeros(10) for i, (train_idx, test_idx) in enumerate(folds.split(X, y)): pipe.fit(X[train_idx], y[train_idx]) scores[i] = pipe.score(X[test_idx], y[test_idx]) print(scores, end='\n\n') print("R2: %3f. (%.3f)" % (scores.mean(), scores.std())) ``` [0.53290474 0.39455398 0.32529149 0.61533419 0.42162928 0.5572809 0.13712307 0.07211125 0.53426102 0.39016258] R2: 0.398065. (0.170) Equivalence with scaling: ``` class BandedRidge2(BaseEstimator, RegressorMixin): def __init__(self, lambd, lambdas): self.lambd = lambd self.lambdas = lambdas def fit(self, X, y, sample_weight=None): I = np.eye(X.shape[1]) X /= self.lambdas self.coef_ = np.linalg.inv(X.T @ X + self.lambd * I) @ X.T @ y return self def predict(self, X, y=None): return X.dot(self.coef_) folds = KFold(n_splits=10) br = BandedRidge2(lambd=1, lambdas=lambdas) gs = GridSearchCV(estimator=br, param_grid=dict(lambd=[0.001, 0.01, 0.1, 1, 10, 100, 1000]), cv=3) pipe = Pipeline([ ('scaler', StandardScaler()), ('model', gs) ]) scores = np.zeros(10) for i, (train_idx, test_idx) in tqdm_notebook(enumerate(folds.split(X, y))): pipe.fit(X[train_idx], y[train_idx]) preds = pipe.predict(X[test_idx]) scores[i] = pipe.score(X[test_idx], y[test_idx]) print(scores, end='\n\n') print("R2: %3f. (%.3f)" % (scores.mean(), scores.std())) plt.plot(betas) plt.plot(gs.best_estimator_.coef_) ```

c3b7b450bd447680958cad0684a5c64baeeab36f

ipynb

Jupyter Notebook

tikhonov_regression_with_non_sphrerical_prior.ipynb

lukassnoek/random_notebooks

d7df507ce2b6949726c29de0022aae2d0dc583ac

2018-05-28T13:45:11.000Z

2021-08-31T11:41:34.000Z

tikhonov_regression_with_non_sphrerical_prior.ipynb

lukassnoek/random_notebooks

d7df507ce2b6949726c29de0022aae2d0dc583ac

tikhonov_regression_with_non_sphrerical_prior.ipynb

lukassnoek/random_notebooks

d7df507ce2b6949726c29de0022aae2d0dc583ac

2018-05-28T13:46:05.000Z

2018-06-11T15:25:59.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Direct Inversion of the Iterative Subspace When solving systems of linear (or nonlinear) equations, iterative methods are often employed. Unfortunately, such methods often suffer from convergence issues such as numerical instability, slow convergence, and significant computational expense when applied to difficult problems. In these cases, convergence accelleration methods may be applied to both speed up, stabilize and/or reduce the cost for the convergence patterns of these methods, so that solving such problems become computationally tractable. One such method is known as the direct inversion of the iterative subspace (DIIS) method, which is commonly applied to address convergence issues within self consistent field computations in Hartree-Fock theory (and other iterative electronic structure methods). In this tutorial, we'll introduce the theory of DIIS for a general iterative procedure, before integrating DIIS into our previous implementation of RHF. ## I. Theory DIIS is a widely applicable convergence acceleration method, which is applicable to numerous problems in linear algebra and the computational sciences, as well as quantum chemistry in particular. Therefore, we will introduce the theory of this method in the general sense, before seeking to apply it to SCF. Suppose that for a given problem, there exist a set of trial vectors $\{\mid{\bf p}_i\,\rangle\}$ which have been generated iteratively, converging toward the true solution, $\mid{\bf p}^f\,\rangle$. Then the true solution can be approximately constructed as a linear combination of the trial vectors, $$\mid{\bf p}\,\rangle = \sum_ic_i\mid{\bf p}_i\,\rangle,$$ where we require that the residual vector $$\mid{\bf r}\,\rangle = \sum_ic_i\mid{\bf r}_i\,\rangle\,;\;\;\; \mid{\bf r}_i\,\rangle =\, \mid{\bf p}_{i+1}\,\rangle - \mid{\bf p}_i\,\rangle$$ is a least-squares approximate to the zero vector, according to the constraint $$\sum_i c_i = 1.$$ This constraint on the expansion coefficients can be seen by noting that each trial function ${\bf p}_i$ may be represented as an error vector applied to the true solution, $\mid{\bf p}^f\,\rangle + \mid{\bf e}_i\,\rangle$. Then \begin{align} \mid{\bf p}\,\rangle &= \sum_ic_i\mid{\bf p}_i\,\rangle\\ &= \sum_i c_i(\mid{\bf p}^f\,\rangle + \mid{\bf e}_i\,\rangle)\\ &= \mid{\bf p}^f\,\rangle\sum_i c_i + \sum_i c_i\mid{\bf e}_i\,\rangle \end{align} Convergence results in a minimization of the error (causing the second term to vanish); for the DIIS solution vector $\mid{\bf p}\,\rangle$ and the true solution vector $\mid{\bf p}^f\,\rangle$ to be equal, it must be that $\sum_i c_i = 1$. We satisfy our condition for the residual vector by minimizing its norm, $$\langle\,{\bf r}\mid{\bf r}\,\rangle = \sum_{ij} c_i^* c_j \langle\,{\bf r}_i\mid{\bf r}_j\,\rangle,$$ using Lagrange's method of undetermined coefficients subject to the constraint on $\{c_i\}$: $${\cal L} = {\bf c}^{\dagger}{\bf Bc} - \lambda\left(1 - \sum_i c_i\right)$$ where $B_{ij} = \langle {\bf r}_i\mid {\bf r}_j\rangle$ is the matrix of residual vector overlaps. Minimization of the Lagrangian with respect to the coefficient $c_k$ yields (for real values) \begin{align} \frac{\partial{\cal L}}{\partial c_k} = 0 &= \sum_j c_jB_{jk} + \sum_i c_iB_{ik} - \lambda\\ &= 2\sum_ic_iB_{ik} - \lambda \end{align} which has matrix representation \begin{equation} \begin{pmatrix} B_{11} & B_{12} & \cdots & B_{1m} & -1 \\ B_{21} & B_{22} & \cdots & B_{2m} & -1 \\ \vdots & \vdots & \ddots & \vdots & \vdots \\ B_{n1} & B_{n2} & \cdots & B_{nm} & -1 \\ -1 & -1 & \cdots & -1 & 0 \end{pmatrix} \begin{pmatrix} c_1\\ c_2\\ \vdots \\ c_n\\ \lambda \end{pmatrix} = \begin{pmatrix} 0\\ 0\\ \vdots\\ 0\\ -1 \end{pmatrix}, \end{equation} which we will refer to as the Pulay equation, named after the inventor of DIIS. It is worth noting at this point that our trial vectors, residual vectors, and solution vector may in fact be tensors of arbitrary rank; it is for this reason that we have used the generic notation of Dirac in the above discussion to denote the inner product between such objects. ## II. Algorithms for DIIS The general DIIS procedure, as described above, has the following structure during each iteration: #### Algorithm 1: Generic DIIS procedure 1. Compute new trial vector, $\mid{\bf p}_{i+1}\,\rangle$, append to list of trial vectors 2. Compute new residual vector, $\mid{\bf r}_{i+1}\,\rangle$, append to list of trial vectors 3. Check convergence criteria - If RMSD of $\mid{\bf r}_{i+1}\,\rangle$ sufficiently small, and - If change in DIIS solution vector $\mid{\bf p}\,\rangle$ sufficiently small, break 4. Build **B** matrix from previous residual vectors 5. Solve Pulay equation for coefficients $\{c_i\}$ 6. Compute DIIS solution vector $\mid{\bf p}\,\rangle$ For SCF iteration, the most common choice of trial vector is the Fock matrix **F**; this choice has the advantage over other potential choices (e.g., the density matrix **D**) of **F** not being idempotent, so that it may benefit from extrapolation. The residual vector is commonly chosen to be the orbital gradient in the AO basis, $$g_{\mu\nu} = ({\bf FDS} - {\bf SDF})_{\mu\nu},$$ however the better choice (which we will make in our implementation!) is to orthogonormalize the basis of the gradient with the inverse overlap metric ${\bf A} = {\bf S}^{-1/2}$: $$r_{\mu\nu} = ({\bf A}^{\rm T}({\bf FDS} - {\bf SDF}){\bf A})_{\mu\nu}.$$ Therefore, the SCF-specific DIIS procedure (integrated into the SCF iteration algorithm) will be: #### Algorithm 2: DIIS within an SCF Iteration 1. Compute **F**, append to list of previous trial vectors 2. Compute AO orbital gradient **r**, append to list of previous residual vectors 3. Compute RHF energy 3. Check convergence criteria - If RMSD of **r** sufficiently small, and - If change in SCF energy sufficiently small, break 4. Build **B** matrix from previous AO gradient vectors 5. Solve Pulay equation for coefficients $\{c_i\}$ 6. Compute DIIS solution vector **F_DIIS** from $\{c_i\}$ and previous trial vectors 7. Compute new orbital guess with **F_DIIS** ## III. Implementation In order to implement DIIS, we're going to integrate it into an existing RHF program. Since we just-so-happened to write such a program in the last tutorial, let's re-use the part of the code before the SCF integration which won't change when we include DIIS: ```julia # ==> Basic Setup <== # Import statements using PyCall: pyimport psi4 = pyimport("psi4") np = pyimport("numpy") # used only to cast to Psi4 arrays using TensorOperations: @tensor using LinearAlgebra: Diagonal, Hermitian, eigen, tr, norm, dot using Printf: @printf # Memory specification psi4.set_memory(Int(5e8)) numpy_memory = 2 # Set output file psi4.core.set_output_file("output.dat", false) # Define Physicist's water -- don't forget C1 symmetry! mol = psi4.geometry(""" O H 1 1.1 H 1 1.1 2 104 symmetry c1 """) # Set computation options psi4.set_options(Dict("basis" => "cc-pvdz", "scf_type" => "pk", "e_convergence" => 1e-8)) # Maximum SCF iterations MAXITER = 40 # Energy convergence criterion E_conv = 1.0e-6 D_conv = 1.0e-3 ``` Memory set to 476.837 MiB by Python driver. 0.001 ```julia # ==> Static 1e- & 2e- Properties <== # Class instantiation wfn = psi4.core.Wavefunction.build(mol, psi4.core.get_global_option("basis")) mints = psi4.core.MintsHelper(wfn.basisset()) # Overlap matrix S = np.asarray(mints.ao_overlap()) # we only need a copy # Number of basis Functions & doubly occupied orbitals nbf = size(S)[1] ndocc = wfn.nalpha() println("Number of occupied orbitals: ", ndocc) println("Number of basis functions: ", nbf) # Memory check for ERI tensor I_size = nbf^4 * 8.e-9 println("\nSize of the ERI tensor will be $I_size GB.") memory_footprint = I_size * 1.5 if I_size > numpy_memory psi4.core.clean() throw(OutOfMemoryError("Estimated memory utilization ($memory_footprint GB) exceeds " * "allotted memory limit of $numpy_memory GB.")) end # Build ERI Tensor I = np.asarray(mints.ao_eri()) # we only need a copy # Build core Hamiltonian T = np.asarray(mints.ao_kinetic()) # we only need a copy V = np.asarray(mints.ao_potential()) # we only need a copy H = T + V; ``` Number of occupied orbitals: 5 Number of basis functions: 24 Size of the ERI tensor will be 0.0026542080000000003 GB. ```julia # ==> CORE Guess <== # AO Orthogonalization Matrix A = mints.ao_overlap() A.power(-0.5, 1.e-16) # ≈ Julia's A^(-0.5) after psi4view() A = np.asarray(A) # Transformed Fock matrix F_p = A * H * A # Diagonalize F_p for eigenvalues & eigenvectors with Julia e, C_p = eigen(Hermitian(F_p)) # Transform C_p back into AO basis C = A * C_p # Grab occupied orbitals C_occ = C[:, 1:ndocc] # Build density matrix from occupied orbitals D = C_occ * C_occ' # Nuclear Repulsion Energy E_nuc = mol.nuclear_repulsion_energy() ``` 8.002366482173422 Now let's put DIIS into action. Before our iterations begin, we'll need to create empty lists to hold our previous residual vectors (AO orbital gradients) and trial vectors (previous Fock matrices), along with setting starting values for our SCF energy and previous energy: ```julia # ==> Pre-Iteration Setup <== # SCF & Previous Energy SCF_E = 0.0 E_old = 0.0; ``` Now we're ready to write our SCF iterations according to Algorithm 2. Here are some hints which may help you along the way: #### Starting DIIS Since DIIS builds the approximate solution vector $\mid{\bf p}\,\rangle$ as a linear combination of the previous trial vectors $\{\mid{\bf p}_i\,\rangle\}$, there's no need to perform DIIS on the first SCF iteration, since there's only one trial vector for DIIS to use! #### Building **B** 1. The **B** matrix in the Lagrange equation is really $\tilde{\bf B} = \begin{pmatrix} {\bf B} & -1\\ -1 & 0\end{pmatrix}$. 2. Since **B** is the matrix of residual overlaps, it will be a square matrix of dimension equal to the number of residual vectors. If **B** is an $N\times N$ matrix, how big is $\tilde{\bf B}$? 3. Since our residuals are real, **B** will be a symmetric matrix. 4. To build $\tilde{\bf B}$, make an empty array of the appropriate dimension, then use array indexing to set the values of the elements. #### Solving the Pulay equation 1. Use built-in Julia functionality to make your life easier. 2. The solution vector for the Pulay equation is $\tilde{\bf c} = \begin{pmatrix} {\bf c}\\ \lambda\end{pmatrix}$, where $\lambda$ is the Lagrange multiplier, and the right hand side is $\begin{pmatrix} {\bf 0}\\ -1\end{pmatrix}$. ```julia # Start from fresh orbitals F_p = A * H * A e, C_p = eigen(Hermitian(F_p)) C = A * C_p C_occ = C[:, 1:ndocc] D = C_occ * C_occ' ; # Trial & Residual Vector Lists F_list = [] DIIS_RESID = [] # ==> SCF Iterations w/ DIIS <== println("==> Starting SCF Iterations <==") SCF_E = let SCF_E = SCF_E, E_old = E_old, D = D # Begin Iterations for scf_iter in 1:MAXITER # Build Fock matrix @tensor G[p,q] := (2I[p,q,r,s] - I[p,r,q,s]) * D[r,s] F = H + G # Build DIIS Residual diis_r = A * (F * D * S - S * D * F) * A # Append trial & residual vectors to lists push!(F_list, F) push!(DIIS_RESID, diis_r) # Compute RHF energy SCF_E = tr((H + F) * D) + E_nuc dE = SCF_E - E_old dRMS = norm(diis_r) @printf("SCF Iteration %3d: Energy = %4.16f dE = %1.5e dRMS = %1.5e \n", scf_iter, SCF_E, SCF_E - E_old, dRMS) # SCF Converged? if abs(SCF_E - E_old) < E_conv && dRMS < D_conv break end E_old = SCF_E if scf_iter >= 2 # Build B matrix B_dim = length(F_list) + 1 B = zeros(B_dim, B_dim) B[end, :] .= -1 B[: , end] .= -1 B[end, end] = 0 for i in eachindex(F_list), j in eachindex(F_list) B[i, j] = dot(DIIS_RESID[i], DIIS_RESID[j]) end # Build RHS of Pulay equation rhs = zeros(B_dim) rhs[end] = -1 # Solve Pulay equation for c_i's with Julia coeff = B \ rhs # Build DIIS Fock matrix F = zeros(size(F)) for i in 1:length(coeff) - 1 F += coeff[i] * F_list[i] end end # Compute new orbital guess with DIIS Fock matrix F_p = A * F * A e, C_p = eigen(Hermitian(F_p)) C = A * C_p C_occ = C[:, 1:ndocc] D = C_occ * C_occ' # MAXITER exceeded? if scf_iter == MAXITER psi4.core.clean() throw(MethodError("Maximum number of SCF iterations exceeded.")) end end SCF_E end # Post iterations println("\nSCF converged.") println("Final RHF Energy: $SCF_E [Eh]") ``` ==> Starting SCF Iterations <== SCF Iteration 1: Energy = -68.9800327333871053 dE = -6.89800e+01 dRMS = 2.79722e+00 SCF Iteration 2: Energy = -69.6472544393141675 dE = -6.67222e-01 dRMS = 2.57832e+00 SCF Iteration 3: Energy = -75.7919291462249021 dE = -6.14467e+00 dRMS = 6.94257e-01 SCF Iteration 4: Energy = -75.9721892296710735 dE = -1.80260e-01 dRMS = 1.81547e-01 SCF Iteration 5: Energy = -75.9893690602362710 dE = -1.71798e-02 dRMS = 2.09996e-02 SCF Iteration 6: Energy = -75.9897163367029123 dE = -3.47276e-04 dRMS = 1.28546e-02 SCF Iteration 7: Energy = -75.9897932415930768 dE = -7.69049e-05 dRMS = 1.49088e-03 SCF Iteration 8: Energy = -75.9897956274068349 dE = -2.38581e-06 dRMS = 6.18909e-04 SCF Iteration 9: Energy = -75.9897957845313954 dE = -1.57125e-07 dRMS = 4.14761e-05 SCF converged. Final RHF Energy: -75.9897957845314 [Eh] Congratulations! You've written your very own Restricted Hartree-Fock program with DIIS convergence accelleration! Finally, let's check your final RHF energy against <span style='font-variant: small-caps'> Psi4</span>: ```julia # Compare to Psi4 SCF_E_psi = psi4.energy("SCF") psi4.compare_values(SCF_E_psi, SCF_E, 6, "SCF Energy") ``` SCF Energy........................................................PASSED true ## References 1. P. Pulay. *Chem. Phys. Lett.* **73**, 393-398 (1980) 2. C. David Sherrill. *"Some comments on accellerating convergence of iterative sequences using direct inversion of the iterative subspace (DIIS)".* Available at: vergil.chemistry.gatech.edu/notes/diis/diis.pdf. (1998)

59715c8a9bedc5c87e8692a20987713397774e4e

ipynb

Jupyter Notebook

Tutorials/03_Hartree-Fock/3b_rhf-diis.ipynb

zyth0s/psi4julia

beb0384028f1a3654b8a2f8690b7db5bd9c24b86

2021-02-13T22:14:21.000Z

2021-04-17T07:34:10.000Z

Tutorials/03_Hartree-Fock/3b_rhf-diis.ipynb

zyth0s/psi4julia

beb0384028f1a3654b8a2f8690b7db5bd9c24b86

Tutorials/03_Hartree-Fock/3b_rhf-diis.ipynb

zyth0s/psi4julia

beb0384028f1a3654b8a2f8690b7db5bd9c24b86

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python # import Python libraries import numpy as np %matplotlib inline import matplotlib import matplotlib.pyplot as plt import sympy as sym from sympy.plotting import plot import pandas as pd from IPython.display import display from IPython.core.display import Math ``` ```python # time elbow_flexion BIClong BICshort BRA r_ef = np.loadtxt('./../data/r_elbowflexors.mot', skiprows=7) f_ef = np.loadtxt('./../data/f_elbowflexors.mot', skiprows=7) ``` ```python m_ef = r_ef*1 m_ef[:, 2:] = r_ef[:, 2:]*f_ef[:, 2:] ``` ```python labels = ['Biceps long head', 'Biceps short head', 'Brachialis'] fig, ax = plt.subplots(nrows=1, ncols=3, sharex=True, figsize=(10, 4)) ax[0].plot(r_ef[:, 1], r_ef[:, 2:]) #ax[0].set_xlabel('Elbow angle $(\,^o)$') ax[0].set_title('Moment arm (m)') ax[1].plot(f_ef[:, 1], f_ef[:, 2:]) ax[1].set_xlabel('Elbow angle $(\,^o)$', fontsize=16) ax[1].set_title('Maximum force (N)') ax[2].plot(m_ef[:, 1], m_ef[:, 2:]) #ax[2].set_xlabel('Elbow angle $(\,^o)$') ax[2].set_title('Maximum torque (Nm)') ax[2].legend(labels, loc='best', framealpha=.5) ax[2].set_xlim(np.min(r_ef[:, 1]), np.max(r_ef[:, 1])) plt.tight_layout() plt.show() ``` ```python a_ef = np.array([624.3, 435.56, 987.26])/50 # 50 N/cm2 print(a_ef) ``` [ 12.486 8.7112 19.7452] ```python from scipy.optimize import minimize ``` ```python def cf_f1(x): """Cost function: sum of forces.""" return x[0] + x[1] + x[2] def cf_f2(x): """Cost function: sum of forces squared.""" return x[0]**2 + x[1]**2 + x[2]**2 def cf_fpcsa2(x, a): """Cost function: sum of squared muscle stresses.""" return (x[0]/a[0])**2 + (x[1]/a[1])**2 + (x[2]/a[2])**2 def cf_fmmax3(x, m): """Cost function: sum of cubic forces normalized by moments.""" return (x[0]/m[0])**3 + (x[1]/m[1])**3 + (x[2]/m[2])**3 ``` ```python def cf_f1d(x): """Derivative of cost function: sum of forces.""" dfdx0 = 1 dfdx1 = 1 dfdx2 = 1 return np.array([dfdx0, dfdx1, dfdx2]) def cf_f2d(x): """Derivative of cost function: sum of forces squared.""" dfdx0 = 2*x[0] dfdx1 = 2*x[1] dfdx2 = 2*x[2] return np.array([dfdx0, dfdx1, dfdx2]) def cf_fpcsa2d(x, a): """Derivative of cost function: sum of squared muscle stresses.""" dfdx0 = 2*x[0]/a[0]**2 dfdx1 = 2*x[1]/a[1]**2 dfdx2 = 2*x[2]/a[2]**2 return np.array([dfdx0, dfdx1, dfdx2]) def cf_fmmax3d(x, m): """Derivative of cost function: sum of cubic forces normalized by moments.""" dfdx0 = 3*x[0]**2/m[0]**3 dfdx1 = 3*x[1]**2/m[1]**3 dfdx2 = 3*x[2]**2/m[2]**3 return np.array([dfdx0, dfdx1, dfdx2]) ``` ```python M = 20 # desired torque at the elbow iang = 69 # which will give the closest value to 90 degrees r = r_ef[iang, 2:] f0 = f_ef[iang, 2:] a = a_ef m = m_ef[iang, 2:] x0 = f_ef[iang, 2:]/10 # far from the correct answer for the sum of torques print('M =', M) print('x0 =', x0) print('r * x0 =', np.sum(r*x0)) ``` M = 20 x0 = [ 57.51311369 36.29974032 89.6470056 ] r * x0 = 6.62200444607 ```python bnds = ((0, f0[0]), (0, f0[1]), (0, f0[2])) ``` ```python # use this in combination with the parameter bounds: cons = ({'type': 'eq', 'fun' : lambda x, r, f0, M: np.array([r[0]*x[0] + r[1]*x[1] + r[2]*x[2] - M]), 'jac' : lambda x, r, f0, M: np.array([r[0], r[1], r[2]]), 'args': (r, f0, M)}) ``` ```python # to enter everything as constraints: cons = ({'type': 'eq', 'fun' : lambda x, r, f0, M: np.array([r[0]*x[0] + r[1]*x[1] + r[2]*x[2] - M]), 'jac' : lambda x, r, f0, M: np.array([r[0], r[1], r[2]]), 'args': (r, f0, M)}, {'type': 'ineq', 'fun' : lambda x, r, f0, M: f0[0]-x[0], 'jac' : lambda x, r, f0, M: np.array([-1, 0, 0]), 'args': (r, f0, M)}, {'type': 'ineq', 'fun' : lambda x, r, f0, M: f0[1]-x[1], 'jac' : lambda x, r, f0, M: np.array([0, -1, 0]), 'args': (r, f0, M)}, {'type': 'ineq', 'fun' : lambda x, r, f0, M: f0[2]-x[2], 'jac' : lambda x, r, f0, M: np.array([0, 0, -1]), 'args': (r, f0, M)}, {'type': 'ineq', 'fun' : lambda x, r, f0, M: x[0], 'jac' : lambda x, r, f0, M: np.array([1, 0, 0]), 'args': (r, f0, M)}, {'type': 'ineq', 'fun' : lambda x, r, f0, M: x[1], 'jac' : lambda x, r, f0, M: np.array([0, 1, 0]), 'args': (r, f0, M)}, {'type': 'ineq', 'fun' : lambda x, r, f0, M: x[2], 'jac' : lambda x, r, f0, M: np.array([0, 0, 1]), 'args': (r, f0, M)}) ``` ```python f1r = minimize(fun=cf_f1, x0=x0, args=(), jac=cf_f1d, constraints=cons, method='SLSQP', options={'disp': True}) ``` Optimization terminated successfully. (Exit mode 0) Current function value: 409.5926601 Iterations: 7 Function evaluations: 7 Gradient evaluations: 7 ```python f2r = minimize(fun=cf_f2, x0=x0, args=(), jac=cf_f2d, constraints=cons, method='SLSQP', options={'disp': True}) ``` Optimization terminated successfully. (Exit mode 0) Current function value: 75657.3847913 Iterations: 5 Function evaluations: 6 Gradient evaluations: 5 ```python fpcsa2r = minimize(fun=cf_fpcsa2, x0=x0, args=(a,), jac=cf_fpcsa2d, constraints=cons, method='SLSQP', options={'disp': True}) ``` Optimization terminated successfully. (Exit mode 0) Current function value: 529.96397777 Iterations: 11 Function evaluations: 11 Gradient evaluations: 11 ```python fmmax3r = minimize(fun=cf_fmmax3, x0=x0, args=(m,), jac=cf_fmmax3d, constraints=cons, method='SLSQP', options={'disp': True}) ``` Optimization terminated successfully. (Exit mode 0) Current function value: 1075.13889317 Iterations: 12 Function evaluations: 12 Gradient evaluations: 12 ```python dat = np.vstack((np.around(r*100,1), np.around(a,1), np.around(f0,0), np.around(m,1))) opt = np.around(np.vstack((f1r.x, f2r.x, fpcsa2r.x, fmmax3r.x)), 1) er = ['-', '-', '-', '-', np.sum(r*f1r.x)-M, np.sum(r*f2r.x)-M, np.sum(r*fpcsa2r.x)-M, np.sum(r*fmmax3r.x)-M] data = np.vstack((np.vstack((dat, opt)).T, er)).T rows = ['$\text{Moment arm}\;[cm]$', '$pcsa\;[cm^2]$', '$F_{max}\;[N]$', '$M_{max}\;[Nm]$', '$\sum F_i$', '$\sum F_i^2$', '$\sum(F_i/pcsa_i)^2$', '$\sum(F_i/M_{max,i})^3$'] cols = ['Biceps long head', 'Biceps short head', 'Brachialis', 'Error in M'] df = pd.DataFrame(data, index=rows, columns=cols) print('\nComparison of different cost functions for solving the distribution problem') df ``` Comparison of different cost functions for solving the distribution problem <div> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>Biceps long head</th> <th>Biceps short head</th> <th>Brachialis</th> <th>Error in M</th> </tr> </thead> <tbody> <tr> <th>$\text{Moment arm}\;[cm]$</th> <td>4.9</td> <td>4.9</td> <td>2.3</td> <td>-</td> </tr> <tr> <th>$pcsa\;[cm^2]$</th> <td>12.5</td> <td>8.7</td> <td>19.7</td> <td>-</td> </tr> <tr> <th>$F_{max}\;[N]$</th> <td>575.0</td> <td>363.0</td> <td>896.0</td> <td>-</td> </tr> <tr> <th>$M_{max}\;[Nm]$</th> <td>28.1</td> <td>17.7</td> <td>20.4</td> <td>-</td> </tr> <tr> <th>$\sum F_i$</th> <td>215.4</td> <td>194.2</td> <td>0.0</td> <td>0.0</td> </tr> <tr> <th>$\sum F_i^2$</th> <td>184.7</td> <td>184.7</td> <td>86.1</td> <td>0.0</td> </tr> <tr> <th>$\sum(F_i/pcsa_i)^2$</th> <td>201.7</td> <td>98.2</td> <td>235.2</td> <td>0.0</td> </tr> <tr> <th>$\sum(F_i/M_{max,i})^3$</th> <td>241.1</td> <td>120.9</td> <td>102.0</td> <td>-3.5527136788e-15</td> </tr> </tbody> </table> </div>

6203a281dc4f596ec8ae6d15534f7f5271f4320c

ipynb

Jupyter Notebook

courses/modsim2018/ahmadhassan/Ahmad_Task20.ipynb

ahmadhassan01/bmc

3114b7d3ecd1f7c678fac0c04e8e139ac2898992

courses/modsim2018/ahmadhassan/Ahmad_Task20.ipynb

ahmadhassan01/bmc

3114b7d3ecd1f7c678fac0c04e8e139ac2898992

courses/modsim2018/ahmadhassan/Ahmad_Task20.ipynb

ahmadhassan01/bmc

3114b7d3ecd1f7c678fac0c04e8e139ac2898992

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python import sys import numpy as np print(sys.version) np.__version__ ``` 3.9.7 (default, Sep 16 2021, 16:59:28) [MSC v.1916 64 bit (AMD64)] '1.20.3' ```python #Criação de matriz com numpy matrix matriz = np.matrix("1, 2, 3;4, 5, 6") print(matriz) ``` [[1 2 3] [4 5 6]] ```python matriz2 = np.matrix([[1, 2, 3], [4, 5, 6]]) print(matriz2) ``` [[1 2 3] [4 5 6]] ```python matriz3 = np.matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) print(matriz3) ``` [[1 2 3] [4 5 6] [7 8 9]] ```python #traz a dimensão da matriz linha 1 coluna 1 matriz3[1, 1] ``` 5 ### Matriz Esparsa Uma matriz esparsa possui uma grande quantidade de elementos que valem zero (ou não presentes, ou não necessários). Matrizes esparsas têm aplicações em problemas de engenharia, física (por exemplo, o método das malhas para resolução de circuitos elétricos ou sistemas de equações lineares). Também têm aplicação em computação, como por exemplo em tecnologias de armazenamento de dados. A matriz esparsa é implementada através de um conjunto de listas ligadas que apontam para elementos diferentes de zero. De forma que os elementos que possuem valor zero não são armazenados ```python #importação de matriz esparsa do scipy import scipy.sparse ``` ```python linhas = np.array([0,1,2,3]) colunas = np.array([1,2,3,4]) valores = np.array([10,20,30,40]) ``` ```python #criação de matriz esparsa mat = scipy.sparse.coo_matrix((valores, (linhas, colunas))) ; print(mat) ``` (0, 1) 10 (1, 2) 20 (2, 3) 30 (3, 4) 40 ```python #criação de matriz esparsa densa print(mat.todense()) ``` [[ 0 10 0 0 0] [ 0 0 20 0 0] [ 0 0 0 30 0] [ 0 0 0 0 40]] ```python #verifica se é uma matriz esparsa scipy.sparse.isspmatrix_coo(mat) ``` True ### Operações ```python a = np.array([[1, 2], [3, 4]]) print(a) ``` [[1 2] [3 4]] ```python a * a ``` array([[ 1, 4], [ 9, 16]]) ```python A = np.mat(a) A ``` matrix([[1, 2], [3, 4]]) ```python A * A ``` matrix([[ 7, 10], [15, 22]]) ## $$ \boxed{ \begin{align} \begin{pmatrix} 1 & 2 \\ 3 & 4 \end{pmatrix} & \begin{pmatrix} 1 & 2 \\ 3 & 4 \end{pmatrix} = \begin{pmatrix} 7 & 10 \\ 15 & 22 \end{pmatrix} \end{align} }$$ ```python from IPython.display import Image Image('cap3/imagens/Matriz.png') ``` ```python #Fazendo um array ter o mesmo comportamento de uma matriz np.dot(a , a) ``` array([[ 7, 10], [15, 22]]) ```python #Converter array para matriz matrizA = np.asmatrix(a) ;matrizA ``` matrix([[1, 2], [3, 4]]) ```python matrizA * matrizA ``` matrix([[ 7, 10], [15, 22]]) ```python #converter matriz para array arrayA = np.asarray(matrizA) ; arrayA ``` array([[1, 2], [3, 4]]) ```python arrayA * arrayA ``` array([[ 1, 4], [ 9, 16]])

49555fb7debfe6bbd49bdfc39b0ef947d8baa0e8

ipynb

Jupyter Notebook

NumPy/ArrayEmatrizNumpy.ipynb

DjCod3r/Jupyter

bbf8e0eb5ae766ef509968be79541eba9389c544

2022-03-03T14:40:51.000Z

2022-03-03T14:40:51.000Z

NumPy/ArrayEmatrizNumpy.ipynb

DjCod3r/Jupyter

bbf8e0eb5ae766ef509968be79541eba9389c544

NumPy/ArrayEmatrizNumpy.ipynb

DjCod3r/Jupyter

bbf8e0eb5ae766ef509968be79541eba9389c544

Qwen/Qwen-72B

1. YES 2. YES

__label__por_Latn

# Laplace transform This notebook is a short tutorial of Laplace transform using SymPy. The main functions to use are ``laplace_transform`` and ``inverse_laplace_transform``. ```python from sympy import * ``` ```python init_session() ``` IPython console for SymPy 1.0 (Python 2.7.13-64-bit) (ground types: python) These commands were executed: >>> from __future__ import division >>> from sympy import * >>> x, y, z, t = symbols('x y z t') >>> k, m, n = symbols('k m n', integer=True) >>> f, g, h = symbols('f g h', cls=Function) >>> init_printing() Documentation can be found at http://docs.sympy.org/1.0/ Let us compute the Laplace transform from variables $t$ to $s$, then, we have the condition that $t>0$ (and real). ```python t = symbols("t", real=True, positive=True) s = symbols("s") ``` To calculate the Laplace transform of the expression $t^4$, we enter ```python laplace_transform(t**4, t, s) ``` This function returns ``(F, a, cond)`` where ``F`` is the Laplace transform of ``f``, $\mathcal{R}(s)>a$ is the half-plane of convergence, and ``cond`` are auxiliary convergence conditions. If we are not interested in the conditions for the convergence of this transform, we can use ``noconds=True`` ```python laplace_transform(t**4, t, s, noconds=True) ``` ```python fun = 1/((s-2)*(s-1)**2) fun ``` ```python inverse_laplace_transform(fun, s, t) ``` Right now, Sympy does not support the tranformation of derivatives. If we do ```python laplace_transform(f(t).diff(t), t, s, noconds=True) ``` we don't obtain, the expected ```python s*LaplaceTransform(f(t), t, s) - f(0) ``` or, $$\mathcal{L}\lbrace f^{(n)}(t)\rbrace = s^n F(s) - \sum_{k=1}^{n} s^{n - k} f^{(k - 1)}(0)\, ,$$ in general. We can still, operate with the trasformation of a differential equation. For example, let us consider the equation $$\frac{d f(t)}{dt} = 3f(t) + e^{-t}\, ,$$ that has as Laplace transform $$sF(s) - f(0) = 3F(s) + \frac{1}{s+1}\, .$$ ```python eq = Eq(s*LaplaceTransform(f(t), t, s) - f(0), 3*LaplaceTransform(f(t), t, s) + 1/(s +1)) eq ``` We then solve for $F(s)$ ```python sol = solve(eq, LaplaceTransform(f(t), t, s)) sol ``` and compute the inverse Laplace transform ```python inverse_laplace_transform(sol[0], s, t) ``` and we verify this using ``dsolve`` ```python factor(dsolve(f(t).diff(t) - 3*f(t) - exp(-t))) ``` that is equal if $4C_1 = 4f(0) + 1$. It is common to use practial fraction decomposition when computing inverse Laplace transforms. We can do this using ``apart``, as follows ```python frac = 1/(x**2*(x**2 + 1)) frac ``` ```python apart(frac) ``` We can also compute the Laplace transform of Heaviside and Dirac's Delta "functions" ```python laplace_transform(Heaviside(t - 3), t, s, noconds=True) ``` ```python laplace_transform(DiracDelta(t - 2), t, s, noconds=True) ``` ```python ``` The next cell change the format of the notebook. ```python from IPython.core.display import HTML def css_styling(): styles = open('./styles/custom_barba.css', 'r').read() return HTML(styles) css_styling() ``` <link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'> <link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'> <link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'> <style> /* Based on Lorena Barba template available at: https://github.com/barbagroup/AeroPython/blob/master/styles/custom.css*/ @font-face { font-family: "Computer Modern"; src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf'); } div.cell{ width:800px; margin-left:16% !important; margin-right:auto; } h1 { font-family: 'Alegreya Sans', sans-serif; } h2 { font-family: 'Fenix', serif; } h3{ font-family: 'Fenix', serif; margin-top:12px; margin-bottom: 3px; } h4{ font-family: 'Fenix', serif; } h5 { font-family: 'Alegreya Sans', sans-serif; } div.text_cell_render{ font-family: 'Alegreya Sans',Computer Modern, "Helvetica Neue", Arial, Helvetica, Geneva, sans-serif; line-height: 135%; font-size: 120%; width:600px; margin-left:auto; margin-right:auto; } .CodeMirror{ font-family: "Source Code Pro"; font-size: 90%; } /* .prompt{ display: None; }*/ .text_cell_render h1 { font-weight: 200; font-size: 50pt; line-height: 100%; color:#CD2305; margin-bottom: 0.5em; margin-top: 0.5em; display: block; } .text_cell_render h5 { font-weight: 300; font-size: 16pt; color: #CD2305; font-style: italic; margin-bottom: .5em; margin-top: 0.5em; display: block; } .warning{ color: rgb( 240, 20, 20 ) } </style>

4e471cf00c8cd5f6dab3069a42dd4d659d08098f

ipynb

Jupyter Notebook

notebooks/sympy/laplace_transform.ipynb

nicoguaro/AdvancedMath

2749068de442f67b89d3f57827367193ce61a09c

2017-06-29T17:45:20.000Z

2022-02-06T20:14:29.000Z

notebooks/sympy/laplace_transform.ipynb

nicoguaro/AdvancedMath

2749068de442f67b89d3f57827367193ce61a09c

notebooks/sympy/laplace_transform.ipynb

nicoguaro/AdvancedMath

2749068de442f67b89d3f57827367193ce61a09c

2019-04-22T08:08:56.000Z

2022-01-27T08:15:53.000Z