remove matplotlib inline

ea783cee · Boman Romain · cdf77ce1 · ea783cee
Commit ea783cee authored 1 year ago by Boman Romain
--- a/math0024/hw-guidelines.ipynb
+++ b/math0024/hw-guidelines.ipynb
@@ -955,16 +955,6 @@
    "## Basic plot example"
   ]
  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "89183b94-2850-4daa-a452-c7ab3f400712",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# %matplotlib inline "
-   ]
-  },
  {
   "cell_type": "code",
   "execution_count": 36,

 %% Cell type:markdown id:545b1695-b5e7-450d-8f3c-2b609abc5c07 tags:

 # Python environment setup

 ## Which python?

 At least you will need a basic python interpreter as well as the popular python scientific libraries:

 - numpy: matrix/vector types with basic linear algebra routines.

 - scipy: advanced algorithms (e.g. sparse linear solvers).

 - matplotlib: display of 2D and 3D plots.

 If you already have a python distribution on your computer, use it.

 There are many ways to install python. Some examples:

 - Available in all Linux distributions ( `apt install python3` on Ubuntu).

 - [Python.org](python.org): the reference binaries available from the official python website. <br/> You should use "PyPI" (`pip` command) for the 3 missing modules: <br/>
  `pip install numpy scipy matplotlib`  <br/>This is the cheapest option in terms of disk space (<0.5Gb).

 - [Anaconda](https://www.anaconda.com/): full IDE around ``conda''. Features: package management, multi-python environments and optimised proprietary libraries (Intel MKL, NVIDIA CUDA). <br/> (comes with >10Gb of libraries/programs already installed, as well as a text editor - no command line needed).


 - [Miniconda](https://conda.io/miniconda.html): minimal conda environment - requires the installation of packages with the command line  ($\approx$1.6Gb on disk).<br/> `conda install numpy scipy matplotlib`

 $\Rightarrow$ You may choose **Anaconda** if you are not familiar with programming and/or the command line.

 ## Anaconda installation

 - Go to https://www.anaconda.com/download/

 - Download the installer for your OS:

 ![](anaconda_web.png)

 - Download the installer for your system (it should be auto-detected).

 - Start the installer and follow the instructions.

 - Uncheck python registration if you plan to use other python versions for other projects:

 ![](anaconda_path.png)

 - Run ``Anaconda Navigator'' (from your Start Menu if Windows):

 ![](anaconda_progs.png)

 - Lots of (too many?) programs have been installed. You just need the "Spyder IDE", which can be run from outside this application.

 - Anaconda may ask you to perform an update of "Anaconda Navigator":

 ![](anaconda_update.png)

 - It is a **bad idea** to update the base environment. The update procedure might fail leading the program to an unstable state!

 - The same remark holds for Spyder or any other python package.

 - If you have previously installed an old version of Anaconda for another project, you can create a new and clean ``python 3'' environment:

 ![](anaconda_envs.png)

 - Anaconda is able to handle several versions of python in separate environments.

 - Launch ``Spyder'' (IDE similar to the one of MATLAB):

 ![](anaconda_spyder.png)

 ## How to learn Python?

 - Use the links from the "help" menu:

 ![](anaconda_help.png)

 - Use `CTRL-I` when your cursor is above any unknown command.

 - Free Python books from Springer: https://lib.uliege.be/

 - If you are familiar with MATLAB:
    - [translation of MATLAB commands](http://mathesaurus.sourceforge.net/matlab-numpy.html)
    - [numpy for MATLAB users](https://numpy.org/doc/stable/user/numpy-for-matlab-users.html)

 # Introduction to (scientific) Python

 ## Basic calculations

 %% Cell type:code id:18d32e8c-5a28-4c70-baca-22ca9487a7eb tags:

 ``` python
 # -*- coding: utf-8 -*-
 # the line above allows you to use UTF8 characters in your file

 import math               # loads the 'math' module from python packages

 a = 1                     # a is an integer! use 1.0 or 1. for floats
 b = math.pi/4             # use a "dot" to access 'math' functions/variables
 c = a + math.sin(b)       # "dir(math)" displays all math functions
 print('c =', c)           # strings such as 'c =' could also use double quotes
 ```

 %% Output

    c = 1.7071067811865475

 %% Cell type:markdown id:233a479c-61ef-4b76-b8be-01bc87c0d2bb tags:

 ## Arrays / loops / conditional statements

 %% Cell type:code id:b81213f2-ab0f-476f-913c-bb6ff3bea9bd tags:

 ``` python
 vals = [1, 2, 3, 5, 8, 11, 20]  # this is a python array (called "list")
 for v in vals:                  # for loop: v is the iteration variable
    print('testing ', v)        # the body of the for loop is indented
    if v % 2 == 0:              # % is the modulo operator
        print(v, ' is even')    # once again, use indentation for the body
    else:
        print(v, ' is odd')
 ```

 %% Output

    testing  1
    1  is odd
    testing  2
    2  is even
    testing  3
    3  is odd
    testing  5
    5  is odd
    testing  8
    8  is even
    testing  11
    11  is odd
    testing  20
    20  is even

 %% Cell type:markdown id:f1ab824e-4d94-4176-bead-1fa9e8a6c3c4 tags:

 ## Functions
 Prefer functions to "copying/pasting" code!

 %% Cell type:code id:c1f5c0f7-7948-45cf-b8b7-18166e2c0930 tags:

 ``` python
 def f(A, omega, t=0.0):             # function f has 3 parameters
    """here goes the documentation string"""
    return A*math.sin(omega*t)

 f(1.0, 10.0, 0.01)                   # evaluation for A=1, omega=10 and t=0.01
 ```

 %% Output

    0.09983341664682815

 %% Cell type:code id:a833adac-51fc-4d20-9132-bf1087a64f88 tags:

 ``` python
 f(1.0, 10.0)                         # uses t=0.0 (default value)
 ```

 %% Output

    0.0

 %% Cell type:markdown id:98b75c4f-5d58-4f3f-b935-e9dcba6d6ef5 tags:

 ## Vectors, matrices (and beyond)

 %% Cell type:code id:3f95bd4e-d6ca-43b3-beae-184239c2c5e8 tags:

 ``` python
 import numpy as np                   # we will write np.* instead of numpy.*

 a = [1., 2., 3.]                     # python "list" (no math operators)
 a = (1., 2., 3.)                     # python "tuple" (immutable array)

 a = np.array([1., 2., 3.])           # numpy column-vector (very efficient)
 a[0] = 0.                            # indices start at 0! (as in C)
 print(a.shape)                       # displays (3,) which is a tuple of size 1
 ```

 %% Output

    (3,)

 %% Cell type:markdown id:89e10ae4-2b5d-4daa-92a9-fd13d9d20bdc tags:

 note: $\texttt{a}$ is a column vector (3 rows, 1 column).

 %% Cell type:code id:7bb32295-2c9f-48d7-944b-34e53f885915 tags:

 ``` python
 B = np.array([[ 11, 12, 13, 14 ],
              [ 21, 22, 23, 24 ],
              [ 31, 32, 33, 34 ]])   # numpy matrix
 print(B.shape)                       # displays (3, 4) as "size()" in MATLAB
 ```

 %% Output

    (3, 4)

 %% Cell type:code id:72db949a-4681-48dc-9bb7-998d0faf2962 tags:

 ``` python
 b = np.linspace(0., 10., 101)        # 101 values from 0. to 10.
 print(b)
 ```

 %% Output

    [ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9  1.   1.1  1.2  1.3
      1.4  1.5  1.6  1.7  1.8  1.9  2.   2.1  2.2  2.3  2.4  2.5  2.6  2.7
      2.8  2.9  3.   3.1  3.2  3.3  3.4  3.5  3.6  3.7  3.8  3.9  4.   4.1
      4.2  4.3  4.4  4.5  4.6  4.7  4.8  4.9  5.   5.1  5.2  5.3  5.4  5.5
      5.6  5.7  5.8  5.9  6.   6.1  6.2  6.3  6.4  6.5  6.6  6.7  6.8  6.9
      7.   7.1  7.2  7.3  7.4  7.5  7.6  7.7  7.8  7.9  8.   8.1  8.2  8.3
      8.4  8.5  8.6  8.7  8.8  8.9  9.   9.1  9.2  9.3  9.4  9.5  9.6  9.7
      9.8  9.9 10. ]

 %% Cell type:code id:f56e9114-dfc8-4f06-b9bd-94b6700e6ccc tags:

 ``` python
 c = np.arange(1., 5.)                # c = [1. 2. 3. 4.]
 print(c)
 ```

 %% Output

    [1. 2. 3. 4.]

 %% Cell type:code id:6ba86ed3-10ad-407a-8fea-1f6fa172fe1e tags:

 ``` python
 C = np.zeros( (2,3) )                # 2x3 matrix filled with zeros
 print(C)
 ```

 %% Output

    [[0. 0. 0.]
     [0. 0. 0.]]

 %% Cell type:code id:a9129600-f9b6-444b-8922-ed97bb4f5830 tags:

 ``` python
 D = np.ones( (2,3) )                 # 2x3 matrix filled with ones
 print(D)
 ```

 %% Output

    [[1. 1. 1.]
     [1. 1. 1.]]

 %% Cell type:markdown id:a88f65a8-90b2-40f2-a708-94580a465b42 tags:

 ## Python "oddities" (very important!)

 %% Cell type:code id:947d24ca-18f9-4668-b45b-94758161c020 tags:

 ``` python
 a = np.array([1,2,3])   # a should be seen as a reference (pointer) to an array
 b = a                   # "pointer" b is set to the value of pointer "a"
 b[0] = 0.               # the vector pointed by b is modified
 print(a)                # prints [0 2 3] (!)
 ```

 %% Output

    [0 2 3]

 %% Cell type:code id:e92357c5-ce86-4bd4-a604-4d134b0a20f7 tags:

 ``` python
 c = a.copy()            # creates an independent copy of "a"
 ```

 %% Cell type:markdown id:bcee6b24-0d63-42ca-98c4-1adc224846bb tags:

 ## Matrix/vector operations

 %% Cell type:code id:23946517-ab31-4c0d-8dad-9212b868e05e tags:

 ``` python
 A = np.array([[1,2,3],
              [4,5,6]])
 b = np.array([1,2])
 c = np.array([3,4])
 ```

 %% Cell type:code id:296aec76-2209-45a9-9727-5f25c0e4f517 tags:

 ``` python
 d = b + c               # sum
 print(d)
 ```

 %% Output

    [4 6]

 %% Cell type:code id:2b0c4db5-fd7d-43a1-bd35-0800f2d273f9 tags:

 ``` python
 E = A.transpose()       # transpose of a matrix
 print(E)
 ```

 %% Output

    [[1 4]
     [2 5]
     [3 6]]

 %% Cell type:code id:dddf9979-ed72-466c-b50a-d9b369d36567 tags:

 ``` python
 f = np.matmul(E, b)     # matrix multiplication
                        # ("*" is the element-wise operation as ".*" in MATLAB)
 print(f)
 ```

 %% Output

    [ 9 12 15]

 %% Cell type:code id:1ab8f77a-9fc5-4f9b-aa22-2bf2237a3308 tags:

 ``` python
 bt = b.reshape(1,2)     # column vector => line vector
 print(bt)
 ```

 %% Output

    [[1 2]]

 %% Cell type:code id:0b6194b3-ac89-4d74-b548-fc705a055f79 tags:

 ``` python
 d.dot(b)                # dot product
 ```

 %% Output

    16

 %% Cell type:markdown id:f8ac0f5b-521e-424f-8434-998a6789efe4 tags:

 ## Slices

 %% Cell type:code id:9f6de2e2-fd97-420a-894d-715f33efaffb tags:

 ``` python
 A = np.array([[ 11, -12, 13, -14 ],
              [ -21, 22, -23, 24 ],
              [ 31, 32, 33, 34 ]])
 print(A)
 ```

 %% Output

    [[ 11 -12  13 -14]
     [-21  22 -23  24]
     [ 31  32  33  34]]

 %% Cell type:code id:3cf5e680-94a4-409a-9373-f33218a0a9b9 tags:

 ``` python
 A[1,2]	                          # A(2,3) in MATLAB
 ```

 %% Output

    -23

 %% Cell type:code id:9b7bf918-abb8-4b61-a4ec-b414ff6f74d8 tags:

 ``` python
 A[0,]                             # A(1,:) in MATLAB (first row)
 ```

 %% Output

    array([ 11, -12,  13, -14])

 %% Cell type:code id:8936a565-0c06-4bbf-b541-cb95847a4098 tags:

 ``` python
 A[:,0]                            # A(:,1) in MATLAB (first column)
 ```

 %% Output

    array([ 11, -21,  31])

 %% Cell type:code id:1fca4996-0564-4ab1-9ddb-f355768b0d20 tags:

 ``` python
 A[1:,]                            # A(2:end,:) in MATLAB (all, except first row)
 ```

 %% Output

    array([[-21,  22, -23,  24],
           [ 31,  32,  33,  34]])

 %% Cell type:code id:e79b4919-6cf2-4293-8186-33c5045044fa tags:

 ``` python
 A[-2:,]                           # A(end-1:end,:) in MATLAB (last two rows)
 ```

 %% Output

    array([[-21,  22, -23,  24],
           [ 31,  32,  33,  34]])

 %% Cell type:markdown id:ad66de2d-46bd-4555-8a53-f7ec604dcc60 tags:

 ## Linear algebra

 %% Cell type:code id:a3310d19-6d05-4a2f-b22e-88834ac07994 tags:

 ``` python
 B = np.matmul(A, A.transpose())   # square matrix
 print(B)
 ```

 %% Output

    [[  630 -1130   -90]
     [-1130  2030   110]
     [  -90   110  4230]]

 %% Cell type:code id:67b6a033-d84f-4ffd-9d1f-194341c280fc tags:

 ``` python
 np.linalg.det(B)                  # determinant
 ```

 %% Output

    6767999.999999746

 %% Cell type:code id:f5d071a3-d82c-43b6-9687-70f18159bdfc tags:

 ``` python
 (vals, vecs) = np.linalg.eig(B)   # eigenvalues / eigenvectors
 print(vals)
 ```

 %% Output

    [6.02701054e-01 2.64688850e+03 4.24250880e+03]

 %% Cell type:code id:2e4d6341-6037-4d5a-8e61-01f197728b60 tags:

 ``` python
 print(vecs)
 ```

 %% Output

    [[-0.87381107 -0.48389356 -0.04797116]
     [-0.48622919  0.87069032  0.07402395]
     [-0.00594831 -0.08800792  0.99610201]]

 %% Cell type:code id:0a08d7c4-ad05-4de2-a60a-328cb43f3337 tags:

 ``` python
 rhs = np.array([1,1,1])
 x = np.linalg.solve(B,rhs)        # solves [B]{x} = {rhs}
 print(x)
 ```

 %% Output

    [1.98037825 1.10212766 0.01371158]

 %% Cell type:code id:4758c366-1ae8-4455-b4c5-0a3f97820cc3 tags:

 ``` python
 print(B.dot(x))    # or np.matmul(B,x)
 ```

 %% Output

    [1. 1. 1.]

 %% Cell type:markdown id:35728504-5ebb-4a64-9b87-6f7d99bd764f tags:

 ## Concatenation

 %% Cell type:code id:c47dc9c1-43cf-434d-b1e9-ab846606a8e2 tags:

 ``` python
 a = np.arange(1, 5)                   # a=1:4 in MATLAB
 print(a)
 ```

 %% Output

    [1 2 3 4]

 %% Cell type:code id:c30d6556-69d7-4dc5-9039-a9aa795e6421 tags:

 ``` python
 b = np.concatenate( ([0], a, [5]) )
 print(b)
 ```

 %% Output

    [0 1 2 3 4 5]

 %% Cell type:code id:ccebba07-28d6-49ba-87fc-889b92fbd849 tags:

 ``` python
 c = np.vstack( (a, a) )               # vertical stacking
 print(c)
 ```

 %% Output

    [[1 2 3 4]
     [1 2 3 4]]

 %% Cell type:code id:3e7ff597-56e0-4cb8-8233-3fe78373115a tags:

 ``` python
 d = np.hstack( (a, a) )               # horizontal stacking
 print(d)
 ```

 %% Output

    [1 2 3 4 1 2 3 4]

 %% Cell type:markdown id:6e7a7fdd-d06c-4f90-92a9-21338f4ef480 tags:

 ## Basic plot example

-%% Cell type:code id:89183b94-2850-4daa-a452-c7ab3f400712 tags:
-
-``` python
-# %matplotlib inline
-```
-
 %% Cell type:code id:03823bda-9932-4e60-b036-21b55a2999a2 tags:

 ``` python
 import numpy as np
 import matplotlib.pyplot as plt

 x = np.linspace(0., 4*np.pi, 100)
 f = np.sin(x)
 g = np.cos(2*x) + 0.5*np.sin(4*x)

 fig = plt.figure()
 plt.plot(x, f, 'b-', label='f(x)')
 plt.plot(x, g, 'r-', label='g(x)')   # figure is "held" by default
 plt.grid()
 plt.legend()
 plt.xlabel('x')
 plt.ylabel('y')
 plt.title(r"$\lambda=5$")  # latex commands are ok (r means "raw" string)

 fig.savefig('fig.pdf')  # save your fig in a vector format (.pdf or .eps)

 plt.show()
 ```

 %% Output



 %% Cell type:markdown id:27e6e8e6-141e-414a-b520-b21b90f48ac7 tags:

 ## Improved plot

 %% Cell type:code id:72ca7562-882d-439c-bf74-44f0bd4b89db tags:

 ``` python
 # additionnal options
 plt.rcParams.update({'figure.autolayout': True})  # = plt.tight_layout()
 plt.rcParams.update({'font.size': 14})  # increases default font size

 x = np.linspace(0., 4*np.pi, 100)
 f = np.sin(x)
 g = np.cos(2*x)+0.5*np.sin(4*x)

 fig = plt.figure()
 plt.plot(x, f, 'b-', label='f(x)')
 plt.plot(x, g, 'r-', label='g(x)')
 plt.grid()
 plt.legend(loc='upper center', ncol=2, fontsize='small')
 plt.xlabel('x')
 plt.ylabel('y')
 plt.axhline(0.0, color='black')  # black x axis
 plt.title(r"$\lambda=5$")
 yl1, yl2 = plt.ylim()
 dy = yl2-yl1
 plt.ylim(yl2-dy*1.1, yl1+dy*1.2)  # more space above curves

 plt.show()
 ```

 %% Output



 %% Cell type:markdown id:b256ea83-5b4a-4f7e-a829-fc656efc9ee6 tags:

 ## 3D plot

 %% Cell type:code id:31774ac4-efb6-4696-bacc-b2106ec041db tags:

 ``` python
 import numpy as np
 import matplotlib
 import matplotlib.pyplot as plt

 fig = plt.figure()
 ax = fig.add_subplot(111, projection='3d')

 x = np.linspace(0, 2*np.pi, 20)
 y = np.linspace(0, 2*np.pi, 20)

 X, Y = np.meshgrid(x, y)
 Z = np.sin(X)+np.cos(Y)

 ax.plot_surface(X,Y,Z, cmap=matplotlib.cm.coolwarm)

 ax.set_xlabel(r'$x$')
 ax.set_ylabel(r'$y$')
 ax.set_zlabel(r'$z=\sin(x)+\cos(y)$')

 plt.show()
 ```

 %% Output



 %% Cell type:markdown id:2d52fbcb-0756-4d8b-b430-98cd02d7da77 tags:

 ## Solving a sparse linear system

 %% Cell type:code id:227f43af-4b18-4fd0-a2f8-a28139cb5b6a tags:

 ``` python
 import scipy.sparse
 import scipy.sparse.linalg

 nnod = 10  # number of nodes

 # sparse matrix creation
 Ai = []  # row indexes
 Aj = []  # column indexes
 Av = []  # values
 f = np.zeros(nnod)  # system rhs

 # assembly
 # ...fill Ai, Aj, Av lists with (i,j,v) values
 # ...fill f with f[ni] += fe[i]

 # implementation has been deleted => this will produce an error

 # build CSR matrix from tuples (Ai, Aj, Av)
 # note: values with same (i,j) are summed!
 K = scipy.sparse.csr_matrix((Av, (Ai, Aj)), shape=(nnod, nnod))

 # solve system
 u = scipy.sparse.linalg.spsolve(K, f)
 ```

 %% Output

    /usr/lib/python3/dist-packages/scipy/sparse/linalg/_dsolve/linsolve.py:206: MatrixRankWarning: Matrix is exactly singular
      warn("Matrix is exactly singular", MatrixRankWarning)

 %% Cell type:markdown id:8d87061b-07e6-4067-b3dc-c43a6039c4b0 tags:

 see also [sparse matrices (scipy.org)](https://docs.scipy.org/doc/scipy/reference/sparse.html).

 %% Cell type:markdown id:2cfb0327-9acc-47fd-a4f3-6ef1c78b8af7 tags:

 # Object-Oriented Programming (OOP)

 ## A quick introduction

 Python is said to be **object-oriented**, as many modern programming languages, which means that you can create **your own types** of data beyond the basic types provided by the language (integers, floating-point numbers, strings, etc.).

 Learning to write good object-oriented code is not easy but it can be learnt **incrementally**. You may take advantage of this homework to get familiar with OOP and you may try to write your first objects (with our help).

 This opportunity to learn OOP was requested by the students from last years, although we never asked them to write object-oriented programs. Using OOP in your homework is **not mandatory**.

 Leaning OOP with python is much easier than learning it with compiled languages such as C++, Java, C#, etc.

 ## Classes

 New types are defined in **classes**.

 A class gathers several variables which are used together. This is similar to a structure (`struct`) in C.

 %% Cell type:code id:55129318-41c7-489f-a1b9-5ed24a0588a9 tags:

 ``` python
 class Vec:
 	"a class is a series of variables used together"
 	def __init__(self, x, y):
 		""" this function is called 'the constructor' of the class
 		it is called each time a new variable of the type Vec is created
 		"""
 		self.x = x  # 'self' refers to 'this object'
 		self.y = y  # stores y in the object
 ```

 %% Cell type:code id:5382eb75-ecb4-4cf3-84f1-125577ec568e tags:

 ``` python
 v = Vec(1, 2)  # creates an object of type Vec and calls Vec.__init__(v, 1, 2)
 print(v.x)
 ```

 %% Output

    1

 %% Cell type:code id:5bbfa8d9-7346-4ca2-931c-36cb44e26a10 tags:

 ``` python
 norm = math.sqrt(v.x*v.x + v.y*v.y) # computes the norm
 print(norm)
 ```

 %% Output

    2.23606797749979

 %% Cell type:markdown id:c337e31c-e93b-41d9-a66a-4ce226ab3243 tags:

 A variable of type `Vec` is called an **instance** of the class or **object**.

 `self.x` and `self.y` are called **attributes** (or **variable members**).

 Classes are much richer than structures. You can define functions in classes. They are called **methods** (or **member functions**):

 %% Cell type:code id:80bbbbc7-ea4d-4e3a-bb0a-3bf13761a34f tags:

 ``` python
 class Vec:
 	"basic 2D vector class"
 	def __init__(self, x=0.0, y=0.0): # you can set default values for the args
 		self.x = x
 		self.y = y

 	def norm(self):
 		"computes the norm of the vector"
 		return math.sqrt(self.x*self.x + self.y*self.y)
 ```

 %% Cell type:code id:1f011953-2b43-4288-9577-a25436a34b8f tags:

 ``` python
 v = Vec(1, 2)
 norm = v.norm()  # calls Vec.norm(self=v)
 print(norm)
 ```

 %% Output

    2.23606797749979

 %% Cell type:markdown id:57d87595-027c-4cc8-9b9f-03a300125166 tags:

 Advantage: the user of the class does not need to know how the components of the vector are stored in the object.

 Hiding implementation details is called **abstraction**.

 Imagine that the implementation of the `Vec` class changes:

 %% Cell type:code id:eeb062a6-5c90-456e-8350-5233bf633afe tags:

 ``` python
 class Vec:
 	"basic 2D vector class"
 	def __init__(self, x=0.0, y=0.0):
 		self.v = [x,y]              # <= use a list instead of 2 variables

 	def norm(self):
 		"computes the norm of the vector"
 		return math.sqrt(self.v[0]*self.v[0] + self.v[1]*self.v[1])
 ```

 %% Cell type:markdown id:19f0b159-a565-45ab-868c-96214b63fca0 tags:

 The code using the class does not need any modification.

 %% Cell type:code id:4ef7a604-80d4-4923-a909-8c208ab3315e tags:

 ``` python
 v = Vec(1, 2)
 norm = v.norm()  # calls Vec.norm(self=v)
 print(norm)
 ```

 %% Output

    2.23606797749979

 %% Cell type:markdown id:c8e12273-f82b-4e08-9b4e-c786d84c8f1b tags:

 Gathering functions and variables into objects reduce the amount of global variables and functions of the code, leading to more **modularity**.

 Special functions can be added so that our new vector behaves as we could expect.

 For example we can add a method for the addition of 2 vectors:

 %% Cell type:code id:21ea1f1c-df08-472b-9e51-7a017ac63ccd tags:

 ``` python
 class Vec:
 	"basic 2D vector class"
 	def __init__(self, x=0.0, y=0.0):
 		self.x, self.y = x, y

 	def __add__(self, v):
 		"computes self + v"
 		return Vec(self.x+v.x, self.y+v.y)

 	def __str__(self):
 		"builds a string representation of self"
 		return f"[{self.x},{self.y}]"
 ```

 %% Cell type:code id:2a132ac4-b220-4c1c-9830-31fa6057a7ec tags:

 ``` python
 v1 = Vec(1, 2)
 v2 = Vec(1, 1)
 v3 = v1+v2      # calls v1.__add__(v2) and returns Vec(2,3)
 print(v3)       # calls Vec.__str__(v3) and prints [2,3]
 ```

 %% Output

    [2,3]

 %% Cell type:markdown id:e2d35191-e76b-4eb5-aabb-6d3aa199fe25 tags:

 In OOP, this is called **operator overloading**.

 ## Objects for Finite Elements?

 There are many ways to define "objects" in the frame of the implementation of the finite element method. **There is no unique or best choice.**

 Ideas of objects could come from mathematical concepts or words that are used in the statement of the exercise.
 Possible objects:
 - BoundaryValueProblem
 - WeakForm
 - ShapeFunction
 - Node
 - FiniteElement
 - DirichletBC, NeumannBC
 - LinearSolver

 The choice depends on the size of the simulation code, the number of features that should be implemented, the amount of time you want to invest in learning OOP.

 OOP is also closely related to **refactoring techniques**. Refactoring means "improving the structure of the code without adding new features".

 It means that you can start writing the first lines of your code with a very limited number of objects (or even no object at all).

 Then, as the number of lines increases, if you see that many functions act on the same set of variables, it is usually a good idea to "refactor" your program and create a class gathering these variables together.

 By doing this, you do not create classes that are unnecessary. Indeed, using too many classes can lead to unreadable code. This is a common problem while learning OOP ("**do not make each byte an object**").

 ## Example

 Implementation of a basic finite element solver for the Helmholtz equation in 1D:
 $$
 \frac{d^2u}{dx^2}+k^2u = 0\qquad x\in ]0,L[ \text{ and } k\in\mathbb{R}
 $$
 with appropriate boundary conditions.

 The problem is solved by an object named `Solver` which contains the main parameters and a `solve()` function

 %% Cell type:code id:dc288d05-da4a-48b1-aedd-578342f873fa tags:

 ``` python
 class Solver:
    def __init__(self, k, L, ne):
        self.k = k      # wave number
        self.L = L      # domain length
        self.ne = ne    # nb of finite elements
    def solve(self):
        "do the FE calculations"
        pass            # (implementation deleted)
    def display(self, figname):
        "display results"
        pass            # (implementation deleted)
 ```

 %% Cell type:markdown id:3762385c-2e46-481e-9ebe-38d9885fb298 tags:

 In the `Solver` object, the mesh is stored as an array of `Nodes` and an array of `Elements`:

 %% Cell type:code id:6d6358dd-0a31-446a-b064-55af134e09e2 tags:

 ``` python
 class Node:
    "a Node is an index to global vectors (x, u, etc)"
    def __init__(self, idx):
        self.idx = idx

 class Element:
    "a 1D finite Element with linear shape functions"
    def __init__(self, n1, n2):
        self.nodes = [n1, n2]
    def getM(self, x):
        "compute the elemental mass matrix M"
        x1, x2 = [x[n.idx] for n in self.nodes]
        # (implementation deleted)
    def getK(self, x):
        "compute the elemental stiffness matrix K"
        # (implementation deleted)
    def h(self, x):
        "returns the length of the element"
        return x[self.nodes[-1].idx] - x[self.nodes[0].idx]
 ```

 %% Cell type:markdown id:72074425-9a6c-434c-92a6-93511be0f556 tags:

 Once everything is implemented, the usage of these objects leads to a very self-explanatory code:

 %% Cell type:code id:05da87dd-4e06-4574-b314-7aac8a105ad3 tags:

 ``` python
 def main():

    k = 10   # wave number
    L = 1.   # length of the domain

    # solve the problem for 2 given numbers of FEs
    solver = Solver(k, L, ne=20)
    solver.solve()
    solver.display('fem_ne20')

    solver = Solver(k, L, ne=60)
    solver.solve()
    solver.display('fem_ne60')
 ```

 %% Cell type:code id:3e2bf0ae-81bd-4606-ab98-1f589bf92b06 tags:

 ``` python
 def convergence_study():

    hs = []
    errors = []
    for i in range(1, 6):
        solver = Solver(k, L, ne=10**i)
        solver.solve()
        print(f'h = {solver.h: <10}error = {solver.error}')
        hs.append(solver.h)
        errors.append(solver.error)

    f = plt.figure()
    plt.loglog(hs, errors, 'o-')
    #...
    f.show()
    plt.savefig(f'fig_error.svg')
 ```

 %% Cell type:markdown id:83fbb567-b4e7-4dd4-a445-e9911aa195e1 tags:

 Note that the same level of clarity could be easily obtained with well-defined functions in a traditional functional-programming approach!

 ## Final remarks on Object-Oriented Programming
 - Once again: using objects is **not mandatory** for the project. Use classical functional programming (as you already did in C or any other language) if you are new to Python and/or finite elements.
 - Keep in mind that using objects is **usually not recommended for such small programs** unless you want to "play" with objects and learn how OOP works in the frame of python.
 - This introduction lacks one of the most interesting feature of OOP: **polymorphism**. It allows you to define derived types of data (by **inheritance**) and to manipulate their instances without knowing their exact types.