linear_algebra_outlook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Arrays 2. Array indexing 3. Datatypes 4. Array math 5. Broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.array([1, 2, 3])   # Create a rank 1 array\n",
    "print(type(a))            # Prints dtype\n",
    "print(a.shape)            \n",
    "print(a[0], a[1], a[2])   \n",
    "a[0] = 5                  # Change an element of the array\n",
    "print(a)                  \n",
    "\n",
    "b = np.array([[1,2,3],[4,5,6]])    # Create a rank 2 array\n",
    "print(b.shape)                     \n",
    "print(b[0, 0], b[0, 1], b[1, 0])   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.zeros((2,2))   # Create an array of all zeros\n",
    "print(a)              \n",
    "\n",
    "b = np.ones((1,2))    # Create an array of all ones\n",
    "print(b)             \n",
    "\n",
    "c = np.full((2,2), 7)  # Create a constant array\n",
    "print(c)               \n",
    "\n",
    "d = np.eye(2)         # Create a 2x2 identity matrix\n",
    "print(d)\n",
    "\n",
    "e = np.random.random((2,2))  # Create an array filled with random values\n",
    "print(e)\n",
    "print(e.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Array indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
    "b = a[:2, 1:3]\n",
    "print b\n",
    "print(a[0, 1])\n",
    "b[0, 0] = 77\n",
    "print(a[0, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
    "row_r1 = a[1, :]\n",
    "row_r2 = a[1:2, :]\n",
    "print(row_r1, row_r1.shape)\n",
    "print(row_r2, row_r2.shape)\n",
    "col_r1 = a[:, 1]\n",
    "col_r2 = a[:, 1:2]\n",
    "print(col_r1, col_r1.shape)\n",
    "print(col_r2, col_r2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
    "\n",
    "print a\n",
    "# An example of integer array indexing.\n",
    "# The returned array will have shape (3,) and\n",
    "print(a[[0, 1, 2], [0, 1, 0]])  # Prints \"[1 4 5]\"\n",
    "\n",
    "# The above example of integer array indexing is equivalent to this:\n",
    "print(np.array([a[0, 0], a[1, 1], a[2, 0]]))  # Prints \"[1 4 5]\"\n",
    "\n",
    "# When using integer array indexing, you can reuse the same\n",
    "# element from the source array:\n",
    "print(a[[0, 0], [1, 1]])  # Prints \"[2 2]\"\n",
    "\n",
    "# Equivalent to the previous integer array indexing example\n",
    "print(np.array([a[0, 1], a[0, 1]]))  # Prints \"[2 2]\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Create a new array from which we will select elements\n",
    "a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "\n",
    "print(a)  # prints \"array([[ 1,  2,  3],\n",
    "          #                [ 4,  5,  6],\n",
    "          #                [ 7,  8,  9],\n",
    "          #                [10, 11, 12]])\"\n",
    "\n",
    "# Create an array of indices\n",
    "b = np.array([0, 2, 0, 1])\n",
    "\n",
    "# Select one element from each row of a using the indices in b\n",
    "print(a[np.arange(4), b])  # Prints \"[ 1  6  7 11]\"\n",
    "\n",
    "# Mutate one element from each row of a using the indices in b\n",
    "a[np.arange(4), b] += 10\n",
    "\n",
    "print(a)  # prints \"array([[11,  2,  3],\n",
    "          #                [ 4,  5, 16],\n",
    "          #                [17,  8,  9],\n",
    "          #                [10, 21, 12]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
    "bool_idx = (a > 2)\n",
    "print(bool_idx)\n",
    "print(a[bool_idx])\n",
    "print(a[a > 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Datatypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = np.array([1, 2])\n",
    "print x\n",
    "print(x.dtype)\n",
    "x = np.array([1.0, 2.0])\n",
    "print(x.dtype) \n",
    "x = np.array([1, 2], dtype=np.float64)\n",
    "print x\n",
    "print(x.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Array math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
    "y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
    "print(x + y)\n",
    "print(np.add(x, y))\n",
    "print(x - y)\n",
    "print(np.subtract(x, y))\n",
    "print(x * y)\n",
    "print(np.multiply(x, y))\n",
    "print(x / y)\n",
    "print(np.divide(x, y))\n",
    "print(np.sqrt(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = np.array([[1,2],[3,4]])\n",
    "y = np.array([[5,6],[7,8]])\n",
    "\n",
    "v = np.array([9,10])\n",
    "w = np.array([11, 12])\n",
    "\n",
    "print(v.dot(w))\n",
    "print(np.dot(v, w))\n",
    "\n",
    "print(x.dot(v))\n",
    "print(np.dot(x, v))\n",
    "\n",
    "print(x.dot(y))\n",
    "print(np.dot(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = np.array([[1,2],[3,4]])\n",
    "\n",
    "print(np.sum(x))\n",
    "print(np.sum(x, axis=0))\n",
    "print(np.sum(x, axis=1))  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "x = np.array([[1,2], [3,4]])\n",
    "print(x)\n",
    "print(x.T)\n",
    "v = np.array([1,2,3])\n",
    "print(v)\n",
    "print(v.T)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Broadcasting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n",
    "# We will add the vector v to each row of the matrix x,\n",
    "# storing the result in the matrix y\n",
    "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "v = np.array([1, 0, 1])\n",
    "y = np.empty_like(x)   # Create an empty matrix with the same shape as x\n",
    "\n",
    "# Add the vector v to each row of the matrix x with an explicit loop\n",
    "for i in range(4):\n",
    "    y[i, :] = x[i, :] + v\n",
    "\n",
    "# Now y is the following\n",
    "# [[ 2  2  4]\n",
    "#  [ 5  5  7]\n",
    "#  [ 8  8 10]\n",
    "#  [11 11 13]]\n",
    "print(y)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# We will add the vector v to each row of the matrix x,\n",
    "# storing the result in the matrix y\n",
    "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "v = np.array([1, 0, 1])\n",
    "vv = np.tile(v, (4, 1))   # Stack 4 copies of v on top of each other\n",
    "print(vv)                 # Prints \"[[1 0 1]\n",
    "                          #          [1 0 1]\n",
    "                          #          [1 0 1]\n",
    "                          #          [1 0 1]]\"\n",
    "y = x + vv  # Add x and vv elementwise\n",
    "print(y)  # Prints \"[[ 2  2  4\n",
    "          #          [ 5  5  7]\n",
    "          #          [ 8  8 10]\n",
    "          #          [11 11 13]]\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# We will add the vector v to each row of the matrix x,\n",
    "# storing the result in the matrix y\n",
    "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "v = np.array([1, 0, 1])\n",
    "y = x + v  # Add v to each row of x using broadcasting\n",
    "print(y)  # Prints \"[[ 2  2  4]\n",
    "          #          [ 5  5  7]\n",
    "          #          [ 8  8 10]\n",
    "          #          [11 11 13]]\""
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}