Module5_PythonComputing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CrashPy\n",
    "\n",
    "**Module 5 : Computing with Python** \n",
    "\n",
    "Python is a fun language to learn, and really easy to pick up even if you are new to programming. In fact, quite often, Python is easier to pick up if you do not have any programming experience whatsoever. Python is high level programming language, targeted at students and professionals from diverse backgrounds.\n",
    "\n",
    "In this module, we will cover\n",
    "- File Handling\n",
    "- Numeric Computation\n",
    "- Image Handling\n",
    "- Symbolic Computation\n",
    "\n",
    "**License Declaration** : Following the lead from the inspirations for this material, and the *spirit* of Python education and development, all modules of this work are licensed under the Creative Commons Attribution 3.0 Unported License. To view a copy of this license, visit http://creativecommons.org/licenses/by/3.0/.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Files in Python\n",
    "\n",
    "Handling files is a pre-requisite for a number of Python computing applications. Hence we learn that first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Handling Files in Python\n",
    "file = open(\"poemRobertFrost.txt\", \"r\", encoding = \"utf8\")\n",
    "print(\"Name of File : \", file.name)\n",
    "print(\"File Closed? : \", file.closed)\n",
    "print(\"Opening Mode : \", file.mode)\n",
    "file.close()  # closing a file is crucial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reading Lines from a File\n",
    "with open(\"poemRobertFrost.txt\", \"r\", encoding = \"utf8\") as file:\n",
    "    line = file.readline()\n",
    "    line_count = 1\n",
    "    while line:\n",
    "        print(\"Line {0:2d} \\t {1:s}\".format(line_count, line.strip()))\n",
    "        line = file.readline()\n",
    "        line_count += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reading Lines from a File\n",
    "with open(\"poemRobertFrost.txt\", \"r\", encoding = \"utf8\") as file:\n",
    "    for line_count, line in enumerate(file):\n",
    "        print(\"Line {0:2d} \\t {1:s}\".format(line_count, line.strip()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reading Words from a File\n",
    "with open(\"poemRobertFrost.txt\", \"r\", encoding = \"utf8\") as file:\n",
    "    for line_count, line in enumerate(file):\n",
    "        print(\"Line {0:2d} \\t\".format(line_count), end = \"\")\n",
    "        for word in line.split(\" \"):\n",
    "            print(word.strip(), end = \"\\t\")\n",
    "        print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quick Tasks\n",
    "\n",
    "- Create a Frequency Table or Dictionary `{Words : Count}` for all distinct words in the file `poemRobertFrost.txt`.    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Numeric Computation\n",
    "\n",
    "`NumPy` is one of the most versatile modules in Python. It helps in Numeric and Scientific computations. This library does not come with the standard Python installation. If you want to use `NumPy`, install the package using your Python package manager of choice. I prefer Conda : `conda install numpy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import NumPy\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an Array\n",
    "x = np.array([1, 2, 3, 4, 5, 6])\n",
    "print(x, \"is of type\", x.dtype, \"and of size\", x.size, \"with shape\", x.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reshape Matrix\n",
    "x = np.array([1, 2, 3, 4, 5, 6])\n",
    "x = x.reshape(2,3)\n",
    "print(x, \"is of type\", x.dtype, \"and of size\", x.size, \"with shape\", x.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Array Arithmetic\n",
    "x = np.arange(1,7).reshape(2,3)\n",
    "y = np.random.random((2,3))\n",
    "\n",
    "print(x)\n",
    "print()\n",
    "print(y)\n",
    "print()\n",
    "print(x + y)\n",
    "print()\n",
    "print(x - y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Array Product\n",
    "x = np.arange(1,7).reshape(2,3)\n",
    "y = np.random.random((3,2))\n",
    "\n",
    "print(x)\n",
    "print()\n",
    "print(y)\n",
    "print()\n",
    "print(x.dot(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quick Tasks\n",
    "\n",
    "- Find the Eigenvalues and Eigenvectors of the `3 x 3` random matrix `np.random.random((3,3))`.      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Image Handling\n",
    "\n",
    "`NumPy` and `MatPlotLib` libraries are capable of providing basic functionalities of image handling and processing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import MatPlotLib and Read Image\n",
    "import matplotlib.pyplot as plt\n",
    "po = plt.imread(\"poDumpling.jpg\")\n",
    "print(type(po), \"of size\", po.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Show the Image\n",
    "fig, axs = plt.subplots(nrows=1, ncols=1, figsize=(8,8))\n",
    "axs.imshow(po)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Slice the Image\n",
    "fig, axs = plt.subplots(nrows=1, ncols=1, figsize=(8,8))\n",
    "axs.imshow(po[64:256,192:384,:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert the image to its Grayscale version, with conversion formula `0.2989 R + 0.5870 G + 0.1140 B`.      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Covnert to Grayscale\n",
    "po_gray = np.dot(po[:,:,0:3], [0.299, 0.587, 0.114])\n",
    "\n",
    "fig, axs = plt.subplots(nrows=1, ncols=2, figsize=(16,8))\n",
    "axs[0].imshow(po)\n",
    "axs[1].imshow(po_gray, cmap=plt.get_cmap('gray'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quick Tasks\n",
    "\n",
    "- Find the Singular Value Decomposition (SVD) of the `512 x 512` grayscale image `po_gray`.      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Symbolic Computation\n",
    "\n",
    "`SymPy` is the Python library for Symbolic Computation. You may install the `SymPy` module using Conda : `conda install sympy`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import SymPy\n",
    "import sympy as sp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create Symbol and Expression\n",
    "x = sp.symbols('x')\n",
    "ep = sp.sin(x) * sp.exp(x)\n",
    "print(ep, \"is of type\", type(ep))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Symbolic Derivative\n",
    "df = sp.diff(ep, x)\n",
    "print(\"The derivative of\", ep, \"is\", df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Symbolic Integration\n",
    "it = sp.integrate(df, x)\n",
    "print(\"The integral of\", df, \"is\", it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Differential Equation\n",
    "t = sp.symbols('t')\n",
    "y = sp.Function('y')\n",
    "sp.dsolve(sp.Eq(y(t).diff(t, t) - y(t), sp.exp(t)), y(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pretty Print in LaTeX\n",
    "z = sp.dsolve(sp.Eq(y(t).diff(t, t) - y(t), sp.exp(t)), y(t))\n",
    "print(sp.latex(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quick Tasks\n",
    "\n",
    "- Find a Function (or a family of functions) whose derivative is a constant multiple of the Function itself.     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}