+# $ conda activate math-python +# (math-python) $ python +# Python 3.7.4 (default, Jul 17 2019, 16:44:45) +# [GCC 4.2.1 Compatible Apple LLVM 8.1.0 (clang-802.0.42)] on darwin +# Type "help", "copyright", "credits" or "license" for more information. +# >>> quit() +#+# +# [Conda envs documentation](https://conda.io/docs/using/envs.html). + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### 5. Managing packages with conda +# +# * Use conda-forge channel +# ```sh +# conda config --add channels conda-forge +# ``` +# +# * List all packages +# ```sh +# conda list +# ``` +# +# * Search a package +# ```sh +# conda search jupyter +# ``` +# +# You can also update or remove, check the [documentation](https://conda.io/docs/using/pkgs.html). + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### 6. Install jupyter with extensions +# +# ``` +# conda install jupyter_contrib_nbextensions +# conda install autopep8 +# ``` + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### 7. Enable autopep8 extension +# +# ``` +# jupyter nbextension enable code_prettify/autopep8 +# ``` + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## With pip + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### 1. First create a [Python environment](https://docs.python.org/3/library/venv.html) +# +# ```dos +# C:\>python -m venv C:\Users\'Username'\my-venv +# C:\Users\'Username'\my-venv\Scripts\activate.bat +# ``` + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### 2. Install pip +# +# ``` +# python -m pip install --upgrade pip +# ``` + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### 3. Install jupyter with extensions + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# ``` +# pip install jupyter_contrib_nbextensions +# jupyter contrib nbextension install --sys-prefix +# pip install autopep8 dataclasses +# jupyter nbextension enable code_prettify/autopep8 +# ``` + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### 4. Managing Packages with pip +# +# - Search a package +# +# ```bash +# pip search lorem +# ``` +# +# - Install a package (or update if it is already installed) +# +# ```bash +# pip install -U lorem +# ``` +# +# - List packages installed +# +# ```bash +# pip list +# ``` +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Get jupyter notebooks +# +# +# ### Clone the repository with git +# +# ``` +# conda install git # install with conda if not present +# git config --global user.name “Prenom Nom" +# git config --global user.email “prenom.nom@univ-rennes1.fr" +# git clone https://github.com/pnavaro/python-notebooks.git +# ``` +# +# ### Or download zip archive. +# +# https://github.com/pnavaro/python-notebooks/archive/master.zip +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Installing Python Packages from a Jupyter Notebook +# +# ### conda package in the current Jupyter kernel +# +# Example with package `lorem` from *conda-forge* +# ```python +# %conda install lorem +# ``` +# +# ### pip package in the current Jupyter kernel +# ``` +# import sys +# %pip install lorem +# ``` diff --git a/01.Introduction.py b/01.Introduction.py new file mode 100644 index 0000000..0017f26 --- /dev/null +++ b/01.Introduction.py @@ -0,0 +1,251 @@ +# -*- coding: utf-8 -*- +# --- +# jupyter: +# jupytext: +# comment_magics: false +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.2' +# jupytext_version: 1.2.2 +# kernelspec: +# display_name: Python 3.7 +# language: python +# name: python3 +# --- + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Python + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +#  + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # History +# +# - Project initiated by Guido Von Rossum in 1990 +# - Interpreted language written in C. +# - Widely used in all domains (Web, Data Science, Scientific Computation). +# - This is a high level language with a simple syntax. +# - Python types are numerously and powerful. +# - Bind Python with other languages is easy. +# - You can perform a lot of operations with very few lines. +# - Available on all platforms Unix, Windows, Mac OS X... +# - Very few limits. +# - Many libraries offer Python bindings. +# +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Python 2 and 3 version +# - Python 3.x isn't a simple improvement or extension of Python 2.x. +# - All libraries exist in version 3 but both versions coexist. +# - Every example are written in Python 3.x, it is the default version. +# - Changes in official documentation: [https://docs.python.org/3/whatsnew/3.0.html] +# - `print` is now a function `print()` with `sep` argument. +# - Some function return "views" instead of "lists". +# - In version 3 division operator isn't pure (7/2 = 3.5). +# - `range` function doesn't return list anymore. Use `list(range(n))`. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Porting your code +# - http://www.diveintopython3.net/porting-code-to-python-3-with-2to3.html +# - [Python-Future](http://python-future.org/quickstart.html) offers Python 2 compatibility. +# - [Migrating to Python 3 with pleasure](https://github.com/arogozhnikov/python3_with_pleasure?utm_campaign=Data%2BElixir&utm_medium=email&utm_source=Data_Elixir_165) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Python distributions +# +# Python packages are available with all linux distributions but you can get standalone bundles: +# +# - [Anaconda](https://www.continuum.io/downloads) +# - [Enthought Python Distribution](http://www.enthought.com/products/epd.php) +# - [Astropy](http://www.astropy.org) +# - [SAGEMATH](http://sagemath.org/) +# - [Pyzo](http://www.pyzo.org) +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Performances +# Python is not fast... but: +# - Sometimes it is. +# - Most of operations are optimized. +# - Package like numpy can reduce the CPU time. +# - With Python you can save time to achieve your project. +# +# Some advices: +# - Write your program with Python language. +# - If it is fast enough, be happy. +# - After profiling, optimize costly parts of your code. +# +# "Premature optimization is the root of all evil" (Donald Knuth 1974) +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Jupyter - Start The Notebook +# +# +# Open the notebook +# ``` +# cd python-notebooks +# jupyter notebook +# ``` +# You should see the notebook open in your browser. If not, go to http://localhost:8888 +# +# The Jupyter Notebook is an interactive environment for writing and running code. The notebook is capable of running code in a wide range of languages. However, each notebook is associated with Python3 kernel. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Code cells allow you to enter and run code +# +# **Make a copy of this notebook by using the File menu.** +# +# Run a code cell using `Shift-Enter` or pressing the button in the toolbar above: +# +# There are two other keyboard shortcuts for running code: +# +# * `Alt-Enter` runs the current cell and inserts a new one below. +# * `Ctrl-Enter` run the current cell and enters command mode. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# +# +# ## Managing the Kernel +# +# Code is run in a separate process called the Kernel. The Kernel can be interrupted or restarted. Try running the following cell and then hit the button in the toolbar above. +# +# The "Cell" menu has a number of menu items for running code in different ways. These includes: +# +# * Run and Select Below +# * Run and Insert Below +# * Run All +# * Run All Above +# * Run All Below +# +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Restarting the kernels +# +# The kernel maintains the state of a notebook's computations. You can reset this state by restarting the kernel. This is done by clicking on the in the toolbar above. +# +# +# Check the [documentation](https://jupyter-notebook.readthedocs.io/en/latest/examples/Notebook/Notebook%20Basics.html). + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # First program +# +# - Print out the string "Hello world!" and its type. +# - Print out the value of `a` variable set to 6625 and its type. + +# %% {"slideshow": {"slide_type": "fragment"}} +s = "Hello World!" +print(type(s),s) +a = 6625 +print(type(a),a) +a+s + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Execute using python + +# %% {"slideshow": {"slide_type": "fragment"}} +%%file hello.py + +s = "Hello World!" +print(type(s),s) +a = 6625 +print(type(a),a) + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# ```bash +# $ python3 hello.py +#
+# marseille +# ├── __init__.py +# ├── calanques +# │ ├── __init__.py +# │ ├── morgiou.py +# │ ├── sorgiou.py +# │ └── sugiton.py +# └── cirm +# ├── __init__.py +# ├── annexe.py +# ├── auditorium.py +# └── bastide.py +#+ +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Relative imports +# +# These imports use leading dots to indicate the current and parent packages involved in the relative import. In the sugiton module, you can use: +# ```python +# from . import morgiou # import module in the same directory +# from .. import cirm # import module in parent directory +# from ..cirm import bastide # import module in another subdirectory of the parent directory +# ``` + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Reminder +# +# Don't forget that importing * is not recommended + +# %% {"slideshow": {"slide_type": "fragment"}} +sum(range(5),-1) + +# %% {"slideshow": {"slide_type": "fragment"}} +from numpy import * +sum(range(5),-1) + +# %% {"slideshow": {"slide_type": "slide"}} +del sum # delete imported sum function from numpy +help(sum) + +# %% {"slideshow": {"slide_type": "slide"}} +import numpy as np +help(np.sum) diff --git a/06.Input.And.Output.py b/06.Input.And.Output.py new file mode 100644 index 0000000..469c610 --- /dev/null +++ b/06.Input.And.Output.py @@ -0,0 +1,256 @@ +# -*- coding: utf-8 -*- +# --- +# jupyter: +# jupytext: +# comment_magics: false +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.2' +# jupytext_version: 1.1.1 +# kernelspec: +# display_name: Python 3 +# language: python +# name: python3 +# --- + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Input and Output +# - str() function return human-readable representations of values. +# - repr() generate representations which can be read by the interpreter. +# - For objects which don’t have a particular representation for human consumption, str() will return the same value as repr(). + +# %% {"slideshow": {"slide_type": "fragment"}} +s = 'Hello, world.' +str(s) + +# %% {"slideshow": {"slide_type": "fragment"}} +l = list(range(4)) +str(l) + +# %% {"slideshow": {"slide_type": "fragment"}} +repr(s) + +# %% {"slideshow": {"slide_type": "fragment"}} +repr(l) + +# %% {"slideshow": {"slide_type": "slide"}} +x = 10 * 3.25 +y = 200 * 200 +s = 'The value of x is ' + str(x) + ', and y is ' + repr(y) + '...' +print(s) + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# repr() of a string adds string quotes and backslashes: + +# %% {"slideshow": {"slide_type": "fragment"}} +hello = 'hello, world\n' +hellos = repr(hello) +hellos + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# The argument to repr() may be any Python object: + +# %% {"slideshow": {"slide_type": "fragment"}} +repr((x, y, ('spam', 'eggs'))) + +# %% {"slideshow": {"slide_type": "slide"}} +n = 7 +for x in range(1, n): + for i in range(n): + print(repr(x**i).rjust(i+2), end=' ') # rjust or center can be used + print() + +# %% {"slideshow": {"slide_type": "fragment"}} +for x in range(1, n): + for i in range(n): + print("%07d" % x**i, end=' ') # old C format + print() + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Usage of the `str.format()` method + +# %% {"slideshow": {"slide_type": "fragment"}} +print('We are at the {} in {}!'.format('osur', 'Rennes')) + +# %% {"slideshow": {"slide_type": "fragment"}} +print('From {0} to {1}'.format('November 17', 'November 24')) + +# %% {"slideshow": {"slide_type": "fragment"}} +print('It takes place at {place}'.format(place='Milon room')) + +# %% {"slideshow": {"slide_type": "fragment"}} +import math +print('The value of PI is approximately {:.7g}.'.format(math.pi)) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Formatted string literals (Python 3.6) + +# %% {"slideshow": {"slide_type": "fragment"}} +print(f'The value of PI is approximately {math.pi:.4f}.') + +# %% {"slideshow": {"slide_type": "fragment"}} +name = "Fred" +print(f"He said his name is {name}.") +print(f"He said his name is {name!r}.") + +# %% {"slideshow": {"slide_type": "fragment"}} +f"He said his name is {repr(name)}." # repr() is equivalent to !r + +# %% {"slideshow": {"slide_type": "fragment"}} +width, precision = 10, 4 +value = 12.34567 +print(f"result: {value:{width}.{precision}f}") # nested fields + +# %% {"slideshow": {"slide_type": "fragment"}} +from datetime import * +today = datetime(year=2017, month=1, day=27) +print(f"{today:%B %d, %Y}") # using date format specifier + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Exercise +# Create a list containing the values of [binomial coefficients](https://en.wikipedia.org/wiki/Binomial_coefficient) and reproduce the [Pascal's triangle](https://en.wikipedia.org/wiki/Pascal%27s_triangle) +#
+# 1 +# 1 1 +# 1 2 1 +# 1 3 3 1 +# 1 4 6 4 1 +# 1 5 10 10 5 1 +# 1 6 15 20 15 6 1 +# 1 7 21 35 35 21 7 1 +#+# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Reading and Writing Files +# +# `open()` returns a file object, and is most commonly used with file name and accessing mode argument. +# + +# %% {"slideshow": {"slide_type": "fragment"}} +f = open('workfile.txt', 'w') +f.write("1. This is a txt file.\n") +f.write("2. \\n is used to begin a new line") +f.close() +!cat workfile.txt + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# `mode` can be : +# - 'r' when the file will only be read, +# - 'w' for only writing (an existing file with the same name will be erased) +# - 'a' opens the file for appending; any data written to the file is automatically added to the end. +# - 'r+' opens the file for both reading and writing. +# - The mode argument is optional; 'r' will be assumed if it’s omitted. +# - Normally, files are opened in text mode. +# - 'b' appended to the mode opens the file in binary mode. + +# %% {"slideshow": {"slide_type": "slide"}} +with open('workfile.txt') as f: + read_text = f.read() +f.closed + +# %% {"slideshow": {"slide_type": "fragment"}} +read_text + +# %% {"slideshow": {"slide_type": "fragment"}} +lines= [] +with open('workfile.txt') as f: + lines.append(f.readline()) + lines.append(f.readline()) + lines.append(f.readline()) + +lines + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# - `f.readline()` returns an empty string when the end of the file has been reached. +# - `f.readlines()` or `list(f)` read all the lines of a file in a list. +# +# For reading lines from a file, you can loop over the file object. This is memory efficient, fast, and leads to simple code: + +# %% {"slideshow": {"slide_type": "fragment"}} +with open('workfile.txt') as f: + for line in f: + print(line, end='') + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Exercise: Wordcount Example +# +# [WordCount](https://hadoop.apache.org/docs/current/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.html#Example:_WordCount_v1.0) is a simple application that counts the number of occurrences of each word in a given input set. +# +# - Use lorem module to write a text in the file "sample.txt" +# - Write a function `words` with file name as input that returns a sorted list of words present in the file. +# - Write the function `reduce` to read the results of words and sum the occurrences of each word to a final count, and then output the results as a dictionary +# `{word1:occurences1, word2:occurences2}`. +# - You can check the results using piped shell commands: +# ```sh +# cat sample.txt | fmt -1 | tr [:upper:] [:lower:] | tr -d '.' | sort | uniq -c +# ``` + +# %% {"slideshow": {"slide_type": "slide"}} +from lorem import text + +text() + + +# %% {"slideshow": {"slide_type": "slide"}} +def words( file ): + """ Parse a file and returns a sorted list of words """ + pass + +words('sample.txt') +#[('adipisci', 1), +# ('adipisci', 1), +# ('adipisci', 1), +# ('aliquam', 1), +# ('aliquam', 1), + +# %% {"slideshow": {"slide_type": "fragment"}} +d = {} +d['word1'] = 3 +d['word2'] = 2 +d + + +# %% {"slideshow": {"slide_type": "slide"}} +def reduce ( words ): + """ Count the number of occurences of a word in list + and return a dictionary """ + pass + +reduce(words('sample.txt')) +#{'neque': 80), +# 'ut': 80, +# 'est': 76, +# 'amet': 74, +# 'magnam': 74, +# 'adipisci': 73, + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Saving structured data with json +# +# - JSON (JavaScript Object Notation) is a popular data interchange format. +# - JSON format is commonly used by modern applications to allow for data exchange. +# - JSON can be used to communicate with applications written in other languages. + +# %% {"slideshow": {"slide_type": "fragment"}} +import json +json.dumps([1, 'simple', 'list']) + +# %% {"slideshow": {"slide_type": "fragment"}} +x = dict(name="Pierre Navaro", organization="CNRS", position="IR") +with open('workfile.json','w') as f: + json.dump(x, f) + +# %% {"slideshow": {"slide_type": "fragment"}} +with open('workfile.json','r') as f: + x = json.load(f) +x + +# %% {"slideshow": {"slide_type": "slide"}} +%cat workfile.json + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# Use `ujson` for big data structures +# https://pypi.python.org/pypi/ujson +# diff --git a/07.Errors.and.Exceptions.py b/07.Errors.and.Exceptions.py new file mode 100644 index 0000000..a0e177c --- /dev/null +++ b/07.Errors.and.Exceptions.py @@ -0,0 +1,137 @@ +# --- +# jupyter: +# jupytext: +# comment_magics: false +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.2' +# jupytext_version: 1.1.1 +# kernelspec: +# display_name: Python 3 +# language: python +# name: python3 +# --- + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Errors and Exceptions +# +# There are two distinguishable kinds of errors: *syntax errors* and *exceptions*. +# - Syntax errors, also known as parsing errors, are the most common. +# - Exceptions are errors caused by statement or expression syntactically corrects. +# - Exceptions are not unconditionally fatal. +# +# [Exceptions in Python documentation](https://docs.python.org/3/library/exceptions.html) + +# %% {"slideshow": {"slide_type": "slide"}} +10 * (1/0) + +# %% {"slideshow": {"slide_type": "slide"}} +4 + spam*3 + +# %% {"slideshow": {"slide_type": "slide"}} +'2' + 2 + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Handling Exceptions +# +# - In example below, the user can interrupt the program with `Control-C` or the `stop` button in Jupyter Notebook. +# - Note that a user-generated interruption is signalled by raising the **KeyboardInterrupt** exception. +# + +# %% {"slideshow": {"slide_type": "fragment"}} +while True: + try: + x = int(input("Please enter a number: ")) + print(f' x = {x}') + break + except ValueError: + print("Oops! That was no valid number. Try again...") + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# - A try statement may have more than one except clause +# - The optional `else` clause must follow all except clauses. + +# %% {"slideshow": {"slide_type": "fragment"}} +import sys + +def process_file(file): + try: + i = int(open(file).readline().strip()) # Read the first line of f and convert to int + print(i) + assert i < 0 # check if i is negative + except OSError as err: + print(f"OS error: {err}") + except ValueError: + print("Could not convert data to an integer.") + except: + print("Unexpected error:", sys.exc_info()[0]) + +# Create the file workfile.txt +with open('workfile.txt','w') as f: + f.write("foo") + f.write("bar") + +# %% {"slideshow": {"slide_type": "slide"}} +process_file('workfile.txt') # catch exception return by int() call + +# %% {"slideshow": {"slide_type": "slide"}} +# Change permission of the file, workfile.txt cannot be read +!chmod u-r workfile.txt + +# %% {"slideshow": {"slide_type": "fragment"}} +process_file('workfile.txt') # catch exception return by open() call + +# %% {"slideshow": {"slide_type": "slide"}} +# Let's delete the file workfile.txt +!rm -f workfile.txt + +# %% {"slideshow": {"slide_type": "fragment"}} +process_file('workfile.txt') # catch another exception return by open() call + +# %% {"slideshow": {"slide_type": "slide"}} +# Insert the value 1 at the top of workfile.txt +!echo "1" > workfile.txt +%cat workfile.txt + +# %% {"slideshow": {"slide_type": "slide"}} +process_file('workfile.txt') # catch exception return by assert() + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Raising Exceptions +# +# The raise statement allows the programmer to force a specified exception to occur. +# + +# %% {"slideshow": {"slide_type": "fragment"}} +raise NameError('HiThere') + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Defining Clean-up Actions +# +# - The try statement has an optional clause which is intended to define clean-up actions that must be executed under all circumstances. +# +# - A finally clause is always executed before leaving the try statement + +# %% {"slideshow": {"slide_type": "fragment"}} +try: + raise KeyboardInterrupt +finally: + print('Goodbye, world!') + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Exercise +# +# - Write a function `check_date` that takes a string "DD/MM/YYYY" as argument and +# returns `True` if the date is valid. +# - Use it with a `try ... except` statement to help the user to enter a valid date. +# - raise ValueError "Not a valid date" +# - Hints: +# * Use string method `split` +# * Year y is a leap year if y%400==0 or (y%4==0 and y%100!=0) +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Wordcount Exercise +# - Improve the function `reduce` to read the results of `words` by using the `KeyError` exception to fill in the dictionary. +# diff --git a/08.Classes.py b/08.Classes.py new file mode 100644 index 0000000..641f42e --- /dev/null +++ b/08.Classes.py @@ -0,0 +1,457 @@ +# -*- coding: utf-8 -*- +# --- +# jupyter: +# jupytext: +# comment_magics: false +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.2' +# jupytext_version: 1.1.1 +# kernelspec: +# display_name: Python 3 +# language: python +# name: python3 +# --- + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Classes +# - Classes provide a means of bundling data and functionality together. +# - Creating a new class creates a **new type** of object. +# - Assigned variables are new **instances** of that type. +# - Each class instance can have **attributes** attached to it. +# - Class instances can also have **methods** for modifying its state. +# - Python classes provide the class **inheritance** mechanism. +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Use class to store data +# +# - A empty class can be used to bundle together a few named data items. +# - You can easily save this class containing your data in JSON file. + +# %% {"slideshow": {"slide_type": "fragment"}} +class Animal: + pass + +dog = Animal() # Create an empty animal record + +# Fill the fields of the record +dog.name = 'Medor' +dog.weight = 18 +dog.age = 4 + +# %% {"slideshow": {"slide_type": "fragment"}} +dog.__dict__ + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # namedtuple + +# %% {"slideshow": {"slide_type": "fragment"}} +from collections import namedtuple + +Animal = namedtuple('Animal', 'name, weight, age') + +# %% {"slideshow": {"slide_type": "fragment"}} +dog = Animal('Dog', 18.0, 4) +dog + +# %% {"slideshow": {"slide_type": "fragment"}} +dog.age + +# %% {"slideshow": {"slide_type": "fragment"}} +# Like tuples, namedtuples are immutable: +dog.weight = 14.5 + + +# %% {"slideshow": {"slide_type": "slide"}} +class Animal: + + "A simple example class Animal with its name, weight and age" + + def __init__(self, name, weight, age): # constructor + self.name = name + self.weight = weight + self.age = age + + def birthyear(self): # method + import datetime + now = datetime.datetime.now() + return now.year - self.age + + +# %% {"slideshow": {"slide_type": "fragment"}} +dog = Animal('Dog', 18, 4) # Instance +print(f' {dog.name}: {dog.weight} Kg, {dog.age} years') +dog.birthyear() + +# %% {"slideshow": {"slide_type": "slide"}} +dog.age = 7 +dog.birthyear() + + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# - `dog` is an *instance* of Animal Class. +# - `dog.birthdate()` is a *method* of `Animal` instance `dog`. +# - `name` and `weight` are attributes of `Animal` instance `dog`. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Convert method to attribute +# +# Use the `property` decorator + +# %% {"slideshow": {"slide_type": "fragment"}} +class Animal: + + "A simple example class Animal with its name, weight and age" + + def __init__(self, name, weight, age): # constructor + self.name = name + self.weight = weight + self.age = age + + @property + def birthyear(self): # method + import datetime + now = datetime.datetime.now() + return now.year - self.age + + +# %% {"slideshow": {"slide_type": "fragment"}} +dog = Animal('Dog', 18, 4) +dog.birthyear # birthyear can now be used as an attribute + +# %% {"slideshow": {"slide_type": "fragment"}} +dog + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # The new Python 3.7 DataClass + +# %% {"slideshow": {"slide_type": "fragment"}} +from dataclasses import dataclass + + +@dataclass +class Animal: + + name: str + weight: float + age: int + + @property + def birthyear(self) -> int: + import datetime + now = datetime.datetime.now() + return now.year - self.age + + +# %% {"slideshow": {"slide_type": "fragment"}} +dog = Animal('Dog', 18.0, 4) +dog + + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Method Overriding +# - Every Python classes has a `__repr__()` method used when you call `print()` function. + +# %% {"slideshow": {"slide_type": "fragment"}} +class Animal: + """Simple example class with method overriding """ + + def __init__(self, name, weight, age): + self.name = name + self.weight = weight + self.age = age + + def __repr__(self): + return f"{self.__class__.__name__}({self.name}, {self.weight}, {self.age})" + + @property + def birthyear(self): + import datetime + now = datetime.datetime.now() + return now.year - self.age + + +# %% {"slideshow": {"slide_type": "fragment"}} +dog = Animal('Dog', 18.0, 4) +print(dog) +dog.birthyear + + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Inheritance + +# %% {"slideshow": {"slide_type": "fragment"}} +class Dog(Animal): # Parent class is defined here + + " Derived from MyClass with k attribute " + + def __init__(self, name, weight, age, breed): + super().__init__(name, weight, age) # Call method in the parent class + self.breed = breed + + def __repr__(self): + return f"{self.__class__.__name__}({self.name}, {self.weight}, {self.age}, {self.breed})" + + +beagle = Dog('Jack', 9.0, 1, 'Beagle') +print(beagle) +beagle.birthyear + + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Exercise: Grocery list item +# +# Let's create a class representing a grocery list. First we need a class to represent an item of this grocery list: +# - The `GroceryItem` class has seven attributes: +# - `name` (string) +# - `price` (double) +# - `category` (string) +# - `vat_percentage` (double) +# - `quantity` (integer) +# - `ingredients` (list of strings) +# +# - The item class has two methods +# - `get_total_vat` returns the VAT value. +# - `get_total_price` returns the total price. +# +# Implement the `GroceryItem` class and override the `__repr__()` method by returning the item name and its quantity. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ```python +# beef = GroceryItem("Beef", 12.3, "Meat", 10, 2, ["Beef"]) +# print(beef) +# print(f"Total price : {beef.get_total_price():.2f} \u20ac ") +# print(f"Total VAT : {beef.get_total_vat():.2f} \u20ac ") +# ``` +# ```pybt +# Beef x 2 +# Total cut : 0.0 € +# Total price : 27.060000000000002 € +# Total VAT : 2.46 € +# ``` + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Exercice: Grocery list +# +# Now implement the GroceryList containing GroceryItem defined above. +# In this class, add these functions: +# +# - `items_with_meat()` return a list of items of 'Meat' category. +# - `prices_with_vat()` return a dict with item names as keys and prices as values. +# - `ingredients_list()` return a set of all ingredients contained in items. +# - `total_invoice()` return the total price of the shopping list. +# - `total_for(category)` return the total price for a category +# - `price_by_category()` return a dict with category as key and the price as value. +# - `total_vat()` return the total VAT amount. +# - `top_ingredients(n)` ranks the `n` most frequently founded ingredients +# - `all_item_names()` return a list of item names + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ```python +# print(f"Articles with meat are : {shopping_list.items_with_meat()}") +# print(f"Full prices are : {shopping_list.prices_with_vat()}") +# print(f"Ingredients : {shopping_list.ingredients_list()}") +# print(f"Total : {shopping_list.total_invoice()}") +# print(f"Total for meat category : {shopping_list.total_for('Meat')}") +# print(f"Prices by category : {shopping_list.price_by_category()}") +# print(f"VAT amount : {shopping_list.total_vat()}") +# print(f"First three ingedients : {shopping_list.top_ingredients(3)}") +# print(f"All articles names : {shopping_list.all_item_names()}") +# ``` +# ```pytb +# Articles with meat are : [Beef x 2, Pork x 1] +# Full prices are : {'Beef': 27.06, 'Pork': 8.34, 'Tomato Sauce': 6.60, 'Beans': 17.32, 'Tuna': 7.19} +# Ingredients : {'Tomato', 'Preservatives', 'Fish', 'Sugar', 'Water', 'Beef', 'Salt', 'Beans', 'Oil', 'Pork'} +# Total : 66.53 +# Total for meat category : 35.40 +# Prices by category : {'Meat': 35.40, 'Can': 31.125000000000004} +# VAT amount : 6.59 +# First three ingedients : ['Water', 'Salt', 'Beef'] +# All articles names : ['Beef', 'Pork', 'Tomato Sauce', 'Beans', 'Tuna'] +# ``` + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Private Variables and Methods + +# %% {"slideshow": {"slide_type": "fragment"}} +class DemoClass: + " Demo class for name mangling " + + def public_method(self): + return 'public!' + + def __private_method(self): # Note the use of leading underscores + return 'private!' + + +object3 = DemoClass() + +# %% {"slideshow": {"slide_type": "slide"}} +object3.public_method() + +# %% {"slideshow": {"slide_type": "fragment"}} +object3.__private_method() + +# %% {"slideshow": {"slide_type": "fragment"}} +[ s for s in dir(object3) if "method" in s] + +# %% {"slideshow": {"slide_type": "fragment"}} +object3._DemoClass__private_method() + +# %% {"slideshow": {"slide_type": "fragment"}} +object3.public_method + + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Use `class` as a Function. + +# %% {"slideshow": {"slide_type": "fragment"}} +class Polynomial: + + " Class representing a polynom P(x) -> c_0+c_1*x+c_2*x^2+..." + + def __init__(self, coeffs): + self.coeffs = coeffs + + def __call__(self, x): + return sum([coef*x**exp for exp,coef in enumerate(self.coeffs)]) + +p = Polynomial([2,4,-1]) +p(2) + + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Exercise: Polynomial +# +# - Improve the class above called Polynomial by creating a method `diff(n)` to compute the nth derivative. +# - Override the `__repr__()` method to output a pretty printing. +# +# Hint: `f"{coeff:+d}"` forces to print sign before the value of an integer. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Operators Overriding + +# %% {"slideshow": {"slide_type": "slide"}} +class MyComplex: + " Simple class representing a complex" + width = 7 + precision = 3 + + def __init__(self, real=0, imag=0): + self.real = real + self.imag = imag + + def __repr__(self): + return (f"({self.real:{self.width}.{self.precision}f}," + f"{self.imag:+{self.width}.{self.precision}f}j)") + + def __eq__(self, other): # override '==' + return (self.real == other.real) and (self.imag == other.imag) + + def __add__(self, other): # override '+' + return MyComplex(self.real+other.real, self.imag+other.imag) + + def __sub__(self, other): # override '-' + return MyComplex(self.real-other.real, self.imag-other.imag) + + def __mul__(self, other): # override '*' + if isinstance(other, MyComplex): + return MyComplex(self.real * other.real - self.imag * other.imag, + self.real * other.imag + self.imag * other.real) + + else: + return MyComplex(other*self.real, other*self.imag) + + +# %% {"slideshow": {"slide_type": "slide"}} +u = MyComplex(0, 1) +v = MyComplex(1, 0) +print('u=', u, "; v=", v) + +# %% {"slideshow": {"slide_type": "fragment"}} +u+v, u-v, u*v, u==v + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# We can change the *class* attribute precision. + +# %% {"slideshow": {"slide_type": "fragment"}} +MyComplex.precision=2 +print(u.precision) +print(u) + +# %% {"slideshow": {"slide_type": "fragment"}} +v.precision + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# We can change the *instance* attribute precision. + +# %% {"slideshow": {"slide_type": "fragment"}} +u.precision=1 +print(u) + +# %% {"slideshow": {"slide_type": "fragment"}} +print(v) + +# %% {"slideshow": {"slide_type": "fragment"}} +MyComplex.precision=5 +u # set attribute keeps its value + +# %% {"slideshow": {"slide_type": "fragment"}} +v # unset attribute is set to the new value + + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Rational example + +# %% {"slideshow": {"slide_type": "slide"}} +class Rational: + " Class representing a rational number" + + def __init__(self, n, d): + assert isinstance(n, int) and isinstance(d, int) + + def gcd(x, y): + if x == 0: + return y + elif x < 0: + return gcd(-x, y) + elif y < 0: + return -gcd(x, -y) + else: + return gcd(y % x, x) + + g = gcd(n, d) + self.numer, self.denom = n//g, d//g + + def __add__(self, other): + return Rational(self.numer * other.denom + other.numer * self.denom, + self.denom * other.denom) + + def __sub__(self, other): + return Rational(self.numer * other.denom - other.numer * self.denom, + self.denom * other.denom) + + def __mul__(self, other): + return Rational(self.numer * other.numer, self.denom * other.denom) + + def __truediv__(self, other): + return Rational(self.numer * other.denom, self.denom * other.numer) + + def __repr__(self): + return f"{self.numer:d}/{self.denom:d}" + + +# %% {"slideshow": {"slide_type": "slide"}} +r1 = Rational(2,3) +r2 = Rational(3,4) +r1+r2, r1-r2, r1*r2, r1/r2 + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Exercise +# Improve the class Polynomial by implementing operations: +# - Overrides '+' operator (__add__) +# - Overrides '-' operator (__neg__) +# - Overrides '==' operator (__eq__) +# - Overrides '*' operator (__mul__) diff --git a/09.Iterators.py b/09.Iterators.py new file mode 100644 index 0000000..3ed0b99 --- /dev/null +++ b/09.Iterators.py @@ -0,0 +1,253 @@ +# -*- coding: utf-8 -*- +# --- +# jupyter: +# jupytext: +# comment_magics: false +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.2' +# jupytext_version: 1.1.1 +# kernelspec: +# display_name: Python 3 +# language: python +# name: python3 +# --- + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Iterators +# Most container objects can be looped over using a for statement: + +# %% {"slideshow": {"slide_type": "slide"}} +for element in [1, 2, 3]: + print(element, end=' ') + +# %% {"slideshow": {"slide_type": "slide"}} +for element in (1, 2, 3): + print(element, end=' ') + +# %% {"slideshow": {"slide_type": "slide"}} +for key in {'one': 1, 'two': 2}: + print(key, end=' ') + +# %% {"slideshow": {"slide_type": "slide"}} +for char in "123": + print(char, end=' ') + +# %% {"slideshow": {"slide_type": "slide"}} +for line in open("environment.yml"): + print(line, end= ' ') + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# - The `for` statement calls `iter()` on the container object. +# - The function returns an iterator object that defines the method `__next__()` +# - To add iterator behavior to your classes: +# - Define an `__iter__()` method which returns an object with a `__next__()`. +# - If the class defines `__next__()`, then `__iter__()` can just return self. +# - The **StopIteration** exception indicates the end of the loop. + +# %% {"slideshow": {"slide_type": "fragment"}} +s = 'abc' +it = iter(s) +it + +# %% {"slideshow": {"slide_type": "fragment"}} +next(it), next(it), next(it) + + +# %% {"slideshow": {"slide_type": "slide"}} +class Reverse: + """Iterator for looping over a sequence backwards.""" + + def __init__(self, data): + self.data = data + self.index = len(data) + + def __iter__(self): + return self + + def __next__(self): + if self.index == 0: + raise StopIteration + self.index = self.index - 1 + return self.data[self.index] + + +# %% {"slideshow": {"slide_type": "fragment"}} +rev = Reverse('spam') +for char in rev: + print(char, end='') + + +# %% {"slideshow": {"slide_type": "slide"}} +def reverse(data): # Python 3.6 + yield from data[::-1] + +for char in reverse('bulgroz'): + print(char, end='') + + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Generators +# - Generators are a simple and powerful tool for creating iterators. +# - Write regular functions but use the yield statement when you want to return data. +# - the `__iter__()` and `__next__()` methods are created automatically. +# + +# %% {"slideshow": {"slide_type": "fragment"}} +def reverse(data): + for index in range(len(data)-1, -1, -1): + yield data[index] + + +# %% {"slideshow": {"slide_type": "fragment"}} +for char in reverse('bulgroz'): + print(char, end='') + +# %% [markdown] +# ### Exercise +# +# Generates a list of IP addresses based on IP range. +# +# ```python +# ip_range = +# for ip in ip_range("192.168.1.0", "192.168.1.10"): +# print(ip) +# +# 192.168.1.0 +# 192.168.1.1 +# 192.168.1.2 +# ... +# ``` + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Generator Expressions +# +# - Use a syntax similar to list comprehensions but with parentheses instead of brackets. +# - Tend to be more memory friendly than equivalent list comprehensions. + +# %% {"slideshow": {"slide_type": "fragment"}} +sum(i*i for i in range(10)) # sum of squares + +# %% {"slideshow": {"slide_type": "fragment"}} +%load_ext memory_profiler + +# %% {"slideshow": {"slide_type": "fragment"}} +%memit doubles = [2 * n for n in range(10000)] + +# %% {"slideshow": {"slide_type": "fragment"}} +%memit doubles = (2 * n for n in range(10000)) + +# %% {"slideshow": {"slide_type": "slide"}} +# list comprehension +doubles = [2 * n for n in range(10)] +for x in doubles: + print(x, end=' ') + +# %% {"slideshow": {"slide_type": "fragment"}} +# generator expression +doubles = (2 * n for n in range(10)) +for x in doubles: + print(x, end=' ') + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Exercise +# +# The [Chebyshev polynomials](https://en.wikipedia.org/wiki/Chebyshev_polynomials) of the first kind are defined by the recurrence relation +# +# $$ +# \begin{eqnarray} +# T_o(x) &=& 1 \\ +# T_1(x) &=& x \\ +# T_{n+1} &=& 2xT_n(x)-T_{n-1}(x) +# \end{eqnarray} +# $$ +# +# - Create a class `Chebyshev` that generates the sequence of Chebyshev polynomials + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # itertools +# +# ## zip_longest +# +# `itertools.zip_longest()` accepts any number of iterables +# as arguments and a fillvalue keyword argument that defaults to None. +# + +# %% {"slideshow": {"slide_type": "fragment"}} +x = [1, 1, 1, 1, 1] +y = [1, 2, 3, 4, 5, 6, 7] +list(zip(x, y)) +from itertools import zip_longest +list(map(sum,zip_longest(x, y, fillvalue=1))) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## combinations + +# %% {"slideshow": {"slide_type": "fragment"}} +loto_numbers = list(range(1,50)) + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# A choice of 6 numbers from the sequence 1 to 49 is called a combination. +# The `itertools.combinations()` function takes two arguments—an iterable +# inputs and a positive integer n—and produces an iterator over tuples of +# all combinations of n elements in inputs. + +# %% {"slideshow": {"slide_type": "slide"}} +from itertools import combinations +len(list(combinations(loto_numbers, 6))) + +# %% {"slideshow": {"slide_type": "fragment"}} +from math import factorial +factorial(49)/ factorial(6) / factorial(49-6) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## permutations + +# %% {"slideshow": {"slide_type": "fragment"}} +from itertools import permutations +for s in permutations('dsi'): + print( "".join(s), end=", ") + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## count + +# %% {"slideshow": {"slide_type": "fragment"}} +from itertools import count +n = 2024 +for k in count(): # replace k = 0; while(True) : k += 1 + if n == 1: + print(f"k = {k}") + break + elif n & 1: + n = 3*n +1 + else: + n = n // 2 + + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## cycle, islice, dropwhile, takewhile + +# %% {"slideshow": {"slide_type": "fragment"}} +from itertools import cycle, islice, dropwhile, takewhile +L = list(range(10)) +cycled = cycle(L) # cycle through the list 'L' +skipped = dropwhile(lambda x: x < 6 , cycled) # drop the values until x==4 +sliced = islice(skipped, None, 20) # take the first 20 values +print(*sliced) + +# %% {"slideshow": {"slide_type": "fragment"}} +result = takewhile(lambda x: x > 0, cycled) # cycled begins to 4 +print(*result) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## product + +# %% {"slideshow": {"slide_type": "fragment"}} +ranks = ['A', 'K', 'Q', 'J', '10', '9', '8', '7'] +suits = [ '\u2660', '\u2665', '\u2663', '\u2666'] +cards = [(rank, suit) for rank in ranks for suit in suits] +len(cards) +from itertools import product +cards = product(ranks, suits) +print(*cards) diff --git a/10.Multiprocessing.py b/10.Multiprocessing.py new file mode 100644 index 0000000..bdc5127 --- /dev/null +++ b/10.Multiprocessing.py @@ -0,0 +1,248 @@ +# --- +# jupyter: +# jupytext: +# comment_magics: false +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.2' +# jupytext_version: 1.1.1 +# kernelspec: +# display_name: Python 3 +# language: python +# name: python3 +# --- + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Map reduce example + +# %% {"slideshow": {"slide_type": "fragment"}} +from time import sleep +def delayed_square(x): + sleep(1) + return x*x +data = list(range(8)) +data + +# %% {"slideshow": {"slide_type": "fragment"}} +%time sum([delayed_square(x) for x in data]) + +# %% {"slideshow": {"slide_type": "fragment"}} +%time sum(map(delayed_square,data)) + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# We can process each `delayed_square` calls independently and in parallel. To accomplish this we'll apply that function across all list items in parallel using multiple processes. +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Thread and Process: Differences +# +# - A Process is an instance of a running program. +# - Process may contain one or more threads, but a thread cannot contain a process. +# - Process has a self-contained execution environment. It has its own memory space. +# - Application running on your computer may be a set of cooperating processes. +# +# - A Thread is made of and exist within a Process; every process has at least one. +# - Multiple threads in a process share resources, which helps in efficient communication between threads. +# - Threads can be concurrent on a multi-core system, with every core executing the separate threads simultaneously. +# +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Multi-Processing vs Multi-Threading +# +# ### Memory +# - Each process has its own copy of the data segment of the parent process. +# - Each thread has direct access to the data segment of its process. +# - A process runs in separate memory spaces. +# - A thread runs in shared memory spaces. +# +# ### Communication +# - Processes must use inter-process communication to communicate with sibling processes. +# - Threads can directly communicate with other threads of its process. +# +# ### Overheads +# - Processes have considerable overhead. +# - Threads have almost no overhead. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Multi-Processing vs Multi-Threading +# +# ### Creation +# - New processes require duplication of the parent process. +# - New threads are easily created. +# +# ### Control +# - Processes can only exercise control over child processes. +# - Threads can exercise considerable control over threads of the same process. +# +# ### Changes +# - Any change in the parent process does not affect child processes. +# - Any change in the main thread may affect the behavior of the other threads of the process. +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## The Global Interpreter Lock (GIL) +# +# - The Python interpreter is not thread safe. +# - A few critical internal data structures may only be accessed by one thread at a time. Access to them is protected by the GIL. +# - Attempts at removing the GIL from Python have failed until now. The main difficulty is maintaining the C API for extension modules. +# - Multiprocessing avoids the GIL by having separate processes which each have an independent copy of the interpreter data structures. +# - The price to pay: serialization of tasks, arguments, and results. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Multiprocessing (history) +# +# - The multiprocessing allows the programmer to fully leverage multiple processors. +# - The `Pool` object parallelizes the execution of a function across multiple input values. +# - The if `__name__ == '__main__'` part is necessary. +#
The next cell will not work on Windows
+ +# %% {"slideshow": {"slide_type": "fragment"}} +%%time + +import os +assert(os.name != 'nt') + +from multiprocessing import Pool + +if __name__ == '__main__': # Executed only on main process. + with Pool() as p: + result = sum(p.map(delayed_square, data)) +result + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Futures +# +# The `concurrent.futures` module provides a high-level interface for asynchronously executing callables. +# +# The asynchronous execution can be performed with threads, using ThreadPoolExecutor, or separate processes, using ProcessPoolExecutor. Both implement the same interface, which is defined by the abstract Executor class. + +# %% {"slideshow": {"slide_type": "slide"}} +%%time +import os +if os.name == "nt": + from loky import ProcessPoolExecutor # for Windows users +else: + from concurrent.futures import ProcessPoolExecutor + +def delayed_square(x): + sleep(1) + return x*x + +e = ProcessPoolExecutor() + +results = list(e.map(delayed_square, range(8))) + +# %% {"slideshow": {"slide_type": "slide"}} +%%time +from concurrent.futures import ThreadPoolExecutor + +e = ThreadPoolExecutor() + +results = list(e.map(delayed_square, range(8))) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Asynchronous Future +# While many parallel applications can be described as maps, some can be more complex. In this section we look at the asynchronous Future interface, which provides a simple API for ad-hoc parallelism. This is useful for when your computations don't fit a regular pattern. +# + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# ### Executor.submit +# +# The `submit` method starts a computation in a separate thread or process and immediately gives us a `Future` object that refers to the result. At first, the future is pending. Once the function completes the future is finished. +# +# We collect the result of the task with the `.result()` method, +# which does not return until the results are available. + +# %% {"slideshow": {"slide_type": "slide"}} +from time import sleep + +def slowadd(a, b, delay=1): + sleep(delay) + return a + b + + +# %% {"slideshow": {"slide_type": "fragment"}} +from concurrent.futures import ThreadPoolExecutor +e = ThreadPoolExecutor(4) +future = e.submit(slowadd, 1, 2) +future + +# %% {"slideshow": {"slide_type": "fragment"}} +future.result() + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# Submit many tasks all at once and they be will executed in parallel. + +# %% {"slideshow": {"slide_type": "fragment"}} +%%time +results = [slowadd(i, i, delay=1) for i in range(8)] + +# %% {"slideshow": {"slide_type": "fragment"}} +%%time +futures = [e.submit(slowadd, 1, 1, delay=1) for i in range(8)] +results = [f.result() for f in futures] + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# * Submit fires off a single function call in the background, returning a future. +# * When you combine submit with a single for loop we recover the functionality of map. +# * To collect your results, replace each of futures, `f`, with a call to `f.result()` +# * Combine submit with multiple for loops and other general programming to get something more general than map. +# * Sometimes, it did not speed up the code very much +# * Threads and processes show some performance differences +# * Use threads carefully, you can break your Python session. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# Today most library designers are coordinating around the concurrent.futures interface, so it's wise to move over. +# +# * Profile your code +# * Used concurrent.futures.ProcessPoolExecutor for simple parallelism +# * Gained some speed boost (but not as much as expected) +# * Lost ability to diagnose performance within parallel code +# * Describing each task as a function call helps use tools like map for parallelism +# * Making your tasks fast is often at least as important as parallelizing your tasks. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Exercise: Pi computation +# +# Parallelize this computation with a ProcessPoolExecutor. ThreadPoolExecutor is not usable because of `random` function calls. + +# %% {"slideshow": {"slide_type": "fragment"}} +import time +import random + +def compute_pi(n): + count = 0 + for i in range(n): + x = random.random() + y = random.random() + if x*x + y*y <= 1: + count += 1 + return count + +elapsed_time = time.time() +nb_simulations = 4 +n = 10**7 +result = [compute_pi(n) for i in range(nb_simulations)] +pi = 4 * sum(result) / (n*nb_simulations) +print(f"Estimated value of Pi : {pi:.8f} time : {time.time()-elapsed_time:.8f}") + +# %% [markdown] +# ### Exercise +# +# - Do the same computation using asynchronous future +# - Implement a joblib version (see example below) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Joblib (bonus) +# +# [Joblib](http://pythonhosted.org/joblib/) provides a simple helper class to write parallel for loops using multiprocessing. +# + +# %% {"slideshow": {"slide_type": "fragment"}} +%%time +from joblib import Parallel, delayed +Parallel(n_jobs=8)(delayed(delayed_square)(x) for x in range(8)) + +# %% diff --git a/11.Standard.Library.py b/11.Standard.Library.py new file mode 100644 index 0000000..41d9c65 --- /dev/null +++ b/11.Standard.Library.py @@ -0,0 +1,163 @@ +# -*- coding: utf-8 -*- +# --- +# jupyter: +# jupytext: +# comment_magics: false +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.2' +# jupytext_version: 1.1.1 +# kernelspec: +# display_name: Python 3 +# language: python +# name: python3 +# --- + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Standard Library +# +# ## Operating System Interface +# + +# %% {"slideshow": {"slide_type": "fragment"}} +import os +os.getcwd() # Return the current working directory + +# %% {"slideshow": {"slide_type": "fragment"}} +%env CC='/usr/local/bin/gcc-7' +os.environ['CC']='/usr/local/bin/gcc-7' # Change the default C compiler to gcc-7 +os.system('mkdir today') # Run the command mkdir in the system shell + +# %% {"slideshow": {"slide_type": "fragment"}} +os.chdir('today') # Change current working directory +os.system('touch data.db') # Create the empty file data.db + +# %% {"slideshow": {"slide_type": "fragment"}} +import shutil +shutil.copyfile('data.db', 'archive.db') +if os.path.exists('backup.db'): # If file backup.db exists + os.remove('backup.db') # Remove it +shutil.move('archive.db', 'backup.db',) +shutil.os.chdir('..') + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## File Wildcards +# +# The glob module provides a function for making file lists from directory wildcard searches: + +# %% {"slideshow": {"slide_type": "fragment"}} +import glob +glob.glob('*.py') + + +# %% {"slideshow": {"slide_type": "fragment"}} +def recursive_replace( root, pattern, replace ) : + """ + Function to replace a string inside a directory + root : directory + pattern : searched string + replace "pattern" by "replace" + """ + for directory, subdirs, filenames in os.walk( root ): + for filename in filenames: + path = os.path.join( directory, filename ) + text = open( path ).read() + if pattern in text: + print('occurence in :' + filename) + open(path,'w').write( text.replace( pattern, replace ) ) + + + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Command Line Arguments +# +# These arguments are stored in the sys module’s argv attribute as a list. + +# %% {"slideshow": {"slide_type": "fragment"}, "magic_args": "-a demo.py", "language": "writefile"} +# import sys +# print(sys.argv) + +# %% {"slideshow": {"slide_type": "fragment"}} +%run demo.py one two three + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Random + +# %% {"slideshow": {"slide_type": "fragment"}} +import random +random.choice(['apple', 'pear', 'banana']) + +# %% {"slideshow": {"slide_type": "fragment"}} +random.sample(range(100), 10) # sampling without replacement + +# %% {"slideshow": {"slide_type": "fragment"}} +random.random() # random float + +# %% {"slideshow": {"slide_type": "fragment"}} +random.randrange(6) # random integer chosen from range(6) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Statistics + +# %% {"slideshow": {"slide_type": "fragment"}} +import statistics +data = [2.75, 1.75, 1.25, 0.25, 0.5, 1.25, 3.5] +statistics.mean(data) + +# %% {"slideshow": {"slide_type": "fragment"}} +statistics.median(data) + +# %% {"slideshow": {"slide_type": "fragment"}} +statistics.variance(data) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Performance Measurement +# + +# %% {"slideshow": {"slide_type": "fragment"}} +from timeit import Timer +Timer('t=a; a=b; b=t', 'a=1; b=2').timeit() + +# %% {"slideshow": {"slide_type": "fragment"}} +Timer('a,b = b,a', 'a=1; b=2').timeit() + +# %% {"slideshow": {"slide_type": "fragment"}} +%%timeit a=1; b=2 +a,b = b,a + + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# The [profile](https://docs.python.org/3/library/profile.html#module-profile) and [pstats](https://docs.python.org/3/library/profile.html#module-pstats) modules provide tools for identifying time critical sections in larger blocks of code. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Quality Control +# +# One approach for developing high quality software is to write tests for each function. +# +# - The doctest module provides a tool for scanning a module and validating tests embedded in a program’s docstrings. +# - This improves the documentation by providing the user with an example and it allows the doctest module to make sure the code remains true to the documentation: + +# %% {"slideshow": {"slide_type": "fragment"}} +def average(values): + """Computes the arithmetic mean of a list of numbers. + + >>> print(average([20, 30, 70])) + 40.0 + """ + return sum(values) / len(values) + +import doctest +doctest.testmod() # automatically validate the embedded tests + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Python’s standard library is very extensive +# - Containers and iterators: `collections`, `itertools` +# - Internet access: `urllib, email, mailbox, cgi, ftplib` +# - Dates and Times: `datetime, calendar, ` +# - Data Compression: `zlib, gzip, bz2, lzma, zipfile, tarfile` +# - File formats: `csv, configparser, netrc, xdrlib, plistlib` +# - Cryptographic Services: `hashlib, hmac, secrets` +# - Structure Markup Processing Tools: `html, xml` +# +# Check the [The Python Standard Library](https://docs.python.org/3/library/index.html) diff --git a/12.Matplotlib.py b/12.Matplotlib.py new file mode 100644 index 0000000..d8cab12 --- /dev/null +++ b/12.Matplotlib.py @@ -0,0 +1,320 @@ +# -*- coding: utf-8 -*- +# --- +# jupyter: +# jupytext: +# comment_magics: false +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.2' +# jupytext_version: 1.1.1 +# kernelspec: +# display_name: Python 3 +# language: python +# name: python3 +# --- + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Getting Started with matplotlib +# +# - Python 2D plotting library which produces figures in many formats and interactive environments. +# - Tries to make easy things easy and hard things possible. +# - You can generate plots, histograms, power spectra, bar charts, errorcharts, scatterplots, etc., with just a few lines of code. +# - Check the [Matplotlib gallery](https://matplotlib.org/gallery.html). +# - For simple plotting the pyplot module provides a MATLAB-like interface, particularly when combined with IPython. +# - Matplotlib provides a set of functions familiar to MATLAB users. +# +# *In this notebook we use some numpy command that will be explain more precisely later.* + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Line Plots +# - `np.linspace(0,1,10)` return 10 evenly spaced values over $[0,1]$. + +# %% {"slideshow": {"slide_type": "fragment"}} +%matplotlib inline +# inline can be replaced by notebook to get interactive plots +import numpy as np +import matplotlib.pyplot as plt + +# %% {"slideshow": {"slide_type": "fragment"}} +plt.rcParams['figure.figsize'] = (10.0, 6.0) # set figures display bigger +x = np.linspace(- 5*np.pi,5*np.pi,100) +plt.plot(x,np.sin(x)/x); + +# %% {"slideshow": {"slide_type": "slide"}} +plt.plot(x,np.sin(x)/x,x,np.sin(2*x)/x); + +# %% [markdown] {"slideshow": {"slide_type": "skip"}} +# If you have a recent Macbook with a Retina screen, you can display high-resolution plot outputs. +# Running the next cell will give you double resolution plot output for Retina screens. +# +# *Note: the example below won’t render on non-retina screens* + +# %% {"slideshow": {"slide_type": "skip"}} +%config InlineBackend.figure_format = 'retina' + +# %% {"slideshow": {"slide_type": "slide"}} +# red, dot-dash, triangles and blue, dot-dash, bullet +plt.plot(x,np.sin(x)/x, 'r-^',x,np.sin(2*x)/x, 'b-o'); + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Simple Scatter Plot + +# %% {"slideshow": {"slide_type": "fragment"}} +x = np.linspace(-1,1,50) +y = np.sqrt(1-x**2) +plt.scatter(x,y); + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Colormapped Scatter Plot + +# %% {"slideshow": {"slide_type": "fragment"}} +theta = np.linspace(0,6*np.pi,50) # 50 steps from 0 to 6 PI +size = 30*np.ones(50) # array with 50 values set to 30 +z = np.random.rand(50) # array with 50 random values in [0,1] +x = theta*np.cos(theta) +y = theta*np.sin(theta) +plt.scatter(x,y,size,z) +plt.colorbar(); + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Change Colormap + +# %% {"slideshow": {"slide_type": "fragment"}} +fig = plt.figure() # create a figure +ax = fig.add_subplot(1, 1, 1) # add a single plot +ax.scatter(x,y,size,z,cmap='jet'); +ax.set_aspect('equal', 'datalim') + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# [colormaps](http://matplotlib.org/api/pyplot_summary.html?highlight=colormaps#matplotlib.pyplot.colormaps) in matplotlib documentation. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Multiple Figures + +# %% {"slideshow": {"slide_type": "fragment"}} +plt.figure() +plt.plot(x) +plt.figure() +plt.plot(z,'ro'); + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Multiple Plots Using `subplot` + +# %% {"slideshow": {"slide_type": "fragment"}} +plt.subplot(1,2,1) # 1 row 1, 2 columns, active plot number 1 +plt.plot(x,'b-*') +plt.subplot(1,2,2) # 1 row 1, 2 columns, active plot number 2 +plt.plot(z,'ro'); + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Legends +# - Legends labels with plot + +# %% {"slideshow": {"slide_type": "fragment"}} +theta =np.linspace(0,4*np.pi,200) +plt.plot(np.sin(theta), label='sin') +plt.plot(np.cos(theta), label='cos') +plt.legend(); + +# %% [markdown] {"slideshow": {"slide_type": "subslide"}} +# - Labelling with `legend` + +# %% {"slideshow": {"slide_type": "fragment"}} +plt.plot(np.sin(theta)) +plt.plot(np.cos(theta)**2) +plt.legend(['sin','$\cos^2$']); + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Titles and Axis Labels + +# %% {"slideshow": {"slide_type": "fragment"}} +plt.plot(theta,np.sin(theta)) +plt.xlabel('radians from 0 to $4\pi$') +plt.ylabel('amplitude'); + +# %% {"slideshow": {"slide_type": "slide"}} +t = np.arange(0.01, 20.0, 0.01) + +plt.subplot(121) +plt.semilogy(t, np.exp(-t/5.0)) +plt.title('semilogy') +plt.grid(True) + +plt.subplot(122,fc='y') +plt.semilogx(t, np.sin(2*np.pi*t)) +plt.title('semilogx') +plt.grid(True) + + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Plot Grid and Save to File + +# %% {"slideshow": {"slide_type": "fragment"}} +theta = np.linspace(0,2*np.pi,100) +plt.plot(np.cos(theta),np.sin(theta)) +plt.grid(); + + +# %% {"slideshow": {"slide_type": "fragment"}} +plt.savefig('circle.png'); +%ls *.png + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Histogram + +# %% {"slideshow": {"slide_type": "fragment"}} +from numpy.random import randn +plt.hist(randn(1000)); + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# Change the number of bins and supress display of returned array with ; +# + +# %% {"slideshow": {"slide_type": "fragment"}} +plt.hist(randn(1000), 30); + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Contour Plot + +# %% {"slideshow": {"slide_type": "fragment"}} +x = y = np.arange(-2.0*np.pi, 2.0*np.pi+0.01, 0.01) +X, Y = np.meshgrid(x, y) +Z = np.sin(X)*np.cos(Y) + +plt.contourf(X, Y, Z,cmap=plt.cm.hot); + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Image Display + +# %% {"slideshow": {"slide_type": "fragment"}} +img = plt.imread("https://hackage.haskell.org/package/JuicyPixels-extra-0.1.0/src/data-examples/lenna.png") +plt.imshow(img) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## figure and axis +# +# Best method to create a plot with many components + +# %% {"slideshow": {"slide_type": "fragment"}} +fig = plt.figure() +axis = fig.add_subplot(111, aspect='equal', + xlim=(-2, 2), ylim=(-2, 2)) + +state = -0.5 + np.random.random((50, 4)) +state[:, :2] *= 3.9 +bounds = [-1, 1, -1, 1] + +particles = axis.plot(state[:,0], state[:,1], 'bo', ms=6) +rect = plt.Rectangle(bounds[::2], + bounds[1] - bounds[0], + bounds[3] - bounds[2], + ec='r', lw=2, fc='none') +axis.grid() +axis.add_patch(rect) +axis.text(-0.5,1.1,"BOX") + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Exercise +# +# Recreate the image my_plots.png using the *delicate_arch.png* file in *images* directory. +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Alternatives +# +# - [bqplot](https://github.com/bloomberg/bqplot/blob/master/README.md) : Jupyter Notebooks, Interactive. +# - [seaborn](https://seaborn.pydata.org) : Statistics. +# - [toyplot](http://toyplot.readthedocs.io/en/stable/) : Nice graphes. +# - [bokeh](http://bokeh.pydata.org/en/latest/) : Interactive and Server mode. +# - [pygal](http://pygal.org/en/stable/) : Charting +# - [Altair](https://github.com/altair-viz/altair) : Data science +# - [plot.ly](https://plot.ly/) : Data science and interactive +# - [Mayavi](http://code.enthought.com/projects/mayavi/): 3D +# - [YT](http://yt-project.org): Astrophysics (volume rendering, contours, particles). +# - [VisIt](http://www.visitusers.org/index.php?title=VisIt-tutorial-Python-scripting): Powerful, easy to use but heavy. +# - [Paraview](http://www.itk.org/Wiki/ParaView/Python_Scripting): The most-used visualization application. Need high learning effort. + +# %% {"slideshow": {"slide_type": "slide"}} +#example from Filipe Fernandes +#http://nbviewer.jupyter.org/gist/ocefpaf/9730c697819e91b99f1d694983e39a8f +import numpy as np +import matplotlib.pyplot as plt +from matplotlib import animation + +g = 9.81 +denw = 1025.0 # Seawater density [kg/m**3]. +sig = 7.3e-2 # Surface tension [N/m]. +a = 1.0 # Wave amplitude [m]. + +L, h = 100.0, 50.0 # Wave height and water column depth. +k = 2 * np.pi / L +omega = np.sqrt((g * k + (sig / denw) * (k**3)) * np.tanh(k * h)) +T = 2 * np.pi / omega +c = np.sqrt((g / k + (sig / denw) * k) * np.tanh(k * h)) + +# We'll solve the wave velocities in the `x` and `z` directions. +x, z = np.meshgrid(np.arange(0, 160, 10), np.arange(0, -80, -10),) +u, w = np.zeros_like(x), np.zeros_like(z) + + +def compute_vel(phase): + u = a * omega * (np.cosh(k * (z+h)) / np.sinh(k*h)) * np.cos(k * x - phase) + w = a * omega * (np.sinh(k * (z+h)) / np.sinh(k*h)) * np.sin(k * x - phase) + mask = -z > h + u[mask] = 0.0 + w[mask] = 0.0 + return u, w + + +def basic_animation(frames=91, interval=30, dt=0.3): + fig = plt.figure(figsize=(8, 6)) + ax = plt.axes(xlim=(0, 150), ylim=(-70, 10)) + + # Animated. + quiver = ax.quiver(x, z, u, w, units='inches', scale=2) + ax.quiverkey(quiver, 120, -60, 1, + label=r'1 m s$^{-1}$', + coordinates='data') + line, = ax.plot([], [], 'b') + + # Non-animated. + ax.plot([0, 150], [0, 0], 'k:') + ax.set_ylabel('Depth [m]') + ax.set_xlabel('Distance [m]') + text = (r'$\lambda$ = %s m; h = %s m; kh = %2.3f; h/L = %s' % + (L, h, k * h, h/L)) + ax.text(10, -65, text) + time_step = ax.text(10, -58, '') + line.set_data([], []) + + def init(): + return line, quiver, time_step + + def animate(i): + time = i * dt + phase = omega * time + eta = a * np.cos(x[0] * k - phase) + u, w = compute_vel(phase) + quiver.set_UVC(u, w) + line.set_data(x[0], 5 * eta) + time_step.set_text('Time = {:.2f} s'.format(time)) + return line, quiver, time_step + + return animation.FuncAnimation(fig, animate, init_func=init, + frames=frames, interval=interval) + + +# %% {"slideshow": {"slide_type": "slide"}} +from IPython.display import HTML + +HTML(basic_animation(dt=0.3).to_jshtml()) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # References +# - Simple examples with increasing difficulty https://matplotlib.org/examples/index.html +# - Gallery https://matplotlib.org/gallery.html +# - A [matplotlib tutorial](http://nbviewer.ipython.org/github/jrjohansson/scientific-python-lectures/blob/master/Lecture-4-Matplotlib.ipynb), part of the [Lectures on Scientific Computing with Python](http://nbviewer.ipython.org/github/jrjohansson/scientific-python-lectures/tree/master) by [J.R. Johansson](https://github.com/jrjohansson). +# - [NumPy Beginner | SciPy 2016 Tutorial | Alexandre Chabot LeClerc](https://youtu.be/gtejJ3RCddE) +# - [matplotlib tutorial](http://www.loria.fr/~rougier/teaching/matplotlib) by Nicolas Rougier from LORIA. +# - [10 Useful Python Data Visualization Libraries for Any Discipline](https://blog.modeanalytics.com/python-data-visualization-libraries/) diff --git a/13.Numpy.py b/13.Numpy.py new file mode 100644 index 0000000..e577d73 --- /dev/null +++ b/13.Numpy.py @@ -0,0 +1,725 @@ +# -*- coding: utf-8 -*- +# --- +# jupyter: +# jupytext: +# comment_magics: false +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.2' +# jupytext_version: 1.1.1 +# kernelspec: +# display_name: Python 3 +# language: python +# name: python3 +# --- + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # What provide Numpy to Python ? +# +# - `ndarray` multi-dimensional array object +# - derived objects such as masked arrays and matrices +# - `ufunc` fast array mathematical operations. +# - Offers some Matlab-ish capabilities within Python +# - Initially developed by [Travis Oliphant](https://www.continuum.io/people/travis-oliphant). +# - Numpy 1.0 released October, 2006. +# - The [SciPy.org website](https://docs.scipy.org/doc/numpy) is very helpful. +# - NumPy fully supports an object-oriented approach. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Routines for fast operations on arrays. +# +# - shape manipulation +# - sorting +# - I/O +# - FFT +# - basic linear algebra +# - basic statistical operations +# - random simulation +# - statistics +# - and much more... + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Getting Started with NumPy +# +# - It is handy to import everything from NumPy into a Python console: +# ```python +# from numpy import * +# ``` +# - But it is easier to read and debug if you use explicit imports. +# ```python +# import numpy as np +# import scipy as sp +# import matplotlib.pyplot as plt +# ``` + +# %% {"slideshow": {"slide_type": "fragment"}} +import numpy as np +print(np.__version__) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Why Arrays ? + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# - Python lists are slow to process and use a lot of memory. +# - For tables, matrices, or volumetric data, you need lists of lists of lists... which becomes messy to program. + +# %% {"slideshow": {"slide_type": "fragment"}} +from random import random +from operator import truediv + +# %% {"slideshow": {"slide_type": "fragment"}} +l1 = [random() for i in range(1000)] +l2 = [random() for i in range(1000)] +%timeit s = sum(map(truediv,l1,l2)) + +# %% {"slideshow": {"slide_type": "fragment"}} +a1 = np.array(l1) +a2 = np.array(l2) +%timeit s = np.sum(a1/a2) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Numpy Arrays: The `ndarray` class. +# +# - There are important differences between NumPy arrays and Python lists: +# - NumPy arrays have a fixed size at creation. +# - NumPy arrays elements are all required to be of the same data type. +# - NumPy arrays operations are performed in compiled code for performance. +# - Most of today's scientific/mathematical Python-based software use NumPy arrays. +# - NumPy gives us the code simplicity of Python, but the operation is speedily executed by pre-compiled C code. + +# %% {"slideshow": {"slide_type": "fragment"}} +a = np.array([0,1,2,3]) # list +b = np.array((4,5,6,7)) # tuple +c = np.matrix('8 9 0 1') # string (matlab syntax) + +# %% {"slideshow": {"slide_type": "fragment"}} +print(a,b,c) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Element wise operations are the “default mode” + +# %% {"slideshow": {"slide_type": "fragment"}} +a*b,a+b + +# %% {"slideshow": {"slide_type": "fragment"}} +5*a, 5+a + +# %% {"slideshow": {"slide_type": "fragment"}} +a @ b, np.dot(a,b) # Matrix multiplication + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # NumPy Arrays Properties + +# %% {"slideshow": {"slide_type": "fragment"}} +a = np.array([1,2,3,4,5]) # Simple array creation + +# %% {"slideshow": {"slide_type": "fragment"}} +type(a) # Checking the type + +# %% {"slideshow": {"slide_type": "fragment"}} +a.dtype # Print numeric type of elements + +# %% {"slideshow": {"slide_type": "fragment"}} +a.itemsize # Print Bytes per element + +# %% {"slideshow": {"slide_type": "slide"}} +a.shape # returns a tuple listing the length along each dimension + +# %% {"slideshow": {"slide_type": "fragment"}} +np.size(a), a.size # returns the entire number of elements. + +# %% {"slideshow": {"slide_type": "fragment"}} +a.ndim # Number of dimensions + +# %% {"slideshow": {"slide_type": "fragment"}} +a.nbytes # Memory used + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# - ** Always use `shape` or `size` for numpy arrays instead of `len` ** +# - `len` gives same information only for 1d array. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Functions to allocate arrays + +# %% {"slideshow": {"slide_type": "fragment"}} +x = np.zeros((2,),dtype=('i4,f4,a10')) +x + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# `empty, empty_like, ones, ones_like, zeros, zeros_like, full, full_like` + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Setting Array Elements Values + +# %% {"slideshow": {"slide_type": "fragment"}} +a = np.array([1,2,3,4,5]) +print(a.dtype) + +# %% {"slideshow": {"slide_type": "fragment"}} +a[0] = 10 # Change first item value +a, a.dtype + +# %% {"slideshow": {"slide_type": "fragment"}} +a.fill(0) # slighty faster than a[:] = 0 +a + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Setting Array Elements Types + +# %% {"slideshow": {"slide_type": "fragment"}} +b = np.array([1,2,3,4,5.0]) # Last item is a float +b, b.dtype + +# %% {"slideshow": {"slide_type": "fragment"}} +a.fill(3.0) # assigning a float into a int array +a[1] = 1.5 # truncates the decimal part +print(a.dtype, a) + +# %% {"slideshow": {"slide_type": "fragment"}} +a.astype('float64') # returns a new array containing doubles + +# %% {"slideshow": {"slide_type": "fragment"}} +np.asfarray([1,2,3,4]) # Return an array converted to a float type + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Slicing x[lower:upper:step] +# - Extracts a portion of a sequence by specifying a lower and upper bound. +# - The lower-bound element is included, but the upper-bound element is **not** included. +# - The default step value is 1 and can be negative. + +# %% {"slideshow": {"slide_type": "fragment"}} +a = np.array([10,11,12,13,14]) + +# %% {"slideshow": {"slide_type": "fragment"}} +a[:2], a[-5:-3], a[0:2], a[-2:] # negative indices work + +# %% {"slideshow": {"slide_type": "fragment"}} +a[::2], a[::-1] + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Exercise: +# - Compute derivative of $f(x) = \sin(x)$ with finite difference method. +# $$ +# \frac{\partial f}{\partial x} \sim \frac{f(x+dx)-f(x)}{dx} +# $$ +# +# derivatives values are centered in-between sample points. + +# %% {"slideshow": {"slide_type": "fragment"}} +x, dx = np.linspace(0,4*np.pi,100, retstep=True) +y = np.sin(x) + +# %% {"slideshow": {"slide_type": "slide"}} +%matplotlib inline +import matplotlib.pyplot as plt +plt.rcParams['figure.figsize'] = [12.,8.] # Increase plot size +plt.plot(x, np.cos(x),'b') +plt.title(r"$\rm{Derivative\ of}\ \sin(x)$"); + +# %% {"slideshow": {"slide_type": "slide"}} +# Compute integral of x numerically +avg_height = 0.5*(y[1:]+y[:-1]) +int_sin = np.cumsum(dx*avg_height) +plt.plot(x[1:], int_sin, 'ro', x, np.cos(0)-np.cos(x)); + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Multidimensional array + +# %% {"slideshow": {"slide_type": "fragment"}} +a = np.arange(4*3).reshape(4,3) # NumPy array +l = [[0,1,2],[3,4,5],[6,7,8],[9,10,11]] # Python List + +# %% {"slideshow": {"slide_type": "fragment"}} +print(a) +print(l) + +# %% {"slideshow": {"slide_type": "slide"}} +l[-1][-1] # Access to last item + +# %% {"slideshow": {"slide_type": "fragment"}} +print(a[-1,-1]) # Indexing syntax is different with NumPy array +print(a[0,0]) # returns the first item +print(a[1,:]) # returns the second line + +# %% {"slideshow": {"slide_type": "fragment"}} +print(a[1]) # second line with 2d array +print(a[:,-1]) # last column + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Exercise +# - We compute numerically the Laplace Equation Solution using Finite Difference Method +# - Replace the computation of the discrete form of Laplace equation with numpy arrays +# $$ +# T_{i,j} = \frac{1}{4} ( T_{i+1,j} + T_{i-1,j} + T_{i,j+1} + T_{i,j-1}) +# $$ +# - The function numpy.allclose can help you to compute the residual. + +# %% {"slideshow": {"slide_type": "slide"}} +%%time +# Boundary conditions +Tnorth, Tsouth, Twest, Teast = 100, 20, 50, 50 + +# Set meshgrid +n, l = 64, 1.0 +X, Y = np.meshgrid(np.linspace(0,l,n), np.linspace(0,l,n)) +T = np.zeros((n,n)) + +# Set Boundary condition +T[n-1:, :] = Tnorth +T[:1, :] = Tsouth +T[:, n-1:] = Teast +T[:, :1] = Twest + +residual = 1.0 +istep = 0 +while residual > 1e-5 : + istep += 1 + print ((istep, residual), end="\r") + residual = 0.0 + for i in range(1, n-1): + for j in range(1, n-1): + T_old = T[i,j] + T[i, j] = 0.25 * (T[i+1,j] + T[i-1,j] + T[i,j+1] + T[i,j-1]) + if T[i,j]>0: + residual=max(residual,abs((T_old-T[i,j])/T[i,j])) + + +print() +print("iterations = ",istep) +plt.title("Temperature") +plt.contourf(X, Y, T) +plt.colorbar() + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Arrays to ASCII files +# + +# %% {"slideshow": {"slide_type": "fragment"}} +x = y = z = np.arange(0.0,5.0,1.0) + +# %% {"slideshow": {"slide_type": "fragment"}} +np.savetxt('test.out', (x,y,z), delimiter=',') # X is an array +%cat test.out + +# %% {"slideshow": {"slide_type": "slide"}} +np.savetxt('test.out', (x,y,z), fmt='%1.4e') # use exponential notation +%cat test.out + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Arrays from ASCII files + +# %% {"slideshow": {"slide_type": "fragment"}} +np.loadtxt('test.out') + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# - [save](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.save.html#numpy.save): Save an array to a binary file in NumPy .npy format +# - [savez](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.savez.html#numpy.savez) : Save several arrays into an uncompressed .npz archive +# - [savez_compressed](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.savez_compressed.html#numpy.savez_compressed): Save several arrays into a compressed .npz archive +# - [load](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.load.html#numpy.load): Load arrays or pickled objects from .npy, .npz or pickled files. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## H5py +# +# Pythonic interface to the HDF5 binary data format. [h5py user manual](http://docs.h5py.org) + +# %% {"slideshow": {"slide_type": "fragment"}} +import h5py as h5 + +with h5.File('test.h5','w') as f: + f['x'] = x + f['y'] = y + f['z'] = z + +# %% {"slideshow": {"slide_type": "fragment"}} +with h5.File('test.h5','r') as f: + for field in f.keys(): + print(field+':',f[field].value) + + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Slices Are References +# - Slices are references to memory in the original array. +# - Changing values in a slice also changes the original array. +# + +# %% {"slideshow": {"slide_type": "fragment"}} +a = np.arange(10) +b = a[3:6] +b # `b` is a view of array `a` and `a` is called base of `b` + +# %% {"slideshow": {"slide_type": "fragment"}} +b[0] = -1 +a # you change a view the base is changed. + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# - Numpy does not copy if it is not necessary to save memory. + +# %% {"slideshow": {"slide_type": "fragment"}} +c = a[7:8].copy() # Explicit copy of the array slice +c[0] = -1 +a + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Fancy Indexing + +# %% {"slideshow": {"slide_type": "fragment"}} +a = np.fromfunction(lambda i, j: (i+1)*10+j, (4, 5), dtype=int) +a + +# %% {"slideshow": {"slide_type": "fragment"}} +np.random.shuffle(a.flat) # shuffle modify only the first axis +a + +# %% {"slideshow": {"slide_type": "slide"}} +locations = a % 3 == 0 # locations can be used as a mask +a[locations] = 0 #set to 0 only the values that are divisible by 3 +a + +# %% {"slideshow": {"slide_type": "fragment"}} +a += a == 0 +a + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### `numpy.take` + +# %% {"slideshow": {"slide_type": "fragment"}} +a[1:3,2:5] + +# %% {"slideshow": {"slide_type": "fragment"}} +np.take(a,[[6,7],[10,11]]) # Use flatten array indices + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Changing array shape + +# %% {"slideshow": {"slide_type": "fragment"}} +grid = np.indices((2,3)) # Return an array representing the indices of a grid. +grid[0] + +# %% {"slideshow": {"slide_type": "fragment"}} +grid[1] + +# %% {"slideshow": {"slide_type": "slide"}} +grid.flat[:] # Return a view of grid array + +# %% {"slideshow": {"slide_type": "fragment"}} +grid.flatten() # Return a copy + +# %% {"slideshow": {"slide_type": "fragment"}} +np.ravel(grid, order='C') # A copy is made only if needed. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Sorting + +# %% {"slideshow": {"slide_type": "fragment"}} +a=np.array([5,3,6,1,6,7,9,0,8]) +np.sort(a) #. Return a view + +# %% {"slideshow": {"slide_type": "fragment"}} +a + +# %% {"slideshow": {"slide_type": "fragment"}} +a.sort() # Change the array inplace +a + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Transpose-like operations + +# %% {"slideshow": {"slide_type": "fragment"}} +a = np.array([5,3,6,1,6,7,9,0,8]) +b = a +b.shape = (3,3) # b is a reference so a will be changed + +# %% {"slideshow": {"slide_type": "fragment"}} +a + +# %% {"slideshow": {"slide_type": "fragment"}} +c = a.T # Return a view so a is not changed +np.may_share_memory(a,c) + +# %% {"slideshow": {"slide_type": "fragment"}} +c[0,0] = -1 # c is stored in same memory so change c you change a +a + +# %% {"slideshow": {"slide_type": "slide"}} +c # is a transposed view of a + +# %% {"slideshow": {"slide_type": "fragment"}} +b # b is a reference to a + +# %% {"slideshow": {"slide_type": "fragment"}} +c.base # When the array is not a view `base` return None + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Methods Attached to NumPy Arrays + +# %% {"slideshow": {"slide_type": "fragment"}} +a = np.arange(20).reshape(4,5) +np.random.shuffle(a.flat) +a + +# %% {"slideshow": {"slide_type": "fragment"}} +a = (a - a.mean())/ a.std() # Standardize the matrix +print(a) + +# %% {"slideshow": {"slide_type": "slide"}} +np.set_printoptions(precision=4) +print(a) + +# %% {"slideshow": {"slide_type": "fragment"}} +a.argmax() # max position in the memory contiguous array + +# %% {"slideshow": {"slide_type": "fragment"}} +np.unravel_index(a.argmax(),a.shape) # get position in the matrix + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Array Operations over a given axis + +# %% {"slideshow": {"slide_type": "fragment"}} +a = np.arange(20).reshape(5,4) +np.random.shuffle(a.flat) + +# %% {"slideshow": {"slide_type": "fragment"}} +a.sum(axis=0) # sum of each column + +# %% {"slideshow": {"slide_type": "fragment"}} +np.apply_along_axis(sum, axis=0, arr=a) + +# %% {"slideshow": {"slide_type": "fragment"}} +np.apply_along_axis(sorted, axis=0, arr=a) + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# You can replace the `sorted` builtin fonction by a user defined function. + +# %% {"slideshow": {"slide_type": "slide"}} +np.empty(10) + +# %% {"slideshow": {"slide_type": "fragment"}} +np.linspace(0,2*np.pi,10) + +# %% {"slideshow": {"slide_type": "fragment"}} +np.arange(0,2.+0.4,0.4) + +# %% {"slideshow": {"slide_type": "slide"}} +np.eye(4) + +# %% {"slideshow": {"slide_type": "fragment"}} +a = np.diag(range(4)) +a + +# %% {"slideshow": {"slide_type": "slide"}} +a[:,:,np.newaxis] + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Create the following arrays +# ```python +# [100 101 102 103 104 105 106 107 108 109] +# ``` +# Hint: numpy.arange +# ```python +# [-2. -1.8 -1.6 -1.4 -1.2 -1. -0.8 -0.6 -0.4 -0.2 0. +# 0.2 0.4 0.6 0.8 1. 1.2 1.4 1.6 1.8] +# ``` +# Hint: numpy.linspace +# ```python +# [[ 0.001 0.00129155 0.0016681 0.00215443 0.00278256 +# 0.003593810.00464159 0.00599484 0.00774264 0.01] +# ``` +# Hint: numpy.logspace +# ```python +# [[ 0. 0. -1. -1. -1.] +# [ 0. 0. 0. -1. -1.] +# [ 0. 0. 0. 0. -1.] +# [ 0. 0. 0. 0. 0.] +# [ 0. 0. 0. 0. 0.] +# [ 0. 0. 0. 0. 0.] +# [ 0. 0. 0. 0. 0.]] +# ``` +# Hint: numpy.tri, numpy.zeros, numpy.transpose +# +# ```python +# [[ 0. 1. 2. 3. 4.] +# [-1. 0. 1. 2. 3.] +# [-1. -1. 0. 1. 2.] +# [-1. -1. -1. 0. 1.] +# [-1. -1. -1. -1. 0.]] +# ``` +# Hint: numpy.ones, numpy.diag +# +# * Compute the integral numerically with Trapezoidal rule +# $$ +# I = \int_{-\infty}^\infty e^{-v^2} dv +# $$ +# with $v \in [-10;10]$ and n=20. +# +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Views and Memory Management +# - If it exists one view of a NumPy array, it can be destroyed. +# + +# %% {"slideshow": {"slide_type": "fragment"}} +big = np.arange(1000000) +small = big[:5] +del big +small.base + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# - Array called `big` is still allocated. +# - Sometimes it is better to create a copy. + +# %% {"slideshow": {"slide_type": "fragment"}} +big = np.arange(1000000) +small = big[:5].copy() +del big +print(small.base) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Change memory alignement + +# %% {"slideshow": {"slide_type": "fragment"}} +del(a) +a = np.arange(20).reshape(5,4) +print(a.flags) + +# %% {"slideshow": {"slide_type": "fragment"}} +b = np.asfortranarray(a) # makes a copy +b.flags + +# %% {"slideshow": {"slide_type": "fragment"}} +b.base is a + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# You can also create a fortran array with array function. + +# %% {"slideshow": {"slide_type": "fragment"}} +c = np.array([[1,2,3],[4,5,6]]) +f = np.asfortranarray(c) + +# %% {"slideshow": {"slide_type": "fragment"}} +print(f.ravel(order='K')) # Return a 1D array using memory order +print(c.ravel(order='K')) # Copy is made only if necessary + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Broadcasting rules +# +# Broadcasting rules allow you to make an outer product between two vectors: the first method involves array tiling, the second one involves broadcasting. The last method is significantly faster. +# + +# %% {"slideshow": {"slide_type": "fragment"}} +n = 1000 +a = np.arange(n) +ac = a[:, np.newaxis] # column matrix +ar = a[np.newaxis, :] # row matrix + +# %% {"slideshow": {"slide_type": "fragment"}} +%timeit np.tile(a, (n,1)).T * np.tile(a, (n,1)) + +# %% {"slideshow": {"slide_type": "fragment"}} +%timeit ac * ar + +# %% {"slideshow": {"slide_type": "fragment"}} +np.all(np.tile(a, (n,1)).T * np.tile(a, (n,1)) == ac * ar) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Numpy Matrix +# +# Specialized 2-D array that retains its 2-D nature through operations. It has certain special operators, such as $*$ (matrix multiplication) and $**$ (matrix power). + +# %% {"slideshow": {"slide_type": "fragment"}} +m = np.matrix('1 2; 3 4') #Matlab syntax +m + +# %% {"slideshow": {"slide_type": "fragment"}} +a = np.matrix([[1, 2],[ 3, 4]]) #Python syntax +a + +# %% {"slideshow": {"slide_type": "slide"}} +a = np.arange(1,4) +b = np.mat(a) # 2D view, no copy! +b, np.may_share_memory(a,b) + +# %% {"slideshow": {"slide_type": "fragment"}} +a = np.matrix([[1, 2, 3],[ 3, 4, 5]]) +a * b.T # Matrix vector product + +# %% {"slideshow": {"slide_type": "fragment"}} +m * a # Matrix multiplication + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## StructuredArray using a compound data type specification + +# %% {"slideshow": {"slide_type": "fragment"}} +data = np.zeros(4, dtype={'names':('name', 'age', 'weight'), + 'formats':('U10', 'i4', 'f8')}) +print(data.dtype) + +# %% {"slideshow": {"slide_type": "fragment"}} +data['name'] = ['Pierre', 'Paul', 'Jacques', 'Francois'] +data['age'] = [45, 10, 71, 39] +data['weight'] = [95.0, 75.0, 88.0, 71.0] +print(data) + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# ## RecordArray + +# %% {"slideshow": {"slide_type": "fragment"}} +data_rec = data.view(np.recarray) +data_rec.age + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # NumPy Array Programming +# - Array operations are fast, Python loops are slow. +# - Top priority: **avoid loops** +# - It’s better to do the work three times witharray operations than once with a loop. +# - This does require a change of habits. +# - This does require some experience. +# - NumPy’s array operations are designed to make this possible. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Fast Evaluation Of Array Expressions +# +# - The `numexpr` package supplies routines for the fast evaluation of array expressions elementwise by using a vector-based virtual machine. +# - Expressions are cached, so reuse is fast. +# +# [Numexpr Users Guide](https://github.com/pydata/numexpr/wiki/Numexpr-Users-Guide) + +# %% {"slideshow": {"slide_type": "slide"}} +import numexpr as ne +import numpy as np +nrange = (2 ** np.arange(6, 24)).astype(int) + +t_numpy = [] +t_numexpr = [] + +for n in nrange: + a = np.random.random(n) + b = np.arange(n, dtype=np.double) + c = np.random.random(n) + + c1 = ne.evaluate("a ** 2 + b ** 2 + 2 * a * b * c ", optimization='aggressive') + + t1 = %timeit -oq -n 10 a ** 2 + b ** 2 + 2 * a * b * c + t2 = %timeit -oq -n 10 ne.re_evaluate() + + t_numpy.append(t1.best) + t_numexpr.append(t2.best) + +%matplotlib inline +%config InlineBackend.figure_format = 'retina' +import matplotlib.pyplot as plt +import seaborn; seaborn.set() + +plt.loglog(nrange, t_numpy, label='numpy') +plt.loglog(nrange, t_numexpr, label='numexpr') + +plt.legend(loc='lower right') +plt.xlabel('Vectors size') +plt.ylabel('Execution Time (s)'); + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # References +# - [NumPy reference](http://docs.scipy.org/doc/numpy/reference/) +# - [Getting the Best Performance out of NumPy](http://ipython-books.github.io/featured-01/) +# - [Numpy by Konrad Hinsen](http://calcul.math.cnrs.fr/Documents/Ecoles/2013/python/NumPy%20avance.pdf) diff --git a/14.SciPy.py b/14.SciPy.py new file mode 100644 index 0000000..b235f95 --- /dev/null +++ b/14.SciPy.py @@ -0,0 +1,396 @@ +# --- +# jupyter: +# jupytext: +# comment_magics: false +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.2' +# jupytext_version: 1.1.1 +# kernelspec: +# display_name: Python 3 +# language: python +# name: python3 +# --- + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Scipy +# +#  +# +# Scipy is the scientific Python ecosystem : +# - fft, linear algebra, scientific computation,... +# - scipy contains numpy, it can be considered as an extension of numpy. +# - the add-on toolkits [Scikits](https://scikits.appspot.com/scikits) complements scipy. + +# %% {"slideshow": {"slide_type": "skip"}} +%matplotlib inline +%config InlineBackend.figure_format = 'retina' +import matplotlib.pyplot as plt +plt.rcParams['figure.figsize'] = (10,6) + +# %% {"slideshow": {"slide_type": "slide"}} +import numpy as np +import scipy as sp +np.sqrt(-1.), np.log(-2.) + +# %% {"slideshow": {"slide_type": "fragment"}} +sp.sqrt(-1.), sp.log(-2.) + +# %% {"slideshow": {"slide_type": "fragment"}} +sp.exp(sp.log(-2.)) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## SciPy main packages +# - `constants` : Physical and mathematical constants +# - `fftpack` : Fast Fourier Transform routines +# - `integrate` : Integration and ordinary differential equation solvers +# - `interpolate` : Interpolation and smoothing splines +# - `io` : Input and Output +# - `linalg` : Linear algebra +# - `signal` : Signal processing +# - `sparse` : Sparse matrices and associated routines +# + +# %% {"slideshow": {"slide_type": "slide"}} +from scipy.interpolate import interp1d +x = np.linspace(-1, 1, num=5) # 5 points evenly spaced in [-1,1]. +y = (x-1.)*(x-0.5)*(x+0.5) # x and y are numpy arrays +f0 = interp1d(x,y, kind='zero') +f1 = interp1d(x,y, kind='linear') +f2 = interp1d(x,y, kind='quadratic') +f3 = interp1d(x,y, kind='cubic') +f4 = interp1d(x,y, kind='nearest') + +# %% {"slideshow": {"slide_type": "slide"}} +xnew = sp.linspace(-1, 1, num=40) +ynew = (xnew-1.)*(xnew-0.5)*(xnew+0.5) +plt.plot(x,y,'D',xnew,f0(xnew),':', xnew, f1(xnew),'-.', + xnew,f2(xnew),'-',xnew ,f3(xnew),'--', + xnew,f4(xnew),'--',xnew, ynew, linewidth=2) +plt.legend(['data','zero','linear','quadratic','cubic','nearest','exact'], + loc='best'); + +# %% {"slideshow": {"slide_type": "slide"}} +from scipy.interpolate import interp2d +x,y=sp.mgrid[0:1:20j,0:1:20j] #create the grid 20x20 +z=sp.cos(4*sp.pi*x)*sp.sin(4*sp.pi*y) #initialize the field +T1=interp2d(x,y,z,kind='linear') +T2=interp2d(x,y,z,kind='cubic') +T3=interp2d(x,y,z,kind='quintic') + +# %% {"slideshow": {"slide_type": "slide"}} +X,Y=sp.mgrid[0:1:100j,0:1:100j] #create the interpolation grid 100x100 +# complex -> number of points, float -> step size +plt.figure(1) +plt.subplot(221) #Plot original data +plt.contourf(x,y,z) +plt.title('20x20') +plt.subplot(222) #Plot linear interpolation +plt.contourf(X,Y,T1(X[:,0],Y[0,:])) +plt.title('100x100 linear') +plt.subplot(223) #Plot cubic interpolation +plt.contourf(X,Y,T2(X[:,0],Y[0,:])) +plt.title('100x100 cubic') +plt.subplot(224) #Plot quintic interpolation +plt.contourf(X,Y,T3(X[:,0],Y[0,:])) +plt.title('100x100 quintic') + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## FFT : scipy.fftpack +# - FFT dimension 1, 2 and n : fft, ifft (inverse), rfft (real), irfft, fft2 (dimension 2), ifft2, fftn (dimension n), ifftn. +# - Discrete cosinus transform : dct +# - Convolution product : convolve + +# %% {"slideshow": {"slide_type": "fragment"}} +from numpy.fft import fft, ifft +x = np.random.random(1024) +%timeit ifft(fft(x)) + +# %% {"slideshow": {"slide_type": "fragment"}} +from scipy.fftpack import fft, ifft +x = np.random.random(1024) +%timeit ifft(fft(x)) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Linear algebra : scipy.linalg +# - Sovers, decompositions, eigen values. (same as numpy). +# - Matrix functions : expm, sinm, sinhm,... +# - Block matrices diagonal, triangular, periodic,... + +# %% {"slideshow": {"slide_type": "fragment"}} +import scipy.linalg as spl +b=sp.ones(5) +A=sp.array([[1.,3.,0., 0.,0.], + [ 2.,1.,-4, 0.,0.], + [ 6.,1., 2,-3.,0.], + [ 0.,1., 4.,-2.,-3.], + [ 0.,0., 6.,-3., 2.]]) +print("x=",spl.solve(A,b,sym_pos=False)) # LAPACK ( gesv ou posv ) +AB=sp.array([[0.,3.,-4.,-3.,-3.], + [1.,1., 2.,-2., 2.], + [2.,1., 4.,-3., 0.], + [6.,1., 6., 0., 0.]]) +print("x=",spl.solve_banded((2,1),AB,b)) # LAPACK ( gbsv ) + + +# %% {"slideshow": {"slide_type": "slide"}} +P,L,U = spl.lu(A) # P A = L U +np.set_printoptions(precision=3) +for M in (P,L,U): + print(M, end="\n"+20*"-"+"\n") + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## CSC (Compressed Sparse Column) +# +# - All operations are optimized +# - Efficient "slicing" along axis=1. +# - Fast Matrix-vector product. +# - Conversion to other format could be costly. + +# %% {"slideshow": {"slide_type": "fragment"}} +import scipy.sparse as spsp +row = sp.array([0,2,2,0,1,2]) +col = sp.array([0,0,1,2,2,2]) +data = sp.array([1,2,3,4,5,6]) +Mcsc1 = spsp.csc_matrix((data,(row,col)),shape=(3,3)) +Mcsc1.todense() + +# %% {"slideshow": {"slide_type": "fragment"}} +indptr = sp.array([0,2,3,6]) +indices = sp.array([0,2,2,0,1,2]) +data = sp.array([1,2,3,4,5,6]) +Mcsc2 = spsp.csc_matrix ((data,indices,indptr),shape=(3,3)) +Mcsc2.todense() + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Dedicated format for assembling +# - `lil_matrix` : Row-based linked list matrix. Easy format to build your matrix and convert to other format before solving. +# - `dok_matrix` : A dictionary of keys based matrix. Ideal format for +# incremental matrix building. The conversion to csc/csr format is efficient. +# - `coo_matrix` : coordinate list format. Fast conversion to formats CSC/CSR. +# +# [Lien vers la documentation scipy](http://docs.scipy.org/doc/scipy/reference/sparse.html) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Matrices creuses : [scipy.sparse.linalg](https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.linalg) +# +# - speigen, speigen_symmetric, lobpcg : (ARPACK). +# - svd : (ARPACK). +# - Direct methods (UMFPACK or SUPERLU) ou iteratives +# - Minimization : lsqr and minres +# +# For linear algebra: +# - Noobs: spsolve. +# - Intermmediate: dsolve.spsolve or isolve.spsolve +# - Advanced: splu, spilu (direct); cg, cgs, bicg, bicgstab, gmres, lgmres et qmr (iterative) +# - Boss: petsc4py et slepc4py. +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## LinearOperator +# +# The LinearOperator is used for matrix-free numerical methods. + +# %% {"slideshow": {"slide_type": "fragment"}} +import scipy.sparse.linalg as spspl +def mv(v): + return sp.array([2*v[0],3*v[1]]) + +A=spspl.LinearOperator((2 ,2),matvec=mv,dtype=float ) +A + +# %% {"slideshow": {"slide_type": "slide"}} +A*sp.ones(2) + +# %% {"slideshow": {"slide_type": "fragment"}} +A.matmat(sp.array([[1,-2],[3,6]])) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## LU decomposition + +# %% {"slideshow": {"slide_type": "fragment"}} +N = 50 +un = sp.ones(N) +w = sp.rand(N+1) +A = spsp.spdiags([w[1:],-2*un,w[:-1]],[-1,0,1],N,N) # tridiagonal matrix +A = A.tocsc() +b = un +op = spspl.splu(A) +op + +# %% {"slideshow": {"slide_type": "fragment"}} +x=op.solve(b) +spl.norm(A*x-b) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Conjugate Gradient + +# %% {"slideshow": {"slide_type": "fragment"}} +global k +k=0 +def f(xk): # function called at every iterations + global k + print ("iteration {0:2d} residu = {1:7.3g}".format(k,spl.norm(A*xk-b))) + k += 1 + +x,info=spspl.cg(A,b,x0=sp.zeros(N),tol=1.0e-12,maxiter=N,M=None,callback=f) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Preconditioned conjugate gradient + +# %% {"slideshow": {"slide_type": "fragment"}} +pc=spspl.spilu(A,drop_tol=0.1) # pc is an ILU decomposition +xp=pc.solve(b) +spl.norm(A*xp-b) + + +# %% {"slideshow": {"slide_type": "fragment"}} +def mv(v): + return pc.solve(v) +lo = spspl.LinearOperator((N,N),matvec=mv) +k = 0 +x,info=spspl.cg(A,b,x0=sp.zeros(N),tol=1.e-12,maxiter=N,M=lo,callback=f) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Numerical integration +# +# - quad, dblquad, tplquad,... Fortran library QUADPACK. +# + +# %% {"slideshow": {"slide_type": "fragment"}} +import scipy.integrate as spi + +x2=lambda x: x**2 +4.**3/3 # int(x2) in [0,4] + +# %% {"slideshow": {"slide_type": "fragment"}} +spi.quad(x2,0.,4.) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Scipy ODE solver +# +# It uses the Fortran ODEPACK library. +# +# ### Van der Pol Oscillator +# $$ +# \begin{eqnarray} +# y_1'(t) & = & y_2(t), \nonumber \\ +# y_2'(t) & = & 1000(1 - y_1^2(t))y_2(t) - y_1(t) \nonumber +# \end{eqnarray} +# $$ +# with $y_1(0) = 2 $ and $ y_2(0) = 0. $. + +# %% {"slideshow": {"slide_type": "fragment"}} +import numpy as np +import scipy.integrate as spi + +def vdp1000(y,t): + dy=np.zeros(2) + dy[0]=y[1] + dy[1]=1000.*(1.-y[0]**2)*y[1]-y[0] + return dy + + +# %% {"slideshow": {"slide_type": "slide"}} +t0, tf =0, 3000 +N = 300000 +t, dt = np.linspace(t0,tf,N, retstep=True) + +# %% {"slideshow": {"slide_type": "fragment"}} +y=spi.odeint(vdp1000,[2.,0.],t) +plt.plot(t,y[:,0]); + +# %% [markdown] +# ## Exercise +# +# The following code solve the Laplace equation using a dense matrix. +# - Modified the code to use a sparse matrix + +# %% +%%time +%matplotlib inline +%config InlineBackend.figure_format = "retina" +import numpy as np +import matplotlib.pyplot as plt +plt.rcParams['figure.figsize'] = (10,6) + +# Boundary conditions +Tnorth, Tsouth, Twest, Teast = 100, 20, 50, 50 + +# Set meshgrid +n = 50 +l = 1.0 +h = l / (n-1) +X, Y = np.meshgrid(np.linspace(0,l,n), np.linspace(0,l,n)) +T = np.zeros((n,n),dtype='d') + +# Set Boundary condition +T[n-1:, :] = Tnorth / h**2 +T[:1, :] = Tsouth / h**2 +T[:, n-1:] = Teast / h**2 +T[:, :1] = Twest / h**2 + +A = np.zeros((n*n,n*n),dtype='d') +nn = n*n +ii = 0 +for j in range(n): + for i in range(n): + if j > 0: + jj = ii - n + A[ii,jj] = -1 + if j < n-1: + jj = ii + n + A[ii,jj] = -1 + if i > 0: + jj = ii - 1 + A[ii,jj] = -1 + if i < n-1: + jj = ii + 1 + A[ii,jj] = -1 + A[ii,ii] = 4 + ii = ii+1 + + +U = np.linalg.solve(A,np.ravel(h**2*T)) +T = U.reshape(n,n) +plt.contourf(X,Y,T) +plt.colorbar() + +# %% +%%time +import scipy.sparse as spsp +import scipy.sparse.linalg as spspl + +# Boundary conditions +Tnorth, Tsouth, Twest, Teast = 100, 20, 50, 50 + +# Set meshgrid +n = 50 +l = 1.0 +h = l / (n-1) +X, Y = np.meshgrid(np.linspace(0,l,n), np.linspace(0,l,n)) +T = np.zeros((n,n),dtype='d') + +# Set Boundary condition +T[n-1:, :] = Tnorth / h**2 +T[ :1, :] = Tsouth / h**2 +T[ :, n-1:] = Teast / h**2 +T[ :, :1] = Twest / h**2 + +bdiag = -4 * np.eye(n) +bup = np.diag([1] * (n - 1), 1) +blow = np.diag([1] * (n - 1), -1) +block = bdiag + bup + blow +# Creat a list of n blocks +blist = [block] * n +S = spsp.block_diag(blist) +# Upper diagonal array offset by -n +upper = np.diag(np.ones(n * (n - 1)), n) +# Lower diagonal array offset by -n +lower = np.diag(np.ones(n * (n - 1)), -n) +S += upper + lower + +T = sp.linalg.solve(S,np.ravel(h**2*T)) +plt.contourf(X,Y,T.reshape(n,n)) +plt.colorbar(); diff --git a/15.Sympy.py b/15.Sympy.py new file mode 100644 index 0000000..3c2b4ca --- /dev/null +++ b/15.Sympy.py @@ -0,0 +1,439 @@ +# -*- coding: utf-8 -*- +# --- +# jupyter: +# jupytext: +# comment_magics: false +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.2' +# jupytext_version: 1.1.1 +# kernelspec: +# display_name: Python 3 +# language: python +# name: python3 +# --- + +# %% {"slideshow": {"slide_type": "fragment"}} +%matplotlib inline +%config InlineBackend.figure_format = "retina" +import matplotlib.pyplot as plt +import numpy as np +import seaborn as sns +sns.set() +plt.rcParams['figure.figsize'] = (10.0, 6.0) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Sympy +#  +# +# The function init_printing() will enable LaTeX pretty printing in the notebook for SymPy expressions. + +# %% {"slideshow": {"slide_type": "fragment"}} +import sympy as sym +from sympy import symbols, Symbol +sym.init_printing() + +# %% {"slideshow": {"slide_type": "slide"}} +x= Symbol('x') +(sym.pi + x)**2 + +# %% {"slideshow": {"slide_type": "fragment"}} +alpha1, omega_2 = symbols('alpha1 omega_2') +alpha1, omega_2 + +# %% {"slideshow": {"slide_type": "fragment"}} +mu, sigma = sym.symbols('mu sigma', positive = True) +1/sym.sqrt(2*sym.pi*sigma**2)* sym.exp(-(x-mu)**2/(2*sigma**2)) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Why use `sympy`? +# - Symbolic derivatives +# - Translate mathematics into low level code +# - Deal with very large expressions +# - Optimize code using mathematics + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# Dividing two integers in Python creates a float, like 1/2 -> 0.5. If you want a rational number, use Rational(1, 2) or S(1)/2. + +# %% {"slideshow": {"slide_type": "fragment"}} +x + sym.S(1)/2 , sym.Rational(1,4) + +# %% {"slideshow": {"slide_type": "fragment"}} +y = Symbol('y') +x ^ y # XOR operator (True only if x != y) + +# %% {"slideshow": {"slide_type": "fragment"}} +x**y + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# SymPy expressions are immutable. Functions that operate on an expression return a new expression. + +# %% {"slideshow": {"slide_type": "fragment"}} +expr = x + 1 +expr + +# %% {"slideshow": {"slide_type": "fragment"}} +expr.subs(x, 2) + +# %% {"slideshow": {"slide_type": "fragment"}} +expr + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Exercise: Lagrange polynomial +# +# Given a set of $k + 1$ data points +# :$(x_0, y_0),\ldots,(x_j, y_j),\ldots,(x_k, y_k)$ the Lagrange interpolation polynomial is: +# +# $$ +# L(x) := \sum_{j=0}^{k} y_j \ell_j(x) +# $$ +# $\ell_j$ are Lagrange basis polynomials: +# $$\ell_j(x) := \prod_{\begin{smallmatrix}0\le m\le k\\ m\neq j\end{smallmatrix}} \frac{x-x_m}{x_j-x_m} $$ +# We can demonstrate that at each point $x_i$, $L(x_i)=y_i$ so $L$ interpolates the function. +# +# - Compute the Lagrange polynomial for points +# $$ +# (-2,21),(-1,1),(0,-1),(1,-3),(2,1) +# $$ +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Evaluate an expression + +# %% {"slideshow": {"slide_type": "fragment"}} +sym.sqrt(2), sym.sqrt(2).evalf(7) # set the precision to 7 digits + +# %% {"slideshow": {"slide_type": "fragment"}} +from sympy import sin +x = Symbol('x') +expr = sin(x)/x +expr.evalf(subs={x: 3.14}) # substitute the symbol x by Pi value + +# %% {"slideshow": {"slide_type": "slide"}} +from sympy.utilities.autowrap import ufuncify +f = ufuncify([x], expr, backend='f2py') + +t = np.linspace(0,4*np.pi,100) +plt.plot(t, f(t)); + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Exercise +# +# - Plot the Lagrange polynomial computed above and interpolations points with matplotlib + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Undefined functions and derivatives +# +# Undefined functions are created with `Function()`. Undefined are useful to state that one variable depends on another (for the purposes of differentiation). + +# %% {"slideshow": {"slide_type": "fragment"}} +from sympy import Function +f = Function('f') + +# %% {"slideshow": {"slide_type": "fragment"}} +f(x) + 1 + +# %% {"slideshow": {"slide_type": "fragment"}} +from sympy import diff, sin, cos +diff(sin(x + 1)*cos(y), x), diff(sin(x + 1)*cos(y), x, y), diff(f(x), x) + +# %% {"slideshow": {"slide_type": "fragment"}} +c, t = sym.symbols('t c') +u = sym.Function('u') +sym.Eq(diff(u(t,x),t,t), c**2*diff(u(t,x),x,2)) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Matrices + +# %% {"slideshow": {"slide_type": "fragment"}} +from sympy import Matrix +Matrix([[1, 2], [3, 4]])*Matrix([x, y]) + +# %% {"slideshow": {"slide_type": "fragment"}} +x, y, z = sym.symbols('x y z') +Matrix([sin(x) + y, cos(y) + x, z]).jacobian([x, y, z]) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Matrix symbols +# +# SymPy can also operate on matrices of symbolic dimension ($n \times m$). `MatrixSymbol("M", n, m)` creates a matrix $M$ of shape $n \times m$. + +# %% {"slideshow": {"slide_type": "fragment"}} +from sympy import MatrixSymbol, Transpose + +n, m = sym.symbols('n m', integer=True) +M = MatrixSymbol("M", n, m) +b = MatrixSymbol("b", m, 1) +Transpose(M*b) + +# %% {"slideshow": {"slide_type": "fragment"}} +Transpose(M*b).doit() + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Solving systems of equations +# +# `solve` solves equations symbolically (not numerically). The return value is a list of solutions. It automatically assumes that it is equal to 0. + +# %% {"slideshow": {"slide_type": "fragment"}} +from sympy import Eq, solve +solve(Eq(x**2, 4), x) + +# %% {"slideshow": {"slide_type": "fragment"}} +solve(x**2 + 3*x - 3, x) + +# %% {"slideshow": {"slide_type": "fragment"}} +eq1 = x**2 + y**2 - 4 # circle of radius 2 +eq2 = 2*x + y - 1 # straight line: y(x) = -2*x + 1 +solve([eq1, eq2], [x, y]) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Solving differential equations +# `dsolve` can (sometimes) produce an exact symbolic solution. Like `solve`, `dsolve` assumes that expressions are equal to 0. + +# %% {"slideshow": {"slide_type": "fragment"}} +from sympy import Function, dsolve +f = Function('f') +dsolve(f(x).diff(x, 2) + f(x)) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Code printers +# The most basic form of code generation are the code printers. They convert SymPy expressions into over a dozen target languages. +# + +# %% {"slideshow": {"slide_type": "fragment"}} +x = symbols('x') +expr = abs(sin(x**2)) +expr + +# %% {"slideshow": {"slide_type": "fragment"}} +sym.ccode(expr) + +# %% {"slideshow": {"slide_type": "fragment"}} +sym.fcode(expr, standard=2003, source_format='free') + +# %% {"slideshow": {"slide_type": "fragment"}} +from sympy.printing.cxxcode import cxxcode +cxxcode(expr) + +# %% {"slideshow": {"slide_type": "slide"}} +sym.tanh(x).rewrite(sym.exp) + +# %% {"slideshow": {"slide_type": "fragment"}} +from sympy import sqrt, exp, pi +expr = 1/sqrt(2*pi*sigma**2)* exp(-(x-mu)**2/(2*sigma**2)) +print(sym.fcode(expr, standard=2003, source_format='free')) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Creating a function from a symbolic expression +# In SymPy there is a function to create a Python function which evaluates (usually numerically) an expression. SymPy allows the user to define the signature of this function (which is convenient when working with e.g. a numerical solver in ``scipy``). + +# %% {"slideshow": {"slide_type": "fragment"}} +from sympy import log +x, y = symbols('x y') +expr = 3*x**2 + log(x**2 + y**2 + 1) +expr + +# %% {"slideshow": {"slide_type": "fragment"}} +%timeit expr.subs({x: 17, y: 42}).evalf() + +# %% {"slideshow": {"slide_type": "slide"}} +import math +f = lambda x, y: 3*x**2 + math.log(x**2 + y**2 + 1) +f(17, 42) + +# %% {"slideshow": {"slide_type": "fragment"}} +%timeit f(17, 42) + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# Evaluate above expression numerically invoking the subs method followed by the evalf method can be quite slow and cannot be done repeatedly. + +# %% {"slideshow": {"slide_type": "slide"}} +from sympy import lambdify +g = lambdify([x, y], expr, modules=['math']) +g(17, 42) + +# %% {"slideshow": {"slide_type": "fragment"}} +%timeit g(17, 42) + +# %% {"slideshow": {"slide_type": "fragment"}} +xarr = np.linspace(17, 18, 5) +h = lambdify([x, y], expr) # lambdify return a python function +out = h(xarr, 42) +out.shape + +# %% {"slideshow": {"slide_type": "fragment"}} +z = z1, z2, z3 = symbols('z:3') +expr2 = x*y*(z1 + z2 + z3) +func2 = lambdify([x, y, z], expr2) +func2(1, 2, (3, 4, 5)) + + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# Behind the scenes lambdify constructs a string representation of the Python code and uses Python's eval function to compile the function. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### SIR model +# +# $$ +# \begin{eqnarray} +# \frac{dS(t)}{dt} &=& - \beta S(t) I(t) \\ +# \frac{dI(t)}{dt} &=& \beta S(t) I(t) - \gamma I(t) \\ +# \frac{dR(t)}{dt} &=& \gamma I(t) +# \end{eqnarray} +# $$ +# +# - S,I,R: ratio of suceptibles, infectious and recovered fraction of the population. +# - t: time +# - $\beta$ : transmission coefficient. +# - $\gamma$ : healing rate. +# +# **We assume that total population is constant.** + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Solving the initial value problem numerically +# We will now integrate this system of ordinary differential equations numerically using the ``odeint`` solver provided by ``scipy``: +# + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# By looking at the [documentation](https://docs.scipy.org/doc/scipy-0.19.0/reference/generated/scipy.integrate.odeint.html) of odeint we see that we need to provide a function which computes a vector of derivatives ($\dot{\mathbf{y}} = [\frac{dy_1}{dt}, \frac{dy_2}{dt}, \frac{dy_3}{dt}]$). The expected signature of this function is: +# +# f(y: array[float64], t: float64, *args: arbitrary constants) -> dydt: array[float64] +# +# in our case we can write it as: + +# %% {"slideshow": {"slide_type": "fragment"}} +def rhs(y, t, beta, gamma): + rb = beta * y[0]*y[1] + rg = gamma * y[1] + return [- rb , rb - rg, rg] + + +# %% {"slideshow": {"slide_type": "slide"}} +import scipy.integrate as spi +tout = np.linspace(0, 10, 100) +k_vals = 1.66, 0.4545455 +y0 = [0.95, 0.05, 0] +yout = spi.odeint(rhs, y0, tout, k_vals) +plt.plot(tout, yout) +plt.legend(['susceptible', 'infected', 'recovered']); + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# We will construct the system from a symbolic representation. But at the same time, we need the ``rhs`` function to be fast. Which means that we want to produce a fast function from our symbolic representation. Generating a function from our symbolic representation is achieved through *code generation*. +# +# 1. Construct a symbolic representation from some domain specific representation using SymPy. +# 2. Have SymPy generate a function with an appropriate signature (or multiple thereof), which we pass on to the solver. +# +# We will achieve (1) by using SymPy symbols (and functions if needed). For (2) we will use a function in SymPy called ``lambdify``―it takes a symbolic expressions and returns a function. In a later notebook, we will look at (1), for now we will just use ``rhs`` which we've already written: + +# %% {"slideshow": {"slide_type": "fragment"}} +y, k = sym.symbols('y:3'), sym.symbols('beta gamma') +ydot = rhs(y, None, *k) +y, ydot + +# %% {"slideshow": {"slide_type": "slide"}} +f = sym.lambdify((y,t)+k, ydot) +plt.plot(tout, spi.odeint(f, y0, tout, k_vals)) +plt.legend(['Suceptible', 'Infected', 'Recovered']); + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# In this example the gains of using a symbolic representation are arguably limited. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# Let's take the same example with demography and $n$ classes of subjects: +# +# $$ +# X_i = S_i, I_i, R_i \qquad i = 1 \ldots n +# $$ +# +# $$ +# \frac{dS_i}{dt} = \nu_i - \beta_i S_i I_i - \mu_i S_i + +# \sum_{j=1}^n m_{ji} S_j-\sum_{j=1}^n m_{ij} S_i \\ +# \frac{dI_i}{dt} = \beta_i S_i I_i - (\gamma_i + \mu_i) I_i + +# \sum_{j=1}^n m_{ij} I_j-\sum_{j=1}^n m_{ji} I_i \\ +# \frac{dR_i}{dt} = - \frac{dS_i}{dt} - \frac{dI_i}{dt} +# $$ +# +# - $\beta$ : transmission coefficient +# - $\gamma$ : healing rate +# - $\mu$ : mortality rate +# - $\nu$ : birth rate +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Exercise +# +# - Create the symbolic matrix $m$, symbols $\nu_i,\mu_i,\beta_i,\gamma_i$ for $i=0,1,2$ and $y_j$ for +# $j=0,1,2,\ldots,8$ +# - Write the system $\dot{y} = f(t,y,m,\nu,\mu,\beta,\gamma)$ +# - `lambdify` the $f$ function. +# - Solve the system with: +# $$ +# m = \begin{bmatrix} +# 0 & 0.01 & 0.01 \\ +# 0.01 & 0 & 0.01 \\ +# 0.01 & 0.01 & 0 \\ +# \end{bmatrix} +# $$ +# $$ +# \begin{aligned} +# t &= [0,10] \mbox{ with } dt = 0.1 \\ +# \nu_i &= 0.0 \\ +# \mu_i &= 0.0 \\ +# \beta_i &= 1.66 \\ +# \gamma_i &= [0.4545,0.3545,0.2545] \\ +# S_i&= 0.95 \\ +# I_i &= 0.05 \\ +# R_i &= 0.0 +# \end{aligned} +# $$ +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Exercise : Bezier curve +# +# We want to compute and the draw the Bezier curve between the 3 points $p_0$, $p_1$, and $p_2$, +# The middle point $p_1$ position is arbitrary. +# +# $$ +# p0=(1,0); \qquad +# p1=(x,y); \qquad +# p2=(0,1) +# $$ +# +# +# The $n+1$ Bernstein basis polynomials of degree $n$ are defined as +# +# $$ +# b_{i,n}(x) = {n \choose i} x^{i} \left( 1 - x \right)^{n - i}, \quad i = 0, \ldots, n. +# $$ +# +# where ${n \choose i}$ is the binomial coefficient. +# +# The Bezier curve is defined by a linear combination of Bernstein basis polynomials: +# +# $$B_n(x) = \sum_{i=0}^{n} \beta_{i} b_{i,n}(x)$$ +# +# - With`sympy.binomial`, write a function `bpoly(t,n,i)` that returns the Bernstein basis polynomial $b_{i,n}(t)$. +# - Compute the Berstein polynomial representing the Bezier curve between $p_0,p_1,p_2$. $\beta_i=1$. +# - Plot the Bezier Curve for 3 positions of $p_1= (0,0), (0.5,0.5), (1,1)$ +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Integrals quadrature + +# %% {"slideshow": {"slide_type": "fragment"}} +from sympy.integrals.quadrature import * +x, w = gauss_legendre(3, 5) +x, w + +# %% {"slideshow": {"slide_type": "fragment"}} +x, w = gauss_lobatto(3,12) +x, w + +# %% [markdown] {"slideshow": {"slide_type": "skip"}} +# # References +# +# - [SciPy 2017 tutorial](https://youtu.be/5jzIVp6bTy0) +# +# diff --git a/16.Fortran.py b/16.Fortran.py new file mode 100644 index 0000000..8861a09 --- /dev/null +++ b/16.Fortran.py @@ -0,0 +1,560 @@ +# -*- coding: utf-8 -*- +# --- +# jupyter: +# jupytext: +# comment_magics: false +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.2' +# jupytext_version: 1.1.1 +# kernelspec: +# display_name: Python 3 +# language: python +# name: python3 +# --- + +# %% {"slideshow": {"slide_type": "slide"}} +%matplotlib inline +%config InlineBackend.figure_format = 'retina' +import matplotlib.pyplot as plt +import scipy.fftpack as sf +import scipy.linalg as sl +import numpy as np + +# %% {"slideshow": {"slide_type": "fragment"}} +import sys +%env FC=gfortran +if sys.platform == "darwin": + %env CC=gcc-8 +# change values for your configuration + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # f2py +# f2py is a part of Numpy and there are three ways to wrap Fortran with Python : +# - Write some fortran subroutines and just run f2py to create Python modules. +# - Insert special f2py directives inside Fortran source for complex wrapping. +# - Write a interface file (.pyf) to wrap Fortran files without changing them. f2py automatically generate the pyf template file that can be modified. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Simple Fortran subroutine to compute norm +# +# ### Fortran 90/95 free format + +# %% {"slideshow": {"slide_type": "fragment"}} +%%file euclidian_norm.f90 +subroutine euclidian_norm (a, b, c) + real(8), intent(in) :: a, b + real(8), intent(out) :: c + c = sqrt (a*a+b*b) +end subroutine euclidian_norm + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Fortran 77 fixed format + +# %% {"slideshow": {"slide_type": "fragment"}} +%%file euclidian_norm.f + subroutine euclidian_norm (a, b, c) + real*8 a,b,c +Cf2py intent(out) c + c = sqrt (a*a+b*b) + end + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Build extension module with f2py program +# + +# %% {"slideshow": {"slide_type": "fragment"}} +!f2py -c euclidian_norm.f90 -m vect --fcompiler=gnu95 --f90flags=-O3 + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Use the extension module in Python + +# %% {"slideshow": {"slide_type": "fragment"}} +import vect +c = vect.euclidian_norm(3,4) +c + +# %% {"slideshow": {"slide_type": "fragment"}} +print(vect.euclidian_norm.__doc__) # Docstring is automatically generate + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Fortran magic +# +# - Jupyter extension that help to use fortran code in an interactive session. +# - It adds a %%fortran cell magic that compile and import the Fortran code in the cell, using F2py. +# - The contents of the cell are written to a .f90 file in the directory IPYTHONDIR/fortran using a filename with the hash of the code. This file is then compiled. The resulting module is imported and all of its symbols are injected into the user's namespace. +# +# [Documentation](http://nbviewer.jupyter.org/github/mgaitan/fortran_magic/blob/master/documentation.ipynb) + +# %% {"slideshow": {"slide_type": "fragment"}} +%load_ext fortranmagic + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # F2py directives +# - F2PY introduces also some extensions to Fortran 90/95 language specification that help designing Fortran to Python interface, make it more “Pythonic”. +# - If editing Fortran codes is acceptable, these specific attributes can be inserted directly to Fortran source codes. Special comment lines are ignored by Fortran compilers but F2PY interprets them as normal lines. +# +# + +# %% {"slideshow": {"slide_type": "fragment"}} +%%fortran +subroutine euclidian_norm(a,c,n) + integer :: n + real(8),dimension(n),intent(in) :: a + !f2py optional , depend(a) :: n=len(a) + real(8),intent(out) :: c + real(8) :: sommec + integer :: i + sommec = 0 + do i=1,n + sommec=sommec+a( i )*a( i ) + end do + c = sqrt (sommec) +end subroutine euclidian_norm + +# %% {"slideshow": {"slide_type": "slide"}} +a=[2,3,4] # Python list +type(a) + +# %% {"slideshow": {"slide_type": "fragment"}} +euclidian_norm(a) + +# %% {"slideshow": {"slide_type": "fragment"}} +a=np.arange(2,5) # numpy array +type(a) + +# %% {"slideshow": {"slide_type": "fragment"}} +euclidian_norm(a) + +# %% {"slideshow": {"slide_type": "slide"}} +print(euclidian_norm.__doc__) # Documentation + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # F2py directives +# - `optional`: The corresponding argument is moved to the end. +# - `required`: This is default. Use it to disable automatic optional setting. +# - `intent(in | inout | out | hide)` , `intent(in)` is the default. +# - `intent(out)` is implicitly translated to `intent(out,hide) `. +# - `intent(copy)` and `intent(overwrite)` control changes for input arguments. +# - `check` performs some assertions, it is often automatically generated. +# - `depend`: f2py detects cyclic dependencies. +# - `allocatable, parameter` +# - `intent(callback), external`: for function as arguments. +# - `intent(c)` C-type argument , array or function. +# - C expressions: `rank, shape, len, size, slen`. +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Callback +# +# You can call a python function inside your fortran code +# + +# %% {"slideshow": {"slide_type": "fragment"}} +%%fortran +subroutine sum_f (f ,n, s) + !Compute sum(f(i), i=1,n) + external f + integer, intent(in) :: n + real, intent(out) :: s + s = 0.0 + do i=1,n + s=s+f(i) + end do +end subroutine sum_f + + +# %% {"slideshow": {"slide_type": "slide"}} +def fonction(i) : # python function + return i*i + +sum_f(fonction,3) + +# %% {"slideshow": {"slide_type": "fragment"}} +sum_f(lambda x :x**2,3) # lambda function + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Fortran arrays and Numpy arrays +# +# Let's see how to pass numpy arrays to fortran subroutine. +# + +# %% {"slideshow": {"slide_type": "fragment"}} +%%fortran --extra "-DF2PY_REPORT_ON_ARRAY_COPY=1" +subroutine push( positions, velocities, dt, n) + integer, intent(in) :: n + real(8), intent(in) :: dt + real(8), dimension(n,3), intent(in) :: velocities + real(8), dimension(n,3) :: positions + do i = 1, n + positions(i,:) = positions(i,:) + dt*velocities(i,:) + end do +end subroutine push + +# %% {"slideshow": {"slide_type": "fragment"}} +positions = [[0, 0, 0], [0, 0, 0], [0, 0, 0]] +velocities = [[0, 1, 2], [0, 3, 2], [0, 1, 3]] + +# %% {"slideshow": {"slide_type": "fragment"}} +import sys +push(positions, velocities, 0.1) +positions # memory is not updated because we used C memory storage + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# During execution, the message "created an array from object" is displayed, because a copy of is made when passing multidimensional array to fortran subroutine. + +# %% {"slideshow": {"slide_type": "fragment"}} +positions = np.array(positions, dtype='f8', order='F') +push(positions, velocities, 0.1) +positions # the memory is updated + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Signature file +# +# This file contains descriptions of wrappers to Fortran or C functions, also called as signatures of the functions. F2PY can create initial signature file by scanning Fortran source codes and catching all relevant information needed to create wrapper functions. +# +# ```bash +# f2py vector.f90 -h vector.pyf +# ``` +# - vector.pyf +# +# ```fortran +# ! -*- f90 -*- +# ! Note: the context of this file is case sensitive. +# +# subroutine euclidian_norm(a,c,n) ! in vector.f90 +# real(kind=8) dimension(n),intent(in) :: a +# real(kind=8) intent(out) :: c +# integer optional,check(len(a)>=n),depend(a) :: n=len(a) +# end subroutine euclidian_norm +# +# ! This file was auto-generated with f2py (version:2). +# ! See http://cens.ioc.ee/projects/f2py2e/ +# ``` +# + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Wrap lapack function dgemm with f2py +# +# - Generate the signature file + +# %% {"slideshow": {"slide_type": "fragment"}} +%rm -f dgemm.f dgemm.pyf +!wget http://ftp.mcs.anl.gov/pub/MINPACK-2/blas/dgemm.f + +# %% {"slideshow": {"slide_type": "slide"}} +# %load dgemm.f + +# %% {"slideshow": {"slide_type": "fragment"}} +!f2py -m mylapack --overwrite-signature -h dgemm.pyf dgemm.f + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ```fortran +# ! -*- f90 -*- +# ! Note: the context of this file is case sensitive. +# +# python module mylapack ! in +# interface ! in :mylapack +# subroutine dgemm(transa,transb,m,n,k,alpha,a,lda,b,ldb,beta,c,ldc) ! in :mylapack:dgemm.f +# character*1 :: transa +# character*1 :: transb +# integer :: m +# integer :: n +# integer :: k +# double precision :: alpha +# double precision dimension(lda,*) :: a +# integer, optional,check(shape(a,0)==lda),depend(a) :: lda=shape(a,0) +# double precision dimension(ldb,*) :: b +# integer, optional,check(shape(b,0)==ldb),depend(b) :: ldb=shape(b,0) +# double precision :: beta +# double precision dimension(ldc,*) :: c +# integer, optional,check(shape(c,0)==ldc),depend(c) :: ldc=shape(c,0) +# end subroutine dgemm +# end interface +# end python module mylapack +# +# ! This file was auto-generated with f2py (version:2). +# ! See http://cens.ioc.ee/projects/f2py2e/ +# ``` + +# %% {"slideshow": {"slide_type": "slide"}} +!f2py -c dgemm.pyf -llapack + +# %% {"slideshow": {"slide_type": "slide"}} +import numpy as np +import mylapack +a = np.array([[7,8],[3,4],[1,2]]) +b = np.array([[1,2,3],[4,5,6]]) +print("a=",a) +print("b=",b) +assert a.shape[1] == b.shape[0] +c = np.zeros((a.shape[0],b.shape[1]),'d',order='F') +mylapack.dgemm('N','N',a.shape[0],b.shape[1],a.shape[1],1.0,a,b,1.0,c) +print(c) +np.all(c == a @ b) # check with numpy matrix multiplication + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ### Exercise +# - Modify the file dgemm.pyf to set all arguments top optional and keep only the two matrices as input. + +# %% {"slideshow": {"slide_type": "slide"}} +# %load solutions/fortran/dgemm2.pyf + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Build the pythoni module + +# %% {"slideshow": {"slide_type": "fragment"}} +!f2py -c dgemm2.pyf -llapack --f90flags=-O3 + +# %% {"slideshow": {"slide_type": "slide"}} +import mylapack2 +a = np.array([[7,8],[3,4],[1,2]]) +b = np.array([[1,2,3],[4,5,6]]) +c = mylapack2.dgemm(a,b) +np.all( c == a @ b) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# ## Check performance between numpy and mylapack + +# %% {"slideshow": {"slide_type": "fragment"}} +a = np.random.random((512,128)) +b = np.random.random((128,512)) + +# %% {"slideshow": {"slide_type": "fragment"}} +%timeit c = mylapack2.dgemm(a,b) + +# %% {"slideshow": {"slide_type": "fragment"}} +%timeit c = a @ b + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# **Fortran arrays allocated in a subroutine share same memory in Python** + +# %% {"slideshow": {"slide_type": "fragment"}} +%%fortran +module f90module + implicit none + real(8), dimension(:), allocatable :: farray +contains + subroutine init( n ) !Allocation du tableau farray + integer, intent(in) :: n + allocate(farray(n)) + end subroutine init +end module f90module + +# %% {"slideshow": {"slide_type": "fragment"}} +f90module.init(10) +len(f90module.farray) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# **Numpy arrays allocated in Python passed to Fortran are already allocated** + +# %% {"slideshow": {"slide_type": "fragment"}} +%%fortran +module f90module + implicit none + real(8), dimension(:), allocatable :: farray +contains + subroutine test_array( allocated_flag, array_size ) + logical, intent(out) :: allocated_flag + integer, intent(out) :: array_size + allocated_flag = allocated(farray) + array_size = size(farray) + end subroutine test_array +end module f90module + +# %% {"slideshow": {"slide_type": "fragment"}} +f90module.farray = np.random.rand(10).astype(np.float64) +f90module.test_array() + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # f2py + OpenMP +# +# + +# %% {"slideshow": {"slide_type": "fragment"}} +import os, sys + +if sys.platform == 'darwin': # for mac users + os.environ['CC'] = 'gcc-8' + +%env OMP_NUM_THREADS=4 + +# %% {"slideshow": {"slide_type": "fragment"}} +%%fortran +subroutine hello( ) + integer :: i + do i = 1, 4 + call sleep(1) + end do +end subroutine + +# %% {"slideshow": {"slide_type": "fragment"}} +%%time +hello() + +# %% {"slideshow": {"slide_type": "slide"}} +%%fortran --f90flags "-fopenmp" --extra "-L/usr/local/lib -lgomp" +subroutine hello_omp( ) + integer :: i + !$OMP PARALLEL PRIVATE(I) + !$OMP DO + do i = 1, 4 + call sleep(1) + end do + !$OMP END DO + !$OMP END PARALLEL + +end subroutine + + +# %% {"slideshow": {"slide_type": "fragment"}} +%%time +hello_omp() + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Conclusions +# +# - Easy to use, it works with modern fortran, legacy fortran and also C. +# - Works with common and modules and arrays dynamically allocated. +# - Python function callback can be very useful combined with Sympy +# - Documentation is automatically generated +# - All fortran compilers are supported: GNU, Portland, Sun, Intel,... +# - F2py is integrated in numpy library. +# +# ## cons +# - Derived types and fortran pointers are not well supported. +# - Absolutely not compatible with fortran 2003-2008 new features (classes) +# - f2py is maintained but not really improved. Development is stopped. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # distutils +# +# ## setup.py +# ```python +# from numpy.distutils.core import Extension, setup +# ext1 = Extension(name = 'scalar', +# sources = ['scalar.f']) +# ext2 = Extension(name = 'fib2', +# sources = ['fib2.pyf','fib1.f']) +# +# setup(name = 'f2py_example', ext_modules = [ext1,ext2]) +# ``` +# Compilation +# ```bash +# python3 setup.py build_ext --inplace +# ``` + +# %% [markdown] +# ### Exercice: Laplace problem +# +# - Replace the `laplace` function by a fortran subroutine + +# %% +%%time +%matplotlib inline +%config InlineBackend.figure_format = 'retina' +import numpy as np +import matplotlib.pyplot as plt +import itertools +# Boundary conditions +Tnorth, Tsouth, Twest, Teast = 100, 20, 50, 50 + +# Set meshgrid +n, l = 64, 1.0 +X, Y = np.meshgrid(np.linspace(0,l,n), np.linspace(0,l,n)) +T = np.zeros((n,n)) + +# Set Boundary condition +T[n-1:, :] = Tnorth +T[:1, :] = Tsouth +T[:, n-1:] = Teast +T[:, :1] = Twest + +def laplace(T, n): + residual = 0.0 + for i in range(1, n-1): + for j in range(1, n-1): + T_old = T[i,j] + T[i, j] = 0.25 * (T[i+1,j] + T[i-1,j] + T[i,j+1] + T[i,j-1]) + if T[i,j]>0: + residual=max(residual,abs((T_old-T[i,j])/T[i,j])) + return residual + +residual = 1.0 +istep = 0 +while residual > 1e-5 : + istep += 1 + residual = laplace(T, n) + print ((istep, residual), end="\r") + +print("iterations = ",istep) +plt.rcParams['figure.figsize'] = (10,6.67) +plt.title("Temperature") +plt.contourf(X, Y, T) +plt.colorbar() + +# %% +# %load solutions/fortran/laplace_fortran.F90 +subroutine laplace_fortran( T, n, residual ) + + real(8), intent(inout) :: T(0:n-1,0:n-1) ! Python indexing + integer, intent(in) :: n + real(8), intent(out) :: residual + real(8) :: T_old + + residual = 0.0 + do i = 1, n-2 + do j = 1, n-2 + T_old = T(i,j) + T(i, j) = 0.25 * (T(i+1,j) + T(i-1,j) + T(i,j+1) + T(i,j-1)) + if (T(i,j) > 0) then + residual=max(residual,abs((T_old-T(i,j))/T(i,j))) + end if + end do + end do + +end subroutine laplace_fortran + +# %% +%%time +%matplotlib inline +%config InlineBackend.figure_format = 'retina' +import numpy as np +import matplotlib.pyplot as plt +import itertools +# Boundary conditions +Tnorth, Tsouth, Twest, Teast = 100, 20, 50, 50 + +# Set meshgrid +n, l = 64, 1.0 +X, Y = np.meshgrid(np.linspace(0,l,n), np.linspace(0,l,n)) +T = np.zeros((n,n), order='F') ## We need to declare a new order in memory + +# Set Boundary condition +T[n-1:, :] = Tnorth +T[:1, :] = Tsouth +T[:, n-1:] = Teast +T[:, :1] = Twest + +residual = 1.0 +istep = 0 +while residual > 1e-5 : + istep += 1 + residual = laplace_fortran(T, n) + print ((istep, residual), end="\r") + +print() +print("iterations = ",istep) +plt.rcParams['figure.figsize'] = (10,6.67) +plt.title("Temperature") +plt.contourf(X, Y, T) +plt.colorbar() + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # References +# - [Talk by E. Sonnendrücker](http://calcul.math.cnrs.fr/Documents/Journees/dec2006/python-fortran.pdf) +# - [SciPy](http://www.scipy.org/F2py) +# - [Sagemath Documentation ](http://www.sagemath.org/doc/numerical_sage/f2py.html) +# - Hans Petter Langtangen. *Python Scripting for Computational Science*. Springer 2004 +# diff --git a/17.Cython.py b/17.Cython.py new file mode 100644 index 0000000..d8b028a --- /dev/null +++ b/17.Cython.py @@ -0,0 +1,792 @@ +# -*- coding: utf-8 -*- +# --- +# jupyter: +# jupytext: +# comment_magics: false +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.2' +# jupytext_version: 1.1.1 +# kernelspec: +# display_name: Python 3 +# language: python +# name: python3 +# --- + +# %% {"slideshow": {"slide_type": "skip"}} +%matplotlib inline +import matplotlib.pyplot as plt +plt.rcParams['figure.figsize'] = (10,6) +%config InlineBackend.figure_format = 'retina' +import numpy as np + + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +#  + +# %% [markdown] {"slideshow": {"slide_type": "fragment"}} +# * Cython provides extra syntax allowing for static type declarations (remember: Python is generally dynamically typed) +# * Python code gets translated into optimised C/C++ code and compiled as Python extension modules +# * Cython allows you to write fast C code in a Python-like syntax. +# * Furthermore, linking to existing C libraries is simplified. + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Pure Python Function +# +# +# $f(x)=-2x^3+5x^2+x$, + +# %% {"slideshow": {"slide_type": "fragment"}} +def f(x): + return -4*x**3 +3*x**2 +2*x + +x = np.linspace(-1,1,100) +ax = plt.subplot(1,1,1) +ax.plot(x, f(x)) +ax.fill_between(x, 0, f(x)); + + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# we compute integral $\int_a^b f(x)dx$ numerically with $N$ points. + +# %% {"slideshow": {"slide_type": "fragment"}} +def integrate_f_py(a,b,N): + s = 0 + dx = (b - a) / (N-1) + for i in range(N-1): # we intentionally use the bad way to do this with a loop + x = a + i*dx + s += (f(x)+f(x+dx))/2 + return s*dx + + +# %% {"slideshow": {"slide_type": "fragment"}} +%timeit integrate_f_py(-1,1,10**3) +print(integrate_f_py(-1,1,1000)) + +# %% {"slideshow": {"slide_type": "slide"}} +%load_ext heat + +# %% {"slideshow": {"slide_type": "fragment"}} +%%heat +def f(x): + return -4*x**3 +3*x**2 +2*x +def integrate_f(a, b, N): + s = 0 + dx = (b - a) / (N-1) + for i in range(N-1): + x = a + i*dx + s += (f(x)+f(x+dx))/2 + return s*dx + +integrate_f(0, 10, 1000) + +# %% [markdown] {"slideshow": {"slide_type": "slide"}} +# # Pure C function +# + +# %% {"slideshow": {"slide_type": "slide"}} +%%file integral_f_c.c + +#include