NumPy Tut.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Following NumPy Tutorial Course"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy Arrays : Creating Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "# Provides beautiful plots of numerous type that are either\n",
    "# static, animated and/or interactive\n",
    "import matplotlib.pylab as plt\n",
    "from numpy import random\n",
    "\n",
    "# A Python list\n",
    "list_1 = [1, 2, 3, 4, 5]\n",
    "\n",
    "# Create NumPy 1 dimensional (a axis) array list object of type byte (-128 to 127)\n",
    "# A N-dimensional array is a usyally fixed size multidimensional\n",
    "# array that contains items of the same type. \n",
    "np_arr_1 = np.array(list_1, dtype=np.int8)\n",
    "np_arr_1\n",
    "# Create multidimenional list\n",
    "m_list_1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
    "\n",
    "# Create NumPy multidimensional (2 axis) array without defining type\n",
    "np_m_arr_1 = np.array(m_list_1)\n",
    "\n",
    "# You can also create arrays by defining the start value,\n",
    "# stop value (up to but not include stop) and step amount\n",
    "np.arange(1, 10)\n",
    "\n",
    "# With floats define start, end and number of values\n",
    "np.linspace(0, 5, 7)\n",
    "\n",
    "# You can create a 3 item array of zeroes\n",
    "np.zeros(4)\n",
    "\n",
    "# You can create multidimensional arrays of zeroes by passing\n",
    "# a tuple with the 1st value being rows and the 2nd columns\n",
    "np.zeros((2, 3))\n",
    "\n",
    "# Create array of 1s\n",
    "np.ones((2, 3))\n",
    "\n",
    "# Get number of items in the array\n",
    "np_m_arr_1.size\n",
    "\n",
    "# Create array with defined values\n",
    "np_arr_2 = np.array([1, 2, 3, 4, 5, 6])\n",
    "\n",
    "# Get type for array\n",
    "np_arr_2.dtype\n",
    "\n",
    "# Data Types\n",
    "# Boolean : np.bool_\n",
    "# Char : np.byte\n",
    "# Short : np.short\n",
    "# Integer : np.short\n",
    "# Long : np.int_\n",
    "# Float : np.single & np.float32\n",
    "# Double : np.double & np.float64\n",
    "# np.int8 : -128 to 127\n",
    "# np.int16 : -32768 to 32767\n",
    "# np.int32 : -2147483648 to 2147483647\n",
    "# np.int64 : -9223372036854775808 to 9223372036854775807\n",
    "\n",
    "# Create random 5 value 1D array from 10 to 50\n",
    "np.random.randint(10, 50, 5)\n",
    "# Create random matrix 2x3 with values between 10 and 50\n",
    "np.random.randint(10, 50, size=(2, 3))\n",
    "\n",
    "# Get help with a function\n",
    "np.random.randint?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing and Indexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10  2  3]\n",
      " [10  5  6]\n",
      " [10  8  9]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 2,  3,  5,  6,  8,  9, 10])"
      ]
     },
     "execution_count": 222,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Change value at index\n",
    "# np_m_arr_1[0,0] = 2\n",
    "# np_m_arr_1.itemset((0,1), 1)\n",
    "np_m_arr_1\n",
    "# Get size of array\n",
    "np_m_arr_1.shape\n",
    "# Get value by index\n",
    "np_m_arr_1[0,1]\n",
    "np_m_arr_1.item(0,1)\n",
    "\n",
    "# Get specific indices\n",
    "np.take(np_m_arr_1, [0, 3, 6])\n",
    "# Replace provided index values with new values\n",
    "np.put(np_m_arr_1, [0, 3, 6], [10, 10, 10])\n",
    "print(np_m_arr_1)\n",
    "\n",
    "# Start at 1st through 5th with 2 step\n",
    "np_arr_1[:5:2]\n",
    "# Get 2nd value from each row\n",
    "np_m_arr_1[:,1]\n",
    "# Flip Array\n",
    "np_arr_1[::-1]\n",
    "\n",
    "# Get evens\n",
    "evens = np_m_arr_1[np_m_arr_1%2==0]\n",
    "evens\n",
    "\n",
    "# Get values > 5\n",
    "np_m_arr_1[np_m_arr_1 > 5]\n",
    "# 5 < value < 9\n",
    "np_m_arr_1[(np_m_arr_1 > 5) & (np_m_arr_1 < 9)]\n",
    "# 5 < value or value = 10\n",
    "np_m_arr_1[(np_m_arr_1 > 5) | (np_m_arr_1 == 10)]\n",
    "\n",
    "# Find uniques\n",
    "np.unique(np_m_arr_1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reshaping Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  3  5 10 10]\n",
      " [ 0  6  8  9 10]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 0,  3,  5,  9, 10],\n",
       "       [ 2,  6,  8, 10, 10]])"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reshape array to 1 by 9\n",
    "np_m_arr_1.reshape((1, 9))\n",
    "np_m_arr_1\n",
    "# Reshape array to 2 by 5 (Items are either lost or 0s added)\n",
    "np_m_arr_1.resize((2,5))\n",
    "np_m_arr_1\n",
    "# Transpose axes\n",
    "np_m_arr_1.transpose()\n",
    "# Swap axes \n",
    "np_m_arr_1.swapaxes(0,1)\n",
    "# Flatten in order\n",
    "np_m_arr_1.flatten()\n",
    "# Flatten in column order\n",
    "np_m_arr_1.flatten('F')\n",
    "# Sort rows\n",
    "np_m_arr_1.sort(axis=1)\n",
    "print(np_m_arr_1)\n",
    "# Sort columns\n",
    "np_m_arr_1.sort(axis=0)\n",
    "np_m_arr_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stacking & Splitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ss_arr_1\n",
      " [[5 9]\n",
      " [3 8]]\n",
      "ss_arr_2\n",
      " [[7 1]\n",
      " [5 6]]\n",
      "ss_arr_3\n",
      " [[5 9]]\n",
      "ss_arr_4\n",
      " [[7 1]]\n",
      "ss_arr_5\n",
      " [[6 7 1 4 1 1 2 2 1 5]\n",
      " [8 3 9 7 6 0 1 9 9 2]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[array([[6, 7],\n",
       "        [8, 3]]),\n",
       " array([[1, 4],\n",
       "        [9, 7]]),\n",
       " array([[1, 1, 2, 2, 1, 5],\n",
       "        [6, 0, 1, 9, 9, 2]])]"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generate random arrays\n",
    "ss_arr_1 = np.random.randint(10, size=(2, 2))\n",
    "print(\"ss_arr_1\\n\", ss_arr_1)\n",
    "ss_arr_2 = np.random.randint(10, size=(2, 2))\n",
    "print(\"ss_arr_2\\n\", ss_arr_2)\n",
    "\n",
    "# Stack arr_2 under arr_1\n",
    "np.vstack((ss_arr_1, ss_arr_2))\n",
    "# Stack horizontally\n",
    "np.hstack((ss_arr_1, ss_arr_2))\n",
    "\n",
    "# Delete 2nd row on each array\n",
    "ss_arr_3 = np.delete(ss_arr_1, 1, 0)\n",
    "ss_arr_4 = np.delete(ss_arr_2, 1, 0)\n",
    "print(\"ss_arr_3\\n\", ss_arr_3)\n",
    "print(\"ss_arr_4\\n\", ss_arr_4)\n",
    "# Combine arrays\n",
    "np.column_stack((ss_arr_3, ss_arr_4))\n",
    "# Stack in a 2D array\n",
    "np.row_stack((ss_arr_3, ss_arr_4))\n",
    "\n",
    "# Generate 2x10 array\n",
    "ss_arr_5 = np.random.randint(10, size=(2, 10))\n",
    "print(\"ss_arr_5\\n\", ss_arr_5)\n",
    "# Split into 5 arrays taking from both arrays in multidimensional array\n",
    "np.hsplit(ss_arr_5, 5)\n",
    "# Split after 2nd & 4th column\n",
    "np.hsplit(ss_arr_5, (2, 4))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copying"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cp_arr_1\n",
      " [[2 4]\n",
      " [6 4]]\n",
      "cp_arr_2\n",
      " [[2 4]\n",
      " [6 4]]\n",
      "cp_arr_3\n",
      " [[2 4]\n",
      " [6 4]]\n",
      "cp_arr_3\n",
      " [2 6 4 4]\n",
      "cp_arr_1\n",
      " [[2 4]\n",
      " [6 4]]\n"
     ]
    }
   ],
   "source": [
    "cp_arr_1 = np.random.randint(10, size=(2, 2))\n",
    "# Both variables point at the same array\n",
    "cp_arr_2 = cp_arr_1\n",
    "# Change value\n",
    "cp_arr_1[0,0] = 2\n",
    "print(\"cp_arr_1\\n\", cp_arr_1)\n",
    "print(\"cp_arr_2\\n\", cp_arr_2)\n",
    "# Create a view of data where changes don't effect original\n",
    "cp_arr_3 = cp_arr_1.view()\n",
    "print(\"cp_arr_3\\n\", cp_arr_3)\n",
    "cp_arr_3 = cp_arr_3.flatten('F')\n",
    "print(\"cp_arr_3\\n\", cp_arr_3)\n",
    "print(\"cp_arr_1\\n\", cp_arr_1)\n",
    "# Copy and create new array\n",
    "cp_arr_4 = cp_arr_1.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[67  7 80]\n",
      " [67 56 17]]\n",
      "arr_3 [1 2 3 4]\n",
      "arr_4 [2 4 6 8]\n",
      "arr_5\n",
      " [[1 2]\n",
      " [3 4]]\n",
      "arr_6\n",
      " [[2 4]\n",
      " [6 9]]\n",
      "arr_7\n",
      " [[22 65 89]\n",
      " [62 17 79]\n",
      " [74 92 46]\n",
      " [94 69 48]\n",
      " [48 81 43]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([94, 92, 89])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_3 = np.array([1, 2, 3, 4])\n",
    "arr_4 = np.array([2, 4, 6, 8])\n",
    "# Add values\n",
    "arr_3 + arr_4\n",
    "# Subtract\n",
    "arr_3 - arr_4\n",
    "# Multiply\n",
    "arr_3 * arr_4\n",
    "# Divide\n",
    "arr_3 / arr_4\n",
    "# Random 4 digit 1D array between 0 to 100\n",
    "arr_5 = random.randint(100, size=(4))\n",
    "arr_5\n",
    "# Random 2 by 3 digit 2D array between 0 to 100\n",
    "arr_6 = random.randint(100, size=(2, 3))\n",
    "arr_6\n",
    "# 4 random floats\n",
    "random.rand(4)\n",
    "# Get random value from an array\n",
    "random.choice(arr_3)\n",
    "\n",
    "# Sum of values in array\n",
    "arr_3.sum()\n",
    "# Sum columns\n",
    "print(arr_6)\n",
    "arr_6.sum(axis=0)\n",
    "# Cumulative sum of rows\n",
    "arr_6.cumsum(axis=1)\n",
    "\n",
    "# Min of each row\n",
    "arr_6.min(axis=1)\n",
    "# Max of each column\n",
    "arr_6.max(axis=0)\n",
    "\n",
    "print(\"arr_3\", arr_3)\n",
    "print(\"arr_4\", arr_4)\n",
    "# Add individual numbers to array\n",
    "np.add(arr_3, 5)\n",
    "# Add arrays\n",
    "np.add(arr_3, arr_4)\n",
    "# Subtract\n",
    "np.subtract(arr_3, arr_4)\n",
    "# Multiply\n",
    "np.multiply(arr_3, arr_4)\n",
    "# Divide\n",
    "np.divide(arr_3, arr_4)\n",
    "\n",
    "arr_5 = np.array([[1, 2], [3, 4]])\n",
    "arr_6 = np.array([[2, 4], [6, 9]])\n",
    "print(\"arr_5\\n\", arr_5)\n",
    "print(\"arr_6\\n\", arr_6)\n",
    "# Divides elements in 1st array by 2nd array and returns remainder\n",
    "np.remainder(arr_6, arr_5)\n",
    "\n",
    "# Return values in 1st array to powers defined in 2nd array\n",
    "np.power(arr_6, arr_5)\n",
    "# Square root\n",
    "np.sqrt(arr_3)\n",
    "# Cube root\n",
    "np.cbrt(arr_3)\n",
    "# Absolute value of every element\n",
    "np.absolute([-1, -2])\n",
    "# Exponential of all elements in array\n",
    "np.exp(arr_3)\n",
    "# log functions\n",
    "np.log(arr_3)\n",
    "np.log2(arr_3)\n",
    "np.log10(arr_3)\n",
    "# Greatest common divisor\n",
    "np.gcd.reduce([9, 12, 15])\n",
    "# Lowest common multiple\n",
    "np.lcm.reduce([9, 12, 15])\n",
    "\n",
    "# Round down\n",
    "np.floor([1.2, 2.5])\n",
    "# Round up\n",
    "np.ceil([1.2, 2.5])\n",
    "\n",
    "# Can receive 6 values and square them\n",
    "sq_arr = np.arange(6)**2\n",
    "sq_arr[arr_3]\n",
    "\n",
    "arr_7 = random.randint(100, size=(5, 3))\n",
    "print(\"arr_7\\n\", arr_7)\n",
    "# Get index for max value per column\n",
    "mc_index = arr_7.argmax(axis=0)\n",
    "mc_index\n",
    "# Get numbers corresponding to indexes\n",
    "max_nums = arr_7[mc_index]\n",
    "arr_7[mc_index, range(arr_7.shape[1])]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading from Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([], dtype=float64),\n",
       " array([ 37., 292.]),\n",
       " array([ 40., 228.]),\n",
       " array([ 49., 324.]),\n",
       " array([ 61., 376.]),\n",
       " array([ 72., 440.]),\n",
       " array([ 79., 496.]),\n",
       " array([ 83., 536.]),\n",
       " array([ 81., 556.]),\n",
       " array([ 75., 496.]),\n",
       " array([ 64., 412.]),\n",
       " array([ 53., 324.]),\n",
       " array([ 40., 320.])]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Pandas is used to manipulate tabular data and more\n",
    "import pandas as pd\n",
    "# Import using NumPy\n",
    "from numpy import genfromtxt\n",
    "\n",
    "# Read table of data from CSV file and convert to Numpy array\n",
    "ic_sales = pd.read_csv('icecreamsales.csv').to_numpy()\n",
    "ic_sales\n",
    "\n",
    "# Read data using NumPy\n",
    "ic_sales_2 = genfromtxt('icecreamsales.csv', delimiter=',')\n",
    "# Remove NANs\n",
    "ic_sales_2 = [row[~np.isnan(row)] for row in ic_sales_2]\n",
    "ic_sales_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Statistics Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ic_sales\n",
      " [[ 37 292]\n",
      " [ 40 228]\n",
      " [ 49 324]\n",
      " [ 61 376]\n",
      " [ 72 440]\n",
      " [ 79 496]\n",
      " [ 83 536]\n",
      " [ 81 556]\n",
      " [ 75 496]\n",
      " [ 64 412]\n",
      " [ 53 324]\n",
      " [ 40 320]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([256.01208459, 273.8864465 , 327.50953224, 399.00697989,\n",
       "       464.54630691, 506.25315137, 530.08563392, 518.16939265,\n",
       "       482.42066882, 416.88134181, 351.34201479, 273.8864465 ])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Array 1 - 5\n",
    "sarr_1 = np.arange(1, 6)\n",
    "np.mean(sarr_1)\n",
    "np.median(sarr_1)\n",
    "np.average(sarr_1)\n",
    "np.std([4, 6, 3, 5, 2]) # Standard Deviation\n",
    "np.var([4, 6, 3, 5, 2]) # Variance\n",
    "# Also nanmedian, nanmean, nanstd, nanvar\n",
    "\n",
    "print(\"ic_sales\\n\", ic_sales)\n",
    "# Get the 50th percentile of the data\n",
    "np.percentile(ic_sales, 50, axis=0)\n",
    "# Get 1st column\n",
    "ic_sales[:,0]\n",
    "\n",
    "# Correlation coefficient : Measure of correlation between data\n",
    "# Closer to 1 the more the data is correlated\n",
    "np.corrcoef(ic_sales[:,0], ic_sales[:,1])\n",
    "\n",
    "# Calculating Regression line\n",
    "# Σ(x-x̅)*(y-ȳ) / Σ(x-x̅)2\n",
    "temp_mean = np.mean(ic_sales[:,0])\n",
    "sales_mean = np.mean(ic_sales[:,1])\n",
    "numerator = np.sum(((ic_sales[:,0] - temp_mean)*(ic_sales[:,1] - sales_mean)))\n",
    "denominator = np.sum(np.square(ic_sales[:,0] - temp_mean))\n",
    "slope = numerator/denominator\n",
    "# Calculate y intercept\n",
    "y_i = sales_mean - slope * temp_mean\n",
    "y_i\n",
    "reg_arr = ic_sales[:,0] * slope + y_i\n",
    "reg_arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Trig Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14.142135623730951"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Generate array of 200 values between -pi & pi\n",
    "t_arr = np.linspace(-np.pi, np.pi, 200)\n",
    "\n",
    "# Plot with x axis & y axis data \n",
    "# plt.plot(t_arr, np.sin(t_arr)) # SIN\n",
    "# plt.plot(t_arr, np.cos(t_arr)) # COS\n",
    "# plt.plot(t_arr, np.tan(t_arr)) # TAN\n",
    "# Display plot\n",
    "# plt.show()\n",
    "\n",
    "# Provides inverse of If y = cos(x), x = arccos(y)\n",
    "np.arcsin(1)\n",
    "np.arccos(1)\n",
    "np.arctan(0)\n",
    "\n",
    "# Also arctan2, sinh, cosh, tanh, arcsinh, arccosh, arctanh\n",
    "\n",
    "# Radians to degrees\n",
    "np.rad2deg(np.pi)\n",
    "# Degrees to radians\n",
    "np.deg2rad(180)\n",
    "\n",
    "# Hypotenuse c = √w² + h²\n",
    "np.hypot(10,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arr_5\n",
      " [[1 2]\n",
      " [3 4]]\n",
      "arr_6\n",
      " [[2 4]\n",
      " [6 9]]\n",
      "arr_3\n",
      " [1 2 3 4]\n",
      "arr_4\n",
      " [2 4 6 8]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 0],\n",
       "       [0, 1]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy import linalg as LA\n",
    "\n",
    "print(\"arr_5\\n\", arr_5)\n",
    "print(\"arr_6\\n\", arr_6)\n",
    "arr_8 = np.array([[5, 6], [7, 8]])\n",
    "\n",
    "# Matrix multiplication with Dot Product\n",
    "# (1 * 2) + (2 * 6) = 14 [0,0]\n",
    "# (1 * 4) + (2 * 9) = 22 [0,1]\n",
    "# (3 * 2) + (4 * 6) = 30 [1,0]\n",
    "# (3 * 4) + (4 * 9) = 12 + 36 = 48 [1,1]\n",
    "np.dot(arr_5, arr_6)\n",
    "# Compute dot product of 2 or more arrays\n",
    "LA.multi_dot([arr_5, arr_6, arr_8])\n",
    "\n",
    "# Inner product \n",
    "# (1 * 2) + (2 * 4) = 10 [0,0]\n",
    "# (1 * 6) + (2 * 9) = 24 [0,1]\n",
    "# (3 * 2) + (4 * 4) = 22 [1,0]\n",
    "# (3 * 6) + (4 * 9) = 54 [1,1]\n",
    "np.inner(arr_5, arr_6)\n",
    "np.dot(arr_5, arr_6)\n",
    "\n",
    "# Tensor Dot Product\n",
    "# (1 * 1) + (2 * 2) + (3 * 3) + (4 * 4) = 30\n",
    "# (5 * 1) + (6 * 2) + (7 * 3) + (8 * 4) = \n",
    "arr_9 = np.array([[[1, 2],\n",
    "        [3, 4]],\n",
    "       [[5, 6],\n",
    "        [7, 8]]])\n",
    "arr_10 = np.array([[1, 2],\n",
    "       [3, 4]], dtype=object)\n",
    "np.tensordot(arr_9, arr_10)\n",
    "\n",
    "# Einstein Summation : Provides many ways to perform\n",
    "# operations on multiple arrays\n",
    "arr_11 = np.array([0, 1])\n",
    "arr_12 = np.array([[0, 1, 2, 3], [4, 5, 6, 7]])\n",
    "# Left Side of -> : 1 axis for arr_11 and 2 axis for arr_12\n",
    "# Right of -> : Array we want (1D Array)\n",
    "# ij : Means multiply arr_11 single item by each column of arr_12 and sum\n",
    "# [0, 4 + 5 + 6 + 7]\n",
    "np.einsum('i,ij->i', arr_11, arr_12)\n",
    "# Sum values in arr_11\n",
    "np.einsum('i->', arr_11)\n",
    "# Dot Product\n",
    "print(\"arr_3\\n\", arr_3)\n",
    "print(\"arr_4\\n\", arr_4)\n",
    "np.einsum('i,i->', arr_3, arr_4)\n",
    "# Matrix multiplication\n",
    "np.einsum('ij,jk', arr_5, arr_6)\n",
    "# Get diagonal\n",
    "np.einsum('ii', arr_5)\n",
    "# Transpose\n",
    "np.einsum('ji', arr_5)\n",
    "\n",
    "# Raise matrix to the power of n\n",
    "# Given [[a, b], [c, d]]\n",
    "# [[a² + bc, ab +db], [ac + dc, d² + bc]\n",
    "LA.matrix_power(arr_5, 2)\n",
    "\n",
    "# Kronecker product of 2 arrays\n",
    "# Given [[a, b], [c, d]], [[e, f], [g, h]]\n",
    "# [[a*e, a*f, b*e, b*f], [a*g, a*h, b*g, b*h], ...]\n",
    "np.kron(arr_5, arr_6)\n",
    "\n",
    "# Compute eigenvalues\n",
    "LA.eig(arr_5) # Returns eigenvectors\n",
    "LA.eigvals(arr_5)\n",
    "\n",
    "# Get Vector Norm sqrt(sum(x**2))\n",
    "LA.norm(arr_5)\n",
    "\n",
    "# Get Multiplicative Inverse of a matrix\n",
    "LA.inv(arr_5)\n",
    "\n",
    "# Get Condition number of matrix\n",
    "LA.cond(arr_5)\n",
    "\n",
    "# Determinates are used to compute volume, area, to solve systems\n",
    "# of equations and more. It is a way you can multiply values in a\n",
    "# matrix to get 1 number.\n",
    "# For a matrix to have an inverse its determinate must not equal 0\n",
    "# det([[a, b], [c, d]]) = a*d - b*c\n",
    "arr_12 = np.array([[1, 2], [3, 4]])\n",
    "# 1*4 - 2*3 = -2\n",
    "LA.det(arr_12)\n",
    "\n",
    "# Determinate of 3x3 Matrix\n",
    "# det([[a, b, c], [d, e, f], [g, h, i]]) = a*e*i - b*d*i + c*d*h\n",
    "# - a*f*h + b*f*g - c*e*g\n",
    "\n",
    "# When we multiply a matrix times its inverse we get the identity\n",
    "# matrix [[1,0],[0,1]] for a 2x2 matrix\n",
    "# Calculate the inverse 1/(a*d - b*c) * [[d, -b], [-c, a]]\n",
    "# 1/(4 - 6) = -.5 -> [[-.5*4, -.5*-2], [-.5*-3, -.5*a]]\n",
    "arr_12_i = LA.inv(arr_12)\n",
    "arr_12_i\n",
    "\n",
    "np.dot(arr_12, arr_12_i)\n",
    "\n",
    "# Solving Systems of Linear Equations\n",
    "# If you have 3x + 5 = 9x -> 5 = 6x -> x = 5/6\n",
    "# If you have x + 4y = 10 & 6x + 18y = 42\n",
    "# Isolate x -> x = 10 - 4y\n",
    "# 6(10 - 4y) + 18y = 42 -> 60 - 24y + 18y = 42 - > -6y = -18 -> y = 3\n",
    "# x + 4*3 = 10 -> x = -2\n",
    "arr_13 = np.array([[1, 4], [6, 18]])\n",
    "arr_14 = np.array([10, 42])\n",
    "# Solve will solve this for you as well\n",
    "LA.solve(arr_13, arr_14)\n",
    "\n",
    "# Return a identity matrix with defined number of rows and columns\n",
    "np.eye(2, 2, dtype=int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving & Loading NumPy Objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2.],\n",
       "       [3., 4.]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr_15 = np.array([[1, 2], [3, 4]])\n",
    "# Save as randarray.npy\n",
    "np.save('randarray', arr_15)\n",
    "# Load saved array \n",
    "arr_16 = np.load('randarray.npy')\n",
    "arr_16\n",
    "\n",
    "# Save as a CSV \n",
    "np.savetxt('randcsv.csv', arr_15)\n",
    "# Load CSV\n",
    "arr_17 = np.loadtxt('randcsv.csv')\n",
    "arr_17"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Financial Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1   -239.58    -23.12    2760.42\n",
      "2   -241.42    -21.28    2519.0\n",
      "3   -243.29    -19.42    2275.71\n",
      "4   -245.16    -17.54    2030.55\n",
      "5   -247.05    -15.65    1783.5\n",
      "6   -248.95    -13.75    1534.55\n",
      "7   -250.87    -11.83    1283.67\n",
      "8   -252.81    -9.89    1030.87\n",
      "9   -254.76    -7.95    776.11\n",
      "10   -256.72    -5.98    519.39\n",
      "11   -258.7    -4.0    260.69\n",
      "12   -260.69    -2.01    0.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2898.6"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Install in Conda terminal with\n",
    "# conda install pip\n",
    "# pip install numpy-financial\n",
    "import numpy_financial as npf\n",
    "\n",
    "# Compute future value of $400 investment every month\n",
    "# with an annual rate of 8% after 10 years\n",
    "npf.fv(.08/12, 10*12, -400, -400)\n",
    "\n",
    "# Calculate interest portion of payment on a loan of $3,000\n",
    "# at 9.25% per year compounded monthly\n",
    "# Period of loan (year)\n",
    "period = np.arange(1*12) + 1\n",
    "principle = 3000.00\n",
    "# Interest Payment\n",
    "ipmt = npf.ipmt(0.0925/12, period, 1*12, principle)\n",
    "# Principle Payment\n",
    "ppmt = npf.ppmt(0.0925/12, period, 1*12, principle)\n",
    "for payment in period:\n",
    "    index = payment - 1\n",
    "    principle = principle + ppmt[index]\n",
    "    print(f\"{payment}   {np.round(ppmt[index], 2)}    {np.round(ipmt[index],2)}    {np.round(principle, 2)}\")\n",
    "\n",
    "# Compute number of payments to pay off $3,000 if you paid\n",
    "# $150 per month with an interest rate of 9.25%\n",
    "np.round(npf.nper(0.0925/12, -150, 3000.00), 2)\n",
    "\n",
    "# Calculate net present value of cash flows of $4,000, $5,000\n",
    "# $6,000, $7,000 after $15,000 investment with .08 rate per period\n",
    "npf.npv(0.08, [-15000, 4000, 5000, 6000, 7000]).round(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparison Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False])"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "carr_1 = np.array([2, 3])\n",
    "carr_2 = np.array([3, 2])\n",
    "# Returns boolean based on whether arr_1 value Comparison arr_2 value\n",
    "np.greater(carr_1, carr_2)\n",
    "np.greater_equal(carr_1, carr_2)\n",
    "np.less(carr_1, carr_2)\n",
    "np.less_equal(carr_1, carr_2)\n",
    "np.not_equal(carr_1, carr_2)\n",
    "np.equal(carr_1, carr_2)"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}