2_numpy_sol.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy et matplotlib\n",
    "\n",
    "Dans cette section, nous allons découvrir deux modules indispensables à la programmation scientifique: [Numpy](http://www.numpy.org/) et [Matplotlib](http://matplotlib.org/).\n",
    "\n",
    "Cette section est adaptée d'un cours de Slim Essid et Alexandre Gramfort, qui était lui-même adapté du travail de J.R. Johansson (robert@riken.jp) http://dml.riken.jp/~rob/. Elle s'inspire aussi de la leçon du [Numpy avancé](https://paris-swc.github.io/advanced-numpy-lesson/) de Softwate Carpentry."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `numpy` est un module utilisé dans presque tous les projets de calcul numérique sous Python\n",
    "   * Il fournit des structures de données performantes pour la manipulation de vecteurs, matrices et tenseurs plus généraux\n",
    "   * `numpy` est écrit en C et en Fortran d'où ses performances élevées lorsque les calculs sont vectorisés (formulés comme des opérations sur des vecteurs/matrices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " * `matplotlib` est un module performant pour la génération de graphiques en 2D et 3D\n",
    "   * syntaxe très proche de celle de Matlab\n",
    "   * supporte texte et étiquettes en $\\LaTeX$\n",
    "   * sortie de qualité dans divers formats (PNG, PDF, SV, EPS...)\n",
    "   * interface graphique interactive pour explorer les figures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour utiliser `numpy` et `matplotlib` il faut commencer par les importer :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi faire cela (mais ce n'est pas conseillé):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from numpy import *\n",
    "from matplotlib.pyplot import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Arrays* `numpy`\n",
    "\n",
    "Dans la terminologie `numpy`, vecteurs, matrices et autres tenseurs sont appelés *arrays*.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Création d'*arrays* `numpy` \n",
    "\n",
    "Plusieurs possibilités:\n",
    "\n",
    " * à partir de listes ou tuples\n",
    " * en utilisant des fonctions dédiées, telles que `arange`, `linspace`, etc.\n",
    " * par chargement à partir de fichiers\n",
    "\n",
    "### A partir de listes\n",
    "\n",
    "Au moyen de la fonction `numpy.array` :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 2 4]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# un vecteur: l'argument de la fonction est une liste Python\n",
    "v = np.array([1, 3, 2, 4])\n",
    "print(v)\n",
    "print(type(v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut alors visualiser ces données :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        this.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width);\n",
       "        canvas.attr('height', height);\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'];\n",
       "    var y0 = fig.canvas.height - msg['y0'];\n",
       "    var x1 = msg['x1'];\n",
       "    var y1 = fig.canvas.height - msg['y1'];\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x;\n",
       "    var y = canvas_pos.y;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overriden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/matplotlib/font_manager.py:273: UserWarning: Matplotlib is building the font cache using fc-list. This may take a moment.\n",
      "  warnings.warn('Matplotlib is building the font cache using fc-list. This may take a moment.')\n",
      "/usr/local/lib/python3.5/dist-packages/matplotlib/font_manager.py:273: UserWarning: Matplotlib is building the font cache using fc-list. This may take a moment.\n",
      "  warnings.warn('Matplotlib is building the font cache using fc-list. This may take a moment.')\n"
     ]
    }
   ],
   "source": [
    "v = np.array([1, 3, 2, 4])\n",
    "x = np.array([0, 1, 2, 3])\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(x,v, 'rv--', label='v(x)')\n",
    "plt.legend(loc='lower right')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('v')\n",
    "plt.title('Mon titre')\n",
    "plt.xlim([-1, 4])\n",
    "plt.ylim([0, 5])\n",
    "# plt.show()\n",
    "plt.savefig('toto.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut omettre `plt.show()`, lorsque la méthode `plt.ion()` a été appelée ; c'est le cas dans Spyder et pylab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour définir une matrice (array de dimension 2 pour numpy):\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "# une matrice: l'argument est une liste emboitée\n",
    "M = np.array([[1, 2], [3, 4]])\n",
    "print(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[0, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les objets `v` et `M` sont tous deux du type `ndarray` (fourni par `numpy`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.ndarray, numpy.ndarray)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(v), type(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`v` et `M` ne diffèrent que par leur taille, que l'on peut obtenir via la propriété `shape` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour obtenir le nombre d'éléments d'un *array* :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les *arrays* ont un type qu'on obtient via `dtype`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "int64\n"
     ]
    }
   ],
   "source": [
    "print(M)\n",
    "print(M.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les types doivent être respectés lors d'assignations à des *arrays*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for long() with base 10: 'hello'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-ca39caffd164>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mM\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"hello\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for long() with base 10: 'hello'"
     ]
    }
   ],
   "source": [
    "M[0, 0] = \"hello\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Attention !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 2 3]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2, 3])\n",
    "a[0] = 3.2\n",
    "print(a)\n",
    "a.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut définir le type de manière explicite en utilisant le mot clé `dtype` en argument: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.5  1.   1. ]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3], dtype=np.int64)\n",
    "b = np.array([2, 2, 3], dtype=np.int64)\n",
    "b = b.astype(float)\n",
    "print(a / b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.+0.j,  2.+0.j],\n",
       "       [ 3.+0.j,  4.+0.j]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.array([[1, 2], [3, 4]], dtype=complex)\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " * Autres types possibles avec `dtype` : `int`, `float`, `complex`, `bool`, `object`, etc.\n",
    "\n",
    " * On peut aussi spécifier la précision en bits: `int64`, `int16`, `float128`, `complex128`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EXERCICE\n",
    "\n",
    "* Créer un simple tableau à 2 dimensions (contenant les éléments que vous voulez).  \n",
    "* Utiliser les fonctions `len()`, `np.shape()` sur votre tableau. Comment sont elles reliées? comment est ce relié à l'attribut `ndim`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "A = np.array([[2, 3, 4, 5], [3, 5, 6, 6], [2, 4, 5, 9]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "(3, 4)\n",
      "2\n",
      "int64\n"
     ]
    }
   ],
   "source": [
    "print(len(A))\n",
    "print(A.shape)\n",
    "print(A.ndim)\n",
    "print(A.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Utilisation de fonction de génération d'*arrays*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### arange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a range\n",
    "x = np.arange(0, 10, 2) # arguments: start, stop, step\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ -1.00000000e+00,  -9.00000000e-01,  -8.00000000e-01,\n",
       "        -7.00000000e-01,  -6.00000000e-01,  -5.00000000e-01,\n",
       "        -4.00000000e-01,  -3.00000000e-01,  -2.00000000e-01,\n",
       "        -1.00000000e-01,  -2.22044605e-16,   1.00000000e-01,\n",
       "         2.00000000e-01,   3.00000000e-01,   4.00000000e-01,\n",
       "         5.00000000e-01,   6.00000000e-01,   7.00000000e-01,\n",
       "         8.00000000e-01,   9.00000000e-01])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(-1, 1, 0.1)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### linspace and logspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0.        ,   0.41666667,   0.83333333,   1.25      ,\n",
       "         1.66666667,   2.08333333,   2.5       ,   2.91666667,\n",
       "         3.33333333,   3.75      ,   4.16666667,   4.58333333,\n",
       "         5.        ,   5.41666667,   5.83333333,   6.25      ,\n",
       "         6.66666667,   7.08333333,   7.5       ,   7.91666667,\n",
       "         8.33333333,   8.75      ,   9.16666667,   9.58333333,  10.        ])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# avec linspace, le début et la fin SONT inclus\n",
    "np.linspace(0, 10, 25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0.,   1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 10, 11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fcba4ccf7d0>]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX8AAAEACAYAAABbMHZzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nECLI/wcr2HGJxHE/eAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fcba4d74a50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "xx = np.linspace(-10, 10, 100)\n",
    "plt.plot(xx, np.sin(xx))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  1.00000000e+00   2.71828183e+00   7.38905610e+00   2.00855369e+01\n",
      "   5.45981500e+01   1.48413159e+02   4.03428793e+02   1.09663316e+03\n",
      "   2.98095799e+03   8.10308393e+03]\n"
     ]
    }
   ],
   "source": [
    "print(np.logspace(0, 9, 10, base=np.e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.00000000e+00,   2.71828183e+00,   7.38905610e+00,\n",
       "         2.00855369e+01,   5.45981500e+01,   1.48413159e+02,\n",
       "         4.03428793e+02,   1.09663316e+03,   2.98095799e+03,\n",
       "         8.10308393e+03])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.e ** np.linspace(0, 9, 10) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Données aléatoires\n",
    "\n",
    "Le module numpy.random peut être utilisé pour les données aléatoires."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tirage uniforme dans [0, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.63240554,  0.3647385 ,  0.75110645,  0.00231932,  0.03433674],\n",
       "       [ 0.9886849 ,  0.68643617,  0.94102738,  0.93197679,  0.4420178 ],\n",
       "       [ 0.94908858,  0.37199717,  0.01181209,  0.07262914,  0.01399884],\n",
       "       [ 0.62131553,  0.18852194,  0.88404436,  0.86107931,  0.7013115 ],\n",
       "       [ 0.79865199,  0.1620585 ,  0.90430306,  0.11433657,  0.85577848]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.rand(5, 5)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tirage suivant une loi normale standard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.92888783,  1.0304577 , -1.16431491, -0.04669933, -0.38078249],\n",
       "       [ 0.55034022, -1.35508458,  0.59333405,  1.89872729,  0.03129873],\n",
       "       [ 0.1313723 , -1.38708298, -0.22298886, -0.86344356,  0.58986267],\n",
       "       [-0.67185757,  0.61634075,  0.30791581, -0.7470249 , -0.04666827],\n",
       "       [-0.79571638,  1.89607563, -1.73119961,  3.15087355,  1.37435913]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randn(5, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Affichage de l'histogramme des tirages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEACAYAAABI5zaHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAFt5JREFUeJzt3X+QXeV93/H3BxQodmIF7FjrStiyCWBKGgvaIfK4rS8h\nHiOcQSTjUNymRJh06JjEtM64AcettplkxjDj2KaeVtPYYYQnGPwzKCkxPwZuM5kxsluQjfmppIMs\nZGvdxlZScMdD4Ns/7ll1veyPe6V79949+37N3Nlzzz3n3O9Kez777HPPeZ5UFZKkdjlh3AVIkobP\ncJekFjLcJamFDHdJaiHDXZJayHCXpBbqK9yTXJfkkebx3mbdqUnuSfJkkruTrJ+z/c1J9ifZl2TL\nqIqXJC1s2XBPci5wNfAPgS3Azyc5A7geuK+qzgbuB25ott8GnFFVZwLXALtGVLskaRH9tNzPAfZW\n1Q+q6gXgz4BfBC4Fdjfb7Aa2N8vbgVsBqmovsD7JhqFWLUlaUj/h/g3gHzfdMC8DLgFOBzZU1QxA\nVR0GZgN8I3Bwzv6HmnWSpBWybrkNquqJJDcC9wLPAg8DLyy06ZBrkyQdo2XDHaCqbgFuAUjyu/Ra\n5jNJNlTVTJIp4DvN5ofotexnbWrW/ZAk/jKQpGNQVVlum36vlvmJ5utrgV8AbgP2ADuaTXYAdzbL\ne4Arm+23Akdmu28WKHCiHjt37hx7Dauhpkmty5qsaS3U1a++Wu7A55OcBjwPvKeq/qbpqvlMkncD\nB4DLm8C+K8klSf4CeA64qu9qJElD0W+3zD9ZYN13gZ9bZPtfO866JEnHwTtU5+h0OuMu4SUmsSaY\nzLqsqT/W1L9JrasfGaQPZ6hvnNS43luSVqsk1LA+UJUkrS6GuyS1kOEuSS1kuEtSCxnuktRChrsk\ntZDhLkktZLhLUgsZ7pLUQoa7dIympjaTZMHH1NTmcZenNc7hB6RjlITF56jJQMOzSv1y+AFJWsMM\nd0lqIcNdklqo32n2/k2SbyT5epI/THJSks1JHkzyVJJPJ1nXbHtSktuT7E/y5WZqPknSClo23JP8\nXeDXgfOr6qfpzd70LuBG4MNVdRZwBLi62eVq4LtVdSbwUeCmURQuSVpcv90yJwIvb1rnpwDfAi4E\nPt+8vhu4rFne3jwH+Bxw0XBKlST1a9lwr6pvAR8GvgkcAv4aeAg4UlUvNps9A2xsljcCB5t9XwCO\nNJNrS5JWyLITZCf5cXqt8dfRC/bPAhcP8B6LXo85PT19dLnT6azq+QolaRS63S7dbnfg/Za9iSnJ\nO4G3V9W/bJ7/C+DNwDuBqap6MclWYGdVbUvypWZ5b5ITgW9X1asXOK43MWlV8yYmjcMwb2L6JrA1\nyd9J76f5IuBR4AHgl5ptfgW4s1ne0zynef3+QQqXJB2/voYfSLITuAJ4HngY+FVgE3A7cGqz7per\n6vkkJwOfAs4D/gq4oqqeXuCYtty1qtly1zj023J3bBnpGBnuGgfHlpGkNcxwl6QWMtylkTh50bHe\nHe9dK8E+d+kYLdfnvvhrvdf9+dexsM9dktYww12SWshwl8Zi8T55++M1DPa5S8foePvcvUZex8I+\nd0lawwx3SWohw12SWshwl6QWMtwlqYUMd0lqIcNdklrIcJekFlo23JOcleThJA81X/86yXuTnJrk\nniRPJrk7yfo5+9ycZH+SfUm2jPZbkCTNt2y4V9VTVXVeVZ0P/APgOeCLwPXAfVV1Nr15Um8ASLIN\nOKOqzgSuAXaNqnhJ0sIG7Zb5OeAvq+ogsB3Y3azf3Tyn+XorQFXtBdYn2TCEWiVJfRo03P8pcFuz\nvKGqZgCq6jAwG+AbgYNz9jnUrJNWlampzUtOuCFNsnX9bpjkR4BLgd9sVs0f2WjgkY6mp6ePLnc6\nHTqdzqCHkEZmZuYAyw/+JY1Wt9ul2+0OvF/fo0ImuRR4T1Vd3Dx/HOhU1UySKeCBqjonya5m+Y5m\nuyeAt8628uccz1EhNdGWHvURlhvZ0VEhNQqjGBXyXcCn5zzfA+xolncAd85Zf2VTxFbgyPxglySN\nVl8t9yQvAw4Ab6iq/9OsOw34DHB689rlVXWkee3jwMX0rqy5qqoeWuCYttw10Wy5axL123J3sg5p\nEYa7JpGTdUirllPw6fjZcpcWMc6Wu616LcaWuyStYYa7JLWQ4a41bam7UKXVzD53rWlL96vb567J\nY5+7JK1hhrsktZDhLkktZLhLUgsZ7pLUQoa7JLWQ4S5JLWS4S1ILGe7SqrL4iJGOGqm5vENVa9pq\nvEN1ueN6XrXbUO9QTbI+yWeTPJ7k0SQ/k+TUJPckeTLJ3UnWz9n+5iT7k+xLsuV4vhFJ0uD67Zb5\nGHBXVZ0DvAl4ArgeuK+qzgbuB24ASLINOKOqzgSuAXYNvWpJ0pKW7ZZJ8grg4ao6Y976J4C3VtVM\nkinggao6J8muZvmOZrvHgc78SbLtltEksFtGq80wu2VeD/zvJLckeSjJf2kmzN4wG9hVdRjY0Gy/\nETg4Z/9DzTpJ0gpZ1+c25wPXVtV/T/IRel0y85sHAzcXpqenjy53Oh06nc6gh5CWNDW1mZmZA+Mu\nQzpm3W6Xbrc78H79dMtsAL5cVW9onv8jeuF+Bk13yzLdMke7b+Yd124ZjdxkzoN6PPvaLbPWDa1b\npgnlg0nOalZdBDwK7AF2NOt2AHc2y3uAK5sitgJH5ge7JGm0+rrOPcmbgE8APwL8T+Aq4ETgM8Dp\nwAHg8qo60mz/ceBi4Dngqqp6aIFj2nLXyNlyV9v023L3Jia1muGutnGaPUlawwx3qVUWH3vGcWfW\nFrtl1GprsVtmqX0951Y/u2UkaQ0z3CWphQx3SWohw12SWshwl6QWMtwlqYUMd0lqIcNdklrIcJek\nFjLcJamFDHdJaiHDXZJaqK9wT/J0kq8leTjJV5p1pya5J8mTSe5Osn7O9jcn2Z9kX5ItoypekrSw\nflvuL9KbL/W8qrqgWXc9cF9VnQ3cD9wAkGQbcEZVnQlcA+wacs2SpGX0G+5ZYNvtwO5meXfzfHb9\nrQBVtRdY30yyLUlaIf2GewF3J/lqkl9t1m2Ynfi6qg4DswG+ETg4Z99DzTpJ0gpZ1+d2b6mqbyf5\nCeCeJE/y0hkBnAVAkiZEX+FeVd9uvv6vJH8EXADMJNlQVTNJpoDvNJsfAk6fs/umZt1LTE9PH13u\ndDp0Op1B65ekVut2u3S73YH3W3aavSQvA06oqmeTvBy4B/gPwEXAd6vqxiTXAz9eVdcnuQS4tqre\nkWQr8NGq2rrAcZ1mT0MxNbWZmZkDS2wxaVPlHc++TrO31vU7zV4/4f564Iv0fmLWAX9YVR9Kchrw\nGXqt9APA5VV1pNnn48DFwHPAVVX10ALHNdw1FEvPkzqJAX08+xrua93Qwn1UDHcNi+He/76ec6uf\nE2RLmudkkiz6mJraPO4CNUS23LXq2XIf3r6ek5PPlrskrWGGuyS1kOEuSS1kuEtSCxnuktRChrsk\ntZDhLkktZLhLUgsZ7loVpqY2L3pnpaSX8g5VrQrHfhfqJN5lejz7eofqWucdqpK0hhnuktRChrsk\ntZDhLkkt1He4JzkhyUNJ9jTPNyd5MMlTST6dZF2z/qQktyfZn+TLSV47quIlSQsbpOV+HfDYnOc3\nAh+uqrOAI8DVzfqr6c2teibwUeCmYRQqSepfX+GeZBNwCfCJOat/Fvh8s7wbuKxZ3t48B/gcvYm0\nJUkrqN+W+0eA99NcJJvklcD3qurF5vVngI3N8kbgIEBVvQAcaSbTliStkGXDPck7gJmq2kfvLoij\nL/X5Ht5CKEkrbF0f27wFuDTJJcApwI8BHwPWJzmhab1vAg412x8CTge+leRE4BVV9d2FDjw9PX10\nudPp0Ol0jvHbkHT8Tl50OIcNG17H4cNPr2w5AqDb7dLtdgfeb6DhB5K8FfiNqro0yR3AF6rqjiT/\nGfhaVe1K8h7gp6rqPUmuAC6rqisWOJbDD6hvDj8w/po8XyfDSgw/cD3wviRPAacBn2zWfxJ4VZL9\nwL9utpMkrSAHDtOqYMt9/DV5vk4GBw6TpDXMcJekFjLcJamFDHdJaiHDXZJayHCXpBYy3CWphQx3\nSWohw12SWshwl6QWMtwlqYUMd0lqIcNdklrIcJekFjLcJamFDHdJaqF+Jsg+OcneJA8neSTJzmb9\n5iQPJnkqyaeTrGvWn5Tk9iT7k3w5yWtH/U1Ikn7YsuFeVT8ALqyq84AtwLYkPwPcCHy4qs4CjgBX\nN7tcDXy3qs4EPgrcNJLK1SpTU5tJsuhD0mD66papqu83iycD6+jNxXUh8Plm/W7gsmZ5e/Mc4HPA\nRUOpVK02M3OA3o/VYg9Jg+gr3JOckORh4DBwL/CXwJGqerHZ5BlgY7O8ETgIUFUvAEeSnDbUqiVJ\nS1rXz0ZNiJ+X5BXAF4E3DvAei/5NPT09fXS50+nQ6XQGOKwktV+326Xb7Q68Xwad0TzJvwP+L/Bv\ngamqejHJVmBnVW1L8qVmeW+SE4FvV9WrFzhOOZu6ZvX61Zf6eVjq9WN9bTXuO76aPF8nQxKqatkP\novq5WuZVSdY3y6cAbwMeAx4AfqnZ7FeAO5vlPc1zmtfvH6x0SdLxWrblnuTv0/uA9ITmcUdV/W6S\n1wO3A6cCDwO/XFXPJzkZ+BRwHvBXwBVV9fQCx7XlrqNsuY/7uMvv6/k6GfptuQ/cLTMshrvmMtzH\nfdzl9/V8nQxD65aRJK0+hrsktZDhLqkPJy969/DU1OZxF6cF2OeuiWCf+7iPe3w1eS6vHPvcJWkN\nM9wlqYUMd0lqIcNdK2apYX0lDZcfqGrFLP2h6Vr6APJ49p3MmjyXV44fqErSGma4S1ILGe6S1EKG\nuyS1kOEuSS1kuEtSCxnuktRC/UyztynJ/UkeTfJIkvc2609Nck+SJ5PcPTsVX/PazUn2J9mXZMso\nvwFJ0kv103L/W+B9VXUu8Gbg2iRvBK4H7quqs+nNk3oDQJJtwBlVdSZwDbBrJJVLkha1bLhX1eGq\n2tcsPws8DmwCttObW5Xm6/ZmeTtwa7P9XmB9kg1DrluStISB+tyTbAa2AA8CG6pqBnq/AIDZAN8I\nHJyz26FmnaRWWnwiDyfzGJ91/W6Y5EeBzwHXVdWzSeYPJjHw4BLT09NHlzudDp1OZ9BDSBq7H7DU\n6T8z48Bwx6Pb7dLtdgfer6+Bw5KsA/4E+NOq+liz7nGgU1UzSaaAB6rqnCS7muU7mu2eAN4628qf\nc0wHDltjHDhsGPuuzpo814dn2AOH/QHw2GywN/YAO5rlHcCdc9Zf2RSxFTgyP9glSaO1bMs9yVuA\nPwMeoffruYAPAF8BPgOcDhwALq+qI80+HwcuBp4DrqqqhxY4ri33NcaW+zD2XZ01ea4PT78td8dz\n14ox3Iex7+qsyXN9eBzPXZLWMMNdklrIcNfQLDVHqvOkSivLPncNzdJ96jCp/cGra9/VWZPn+vDY\n5y5Ja5jhLkktZLhLUgsZ7pJGbPGBxRxUbHT6HjhMko7N4gOLOajY6Nhyl6QWMtwlqYUMd0lqIcNd\nA1nqLlRJk8M7VDWQ8YzseDz7TmJNx7Nv+2oyBwbjHaqStIYZ7pLUQsuGe5JPJplJ8vU5605Nck+S\nJ5PcnWT9nNduTrI/yb4kW0ZVuCRpcf203G8B3j5v3fXAfVV1NnA/cANAkm3AGVV1JnANsGuItUqS\n+rRsuFfVnwPfm7d6O7C7Wd7dPJ9df2uz315gfZINwylVktSvY+1zf3VVzQBU1WFgNsA3AgfnbHeo\nWSdJC1h83BnHnjk+wxpb5piuZZqenj663Ol06HQ6QypH0uqw+Lgz4NgzAN1ul263O/B+fV3nnuR1\nwB9X1U83zx8HOlU1k2QKeKCqzkmyq1m+o9nuCeCts638ecf0OvdVyOvcx73v2qvJnPhhw77OPc1j\n1h5gR7O8A7hzzvormwK2AkcWCnZJ0mgt2y2T5DagA7wyyTeBncCHgM8meTdwALgcoKruSnJJkr8A\nngOuGlXhkqTFOfyABmK3zLj3XXs1mRM/zOEHJGkNM9wlqYUMd72Ew/pKq5997nqJY+9XX3v9wX4/\no6/JnPhh9rlLaoHF72D17tWlDesOVUkagcXvYPXu1aXZcpekFjLcJamFDHdJaiHDvaWWupzxxBNf\nvuQwq9Lq4IetS/FSyJYazzABa+8yPb+fya2prfnipZCStIYZ7pLUQoa7JLWQ4S6phZybdSThnuTi\nJE8keSrJb47iPSRpcbN3ti78mJk5MMbaVsbQwz3JCcDHgbcD5wLvSvLGYb/PKBzLJLSjtlhNS13q\nuDKXMy5c13h1x13AArrjLmAB3XEXsIDuCr9ff5dRTmIm9GsULfcLgP1VdaCqngduB7aP4H2GbtL+\nI6emNnPhhRcu+APYa3ks3jIZve4KvMeguuMuYAHdcRewgO64C1hAd4Xfb/GW/czM4aPn2ULn32rp\n0hlFuG8EDs55/kyzbk06npuJegG+k/GEt7RWzQ3+l55/q6VLpzUfqH7hC19YMihf85pNI3vvpQJ8\nqRb2iy9+f9HXDHBp9Vmuu3QlW/1Dv0M1yVZguqoubp5fD1RV3ThvO9NLko5BP3eojiLcTwSeBC4C\nvg18BXhXVT0+1DeSJC1q6JN1VNULSX4NuIdet88nDXZJWlljGzhMkjQ6Y/1ANcnOJM8keah5XDzO\neuZK8htJXkxy2gTU8ttJvpbk4SRfSjI1ATXdlOTxJPuSfD7JK8ZdE0CSdyb5RpIXkpw/5lom6ma+\nJJ9MMpPk6+OuZVaSTUnuT/JokkeSvHcCajo5yd7mfHskyc5x1zQryQlNVu5ZbttJuFrm96rq/Obx\npXEXA70fOOBtwKRc83RTVb2pqs4D/iu967PG7R7g3KraAuwHbhhzPbMeAX4B+G/jLGJCb+a7paln\nkvwt8L6qOhd4M3DtuP+dquoHwIXN+bYF2JbkgnHWNMd1wGP9bDgJ4T6Js0N8BHj/uIuYVVXPznn6\ncuDFcdUyq6ruq6rZOh4ERnet6QCq6smq2s/4f64m7ma+qvpz4HvjrGG+qjpcVfua5WeBx5mA+2Kq\n6vvN4sn0Ppsce/910+i8BPhEP9tPQrhf2/xp/4kk68ddTJJLgYNV9ci4a5krye8k+Sbwz4B/P+56\n5nk38KfjLmLCeDPfgJJsptdS3jveSo52fzwMHAburaqvjrsm/n+js69fNEO/Wma+JPcCG+auolfc\nbwH/CfjtqqokvwP8HnD1GGv6IPABel0yc18buaX+narqj6vqg8AHm77bXwemx11Ts81vAc9X1W2j\nrmeQurS6JPlR4HPAdfP+Uh2L5q/S85rPkv4oyd+rqr66Q0YhyTuAmaral6RDH7k08nCvqrctvxUA\nvw+syIm5WE1JfgrYDHwtvdG3NgH/I8kFVfWdcdS0gNuAu1iBcF+upiQ76P2Z+LOjrmWuAf6txukQ\n8No5zzc16zRPknX0gv1TVXXnuOuZq6r+JskDwMX02dc9Im8BLk1yCXAK8GNJbq2qKxfbYdxXy8y9\n6uMXgW+MqxaAqvpGVU1V1Ruq6vX0/pQ+b9TBvpwkPznn6WX0+iXHqrmy6f3Apc0HUJNonP3uXwV+\nMsnrkpwEXAEse4XDCgjj/zxivj8AHquqj427EIAkr5rtIk5yCr2/5J8YZ01V9YGqem1VvYHez9L9\nSwU7rEDLfRk3JdlC7wPCp4FrxlvOSxSTcSJ8KMlZ9P6dDgD/asz1APxH4CTg3t4fOTxYVe8Zb0mQ\n5DJ6tb0K+JMk+6pq20rXMYk38yW5DegAr2w+v9lZVbeMuaa3AP8ceKTp4y7gA2O+cu41wO7miqcT\ngDuq6q4x1nNMvIlJklpoEq6WkSQNmeEuSS1kuEtSCxnuktRChrsktZDhLkktZLhLUgsZ7pLUQv8P\nT0hjGqI+cEwAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fcba4d74650>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a = np.random.randn(10000)\n",
    "hh = plt.hist(a, 40)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### diag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0],\n",
       "       [0, 2, 0],\n",
       "       [0, 0, 3]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# une matrice diagonale\n",
    "np.diag([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 0, 0],\n",
       "       [0, 0, 2, 0],\n",
       "       [0, 0, 0, 3],\n",
       "       [0, 0, 0, 0]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# diagonale avec décalage par rapport à la diagonale principale\n",
    "np.diag([1, 2, 3], k=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### zeros et ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3,), dtype=int)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.],\n",
       "       [ 1.,  1.,  1.]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 0 0]\n",
      "[[0 0 0]]\n",
      "[[0]\n",
      " [0]\n",
      " [0]]\n"
     ]
    }
   ],
   "source": [
    "print(np.zeros((3,), dtype=int))\n",
    "print(np.zeros((1, 3), dtype=int))\n",
    "print(np.zeros((3, 1), dtype=int))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Fichiers d'E/S"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fichiers séparés par des virgules (CSV)\n",
    "\n",
    "Un format fichier classique est le format CSV (comma-separated values), ou bien TSV (tab-separated values). Pour lire de tels fichiers, on peut utiliser `numpy.genfromtxt`. Par exemple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1, 2, 3, 4\r\n",
      "5, 6, 7, 8\r\n",
      "9, 10, 11, 12\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "!cat 2_numpy_data.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1.,   2.,   3.,   4.],\n",
       "       [  5.,   6.,   7.,   8.],\n",
       "       [  9.,  10.,  11.,  12.]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.genfromtxt('2_numpy_data.csv', delimiter=',')\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi utiliser une fonction très pratique de [pandas](http://pandas.pydata.org): `pandas.read_csv`. Les données sont alors un [pandas Dataframe](http://pandas.pydata.org/pandas-docs/stable/api.html#dataframe) que l'on peut convertir en numpy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv('2_numpy_data.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pandas.core.frame.DataFrame"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dn = np.array(df)\n",
    "type(dn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5,  6,  7,  8],\n",
       "       [ 9, 10, 11, 12]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A l'aide de `numpy.savetxt` on peut enregistrer un *array* `numpy` dans un fichier txt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.95002593,  0.72664824,  0.30648333],\n",
       "       [ 0.70091535,  0.45909001,  0.87398896],\n",
       "       [ 0.15629332,  0.27164733,  0.48745435]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = random.rand(3,3)\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "np.savetxt(\"random-matrix.txt\", M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9.500259308602102548e-01 7.266482437899983715e-01 3.064833254259071715e-01\r\n",
      "7.009153535793422041e-01 4.590900090233598352e-01 8.739889574233675740e-01\r\n",
      "1.562933191365947216e-01 2.716473283446109166e-01 4.874543548502691115e-01\r\n"
     ]
    }
   ],
   "source": [
    "!cat random-matrix.txt\n",
    "#!type random-matrix.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.95003,0.72665,0.30648\r\n",
      "0.70092,0.45909,0.87399\r\n",
      "0.15629,0.27165,0.48745\r\n"
     ]
    }
   ],
   "source": [
    "np.savetxt(\"random-matrix.csv\", M, fmt='%.5f', delimiter=',') # fmt spécifie le format\n",
    "\n",
    "!cat random-matrix.csv\n",
    "#!type random-matrix.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici aussi, on peut utiliser une fonction très pratique de pandas: `to_csv`, mais il faudrait convertir le tableau en pandas DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "df = pd.DataFrame(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.950026</td>\n",
       "      <td>0.726648</td>\n",
       "      <td>0.306483</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.700915</td>\n",
       "      <td>0.459090</td>\n",
       "      <td>0.873989</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.156293</td>\n",
       "      <td>0.271647</td>\n",
       "      <td>0.487454</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0         1         2\n",
       "0  0.950026  0.726648  0.306483\n",
       "1  0.700915  0.459090  0.873989\n",
       "2  0.156293  0.271647  0.487454"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "df.to_csv(\"random_matrix_pd.csv\", index=False, header=False, float_format='%.5f')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.95003,0.72665,0.30648\r\n",
      "0.70092,0.45909,0.87399\r\n",
      "0.15629,0.27165,0.48745\r\n"
     ]
    }
   ],
   "source": [
    "!cat random_matrix_pd.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Manipulation d'*arrays*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[[ 0.84545627  0.96535677  0.67241722  0.45286897]\n",
      " [ 0.85997758  0.99879739  0.77908149  0.85394982]\n",
      " [ 0.41792985  0.19131733  0.80087151  0.68905348]]\n"
     ]
    }
   ],
   "source": [
    "v = np.arange(10)\n",
    "print(v)\n",
    "M = np.random.rand(3, 4)\n",
    "print(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "v est un vecteur, il n'a qu'une dimension -> un seul indice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "M est une matrice, ou un array à 2 dimensions -> deux indices "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9987973880375437"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Contenu complet :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.84545627,  0.96535677,  0.67241722,  0.45286897],\n",
       "       [ 0.85997758,  0.99879739,  0.77908149,  0.85394982],\n",
       "       [ 0.41792985,  0.19131733,  0.80087151,  0.68905348]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La deuxième ligne :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.85997758,  0.99879739,  0.77908149,  0.85394982])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi utiliser `:` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.85997758,  0.99879739,  0.77908149,  0.85394982])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1, :] # 2 ème ligne (indice 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.96535677,  0.99879739,  0.19131733])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[:, 1] # 2 ème colonne (indice 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4)\n",
      "((4,), (3,))\n"
     ]
    }
   ],
   "source": [
    "print(M.shape)\n",
    "print(M[1, :].shape, M[:, 1].shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut assigner des nouvelles valeurs à certaines cellules :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "M[0, 0] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  0.96535677,  0.67241722,  0.45286897],\n",
       "       [ 0.85997758,  0.99879739,  0.77908149,  0.85394982],\n",
       "       [ 0.41792985,  0.19131733,  0.80087151,  0.68905348]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# on peut aussi assigner des lignes ou des colonnes\n",
    "M[1, :] = -1\n",
    "# M[1,:] = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        ,  0.96535677,  0.67241722,  0.45286897],\n",
       "       [-1.        , -1.        , -1.        , -1.        ],\n",
       "       [ 0.41792985,  0.19131733,  0.80087151,  0.68905348]])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Slicing* ou accès par tranches\n",
    "\n",
    "*Slicing* fait référence à la syntaxe `M[start:stop:step]` pour extraire une partie d'un *array*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([1, 2, 3, 4, 5])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les tranches sont modifiables :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:3] = [-2, -3]\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut omettre n'importe lequel des argument dans `M[start:stop:step]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3,  4,  5])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::] # indices de début, fin, et pas avec leurs valeurs par défaut"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -3,  5])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[::2] # pas = 2, indices de début et de fin par défaut"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -2, -3])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:3] # les trois premiers éléments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[3:] # à partir de l'indice 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2]\n",
      " [ 3  4  5]\n",
      " [ 6  7  8]\n",
      " [ 9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "M = np.arange(12).reshape(4, 3)\n",
    "print(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut utiliser des indices négatifs :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "A = np.array([1, 2, 3, 4, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-1] # le dernier élément"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[-3:] # les 3 derniers éléments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le *slicing* fonctionne de façon similaire pour les *array* multi-dimensionnels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[n + m * 10 for n in range(5)] for m in range(5)])\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11, 12, 13],\n",
       "       [21, 22, 23],\n",
       "       [31, 32, 33]])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:4, 1:4]  # sous-tableau"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4],\n",
       "       [20, 22, 24],\n",
       "       [40, 42, 44]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sauts\n",
    "A[::2, ::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34],\n",
       "       [40, 41, 42, 43, 44]])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [30, 31, 32, 33, 34]])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[[0, 1, 3]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EXERCICE: le plateau d'échec\n",
    "\n",
    "Créez un tableau de zéros et le remplir pour obtenir un motif de plateau d'échec de dimension 8x8.\n",
    "<img src=\"checkerboard.svg\" width=300, height=300>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  0.,  1.,  0.,  1.,  0.,  1.,  0.],\n",
       "       [ 0.,  1.,  0.,  1.,  0.,  1.,  0.,  1.],\n",
       "       [ 1.,  0.,  1.,  0.,  1.,  0.,  1.,  0.],\n",
       "       [ 0.,  1.,  0.,  1.,  0.,  1.,  0.,  1.],\n",
       "       [ 1.,  0.,  1.,  0.,  1.,  0.,  1.,  0.],\n",
       "       [ 0.,  1.,  0.,  1.,  0.,  1.,  0.,  1.],\n",
       "       [ 1.,  0.,  1.,  0.,  1.,  0.,  1.,  0.],\n",
       "       [ 0.,  1.,  0.,  1.,  0.,  1.,  0.,  1.]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E = np.zeros((8, 8))\n",
    "E[0::2, 0::2] = 1\n",
    "E[1::2, 1::2] = 1\n",
    "E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 1, 0, 1, 0, 1, 0],\n",
       "       [0, 1, 0, 1, 0, 1, 0, 1],\n",
       "       [1, 0, 1, 0, 1, 0, 1, 0],\n",
       "       [0, 1, 0, 1, 0, 1, 0, 1],\n",
       "       [1, 0, 1, 0, 1, 0, 1, 0],\n",
       "       [0, 1, 0, 1, 0, 1, 0, 1],\n",
       "       [1, 0, 1, 0, 1, 0, 1, 0],\n",
       "       [0, 1, 0, 1, 0, 1, 0, 1]])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E = np.tile([[1, 0], [0, 1]], (4, 4))\n",
    "E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "np.tile?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexation avancée (*fancy indexing*)\n",
    "\n",
    "Lorsque qu'on utilise des listes ou des *array* pour définir des tranches : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n",
      "[[10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[n + m * 10 for n in range(5)] for m in range(5)])\n",
    "row_indices = [1, 2, 3]\n",
    "print(A)\n",
    "print(A[row_indices])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n"
     ]
    }
   ],
   "source": [
    "A[[1, 2]][:, [3, 4]] = 0  # ATTENTION !\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [10 11 12  0  0]\n",
      " [20 21 22  0  0]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n"
     ]
    }
   ],
   "source": [
    "A[np.ix_([1, 2], [3, 4])] = 0\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut aussi utiliser des masques binaires :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = np.arange(5)\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 2]\n",
      "[0 2]\n"
     ]
    }
   ],
   "source": [
    "row_mask = np.array([True, False, True, False, False])\n",
    "print(B[row_mask])\n",
    "print(B[[0, 2]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# de façon équivalente\n",
    "row_mask = np.array([1, 0, 1, 0, 0], dtype=bool)\n",
    "B[row_mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ True  True False False False]\n",
      "[0 1]\n"
     ]
    }
   ],
   "source": [
    "# ou encore\n",
    "a = np.array([1, 2, 3, 4, 5])\n",
    "print(a < 3)\n",
    "print(B[a < 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [10 11 12  0  0]\n",
      " [20 21 22  0  0]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n",
      "[[ 0  1]\n",
      " [10 11]\n",
      " [20 21]\n",
      " [30 31]\n",
      " [40 41]]\n"
     ]
    }
   ],
   "source": [
    "print(A)\n",
    "print(A[:, a < 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EXERCICE\n",
    "\n",
    "En utilisant l'indexation avancée, sélectionnez au hasard avec répétition 10 éléments d'un tableau contenant 100 éléments tirés au hasard. \n",
    "(Astuce: np.random.randint(max_int, size=n) génère n nombres au hasard de 0 à max_int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[13 49 32 96 94 91 57 81 18 68]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 0.43158864,  0.29168867,  0.02041883,  0.82911931,  0.07722761,\n",
       "        0.61429739,  0.83639657,  0.15610273,  0.96411602,  0.05654221])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r = np.random.rand(100)\n",
    "ind = np.random.randint(100, size=10)\n",
    "print(ind)\n",
    "r[ind]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extraction de données à partir d'*arrays* et création d'*arrays*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### where\n",
    "\n",
    "Un masque binaire peut être converti en indices de positions avec `where`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.   0.5  1.   1.5  2.   2.5  3.   3.5  4.   4.5  5.   5.5  6.   6.5  7.\n",
      "  7.5  8.   8.5  9.   9.5]\n",
      "[False False False False False False False False False False False  True\n",
      "  True  True  True False False False False False]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([11, 12, 13, 14]),)"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(0, 10, 0.5)\n",
    "print(x)\n",
    "mask = (x > 5) * (x < 7.5)\n",
    "print(mask)\n",
    "indices = np.where(mask)\n",
    "indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5.5,  6. ,  6.5,  7. ])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[indices] # équivalent à x[mask]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### diag\n",
    "\n",
    "Extraire la diagonale ou une sous-diagonale d'un *array* :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [10 11 12  0  0]\n",
      " [20 21 22  0  0]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 0, 11, 22, 33, 44])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(A)\n",
    "np.diag(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 21, 32, 43])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(A, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Algèbre linéaire\n",
    "\n",
    "La performance des programmes écrit en Python/Numpy dépend de la capacité à vectoriser les calculs (les écrire comme des opérations sur des vecteurs/matrices) en évitant au maximum les boucles `for/while`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Opérations scalaires\n",
    "\n",
    "On peut effectuer les opérations arithmétiques habituelles pour multiplier, additionner, soustraire et diviser des *arrays* avec/par des scalaires :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "v1 = np.arange(5)\n",
    "print(v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXUAAAEACAYAAABMEua6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nGrGibowxacSKujHGpBEr6sYYk0b+PzQ1dGbezPYBAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fcba0effad0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(v1 ** 2,'g--', label='$y = x^2$')\n",
    "plt.legend(loc=0)\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(sqrt(v1), 'r*-', label='$y = \\sqrt{x}$')\n",
    "plt.legend(loc=2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[n + m * 10 for n in range(5)] for m in range(5)])\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  2  4  6  8]\n",
      " [20 22 24 26 28]\n",
      " [40 42 44 46 48]\n",
      " [60 62 64 66 68]\n",
      " [80 82 84 86 88]]\n"
     ]
    }
   ],
   "source": [
    "print(A * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  3  4  5  6]\n",
      " [12 13 14 15 16]\n",
      " [22 23 24 25 26]\n",
      " [32 33 34 35 36]\n",
      " [42 43 44 45 46]]\n"
     ]
    }
   ],
   "source": [
    "print(A + 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Opérations terme-à-terme sur les *arrays*\n",
    "\n",
    "Les opérations par défaut sont des opérations **terme-à-terme** :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[n + m * 10 for n in range(5)] for m in range(5)])\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   0,    1,    4,    9,   16],\n",
       "       [ 100,  121,  144,  169,  196],\n",
       "       [ 400,  441,  484,  529,  576],\n",
       "       [ 900,  961, 1024, 1089, 1156],\n",
       "       [1600, 1681, 1764, 1849, 1936]])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * A # multiplication terme-à-terme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  5, 11, 16, 22],\n",
       "       [ 5, 11, 16, 22, 27],\n",
       "       [11, 16, 22, 27, 33],\n",
       "       [16, 22, 27, 33, 38],\n",
       "       [22, 27, 33, 38, 44]])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(A + A.T) / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n",
      "[ 0  1  4  9 16]\n"
     ]
    }
   ],
   "source": [
    "print v1\n",
    "print v1 * v1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En multipliant des *arrays* de tailles compatibles, on obtient des multiplications terme-à-terme par ligne :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (5,))"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.shape, v1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n",
      "[0 1 2 3 4]\n",
      "[[  0   1   4   9  16]\n",
      " [  0  11  24  39  56]\n",
      " [  0  21  44  69  96]\n",
      " [  0  31  64  99 136]\n",
      " [  0  41  84 129 176]]\n"
     ]
    }
   ],
   "source": [
    "print(A)\n",
    "print(v1)\n",
    "print(A * v1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De façon plus générale, on peut faire des opérations sur des tableaux de différentes tailles. Dans certains cas, NumPy peut transformer les tableaux pour qu'ils aient la même taille, cette conversion s'appelle le **\"Broadcasting\"**.\n",
    "<img src=\"numpy_broadcasting.png\" width=600>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([0, 1, 2, 3]), (4,))\n",
      "(array([0, 1, 2, 3, 4]), (5,))\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (4,) (5,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-108-214c8fb85dfa>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;32mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;32mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0ma\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (4,) (5,) "
     ]
    }
   ],
   "source": [
    "a = np.arange(4)\n",
    "b = np.arange(5)\n",
    "print(a, a.shape)\n",
    "print(b, b.shape)\n",
    "a * b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((4, 1), (1, 5), (4, 5))\n"
     ]
    }
   ],
   "source": [
    "b = b[:, np.newaxis].T\n",
    "a = a[:, np.newaxis]\n",
    "c = a * b\n",
    "print(a.shape, b.shape, c.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il existe une règle pour savoir dans quel cas on peut faire du \"broadcasting\":\n",
    "**Dans une opération, la taille des axex des deux tableaux doit être soit la même, soit une des deux doit être 1**.\n",
    "Dans la figure ci-dessus, cette règle est respectée:\n",
    "```\n",
    "a:      4 x 3   \n",
    "b:      4 x 3\n",
    "result: 4 x 3\n",
    "\n",
    "a:      4 x 3\n",
    "b:          3\n",
    "result: 4 x 3\n",
    "\n",
    "a:      4 x 1\n",
    "b:          3\n",
    "result: 4 x 3\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que donnerait les deux cas suivant?\n",
    "\n",
    "```\n",
    "Image  (3d array): 256 x 256 x 3\n",
    "Scale  (1d array):             3\n",
    "Result (3d array): \n",
    "\n",
    "A      (4d array):  8 x 1 x 6 x 1\n",
    "B      (3d array):      7 x 1 x 5\n",
    "Result (4d array):  \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EXERCICE:\n",
    "\n",
    "Sans utiliser de boucles (`for/while`) :\n",
    "\n",
    " * Créer une matrice (5x6) aléatoire\n",
    " * Remplacer une colonne sur deux par sa valeur moins le double de la colonne suivante\n",
    " * Remplacer les valeurs négatives par 0 en utilisant un masque binaire\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.53774259,  0.60348793,  0.78278186,  0.91448936,  0.41535244,\n",
       "         0.08619515],\n",
       "       [ 0.42095431,  0.26497632,  0.94171474,  0.67746094,  0.12019409,\n",
       "         0.82722855],\n",
       "       [ 0.76435291,  0.40741504,  0.08401732,  0.52897861,  0.46754469,\n",
       "         0.49519178],\n",
       "       [ 0.63357359,  0.6293344 ,  0.15837992,  0.33311209,  0.63927252,\n",
       "         0.01631527],\n",
       "       [ 0.45462769,  0.1563657 ,  0.22031721,  0.47801851,  0.86637709,\n",
       "         0.57759162]])"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = random.rand(5,6)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "A[:, ::2] = A[:, ::2] - 2 * A[:,1::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.66923326,  0.60348793, -1.04619686,  0.91448936,  0.24296215,\n",
       "         0.08619515],\n",
       "       [-0.10899833,  0.26497632, -0.41320713,  0.67746094, -1.53426302,\n",
       "         0.82722855],\n",
       "       [-0.05047717,  0.40741504, -0.97393991,  0.52897861, -0.52283886,\n",
       "         0.49519178],\n",
       "       [-0.62509522,  0.6293344 , -0.50784427,  0.33311209,  0.60664199,\n",
       "         0.01631527],\n",
       "       [ 0.14189629,  0.1563657 , -0.73571981,  0.47801851, -0.28880615,\n",
       "         0.57759162]])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "A[np.where(A < 0)] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.        ,  0.60348793,  0.        ,  0.91448936,  0.24296215,\n",
       "         0.08619515],\n",
       "       [ 0.        ,  0.26497632,  0.        ,  0.67746094,  0.        ,\n",
       "         0.82722855],\n",
       "       [ 0.        ,  0.40741504,  0.        ,  0.52897861,  0.        ,\n",
       "         0.49519178],\n",
       "       [ 0.        ,  0.6293344 ,  0.        ,  0.33311209,  0.60664199,\n",
       "         0.01631527],\n",
       "       [ 0.14189629,  0.1563657 ,  0.        ,  0.47801851,  0.        ,\n",
       "         0.57759162]])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Créez un tableau qui contient la somme de chaque élément de `x` avec chaque élément de `y`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = np.random.rand(3, 5)\n",
    "y = np.random.randint(10, size=8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 5, 8)\n"
     ]
    }
   ],
   "source": [
    "x = x[:, :, np.newaxis]\n",
    "z = x + y\n",
    "print(z.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algèbre matricielle\n",
    "\n",
    "Comment faire des multiplications de matrices ? Deux façons :\n",
    " \n",
    " * en utilisant les fonctions `dot`; (recommandé)\n",
    " * en utiliser le type `matrix`. (à éviter)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((5, 5), (5,))\n",
      "[[ 0  1  2  3  4]\n",
      " [10 11 12 13 14]\n",
      " [20 21 22 23 24]\n",
      " [30 31 32 33 34]\n",
      " [40 41 42 43 44]]\n",
      "[0 1 2 3 4]\n",
      "(<type 'numpy.ndarray'>, <type 'numpy.ndarray'>)\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[n + m * 10 for n in range(5)] for m in range(5)])\n",
    "v1 = np.arange(5)\n",
    "print(A.shape, v1.shape)\n",
    "print(A)\n",
    "print(v1)\n",
    "print(type(A), type(v1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 300  310  320  330  340]\n",
      " [1300 1360 1420 1480 1540]\n",
      " [2300 2410 2520 2630 2740]\n",
      " [3300 3460 3620 3780 3940]\n",
      " [4300 4510 4720 4930 5140]]\n",
      "[[   0    1    4    9   16]\n",
      " [ 100  121  144  169  196]\n",
      " [ 400  441  484  529  576]\n",
      " [ 900  961 1024 1089 1156]\n",
      " [1600 1681 1764 1849 1936]]\n"
     ]
    }
   ],
   "source": [
    "print(np.dot(A, A))  # multiplication matrice\n",
    "print(A * A)  # multiplication élément par élément"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 30, 130, 230, 330, 430])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.dot(v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(v1, v1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avec le type `matrix` de Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "M = np.matrix(A)\n",
    "v = np.matrix(v1).T # en faire un vecteur colonne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30],\n",
       "        [130],\n",
       "        [230],\n",
       "        [330],\n",
       "        [430]])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[30]])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# produit scalaire\n",
    "v.T * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30],\n",
       "        [131],\n",
       "        [232],\n",
       "        [333],\n",
       "        [434]])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# avec les objets matrices, c'est les opérations standards sur les matrices qui sont appliquées\n",
    "v + M * v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si les dimensions sont incompatibles on provoque des erreurs :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "v = np.matrix([1, 2, 3, 4, 5, 6]).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((5, 5), (6, 1))"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(M), np.shape(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-127-995fb48ad0cc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mM\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/usr/local/lib/python2.7/dist-packages/numpy/matrixlib/defmatrix.pyc\u001b[0m in \u001b[0;36m__mul__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m    341\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndarray\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    342\u001b[0m             \u001b[0;31m# This promotes 1-D vectors to row vectors\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 343\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0masmatrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    344\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0misscalar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'__rmul__'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    345\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)"
     ]
    }
   ],
   "source": [
    "M * v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voir également les fonctions : `inner`, `outer`, `cross`, `kron`, `tensordot`. Utiliser par exemple `help(kron)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transformations d'*arrays* ou de matrices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " * Plus haut `.T` a été utilisé pour transposer l'objet matrice `v`\n",
    " * On peut aussi utiliser la fonction `transpose`\n",
    "\n",
    "**Autres transformations :**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.+1.j,  0.+2.j],\n",
       "        [ 0.+3.j,  0.+4.j]])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = np.matrix([[1j, 2j], [3j, 4j]])\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.-1.j,  0.-2.j],\n",
       "        [ 0.-3.j,  0.-4.j]])"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.conjugate(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transposée conjuguée :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.-1.j,  0.-3.j],\n",
       "        [ 0.-2.j,  0.-4.j]])"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.H"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parties réelles et imaginaires :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 0.,  0.],\n",
       "        [ 0.,  0.]])"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.real(C) # same as: C.real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 1.,  2.],\n",
       "        [ 3.,  4.]])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.imag(C) # same as: C.imag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Argument et module :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.78539816,  1.10714872],\n",
       "       [ 1.24904577,  1.32581766]])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.angle(C + 1) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 1.,  2.],\n",
       "        [ 3.,  4.]])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.abs(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analyse de données\n",
    "\n",
    "Numpy propose des fonctions pour calculer certaines statistiques des données stockées dans des *arrays* :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11],\n",
       "       [ 9,  9,  9,  9],\n",
       "       [16, 17, 18, 19]])"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = arange(20).reshape((5, 4))\n",
    "data[3, :] = 9\n",
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 7.4  8.2  9.   9.8]\n"
     ]
    }
   ],
   "source": [
    "# np.mean(data)\n",
    "print(np.mean(data, axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.0"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# la moyenne de la troisième colonne\n",
    "np.mean(data[:, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### variance et écart type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(28.0, 5.2915026221291814)"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.var(data[:, 2]), np.std(data[:, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### min et max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[:, 2].min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[:, 2].max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[:, 2].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19440"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[:, 2].prod()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### sum, prod, et trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = np.arange(0, 10)\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Somme des éléments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou encore :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.sum()"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Produit des éléments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.prod(d + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Somme cumulée"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  3,  6, 10, 15, 21, 28, 36, 45])"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.cumsum(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Produit cumulé"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([      1,       2,       6,      24,     120,     720,    5040,\n",
       "         40320,  362880, 3628800])"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.cumprod(d + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trace (équivalent à diag(A).sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.trace(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculs aves données multi-dimensionnelles\n",
    "\n",
    "Pour appliquer `min`, `max`, etc., par lignes ou colonnes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.88030491,  0.26042839,  0.26811414,  0.53611442],\n",
       "       [ 0.45046151,  0.21391599,  0.17395625,  0.40527054],\n",
       "       [ 0.60092552,  0.79384373,  0.74293339,  0.26457557]])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = random.rand(3,4)\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.88030491391957288"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max global \n",
    "m.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.88030491,  0.79384373,  0.74293339,  0.53611442])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max dans chaque colonne\n",
    "m.max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.88030491,  0.45046151,  0.79384373])"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max dans chaque ligne\n",
    "m.max(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plusieurs autres méthodes des classes `array` et `matrix` acceptent l'argument (optional) `axis` keyword argument."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EXERCICE :\n",
    "\n",
    "Soustrayez de chaque colonne de `a` sa moyenne, puis faites de même avec les lignes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.random.rand(100, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b = a - np.mean(a, axis=0)\n",
    "b = b - np.mean(b, axis=1)[:,np.newaxis]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Copy\n",
    "\n",
    "Pour des raisons de performance Python ne copie pas automatiquement les objets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[0,  2], [ 3,  4]])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "B = A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# changer B affecte A\n",
    "B[0, 0] = 10\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 3,  4]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "B = A\n",
    "print(B is A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut avoir accès à l'adresse mémoire de l'élément avec:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50014304\n",
      "50014304\n"
     ]
    }
   ],
   "source": [
    "print(A.__array_interface__['data'][0])\n",
    "print(B.__array_interface__['data'][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour éviter ce comportement, on peut demander une *copie profonde* (*deep copy*) de `A` dans `B`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# B = np.copy(A)\n",
    "B = A.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-5  2]\n",
      " [ 3  4]]\n",
      "[[10  2]\n",
      " [ 3  4]]\n"
     ]
    }
   ],
   "source": [
    "# maintenant en modifiant B, A n'est plus affecté\n",
    "B[0, 0] = -5\n",
    "print(B)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50014304\n",
      "59944224\n"
     ]
    }
   ],
   "source": [
    "print(A.__array_interface__['data'][0])\n",
    "print(B.__array_interface__['data'][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Concaténer, répéter des *arrays*\n",
    "\n",
    "En utilisant les fonctions `repeat`, `tile`, `vstack`, `hstack`, et `concatenate`, on peut créer des vecteurs/matrices plus grandes à partir de vecteurs/matrices plus petites :\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### repeat et tile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 2], [3, 4]])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# répéter chaque élément 3 fois\n",
    "np.repeat(a, 3) # résultat 1-d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, 2, 2, 2],\n",
       "       [3, 3, 3, 4, 4, 4]])"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# on peut spécifier l'argument axis\n",
    "np.repeat(a, 3, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour répéter la matrice, il faut utiliser `tile`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 1, 2, 1, 2],\n",
       "       [3, 4, 3, 4, 3, 4]])"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# répéter la matrice 3 fois\n",
    "np.tile(a, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### concatenate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b = np.array([[5, 6]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((a, b), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((a, b.T), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### hstack et vstack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5],\n",
       "       [3, 4, 6]])"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hstack((a, b.T))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Itérer sur les éléments d'un *array*\n",
    "\n",
    " * Dans la mesure du possible, il faut éviter l'itération sur les éléments d'un *array* : c'est beaucoup plus lent que les opérations vectorisées\n",
    " * Mais il arrive que l'on n'ait pas le choix..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "v = np.arange(4)\n",
    "\n",
    "for element in v:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "row [1 2]\n",
      "1\n",
      "2\n",
      "row [3 4]\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "M = np.array([[1, 2], [3, 4]])\n",
    "\n",
    "for row in M:\n",
    "    print(\"row\", row)\n",
    "    \n",
    "    for element in row:\n",
    "        print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour obtenir les indices des éléments sur lesquels on itère (par exemple, pour pouvoir les modifier en même temps) on peut utiliser `enumerate` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "row_idx 0 row [1 2]\n",
      "col_idx 0 element 1\n",
      "col_idx 1 element 2\n",
      "row_idx 1 row [3 4]\n",
      "col_idx 0 element 3\n",
      "col_idx 1 element 4\n"
     ]
    }
   ],
   "source": [
    "for row_idx, row in enumerate(M):\n",
    "    print(\"row_idx\", row_idx, \"row\", row)\n",
    "    \n",
    "    for col_idx, element in enumerate(row):\n",
    "        print(\"col_idx\", col_idx, \"element\", element)\n",
    "       \n",
    "        # update the matrix M: square each element\n",
    "        M[row_idx, col_idx] = element ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# chaque élément de M a maintenant été élevé au carré\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Utilisation d'*arrays* dans des conditions\n",
    "\n",
    "Losqu'on s'intéresse à des conditions sur tout on une partie d'un *array*, on peut utiliser `any` ou `all` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4],\n",
       "       [ 9, 16]])"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "au moins un élément de M est plus grand que 5\n"
     ]
    }
   ],
   "source": [
    "if (M > 5).any():\n",
    "    print(\"au moins un élément de M est plus grand que 5\")\n",
    "else:\n",
    "    print(\"aucun élément de M n'est plus grand que 5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tous les éléments de M sont plus petits que 5\n"
     ]
    }
   ],
   "source": [
    "if (M > 5).all():\n",
    "    print(\"tous les éléments de M sont plus grands que 5\")\n",
    "else:\n",
    "    print(\"tous les éléments de M sont plus petits que 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Type casting*\n",
    "\n",
    "On peut créer une vue d'un autre type que l'original pour un *array*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = array([[-1,2], [0,4]])\n",
    "M.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.,  2.],\n",
       "       [ 0.,  4.]])"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2 = M.astype(float)\n",
    "M2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M2.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True],\n",
       "       [False,  True]], dtype=bool)"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M3 = M.astype(bool)\n",
    "M3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pour aller plus loin\n",
    "\n",
    "* http://numpy.scipy.org\n",
    "* http://scipy.org/Tentative_NumPy_Tutorial\n",
    "* http://scipy.org/NumPy_for_Matlab_Users - Un guide pour les utilisateurs de MATLAB."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}