NumPy_basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy Basics\n",
    "\n",
    "NumPy is a more like arrays as in C but powered with fast and advanced algorithms in the background.\n",
    "\n",
    "It includes:\n",
    "- Basic functions for matrices (transpose, multiplication, ranking, ect.)\n",
    "- Various random number generators\n",
    "- Doing linear algerba related calculations\n",
    "\n",
    "To start with NumPy we need:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some example functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1.0\n",
      "1.4142135623730951\n",
      "2.0000000000000004\n"
     ]
    }
   ],
   "source": [
    "print(np.cos(np.pi))\n",
    "print(np.sqrt(2))\n",
    "print(np.sqrt(2)**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining arrays\n",
    "### From lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 5]\n",
      "\n",
      "[[ 1  3  5]\n",
      " [ 7  9 11]\n",
      " [13 15 17]]\n"
     ]
    }
   ],
   "source": [
    "vec1 = np.array([1, 3, 5])\n",
    "print (vec1)\n",
    "print()\n",
    "mat1 = np.array([[1,3,5], [7, 9, 11], [13, 15, 17]])\n",
    "print (mat1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transpose a matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  7 13]\n",
      " [ 3  9 15]\n",
      " [ 5 11 17]]\n"
     ]
    }
   ],
   "source": [
    "print(mat1.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other ways to define arrays\n",
    "### Range and Linear spaced range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7 8 9]\n",
      "[0 2 4 6 8]\n",
      "[  0.           9.09090909  18.18181818  27.27272727  36.36363636\n",
      "  45.45454545  54.54545455  63.63636364  72.72727273  81.81818182\n",
      "  90.90909091 100.        ]\n"
     ]
    }
   ],
   "source": [
    "vec2 = np.arange(1, 10)\n",
    "vec3 = np.arange(0, 10, 2)\n",
    "vec4 = np.linspace(0, 100, 12)\n",
    "print (vec2, vec3, vec4, sep='\\n')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "print(len(vec4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conversion from vector to matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  0.           9.09090909  18.18181818  27.27272727]\n",
      " [ 36.36363636  45.45454545  54.54545455  63.63636364]\n",
      " [ 72.72727273  81.81818182  90.90909091 100.        ]]\n"
     ]
    }
   ],
   "source": [
    "mat2 = vec4.reshape(3,4) # See: rows x columns is the order of the parameters\n",
    "print(mat2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generation of random numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    }
   ],
   "source": [
    "from numpy import random\n",
    "rvec1 = random.randint(20)\n",
    "print(rvec1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pydoc import doc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python Library Documentation: built-in function randint\n",
      "\n",
      "randint(...) method of numpy.random.mtrand.RandomState instance\n",
      "    randint(low, high=None, size=None, dtype=int)\n",
      "    \n",
      "    Return random integers from `low` (inclusive) to `high` (exclusive).\n",
      "    \n",
      "    Return random integers from the \"discrete uniform\" distribution of\n",
      "    the specified dtype in the \"half-open\" interval [`low`, `high`). If\n",
      "    `high` is None (the default), then results are from [0, `low`).\n",
      "    \n",
      "    .. note::\n",
      "        New code should use the ``integers`` method of a ``default_rng()``\n",
      "        instance instead; see `random-quick-start`.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    low : int or array-like of ints\n",
      "        Lowest (signed) integers to be drawn from the distribution (unless\n",
      "        ``high=None``, in which case this parameter is one above the\n",
      "        *highest* such integer).\n",
      "    high : int or array-like of ints, optional\n",
      "        If provided, one above the largest (signed) integer to be drawn\n",
      "        from the distribution (see above for behavior if ``high=None``).\n",
      "        If array-like, must contain integer values\n",
      "    size : int or tuple of ints, optional\n",
      "        Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n",
      "        ``m * n * k`` samples are drawn.  Default is None, in which case a\n",
      "        single value is returned.\n",
      "    dtype : dtype, optional\n",
      "        Desired dtype of the result. Byteorder must be native.\n",
      "        The default value is int.\n",
      "    \n",
      "        .. versionadded:: 1.11.0\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    out : int or ndarray of ints\n",
      "        `size`-shaped array of random integers from the appropriate\n",
      "        distribution, or a single such random int if `size` not provided.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    random_integers : similar to `randint`, only for the closed\n",
      "        interval [`low`, `high`], and 1 is the lowest value if `high` is\n",
      "        omitted.\n",
      "    Generator.integers: which should be used for new code.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.random.randint(2, size=10)\n",
      "    array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0]) # random\n",
      "    >>> np.random.randint(1, size=10)\n",
      "    array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n",
      "    \n",
      "    Generate a 2 x 4 array of ints between 0 and 4, inclusive:\n",
      "    \n",
      "    >>> np.random.randint(5, size=(2, 4))\n",
      "    array([[4, 0, 2, 1], # random\n",
      "           [3, 2, 2, 0]])\n",
      "    \n",
      "    Generate a 1 x 3 array with 3 different upper bounds\n",
      "    \n",
      "    >>> np.random.randint(1, [3, 5, 10])\n",
      "    array([2, 2, 9]) # random\n",
      "    \n",
      "    Generate a 1 by 3 array with 3 different lower bounds\n",
      "    \n",
      "    >>> np.random.randint([1, 5, 7], 10)\n",
      "    array([9, 8, 7]) # random\n",
      "    \n",
      "    Generate a 2 by 4 array using broadcasting with dtype of uint8\n",
      "    \n",
      "    >>> np.random.randint([1, 3, 5, 7], [[10], [20]], dtype=np.uint8)\n",
      "    array([[ 8,  6,  9,  7], # random\n",
      "           [ 1, 16,  9, 12]], dtype=uint8)\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(doc(random.randint))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[23 22 32]\n",
      " [51  5  6]]\n"
     ]
    }
   ],
   "source": [
    "rvec2 = random.randint(1.0, 100, size=(2,3), dtype=np.uint8)\n",
    "print(rvec2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Trivial matrices\n",
    "- Zeroes\n",
    "- Ones\n",
    "- Identity matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]]\n",
      "\n",
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]]\n",
      "\n",
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "z = np.zeros([2,3])\n",
    "o = np.ones([2,3])\n",
    "e = np.eye(3)\n",
    "print(z, o, e, sep='\\n\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}