Chapter 2 - Libraries and Data Visualization/Lesson_1_NumPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4a90d1f1-801d-47b0-adc2-ec0277b317e3",
   "metadata": {},
   "source": [
    "# Lesson 1: NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8dba4691-6528-487e-90a4-d11d5e56cdeb",
   "metadata": {},
   "source": [
    "## Packages in Python 📚\n",
    "A Python package is a collection of modules. They are created by other developers to help you perform common tasks more easily without having to write all the code from scratch."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53a11dff-a5a0-4371-988c-4c948598362b",
   "metadata": {},
   "source": [
    "## Core Packages for Aerospace 🚀\n",
    "In aerospace and astronomy, many core packages are commonly used to perform various tasks, including numerical simulations, data analysis, visualization, and more. Here are some essential packages for each field:\n",
    "\n",
    "`numpy`: NumPy is a fundamental package for scientific computing in Python. It provides support for large, multi-dimensional arrays and matrices, along with a collection of mathematical functions to operate on these arrays efficiently.\n",
    "\n",
    "`scipy`: SciPy is built on top of NumPy and provides additional functionality for scientific and technical computing. It includes modules for optimization, integration, interpolation, signal processing, linear algebra, and more.\n",
    "\n",
    "`matplotlib`:Matplotlib is a comprehensive library for creating static, animated, and interactive visualizations in Python. It provides a MATLAB-like interface for generating plots and graphs, making it suitable for visualizing aerospace data. \n",
    "\n",
    "`pandas`: Pandas is a powerful data analysis and manipulation library that provides data structures and functions for working with structured data.\n",
    "\n",
    "`astropy`: Astropy is a core package for astronomy in Python, providing a wide range of tools and utilities for astronomical data analysis and modeling."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "275768ea-9351-4a47-8950-349ce6edfd98",
   "metadata": {},
   "source": [
    "## Getting Started with NumPy 🐍\n",
    "NumPy is a fundamental package for scientific computing in Python, providing support for large, multi-dimensional arrays and matrices, along with a collection of mathematical functions to operate on these arrays efficiently. In aerospace applications, NumPy is widely used for numerical simulations, data analysis, signal processing, and more. Learn more at: [https://numpy.org/](https://numpy.org/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "063f3b33-c4d8-40c0-8c63-737786d1e253",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "191e934c-acdd-4748-8b3e-1bf0ab96409a",
   "metadata": {},
   "source": [
    "## Arrays 🗂️\n",
    "NumPy arrays and ndarrays (n-dimensional arrays) are the core data structure used for numerical computations. You can create arrays using  `np.array()` \n",
    "\n",
    "In NumPy dimensions are called **axes**. The number of axes is referred to as **rank**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2d6bee99-a3bd-46da-8d0a-3475b4b681b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1D Array: [1 2 3 4 5]\n",
      "2D Array:\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "# Create a 1D array\n",
    "arr1d = np.array([1, 2, 3, 4, 5])\n",
    "print(\"1D Array:\", arr1d)\n",
    "\n",
    "# Create a 2D array\n",
    "arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
    "print(\"2D Array:\")\n",
    "print(arr2d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15b004fa-ad7d-4a34-9b37-eaa28b2dbb2f",
   "metadata": {},
   "source": [
    "There are additional methods for creating specific arrays within NumPy. They include:\n",
    "\n",
    "`np.zeros()` create an array filled with 0 of a specified shape\n",
    "\n",
    "`np.ones()`  create an array filled with 1 of a specified shape\n",
    "\n",
    "`np.arange()` create an array with evenly spaced values within a specified range\n",
    "\n",
    "`np.linspace()` create an array with evenly spaced values over a specified interval\n",
    "\n",
    "`np.full()` create a new NumPy array filled with a specified value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a5d2cd3d-f2e5-4926-a70f-1c624450d3ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1D Array filled with zeros: [0. 0. 0. 0. 0.]\n",
      "2D Array filled with zeros:\n",
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]\n",
      " [0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# Create a 1D array filled with zeros\n",
    "zeros_1d = np.zeros(5)\n",
    "print(\"1D Array filled with zeros:\", zeros_1d)\n",
    "\n",
    "# Create a 2D array filled with zeros\n",
    "zeros_2d = np.zeros((3, 3))\n",
    "print(\"2D Array filled with zeros:\")\n",
    "print(zeros_2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6c576eff-2207-49e2-8452-35674dae3e65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1D Array filled with ones: [1. 1. 1. 1. 1.]\n",
      "2D Array filled with ones:\n",
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# Create a 1D array filled with ones\n",
    "ones_1d = np.ones(5)\n",
    "print(\"1D Array filled with ones:\", ones_1d)\n",
    "\n",
    "# Create a 2D array filled with ones\n",
    "ones_2d = np.ones((3, 3))\n",
    "print(\"2D Array filled with ones:\")\n",
    "print(ones_2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ff90c36b-8313-49c4-8555-741abb2ff2da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array with values from 0 to 9: [0 1 2 3 4 5 6 7 8 9]\n",
      "Array with values from 5 to 14: [ 5  6  7  8  9 10 11 12 13 14]\n",
      "Array with values from 0 to 9 with a step of 2: [0 2 4 6 8]\n"
     ]
    }
   ],
   "source": [
    "# Create an array with values from 0 to 9\n",
    "arr_range_1 = np.arange(10)\n",
    "print(\"Array with values from 0 to 9:\", arr_range_1)\n",
    "\n",
    "# Create an array with values from 5 to 14\n",
    "arr_range_2 = np.arange(5, 15)\n",
    "print(\"Array with values from 5 to 14:\", arr_range_2)\n",
    "\n",
    "# Create an array with values from 0 to 9 with a step of 2\n",
    "arr_range_3 = np.arange(0, 10, 2)\n",
    "print(\"Array with values from 0 to 9 with a step of 2:\", arr_range_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "a222f315-329d-4057-b937-512d7494432b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array with 10 evenly spaced values between 0 and 1: [0.         0.11111111 0.22222222 0.33333333 0.44444444 0.55555556\n",
      " 0.66666667 0.77777778 0.88888889 1.        ]\n",
      "Array with 5 evenly spaced values between 1 and 10: [ 1.    3.25  5.5   7.75 10.  ]\n"
     ]
    }
   ],
   "source": [
    "# Create an array with 10 evenly spaced values between 0 and 1\n",
    "arr_linspace_1 = np.linspace(0, 1, 10)\n",
    "print(\"Array with 10 evenly spaced values between 0 and 1:\", arr_linspace_1)\n",
    "\n",
    "# Create an array with 5 evenly spaced values between 1 and 10\n",
    "arr_linspace_2 = np.linspace(1, 10, 5)\n",
    "print(\"Array with 5 evenly spaced values between 1 and 10:\", arr_linspace_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "95de3a87-ab11-4eb5-83fe-14417db73751",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5 5 5]\n",
      " [5 5 5]]\n"
     ]
    }
   ],
   "source": [
    "# Create a 2x3 array filled with 5\n",
    "arr = np.full((2, 3), 5)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aef91dbe-2efa-457d-951f-04bb081570db",
   "metadata": {},
   "source": [
    "Additional features you should know are `np.shape()` and `dtype`\n",
    "\n",
    "`np.shape()` method returns a tuple indicating the dimensions of the array. For a 1D array, it returns a single-element tuple with the length of the array. For multidimensional arrays, it returns a tuple specifying the size of each dimension.\n",
    "\n",
    "`dtype`  create an array filled with 1 of a specified shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5b47f49e-7daf-4d2f-846e-a08b62428076",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of 1D array: (5,)\n",
      "Shape of 2D array: (2, 3)\n"
     ]
    }
   ],
   "source": [
    "# Create a 1D array\n",
    "arr_1d = np.array([1, 2, 3, 4, 5])\n",
    "print(\"Shape of 1D array:\", arr_1d.shape)  # Output: (5,)\n",
    "\n",
    "# Create a 2D array\n",
    "arr_2d = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "print(\"Shape of 2D array:\", arr_2d.shape)  # Output: (2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "ef1bcbc7-a2ae-4eb5-b4b8-b88fdf9cbc04",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data type of array with integers: int64\n",
      "Data type of array with floats: float64\n"
     ]
    }
   ],
   "source": [
    "arr_int = np.array([1, 2, 3, 4, 5])\n",
    "print(\"Data type of array with integers:\", arr_int.dtype)  # Output: int64\n",
    "\n",
    "# Create an array with floating-point elements\n",
    "arr_float = np.array([1.0, 2.5, 3.7])\n",
    "print(\"Data type of array with floats:\", arr_float.dtype)  # Output: float64"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fb231c5-aab1-4158-8282-cb7eabe23e09",
   "metadata": {},
   "source": [
    "## Array Operations ➗\n",
    "NumPy supplies an assortment of methods to use for computing numerical operations on arrays. Array operations include:\n",
    "\n",
    "### Element-wise Arithmetic Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c11f67fb-9a3c-445c-a83c-ad9d0054e606",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element-wise addition: [ 7  9 11 13 15]\n",
      "Element-wise subtraction: [-5 -5 -5 -5 -5]\n",
      "Element-wise multiplication: [ 6 14 24 36 50]\n",
      "Element-wise division: [6.         3.5        2.66666667 2.25       2.        ]\n"
     ]
    }
   ],
   "source": [
    "# Create two NumPy arrays\n",
    "arr1 = np.array([1, 2, 3, 4, 5])\n",
    "arr2 = np.array([6, 7, 8, 9, 10])\n",
    "\n",
    "# Addition\n",
    "result_add = np.add(arr1, arr2)\n",
    "print(\"Element-wise addition:\", result_add)\n",
    "\n",
    "# Subtraction\n",
    "result_sub = np.subtract(arr1, arr2)\n",
    "print(\"Element-wise subtraction:\", result_sub)\n",
    "\n",
    "# Multiplication\n",
    "result_mul = np.multiply(arr1, arr2)\n",
    "print(\"Element-wise multiplication:\", result_mul)\n",
    "\n",
    "# Division\n",
    "result_div = np.divide(arr2, arr1)\n",
    "print(\"Element-wise division:\", result_div)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf72b6ec-a016-4561-8bec-1abae113ed4e",
   "metadata": {},
   "source": [
    "### Scalar Arithmetic Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "98d12f3b-d824-4bf5-a188-c22d9738cb23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scalar addition: [11 12 13 14 15]\n",
      "Scalar subtraction: [-2 -1  0  1  2]\n",
      "Scalar multiplication: [ 2  4  6  8 10]\n",
      "Scalar division: [0.5 1.  1.5 2.  2.5]\n"
     ]
    }
   ],
   "source": [
    "# Create a NumPy array\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "# Scalar addition\n",
    "scalar_add = arr + 10\n",
    "print(\"Scalar addition:\", scalar_add)\n",
    "\n",
    "# Scalar subtraction\n",
    "scalar_sub = arr - 3\n",
    "print(\"Scalar subtraction:\", scalar_sub)\n",
    "\n",
    "# Scalar multiplication\n",
    "scalar_mul = arr * 2\n",
    "print(\"Scalar multiplication:\", scalar_mul)\n",
    "\n",
    "# Scalar division\n",
    "scalar_div = arr / 2\n",
    "print(\"Scalar division:\", scalar_div)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0644a98-b6b7-4dcd-bad4-664c398adc68",
   "metadata": {},
   "source": [
    "### Element-wise Mathematical Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "bb5b603c-9b60-4f29-ad19-7b74bb7e7817",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Square root of each element: [1.         1.41421356 1.73205081 2.         2.23606798]\n",
      "Exponential of each element: [  2.71828183   7.3890561   20.08553692  54.59815003 148.4131591 ]\n",
      "Sine of each element: [ 0.84147098  0.90929743  0.14112001 -0.7568025  -0.95892427]\n",
      "Cosine of each element: [ 0.54030231 -0.41614684 -0.9899925  -0.65364362  0.28366219]\n",
      "Tangent of each element: [ 1.55740772 -2.18503986 -0.14254654  1.15782128 -3.38051501]\n"
     ]
    }
   ],
   "source": [
    "# Create a NumPy array\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "# Square root of each element\n",
    "result_sqrt = np.sqrt(arr)\n",
    "print(\"Square root of each element:\", result_sqrt)\n",
    "\n",
    "# Exponential of each element\n",
    "result_exp = np.exp(arr)\n",
    "print(\"Exponential of each element:\", result_exp)\n",
    "\n",
    "# Trigonometric functions\n",
    "result_sin = np.sin(arr)\n",
    "print(\"Sine of each element:\", result_sin)\n",
    "\n",
    "result_cos = np.cos(arr)\n",
    "print(\"Cosine of each element:\", result_cos)\n",
    "\n",
    "result_tan = np.tan(arr)\n",
    "print(\"Tangent of each element:\", result_tan)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29fcd035-4fe0-4cd1-a645-c1fb4c3c9bd8",
   "metadata": {},
   "source": [
    "### Exercise 1: Spacecraft Telemetry Modeling with NumPy Arrays 🚀 \n",
    "You are part of a team developing a flight trajectory planning software for a space mission to Mars. The software requires efficient handling of numerical data for trajectory calculations and simulations.\n",
    "\n",
    "#### Objectives:\n",
    "- Generate a NumPy array representing time in seconds from t=0 to t=100 seconds with a step size of 1 second.\n",
    "- Generate a NumPy array representing altitude in meters during the launch phase. The altitude should start at 0 meters and increase linearly with time at a constant rate of 100 meters per second.\n",
    "- Calculate the velocity array using the altitude array. Assume constant acceleration due to gravity (9.81 m/s^2) during the launch phase.\n",
    "- Calculate the acceleration array using a constant acceleration value of 9.81 m/s^2.\n",
    "- Print the shape and data type of each generated NumPy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "55fa7d1d-38ec-40fd-820b-986b33a94d51",
   "metadata": {},
   "outputs": [],
   "source": [
    "gravity_acceleration = 9.81  # Constant acceleration due to gravity in m/s^2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2d0b5d9-917a-472e-9ec7-411b486aae06",
   "metadata": {},
   "source": [
    "## Random Number Generation 🦄\n",
    "NumPy provides functions for generating random numbers and random arrays, including `np.random.rand()`, `np.random.randn()`, `np.random.randint()`, and more. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b52e2c19-0d9d-4a06-83e6-a786188a3cf8",
   "metadata": {},
   "source": [
    "`np.random.rand()` generates random numbers from a uniform distribution between 0 and 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "117f6dc1-c67e-4061-84f7-5949e8371679",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1D Array of random numbers between 0 and 1:\n",
      "[0.74452333 0.06345792 0.16023151 0.78127545 0.35980403]\n",
      "\n",
      "2D Array of random numbers between 0 and 1:\n",
      "[[0.81258543 0.04161309 0.41193043]\n",
      " [0.21494729 0.81923313 0.48843957]]\n"
     ]
    }
   ],
   "source": [
    "# Generate a 1D array of random numbers between 0 and 1\n",
    "rand_array_1d = np.random.rand(5)\n",
    "print(\"1D Array of random numbers between 0 and 1:\")\n",
    "print(rand_array_1d)\n",
    "\n",
    "# Generate a 2D array of random numbers between 0 and 1\n",
    "rand_array_2d = np.random.rand(2, 3)\n",
    "print(\"\\n2D Array of random numbers between 0 and 1:\")\n",
    "print(rand_array_2d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "771a1b60-fa5e-4ccf-8e2e-4cfcaee903d3",
   "metadata": {},
   "source": [
    "`np.random.randn()` generates random numbers from a standard normal distribution (mean = 0, standard deviation = 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "c72ab5d8-45e5-4751-aadc-9bbf51c727d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1D Array of random numbers from a standard normal distribution:\n",
      "[ 0.05487637 -0.82945917 -0.76285806 -0.64448938  3.12881364]\n",
      "\n",
      "2D Array of random numbers from a standard normal distribution:\n",
      "[[ 0.60633868 -1.9122101   0.06479419]\n",
      " [ 0.58945697  0.79181128  1.28282213]]\n"
     ]
    }
   ],
   "source": [
    "# Generate a 1D array of random numbers from a standard normal distribution\n",
    "randn_array_1d = np.random.randn(5)\n",
    "print(\"1D Array of random numbers from a standard normal distribution:\")\n",
    "print(randn_array_1d)\n",
    "\n",
    "# Generate a 2D array of random numbers from a standard normal distribution\n",
    "randn_array_2d = np.random.randn(2, 3)\n",
    "print(\"\\n2D Array of random numbers from a standard normal distribution:\")\n",
    "print(randn_array_2d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b5a6c60-91b3-4a46-bc31-d669f987f433",
   "metadata": {},
   "source": [
    "`np.random.randint()` generates random integers from a specified low (inclusive) to high (exclusive) range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "afb4b732-d950-492c-84c6-b1822b05f08c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1D Array of random integers between 0 and 9:\n",
      "[1 6 9 6 1]\n",
      "\n",
      "2D Array of random integers between 0 and 99:\n",
      "[[47 22 56]\n",
      " [91 46 80]]\n"
     ]
    }
   ],
   "source": [
    "# Generate a 1D array of random integers between 0 and 9\n",
    "randint_array_1d = np.random.randint(0, 10, size=5)\n",
    "print(\"1D Array of random integers between 0 and 9:\")\n",
    "print(randint_array_1d)\n",
    "\n",
    "# Generate a 2D array of random integers between 0 and 99\n",
    "randint_array_2d = np.random.randint(0, 100, size=(2, 3))\n",
    "print(\"\\n2D Array of random integers between 0 and 99:\")\n",
    "print(randint_array_2d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db4fe6f3-04b5-421c-880f-46d653bd12bd",
   "metadata": {},
   "source": [
    "## Array Comparison and Boolean Operations >\n",
    "Array comparison and boolean operations in NumPy allow you to compare elements in arrays and perform logical operations efficiently. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e011df8-3f6b-4472-9564-084f8a46a224",
   "metadata": {},
   "source": [
    "`np.where()` returns the indices of elements in an array that satisfy a given condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f35765c7-cb0d-470d-8b9e-21ee5aa4c5de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Indices where elements are greater than 2: (array([2, 3, 4]),)\n"
     ]
    }
   ],
   "source": [
    "# Create a NumPy array\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "# Find indices where elements are greater than 2\n",
    "indices = np.where(arr > 2)\n",
    "print(\"Indices where elements are greater than 2:\", indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbb6c906-3062-43f2-be0b-79a6ce4f7a0a",
   "metadata": {},
   "source": [
    "`ndarray.any()` returns True if ANY element in the array evaluates to True, otherwise False.\n",
    "\n",
    "`ndarray.all()` returns True if ALL elements in the array evaluate to True, otherwise False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "decbe301-bd6b-4035-99e2-3c18d0b90bd7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Any element is True: True\n",
      "All elements are True: False\n"
     ]
    }
   ],
   "source": [
    "# Create a NumPy array\n",
    "arr = np.array([False, True, False, True])\n",
    "\n",
    "# Test if any element is True\n",
    "any_true = arr.any()\n",
    "print(\"Any element is True:\", any_true)\n",
    "\n",
    "# Test if all elements are True\n",
    "all_true = arr.all()\n",
    "print(\"All elements are True:\", all_true)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08efc8fb-5bc3-4910-adb8-918eaf6a4b59",
   "metadata": {},
   "source": [
    "`np.logical_and()` performs element-wise logical AND operation between two arrays.\n",
    "    \n",
    "`np.logical_or()` performs element-wise logical OR operation between two arrays.\n",
    "    \n",
    "`np.logical_not()` performs element-wise logical NOT operation on an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "45f77230-ca2f-4484-a8e9-6cc49e236b78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element-wise logical AND: [ True False False False]\n",
      "Element-wise logical OR: [ True  True  True False]\n",
      "Element-wise logical NOT: [False False  True  True]\n"
     ]
    }
   ],
   "source": [
    "# Create NumPy arrays\n",
    "arr1 = np.array([True, True, False, False])\n",
    "arr2 = np.array([True, False, True, False])\n",
    "\n",
    "# Element-wise logical AND\n",
    "result_and = np.logical_and(arr1, arr2)\n",
    "print(\"Element-wise logical AND:\", result_and)\n",
    "\n",
    "# Element-wise logical OR\n",
    "result_or = np.logical_or(arr1, arr2)\n",
    "print(\"Element-wise logical OR:\", result_or)\n",
    "\n",
    "# Element-wise logical NOT\n",
    "result_not = np.logical_not(arr1)\n",
    "print(\"Element-wise logical NOT:\", result_not)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0963fc1-c776-4218-8752-fa320a1d4f93",
   "metadata": {},
   "source": [
    "## Array Manipulation 🏗️\n",
    "\n",
    "### Indexing \n",
    "Array indexing in NumPy works similarly to Python lists, where you can access individual elements using square brackets `[]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "908b7174-46b0-47e2-bf0f-327b121f5959",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element at index 0: 1\n",
      "Element at index 3: 4\n",
      "Element at index -1: 5\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "print(\"Element at index 0:\", arr[0])  # Output: 1\n",
    "print(\"Element at index 3:\", arr[3])  # Output: 4\n",
    "print(\"Element at index -1:\", arr[-1])  # Output: 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed645116-406c-4aee-9e15-177865c9c652",
   "metadata": {},
   "source": [
    "### Slicing \n",
    "Array slicing in NumPy allows you to extract subarrays (slices) from NumPy arrays using colon `:` notation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e130daa6-7bbd-4032-a191-1ee870297c45",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First three elements: [1 2 3]\n",
      "Elements from index 3 to 6: [4 5 6 7]\n",
      "Even-indexed elements: [1 3 5 7 9]\n",
      "Reverse the array: [10  9  8  7  6  5  4  3  2  1]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])\n",
    "print(\"First three elements:\", arr[:3])  # Output: [1 2 3]\n",
    "print(\"Elements from index 3 to 6:\", arr[3:7])  # Output: [4 5 6 7]\n",
    "print(\"Even-indexed elements:\", arr[::2])  # Output: [1 3 5 7 9]\n",
    "print(\"Reverse the array:\", arr[::-1])  # Output: [10  9  8  7  6  5  4  3  2  1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7de48828-65ea-43fb-8eb1-823d4d8783f6",
   "metadata": {},
   "source": [
    "### Appending and Concatenating Arrays "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "031bcd26-aa7a-429c-a91c-6211e575f3d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Appended array:\n",
      "[1 2 3 4 5 6]\n",
      "Concatenated array along axis 0:\n",
      "[1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([1, 2, 3])\n",
    "arr2 = np.array([4, 5, 6])\n",
    "\n",
    "# Append arr2 to arr1\n",
    "appended_arr = np.append(arr1, arr2)\n",
    "print(\"Appended array:\")\n",
    "print(appended_arr)\n",
    "\n",
    "# Concatenate arrays along axis 0 (along rows)\n",
    "concatenated_arr = np.concatenate((arr1, arr2))\n",
    "print(\"Concatenated array along axis 0:\")\n",
    "print(concatenated_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa11233b-c126-48d7-833c-edb0447e031a",
   "metadata": {},
   "source": [
    "### Flattening Arrays "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "c6b3afa7-7d78-4470-a6d0-ae051c0ab54a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Flattened array:\n",
      "[1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "flattened_arr = arr.flatten()\n",
    "print(\"Flattened array:\")\n",
    "print(flattened_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5b6836e-e101-4a2b-86a3-39e4a9f5e377",
   "metadata": {},
   "source": [
    "### Exercise 2: Mission Profiling 📡\n",
    "\n",
    "#### Objectives:\n",
    "- Use NumPy's random number generation functions to generate simulated altitude, velocity, and acceleration data.\n",
    "- Assume that the flight data consists of 1000 data points each for altitude, velocity, and acceleration.\n",
    "- Perform array indexing and slicing to extract subsets of data for analysis.\n",
    "- Use array comparisons and conditional methods to identify critical points:\n",
    "   - Critical altitude: Altitude above 5000 meters.\n",
    "   - Critical velocity: Velocity greater than 300 meters per second.\n",
    "   - Critical acceleration: Acceleration less than -9.8 meters per second squared (indicating deceleration).\n",
    "- Concatenate arrays representing critical points to an array and print it out!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49fa8dde-09cd-4a69-b1fc-6f555f6dbf4f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "77c496a8-9931-4ddf-aff5-b11f52508143",
   "metadata": {},
   "source": [
    "Well done! You have now covered the foundations of using NumPy!\n",
    "Next up, we will cover the pandas library 🐼!"
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}