Lectures/numPy_GettingStarted.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyN/S47H1QFy6IVw/Y4bdtpA",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/hamidrezanorouzi/numericalMethods/blob/main/Lectures/numPy_GettingStarted.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 1. Introduction to NumPy\n",
        "\n",
        "NumPy is a Python library that stands for \"Numerical 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",
        "To get started with NumPy, you need to import it:\n",
        "\n",
        "```python\n",
        "import numpy as np\n",
        "```\n"
      ],
      "metadata": {
        "id": "p8D4qha7RQ2e"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 2. Creating NumPy Arrays\n",
        "\n",
        "### Creating 1D and 2D Arrays:"
      ],
      "metadata": {
        "id": "liiXVMyySBj-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Creating a 1D array\n",
        "arr_1d = np.array([1, 2, 3, 4, 5])\n",
        "\n",
        "# Creating a 2D array (matrix)\n",
        "matrix_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
        "print(matrix_2d)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SjpNzIsoSJEV",
        "outputId": "d5191354-d90d-4670-a20c-328a80961605"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Creating Arrays with Zeros and Ones:\n"
      ],
      "metadata": {
        "id": "Gx1FtaBlSa-I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a 3x3 array filled with zeros\n",
        "zeros_array = np.zeros((3, 3))\n",
        "\n",
        "# Creating a 2x4 array filled with ones\n",
        "ones_array = np.ones((2, 4))"
      ],
      "metadata": {
        "id": "IHo5lpGQSekm"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Creating Arrays with a Range of Values:"
      ],
      "metadata": {
        "id": "9d1ovp37Si8y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating an array from 0 to 8 with a step of 2\n",
        "range_array = np.arange(0, 10, 2)\n",
        "print(\"range_array is:\", range_array)\n",
        "\n",
        "# Creating array of values equally spaced\n",
        "lin = np.linspace(0.0, 10.0, 21)\n",
        "print(\"lin is:\", lin)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZwFyh0hdSnxh",
        "outputId": "127e30b8-ada8-4701-f2d1-f27f86b9ecb2"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "range_array is: [0 2 4 6 8]\n",
            "lin is: [ 0.   0.5  1.   1.5  2.   2.5  3.   3.5  4.   4.5  5.   5.5  6.   6.5\n",
            "  7.   7.5  8.   8.5  9.   9.5 10. ]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Creating Random Arrays:\n"
      ],
      "metadata": {
        "id": "_QfpCpS4TLjY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a 3x3 matrix of random values between 0 and 1\n",
        "random_array = np.random.rand(3, 3)\n",
        "print(random_array)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2Y2eOdOuTT60",
        "outputId": "ab2d03d8-ef74-4c45-9a27-35421febf4af"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0.27381072 0.66806182 0.18436933]\n",
            " [0.64857279 0.47824298 0.70632653]\n",
            " [0.83283609 0.42210995 0.23475899]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 3. Basic Operations with NumPy Arrays\n",
        "### Element-wise Arithmetic Operations:\n"
      ],
      "metadata": {
        "id": "LQJtFE8ETjXE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "a = np.array([1, 2, 3])\n",
        "b = np.array([4, 5, 6])\n",
        "\n",
        "# Addition\n",
        "addition = a + b\n",
        "print(\"addition : \", addition)\n",
        "\n",
        "# Subtraction\n",
        "subtraction = a - b\n",
        "print(\"subtraction : \", subtraction)\n",
        "\n",
        "# Multiplication\n",
        "multiplication = a * b\n",
        "print(\"multiplication : \", multiplication)\n",
        "\n",
        "\n",
        "# Division\n",
        "division = a / b\n",
        "print(\"division : \", division)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ESFXZUEjTu68",
        "outputId": "7aca7431-5c6a-413f-f2e0-7aa7ca91b804"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "addition :  [5 7 9]\n",
            "subtraction :  [-3 -3 -3]\n",
            "multiplication :  [ 4 10 18]\n",
            "division :  [0.25 0.4  0.5 ]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Element-wise Operations:\n"
      ],
      "metadata": {
        "id": "ACNcX9xUUNaC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Square each element\n",
        "square = np.square(a)\n",
        "print(\"square: \", square)\n",
        "# Square root of each element\n",
        "sqrt = np.sqrt(a)\n",
        "print(\"sqrt: \", sqrt)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "otwkrEoqUROU",
        "outputId": "a35a3cb4-3e03-438d-e345-4c62e702a74a"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "square:  [1 4 9]\n",
            "sqrt:  [1.         1.41421356 1.73205081]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### More Functions:\n",
        "\n",
        "NumPy provides a wide range of mathematical functions for arrays. Here are a few examples:\n",
        "\n",
        "- `np.exp(arr)`: Compute the exponent of each element.\n",
        "- `np.log(arr)`: Compute the natural logarithm of each element.\n",
        "- `np.sin(arr)`, `np.cos(arr)`, `np.tan(arr)`: Compute trigonometric functions element-wise."
      ],
      "metadata": {
        "id": "VXeBilktUeP9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 4. Matrix Manipulation\n",
        "### Transpose a Matrix and Matrix Multiplication (Dot Product)"
      ],
      "metadata": {
        "id": "nRe-p85TUjLG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "matrix_a = np.array([[1, 2], [3, 4]])\n",
        "matrix_b = np.array([[5, 6], [7, 8]])\n",
        "\n",
        "# Transpose of a matrix\n",
        "transposed_matrix_a = matrix_a.T\n",
        "print(transposed_matrix_a)\n",
        "\n",
        "# Matrix multiplication\n",
        "result = np.dot(matrix_a, matrix_b)\n",
        "print(\"result \\n\", result)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "izP4TRAPUrbc",
        "outputId": "648e266e-c2e2-454a-8264-112f8aeec5f7"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 3]\n",
            " [2 4]]\n",
            "result \n",
            " [[19 22]\n",
            " [43 50]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Matrix Inversion and determinant"
      ],
      "metadata": {
        "id": "jnDMe44-WM_6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Inverse of a matrix\n",
        "inverse_matrix = np.linalg.inv(matrix_a)\n",
        "\n",
        "# Determinant of a matrix\n",
        "determinant = np.linalg.det(matrix_a)"
      ],
      "metadata": {
        "id": "-v1rrxO9WSkM"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 5. Linear Algebra Operations\n",
        "### Solving a Linear System of Equations:\n"
      ],
      "metadata": {
        "id": "-kzqgiuSWXaa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A = np.array([[2, 3], [1, -2]])\n",
        "b = np.array([5, 1])\n",
        "\n",
        "# Solve Ax = b for x\n",
        "x = np.linalg.solve(A, b)\n",
        "print(\"solution is \", x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vt8KuLRzWPKD",
        "outputId": "322d27c1-cf3d-4477-ed63-2c340b18e171"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "solution is  [1.85714286 0.42857143]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 6. Additional NumPy Features"
      ],
      "metadata": {
        "id": "AdLlgliuWoIZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Broadcasting a scalar to an array\n",
        "arr_1d = np.array([1, 2, 3, 4, 5, 6])\n",
        "result = arr_1d + 2  # Adding 2 to each element using\n",
        "\n",
        "# Compute statistics on arrays\n",
        "total = np.sum(arr_1d)\n",
        "average = np.mean(arr_1d)\n",
        "maximum = np.max(arr_1d)\n",
        "minimum = np.min(arr_1d)\n",
        "\n",
        "# Reshaping an array\n",
        "reshaped = np.reshape(arr_1d, (3, 2))\n",
        "reshaped_vec = np.reshape(np.array([10, 11, 12]), (3,1))\n",
        "print(reshaped)\n",
        "print(reshaped_vec)\n",
        "# Concatenating arrays\n",
        "concatenated = np.concatenate((reshaped,reshaped_vec),axis=1)\n",
        "print(concatenated)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZUp6mgc_W-2Z",
        "outputId": "589dc1f3-e2af-454c-f219-13635a0d1436"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2]\n",
            " [3 4]\n",
            " [5 6]]\n",
            "[[10]\n",
            " [11]\n",
            " [12]]\n",
            "[[ 1  2 10]\n",
            " [ 3  4 11]\n",
            " [ 5  6 12]]\n"
          ]
        }
      ]
    }
  ]
}