Numpy_Assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1: Importing the numpy package under the name `np`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2: Printing the numpy version and the configuration (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.26.2\n",
      "{\n",
      "  \"Compilers\": {\n",
      "    \"c\": {\n",
      "      \"name\": \"msvc\",\n",
      "      \"linker\": \"link\",\n",
      "      \"version\": \"19.29.30153\",\n",
      "      \"commands\": \"cl.exe\"\n",
      "    },\n",
      "    \"cython\": {\n",
      "      \"name\": \"cython\",\n",
      "      \"linker\": \"cython\",\n",
      "      \"version\": \"3.0.0\",\n",
      "      \"commands\": \"cython\"\n",
      "    },\n",
      "    \"c++\": {\n",
      "      \"name\": \"msvc\",\n",
      "      \"linker\": \"link\",\n",
      "      \"version\": \"19.29.30153\",\n",
      "      \"commands\": \"cl.exe\"\n",
      "    }\n",
      "  },\n",
      "  \"Machine Information\": {\n",
      "    \"host\": {\n",
      "      \"cpu\": \"x86_64\",\n",
      "      \"family\": \"x86_64\",\n",
      "      \"endian\": \"little\",\n",
      "      \"system\": \"windows\"\n",
      "    },\n",
      "    \"build\": {\n",
      "      \"cpu\": \"x86_64\",\n",
      "      \"family\": \"x86_64\",\n",
      "      \"endian\": \"little\",\n",
      "      \"system\": \"windows\"\n",
      "    }\n",
      "  },\n",
      "  \"Build Dependencies\": {\n",
      "    \"blas\": {\n",
      "      \"name\": \"mkl-sdl\",\n",
      "      \"found\": true,\n",
      "      \"version\": \"2023.1\",\n",
      "      \"detection method\": \"pkgconfig\",\n",
      "      \"include directory\": \"C:/Users/user/miniconda3/Library/include\",\n",
      "      \"lib directory\": \"C:/Users/user/miniconda3/Library/lib\",\n",
      "      \"openblas configuration\": \"unknown\",\n",
      "      \"pc file directory\": \"C:\\\\b\\\\abs_7267ja_mqz\\\\croot\\\\numpy_and_numpy_base_1701295083047\\\\_h_env\\\\Library\\\\lib\\\\pkgconfig\"\n",
      "    },\n",
      "    \"lapack\": {\n",
      "      \"name\": \"dep1610466607184\",\n",
      "      \"found\": true,\n",
      "      \"version\": \"1.26.2\",\n",
      "      \"detection method\": \"internal\",\n",
      "      \"include directory\": \"unknown\",\n",
      "      \"lib directory\": \"unknown\",\n",
      "      \"openblas configuration\": \"unknown\",\n",
      "      \"pc file directory\": \"unknown\"\n",
      "    }\n",
      "  },\n",
      "  \"Python Information\": {\n",
      "    \"path\": \"C:\\\\b\\\\abs_7267ja_mqz\\\\croot\\\\numpy_and_numpy_base_1701295083047\\\\_h_env\\\\python.exe\",\n",
      "    \"version\": \"3.11\"\n",
      "  },\n",
      "  \"SIMD Extensions\": {\n",
      "    \"baseline\": [\n",
      "      \"SSE\",\n",
      "      \"SSE2\",\n",
      "      \"SSE3\"\n",
      "    ],\n",
      "    \"found\": [\n",
      "      \"SSSE3\",\n",
      "      \"SSE41\",\n",
      "      \"POPCNT\",\n",
      "      \"SSE42\",\n",
      "      \"AVX\",\n",
      "      \"F16C\",\n",
      "      \"FMA3\",\n",
      "      \"AVX2\"\n",
      "    ],\n",
      "    \"not found\": [\n",
      "      \"AVX512F\",\n",
      "      \"AVX512CD\",\n",
      "      \"AVX512_SKX\",\n",
      "      \"AVX512_CLX\",\n",
      "      \"AVX512_CNL\",\n",
      "      \"AVX512_ICL\"\n",
      "    ]\n",
      "  }\n",
      "}\n",
      "None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\user\\miniconda3\\Lib\\site-packages\\numpy\\__config__.py:149: UserWarning: Install `pyyaml` for better output\n",
      "  warnings.warn(\"Install `pyyaml` for better output\", stacklevel=1)\n"
     ]
    }
   ],
   "source": [
    "print(np.__version__)\n",
    "print(np.show_config())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3: Creating a null vector of size 10 (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "null_vector = np.zeros(10)\n",
    "print(null_vector)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4: Finding the memory size of any array (★☆☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "800\n"
     ]
    }
   ],
   "source": [
    "array = np.zeros((10, 10))\n",
    "print(array.size * array.itemsize) # This will give memory size in bytes\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5: Getting the documentation of the numpy add function from the command line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on ufunc:\n",
      "\n",
      "add = <ufunc 'add'>\n",
      "    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",
      "\n"
     ]
    }
   ],
   "source": [
    "#python -c \n",
    "import numpy as np; help(np.add)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6: Creating a null vector of size 10 but the fifth value which is 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "null_vector = np.zeros(10)\n",
    "null_vector[4] = 1\n",
    "print(null_vector)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 7: Create a vector with values ranging from 10 to 49"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33\n",
      " 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49]\n"
     ]
    }
   ],
   "source": [
    "vector = np.arange(10, 50)\n",
    "print(vector)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 8: Reversing a vector (first element becomes last)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9 8 7 6 5 4 3 2 1 0]\n"
     ]
    }
   ],
   "source": [
    "vector = np.arange(10)\n",
    "reversed_vector = vector[::-1]\n",
    "print(reversed_vector)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 9: Creating a 3x3 matrix with values ranging from 0 to 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "matrix = np.arange(9).reshape(3, 3)\n",
    "print(matrix)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 10: Finding indices of non-zero elements from [1,2,0,0,4,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([0, 1, 4], dtype=int64),)\n"
     ]
    }
   ],
   "source": [
    "array = np.array([1, 2, 0, 0, 4, 0])\n",
    "indices = np.nonzero(array)\n",
    "print(indices)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 11: Creating a 3x3 identity matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "identity_matrix = np.eye(3)\n",
    "print(identity_matrix)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 12: Creating a 3x3x3 array with random values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0.18830662 0.6555216  0.72687971]\n",
      "  [0.06816588 0.07800422 0.6552319 ]\n",
      "  [0.55516862 0.42205188 0.22236847]]\n",
      "\n",
      " [[0.59429823 0.94344599 0.88480333]\n",
      "  [0.23994484 0.33448252 0.98903677]\n",
      "  [0.68867091 0.34594632 0.21924752]]\n",
      "\n",
      " [[0.43702359 0.02281784 0.26990528]\n",
      "  [0.6359524  0.07819435 0.30753138]\n",
      "  [0.09264893 0.69237783 0.21760142]]]\n"
     ]
    }
   ],
   "source": [
    "random_array = np.random.random((3, 3, 3))\n",
    "print(random_array)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 13: Creating a 10x10 array with random values and find the minimum and maximum values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum: 0.02130465330823572\n",
      "Maximum: 0.9919295314713787\n"
     ]
    }
   ],
   "source": [
    "array = np.random.random((10, 10))\n",
    "min_value = np.min(array)\n",
    "max_value = np.max(array)\n",
    "print(\"Minimum:\", min_value)\n",
    "print(\"Maximum:\", max_value)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 14: Creating a random vector of size 30 and find the mean value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean: 0.504774811685754\n"
     ]
    }
   ],
   "source": [
    "vector = np.random.random(30)\n",
    "mean_value = np.mean(vector)\n",
    "print(\"Mean:\", mean_value)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 15: Creating a 2d array with 1 on the border and 0 inside"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1. 1. 1.]\n",
      " [1. 0. 0. 0. 1.]\n",
      " [1. 0. 0. 0. 1.]\n",
      " [1. 0. 0. 0. 1.]\n",
      " [1. 1. 1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "array = np.ones((5, 5))\n",
    "array[1:-1, 1:-1] = 0\n",
    "print(array)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 16: Adding a border (filled with 0's) around an existing array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0. 0.]\n",
      " [0. 1. 1. 1. 0.]\n",
      " [0. 1. 1. 1. 0.]\n",
      " [0. 1. 1. 1. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "array = np.ones((3, 3))\n",
    "array_with_border = np.pad(array, pad_width=1, mode='constant', constant_values=0)\n",
    "print(array_with_border)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 17: Result of the expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nan\n",
      "False\n",
      "False\n",
      "nan\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(0 * np.nan)        # nan\n",
    "print(np.nan == np.nan)  # False\n",
    "print(np.inf > np.nan)   # False\n",
    "print(np.nan - np.nan)   # nan\n",
    "print(np.nan in set([np.nan]))  # True\n",
    "print(0.3 == 3 * 0.1)    # False\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 18: Creating a 5x5 matrix with values 1,2,3,4 just below the diagonal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[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]]\n"
     ]
    }
   ],
   "source": [
    "matrix = np.diag(np.arange(1, 5), k=-1)\n",
    "print(matrix)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 19: Creating a 8x8 matrix and filling it with a checkerboard pattern"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0]\n",
      " [0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0]\n",
      " [0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0]\n",
      " [0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0]]\n"
     ]
    }
   ],
   "source": [
    "matrix = np.zeros((8, 8), dtype=int)\n",
    "matrix[1::2, ::2] = 1\n",
    "matrix[::2, 1::2] = 1\n",
    "print(matrix)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 20: Finding the index (x,y,z) of the 100th element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 5, 4)\n"
     ]
    }
   ],
   "source": [
    "index = np.unravel_index(100, (6, 7, 8))\n",
    "print(index)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 21: Creating a checkerboard 8x8 matrix using the tile function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0]\n",
      " [0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0]\n",
      " [0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0]\n",
      " [0 1 0 1 0 1 0 1]\n",
      " [1 0 1 0 1 0 1 0]]\n"
     ]
    }
   ],
   "source": [
    "matrix = np.tile([[0, 1], [1, 0]], (4, 4))\n",
    "print(matrix)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 22: Normalizing a 5x5 random matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.15511618 -1.12140828  0.74367879  0.14655349 -1.22824055]\n",
      " [ 1.32166681 -0.56954181  1.19538835  0.02314005 -1.49497263]\n",
      " [ 0.23459182 -0.33835006  1.24183257 -0.3531314  -1.39262955]\n",
      " [ 0.76086487 -1.26036807  0.97620621  0.69444288 -1.43949707]\n",
      " [ 0.47657521  1.33864682 -0.64168329 -1.37418611  0.90530477]]\n"
     ]
    }
   ],
   "source": [
    "matrix = np.random.random((5, 5))\n",
    "normalized_matrix = (matrix - np.mean(matrix)) / np.std(matrix)\n",
    "print(normalized_matrix)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 23: Creating a custom dtype that describes a color as four unsigned bytes (RGBA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('R', 'u1'), ('G', 'u1'), ('B', 'u1'), ('A', 'u1')]\n"
     ]
    }
   ],
   "source": [
    "color_dtype = np.dtype([('R', np.ubyte),\n",
    "                        ('G', np.ubyte),\n",
    "                        ('B', np.ubyte),\n",
    "                        ('A', np.ubyte)])\n",
    "print(color_dtype)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 24: Multiplying a 5x3 matrix by a 3x2 matrix (real matrix product) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix 1:\n",
      "[[0.72535804 0.85535865 0.85898885]\n",
      " [0.81520145 0.87913773 0.77208816]\n",
      " [0.94989075 0.3204214  0.95152493]\n",
      " [0.46493588 0.29379914 0.86664315]\n",
      " [0.71801218 0.68377089 0.3033788 ]]\n",
      "\n",
      "Matrix 2:\n",
      "[[0.74128839 0.65809048]\n",
      " [0.74293887 0.09495202]\n",
      " [0.73067445 0.09161702]]\n",
      "\n",
      "Matrix Product:\n",
      "[[1.80081988 0.63726725]\n",
      " [1.82159004 0.69068864]\n",
      " [1.63745145 0.7427146 ]\n",
      " [1.19616038 0.41326597]\n",
      " [1.2619252  0.56523707]]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "matrix1 = np.random.random((5, 3))\n",
    "matrix2 = np.random.random((3, 2))\n",
    "\n",
    "product = np.dot(matrix1, matrix2)\n",
    "\n",
    "print(\"Matrix 1:\")\n",
    "print(matrix1)\n",
    "\n",
    "print(\"\\nMatrix 2:\")\n",
    "print(matrix2)\n",
    "\n",
    "print(\"\\nMatrix Product:\")\n",
    "print(product)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 25: Negating all elements (in a 1D array) which are between 3 and 8, in place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1 -5 -4  9 -7  2 -6 -3 -8]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 5, 4, 9, 7, 2, 6, 3, 8])\n",
    "\n",
    "# Find the indices of elements between 3 and 8\n",
    "indices = np.where((arr >= 3) & (arr <= 8))\n",
    "\n",
    "# Negate the elements at the found indices\n",
    "arr[indices] = -arr[indices]\n",
    "\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 26: What is the output of the following script? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "print(sum(range(5),-1))\n",
    "\n",
    "from numpy import *\n",
    "\n",
    "print(sum(range(5),-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 27: Finding the legal expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Z**Z\\n2 << Z >> 2\\nZ <- Z\\n1j*Z\\nZ/1/1\\nZ<Z>Z '"
      ]
     },
     "execution_count": 288,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"Z**Z\n",
    "2 << Z >> 2\n",
    "Z <- Z\n",
    "1j*Z\n",
    "Z/1/1\n",
    "Z<Z>Z \"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 28: What are the result of the following expressions?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\user\\AppData\\Local\\Temp\\ipykernel_2104\\548293649.py:1: RuntimeWarning: invalid value encountered in divide\n",
      "  np.array(0) / np.array(0)\n",
      "C:\\Users\\user\\AppData\\Local\\Temp\\ipykernel_2104\\548293649.py:2: RuntimeWarning: divide by zero encountered in floor_divide\n",
      "  np.array(0) // np.array(0)\n",
      "C:\\Users\\user\\AppData\\Local\\Temp\\ipykernel_2104\\548293649.py:3: RuntimeWarning: invalid value encountered in cast\n",
      "  np.array([np.nan]).astype(int).astype(float)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([-2.14748365e+09])"
      ]
     },
     "execution_count": 289,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": {},
   "source": [
    "### 29: How to round away from zero a float array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-2.  3. -5.  6. -1.]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([-1.5, 2.3, -4.7, 5.9, -0.1])\n",
    "\n",
    "rounded_arr = np.ceil(np.abs(arr)) * np.copysign(1, arr)\n",
    "\n",
    "print(rounded_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 30: How to find common values between two arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4 5]\n"
     ]
    }
   ],
   "source": [
    "array1 = np.array([1, 2, 3, 4, 5])\n",
    "array2 = np.array([4, 5, 6, 7, 8])\n",
    "\n",
    "common_values = np.intersect1d(array1, array2)\n",
    "\n",
    "print(common_values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 31: Ignoring all numpy warnings (not recommended)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import warnings\n",
    "\n",
    "# Ignore all NumPy warnings\n",
    "warnings.filterwarnings('ignore', category=FutureWarning)\n",
    "\n",
    "# Reset warnings to default behavior\n",
    "warnings.resetwarnings()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 32: Is the following expressions true? \n",
    "\n",
    "np.sqrt(-1) == np.emath.sqrt(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 33: How to get the dates of yesterday, today and tomorrow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yesterday: 2024-02-21\n",
      "Today: 2024-02-22\n",
      "Tomorrow: 2024-02-23\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime, timedelta\n",
    "\n",
    "# Get today's date\n",
    "today = datetime.now().date()\n",
    "\n",
    "# Get yesterday's date\n",
    "yesterday = today - timedelta(days=1)\n",
    "\n",
    "# Get tomorrow's date\n",
    "tomorrow = today + timedelta(days=1)\n",
    "\n",
    "# Print the dates\n",
    "print(\"Yesterday:\", yesterday)\n",
    "print(\"Today:\", today)\n",
    "print(\"Tomorrow:\", tomorrow)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 34: Getting all the dates corresponding to the month of July 2016"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2016-07-01\n",
      "2016-07-02\n",
      "2016-07-03\n",
      "2016-07-04\n",
      "2016-07-05\n",
      "2016-07-06\n",
      "2016-07-07\n",
      "2016-07-08\n",
      "2016-07-09\n",
      "2016-07-10\n",
      "2016-07-11\n",
      "2016-07-12\n",
      "2016-07-13\n",
      "2016-07-14\n",
      "2016-07-15\n",
      "2016-07-16\n",
      "2016-07-17\n",
      "2016-07-18\n",
      "2016-07-19\n",
      "2016-07-20\n",
      "2016-07-21\n",
      "2016-07-22\n",
      "2016-07-23\n",
      "2016-07-24\n",
      "2016-07-25\n",
      "2016-07-26\n",
      "2016-07-27\n",
      "2016-07-28\n",
      "2016-07-29\n",
      "2016-07-30\n",
      "2016-07-31\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime, timedelta\n",
    "\n",
    "def get_dates_in_month(year, month):\n",
    "    start_date = datetime(year, month, 1).date()\n",
    "    next_month = start_date.replace(day=28) + timedelta(days=4)  # Adding 4 days to go beyond end of month\n",
    "    end_date = next_month - timedelta(days=next_month.day)\n",
    "\n",
    "    dates_in_month = []\n",
    "    current_date = start_date\n",
    "    while current_date <= end_date:\n",
    "        dates_in_month.append(current_date)\n",
    "        current_date += timedelta(days=1)\n",
    "\n",
    "    return dates_in_month\n",
    "\n",
    "# Getting all the dates in July 2016\n",
    "dates_july_2016 = get_dates_in_month(2016, 7)\n",
    "\n",
    "# Printing the dates\n",
    "for date in dates_july_2016:\n",
    "    print(date)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 35: How to compute ((A+B)*(-A/2)) in place (without copy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-2.5 -3.5 -4.5]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([1, 2, 3], dtype=float)\n",
    "B = np.array([4, 5, 6])\n",
    "\n",
    "# Computing ((A+B)*(-A/2)) in place\n",
    "np.add(A, B, out=A)\n",
    "np.negative(A, out=A)\n",
    "np.divide(A, 2, out=A)\n",
    "\n",
    "# Printing the result\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 36: Extracting the integer part of a random array of positive numbers using four different methods "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method 1 (np.floor()): [2. 2. 0. 2. 6.]\n",
      "Method 2 (np.trunc()): [2. 2. 0. 2. 6.]\n",
      "Method 3 (np.ceil() and subtraction): [2. 2. 0. 2. 6.]\n",
      "Method 4 (np.astype()): [2 2 0 2 6]\n"
     ]
    }
   ],
   "source": [
    "# Generating a random array of positive numbers\n",
    "arr = np.random.rand(5) * 10  # Adjust the size of the array as needed\n",
    "\n",
    "# Method 1: Using np.floor()\n",
    "int_part_1 = np.floor(arr)\n",
    "print(\"Method 1 (np.floor()):\", int_part_1)\n",
    "\n",
    "# Method 2: Using np.trunc()\n",
    "int_part_2 = np.trunc(arr)\n",
    "print(\"Method 2 (np.trunc()):\", int_part_2)\n",
    "\n",
    "# Method 3: Using np.ceil() and subtraction\n",
    "int_part_3 = arr - (arr % 1)\n",
    "print(\"Method 3 (np.ceil() and subtraction):\", int_part_3)\n",
    "\n",
    "# Method 4: Using np.astype()\n",
    "int_part_4 = arr.astype(int)\n",
    "print(\"Method 4 (np.astype()):\", int_part_4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 37: Creating a 5x5 matrix with row values ranging from 0 to 4 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[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]]\n"
     ]
    }
   ],
   "source": [
    "# Create a 1-dimensional array ranging from 0 to 4\n",
    "row_values = np.arange(5)\n",
    "\n",
    "# Create a 5x5 matrix by broadcasting the row values\n",
    "matrix = np.tile(row_values, (5, 1))\n",
    "\n",
    "# Print the matrix\n",
    "print(matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 38: A generator function that generates 10 integers and use it to build an array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "def integer_generator():\n",
    "    for i in range(10):\n",
    "        yield i\n",
    "\n",
    "# Create an array using the generator function\n",
    "array = np.fromiter(integer_generator(), dtype=int)\n",
    "\n",
    "# Print the array\n",
    "print(array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 39: Create a vector of size 10 with values ranging from 0 to 1, both excluded "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n"
     ]
    }
   ],
   "source": [
    "vector = np.linspace(0, 1, 10, endpoint=False)[1:]\n",
    "\n",
    "# Printing the vector\n",
    "print(vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 40: Create a random vector of size 10 and sort it (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.19332582 0.25688499 0.28601334 0.28891915 0.39015381 0.40021487\n",
      " 0.59036991 0.65817096 0.67233058 0.71761725]\n"
     ]
    }
   ],
   "source": [
    "# Creating a random vector of size 10\n",
    "vector = np.random.rand(10)\n",
    "\n",
    "# Sorting the vector\n",
    "sorted_vector = np.sort(vector)\n",
    "\n",
    "# Printing the sorted vector\n",
    "print(sorted_vector)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 41: How to sum a small array faster than np.sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "arr = [1, 2, 3, 4, 5]\n",
    "total = sum(arr)\n",
    "\n",
    "\n",
    "arr = [1.1, 2.2, 3.3, 4.4, 5.5]\n",
    "total = math.fsum(arr)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 42: Checking if two random array A and B,  are equal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 302,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "# Generate two random arrays A and B\n",
    "A = np.random.rand(5)\n",
    "B = np.random.rand(5)\n",
    "\n",
    "# Check if A and B are equal\n",
    "are_equal = np.array_equal(A, B)\n",
    "\n",
    "# Print the result\n",
    "print(are_equal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 43: Make an array immutable (read-only) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attempted modification of immutable array ignored.\n"
     ]
    }
   ],
   "source": [
    "mutable_array = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "# Making the array immutable\n",
    "immutable_array = mutable_array.copy()\n",
    "immutable_array.flags.writeable = False\n",
    "\n",
    "try:\n",
    "    # Trying to modify the immutable array\n",
    "    immutable_array[0] = 10  # This will raise a ValueError\n",
    "except ValueError as e:\n",
    "    print(\"Attempted modification of immutable array ignored.\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 44: Consider a random 10x2 matrix representing cartesian coordinates, convert them to polar coordinates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 304,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.95236481 0.13324849]\n",
      " [0.99488601 0.00806542]\n",
      " [0.69044966 0.67966087]\n",
      " [1.08613436 1.1394707 ]\n",
      " [0.4792617  0.88684847]\n",
      " [0.40418802 0.01333778]\n",
      " [0.90579016 1.09626709]\n",
      " [1.09268197 0.51625965]\n",
      " [1.02933691 1.00954683]\n",
      " [0.8380978  1.49602818]]\n"
     ]
    }
   ],
   "source": [
    "# Creating a random 10x2 matrix representing Cartesian coordinates\n",
    "cartesian_coords = np.random.rand(10, 2)\n",
    "\n",
    "# Convert Cartesian coordinates to polar coordinates\n",
    "x = cartesian_coords[:, 0]\n",
    "y = cartesian_coords[:, 1]\n",
    "r = np.hypot(x, y)\n",
    "theta = np.arctan2(y, x)\n",
    "\n",
    "# Stacking r and theta to form a 10x2 matrix representing polar coordinates\n",
    "polar_coords = np.column_stack((r, theta))\n",
    "\n",
    "# Printing the polar coordinates\n",
    "print(polar_coords)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 45: Creating a random vector of size 10 and replacing the maximum value by 0 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.         0.15694857 0.07553608 0.51028909 0.20327651 0.81809342\n",
      " 0.50993977 0.74338387 0.39105979 0.06039703]\n"
     ]
    }
   ],
   "source": [
    "# Creating a random vector of size 10\n",
    "vector = np.random.rand(10)\n",
    "\n",
    "# Finding the maximum value in the vector\n",
    "max_value = np.max(vector)\n",
    "\n",
    "# Replacing the maximum value with 0\n",
    "vector[vector == max_value] = 0\n",
    "\n",
    "# Printing the updated vector\n",
    "print(vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 46: Creating a structured array with `x` and `y` coordinates covering the [0,1]x[0,1] area "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 306,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0.  , 0.  ) (0.25, 0.  ) (0.5 , 0.  ) (0.75, 0.  ) (1.  , 0.  )\n",
      " (0.  , 0.25) (0.25, 0.25) (0.5 , 0.25) (0.75, 0.25) (1.  , 0.25)\n",
      " (0.  , 0.5 ) (0.25, 0.5 ) (0.5 , 0.5 ) (0.75, 0.5 ) (1.  , 0.5 )\n",
      " (0.  , 0.75) (0.25, 0.75) (0.5 , 0.75) (0.75, 0.75) (1.  , 0.75)\n",
      " (0.  , 1.  ) (0.25, 1.  ) (0.5 , 1.  ) (0.75, 1.  ) (1.  , 1.  )]\n"
     ]
    }
   ],
   "source": [
    "# Defining the number of points in each dimension\n",
    "num_points = 5\n",
    "\n",
    "# Creating a grid of x and y coordinates\n",
    "x_coords = np.linspace(0, 1, num_points)\n",
    "y_coords = np.linspace(0, 1, num_points)\n",
    "xx, yy = np.meshgrid(x_coords, y_coords)\n",
    "\n",
    "# Creating a structured array\n",
    "structured_array = np.zeros((num_points*num_points,), dtype=[('x', float), ('y', float)])\n",
    "structured_array['x'] = xx.flatten()\n",
    "structured_array['y'] = yy.flatten()\n",
    "\n",
    "# Printing the structured array\n",
    "print(structured_array)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 47: Given two arrays, X and Y, construct the Cauchy matrix C (Cij =1/(xi - yj)) (★★☆)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.33333333 -0.25       -0.2       ]\n",
      " [-0.5        -0.33333333 -0.25      ]\n",
      " [-1.         -0.5        -0.33333333]]\n"
     ]
    }
   ],
   "source": [
    "# Example arrays X and Y\n",
    "X = np.array([1, 2, 3])\n",
    "Y = np.array([4, 5, 6])\n",
    "\n",
    "# Computing the Cauchy matrix\n",
    "C = 1 / (X[:, np.newaxis] - Y)\n",
    "\n",
    "# Printing the Cauchy matrix\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 48: Printing the minimum and maximum representable value for each numpy scalar type "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int8: min=-128, max=127\n",
      "int16: min=-32768, max=32767\n",
      "int32: min=-2147483648, max=2147483647\n",
      "int64: min=-9223372036854775808, max=9223372036854775807\n",
      "uint8: min=0, max=255\n",
      "uint16: min=0, max=65535\n",
      "uint32: min=0, max=4294967295\n",
      "uint64: min=0, max=18446744073709551615\n",
      "float16: min=-65504.0, max=65504.0\n",
      "float32: min=-3.4028234663852886e+38, max=3.4028234663852886e+38\n",
      "float64: min=-1.7976931348623157e+308, max=1.7976931348623157e+308\n"
     ]
    }
   ],
   "source": [
    "# Integer scalar types\n",
    "integer_types = [np.int8, np.int16, np.int32, np.int64,\n",
    "                 np.uint8, np.uint16, np.uint32, np.uint64]\n",
    "\n",
    "for int_type in integer_types:\n",
    "    info = np.iinfo(int_type)\n",
    "    print(f\"{int_type.__name__}: min={info.min}, max={info.max}\")\n",
    "\n",
    "# Floating-point scalar types\n",
    "float_types = [np.float16, np.float32, np.float64]\n",
    "\n",
    "for float_type in float_types:\n",
    "    info = np.finfo(float_type)\n",
    "    print(f\"{float_type.__name__}: min={info.min}, max={info.max}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 49: Printing all the values of an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "# Creating an example array\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "# Printing all the values of the array\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 50: Find the closest value (to a given scalar) in a vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "# Example vector\n",
    "vector = np.array([1, 4, 7, 10])\n",
    "\n",
    "# Target scalar\n",
    "target = 6\n",
    "\n",
    "# Find the index of the closest value\n",
    "index = np.abs(vector - target).argmin()\n",
    "\n",
    "# Get the closest value\n",
    "closest_value = vector[index]\n",
    "\n",
    "# Print the closest value\n",
    "print(closest_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 51: Creating a structured array representing a position (x,y) and a color (r,g,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[((0., 0.), (0, 0, 0))]\n"
     ]
    }
   ],
   "source": [
    "structured_array = np.zeros(1, dtype=[('position', [('x', float), ('y', float)]),\n",
    "                                      ('color', [('r', int), ('g', int), ('b', int)])])\n",
    "print(structured_array)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 52: Finding the point by point distances for a random vector with shape (100,2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 312,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.         0.38926489 0.71370806 ... 0.96081331 0.3223847  0.78514282]\n",
      " [0.38926489 0.         0.32934086 ... 0.61689959 0.34333761 0.44795519]\n",
      " [0.71370806 0.32934086 0.         ... 0.33528569 0.6354355  0.36932274]\n",
      " ...\n",
      " [0.96081331 0.61689959 0.33528569 ... 0.         0.95136646 0.67051088]\n",
      " [0.3223847  0.34333761 0.6354355  ... 0.95136646 0.         0.55244754]\n",
      " [0.78514282 0.44795519 0.36932274 ... 0.67051088 0.55244754 0.        ]]\n"
     ]
    }
   ],
   "source": [
    "coordinates = np.random.random((100, 2))\n",
    "distances = np.sqrt(np.sum((coordinates[None, :] - coordinates[:, None])**2, axis=-1))\n",
    "print(distances)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 53: Converting a float (32 bits) array into an integer (32 bits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1063672638 1051297893 1057778687 1060565800 1062622304 1053990527\n",
      " 1037914735 1061150667 1046099457 1061660658]\n"
     ]
    }
   ],
   "source": [
    "float_array = np.random.rand(10).astype(np.float32)\n",
    "integer_array = float_array.view(np.int32)\n",
    "print(integer_array)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 55: Finding the equivalent of enumerate for numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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"
     ]
    }
   ],
   "source": [
    "array = np.arange(9).reshape(3,3)\n",
    "for index, value in np.ndenumerate(array):\n",
    "    print(index, value)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 56: Generating a generic 2D Gaussian-like array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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",
    "gaussian = np.exp(-( (d-mu)**2 / ( 2.0 * sigma**2 ) ) )\n",
    "print(gaussian)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 57: How to randomly place p elements in a 2D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 1.]\n",
      " [0. 0. 0. 1. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "p = 3\n",
    "array = np.zeros((5,5))\n",
    "np.put(array, np.random.choice(range(5*5), p, replace=False), 1)\n",
    "print(array)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 58: Subtracting the mean of each row of a matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.11455202 -0.00964929  0.12420132]\n",
      " [-0.10899378 -0.20600906  0.31500285]\n",
      " [ 0.29690196 -0.60586266  0.3089607 ]]\n"
     ]
    }
   ],
   "source": [
    "matrix = np.random.rand(3, 3)\n",
    "mean_subtracted_matrix = matrix - matrix.mean(axis=1, keepdims=True)\n",
    "print(mean_subtracted_matrix)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 59: Sorting an array by the nth column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4 1 1]\n",
      " [8 1 1]\n",
      " [6 7 1]]\n"
     ]
    }
   ],
   "source": [
    "array = np.random.randint(0, 10, (3,3))\n",
    "n = 1  # Sort by the second column\n",
    "sorted_array = array[array[:, n].argsort()]\n",
    "print(sorted_array)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 60: How to tell if a given 2D array has null columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "array = np.random.randint(0, 3, (3, 3))\n",
    "has_null_columns = np.any(np.all(array == 0, axis=0))\n",
    "print(has_null_columns)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 61: Finding the nearest value from a given value in an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5073788093503514\n"
     ]
    }
   ],
   "source": [
    "array = np.random.random(10)\n",
    "value = 0.5\n",
    "nearest_value = array[(np.abs(array - value)).argmin()]\n",
    "print(nearest_value)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 62: Considering two arrays with shape (1,3) and (3,1), computing their sum using an iterator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [1 2 3]\n",
      " [2 3 4]]\n"
     ]
    }
   ],
   "source": [
    "A = np.arange(3).reshape(1,3)\n",
    "B = np.arange(3).reshape(3,1)\n",
    "iterator = np.nditer([A,B,None])\n",
    "for x,y,z in iterator: \n",
    "    z[...] = x + y\n",
    "print(iterator.operands[2])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 63: Creating an array class that has a name attribute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 322,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MyArray\n"
     ]
    }
   ],
   "source": [
    "class NamedArray(np.ndarray):\n",
    "    def __new__(cls, array, name=\"No Name\"):\n",
    "        obj = np.asarray(array).view(cls)\n",
    "        obj.name = name\n",
    "        return obj\n",
    "\n",
    "    def __array_finalize__(self, obj):\n",
    "        if obj is None: return\n",
    "        self.info = getattr(obj, 'name', \"No Name\")\n",
    "\n",
    "array = NamedArray(np.arange(10), \"MyArray\")\n",
    "print(array.name)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 64: Adding 1 to each element indexed by a second vector "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6. 5. 1. 3. 1. 3. 3. 3. 1. 4.]\n"
     ]
    }
   ],
   "source": [
    "vector = np.ones(10)\n",
    "indices = np.random.randint(0, len(vector), 20)\n",
    "np.add.at(vector, indices, 1)\n",
    "print(vector)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 65: How to accumulate elements of a vector (X) to an array (F) based on an index list (I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 66: Considering a (w,h,3) image of (dtype=ubyte), and computing the number of unique colors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "256\n"
     ]
    }
   ],
   "source": [
    "w, h = 16, 16\n",
    "image = np.random.randint(0, 256, (w, h, 3)).astype(np.ubyte)\n",
    "unique_colors = len(np.unique(image.reshape(-1, 3), axis=0))\n",
    "print(unique_colors)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 67: Considering a four dimensions array, and getting sum over the last two axis at once"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 326,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[42 30 46]\n",
      " [42 46 32]\n",
      " [41 43 42]]\n"
     ]
    }
   ],
   "source": [
    "array = np.random.randint(0, 10, (3,3,3,3))\n",
    "sum_last_two_axes = array.sum(axis=(-2,-1))\n",
    "print(sum_last_two_axes)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 68. Computing means of subsets of D using a vector S of same size describing subset  indices "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.55056365 0.55811167 0.40182013 0.49928279 0.41615889 0.5143225\n",
      " 0.50936079 0.3943793  0.47658876 0.5624778 ]\n"
     ]
    }
   ],
   "source": [
    "D = np.random.uniform(0, 1, 100)\n",
    "S = np.random.randint(0, 10, 100)\n",
    "means = np.bincount(S, weights=D) / np.bincount(S)\n",
    "print(means)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 69: Getting the diagonal of a dot product "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 328,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[33 93 22]\n"
     ]
    }
   ],
   "source": [
    "A = np.random.randint(0, 10, (3,3))\n",
    "B = np.random.randint(0, 10, (3,3))\n",
    "diagonal_dot_product = np.diag(np.dot(A, B))\n",
    "print(diagonal_dot_product)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 70: Building a new vector with 3 consecutive zeros interleaved between each value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 329,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 0. 0. 0. 2. 0. 0. 0. 3. 0. 0. 0. 4. 0. 0. 0. 5.]\n"
     ]
    }
   ],
   "source": [
    "vector = np.array([1, 2, 3, 4, 5])\n",
    "zeros = 3\n",
    "new_vector = np.zeros(len(vector) + (len(vector)-1)*zeros)\n",
    "new_vector[::zeros+1] = vector\n",
    "print(new_vector)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 71: mulitplying an array of dimension (5,5,3) by an array with dimensions (5,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 330,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[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",
    "B = 2*np.ones((5,5))\n",
    "C = A * B[:,:,None]\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 72: Swapping two rows of an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 331,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3 4 5]\n",
      " [0 1 2]\n",
      " [6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "array = np.arange(9).reshape(3,3)\n",
    "array[[0,1]] = array[[1,0]]\n",
    "print(array)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1 16]\n",
      " [ 1 83]\n",
      " [ 2 23]\n",
      " [ 2 69]\n",
      " [ 4 38]\n",
      " [ 4 90]\n",
      " [16 83]\n",
      " [17 63]\n",
      " [17 97]\n",
      " [20 52]\n",
      " [20 79]\n",
      " [21 30]\n",
      " [21 68]\n",
      " [23 69]\n",
      " [25 38]\n",
      " [25 57]\n",
      " [30 68]\n",
      " [38 57]\n",
      " [38 90]\n",
      " [40 51]\n",
      " [40 98]\n",
      " [43 58]\n",
      " [43 92]\n",
      " [51 98]\n",
      " [52 79]\n",
      " [58 92]\n",
      " [63 97]\n",
      " [67 72]\n",
      " [67 83]\n",
      " [72 83]]\n"
     ]
    }
   ],
   "source": [
    "triangles = np.random.randint(0, 100, (10, 3))\n",
    "lines = np.roll(triangles.repeat(2, axis=1), -1, axis=1)\n",
    "lines = lines.reshape(len(lines)*3, 2)\n",
    "lines = np.sort(lines, axis=1)\n",
    "unique_lines = np.unique(lines, axis=0)\n",
    "print(unique_lines)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 74. Given a sorted array C that corresponds to a bincount, how to produce an array A such that np.bincount(A) == C? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 333,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 75: Computing averages using a sliding window over an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 334,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2. 3. 4. 5. 6. 7. 8. 9.]\n"
     ]
    }
   ],
   "source": [
    "def moving_average(a, n=3) :\n",
    "    ret = np.cumsum(a, dtype=float)\n",
    "    ret[n:] = ret[n:] - ret[:-n]\n",
    "    return ret[n - 1:] / n\n",
    "\n",
    "array = np.array([1,2,3,4,5,6,7,8,9,10])\n",
    "print(moving_average(array, n=3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 76: Building 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]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 335,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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": [
    "Z = np.arange(10)\n",
    "n = 3\n",
    "result = np.lib.stride_tricks.sliding_window_view(Z, (n,))\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 77: How to negate a boolean, or to change the sign of a float inplace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 1 1 0 1 0 0 0 1 1]\n",
      "[-0.51811393  0.2723329  -0.02739959 -0.28170368  0.92144975 -0.10014716\n",
      "  0.75110924 -0.715918   -0.852206   -0.5005306 ]\n"
     ]
    }
   ],
   "source": [
    "array = np.random.randint(0,2,10)\n",
    "np.logical_not(array, out=array)\n",
    "\n",
    "float_array = np.random.uniform(-1.0, 1.0, 10)\n",
    "np.negative(float_array, out=float_array)\n",
    "print(array)\n",
    "print(float_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 337,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.07539905  5.44163716 12.34703459  7.01846127  5.70911505  1.01921282\n",
      "  6.32496111 12.35739147  7.58529269  7.61033237]\n"
     ]
    }
   ],
   "source": [
    "def distance(P0, P1, p):\n",
    "    T = P1 - P0\n",
    "    L = (T**2).sum(axis=1)\n",
    "    U = -((P0[:,0]-p[...,0])*T[:,0] + (P0[:,1]-p[...,1])*T[:,1]) / L\n",
    "    U = U.reshape(len(U),1)\n",
    "    D = P0 + U*T - p\n",
    "    return np.sqrt((D**2).sum(axis=1))\n",
    "\n",
    "P0 = np.random.uniform(-10, 10, (10,2))\n",
    "P1 = np.random.uniform(-10,10,(10,2))\n",
    "p  = np.random.uniform(-10, 10, ( 1,2))\n",
    "\n",
    "print(distance(P0, P1, p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": 338,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 4.3668773   9.3538279  12.20784696  3.95609822  6.99951029 14.78431454\n",
      "  9.2231105  14.0034543   0.5721129   4.22082701]\n"
     ]
    }
   ],
   "source": [
    "def distance(P0, P1, P):\n",
    "    T = P1 - P0\n",
    "    L = (T**2).sum(axis=1)\n",
    "    U = -((P0[:,0]-P[...,0])*T[:,0] + (P0[:,1]-P[...,1])*T[:,1]) / L\n",
    "    U = U.reshape(len(U),1)\n",
    "    D = P0 + U*T - P\n",
    "    return np.sqrt((D**2).sum(axis=1))\n",
    "\n",
    "P0 = np.random.uniform(-10, 10, (10,2))\n",
    "P1 = np.random.uniform(-10,10,(10,2))\n",
    "P  = np.random.uniform(-10, 10, (10,2))\n",
    "\n",
    "print(distance(P0, P1, P))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 80: Function that extract a subpart with a fixed shape and centered on a given element (pad with a `fill` value when necessary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 339,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [0 7 1]\n",
      " [3 1 5]]\n"
     ]
    }
   ],
   "source": [
    "def extract_subpart(array, shape, position, fill=0):\n",
    "    R, C = shape\n",
    "    r, c = position\n",
    "    r_off, c_off = (R - 1) // 2, (C - 1) // 2\n",
    "    r_start, c_start = r - r_off, c - c_off\n",
    "    r_end, c_end = r + r_off + 1, c + c_off + 1\n",
    "    subpart = array[max(r_start, 0):r_end, max(c_start, 0):c_end]\n",
    "    result = np.full(shape, fill, dtype=array.dtype)\n",
    "    r_offset = max(-r_start, 0)\n",
    "    c_offset = max(-c_start, 0)\n",
    "    r_start = max(r_start, 0)\n",
    "    c_start = max(c_start, 0)\n",
    "    result[r_offset:r_offset + subpart.shape[0], c_offset:c_offset + subpart.shape[1]] = subpart\n",
    "    return result\n",
    "\n",
    "array = np.random.randint(0, 10, (10, 10))\n",
    "shape = (3, 3)\n",
    "position = (5, 5)\n",
    "subpart = extract_subpart(array, shape, position, fill=0)\n",
    "print(subpart)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 81: Generating an array of R = [[1,2,3,4], [2,3,4,5], [3,4,5,6], ..., [11,12,13,14]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 340,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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": [
    "Z = np.arange (1, 15)\n",
    "window_size = 4\n",
    "R = np.lib.stride_tricks.sliding_window_view(Z, (window_size,))\n",
    "\n",
    "print(R)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 82: Computing a Matrix rank"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 341,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "matrix = np.random.uniform(0, 1, (4, 4))\n",
    "rank = np.linalg.matrix_rank(matrix)\n",
    "\n",
    "print(rank)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 83: Finding the most frequent value in an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 342,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "array = np.random.randint(0, 10, 20)\n",
    "\n",
    "most_frequent_value = np.bincount(array).argmax()\n",
    "\n",
    "print(most_frequent_value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 84: Extracting all the contiguous 3x3 blocks from a random 10x10 matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 343,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[[0 3 5]\n",
      "   [7 9 8]\n",
      "   [2 4 6]]\n",
      "\n",
      "  [[3 5 7]\n",
      "   [9 8 0]\n",
      "   [4 6 3]]\n",
      "\n",
      "  [[5 7 7]\n",
      "   [8 0 7]\n",
      "   [6 3 7]]\n",
      "\n",
      "  [[7 7 3]\n",
      "   [0 7 3]\n",
      "   [3 7 2]]\n",
      "\n",
      "  [[7 3 9]\n",
      "   [7 3 4]\n",
      "   [7 2 4]]\n",
      "\n",
      "  [[3 9 7]\n",
      "   [3 4 9]\n",
      "   [2 4 6]]\n",
      "\n",
      "  [[9 7 4]\n",
      "   [4 9 8]\n",
      "   [4 6 1]]\n",
      "\n",
      "  [[7 4 2]\n",
      "   [9 8 9]\n",
      "   [6 1 7]]]\n",
      "\n",
      "\n",
      " [[[7 9 8]\n",
      "   [2 4 6]\n",
      "   [4 4 2]]\n",
      "\n",
      "  [[9 8 0]\n",
      "   [4 6 3]\n",
      "   [4 2 1]]\n",
      "\n",
      "  [[8 0 7]\n",
      "   [6 3 7]\n",
      "   [2 1 2]]\n",
      "\n",
      "  [[0 7 3]\n",
      "   [3 7 2]\n",
      "   [1 2 0]]\n",
      "\n",
      "  [[7 3 4]\n",
      "   [7 2 4]\n",
      "   [2 0 3]]\n",
      "\n",
      "  [[3 4 9]\n",
      "   [2 4 6]\n",
      "   [0 3 3]]\n",
      "\n",
      "  [[4 9 8]\n",
      "   [4 6 1]\n",
      "   [3 3 6]]\n",
      "\n",
      "  [[9 8 9]\n",
      "   [6 1 7]\n",
      "   [3 6 3]]]\n",
      "\n",
      "\n",
      " [[[2 4 6]\n",
      "   [4 4 2]\n",
      "   [6 5 2]]\n",
      "\n",
      "  [[4 6 3]\n",
      "   [4 2 1]\n",
      "   [5 2 0]]\n",
      "\n",
      "  [[6 3 7]\n",
      "   [2 1 2]\n",
      "   [2 0 7]]\n",
      "\n",
      "  [[3 7 2]\n",
      "   [1 2 0]\n",
      "   [0 7 3]]\n",
      "\n",
      "  [[7 2 4]\n",
      "   [2 0 3]\n",
      "   [7 3 0]]\n",
      "\n",
      "  [[2 4 6]\n",
      "   [0 3 3]\n",
      "   [3 0 9]]\n",
      "\n",
      "  [[4 6 1]\n",
      "   [3 3 6]\n",
      "   [0 9 5]]\n",
      "\n",
      "  [[6 1 7]\n",
      "   [3 6 3]\n",
      "   [9 5 1]]]\n",
      "\n",
      "\n",
      " [[[4 4 2]\n",
      "   [6 5 2]\n",
      "   [4 4 0]]\n",
      "\n",
      "  [[4 2 1]\n",
      "   [5 2 0]\n",
      "   [4 0 0]]\n",
      "\n",
      "  [[2 1 2]\n",
      "   [2 0 7]\n",
      "   [0 0 5]]\n",
      "\n",
      "  [[1 2 0]\n",
      "   [0 7 3]\n",
      "   [0 5 3]]\n",
      "\n",
      "  [[2 0 3]\n",
      "   [7 3 0]\n",
      "   [5 3 8]]\n",
      "\n",
      "  [[0 3 3]\n",
      "   [3 0 9]\n",
      "   [3 8 2]]\n",
      "\n",
      "  [[3 3 6]\n",
      "   [0 9 5]\n",
      "   [8 2 6]]\n",
      "\n",
      "  [[3 6 3]\n",
      "   [9 5 1]\n",
      "   [2 6 2]]]\n",
      "\n",
      "\n",
      " [[[6 5 2]\n",
      "   [4 4 0]\n",
      "   [6 5 6]]\n",
      "\n",
      "  [[5 2 0]\n",
      "   [4 0 0]\n",
      "   [5 6 9]]\n",
      "\n",
      "  [[2 0 7]\n",
      "   [0 0 5]\n",
      "   [6 9 5]]\n",
      "\n",
      "  [[0 7 3]\n",
      "   [0 5 3]\n",
      "   [9 5 9]]\n",
      "\n",
      "  [[7 3 0]\n",
      "   [5 3 8]\n",
      "   [5 9 9]]\n",
      "\n",
      "  [[3 0 9]\n",
      "   [3 8 2]\n",
      "   [9 9 4]]\n",
      "\n",
      "  [[0 9 5]\n",
      "   [8 2 6]\n",
      "   [9 4 3]]\n",
      "\n",
      "  [[9 5 1]\n",
      "   [2 6 2]\n",
      "   [4 3 7]]]\n",
      "\n",
      "\n",
      " [[[4 4 0]\n",
      "   [6 5 6]\n",
      "   [9 9 5]]\n",
      "\n",
      "  [[4 0 0]\n",
      "   [5 6 9]\n",
      "   [9 5 8]]\n",
      "\n",
      "  [[0 0 5]\n",
      "   [6 9 5]\n",
      "   [5 8 8]]\n",
      "\n",
      "  [[0 5 3]\n",
      "   [9 5 9]\n",
      "   [8 8 8]]\n",
      "\n",
      "  [[5 3 8]\n",
      "   [5 9 9]\n",
      "   [8 8 4]]\n",
      "\n",
      "  [[3 8 2]\n",
      "   [9 9 4]\n",
      "   [8 4 2]]\n",
      "\n",
      "  [[8 2 6]\n",
      "   [9 4 3]\n",
      "   [4 2 8]]\n",
      "\n",
      "  [[2 6 2]\n",
      "   [4 3 7]\n",
      "   [2 8 3]]]\n",
      "\n",
      "\n",
      " [[[6 5 6]\n",
      "   [9 9 5]\n",
      "   [7 2 0]]\n",
      "\n",
      "  [[5 6 9]\n",
      "   [9 5 8]\n",
      "   [2 0 2]]\n",
      "\n",
      "  [[6 9 5]\n",
      "   [5 8 8]\n",
      "   [0 2 7]]\n",
      "\n",
      "  [[9 5 9]\n",
      "   [8 8 8]\n",
      "   [2 7 9]]\n",
      "\n",
      "  [[5 9 9]\n",
      "   [8 8 4]\n",
      "   [7 9 9]]\n",
      "\n",
      "  [[9 9 4]\n",
      "   [8 4 2]\n",
      "   [9 9 6]]\n",
      "\n",
      "  [[9 4 3]\n",
      "   [4 2 8]\n",
      "   [9 6 2]]\n",
      "\n",
      "  [[4 3 7]\n",
      "   [2 8 3]\n",
      "   [6 2 8]]]\n",
      "\n",
      "\n",
      " [[[9 9 5]\n",
      "   [7 2 0]\n",
      "   [8 7 7]]\n",
      "\n",
      "  [[9 5 8]\n",
      "   [2 0 2]\n",
      "   [7 7 6]]\n",
      "\n",
      "  [[5 8 8]\n",
      "   [0 2 7]\n",
      "   [7 6 2]]\n",
      "\n",
      "  [[8 8 8]\n",
      "   [2 7 9]\n",
      "   [6 2 5]]\n",
      "\n",
      "  [[8 8 4]\n",
      "   [7 9 9]\n",
      "   [2 5 8]]\n",
      "\n",
      "  [[8 4 2]\n",
      "   [9 9 6]\n",
      "   [5 8 0]]\n",
      "\n",
      "  [[4 2 8]\n",
      "   [9 6 2]\n",
      "   [8 0 7]]\n",
      "\n",
      "  [[2 8 3]\n",
      "   [6 2 8]\n",
      "   [0 7 7]]]]\n"
     ]
    }
   ],
   "source": [
    "matrix = np.random.randint(0, 10, (10, 10))\n",
    "\n",
    "blocks = np.lib.stride_tricks.sliding_window_view(matrix, (3, 3))\n",
    "\n",
    "print(blocks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 85: Creating a 2D array subclass such that Z[i,j] == Z[j,i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Define a new class `SymmetricArray` that inherits from `np.ndarray`\n",
    "class SymmetricArray(np.ndarray):\n",
    "    # Override the __new__ method to properly initialize the array\n",
    "    def __new__(cls, input_array):\n",
    "        # Convert the input array to a numpy array and create a view of the class\n",
    "        obj = np.asarray(input_array).view(cls)\n",
    "        return obj\n",
    "\n",
    "    # Override the __setitem__ method to set values in a symmetric manner\n",
    "    def __setitem__(self, index, value):\n",
    "        # Extract row and column indices from the index tuple\n",
    "        i, j = index\n",
    "        # Set the value at index (i, j)\n",
    "        super().__setitem__((i, j), value)\n",
    "        # Set the corresponding symmetric value at index (j, i)\n",
    "        super().__setitem__((j, i), value)\n",
    "\n",
    "    # Override the __getitem__ method to get values\n",
    "    def __getitem__(self, index):\n",
    "        # Extract row and column indices from the index tuple\n",
    "        i, j = index\n",
    "        # Return the value at index (i, j)\n",
    "        return super().__getitem__((i, j))\n",
    "\n",
    "# Create an instance of the SymmetricArray class initialized with zeros\n",
    "Z = SymmetricArray(np.zeros((5, 5)))\n",
    "\n",
    "# Set a value at index (0, 1) (which also sets the symmetric value at index (1, 0))\n",
    "Z[0, 1] = 2\n",
    "\n",
    "# Print the value at index (1, 0) (which is symmetrically set with the above operation)\n",
    "print(Z[1, 0])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 86: How to compute the sum of of the p matrix products at once (result has shape (n,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 345,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3.25211714]\n",
      " [4.96841331]\n",
      " [4.22065699]]\n"
     ]
    }
   ],
   "source": [
    "p = 5\n",
    "n =3\n",
    "matrices = np.random.rand(p, n, n)\n",
    "vectors = np.random.rand(p, n, 1)\n",
    "result = np.sum(matrices @ vectors, axis=0)\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 87: How to get the block-sum (block size is 4x4)?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 346,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[100  78  63  82]\n",
      " [ 54  84  96  88]\n",
      " [ 94  79  74  76]\n",
      " [ 85  98  66  75]]\n"
     ]
    }
   ],
   "source": [
    "array = np.random.randint(1, 10, (16, 16))\n",
    "block_size = 4\n",
    "block_sum = np.add.reduceat(np.add.reduceat(array, np.arange(0, array.shape[0], block_size), axis=0),\n",
    "                            np.arange(0, array.shape[1], block_size), axis=1)\n",
    "print(block_sum)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 88: How to implement the Game of Life using numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 347,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 1 1 1 0 0 0 0]\n",
      " [0 0 1 0 0 0 1 0 0 0]\n",
      " [1 1 0 0 0 0 0 0 0 0]\n",
      " [0 0 1 0 0 0 0 0 0 0]\n",
      " [0 0 0 0 0 0 0 0 0 1]\n",
      " [0 1 1 0 0 0 0 0 0 1]\n",
      " [0 0 0 1 1 1 0 0 0 0]\n",
      " [1 0 0 0 0 0 0 0 0 0]\n",
      " [0 0 0 0 0 0 0 0 1 0]\n",
      " [0 1 0 0 0 0 0 0 1 0]]\n",
      "[[0 0 1 0 0 0 0 0 0 0]\n",
      " [0 1 0 1 1 1 0 0 0 0]\n",
      " [0 1 1 0 0 0 0 0 0 0]\n",
      " [1 1 0 0 0 0 0 0 0 0]\n",
      " [1 1 1 0 0 0 0 0 0 0]\n",
      " [1 0 0 1 1 0 0 0 0 0]\n",
      " [1 1 1 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 1]\n",
      " [0 0 0 0 1 0 0 0 0 0]]\n",
      "[[0 0 0 0 0 1 0 0 0 0]\n",
      " [0 1 0 1 0 0 0 0 0 0]\n",
      " [0 0 0 1 1 0 0 0 0 0]\n",
      " [0 0 0 0 0 0 0 0 0 0]\n",
      " [0 0 1 1 0 0 0 0 0 1]\n",
      " [0 0 0 1 0 0 0 0 0 1]\n",
      " [0 1 0 0 1 0 0 0 0 0]\n",
      " [1 1 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 1 0 0 0 0 0 0 0]\n",
      " [0 0 1 0 0 0 0 0 0 0]\n",
      " [0 0 1 0 1 0 0 0 0 0]\n",
      " [0 0 0 0 0 0 0 0 0 0]\n",
      " [1 0 0 1 1 0 0 0 0 0]\n",
      " [0 0 1 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 0 0 0 0 0]\n",
      " [0 0 0 1 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",
      " [0 0 0 1 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",
      " [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",
      " [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",
      " [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",
      " [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",
      " [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"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\user\\AppData\\Local\\Temp\\ipykernel_2104\\2112032432.py:2: DeprecationWarning: Calling np.sum(generator) is deprecated, and in the future will give a different result. Use np.sum(np.fromiter(generator)) or the python sum builtin instead.\n",
      "  neighbor_count = sum(np.roll(np.roll(board, i, 0), j, 1)\n"
     ]
    }
   ],
   "source": [
    "def iterate_life(board):\n",
    "    neighbor_count = sum(np.roll(np.roll(board, i, 0), j, 1)\n",
    "                         for i in (-1, 0, 1) for j in (-1, 0, 1)\n",
    "                         if (i != 0 or j != 0))\n",
    "    new_board = (neighbor_count == 3) | (board & neighbor_count == 2)\n",
    "    return new_board.astype(int)\n",
    "\n",
    "board = np.random.randint(0, 2, (10, 10))\n",
    "for _ in range(10):\n",
    "    board = iterate_life(board)\n",
    "    print(board)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 89: How to get the n largest values of an array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 348,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[83 97 99]\n"
     ]
    }
   ],
   "source": [
    "array = np.random.randint(0, 100, 10)\n",
    "n_largest_values = np.sort(array)[-n:]\n",
    "print(n_largest_values)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 90: Given an arbitrary number of vectors, build the cartesian product (every combinations of every item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 349,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 4 6]\n",
      " [1 5 6]\n",
      " [2 4 6]\n",
      " [2 5 6]\n",
      " [3 4 6]\n",
      " [3 5 6]\n",
      " [1 4 7]\n",
      " [1 5 7]\n",
      " [2 4 7]\n",
      " [2 5 7]\n",
      " [3 4 7]\n",
      " [3 5 7]]\n"
     ]
    }
   ],
   "source": [
    "arrays = [np.array([1, 2, 3]), np.array([4, 5]), np.array([6, 7])]\n",
    "cartesian_product = np.array(np.meshgrid(*arrays)).T.reshape(-1, len(arrays))\n",
    "print(cartesian_product)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 91: How to create a record array from a regular array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 350,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Alice', 25, 4. ) ('Bob', 30, 4.5)]\n"
     ]
    }
   ],
   "source": [
    "array = np.array([(\"Alice\", 25, 4.0), (\"Bob\", 30, 4.5)], dtype=[(\"name\", 'U10'), (\"age\", int), (\"score\", float)])\n",
    "print(array)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 92: Computing Z vector to the power of 3 using 3 different methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 351,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.18807541 0.86939214 0.3816707  ... 0.00700328 0.27879828 0.08775999]\n",
      "[0.18807541 0.86939214 0.3816707  ... 0.00700328 0.27879828 0.08775999]\n",
      "[0.18807541 0.86939214 0.3816707  ... 0.00700328 0.27879828 0.08775999]\n"
     ]
    }
   ],
   "source": [
    "Z = np.random.rand(1000000)\n",
    "# Method 1:\n",
    "print(np.power(Z, 3))\n",
    "# Method 2:\n",
    "print(Z ** 3)\n",
    "# Method 3:\n",
    "print(np.einsum('i,i,i->i', Z, Z, Z))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 93: How to find rows of A that contain elements of each row of B regardless of the order of the elements in B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 352,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "# Consider two arrays A and B\n",
    "A = np.random.randint(0, 10, (8, 3))\n",
    "B = np.random.randint(0, 10, (2, 2))\n",
    "\n",
    "# Check if any row of A contains all elements of each row of B\n",
    "contains_all_elements = np.all(np.isin(A[:, :, None], B), axis=(1, 2))\n",
    "rows_with_elements_of_B = A[contains_all_elements]\n",
    "\n",
    "print(rows_with_elements_of_B)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 94: Considering a 10x3 matrix, extract rows with unequal values (e.g. [2,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 353,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4 1 4]\n",
      " [2 0 3]\n",
      " [0 3 4]\n",
      " [4 3 1]\n",
      " [3 0 0]\n",
      " [2 0 0]\n",
      " [0 4 0]\n",
      " [2 2 0]\n",
      " [3 3 4]\n",
      " [1 0 1]]\n"
     ]
    }
   ],
   "source": [
    "# Consider a 10x3 matrix\n",
    "matrix = np.random.randint(0, 5, (10, 3))\n",
    "\n",
    "# Finding rows with unequal values\n",
    "unequal_rows = matrix[~np.all(matrix[:, 1:] == matrix[:, :-1], axis=1)]\n",
    "\n",
    "print(unequal_rows)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 95: Converting a vector of ints into a matrix binary representation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 354,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]\n",
      " [0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]\n",
      " [1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]\n",
      " [0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]\n",
      " [1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "# Consider a vector of integers\n",
    "vector = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "# Converting each integer to its binary representation\n",
    "binary_matrix = ((vector[:, None] & (1 << np.arange(32))) > 0).astype(int)\n",
    "\n",
    "print(binary_matrix)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 96: Given a two dimensional array, how to extract unique rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 355,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 4 2]\n",
      " [2 3 1]\n",
      " [3 1 3]\n",
      " [3 3 1]\n",
      " [4 3 1]]\n"
     ]
    }
   ],
   "source": [
    "# Consider a two-dimensional array\n",
    "array = np.random.randint(0, 5, (5, 3))\n",
    "\n",
    "# Convert the array to a set of tuples and then back to an array to remove duplicates\n",
    "unique_rows = np.unique(array, axis=0)\n",
    "\n",
    "print(unique_rows)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 97: Considering 2 vectors A & B, write the einsum equivalent of inner, outer, sum, and mul function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 356,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inner product: 32\n",
      "Outer product: [[ 4  5  6]\n",
      " [ 8 10 12]\n",
      " [12 15 18]]\n",
      "Sum: 6\n",
      "Element-wise multiplication: [ 4 10 18]\n"
     ]
    }
   ],
   "source": [
    "# Consider two vectors A and B\n",
    "A = np.array([1, 2, 3])\n",
    "B = np.array([4, 5, 6])\n",
    "\n",
    "# Equivalent of inner product\n",
    "inner_product = np.einsum('i,i->', A, B)\n",
    "\n",
    "# Equivalent of outer product\n",
    "outer_product = np.einsum('i,j->ij', A, B)\n",
    "\n",
    "# Equivalent of sum\n",
    "sum_result = np.einsum('i->', A)\n",
    "\n",
    "# Equivalent of element-wise multiplication\n",
    "mul_result = np.einsum('i,i->i', A, B)\n",
    "\n",
    "print(\"Inner product:\", inner_product)\n",
    "print(\"Outer product:\", outer_product)\n",
    "print(\"Sum:\", sum_result)\n",
    "print(\"Element-wise multiplication:\", mul_result)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 98: Considering a path described by two vectors (X,Y), how to sample it using equidistant samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 357,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.         0.33253311 0.66506622 0.99759934 1.41266556 1.82833195\n",
      " 2.24399834 2.65966473 3.05022075] [0.         0.66506622 1.33013245 1.99519867 2.41266556 2.82833195\n",
      " 3.24399834 3.65966473 4.05022075]\n"
     ]
    }
   ],
   "source": [
    "# Consider two vectors X and Y describing a path\n",
    "X = np.array([0, 1, 3, 6, 10])\n",
    "Y = np.array([0, 2, 4, 7, 11])\n",
    "\n",
    "# Calculate the total length of the path\n",
    "distance = np.sqrt(np.diff(X)**2 + np.diff(Y)**2).sum()\n",
    "\n",
    "# Determine the number of equidistant samples\n",
    "num_samples = 10\n",
    "step = distance / (num_samples - 1)\n",
    "\n",
    "# Interpolate the path to obtain equidistant samples\n",
    "t = np.arange(0, distance, step)\n",
    "X_samples = np.interp(t, np.cumsum(np.hstack([[0], np.diff(X)**2 + np.diff(Y)**2])), X)\n",
    "Y_samples = np.interp(t, np.cumsum(np.hstack([[0], np.diff(X)**2 + np.diff(Y)**2])), Y)\n",
    "\n",
    "print(X_samples, Y_samples)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 358,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 2]\n",
      " [0 3 2]\n",
      " [5 0 0]\n",
      " [1 1 3]]\n"
     ]
    }
   ],
   "source": [
    "# Consider an integer n and a 2D array X\n",
    "n = 5\n",
    "X = np.array([[1, 2, 2], [0, 3, 2], [5, 0, 0], [1, 1, 3]])\n",
    "\n",
    "# Select rows from X which sum to n and contain only integers\n",
    "selected_rows = X[(X.sum(axis=1) == n) & np.all(X.astype(int) == X, axis=1)]\n",
    "\n",
    "print(selected_rows)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 359,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.09570512  0.02830994]\n"
     ]
    }
   ],
   "source": [
    "# Consider a 1D array X\n",
    "X = np.random.normal(0, 1, 1000)\n",
    "\n",
    "# Number of bootstrap samples\n",
    "N = 1000\n",
    "\n",
    "# Resample the elements of X with replacement N times\n",
    "bootstrap_samples = np.random.choice(X, size=(len(X), N), replace=True)\n",
    "\n",
    "# Compute the mean of each sample\n",
    "bootstrap_means = np.mean(bootstrap_samples, axis=0)\n",
    "\n",
    "# Compute 95% confidence intervals\n",
    "confidence_intervals = np.percentile(bootstrap_means, [2.5, 97.5])\n",
    "\n",
    "print(confidence_intervals)\n"
   ]
  }
 ],
 "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}