numpy_examples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy\n",
    "\n",
    "numpy is python's package for doing math that is more advanced than +-*/\n",
    "\n",
    "This includes special functions like cosine, exponential, sqrt, ...\n",
    "\n",
    "On top of this we can use numpy to generate samples from many types of random variables\n",
    "\n",
    "numpy also has a powerful data type to define vectors, matrices, and tensors\n",
    "\n",
    "With these data types numpy also allows us to do linear algebra - matrix multiplication and matrix-vector solutions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the first step of using numpy is to tell python to use it\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.cos(np.pi))\n",
    "print(np.sqrt(1.21))\n",
    "print(np.log(np.exp(5.2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can create numpy arrays by converting lists\n",
    "# this is a vector\n",
    "vec = np.array([1,2,3])\n",
    "print(vec)\n",
    "# we can create matrices by converting lists of lists\n",
    "mat = np.array([[1,2,1],[4,5,9],[1,8,9]])\n",
    "print('')\n",
    "print(mat)\n",
    "print('')\n",
    "print(mat.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# there are lots of other ways to create numpy arrays\n",
    "vec2 = np.arange(0,15)\n",
    "print(vec2)\n",
    "print('')\n",
    "vec3 = np.arange(3,21,6)\n",
    "print(vec3)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "vec4 = np.linspace(0,5,10)\n",
    "print(vec4)\n",
    "print('')\n",
    "print(vec4.reshape(5,2))\n",
    "vec4_reshaped = vec4.reshape(5,2)\n",
    "print(vec4_reshaped)\n",
    "print(vec4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat2 = np.zeros([5,3])\n",
    "print(mat2)\n",
    "mat3 = np.ones((3,5))\n",
    "print('')\n",
    "print(mat3)\n",
    "mat4 = np.eye(5)\n",
    "print('')\n",
    "print(mat4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can +-*/ arrays together if they're the right size\n",
    "vec5 = np.arange(1,6)\n",
    "vec6 = np.arange(3,8)\n",
    "print(vec5)\n",
    "print(vec6)\n",
    "print(vec5+vec6)\n",
    "print(vec5*vec6)\n",
    "print(1/vec5)\n",
    "print(np.sqrt(vec6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can do matrix multiplication\n",
    "print(mat)\n",
    "print('')\n",
    "print(vec)\n",
    "print()\n",
    "product = np.matmul(mat,vec)\n",
    "print(product)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.linalg.solve(mat,product))\n",
    "print('')\n",
    "print(np.linalg.inv(mat))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can find the unique values in an array\n",
    "vec7 = np.array(['blue','red','orange','purple','purple','orange','Red',6])\n",
    "print(vec7)\n",
    "print(np.unique(vec7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can also use numpy to generate samples of a random variable\n",
    "rand_mat = np.random.rand(5,5) # uniform random variable\n",
    "print(rand_mat)\n",
    "rand_mat2 = np.random.randn(10,5) # standard normal random variable\n",
    "print('')\n",
    "print(rand_mat2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can also use numpy for statistical tools on arrays\n",
    "print(np.mean(rand_mat))\n",
    "print(np.std(rand_mat2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.min(rand_mat))\n",
    "print(np.max(rand_mat2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# break here for next video!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# how do we access entries in a numpy vector\n",
    "rand_vec = np.random.randn(19)\n",
    "print(rand_vec)\n",
    "print(rand_vec[6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can access multiple entries at once using :\n",
    "print(rand_vec[4:9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can also access multiple non-consecutive entries using np.arange\n",
    "print(np.arange(0,15,3))\n",
    "print(rand_vec[np.arange(0,15,3)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# what about matrices\n",
    "print(rand_mat)\n",
    "print(rand_mat[1][2])\n",
    "print(rand_mat[1,2])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(rand_mat[0:2,1:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's change some values in an array!\n",
    "print(rand_vec)\n",
    "rand_vec[3:5] = 4\n",
    "print('')\n",
    "print(rand_vec)\n",
    "rand_vec[3:5] = [1,2]\n",
    "print('')\n",
    "print(rand_vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(rand_mat)\n",
    "rand_mat[1:3,3:5] = 0\n",
    "print('')\n",
    "print(rand_mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sub_mat = rand_mat[0:2,0:3]\n",
    "print(sub_mat)\n",
    "sub_mat[:] = 3\n",
    "print(sub_mat)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(rand_mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sub_mat2 = rand_mat[0:2,0:3].copy()\n",
    "sub_mat2[:] = 99\n",
    "print(sub_mat2)\n",
    "print(rand_mat)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# break here for next video"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can also access entries with logicals\n",
    "rand_vec = np.random.randn(15)\n",
    "\n",
    "print(rand_vec)\n",
    "print(rand_vec>0)\n",
    "print(rand_vec[rand_vec>0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(rand_mat2)\n",
    "print(rand_mat2[rand_mat2>0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "print(rand_vec)\n",
    "print('')\n",
    "rand_vec[rand_vec>0.5] = -5\n",
    "print(rand_vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's save some arrays on the disk for use later!\n",
    "np.save('saved_file_name',rand_mat2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savez('zipped_file_name',rand_mat=rand_mat,rand_mat2=rand_mat2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# now let's load it\n",
    "loaded_vec = np.load('saved_file_name.npy')\n",
    "loaded_zip = np.load('zipped_file_name.npz')\n",
    "\n",
    "print(loaded_vec)\n",
    "print('')\n",
    "print(loaded_zip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(loaded_zip['rand_mat'])\n",
    "print('')\n",
    "print(loaded_zip['rand_mat2'])\n",
    "\n",
    "new_array  = loaded_zip['rand_mat']\n",
    "print(new_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can also save/load as text files...but only single variables\n",
    "np.savetxt('text_file_name.txt',rand_mat,delimiter=',')\n",
    "rand_mat_txt = np.loadtxt('text_file_name.txt',delimiter=',')\n",
    "print(rand_mat)\n",
    "print('')\n",
    "print(rand_mat_txt)"
   ]
  },
  {
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}