Download presentation
Presentation is loading. Please wait.
1
Programmazione ad alto livello con Python
Lezione 8: Introduzione alla libreria per il calcolo scientifico SciPy. Dr. Gabriele Mencagli Dipartimento di Informatica Università di Pisa 21/09/2018
2
Informazioni Dr. Gabriele Mencagli
Dipartimento di Informatica, Università di Pisa Stanza 287. Ricevimento su appuntamento (mandare una ) web: Organizzazione: corso introduttivo. 16 ore di didattica frontale, 14 di esercizi individuali in laboratorio Durata: 2 mesi Modalità di esame: progetto finale di complessità variabile Importante gli homework!!! (tipicamente uno per settimana) 21/09/2018
3
Available at: http://www.spipy.org
What is SciPy? SciPy is a collection of mathematical algorithms and convenience functions built on the NumPy extension of Python. The additional benefit of basing SciPy on Python is that this also makes a powerful programming language available for use in developing sophisticated programs and specialized applications. Scientific applications using SciPy benefit from the development of additional modules in numerous niche’s of the software landscape by developers across the world. Everything from parallel programming to web and data-base subroutines and classes have been made available to the Python programmer. All of this power is available in addition to the mathematical libraries in SciPy. During this lecture we will see the main features of SciPy, its structures, the set of functionalities provided to the user and how to program with SciPy! Available at: 21/09/2018
4
SciPy organization SciPy library is organized into packages (modules) covering different scientific computing domains. These are summarized in the following table: SciPy is fully integrated with other libraries that we have already studied during this cource, notably: NumPy (with ndarrays) and MatPlotLib! 21/09/2018
5
Documentation SciPy and NumPy have documentation versions in both HTML and PDF format available at that cover nearly all available functionality. However, this documentation is still work-in-progress and some parts may be incomplete or sparse. Python’s documentation strings are used in SciPy for on-line documentation. There are two methods for reading them and getting help: One is Python’s command help in the pydoc module. Entering this command with no arguments (i.e. >>> help ) launches an interactive help session that allows searching through the keywords and modules available to all of Python. Secondly, running the command help(obj) with an object as the argument displays that object’s calling signature, and documentation string. Let us show and example of how to read the SciPy documentation about objects, methods and functions. 21/09/2018
6
Documentation (2) An example of pydoc command help. You can use it for any function of an imported module: 21/09/2018
7
Helpful sites Two important web sites in which interested readers can find useful information about NumPy and SciPy: SCIPY DOCUMENTATION NUMPY EXAMPLES 21/09/2018
8
Useful import SciPy builds on NumPy, and for all basic array handling needs you can use NumPy functions: To use functions from some of the SciPy modules, you can do: The top level of SciPy also contains functions from NumPy and numpy.lib.scimath. However, it is better to use them directly from the NumPy module instead. Remember to install SciPy and NumPy: sometimes, they are not already installed! >>> import numpy as np >>> np.some_function() >>> from scipy import some_module >>> some_module.some_function() 21/09/2018
9
Vectorized functions One of the features that NumPy provides is a class vectorize to convert an ordinary Python function which accepts scalars and returns scalars into a “vectorized-function”. 21/09/2018
10
Polynomial p = poly1d(<coefficient array>)
p.roots (p.r) are the roots p.coefficients (p.c) are the coefficients p.order is the order p[n] is the coefficient of xn p(val) evaulates the polynomial at val p.integ() integrates the polynomial p.deriv() differentiates the polynomial Basic numeric operations (+,-,/,*) work Acts like p.c when used as an array Fancy printing >>> import numpy as np >>> p = np.poly1d([1,-2,4]) >>> print p 2 x - 2 x + 4 >>> g = p**3 + p*(3-2*p) >>> print g x - 6 x + 25 x - 51 x + 81 x - 58 x + 44 >>> print g.deriv(m=2) #m=order 30 x x x x + 162 >>> print p.integ(m=2,k=[2,1]) x x + 2 x + 2 x + 1 >>> print p.roots [ j j] >>> print p.coeffs [ ] 21/09/2018
11
Polynomial (2) To use polynomial in SciPy we rely on the NumPy library. The most common way is to use the poly1d class from NumPy. This class accepts coefficients or polynomial roots to initialize a polynomial. 21/09/2018
12
Finding the roots An example in which we use SciPy, NumPy and MatPlotLib altogether to show the curve of a polynomial and its real roots! >>> import numpy as np >>> import matplotlib.pyplot as plt >>> p = np.poly1d([1.3, 4.0, 0.6]) >>> print p 2 1.3 x + 4 x + 0.6 >>> x = np.linspace(-4, 1.0, 101) >>> y = p(x) >>> plt.plot(x,y,'-') >>> r = p.roots >>> s = p(r) >>> r array([ , ]) >>> plt.plot(r.real,s.real,'ro') >>> plt.show() 21/09/2018
13
Interpolation 1-D Interpolating Class
SciPy provides great support to interpolation with 1-D and 2-D functions. scipy.interpolate --- General purpose Interpolation 1-D Interpolating Class Constructs callable function from data points and desired spline interpolation order. Function takes vector of inputs and returns interpolated value using the spline. 1-D and 2-D spline interpolation (FITPACK) Smoothing splines up to order 5. Parametric splines. 21/09/2018
14
1-D interpolation The standard function for 1-D interpolation can be imported by using: The function has the following signature: Returns a function that uses interpolation to find the value of new points: x – 1-D array of increasing real values which cannot contain duplicates; y – Ndarray of real values whose length along the interpolation axis must be len(x); kind – kind of interpolation (e.g. ‘linear’, ‘quadratic’, ‘cubic’). Can also be an integer n>1 which returns interpolating spline (with minimum sum-of-squares discontinuity in nth derivative); axis – axis of y along which to interpolate; copy – make internal copies of x and y; bounds_error – raise error for out-of-bounds; fill_value – if bounds_error is False, then use this value to fill in out-of-bounds. >>> from scipy.interpolate import interp1d interp1d(x, y, kind=‘linear’, axis=-1, copy=True, bounds_error=True, fill_value=numpy.nan) 21/09/2018
15
1-D interpolation example
An example of 1-D interpolation with results shown graphically using MatPlotLib. We show the use of spline interpolation (multi-polynomial). >>> from scipy.interpolate import interp1d >>> import matplotlib.pyplot as plt >>> import numpy as np # Sample values. >>> x = np.linspace(0, 2*np.pi, 6) >>> y = np.sin(x) # Create a spline class for interpolation. # kind=5 sets to 5th degree spline. # kind=‘linear’ -> linear interpolation. # kind=n -> use an nth order spline. >>> spline_fit = interp1d(x, y, kind=5) >>> xx = np.linspace(0, 2*np.pi, 50) >>> yy = spline_fit(xx) # Display the results. >>> plt. plot(xx, np.sin(xx), 'r-', x, y, 'ro', xx, yy, 'b--', linewidth=2) >>> plt.show() 21/09/2018
16
1-D interpolation example (2)
Another example of 1-D interpolation (linear and cubic): 21/09/2018
17
Linear algebra Uses ATLAS if available --- very fast
SciPy provides a set of advanced functions for supporting linear algebra computations. scipy.linalg --- FAST LINEAR ALGEBRA Uses ATLAS if available --- very fast Low-level access to BLAS and LAPACK routines in modules linalg.fblas, and linalg.flapack (FORTRAN order) High level matrix routines Linear Algebra Basics: inv, solve, det, norm, lstsq, pinv Decompositions: eig, lu, svd, orth, cholesky, qr, schur Matrix Functions: expm, logm, sqrtm, cosm, coshm, funm (general matrix functions) 21/09/2018
18
Linear algebra basics Some basic functionalities of linear algebra kernels in SciPy: LU FACTORIZATION EIGEN VALUES AND VECTORS >>> import numpy as np >>> from scipy import linalg >>> a = np.array([[1,3,5], [2,5,1], [2,3,6]]) # Time consuming factorization. >>> lu, piv = linalg.lu_factor(a) # Fast solve for 1 or more right hand sides. >>> b = np.array([10,8,3]) >>> linalg.lu_solve((lu, piv), b) array([ , , ]) >>> import numpy as np >>> from scipy import linalg >>> a = np.array([[1,3,5], [2,5,1], [2,3,6]]) # Compute eigen values/vectors. >>> vals, vecs = linalg.eig(a) # Print eigen values. >>> vals array([ j, j, j]) # Eigen vectors are in columns print first eigen vector. >>> vecs[:,0] array([ , , ]) Matrix LU contains U in its upper triangle and L in its lower triangle. Piv is the permutation matrix 21/09/2018
19
Matrix objects Solving linear system of equations in SciPy:
STRING CONSTRUCTION DIAGONAL >>> import numpy as np >>> a = np.mat('[1,3,5;2,5,1;2,3,6]') >>> a matrix([[1, 3, 5], [2, 5, 1], [2, 3, 6]]) >>> a.diagonal() matrix([[1, 5, 6]]) SOLVE >>> b = np.mat('10;8;3') >>> a.I*b matrix([[ ], [ ], [ ]]) >>> from scipy import linalg >>> linalg.solve(a,b) TRANSPOSE ATTRIBUTE >>> a.T matrix([[1, 2, 2], [3, 5, 3], [5, 1, 6]]) INVERTED ATTRIBUTE >>> a.I matrix([[ , , ], [ , , ], [ , , ] ]) 21/09/2018
20
Optimization SciPy provides great support to several optimization methods. scipy.optimize --- unconstrained minimization and root finding Unconstrained Optimization fmin (Nelder-Mead simplex), fmin_powell (Powell’s method), fmin_bfgs (BFGS quasi-Newton method), fmin_ncg (Newton conjugate gradient), leastsq (Levenberg-Marquardt), anneal (simulated annealing global minimizer), brute (brute force global minimizer), brent (excellent 1-D minimizer), golden, bracket Constrained Optimization fmin_l_bfgs_b, fmin_tnc (truncated newton code), fmin_cobyla (constrained optimization by linear approximation), fminbound (interval constrained 1-d minimizer) Root finding fsolve (using MINPACK), brentq, brenth, ridder, newton, bisect, fixed_point (fixed point equation solver) 21/09/2018
21
1-D minimization An example of minimization of a 1-D function (Bessel’s function in this case): EXAMPLE: MINIMIZE BESSEL FUNCTION >>> from scipy.special import j1 >>> from scipy.optimize import \ Fminbound >>> import numpy as np >>> import matplotlib.pyplot as plt # Minimize 1st order bessel function between 4 and 7. >>> x=np.arange(2, 7.1, 0.1) >>> j1x = j1(x) >>> plt.plot(x,j1x,’-’) >>> x_min = fminbound(j1,4,7) >>> j1_min = j1(x_min) >>> plt.plot([x_min],[j1_min],’ro’) >>> plt.show() By default fminbound uses Brent’s method! 21/09/2018
22
Fitting polynomials Polyfit returns the coefficients of a polynomial of degree deg that is the least squares fit to the data values y given at points x. POLYFIT(X, Y, DEGREE) >>> from numpy import polyfit, poly1d >>> from scipy.stats import norm >>> import numpy as np # Create clean data. >>> x = np.linspace(0, 4.0, 100) >>> y = 1.5 * np.exp(-0.2 * x) + 0.3 # Add a bit of noise. >>> noise = 0.1 * norm.rvs(size=100) >>> noisy_y = y + noise # Fit noisy data with a linear model. >>> linear_coef = polyfit(x, noisy_y, 1) >>> linear_poly = poly1d(linear_coef) >>> linear_y = linear_poly(x) # Fit noisy data with a quadratic model. >>> quad_coef = polyfit(x, noisy_y, 2) >>> quad_poly = poly1d(quad_coef) >>> quad_y = quad_poly(x)) 21/09/2018
23
Signal processing What’s Available?
SciPy provides an entire module for signal processing operations performed on Ndarrays: scipy.signal --- Signal and Image Processing What’s Available? Filtering General 2-D Convolution (more boundary conditions) N-D convolution B-spline filtering N-D Order filter, N-D median filter, faster 2d version, IIR and FIR filtering and filter design LTI systems System simulation Impulse and step responses Partial fraction expansion 21/09/2018
24
Image processing Many signal processing filters are available in SciPy. They can be applied on images and consist in well-known filtering techniques as in this example: NOISY IMAGE FILTERED IMAGE noise removal filter IMAGE DETECT EDGES edge detection 21/09/2018
25
Open an image SciPy offers a module to manipulate images. You can open an image file and modify it by using proper filters. >>> from scipy import misc >>> import numpy as np >>> import matplotlib.pyplot as plt >>> img = misc.lena() >>> misc.imsave('lena.png’) >>> plt.imshow(img) >>> plt.show() >>> # We can also create a ndarray of the image. >>> lena = misc.imread('lena.png’) >>> type(lena) <type 'numpy.ndarray'> >>> lena.shape, lena.dtype ((512, 512), dtype('uint8')) Lena.png is a 512x512 image file with grayscale! 21/09/2018
26
Image tansformations Now we can manipulate the open image. Several geometrical transformations are possible in SciPy: >>> from scipy import misc >>> from scipy import ndimage >>> import numpy as np >>> import matplotlib.pyplot as plt >>> lena = misc.lena() >>> # 512 x 512. >>> lx, ly = lena.shape >>> # Cropping. >>> crop_lena = lena[lx/4:-lx/4, ly/4:-ly/4] >>> # up <-> down flip. >>> flip_ud_lena = np.flipud(lena) >>> # rotation. >>> rotate_lena = ndimage.rotate(lena, 45) >>> rotate_lena_noreshape = ndimage.rotate(lena, 45, reshape=False) 21/09/2018
27
Image filtering The image can be modified by applying several filtering techniques available in the SciPy library! Filters usually place the value of pixels by a function of the values of neighboring pixels. >>> from scipy import misc >>> lena = misc.lena() >>> # Gaussian filter. >>> blurred_lena = ndimage.gaussian_filter(lena, sigma=3) >>> very_blurred = ndimage.gaussian_filter(lena, sigma=5) >>> # Uniform filter. >>> local_mean = ndimage.uniform_filter(lena, size=11) 21/09/2018
28
Feature extraction Feature extraction are a set of advanced filters able to extract interesting features from an image. A notable example is edge detection: >>> from scipy import misc >>> from scipy.ndimage.filters import sobel >>> import numpy as np >>> import matplotlib.pyplot as plt >>> img = misc.lena() >>> misc.imsave('lena.png', l) >>> plt.imshow(img) >>> plt.show() >>> # We apply Sobel (Edge Detection). >>> edges = sobel(lena) >>> plt.imshow(edges) 21/09/2018
29
Integration Ordinary Differential Equations (ODE)
SciPy offers several methods to perform numerical integration. scipy.integrate --- General purpose Integration Ordinary Differential Equations (ODE) integrate.odeint, integrate.ode Samples of a 1-d function integrate.trapz (trapezoidal Method), integrate.simps (Simpson Method), integrate.romb (Romberg Method) Arbitrary callable function integrate.quad (general purpose), integrate.dblquad (double integration), integrate.tplquad (triple integration), integrate.fixed_quad (fixed order Gaussian integration), integrate.quadrature (Gaussian quadrature to tolerance), integrate.romberg (Romberg) 21/09/2018
30
Integration example Integrate func from a to b (possibly infinite interval) using a technique from the Fortran library QUADPACK A simple example of integration in which the function is given by the programmer. EXAMPLE (INTEGRATE A CALLABLE) >>> import numpy as np >>> from scipy import integrate # Compare sin to integral(cos) >>> def func(x): return integrate.quad(np.cos,0,x)[0] >>> vecfunc = vectorize(func) >>> x = np.linspace(0, 2*np.pi, 100) >>> x2 = x[::5] # Only 20 points. >>> y = np.sin(x) >>> y2 = vecfunc(x2) >>> plot(x,y,x2,y2,'rx') >>> legend([‘Exact‘, ‘Integral Result’]) 21/09/2018
31
MatLab compatibility You may have a .mat file that you want to read into SciPy. Or, you want to pass some variables from SciPy/NumPy into MatLab. In these examples we use Octave which is a free version of MatLab. 21/09/2018
32
MatLab compatibility (2)
In Python (with SciPy and NumPy) we can open a MatLab file and inspect its content. We need to use import scipy.io as sio. Arrays and matrices saved in the MatLab file can be imported and traslated into corresponding Ndarrays! 21/09/2018
33
From Python to MatLab We can also do the opposite (from Python to MatLab): An in MatLab (octave) we can do: 21/09/2018
34
PyLab! IPython SciPy Matplotlib NumPy Python
You could often listen to the name PyLab when searching information about Python libraries for scientific computing. Sometimes the union of the 5 packages is called PyLab ipython -pylab. Literally 1000's more modules/packages for Python PMV PIL IPython MayaVi VTK SciPy Matplotlib DejaVu RPy PMV NumPy ETS ViPEr Python MolKit Pygame 21/09/2018
35
END 21/09/2018
36
Special functions Includes over 200 functions:
The module scipy.special includes many functions not defined in standard modules like math, numpy, etc. scipy.special Includes over 200 functions: Airy, Elliptic, Bessel, Gamma, Hyper-Geometric, Struve, Error, Orthogonal Polynomials, Parabolic Cylinder, Mathieu, Spheroidal Wave, Kelvin FIRST ORDER BESSEL EXAMPLE >>> import numpy as np >>> from scipy import special >>> import matplotlib.pyplot as plt >>> x = np.linspace(0, 100, 1001) # An example of ipergeometrical eq. >>> j0x = special.j0(x) >>> plt.plot(x,j0x) Bessel’s function of the first kind with order 1 21/09/2018
37
Special functions (2) Another example of special function already implemented in SciPy: Airy’s functions. They are the solutions of special ODEs. AIRY FUNCTIONS >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy import special >>> x = np.linspace(-5, 1.5, 100) >>> Ai, Aip, Bi, Bip = special.airy(x) >>> plt.plot(x, Ai) # derivative of Ai. >>> plt.plot(x, Aip) >>> plt.plot(x, Bi) # derivative of Bi. >>> plt.plot(x, Bip) 21/09/2018
38
interp2d(x, y, z, kind=‘linear’)
2-D interpolation The standard function for 2-D interpolation can be imported by using: The function has the following signature: Returns a function, f, that uses interpolation to find the value of new points: z_new = f(x_new, y_new): x – 1-D or 2-D array; y – 1-D or 2-D array; z – 1-D or 2-D array representing function evaluated at x and y; kind – kind of interpolation: ‘linear’, ‘quadratic’, or ‘cubic’; The shape of x, y, and z must be the same. >>> from scipy.interpolate import interp2d interp2d(x, y, z, kind=‘linear’) 21/09/2018
39
Continuous statistics
SciPy offers an entire package for continuous statistics. scipy.stats CONTINUOUS DISTRIBUTIONS Over 80 continuous distributions! METHODS pdf cdf rvs ppf stats fit sf isf entropy nnlf moment freeze 21/09/2018
40
Discrete statistics SciPy offers an entire package for discrete statistics. scipy.stats Discrete Distributions 10 standard discrete distributions (plus any finite RV) METHODS pmf cdf rvs ppf stats sf isf moment entropy freeze 21/09/2018
41
Using stats object An example of how to use a stat object in SciPy to inspect a set of samples and extract interesting statistical properties and measures: >>> import numpy as np >>> from scipy.stats import norm >>> x = np.linspace(-5, 5, 100) # Calculate probability dist. >>> pdf = norm.pdf(x) # Calculate cummulative dist. >>> cdf = norm.cdf(x) # Calculate Percent Point Function >>> ppf = norm.ppf(x) # Estimate parameters from data. # Sample normal dist. 100 times. >>> samp = norm.rvs(size=100) >>> mu, sigma = norm.fit(samp) >>> print "%4.2f, %4.2f" % (mu, sigma) -0.14, 1.01 21/09/2018
42
Using stats object (2) Example of discrete statistic distributions using the stats object of SciPy: CREATING NEW DISCRETE DISTRIBUTIONS >>> import matplotlib.pyplot as plt >>> import numpy as np >>> from scipy.stats import rv_discrete # Create loaded dice. >>> xk = [1,2,3,4,5,6] >>> pk = [0.3,0.35,0.25,0.05, 0.025,0.025] >>> new = rv_discrete(name='loaded', values=(xk,pk)) # Calculate histogram. >>> samples = new.rvs(size=1000) >>> bins=np.linspace(0.5,5.5,6) >>> plt.subplot(211) >>> plt.hist(samples,bins=bins,normed=True) # Calculate pmf. >>> x = np.range(0,8) >>> plt.subplot(212) >>> plt.stem(x,new.pmf(x)) >>> plt.show() 21/09/2018
43
More on statistics SciPy offers powerful tools to estimate a continuous distribution from a set of raw data. CONTINOUS DISTRIBUTION ESTIMATION USING GAUSSIAN KERNELS >>> import matplotlib.pyplot as plt >>> import numpy as np >>> import scipy.stats as stats >>> from scipy.stats.kde import gaussian_kde # Sample two normal distributions and create a bi-modal distribution. >>> rv1 = stats.norm() >>> rv2 = stats.norm(2.0,0.8) >>> samples = np.hstack([rv1.rvs(size=100), rv2.rvs(size=100)]) # Use a gaussian kernel density to estimate the pdf for the samples. >>> approximate_pdf = gaussian_kde(samples) >>> x = np.linspace(-3,6,200) # Compare the histogram of the samples to the pdf approximation. >>> plt.hist(samples, bins=25, normed=True) >>> plt.plot(x, approximate_pdf(x),’r’) >>> plt.show() 21/09/2018
44
Iterative methods An example of the conjugate gradient method applied on the minimization of the Rosenbrock function: 21/09/2018
45
Iterative methods (2) By passing explicitly the gradient we can greatly reduce the number of iterations! 21/09/2018
46
Data fitting Minimizzare la somma dei quadrati degli scarti.
A class of optimization problems is represented by least squares problems in which we are looking for a solution the minimizes the sum of the squares of the errors. NONLINEAR LEAST SQUARES >>> from scipy.optimize import leastsq >>> import numpy as np # Define the function to fit. >>> def function(x, a , b, f, phi): result = a * np.exp(-b * np.sin(f * x + phi)) return result # And an error function that compares it to data. >>> def error_function(params, x_data, y_data): result = func(x_data, *params) – y_data # Create a noisy data set. >>> actual_params = [3, 2, 1, pi/4] >>> x = np.linspace(0,2*pi,25) >>> exact = function(x, *actual_params) >>> noisy = exact * np.random.randn(len(x)) # Use least squares to to estimate the function parameters from the noisy data. >>> initial_guess = [1,1,1,1] >>> estimated_params, d = leastsq(error_function, initial_guess, args=(x, noisy)) >>> estimated_params array([3.1705, , , ]) 21/09/2018
47
Integrating with trapz.
Several numerical integration methods are available in the scipy.integrate module. In this example we show the use of the trapezoidal rule to compute integral from samples. >>> import numpy as np >>> from scipy.integrate import trapz >>> import matplotlib.pyplot as plt # Compare sin to integral(cos). >>> x = np.linspace(0, 2*np.pi, 100) >>> y = sin(x) >>> fx = cos(x) >>> N = len(x)+1 >>> y2 = [trapz(fx[:i],x[:i]) for i in range(5,N,5)] >>> x2 = x[4::5] >>> plt.plot(x,y,x2,y2,'rx') >>> plt.legend([‘Exact‘, ‘Trapezoidal Rule’]) >>> plt.show() 21/09/2018
48
Integrating with samples
For an odd number of samples that are equally spaced Simpson’s rule is exact if the function is a polynomial of order 3 or less. If the samples are not equally spaced, then the result is exact if the function is a polynomial of order 2 or less. >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy.integrate import simps >>> def f(x): return x**2 >>> def f2(x): return x**3 >>> x = np.array([1,3,4]) >>> y1 = f1(x) >>> I1 = integrate.simps(y1, x) >>> print(I1) 21.0 >>> y2 = f2(x) >>> I2 = integrate.simps(y2, x) >>> print(I2) 61.5 21/09/2018
49
Ordinary differential equations
It includes the function odeint for numerically solving sets of first-order, ordinary differential equations (ODEs) using sophisticated algorithms. The example below calculates the solution to the following second-order differential equation: It can be rewritten as the following two first-order differential equations: The function y and its derivative y′will be part of elements of an array. The function y is the first element y[0] and the derivative y′is y[1]. 21/09/2018
50
Ordinary differential equations (2)
We can solve numerically the previous differential equations using the tools provided by SciPy. As in this example: >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy.integrate import odeint # Return the first derivative of each element of y. >>> def deriv(y,t): ... a = -2.0 ... b = -0.1 ... return np.array([y[1], a*y[0]+b*y[1]]) >>> time = np.linspace(0.0,10.0,1000) # initial values. >>> yinit = np.array([0.0005,0.2]) >>> y = odeint(deriv,yinit,time) >>> plt.figure() >>> plt.plot(time,y[:,0]) >>> plt.xlabel(‘t’) >>> plt.ylabel(‘y’) >>> plt.show() 21/09/2018
Similar presentations
© 2025 SlidePlayer.com Inc.
All rights reserved.