source/notebooks/L1/numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A brief introduction to NumPy\n",
    "\n",
    "```{attention}\n",
    "Finnish university students are encouraged to use the CSC Notebooks platform.<br/>\n",
    "<a href=\"https://notebooks.csc.fi\"><img alt=\"CSC badge\" src=\"https://img.shields.io/badge/launch-CSC%20notebook-blue.svg\" style=\"vertical-align:text-bottom\"></a>\n",
    "\n",
    "Others can follow the lesson and fill in their notebooks using Binder.<br/>\n",
    "<a href=\"https://mybinder.org/v2/gh/introqg/notebooks/master?urlpath=lab/tree/L1/numpy.ipynb\"><img alt=\"Binder badge\" src=\"https://img.shields.io/badge/launch-binder-red.svg\" style=\"vertical-align:text-bottom\"></a>\n",
    "```\n",
    "\n",
    "In this course we divide our time between using simple numerical models and solving equations, and loading and manipulating data files. Thus, one of the things we will often need to do is create an array for a variable that has a range from one value to another. To help with this, there are a few handy NumPy functions we can use for this, which we introduce below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting started\n",
    "\n",
    "As always, we should start by importing NumPy. The tradition is to import the NumPy library as `np`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining arrays with a fixed number of increments\n",
    "\n",
    "Let's say that we want to calculate the sine of a variable `x` at 10 points from 0 to $2 \\pi$.\n",
    "We can do this in NumPy as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0.0, 2 * np.pi, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.         0.6981317  1.3962634  2.0943951  2.7925268  3.4906585\n",
      " 4.1887902  4.88692191 5.58505361 6.28318531]\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`np.linspace()` is a NumPy function that will create an array that starts at one value, ends at another, and uses a fixed number of steps between the values.\n",
    "The general syntax is of the form\n",
    "\n",
    "```python\n",
    "np.linspace(start, stop, num)\n",
    "```\n",
    "\n",
    "where `start` will be the first value in the array, `stop` will be the last, and `num` is total number of values in the array, with steps that are divided equally between `start` and `stop`.\n",
    "\n",
    "With `x` defined, we can now move on to calculating `sin(x)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = np.sin(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.00000000e+00  6.42787610e-01  9.84807753e-01  8.66025404e-01\n",
      "  3.42020143e-01 -3.42020143e-01 -8.66025404e-01 -9.84807753e-01\n",
      " -6.42787610e-01 -2.44929360e-16]\n"
     ]
    }
   ],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, x starts at zero and goes to $2 \\pi$ in 10 increments, and `y` is simply the sine function at those values of `x`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining arrays with a fixed increment between values\n",
    "\n",
    "Alternatively, if we wanted to specify the size of the increments for a new variable `x2`, we could use the `np.arange()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "x2 = np.arange(0.0, 10.0, 0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.  0.5 1.  1.5 2.  2.5 3.  3.5 4.  4.5 5.  5.5 6.  6.5 7.  7.5 8.  8.5\n",
      " 9.  9.5]\n"
     ]
    }
   ],
   "source": [
    "print(x2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, `x2` starts at zero and increases in steps of 0.5 up to a value of 9.5 (notably excluding 10.0).\n",
    "`np.arange()` is similar to the `linspace()` function in the sense that it can be used to create arrays of values.\n",
    "The difference is that here we specify the size of the increment (or step) between values, rather than the number of values in the array.\n",
    "Thus, the syntax is\n",
    "\n",
    "```python\n",
    "np.arange(start, stop, step)\n",
    "```\n",
    "\n",
    "where `start` will be the first value in the array, `stop` is the end value but will be excluded from the array, and `step` is the size of the increment between array values.\n",
    "With this function, the last value in the array will be the largest multiple of `step` that is smaller than `stop`.\n",
    "\n",
    "Both `np.linspace()` and `np.arange()` array creation options can be useful in different situations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generating random numbers with NumPy\n",
    "\n",
    "We'll also want to occasionally generate some random numbers with NumPy. We can easily generate sequences of random numbers using the `np.random.rand()` function. Let's generate 10 random numbers below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "rand = np.random.rand(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.27741089 0.20017217 0.38780481 0.57159229 0.52805668 0.28452518\n",
      " 0.4902802  0.81577994 0.19412857 0.20555974]\n"
     ]
    }
   ],
   "source": [
    "print(rand)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, `np.random.rand()` takes a single parameter, the number of random numbers you would like to produce. With that parameter, we get back a NumPy array of floating-point values from 0.0 up to (but not including) 1.0. This range is often useful because you can easily scale the array values to have random numbers over any range.\n",
    "\n",
    "There are many other options for producing random numbers with NumPy, such as random integers or random values from different types of distributions. You can find more about random numbers on the [NumPy website](https://numpy.org/doc/stable/reference/random/index.html#module-numpy.random)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}