TASK_3_Numpy_tasks(DW21).ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l2RQlZXE7IKv"
      },
      "source": [
        "# Numpy\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pSRLRs_x7IKz"
      },
      "source": [
        "#### 1. Import the numpy package under the name `np` (★☆☆) \n",
        "(**hint**: import … as …)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "collapsed": true,
        "id": "DBfZ21Vx7IK0"
      },
      "outputs": [],
      "source": [
        "import numpy as np"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A0eMHUUk7IK0"
      },
      "source": [
        "#### 2. Print the numpy version and the configuration (★☆☆) \n",
        "(**hint**: np.\\_\\_version\\_\\_, np.show\\_config)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "E0pO_Jib7IK1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "19e6a730-d24d-4c19-f348-1eff0a3d8fb4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "blas_mkl_info:\n",
            "  NOT AVAILABLE\n",
            "blis_info:\n",
            "  NOT AVAILABLE\n",
            "openblas_info:\n",
            "    libraries = ['openblas', 'openblas']\n",
            "    library_dirs = ['/usr/local/lib']\n",
            "    language = c\n",
            "    define_macros = [('HAVE_CBLAS', None)]\n",
            "    runtime_library_dirs = ['/usr/local/lib']\n",
            "blas_opt_info:\n",
            "    libraries = ['openblas', 'openblas']\n",
            "    library_dirs = ['/usr/local/lib']\n",
            "    language = c\n",
            "    define_macros = [('HAVE_CBLAS', None)]\n",
            "    runtime_library_dirs = ['/usr/local/lib']\n",
            "lapack_mkl_info:\n",
            "  NOT AVAILABLE\n",
            "openblas_lapack_info:\n",
            "    libraries = ['openblas', 'openblas']\n",
            "    library_dirs = ['/usr/local/lib']\n",
            "    language = c\n",
            "    define_macros = [('HAVE_CBLAS', None)]\n",
            "    runtime_library_dirs = ['/usr/local/lib']\n",
            "lapack_opt_info:\n",
            "    libraries = ['openblas', 'openblas']\n",
            "    library_dirs = ['/usr/local/lib']\n",
            "    language = c\n",
            "    define_macros = [('HAVE_CBLAS', None)]\n",
            "    runtime_library_dirs = ['/usr/local/lib']\n",
            "Supported SIMD extensions in this NumPy install:\n",
            "    baseline = SSE,SSE2,SSE3\n",
            "    found = SSSE3,SSE41,POPCNT,SSE42,AVX,F16C,FMA3,AVX2\n",
            "    not found = AVX512F,AVX512CD,AVX512_KNL,AVX512_KNM,AVX512_SKX,AVX512_CLX,AVX512_CNL,AVX512_ICL\n"
          ]
        }
      ],
      "source": [
        "np.__version__\n",
        "np.show_config()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u5EGBepA7IK1"
      },
      "source": [
        "#### 3. Create a null vector of size 10 (★☆☆) \n",
        "(**hint**: np.zeros)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QRveQTqU7IK2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6fe05be3-a3e7-4c0e-9e91-5e1dd9cd1c8a"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ],
      "source": [
        "np.zeros(10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LKE0PU-v7IK2"
      },
      "source": [
        "#### 4.  How to find the memory size of any array (★☆☆) \n",
        "(**hint**: size, itemsize)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "elumRK3G7IK3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "85475817-cc1f-4264-9642-317059a6d45c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "8\n"
          ]
        }
      ],
      "source": [
        "x=np.zeros(10)\n",
        "print(x.size) \n",
        "print(x.itemsize)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_Bk90eaT7IK3"
      },
      "source": [
        "#### 5.  How to get the documentation of the numpy add function from the command line? (★☆☆) \n",
        "(**hint**: np.info)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "jXZWH7Dy7IK4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c882de4a-c3ee-4589-87ae-6f9955bf7386"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])\n",
            "\n",
            "Add arguments element-wise.\n",
            "\n",
            "Parameters\n",
            "----------\n",
            "x1, x2 : array_like\n",
            "    The arrays to be added.\n",
            "    If ``x1.shape != x2.shape``, they must be broadcastable to a common\n",
            "    shape (which becomes the shape of the output).\n",
            "out : ndarray, None, or tuple of ndarray and None, optional\n",
            "    A location into which the result is stored. If provided, it must have\n",
            "    a shape that the inputs broadcast to. If not provided or None,\n",
            "    a freshly-allocated array is returned. A tuple (possible only as a\n",
            "    keyword argument) must have length equal to the number of outputs.\n",
            "where : array_like, optional\n",
            "    This condition is broadcast over the input. At locations where the\n",
            "    condition is True, the `out` array will be set to the ufunc result.\n",
            "    Elsewhere, the `out` array will retain its original value.\n",
            "    Note that if an uninitialized `out` array is created via the default\n",
            "    ``out=None``, locations within it where the condition is False will\n",
            "    remain uninitialized.\n",
            "**kwargs\n",
            "    For other keyword-only arguments, see the\n",
            "    :ref:`ufunc docs <ufuncs.kwargs>`.\n",
            "\n",
            "Returns\n",
            "-------\n",
            "add : ndarray or scalar\n",
            "    The sum of `x1` and `x2`, element-wise.\n",
            "    This is a scalar if both `x1` and `x2` are scalars.\n",
            "\n",
            "Notes\n",
            "-----\n",
            "Equivalent to `x1` + `x2` in terms of array broadcasting.\n",
            "\n",
            "Examples\n",
            "--------\n",
            ">>> np.add(1.0, 4.0)\n",
            "5.0\n",
            ">>> x1 = np.arange(9.0).reshape((3, 3))\n",
            ">>> x2 = np.arange(3.0)\n",
            ">>> np.add(x1, x2)\n",
            "array([[  0.,   2.,   4.],\n",
            "       [  3.,   5.,   7.],\n",
            "       [  6.,   8.,  10.]])\n",
            "\n",
            "The ``+`` operator can be used as a shorthand for ``np.add`` on ndarrays.\n",
            "\n",
            ">>> x1 = np.arange(9.0).reshape((3, 3))\n",
            ">>> x2 = np.arange(3.0)\n",
            ">>> x1 + x2\n",
            "array([[ 0.,  2.,  4.],\n",
            "       [ 3.,  5.,  7.],\n",
            "       [ 6.,  8., 10.]])\n"
          ]
        }
      ],
      "source": [
        "np.info(np.add)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "emXnMTOu7IK4"
      },
      "source": [
        "#### 6.  Create a null vector of size 10 but the fifth value which is 1 (★☆☆) \n",
        "(**hint**: array\\[4\\])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Z9vk658d7IK5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "586a1447-7d91-4886-b2f1-fa39805069f6"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0., 0., 0., 0., 1., 0., 0., 0., 0., 0.])"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ],
      "source": [
        "a = np.zeros(10)\n",
        "a[4] = 1\n",
        "a"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OIRQV1Qy7IK5"
      },
      "source": [
        "#### 7.  Create a vector with values ranging from 10 to 49 (★☆☆) \n",
        "(**hint**: np.arange)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0UXuwN7v7IK5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5402f92e-ae78-49c2-8235-42f6c844e253"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,\n",
              "       27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,\n",
              "       44, 45, 46, 47, 48, 49])"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ],
      "source": [
        "a=np.arange(10,50)\n",
        "a"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b12DvmOm7IK5"
      },
      "source": [
        "#### 8.  Reverse a vector (first element becomes last) (★☆☆) \n",
        "(**hint**: array\\[::-1\\])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BZIS1oEB7IK6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ec0d4f6e-ef27-45c6-d216-6ee436a1697b"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,\n",
              "       27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,\n",
              "       44, 45, 46, 47, 48, 49])"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ],
      "source": [
        "a[::-1]\n",
        "a"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KDZp_f9F7IK6"
      },
      "source": [
        "#### 9.  Create a 3x3 matrix with values ranging from 0 to 8 (★☆☆) \n",
        "(**hint**: reshape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "p-0Dm9GT7IK6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9b299c6d-c4fb-47a9-9221-d635939c7bc6"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 1, 2],\n",
              "       [3, 4, 5],\n",
              "       [6, 7, 8]])"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ],
      "source": [
        "np.arange(0,9).reshape(3,3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RFUOPuJ67IK6"
      },
      "source": [
        "#### 10. Find indices of non-zero elements from \\[1,2,0,0,4,0\\] (★☆☆) \n",
        "(**hint**: np.nonzero)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BbjNQPPI7IK7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ee6dd521-c63a-4243-ac40-5e5388e742b6"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([0, 1, 4]),)"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ],
      "source": [
        "x = [1,2,0,0,4,0]\n",
        "np.nonzero(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ozCTyDMj7IK7"
      },
      "source": [
        "#### 11. Create a 3x3 identity matrix (★☆☆) \n",
        "(**hint**: np.eye)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DCQqcds17IK7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "63837cb1-a863-4194-dcd1-21b4e8b0ecc7"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 0., 0.],\n",
              "       [0., 1., 0.],\n",
              "       [0., 0., 1.]])"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ],
      "source": [
        "np.eye(3,3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "60kWMqKc7IK7"
      },
      "source": [
        "#### 12. Create a 3x3x3 array with random values (★☆☆) \n",
        "(**hint**: np.random.random)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "87QWUb8-7IK8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "818e0946-13f1-4d8b-9a94-1e987c4db6ad"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[0.98482183, 0.80927276, 0.59918162],\n",
              "        [0.67734982, 0.70549055, 0.10514144],\n",
              "        [0.51279731, 0.29242402, 0.45654682]],\n",
              "\n",
              "       [[0.1898919 , 0.65058063, 0.017871  ],\n",
              "        [0.6510397 , 0.53008075, 0.12815645],\n",
              "        [0.87673542, 0.37028898, 0.62239822]],\n",
              "\n",
              "       [[0.4859248 , 0.46046915, 0.57144364],\n",
              "        [0.8606885 , 0.50718242, 0.58904494],\n",
              "        [0.03000236, 0.46920074, 0.74995637]]])"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ],
      "source": [
        "np.random.random((3,3,3))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AF8v8kzu7IK8"
      },
      "source": [
        "#### 13. Create a 10x10 array with random values and find the minimum and maximum values (★☆☆) \n",
        "(**hint**: min, max)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XKYfEF757IK8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3fcd08c8-918c-47e3-fcf8-706222af7215"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[14 63 90 27 81 92 64 96 43 22]\n",
            " [64 88 91 97 27 87 61 37 98 36]\n",
            " [26 81 49 73 87 49 80 65 37 11]\n",
            " [67 66 69 21 40 13 62 69 31 87]\n",
            " [85 30 92 56 38 53 52 57 15 41]\n",
            " [30 91 37 49 31 29 12 62 57 40]\n",
            " [86 62 95 14 60 56 30 41 74 17]\n",
            " [35 70 53 70 39 71 47 35 35 28]\n",
            " [90 87 97 96 11 14 77 39 20 12]\n",
            " [20 62 75 63 65 43 46 33 88 16]]\n",
            "11\n",
            "98\n"
          ]
        }
      ],
      "source": [
        "x = np.random.randint(10,100,(10,10))\n",
        "print(x)\n",
        "print(np.min(x))\n",
        "print(np.max(x))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8Uv-4PEh7IK8"
      },
      "source": [
        "#### 14. Create a random vector of size 30 and find the mean value (★☆☆) \n",
        "(**hint**: mean)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Cy0Xa6uj7IK8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "555e71bf-7f2b-408c-f936-4dc72b67b6a5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0.31813628 0.12744074 0.2084699  0.85506664 0.85863058 0.31068345\n",
            " 0.94028015 0.79288901 0.28584627 0.40461942 0.64074032 0.71698726\n",
            " 0.07531533 0.00755778 0.2022502  0.14954403 0.91542629 0.70261246\n",
            " 0.98453963 0.28742422 0.95908199 0.11324414 0.28387563 0.4155042\n",
            " 0.59169656 0.05848948 0.25958991 0.57023393 0.66133228 0.60731201]\n",
            "0.4768273365766894\n"
          ]
        }
      ],
      "source": [
        "x = np.random.rand(30)\n",
        "print(x)\n",
        "print(np.mean(x))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SXEpm0sq7IK8"
      },
      "source": [
        "#### 15. Create a 2d array with 1 on the border and 0 inside (★☆☆) \n",
        "(**hint**: array\\[1:-1, 1:-1\\])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Tz9fdxQQ7IK8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0e043d25-5715-4152-a867-8bc00acbae18"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 1., 1., 1., 1., 1.],\n",
              "       [1., 0., 0., 0., 0., 1.],\n",
              "       [1., 0., 0., 0., 0., 1.],\n",
              "       [1., 0., 0., 0., 0., 1.],\n",
              "       [1., 0., 0., 0., 0., 1.],\n",
              "       [1., 1., 1., 1., 1., 1.]])"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ],
      "source": [
        "x = np.ones((6,6))\n",
        "x[1:-1,1:-1] =0\n",
        "x"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9AMkQIhp7IK9"
      },
      "source": [
        "#### 16. How to add a border (filled with 0's) around an existing array? (★☆☆) \n",
        "(**hint**: np.pad)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WgrSMIoJ7IK9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d95523de-7129-4e10-c88d-b6795c758a55"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 0., 0., 0., 0., 0., 0.],\n",
              "       [0., 1., 1., 1., 1., 1., 0.],\n",
              "       [0., 1., 1., 1., 1., 1., 0.],\n",
              "       [0., 1., 1., 1., 1., 1., 0.],\n",
              "       [0., 1., 1., 1., 1., 1., 0.],\n",
              "       [0., 1., 1., 1., 1., 1., 0.],\n",
              "       [0., 0., 0., 0., 0., 0., 0.]])"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ],
      "source": [
        "x = np.ones((5,5))\n",
        "np.pad(x,1,mode='constant',constant_values = 0)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PQN1Oc1J7IK9"
      },
      "source": [
        "#### 17. What is the result of the following expression? (★☆☆) \n",
        "(**hint**: NaN = not a number, inf = infinity)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8BFmUVD17IK9"
      },
      "source": [
        "```python\n",
        "0 * np.nan\n",
        "np.nan == np.nan\n",
        "np.inf > np.nan\n",
        "np.nan - np.nan\n",
        "0.3 == 3 * 0.1\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "itw3NJFN7IK9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9d31aa0f-a2be-40ae-c6b3-122939c76b6b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "nan\n",
            "False\n",
            "False\n",
            "nan\n",
            "False\n"
          ]
        }
      ],
      "source": [
        "print(0 * np.nan)\n",
        "print(np.nan == np.nan)\n",
        "print(np.inf > np.nan)\n",
        "print(np.nan - np.nan)\n",
        "print(0.3 == 3 * 0.1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oy2alpnm7IK-"
      },
      "source": [
        "#### 18. Create a 5x5 matrix with values 1,2,3,4 just below the diagonal (★☆☆) \n",
        "(**hint**: np.diag)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1zui_itg7IK-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1b693ef5-48b4-428c-821c-bcba6345baaf"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 0, 0, 0, 0],\n",
              "       [1, 0, 0, 0, 0],\n",
              "       [0, 2, 0, 0, 0],\n",
              "       [0, 0, 3, 0, 0],\n",
              "       [0, 0, 0, 4, 0]])"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ],
      "source": [
        "a = np.diag([1,2,3,4], k=-1)\n",
        "a"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uWYNDgtr7IK-"
      },
      "source": [
        "#### 19. Create a 8x8 matrix and fill it with a checkerboard pattern (★☆☆) \n",
        "(**hint**: array\\[::2\\])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "afD0OKPP7IK-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d834549d-bc4a-451f-9c54-fc5e22594a0b"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 1., 1., 1., 1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1., 1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1., 1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1., 1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1., 1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1., 1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1., 1., 1., 1., 1.],\n",
              "       [1., 1., 1., 1., 1., 1., 1., 1.]])"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ],
      "source": [
        "x = np.ones((8,8))\n",
        "x"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S3p1Le1G7IK-"
      },
      "source": [
        "#### 20. Consider a (6,7,8) shape array, what is the index (x,y,z) of the 100th element? \n",
        "(**hint**: np.unravel_index)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UA4YsL-t7IK-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5b89f141-48ab-45cc-8a38-4711a3758097"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([1]), array([5]), array([3]))"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ],
      "source": [
        "x=np.arange(1,337).reshape(6,7,8)\n",
        "np.where(x == 100)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W2SOMpR-7IK_"
      },
      "source": [
        "#### 21. Create a checkerboard 8x8 matrix using the tile function (★☆☆) \n",
        "(**hint**: np.tile)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GMI0yTXT7IK_"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aUpaq8Hd7IK_"
      },
      "source": [
        "#### 22. Normalize a 5x5 random matrix (★☆☆) \n",
        "(**hint**: (x - min) / (max - min))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "di-BTOU87ILA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4d132dc9-6b57-4b54-c5f5-84ebd57835f9"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.84933659, 1.        , 0.7817927 , 0.50536678, 0.434901  ],\n",
              "       [0.34012625, 0.41215836, 0.93181277, 0.23351618, 0.80649215],\n",
              "       [0.03965763, 0.96309711, 0.21119887, 0.83708765, 0.        ],\n",
              "       [0.28812576, 0.79457397, 0.78030662, 0.83700539, 0.08282696],\n",
              "       [0.69912594, 0.69363675, 0.3665729 , 0.88003551, 0.26402465]])"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ],
      "source": [
        "x = np.random.rand(5,5)\n",
        "x = (x- np.min(x))/(np.max(x) - np.min(x))\n",
        "x"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rVm9MHQd7ILA"
      },
      "source": [
        "#### 23. Create a custom dtype that describes a color as four unsigned bytes (RGBA) (★☆☆) \n",
        "(**hint**: np.dtype)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "nUkH-Nqi7ILA"
      },
      "outputs": [],
      "source": [
        "colorone = np.dtype([(\"r\", np.ubyte),\n",
        "                  (\"g\", np.ubyte),\n",
        "                  (\"b\", np.ubyte),\n",
        "                  (\"a\", np.ubyte)])\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JjkN5KE37ILA"
      },
      "source": [
        "#### 24. Multiply a 5x3 matrix by a 3x2 matrix (real matrix product) (★☆☆) \n",
        "(**hint**: np.dot | @)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cfuoNgU37ILA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d3aae6fb-a9b3-44fb-b331-3fe856bc0293"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 22,  28],\n",
              "       [ 49,  64],\n",
              "       [ 76, 100],\n",
              "       [103, 136],\n",
              "       [130, 172]])"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ],
      "source": [
        "x1 = np.arange(1,16).reshape(5,3)\n",
        "x2 = np.arange(1,7).reshape(3,2)\n",
        "np.dot(x1,x2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LK3oBNiI7ILA"
      },
      "source": [
        "#### 25. Given a 1D array, negate all elements which are between 3 and 8, in place. (★☆☆) \n",
        "(**hint**: >, <=)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8N5xOrZD7ILA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "07b6507d-ac33-4891-b5f6-08a48247ef9e"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([7, 6, 2, 8, 8, 3, 4, 1, 6, 6, 6, 2, 7, 5, 1, 1, 2, 2, 1, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ],
      "source": [
        "np.random.randint(1,10,size=20)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UGKDqNN_7ILB"
      },
      "source": [
        "#### 26. What is the output of the following script? (★☆☆) \n",
        "(**hint**: np.sum)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NmgNFsPj7ILB"
      },
      "source": [
        "```python\n",
        "# Author: Jake VanderPlas\n",
        "\n",
        "print(sum(range(5),-1))\n",
        "from numpy import *\n",
        "print(sum(range(5),-1))\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TdYNLB8S7ILB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "45442e1e-0fde-4788-a49c-56c0f7983f63"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9\n",
            "10\n"
          ]
        }
      ],
      "source": [
        "print(sum(range(5),-1))\n",
        "from numpy import *\n",
        "print(sum(range(5),-1))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WdayMGzJ7ILB"
      },
      "source": [
        "#### 27. Consider an integer vector Z, which of these expressions are legal? (★☆☆)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Na8pUaQ7ILB"
      },
      "source": [
        "```python\n",
        "Z**Z\n",
        "2 << Z >> 2\n",
        "Z <- Z\n",
        "1j*Z\n",
        "Z/1/1\n",
        "Z<Z>Z\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pTTa9V5l7ILB",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 299
        },
        "outputId": "2ce9f1ed-551b-4021-dc2f-46020581d5e3"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[   1 3125   27    1]\n",
            "[ 1 16  4  1]\n",
            "[False False False False]\n",
            "[0.+1.j 0.+5.j 0.+3.j 0.+1.j]\n",
            "[1. 5. 3. 1.]\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-46-bd23e40a6da7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1j\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mZ\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mZ\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mZ\u001b[0m\u001b[0;34m<\u001b[0m\u001b[0mZ\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0mZ\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
          ]
        }
      ],
      "source": [
        "Z=np.array([1,5,3,1])\n",
        "print(Z**Z)\n",
        "print(2 << Z >> 2)\n",
        "print(Z <- Z)\n",
        "print(1j*Z)\n",
        "print(Z/1/1)\n",
        "print(Z<Z>Z) # NOT A LEGAL EXPRESSION"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ktZviAXZ7ILB"
      },
      "source": [
        "#### 28. What are the result of the following expressions?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lTBTFeu27ILB"
      },
      "source": [
        "```python\n",
        "np.array(0) / np.array(0)\n",
        "np.array(0) // np.array(0)\n",
        "np.array([np.nan]).astype(int).astype(float)\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vWI3edmC7ILC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "be996e6e-9061-4eb6-c0e2-1f3c1f9d2995"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in true_divide\n",
            "  \"\"\"Entry point for launching an IPython kernel.\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:2: RuntimeWarning: divide by zero encountered in floor_divide\n",
            "  \n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-9.22337204e+18])"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ],
      "source": [
        "np.array(0) / np.array(0)\n",
        "np.array(0) // np.array(0)\n",
        "np.array([np.nan]).astype(int).astype(float)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gN_AWJaU7ILC"
      },
      "source": [
        "#### 29. How to round away from zero a float array ? (★☆☆) \n",
        "(**hint**: np.uniform, np.copysign, np.ceil, np.abs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZV1gQ_tb7ILC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "df0405c6-753c-431e-e96c-e78e0c895be9"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])"
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ],
      "source": [
        "x = np.random.rand(10)\n",
        "np.ceil(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bUd94DhX7ILC"
      },
      "source": [
        "#### 30. How to find common values between two arrays? (★☆☆) \n",
        "(**hint**: np.intersect1d)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OkXKUs4l7ILC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d35ff5f4-44be-43c6-c24f-1204e234649f"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([4, 5])"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ],
      "source": [
        "a = np.array([1,2,3,4,5])\n",
        "b = np.array([4,5,6,7,8])\n",
        "np.intersect1d(a,b)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yfHhX-xQ7ILC"
      },
      "source": [
        "#### 31. How to ignore all numpy warnings (not recommended)? (★☆☆) \n",
        "(**hint**: np.seterr, np.errstate)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kShd5QD57ILC"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kqGl0s-37ILC"
      },
      "source": [
        "#### 32. Is the following expressions true? (★☆☆) \n",
        "(**hint**: imaginary number)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r48D6uWC7ILD"
      },
      "source": [
        "```python\n",
        "np.sqrt(-1) == np.emath.sqrt(-1)\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Da0AnAnZ7ILD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "256fad12-ad95-424a-bde6-9939f679a0c5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in sqrt\n",
            "  \"\"\"Entry point for launching an IPython kernel.\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ],
      "source": [
        "np.sqrt(-1) == np.emath.sqrt(-1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "voclTenT7ILD"
      },
      "source": [
        "#### 33. How to get the dates of yesterday, today and tomorrow? (★☆☆) \n",
        "(**hint**: np.datetime64, np.timedelta64)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "TpP5KIN57ILD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "84932867-83bc-44ff-8fba-cd625212d15b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2022-08-24 2022-08-25 2022-08-26\n"
          ]
        }
      ],
      "source": [
        "today = np.datetime64('today','D')\n",
        "yesterday = np.datetime64('today', 'D') - np.timedelta64(1, 'D')\n",
        "tomorrow =np.datetime64('today', 'D') + np.timedelta64(1, 'D')\n",
        "print(yesterday, today, tomorrow)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MJTRiTSW7ILD"
      },
      "source": [
        "#### 34. How to get all the dates corresponding to the month of July 2016? (★★☆) \n",
        "(**hint**: np.arange(dtype=datetime64\\['D'\\]))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "r4kbkSgs7ILD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1c37a968-4a33-49a7-9343-d5b8ef1332db"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array(['2016-07-01', '2016-07-02', '2016-07-03', '2016-07-04',\n",
              "       '2016-07-05', '2016-07-06', '2016-07-07', '2016-07-08',\n",
              "       '2016-07-09', '2016-07-10', '2016-07-11', '2016-07-12',\n",
              "       '2016-07-13', '2016-07-14', '2016-07-15', '2016-07-16',\n",
              "       '2016-07-17', '2016-07-18', '2016-07-19', '2016-07-20',\n",
              "       '2016-07-21', '2016-07-22', '2016-07-23', '2016-07-24',\n",
              "       '2016-07-25', '2016-07-26', '2016-07-27', '2016-07-28',\n",
              "       '2016-07-29', '2016-07-30', '2016-07-31'], dtype='datetime64[D]')"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ],
      "source": [
        "np.arange('2016-07','2016-08', dtype=\"datetime64[D]\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9Oe5Tiiw7ILD"
      },
      "source": [
        "#### 35. How to compute ((A+B)\\*(-A/2)) in place (without copy)? (★★☆) \n",
        "(**hint**: np.add(out=), np.negative(out=), np.multiply(out=), np.divide(out=))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZceGQKcN7ILE"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PCLZGqGD7ILE"
      },
      "source": [
        "#### 36. Extract the integer part of a random array using 5 different methods (★★☆) \n",
        "(**hint**: %, np.floor, np.ceil, astype, np.trunc)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Q358yhKJ7ILE"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3ZyMIncu7ILE"
      },
      "source": [
        "#### 37. Create a 5x5 matrix with row values ranging from 0 to 4 (★★☆) \n",
        "(**hint**: np.arange)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YSSsZm0w7ILE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4d27f31d-a6e5-4257-acb1-1b229cff29d6"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 1, 2, 3, 4],\n",
              "       [0, 1, 2, 3, 4],\n",
              "       [0, 1, 2, 3, 4],\n",
              "       [0, 1, 2, 3, 4],\n",
              "       [0, 1, 2, 3, 4]])"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ],
      "source": [
        "x = np.arange(5)\n",
        "np.tile(x,(5,1))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SUjzmQGF7ILE"
      },
      "source": [
        "#### 38. Consider a generator function that generates 10 integers and use it to build an array (★☆☆) \n",
        "(**hint**: np.fromiter)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-v-Owu5l7ILE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0a754189-d0a1-467c-a106-dd1463986674"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0 1 2 3 4 5 6 7 8 9]\n"
          ]
        }
      ],
      "source": [
        "def generate():\n",
        "    for x in range(10):\n",
        "        yield x\n",
        "a = np.fromiter(generate(),dtype=int)\n",
        "print(a)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WgQaiF5-7ILE"
      },
      "source": [
        "#### 39. Create a vector of size 10 with values ranging from 0 to 1, both excluded (★★☆) \n",
        "(**hint**: np.linspace)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FP8JQSRE7ILF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4c29a7c8-1f92-4034-a6f3-abf887a865c9"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.1       , 0.18181818, 0.26363636, 0.34545455, 0.42727273,\n",
              "       0.50909091, 0.59090909, 0.67272727, 0.75454545, 0.83636364,\n",
              "       0.91818182])"
            ]
          },
          "metadata": {},
          "execution_count": 59
        }
      ],
      "source": [
        "np.linspace(0.1,1,11,endpoint=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "us76t3dL7ILF"
      },
      "source": [
        "#### 40. Create a random vector of size 10 and sort it (★★☆) \n",
        "(**hint**: sort)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Y8H-Ph-L7ILF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "afee9d4d-c727-46ca-e2f4-c56befa09961"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 1, 2, 3, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ],
      "source": [
        "np.random.rand(10)\n",
        "np.sort(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aLFvRIXM7ILF"
      },
      "source": [
        "#### 41. How to sum a small array faster than np.sum? (★★☆) \n",
        "(**hint**: np.add.reduce)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-glbO6WP7ILF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cb743f92-1c6a-4d69-e221-1d135f94cf9d"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {},
          "execution_count": 61
        }
      ],
      "source": [
        "a = np.array([3,4,2,1,5])\n",
        "np.add.reduce(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qC7Ortko7ILF"
      },
      "source": [
        "#### 42. Consider two random array A and B, check if they are equal (★★☆) \n",
        "(**hint**: np.allclose, np.array\\_equal)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rjt3znWa7ILF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "38e952d0-517a-4214-abb3-4696dd0ced93"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n",
            "False\n"
          ]
        }
      ],
      "source": [
        "A = np.random.randint(0,3,5)\n",
        "B = np.random.randint(0,3,5)\n",
        "print(np.allclose(A,B))\n",
        "print(np.array_equal(A,B))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "syM_pX8V7ILG"
      },
      "source": [
        "#### 43. Make an array immutable (read-only) (★★☆) \n",
        "(**hint**: flags.writeable)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "leA6gPFF7ILG"
      },
      "outputs": [],
      "source": [
        "x = np.zeros(15\n",
        "             )\n",
        "x.flags.writeable = False"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YaMmAtzA7ILG"
      },
      "source": [
        "#### 44. Consider a random 10x2 matrix representing cartesian coordinates, convert them to polar coordinates (★★☆) \n",
        "(**hint**: np.sqrt, np.arctan2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9kHhEKYA7ILG"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Px0-e8UB7ILG"
      },
      "source": [
        "#### 45. Create random vector of size 10 and replace the maximum value by 0 (★★☆) \n",
        "(**hint**: argmax)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7vgZcaGi7ILG"
      },
      "outputs": [],
      "source": [
        "x = np.random.random(10)\n",
        "x[x.argmax()] = 0"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3jL-qDlU7ILG"
      },
      "source": [
        "#### 46. Create a structured array with `x` and `y` coordinates covering the \\[0,1\\]x\\[0,1\\] area (★★☆) \n",
        "(**hint**: np.meshgrid)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "u0_TkhJI7ILG"
      },
      "outputs": [],
      "source": [
        "for dtype in [np.int8, np.int32, np.int64]:\n",
        "   print(np.iinfo(dtype).min)\n",
        "   print(np.iinfo(dtype).max)\n",
        "for dtype in [np.float32, np.float64]:\n",
        "   print(np.finfo(dtype).min)\n",
        "   print(np.finfo(dtype).max)\n",
        "   print(np.finfo(dtype).eps)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FYVK_27i7ILG"
      },
      "source": [
        "####  47. Given two arrays, X and Y, construct the Cauchy matrix C (Cij =1/(xi - yj)) \n",
        "(**hint**: np.subtract.outer)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "URiGaY2w7ILH"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i0wRLA907ILH"
      },
      "source": [
        "#### 48. Print the minimum and maximum representable value for each numpy scalar type (★★☆) \n",
        "(**hint**: np.iinfo, np.finfo, eps)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XKCZplnB7ILH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d57a177d-91cb-4443-a56c-7d5c216b7515"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-128\n",
            "127\n",
            "-2147483648\n",
            "2147483647\n",
            "-9223372036854775808\n",
            "9223372036854775807\n",
            "-3.4028235e+38\n",
            "3.4028235e+38\n",
            "1.1920929e-07\n",
            "-1.7976931348623157e+308\n",
            "1.7976931348623157e+308\n",
            "2.220446049250313e-16\n"
          ]
        }
      ],
      "source": [
        "for dtype in [np.int8, np.int32, np.int64]:\n",
        "   print(np.iinfo(dtype).min)\n",
        "   print(np.iinfo(dtype).max)\n",
        "for dtype in [np.float32, np.float64]:\n",
        "   print(np.finfo(dtype).min)\n",
        "   print(np.finfo(dtype).max)\n",
        "   print(np.finfo(dtype).eps)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "axJHNhzg7ILH"
      },
      "source": [
        "#### 49. How to print all the values of an array? (★★☆) \n",
        "(**hint**: np.set\\_printoptions)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "n5vTVgLc7ILH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b25df242-b3e1-4960-92b2-01244ef6c875"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]\n"
          ]
        }
      ],
      "source": [
        "np.set_printoptions(threshold=float(\"inf\"))\n",
        "Z = np.zeros((10,10))\n",
        "print(Z)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-uVhhQ9D7ILH"
      },
      "source": [
        "#### 50. How to find the closest value (to a given scalar) in a vector? (★★☆) \n",
        "(**hint**: argmin)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4dUfyPVE7ILH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "acf60201-64cc-4cd2-a984-79f3a71658a6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n",
            " 24 25 26 27 28 29]\n",
            "26.329335495154744\n",
            "26\n"
          ]
        }
      ],
      "source": [
        "Z = np.arange(30)\n",
        "print(Z)\n",
        "v = np.random.uniform(0,30)\n",
        "print(v)\n",
        "index = (np.abs(Z-v)).argmin()\n",
        "print(Z[index])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lvqVg21Y7ILH"
      },
      "source": [
        "#### 51. Create a structured array representing a position (x,y) and a color (r,g,b) (★★☆) \n",
        "(**hint**: dtype)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "Z = np.zeros(10, [ ('position', [ ('x', float, 1),\n",
        "                                   ('y', float, 1)]),\n",
        "                    ('color',    [ ('r', float, 1),\n",
        "                                   ('g', float, 1),\n",
        "                                   ('b', float, 1)])])\n",
        "print(Z)"
      ],
      "metadata": {
        "id": "TPI9_nod1uQC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pzsMSOdq7ILI"
      },
      "source": [
        "#### 52. Consider a random vector with shape (100,2) representing coordinates, find point by point distances (★★☆) \n",
        "(**hint**: np.atleast\\_2d, T, np.sqrt)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "1k3ewP0Q7ILI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cae12881-a9cc-4e42-ea52-1d6f6c06ed06"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0.         0.14163122 0.52403549 0.43740365 0.78030315 0.53299652\n",
            "  0.79012997 0.73468461 0.5415028  0.46925262]\n",
            " [0.14163122 0.         0.42469937 0.35082559 0.72007602 0.61293086\n",
            "  0.66435794 0.66466086 0.49034436 0.38763102]\n",
            " [0.52403549 0.42469937 0.         0.09582262 0.34188684 0.6698294\n",
            "  0.31310653 0.27103732 0.20405755 0.68505627]\n",
            " [0.43740365 0.35082559 0.09582262 0.         0.37729249 0.5872318\n",
            "  0.40572321 0.31617137 0.17826515 0.65217951]\n",
            " [0.78030315 0.72007602 0.34188684 0.37729249 0.         0.67478325\n",
            "  0.47387194 0.07583428 0.23950485 1.02381647]\n",
            " [0.53299652 0.61293086 0.6698294  0.5872318  0.67478325 0.\n",
            "  0.97875653 0.68291207 0.50977797 0.99445166]\n",
            " [0.79012997 0.66435794 0.31310653 0.40572321 0.47387194 0.97875653\n",
            "  0.         0.40503869 0.48141503 0.78674452]\n",
            " [0.73468461 0.66466086 0.27103732 0.31617137 0.07583428 0.68291207\n",
            "  0.40503869 0.         0.20488608 0.95552112]\n",
            " [0.5415028  0.49034436 0.20405755 0.17826515 0.23950485 0.50977797\n",
            "  0.48141503 0.20488608 0.         0.82408929]\n",
            " [0.46925262 0.38763102 0.68505627 0.65217951 1.02381647 0.99445166\n",
            "  0.78674452 0.95552112 0.82408929 0.        ]]\n",
            "[[0.         0.57421285 0.2452138  0.82586024 0.70491742 0.36329256\n",
            "  0.21247772 0.28443193 0.51682145 0.42357383]\n",
            " [0.57421285 0.         0.61050044 0.36568215 0.94565701 0.92573322\n",
            "  0.58457711 0.8162808  0.5142003  0.99284132]\n",
            " [0.2452138  0.61050044 0.         0.93391583 0.95008415 0.38142027\n",
            "  0.45548171 0.48406972 0.33015758 0.54169651]\n",
            " [0.82586024 0.36568215 0.93391583 0.         0.91123692 1.18866773\n",
            "  0.7427069  0.99642679 0.87971638 1.20129247]\n",
            " [0.70491742 0.94565701 0.95008415 0.91123692 0.         0.86698224\n",
            "  0.49970823 0.55037324 1.18305871 0.71296958]\n",
            " [0.36329256 0.92573322 0.38142027 1.18866773 0.86698224 0.\n",
            "  0.49591521 0.31743935 0.70626116 0.21313394]\n",
            " [0.21247772 0.58457711 0.45548171 0.7427069  0.49970823 0.49591521\n",
            "  0.         0.25372221 0.68978892 0.46131867]\n",
            " [0.28443193 0.8162808  0.48406972 0.99642679 0.55037324 0.31743935\n",
            "  0.25372221 0.         0.79276117 0.21331943]\n",
            " [0.51682145 0.5142003  0.33015758 0.87971638 1.18305871 0.70626116\n",
            "  0.68978892 0.79276117 0.         0.87142024]\n",
            " [0.42357383 0.99284132 0.54169651 1.20129247 0.71296958 0.21313394\n",
            "  0.46131867 0.21331943 0.87142024 0.        ]]\n"
          ]
        }
      ],
      "source": [
        "ARRY = np.random.random((10,2))\n",
        "A,Y = np.atleast_2d(ARRY[:,0]), np.atleast_2d(ARRY[:,1])\n",
        "D = np.sqrt( (A-A.T)**2 + (Y-Y.T)**2)\n",
        "print(D)\n",
        "\n",
        "# Much faster with scipy\n",
        "import scipy\n",
        "# Thanks Gavin Heverly-Coulson (#issue 1)\n",
        "import scipy.spatial\n",
        "\n",
        "ARRY = np.random.random((10,2))\n",
        "D = scipy.spatial.distance.cdist(ARRY,ARRY)\n",
        "print(D)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "91jDB5bc7ILI"
      },
      "source": [
        "#### 53. How to convert a float (32 bits) array into an integer (32 bits) in place? \n",
        "(**hint**: astype(copy=False))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "Z1wtlFI47ILI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "563d0204-2055-4d38-9d88-2145b32ab288"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[56 92 86 79  2 58 25 53 52 42]\n"
          ]
        }
      ],
      "source": [
        "Z = (np.random.rand(10)*100).astype(np.float32)\n",
        "Y = Z.view(np.int32)\n",
        "Y[:] = Z\n",
        "print(Y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CwFKKllX7ILI"
      },
      "source": [
        "#### 54. How to read the following file? (★★☆) \n",
        "(**hint**: np.genfromtxt)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gh2iafAS7ILI"
      },
      "source": [
        "```\n",
        "1, 2, 3, 4, 5\n",
        "6,  ,  , 7, 8\n",
        " ,  , 9,10,11\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "tH2T0KxI7ILI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4b0f24eb-28f6-4b45-df6d-1715f045297c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 1  2  3  4  5]\n",
            " [ 6 -1 -1  7  8]\n",
            " [-1 -1  9 10 11]]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:7: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
            "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
            "  import sys\n"
          ]
        }
      ],
      "source": [
        "from io import StringIO\n",
        "\n",
        "string = StringIO('''1, 2, 3, 4, 5\n",
        "                6,  ,  , 7, 8\n",
        "                 ,  , 9,10,11\n",
        "''')\n",
        "Z = np.genfromtxt(string, delimiter=\",\", dtype=np.int)\n",
        "print(Z)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qfFCbPXz7ILJ"
      },
      "source": [
        "#### 55. What is the equivalent of enumerate for numpy arrays? (★★☆) \n",
        "(**hint**: np.ndenumerate, np.ndindex)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "1fN0T8ry7ILJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "acf470d8-bb8d-45be-8a57-6fee6adb123d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(0, 0) 0\n",
            "(0, 1) 1\n",
            "(0, 2) 2\n",
            "(1, 0) 3\n",
            "(1, 1) 4\n",
            "(1, 2) 5\n",
            "(2, 0) 6\n",
            "(2, 1) 7\n",
            "(2, 2) 8\n",
            "(0, 0) 0\n",
            "(0, 1) 1\n",
            "(0, 2) 2\n",
            "(1, 0) 3\n",
            "(1, 1) 4\n",
            "(1, 2) 5\n",
            "(2, 0) 6\n",
            "(2, 1) 7\n",
            "(2, 2) 8\n"
          ]
        }
      ],
      "source": [
        "Z = np.arange(9).reshape(3,3)\n",
        "for index, value in np.ndenumerate(Z):\n",
        "    print(index, value)\n",
        "for index in np.ndindex(Z.shape):\n",
        "    print(index, Z[index])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_4gcZYMj7ILJ"
      },
      "source": [
        "#### 56. Generate a generic 2D Gaussian-like array (★★☆) \n",
        "(**hint**: np.meshgrid, np.exp)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "gX1X9Fcu7ILJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6cb0bce6-0850-417a-be96-f7a5d09ae28e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0.36787944 0.44822088 0.51979489 0.57375342 0.60279818 0.60279818\n",
            "  0.57375342 0.51979489 0.44822088 0.36787944]\n",
            " [0.44822088 0.54610814 0.63331324 0.69905581 0.73444367 0.73444367\n",
            "  0.69905581 0.63331324 0.54610814 0.44822088]\n",
            " [0.51979489 0.63331324 0.73444367 0.81068432 0.85172308 0.85172308\n",
            "  0.81068432 0.73444367 0.63331324 0.51979489]\n",
            " [0.57375342 0.69905581 0.81068432 0.89483932 0.9401382  0.9401382\n",
            "  0.89483932 0.81068432 0.69905581 0.57375342]\n",
            " [0.60279818 0.73444367 0.85172308 0.9401382  0.98773022 0.98773022\n",
            "  0.9401382  0.85172308 0.73444367 0.60279818]\n",
            " [0.60279818 0.73444367 0.85172308 0.9401382  0.98773022 0.98773022\n",
            "  0.9401382  0.85172308 0.73444367 0.60279818]\n",
            " [0.57375342 0.69905581 0.81068432 0.89483932 0.9401382  0.9401382\n",
            "  0.89483932 0.81068432 0.69905581 0.57375342]\n",
            " [0.51979489 0.63331324 0.73444367 0.81068432 0.85172308 0.85172308\n",
            "  0.81068432 0.73444367 0.63331324 0.51979489]\n",
            " [0.44822088 0.54610814 0.63331324 0.69905581 0.73444367 0.73444367\n",
            "  0.69905581 0.63331324 0.54610814 0.44822088]\n",
            " [0.36787944 0.44822088 0.51979489 0.57375342 0.60279818 0.60279818\n",
            "  0.57375342 0.51979489 0.44822088 0.36787944]]\n"
          ]
        }
      ],
      "source": [
        "X, Y = np.meshgrid(np.linspace(-1,1,10), np.linspace(-1,1,10))\n",
        "D = np.sqrt(X*X+Y*Y)\n",
        "sigma, mu = 1.0, 0.0\n",
        "G = np.exp(-( (D-mu)**2 / ( 2.0 * sigma**2 ) ) )\n",
        "print(G)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zHlJiGAg7ILJ"
      },
      "source": [
        "#### 57. How to randomly place p elements in a 2D array? (★★☆) \n",
        "(**hint**: np.put, np.random.choice)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "R_vE9_W27ILJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "611cdd73-6d67-4462-b7f0-061e1c02a9e7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 1. 0. 0. 0. 1. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]\n"
          ]
        }
      ],
      "source": [
        "n = 10\n",
        "p = 3\n",
        "Z = np.zeros((n,n))\n",
        "np.put(Z, np.random.choice(range(n*n), p, replace=False),1)\n",
        "print (Z)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Bp7A_V67ILJ"
      },
      "source": [
        "#### 58. Subtract the mean of each row of a matrix (★★☆) \n",
        "(**hint**: mean(axis=,keepdims=))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "G55zI_YM7ILJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "afc9d88e-bca3-451b-9376-c00b507cc4ba"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[-0.1587686 , -0.07117452,  0.11354241,  0.15138729,  0.4218913 ,\n",
              "        -0.33556522, -0.32245726,  0.3747957 ,  0.00229323, -0.17594433],\n",
              "       [ 0.25671489, -0.49707422,  0.24489201,  0.26138698, -0.20301946,\n",
              "        -0.18509635, -0.03500443,  0.09350698, -0.29237526,  0.35606885],\n",
              "       [ 0.50836096,  0.16871073, -0.01328681,  0.06985905, -0.26384334,\n",
              "        -0.42741831, -0.09162625,  0.16442047, -0.08663402, -0.02854247],\n",
              "       [ 0.41267803,  0.01318834, -0.09321692, -0.01938627, -0.30865538,\n",
              "        -0.27635228, -0.13969634,  0.35110985,  0.13052878, -0.07019782],\n",
              "       [ 0.22682392, -0.3588204 ,  0.39461132, -0.38665077, -0.0637164 ,\n",
              "        -0.20959386,  0.28235937, -0.10493066,  0.43647588, -0.21655839]])"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ],
      "source": [
        "X = np.random.rand(5, 10)\n",
        "\n",
        "Y = X - X.mean(axis=1, keepdims=True)\n",
        "\n",
        "Y"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ORFD9PCJ7ILJ"
      },
      "source": [
        "#### 59. How to sort an array by the nth column? (★★☆) \n",
        "(**hint**: argsort)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "3UIzA6-Q7ILK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "378fe43d-d950-44d7-dac3-db628a389397"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 4 2]\n",
            " [1 5 5]\n",
            " [7 7 9]]\n",
            "[[1 4 2]\n",
            " [1 5 5]\n",
            " [7 7 9]]\n"
          ]
        }
      ],
      "source": [
        "Z = np.random.randint(0,10,(3,3))\n",
        "print(Z)\n",
        "print(Z[Z[:,1].argsort()])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CUAH6_p47ILK"
      },
      "source": [
        "#### 60. How to tell if a given 2D array has null columns? (★★☆) \n",
        "(**hint**: any, ~)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "gxlLPwjO7ILK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1209b505-e077-41cf-f5a6-da8dc649a68d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ],
      "source": [
        "Z = np.random.randint(0,3,(3,10))\n",
        "print((~Z.any(axis=0)).any())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TBXHaZpq7ILK"
      },
      "source": [
        "#### 61. Find the nearest value from a given value in an array (★★☆) \n",
        "(**hint**: np.abs, argmin, flat)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "gbOc0shy7ILK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0569e3e4-ebfd-4559-8c51-178db213d160"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.604040099329476\n"
          ]
        }
      ],
      "source": [
        "Z = np.random.uniform(0,1,10)\n",
        "z = 0.5\n",
        "m = Z.flat[np.abs(Z - z).argmin()]\n",
        "print(m)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cU86pnGD7ILK"
      },
      "source": [
        "#### 62. Considering two arrays with shape (1,3) and (3,1), how to compute their sum using an iterator? (★★☆) \n",
        "(**hint**: np.nditer)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "nR75EcZB7ILK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ad318dee-6391-40f8-8a2a-e24ae5117e4f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0 1 2]\n",
            " [1 2 3]\n",
            " [2 3 4]]\n"
          ]
        }
      ],
      "source": [
        "A = np.arange(3).reshape(3,1)\n",
        "B = np.arange(3).reshape(1,3)\n",
        "it = np.nditer([A,B,None])\n",
        "for x,y,z in it: z[...] = x + y\n",
        "print(it.operands[2])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tf2_q8lJ7ILK"
      },
      "source": [
        "#### 63. Create an array class that has a name attribute (★★☆) \n",
        "(**hint**: class method)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kn80RLD47ILK"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1rtMw1B17ILL"
      },
      "source": [
        "#### 64. Consider a given vector, how to add 1 to each element indexed by a second vector (be careful with repeated indices)? (★★★) \n",
        "(**hint**: np.bincount | np.add.at)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "0QxFimTN7ILL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ce06a4d5-2f74-4c36-eaad-a22e968b76d5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[4. 3. 4. 3. 2. 3. 1. 4. 2. 4.]\n",
            "[7. 5. 7. 5. 3. 5. 1. 7. 3. 7.]\n"
          ]
        }
      ],
      "source": [
        "Z = np.ones(10)\n",
        "I = np.random.randint(0,len(Z),20)\n",
        "Z += np.bincount(I, minlength=len(Z))\n",
        "print(Z)\n",
        "np.add.at(Z, I, 1)\n",
        "print(Z)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J_FKVLju7ILM"
      },
      "source": [
        "#### 65. How to accumulate elements of a vector (X) to an array (F) based on an index list (I)? (★★★) \n",
        "(**hint**: np.bincount)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "5mkQljQ47ILM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "98c8982a-2038-4ad0-cc20-65170870f8ec"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0. 7. 0. 6. 5. 0. 0. 0. 0. 3.]\n"
          ]
        }
      ],
      "source": [
        "X = [1,2,3,4,5,6]\n",
        "I = [1,3,9,3,4,1]\n",
        "F = np.bincount(I,X)\n",
        "print(F)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6NXCzQrf7ILM"
      },
      "source": [
        "#### 66. Considering a (w,h,3) image of (dtype=ubyte), compute the number of unique colors (★★★) \n",
        "(**hint**: np.unique)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YBPKMipn7ILM"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KIwD2i2k7ILM"
      },
      "source": [
        "#### 67. Considering a four dimensions array, how to get sum over the last two axis at once? (★★★) \n",
        "(**hint**: sum(axis=(-2,-1)))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "mqPCj2Jh7ILM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "45dc7bea-d155-431f-bf13-f345d9fc55fb"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[52 61 34 64]\n",
            " [54 57 60 38]\n",
            " [60 63 52 49]]\n",
            "[[52 61 34 64]\n",
            " [54 57 60 38]\n",
            " [60 63 52 49]]\n"
          ]
        }
      ],
      "source": [
        "A = np.random.randint(0,10,(3,4,3,4))\n",
        "\n",
        "sum = A.sum(axis=(-2,-1))\n",
        "print(sum)\n",
        "sum = A.reshape(A.shape[:-2] + (-1,)).sum(axis=-1)\n",
        "print(sum)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WGJXHppD7ILM"
      },
      "source": [
        "#### 68. Considering a one-dimensional vector D, how to compute means of subsets of D using a vector S of same size describing subset  indices? (★★★) \n",
        "(**hint**: np.bincount)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BuZHadAg7ILM"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ifyKm7T87ILN"
      },
      "source": [
        "#### 69. How to get the diagonal of a dot product? (★★★) \n",
        "(**hint**: np.diag)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "aPFxhmpn7ILN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4beddc6c-30e6-449d-de04-1831c79c8b8a"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1.83611697, 1.31693547, 1.09397325, 1.44157227, 1.8380128 ])"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ],
      "source": [
        "A = np.random.uniform(0,1,(5,5))\n",
        "B = np.random.uniform(0,1,(5,5))\n",
        "\n",
        "\n",
        "np.diag(np.dot(A, B))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sn7wbpB27ILN"
      },
      "source": [
        "#### 70. Consider the vector \\[1, 2, 3, 4, 5\\], how to build a new vector with 3 consecutive zeros interleaved between each value? (★★★) \n",
        "(**hint**: array\\[::4\\])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sZaBp0SC7ILN"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0okYtnQw7ILN"
      },
      "source": [
        "#### 71. Consider an array of dimension (5,5,3), how to mulitply it by an array with dimensions (5,5)? (★★★) \n",
        "(**hint**: array\\[:, :, None\\])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "collapsed": true,
        "id": "bTR-Nr6o7ILN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "56584827-e467-4fe7-ba43-7cf88069f18a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[[1. 1. 1.]\n",
            "  [1. 1. 1.]\n",
            "  [1. 1. 1.]\n",
            "  [1. 1. 1.]\n",
            "  [1. 1. 1.]]\n",
            "\n",
            " [[1. 1. 1.]\n",
            "  [1. 1. 1.]\n",
            "  [1. 1. 1.]\n",
            "  [1. 1. 1.]\n",
            "  [1. 1. 1.]]\n",
            "\n",
            " [[1. 1. 1.]\n",
            "  [1. 1. 1.]\n",
            "  [1. 1. 1.]\n",
            "  [1. 1. 1.]\n",
            "  [1. 1. 1.]]\n",
            "\n",
            " [[1. 1. 1.]\n",
            "  [1. 1. 1.]\n",
            "  [1. 1. 1.]\n",
            "  [1. 1. 1.]\n",
            "  [1. 1. 1.]]\n",
            "\n",
            " [[1. 1. 1.]\n",
            "  [1. 1. 1.]\n",
            "  [1. 1. 1.]\n",
            "  [1. 1. 1.]\n",
            "  [1. 1. 1.]]]\n",
            "**\n",
            "[[2. 2. 2. 2. 2.]\n",
            " [2. 2. 2. 2. 2.]\n",
            " [2. 2. 2. 2. 2.]\n",
            " [2. 2. 2. 2. 2.]\n",
            " [2. 2. 2. 2. 2.]]\n",
            "**\n",
            "[[[2. 2. 2.]\n",
            "  [2. 2. 2.]\n",
            "  [2. 2. 2.]\n",
            "  [2. 2. 2.]\n",
            "  [2. 2. 2.]]\n",
            "\n",
            " [[2. 2. 2.]\n",
            "  [2. 2. 2.]\n",
            "  [2. 2. 2.]\n",
            "  [2. 2. 2.]\n",
            "  [2. 2. 2.]]\n",
            "\n",
            " [[2. 2. 2.]\n",
            "  [2. 2. 2.]\n",
            "  [2. 2. 2.]\n",
            "  [2. 2. 2.]\n",
            "  [2. 2. 2.]]\n",
            "\n",
            " [[2. 2. 2.]\n",
            "  [2. 2. 2.]\n",
            "  [2. 2. 2.]\n",
            "  [2. 2. 2.]\n",
            "  [2. 2. 2.]]\n",
            "\n",
            " [[2. 2. 2.]\n",
            "  [2. 2. 2.]\n",
            "  [2. 2. 2.]\n",
            "  [2. 2. 2.]\n",
            "  [2. 2. 2.]]]\n"
          ]
        }
      ],
      "source": [
        "A = np.ones((5,5,3))\n",
        "print(A)\n",
        "print(\"**\")\n",
        "B = 2*np.ones((5,5))\n",
        "print(B)\n",
        "print(\"**\")\n",
        "print(A * B[:,:,None])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lbieDpts7ILN"
      },
      "source": [
        "#### 72. How to swap two rows of an array? (★★★) \n",
        "(**hint**: array\\[\\[\\]\\] = array\\[\\[\\]\\])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "Pcitgm7R7ILO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "19ff8ba9-bbd0-4197-ab7c-6b52305d3268"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 0  1  2  3  4]\n",
            " [ 5  6  7  8  9]\n",
            " [10 11 12 13 14]\n",
            " [15 16 17 18 19]\n",
            " [20 21 22 23 24]]\n",
            "[[ 5  6  7  8  9]\n",
            " [ 0  1  2  3  4]\n",
            " [10 11 12 13 14]\n",
            " [15 16 17 18 19]\n",
            " [20 21 22 23 24]]\n"
          ]
        }
      ],
      "source": [
        "A = np.arange(25).reshape(5,5)\n",
        "print(A)\n",
        "\n",
        "A[[0,1]] = A[[1,0]]\n",
        "print(A)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cCnipU9V7ILO"
      },
      "source": [
        "#### 73. Consider a set of 10 triplets describing 10 triangles (with shared vertices), find the set of unique line segments composing all the  triangles (★★★) \n",
        "(**hint**: repeat, np.roll, np.sort, view, np.unique)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "wb_9jhzh7ILO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "78560220-9d2e-4c1c-deaf-19ea4fbd1115"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[( 1,  9) ( 1, 53) ( 2, 15) ( 2, 19) ( 5, 74) ( 5, 79) ( 7, 25) ( 7, 73)\n",
            " ( 9, 53) (14, 40) (14, 91) (15, 19) (17, 23) (17, 87) (23, 87) (24, 25)\n",
            " (24, 43) (25, 43) (25, 73) (40, 91) (41, 58) (41, 60) (49, 57) (49, 90)\n",
            " (57, 90) (58, 60) (73, 82) (73, 95) (74, 79) (82, 95)]\n"
          ]
        }
      ],
      "source": [
        "faces = np.random.randint(0,100,(10,3))\n",
        "F = np.roll(faces.repeat(2,axis=1),-1,axis=1)\n",
        "F = F.reshape(len(F)*3,2)\n",
        "F = np.sort(F,axis=1)\n",
        "G = F.view( dtype=[('p0',F.dtype),('p1',F.dtype)] )\n",
        "G = np.unique(G)\n",
        "print(G)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UswcsJSY7ILO"
      },
      "source": [
        "#### 74. Given an array C that is a bincount, how to produce an array A such that np.bincount(A) == C? (★★★) \n",
        "(**hint**: np.repeat)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "nMbsu98U7ILO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7d85d076-f152-42db-b809-429edc2fd272"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 1 2 3 4 4 6]\n"
          ]
        }
      ],
      "source": [
        "C = np.bincount([1,1,2,3,4,4,6])\n",
        "A = np.repeat(np.arange(len(C)), C)\n",
        "print(A)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-WBa7gog7ILO"
      },
      "source": [
        "#### 75. How to compute averages using a sliding window over an array? (★★★) \n",
        "(**hint**: np.cumsum)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2VaWzb5x7ILO"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t2wt-OPT7ILP"
      },
      "source": [
        "#### 76. Consider a one-dimensional array Z, build a two-dimensional array whose first row is (Z\\[0\\],Z\\[1\\],Z\\[2\\]) and each subsequent row is  shifted by 1 (last row should be (Z\\[-3\\],Z\\[-2\\],Z\\[-1\\]) (★★★) \n",
        "(**hint**: from numpy.lib import stride_tricks)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "GSY-h4LM7ILP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1b7a0500-6e99-4c5a-87e6-6f6024c6c133"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0 1 2]\n",
            " [1 2 3]\n",
            " [2 3 4]\n",
            " [3 4 5]\n",
            " [4 5 6]\n",
            " [5 6 7]\n",
            " [6 7 8]\n",
            " [7 8 9]]\n"
          ]
        }
      ],
      "source": [
        "\n",
        "def rolling(a, window):\n",
        "    shape = (a.size - window + 1, window)\n",
        "    strides = (a.itemsize, a.itemsize)\n",
        "    return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)\n",
        "Z = rolling(np.arange(10), 3)\n",
        "print(Z)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uvASnNQ47ILP"
      },
      "source": [
        "#### 77. How to negate a boolean, or to change the sign of a float inplace? (★★★) \n",
        "(**hint**: np.logical_not, np.negative)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "e42zfisI7ILP"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zD-NvH687ILP"
      },
      "source": [
        "#### 78. Consider 2 sets of points P0,P1 describing lines (2d) and a point p, how to compute distance from p to each line i  (P0\\[i\\],P1\\[i\\])? (★★★)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "00wl761-7ILP"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LktlDN-O7ILQ"
      },
      "source": [
        "#### 79. Consider 2 sets of points P0,P1 describing lines (2d) and a set of points P, how to compute distance from each point j (P\\[j\\]) to each line i (P0\\[i\\],P1\\[i\\])? (★★★)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "id": "VxpmpWFi7ILQ"
      },
      "outputs": [],
      "source": [
        "P0 = np.random.uniform(-10, 10, (5,2))\n",
        "P1 = np.random.uniform(-10,10,(5,2))\n",
        "p = np.random.uniform(-10, 10, (5,2))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tQT5XZ2_7ILQ"
      },
      "source": [
        "#### 80. Consider an arbitrary array, write a function that extract a subpart with a fixed shape and centered on a given element (pad with a `fill` value when necessary) (★★★) \n",
        "(**hint**: minimum, maximum)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DWRAeXl97ILQ"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-kjPtyG_7ILQ"
      },
      "source": [
        "#### 81. Consider an array Z = \\[1,2,3,4,5,6,7,8,9,10,11,12,13,14\\], how to generate an array R = \\[\\[1,2,3,4\\], \\[2,3,4,5\\], \\[3,4,5,6\\], ..., \\[11,12,13,14\\]\\]? (★★★) \n",
        "(**hint**: stride\\_tricks.as\\_strided)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "id": "xXXAczXE7ILQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7906b186-ac12-49d1-ebd3-618f1b58930a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 1  2  3  4]\n",
            " [ 2  3  4  5]\n",
            " [ 3  4  5  6]\n",
            " [ 4  5  6  7]\n",
            " [ 5  6  7  8]\n",
            " [ 6  7  8  9]\n",
            " [ 7  8  9 10]\n",
            " [ 8  9 10 11]\n",
            " [ 9 10 11 12]\n",
            " [10 11 12 13]\n",
            " [11 12 13 14]]\n"
          ]
        }
      ],
      "source": [
        "from numpy.lib import stride_tricks\n",
        "Z = np.arange(1,15,dtype=np.uint32)\n",
        "R = stride_tricks.as_strided(Z,(11,4),(4,4))\n",
        "print(R)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "itIzOWck7ILQ"
      },
      "source": [
        "#### 82. Compute a matrix rank (★★★) \n",
        "(**hint**: np.linalg.svd) (suggestion: np.linalg.svd)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "id": "xof62vO17ILQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6ca87dd7-5719-4794-e55b-c54c97b6ff7f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n"
          ]
        }
      ],
      "source": [
        "Z = np.random.uniform(0,1,(10,10))\n",
        "U, S, V = np.linalg.svd(Z) \n",
        "rank = np.sum(S > 1e-10)\n",
        "print(rank)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Bok6krTE7ILQ"
      },
      "source": [
        "#### 83. How to find the most frequent value in an array? \n",
        "(**hint**: np.bincount, argmax)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "id": "CVugLZp17ILR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f0e12580-d6b5-433c-99c6-ed60718e97bf"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ],
      "source": [
        "Z = np.random.randint(0,10,50)\n",
        "print(np.bincount(Z).argmax())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tch2i5aq7ILR"
      },
      "source": [
        "#### 84. Extract all the contiguous 3x3 blocks from a random 10x10 matrix (★★★) \n",
        "(**hint**: stride\\_tricks.as\\_strided)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {
        "id": "qHY5gUD-7ILR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e88e4776-1343-4cc5-b202-677ad9d70a70"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[[[2 4 4]\n",
            "   [1 4 2]\n",
            "   [0 2 4]]\n",
            "\n",
            "  [[4 4 4]\n",
            "   [4 2 4]\n",
            "   [2 4 1]]\n",
            "\n",
            "  [[4 4 3]\n",
            "   [2 4 2]\n",
            "   [4 1 0]]\n",
            "\n",
            "  [[4 3 3]\n",
            "   [4 2 2]\n",
            "   [1 0 3]]\n",
            "\n",
            "  [[3 3 4]\n",
            "   [2 2 2]\n",
            "   [0 3 0]]\n",
            "\n",
            "  [[3 4 3]\n",
            "   [2 2 1]\n",
            "   [3 0 1]]\n",
            "\n",
            "  [[4 3 0]\n",
            "   [2 1 3]\n",
            "   [0 1 4]]\n",
            "\n",
            "  [[3 0 2]\n",
            "   [1 3 0]\n",
            "   [1 4 1]]]\n",
            "\n",
            "\n",
            " [[[1 4 2]\n",
            "   [0 2 4]\n",
            "   [3 4 2]]\n",
            "\n",
            "  [[4 2 4]\n",
            "   [2 4 1]\n",
            "   [4 2 4]]\n",
            "\n",
            "  [[2 4 2]\n",
            "   [4 1 0]\n",
            "   [2 4 1]]\n",
            "\n",
            "  [[4 2 2]\n",
            "   [1 0 3]\n",
            "   [4 1 4]]\n",
            "\n",
            "  [[2 2 2]\n",
            "   [0 3 0]\n",
            "   [1 4 3]]\n",
            "\n",
            "  [[2 2 1]\n",
            "   [3 0 1]\n",
            "   [4 3 4]]\n",
            "\n",
            "  [[2 1 3]\n",
            "   [0 1 4]\n",
            "   [3 4 2]]\n",
            "\n",
            "  [[1 3 0]\n",
            "   [1 4 1]\n",
            "   [4 2 1]]]\n",
            "\n",
            "\n",
            " [[[0 2 4]\n",
            "   [3 4 2]\n",
            "   [1 2 1]]\n",
            "\n",
            "  [[2 4 1]\n",
            "   [4 2 4]\n",
            "   [2 1 1]]\n",
            "\n",
            "  [[4 1 0]\n",
            "   [2 4 1]\n",
            "   [1 1 1]]\n",
            "\n",
            "  [[1 0 3]\n",
            "   [4 1 4]\n",
            "   [1 1 3]]\n",
            "\n",
            "  [[0 3 0]\n",
            "   [1 4 3]\n",
            "   [1 3 0]]\n",
            "\n",
            "  [[3 0 1]\n",
            "   [4 3 4]\n",
            "   [3 0 2]]\n",
            "\n",
            "  [[0 1 4]\n",
            "   [3 4 2]\n",
            "   [0 2 2]]\n",
            "\n",
            "  [[1 4 1]\n",
            "   [4 2 1]\n",
            "   [2 2 1]]]\n",
            "\n",
            "\n",
            " [[[3 4 2]\n",
            "   [1 2 1]\n",
            "   [4 3 2]]\n",
            "\n",
            "  [[4 2 4]\n",
            "   [2 1 1]\n",
            "   [3 2 4]]\n",
            "\n",
            "  [[2 4 1]\n",
            "   [1 1 1]\n",
            "   [2 4 2]]\n",
            "\n",
            "  [[4 1 4]\n",
            "   [1 1 3]\n",
            "   [4 2 3]]\n",
            "\n",
            "  [[1 4 3]\n",
            "   [1 3 0]\n",
            "   [2 3 3]]\n",
            "\n",
            "  [[4 3 4]\n",
            "   [3 0 2]\n",
            "   [3 3 3]]\n",
            "\n",
            "  [[3 4 2]\n",
            "   [0 2 2]\n",
            "   [3 3 4]]\n",
            "\n",
            "  [[4 2 1]\n",
            "   [2 2 1]\n",
            "   [3 4 3]]]\n",
            "\n",
            "\n",
            " [[[1 2 1]\n",
            "   [4 3 2]\n",
            "   [4 0 2]]\n",
            "\n",
            "  [[2 1 1]\n",
            "   [3 2 4]\n",
            "   [0 2 0]]\n",
            "\n",
            "  [[1 1 1]\n",
            "   [2 4 2]\n",
            "   [2 0 2]]\n",
            "\n",
            "  [[1 1 3]\n",
            "   [4 2 3]\n",
            "   [0 2 0]]\n",
            "\n",
            "  [[1 3 0]\n",
            "   [2 3 3]\n",
            "   [2 0 1]]\n",
            "\n",
            "  [[3 0 2]\n",
            "   [3 3 3]\n",
            "   [0 1 0]]\n",
            "\n",
            "  [[0 2 2]\n",
            "   [3 3 4]\n",
            "   [1 0 3]]\n",
            "\n",
            "  [[2 2 1]\n",
            "   [3 4 3]\n",
            "   [0 3 0]]]\n",
            "\n",
            "\n",
            " [[[4 3 2]\n",
            "   [4 0 2]\n",
            "   [0 1 2]]\n",
            "\n",
            "  [[3 2 4]\n",
            "   [0 2 0]\n",
            "   [1 2 0]]\n",
            "\n",
            "  [[2 4 2]\n",
            "   [2 0 2]\n",
            "   [2 0 1]]\n",
            "\n",
            "  [[4 2 3]\n",
            "   [0 2 0]\n",
            "   [0 1 1]]\n",
            "\n",
            "  [[2 3 3]\n",
            "   [2 0 1]\n",
            "   [1 1 3]]\n",
            "\n",
            "  [[3 3 3]\n",
            "   [0 1 0]\n",
            "   [1 3 0]]\n",
            "\n",
            "  [[3 3 4]\n",
            "   [1 0 3]\n",
            "   [3 0 2]]\n",
            "\n",
            "  [[3 4 3]\n",
            "   [0 3 0]\n",
            "   [0 2 4]]]\n",
            "\n",
            "\n",
            " [[[4 0 2]\n",
            "   [0 1 2]\n",
            "   [1 2 3]]\n",
            "\n",
            "  [[0 2 0]\n",
            "   [1 2 0]\n",
            "   [2 3 3]]\n",
            "\n",
            "  [[2 0 2]\n",
            "   [2 0 1]\n",
            "   [3 3 4]]\n",
            "\n",
            "  [[0 2 0]\n",
            "   [0 1 1]\n",
            "   [3 4 3]]\n",
            "\n",
            "  [[2 0 1]\n",
            "   [1 1 3]\n",
            "   [4 3 4]]\n",
            "\n",
            "  [[0 1 0]\n",
            "   [1 3 0]\n",
            "   [3 4 2]]\n",
            "\n",
            "  [[1 0 3]\n",
            "   [3 0 2]\n",
            "   [4 2 2]]\n",
            "\n",
            "  [[0 3 0]\n",
            "   [0 2 4]\n",
            "   [2 2 0]]]\n",
            "\n",
            "\n",
            " [[[0 1 2]\n",
            "   [1 2 3]\n",
            "   [0 4 0]]\n",
            "\n",
            "  [[1 2 0]\n",
            "   [2 3 3]\n",
            "   [4 0 0]]\n",
            "\n",
            "  [[2 0 1]\n",
            "   [3 3 4]\n",
            "   [0 0 0]]\n",
            "\n",
            "  [[0 1 1]\n",
            "   [3 4 3]\n",
            "   [0 0 3]]\n",
            "\n",
            "  [[1 1 3]\n",
            "   [4 3 4]\n",
            "   [0 3 4]]\n",
            "\n",
            "  [[1 3 0]\n",
            "   [3 4 2]\n",
            "   [3 4 4]]\n",
            "\n",
            "  [[3 0 2]\n",
            "   [4 2 2]\n",
            "   [4 4 3]]\n",
            "\n",
            "  [[0 2 4]\n",
            "   [2 2 0]\n",
            "   [4 3 3]]]]\n"
          ]
        }
      ],
      "source": [
        "Z = np.random.randint(0,5,(10,10))\n",
        "n = 3\n",
        "i = 1 + (Z.shape[0]-3)\n",
        "j = 1 + (Z.shape[1]-3)\n",
        "C = stride_tricks.as_strided(Z, shape=(i, j, n, n), strides=Z.strides + Z.strides)\n",
        "print(C)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bMWzfqtj7ILR"
      },
      "source": [
        "#### 85. Create a 2D array subclass such that Z\\[i,j\\] == Z\\[j,i\\] (★★★) \n",
        "(**hint**: class method)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PRaTwLBK7ILR"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rSLZJwM87ILR"
      },
      "source": [
        "#### 86. Consider a set of p matrices wich shape (n,n) and a set of p vectors with shape (n,1). How to compute the sum of of the p matrix products at once? (result has shape (n,1)) (★★★) \n",
        "(**hint**: np.tensordot)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "id": "xE9ycXa_7ILR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9ebd73e7-373a-41e3-ef4c-6af4dc1b16d3"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[200.]\n",
            " [200.]\n",
            " [200.]\n",
            " [200.]\n",
            " [200.]\n",
            " [200.]\n",
            " [200.]\n",
            " [200.]\n",
            " [200.]\n",
            " [200.]\n",
            " [200.]\n",
            " [200.]\n",
            " [200.]\n",
            " [200.]\n",
            " [200.]\n",
            " [200.]\n",
            " [200.]\n",
            " [200.]\n",
            " [200.]\n",
            " [200.]]\n"
          ]
        }
      ],
      "source": [
        "p, n = 10, 20\n",
        "M = np.ones((p,n,n))\n",
        "V = np.ones((p,n,1))\n",
        "S = np.tensordot(M, V, axes=[[0, 2], [0, 1]])\n",
        "print(S)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xhh3W7187ILR"
      },
      "source": [
        "#### 87. Consider a 16x16 array, how to get the block-sum (block size is 4x4)? (★★★) \n",
        "(**hint**: np.add.reduceat)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "id": "WR_vvr9j7ILS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3fe7f90f-230a-4831-dcd6-40dd57b42ff4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[16. 16. 16. 16.]\n",
            " [16. 16. 16. 16.]\n",
            " [16. 16. 16. 16.]\n",
            " [16. 16. 16. 16.]]\n"
          ]
        }
      ],
      "source": [
        "Z = np.ones((16,16))\n",
        "k = 4\n",
        "S = np.add.reduceat(np.add.reduceat(Z, np.arange(0, Z.shape[0], k), axis=0),\n",
        "                                       np.arange(0, Z.shape[1], k), axis=1)\n",
        "print(S)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O_ZT2s367ILS"
      },
      "source": [
        "#### 88. How to implement the Game of Life using numpy arrays? (★★★)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GxoSttMf7ILS"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "12tWcRbv7ILS"
      },
      "source": [
        "#### 89. How to get the n largest values of an array (★★★) \n",
        "(**hint**: np.argsort | np.argpartition)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "id": "-tgT2Yk57ILS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3cd6a961-c781-443a-ebfd-526edb9612dd"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[9995 9996 9997 9998 9999]\n",
            "[9999 9998 9996 9997 9995]\n"
          ]
        }
      ],
      "source": [
        "Z = np.arange(10000)\n",
        "np.random.shuffle(Z)\n",
        "n = 5\n",
        "\n",
        "\n",
        "print (Z[np.argsort(Z)[-n:]])\n",
        "print (Z[np.argpartition(-Z,n)[:n]])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SJF9Fvwg7ILS"
      },
      "source": [
        "#### 90. Given an arbitrary number of vectors, build the cartesian product (every combinations of every item) (★★★) \n",
        "(**hint**: np.indices)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "scrolled": true,
        "id": "2GY6UpxC7ILS"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mbejp7Pg7ILS"
      },
      "source": [
        "#### 91. How to create a record array from a regular array? (★★★) \n",
        "(**hint**: np.core.records.fromarrays)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {
        "id": "7yD8RhL27ILT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fc7665fd-5030-4428-9981-c1a70bce8a94"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(b'Hello', 2.5, 3) (b'World', 3.6, 2)]\n"
          ]
        }
      ],
      "source": [
        "Z = np.array([(\"Hello\", 2.5, 3),\n",
        "              (\"World\", 3.6, 2)])\n",
        "R = np.core.records.fromarrays(Z.T,\n",
        "                               names='col1, col2, col3',\n",
        "                               formats = 'S8, f8, i8')\n",
        "print(R)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xu75huJB7ILT"
      },
      "source": [
        "#### 92. Consider a large vector Z, compute Z to the power of 3 using 3 different methods (★★★) \n",
        "(**hint**: np.power, \\*, np.einsum)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OyWninXO7ILT"
      },
      "outputs": [],
      "source": [
        "x = np.random.rand(int(5e7))\n",
        "\n",
        "%timeit np.power(x,3)\n",
        "%timeit x*x*x\n",
        "%timeit np.einsum('i,i,i->i',x,x,x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PdF5FtQ87ILT"
      },
      "source": [
        "#### 93. Consider two arrays A and B of shape (8,3) and (2,2). How to find rows of A that contain elements of each row of B regardless of the order of the elements in B? (★★★) \n",
        "(**hint**: np.where)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "-5eAgmCa7ILT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f5378284-6671-4f9a-d961-6a40b2ab3b39"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3 6]\n"
          ]
        }
      ],
      "source": [
        "A = np.random.randint(0,5,(8,3))\n",
        "B = np.random.randint(0,5,(2,2))\n",
        "\n",
        "C = (A[..., np.newaxis, np.newaxis] == B)\n",
        "rows = np.where(C.any((3,1)).all(1))[0]\n",
        "print(rows)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yFB6kJ1Z7ILT"
      },
      "source": [
        "#### 94. Considering a 10x3 matrix, extract rows with unequal values (e.g. \\[2,2,3\\]) (★★★)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "Ig7C4YHZ7ILT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9a5ee69e-79fa-4d49-a3f8-1b409bbbe82e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[4 2 3]\n",
            " [0 0 0]\n",
            " [0 1 2]\n",
            " [4 4 2]\n",
            " [2 1 3]\n",
            " [0 2 1]\n",
            " [1 0 1]\n",
            " [2 0 1]\n",
            " [1 3 1]\n",
            " [4 0 3]]\n",
            "[[4 2 3]\n",
            " [0 1 2]\n",
            " [4 4 2]\n",
            " [2 1 3]\n",
            " [0 2 1]\n",
            " [1 0 1]\n",
            " [2 0 1]\n",
            " [1 3 1]\n",
            " [4 0 3]]\n",
            "[[4 2 3]\n",
            " [0 1 2]\n",
            " [4 4 2]\n",
            " [2 1 3]\n",
            " [0 2 1]\n",
            " [1 0 1]\n",
            " [2 0 1]\n",
            " [1 3 1]\n",
            " [4 0 3]]\n"
          ]
        }
      ],
      "source": [
        "Z = np.random.randint(0,5,(10,3))\n",
        "print(Z)\n",
        "\n",
        "E = np.all(Z[:,1:] == Z[:,:-1], axis=1)\n",
        "U = Z[~E]\n",
        "print(U)\n",
        "\n",
        "U = Z[Z.max(axis=1) != Z.min(axis=1),:]\n",
        "print(U)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aKQIIzrX7ILT"
      },
      "source": [
        "#### 95. Convert a vector of ints into a matrix binary representation (★★★) \n",
        "(**hint**: np.unpackbits)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "LsQ4qC377ILT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1d003c78-cf76-43fd-b9ed-e85b4f3b02cf"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0 0 0 0 0 0 0 0]\n",
            " [0 0 0 0 0 0 0 1]\n",
            " [0 0 0 0 0 0 1 0]\n",
            " [0 0 0 0 0 0 1 1]\n",
            " [0 0 0 0 1 1 1 1]\n",
            " [0 0 0 1 0 0 0 0]\n",
            " [0 0 1 0 0 0 0 0]\n",
            " [0 1 0 0 0 0 0 0]\n",
            " [1 0 0 0 0 0 0 0]]\n"
          ]
        }
      ],
      "source": [
        "I = np.array([0, 1, 2, 3, 15, 16, 32, 64, 128])\n",
        "B = ((I.reshape(-1,1) & (2**np.arange(8))) != 0).astype(int)\n",
        "print(B[:,::-1])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QYM3DA5u7ILT"
      },
      "source": [
        "#### 96. Given a two dimensional array, how to extract unique rows? (★★★) \n",
        "(**hint**: np.ascontiguousarray)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "iKH6CXgU7ILU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "44065813-6111-4731-dff4-79d933fee696"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0 0 0]\n",
            " [0 0 1]\n",
            " [1 0 0]\n",
            " [1 0 1]]\n"
          ]
        }
      ],
      "source": [
        "Z = np.random.randint(0,2,(6,3))\n",
        "T = np.ascontiguousarray(Z).view(np.dtype((np.void, Z.dtype.itemsize * Z.shape[1])))\n",
        "_, idx = np.unique(T, return_index=True)\n",
        "uZ = Z[idx]\n",
        "print(uZ)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "16ztai6f7ILU"
      },
      "source": [
        "#### 97. Considering 2 vectors A & B, write the einsum equivalent of inner, outer, sum, and mul function (★★★) \n",
        "(**hint**: np.einsum)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "4eFl_-sN7ILU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "511baf19-9cb5-47c8-89da-72d6af9459b5"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[5.06026233e-01, 8.38626061e-01, 6.46090242e-02, 5.07712759e-01,\n",
              "        1.42422348e-02, 8.37780491e-01, 1.05149607e-03, 1.96475421e-01,\n",
              "        8.12198482e-01, 6.55295372e-01],\n",
              "       [4.60027699e-01, 7.62393709e-01, 5.87359682e-02, 4.61560917e-01,\n",
              "        1.29475946e-02, 7.61625003e-01, 9.55913519e-04, 1.78615514e-01,\n",
              "        7.38368437e-01, 5.95728052e-01],\n",
              "       [1.10752978e-01, 1.83548456e-01, 1.41408515e-02, 1.11122105e-01,\n",
              "        3.11717026e-03, 1.83363388e-01, 2.30138901e-04, 4.30021935e-02,\n",
              "        1.77764303e-01, 1.43423224e-01],\n",
              "       [4.22356801e-02, 6.99962565e-02, 5.39261781e-03, 4.23764466e-02,\n",
              "        1.18873378e-03, 6.99256807e-02, 8.77635361e-05, 1.63988989e-02,\n",
              "        6.77904682e-02, 5.46944879e-02],\n",
              "       [7.42468786e-02, 1.23047706e-01, 9.47978201e-03, 7.44943347e-02,\n",
              "        2.08969696e-03, 1.22923640e-01, 1.54281134e-04, 2.88279259e-02,\n",
              "        1.19170111e-01, 9.61484461e-02],\n",
              "       [1.71715735e-01, 2.84580682e-01, 2.19245275e-02, 1.72288043e-01,\n",
              "        4.83298229e-03, 2.84293745e-01, 3.56816324e-04, 6.66722773e-02,\n",
              "        2.75612706e-01, 2.22368958e-01],\n",
              "       [2.22681145e-01, 3.69044526e-01, 2.84317502e-02, 2.23423315e-01,\n",
              "        6.26741649e-03, 3.68672426e-01, 4.62719782e-04, 8.64606789e-02,\n",
              "        3.57414845e-01, 2.88368298e-01],\n",
              "       [3.44131202e-01, 5.70321014e-01, 4.39383962e-02, 3.45278150e-01,\n",
              "        9.68565871e-03, 5.69745970e-01, 7.15086654e-04, 1.33616240e-01,\n",
              "        5.52348518e-01, 4.45644058e-01],\n",
              "       [1.03733942e-01, 1.71915963e-01, 1.32446666e-02, 1.04079675e-01,\n",
              "        2.91961773e-03, 1.71742623e-01, 2.15553711e-04, 4.02769038e-02,\n",
              "        1.66498384e-01, 1.34333692e-01],\n",
              "       [5.06164663e-01, 8.38855478e-01, 6.46266988e-02, 5.07851650e-01,\n",
              "        1.42461310e-02, 8.38009677e-01, 1.05178372e-03, 1.96529170e-01,\n",
              "        8.12420670e-01, 6.55474637e-01]])"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ],
      "source": [
        "A = np.random.uniform(0,1,10)\n",
        "B = np.random.uniform(0,1,10)\n",
        "\n",
        "np.einsum('i->', A)       \n",
        "np.einsum('i,i->i', A, B) \n",
        "np.einsum('i,i', A, B)   \n",
        "np.einsum('i,j->ij', A, B)  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kSsrHiwp7ILU"
      },
      "source": [
        "#### 98. Considering a path described by two vectors (X,Y), how to sample it using equidistant samples (★★★)? \n",
        "(**hint**: np.cumsum, np.interp)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "collapsed": true,
        "id": "j_9Cuobe7ILU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "05b47b11-3363-4b97-984f-f13ddad1029d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[ 0.00000000e+00 -3.73131229e-01 -2.59817608e+00 -3.26212050e+00\n",
            " -2.18442687e+00 -2.98929946e-02  2.42923642e+00  4.54913599e+00\n",
            "  5.92318348e+00  6.35117933e+00  5.82369277e+00  4.46259540e+00\n",
            "  2.47320794e+00  1.09577220e-01 -2.36575300e+00 -4.71261671e+00\n",
            " -6.72701769e+00 -8.25541575e+00 -9.18486120e+00 -9.46381505e+00\n",
            " -9.11085788e+00 -8.12875279e+00 -6.63306046e+00 -4.69271059e+00\n",
            " -2.44736165e+00 -2.05444585e-02  2.46101146e+00  4.86841760e+00\n",
            "  7.08937968e+00  9.02539126e+00  1.05948609e+01  1.17357250e+01\n",
            "  1.24068974e+01  1.25885805e+01  1.22815267e+01  1.15053927e+01\n",
            "  1.02963689e+01  8.70429550e+00  6.78948686e+00  4.61716636e+00\n",
            "  2.25853448e+00 -1.98731680e-01 -2.68040566e+00 -5.11543300e+00\n",
            " -7.41973991e+00 -9.53891040e+00 -1.14237629e+01 -1.29919305e+01\n",
            " -1.42355069e+01 -1.51243232e+01 -1.56061571e+01 -1.57219415e+01\n",
            " -1.54217066e+01 -1.47579136e+01 -1.37255236e+01 -1.23634834e+01\n",
            " -1.07024632e+01 -8.78327367e+00 -6.65029558e+00 -4.35514246e+00\n",
            " -1.94290275e+00  5.28038914e-01  3.00985904e+00  5.45450275e+00\n",
            "  7.80093594e+00  1.00179639e+01  1.20595602e+01  1.38732623e+01\n",
            "  1.54564938e+01  1.67497894e+01  1.77435802e+01  1.84439878e+01\n",
            "  1.87990820e+01  1.88271003e+01  1.85472755e+01  1.79378850e+01\n",
            "  1.70105456e+01  1.58085777e+01  1.43501808e+01  1.26222364e+01\n",
            "  1.06905445e+01  8.58498641e+00  6.33562529e+00  3.96179025e+00\n",
            "  1.51802643e+00 -9.61699044e-01 -3.44349301e+00 -5.88951759e+00\n",
            " -8.26006582e+00 -1.05270865e+01 -1.26610269e+01 -1.46343020e+01\n",
            " -1.64206033e+01 -1.79708499e+01 -1.92894561e+01 -2.03605967e+01\n",
            " -2.11716587e+01 -2.17133504e+01 -2.19797677e+01 -2.19626531e+01\n",
            " -2.16476737e+01 -2.10622561e+01 -2.02145809e+01 -1.91158467e+01\n",
            " -1.77800930e+01 -1.62239930e+01 -1.44666197e+01 -1.25291882e+01\n",
            " -1.04347777e+01 -8.20773276e+00 -5.86978851e+00 -3.45563299e+00\n",
            " -9.92556869e-01  1.49191203e+00  3.97031733e+00  6.41557503e+00\n",
            "  8.80126359e+00  1.11019001e+01  1.32931995e+01  1.53523150e+01\n",
            "  1.72580567e+01  1.89910866e+01  2.05340895e+01  2.18719167e+01\n",
            "  2.29917039e+01  2.38829603e+01  2.45376309e+01  2.49501314e+01\n",
            "  2.51173551e+01  2.50386548e+01  2.47157984e+01  2.41529019e+01\n",
            "  2.33563391e+01  2.23346314e+01  2.10983193e+01  1.96598169e+01\n",
            "  1.80332532e+01  1.62343003e+01  1.42799934e+01  1.21885425e+01\n",
            "  9.97914013e+00  7.67176574e+00  5.28699023e+00  2.84441658e+00\n",
            "  3.68190102e-01 -2.11846865e+00 -4.59426061e+00 -7.03829202e+00\n",
            " -9.43024209e+00 -1.17505186e+01 -1.39803999e+01 -1.61021634e+01\n",
            " -1.80991985e+01 -1.99561058e+01 -2.16587804e+01 -2.31850397e+01\n",
            " -2.45166960e+01 -2.56568097e+01 -2.65976904e+01 -2.73332424e+01\n",
            " -2.78589555e+01 -2.81718833e+01 -2.82706110e+01 -2.81552119e+01\n",
            " -2.78066635e+01 -2.72341677e+01 -2.64578863e+01 -2.54844118e+01\n",
            " -2.43214986e+01 -2.29779690e+01 -2.14636172e+01 -1.97837046e+01\n",
            " -1.79341987e+01 -1.59545785e+01 -1.38585628e+01 -1.16602783e+01\n",
            " -9.37416511e+00 -7.01488958e+00 -4.59184632e+00 -2.12995331e+00\n",
            "  3.50691071e-01  2.83498918e+00  5.30813450e+00  7.75565814e+00\n",
            "  1.01522531e+01  1.24813227e+01  1.47337756e+01  1.68973642e+01\n",
            "  1.89604991e+01  2.09071945e+01  2.26943693e+01  2.43420179e+01\n",
            "  2.58422998e+01  2.71881423e+01  2.83731992e+01  2.93376609e+01\n",
            "  3.01222558e+01  3.07280750e+01  3.11531219e+01  3.13960177e+01]\n",
            "[ 0.00000000e+00  1.74026724e+00  9.81816584e-01 -1.34251287e+00\n",
            " -3.53191891e+00 -4.70449474e+00 -4.59573427e+00 -3.33831870e+00\n",
            " -1.28956083e+00  1.14234685e+00  3.55645601e+00  5.62188218e+00\n",
            "  7.09389488e+00  7.82951803e+00  7.78700678e+00  6.99685666e+00\n",
            "  5.55535240e+00  3.60417006e+00  1.30506373e+00 -1.15819722e+00\n",
            " -3.61328132e+00 -5.89130465e+00 -7.87065053e+00 -9.41689057e+00\n",
            " -1.04714836e+01 -1.09903787e+01 -1.09354306e+01 -1.03330912e+01\n",
            " -9.22690166e+00 -7.67489830e+00 -5.75257980e+00 -3.54832201e+00\n",
            " -1.15854355e+00  1.31709956e+00  3.78023622e+00  6.13780326e+00\n",
            "  8.30540149e+00  1.02098724e+01  1.17910419e+01  1.29972950e+01\n",
            "  1.37774249e+01  1.41319792e+01  1.40585758e+01  1.35636816e+01\n",
            "  1.26345244e+01  1.13409083e+01  9.72216360e+00  7.79464305e+00\n",
            "  5.64544223e+00  3.32503222e+00  8.88107041e-01 -1.59329248e+00\n",
            " -4.05992507e+00 -6.45313746e+00 -8.71327144e+00 -1.07900854e+01\n",
            " -1.26380653e+01 -1.42147006e+01 -1.54892299e+01 -1.64390858e+01\n",
            " -1.70351433e+01 -1.72938948e+01 -1.71685631e+01 -1.67219979e+01\n",
            " -1.59044166e+01 -1.47824153e+01 -1.33665280e+01 -1.16678134e+01\n",
            " -9.75246391e+00 -7.63091465e+00 -5.35345831e+00 -2.96905840e+00\n",
            " -5.09631905e-01  1.97507060e+00  4.44430515e+00  6.85344809e+00\n",
            "  9.15903461e+00  1.13337844e+01  1.33467125e+01  1.51336120e+01\n",
            "  1.66966787e+01  1.80162922e+01  1.90746708e+01  1.98127969e+01\n",
            "  2.02634499e+01  2.04221761e+01  2.02877631e+01  1.98449702e+01\n",
            "  1.90974465e+01  1.80799531e+01  1.68069397e+01  1.52959771e+01\n",
            "  1.35665801e+01  1.16227312e+01  9.51601869e+00  7.27388893e+00\n",
            "  4.92519240e+00  2.49981337e+00  2.82932820e-02 -2.45817963e+00\n",
            " -4.92460367e+00 -7.34030894e+00 -9.67635928e+00 -1.19050601e+01\n",
            " -1.40002645e+01 -1.59376556e+01 -1.76950019e+01 -1.92523833e+01\n",
            " -2.05923861e+01 -2.16995543e+01 -2.25478860e+01 -2.31432552e+01\n",
            " -2.34800725e+01 -2.35556687e+01 -2.33702741e+01 -2.29269662e+01\n",
            " -2.22315865e+01 -2.12926288e+01 -2.01211000e+01 -1.87303570e+01\n",
            " -1.71359212e+01 -1.53552740e+01 -1.34076356e+01 -1.13137308e+01\n",
            " -9.09554383e+00 -6.77606668e+00 -4.37904252e+00 -1.92870828e+00\n",
            "  5.50461201e-01  3.03400451e+00  5.49771780e+00  7.91788934e+00\n",
            "  1.02715222e+01  1.25365431e+01  1.46919953e+01  1.67182148e+01\n",
            "  1.85969872e+01  2.03116866e+01  2.18473923e+01  2.31909872e+01\n",
            "  2.43312337e+01  2.52588296e+01  2.59664444e+01  2.64391214e+01\n",
            "  2.66748505e+01  2.66796333e+01  2.64545680e+01  2.60026765e+01\n",
            "  2.53288265e+01  2.44396400e+01  2.33433894e+01  2.20498837e+01\n",
            "  2.05703459e+01  1.89172843e+01  1.71043584e+01  1.51396391e+01\n",
            "  1.30387952e+01  1.08294252e+01  8.52903617e+00  6.15551380e+00\n",
            "  3.72697869e+00  1.26164946e+00 -1.22228693e+00 -3.70679651e+00\n",
            " -6.17014862e+00 -8.59028675e+00 -1.09516293e+01 -1.32379536e+01\n",
            " -1.54338179e+01 -1.75246263e+01 -1.94966815e+01 -2.13317519e+01\n",
            " -2.29952001e+01 -2.44987532e+01 -2.58335652e+01 -2.69919481e+01\n",
            " -2.79673583e+01 -2.87543764e+01 -2.93186910e+01 -2.96679958e+01\n",
            " -2.98181354e+01 -2.97693731e+01 -2.95229769e+01 -2.90811595e+01\n",
            " -2.84133854e+01 -2.75430665e+01 -2.64934034e+01 -2.52713717e+01\n",
            " -2.38845608e+01 -2.23353782e+01 -2.06051319e+01 -1.87442619e+01\n",
            " -1.67635423e+01 -1.46739620e+01 -1.24866789e+01 -1.01933401e+01\n",
            " -7.83474328e+00 -5.42495146e+00 -2.97607515e+00 -5.00072086e-01]\n"
          ]
        }
      ],
      "source": [
        "phi = np.arange(0, 10*np.pi, 0.1)\n",
        "a = 1\n",
        "x = a*phi*np.cos(phi)\n",
        "y = a*phi*np.sin(phi)\n",
        "\n",
        "dr = (np.diff(x)**2 + np.diff(y)**2)**.5 \n",
        "r = np.zeros_like(x)\n",
        "r[1:] = np.cumsum(dr)                \n",
        "r_int = np.linspace(0, r.max(), 200) \n",
        "x_int = np.interp(r_int, r, x)       \n",
        "y_int = np.interp(r_int, r, y)\n",
        "print(x_int)\n",
        "print(y_int)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v1yDXx8t7ILU"
      },
      "source": [
        "#### 99. Given an integer n and a 2D array X, select from X the rows which can be interpreted as draws from a multinomial distribution with n degrees, i.e., the rows which only contain integers and which sum to n. (★★★) \n",
        "(**hint**: np.logical\\_and.reduce, np.mod)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "ZpNU411c7ILU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e0433141-d9c1-491f-95b9-2106429c7758"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[2. 0. 1. 1.]]\n"
          ]
        }
      ],
      "source": [
        "X = np.asarray([[1.0, 0.0, 3.0, 8.0],\n",
        "                [2.0, 0.0, 1.0, 1.0],\n",
        "                [1.5, 2.5, 1.0, 0.0]])\n",
        "n = 4\n",
        "M = np.logical_and.reduce(np.mod(X, 1) == 0, axis=-1)\n",
        "M &= (X.sum(axis=-1) == n)\n",
        "print(X[M])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QyZAYbbl7ILU"
      },
      "source": [
        "#### 100. Compute bootstrapped 95% confidence intervals for the mean of a 1D array X (i.e., resample the elements of an array with replacement N times, compute the mean of each sample, and then compute percentiles over the means). (★★★) \n",
        "(**hint**: np.percentile)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "fdhF15T17ILU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7e11b60b-0c4f-4f35-b05d-33ee60b379aa"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[-0.09679491  0.31288698]\n"
          ]
        }
      ],
      "source": [
        "X = np.random.randn(100)\n",
        "N = 1000 \n",
        "idx = np.random.randint(0, X.size, (N, X.size))\n",
        "means = X[idx].mean(axis=1)\n",
        "confint = np.percentile(means, [2.5, 97.5])\n",
        "print(confint)"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Ygjak-MDhi5m"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "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.8.3"
    },
    "colab": {
      "name": "TASK 3- Numpy_tasks(DW21).ipynb",
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}