2-ndarray-tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c5b88d62-9e09-466d-9eb9-07f175a03faa",
   "metadata": {},
   "source": [
    "## Google Colab Rust Setup\n",
    "\n",
    "The following cell is used to set up a Rust environment on Colab. Don't execute it locally!\n",
    "\n",
    "Many thanks to [`mateusvmv`](https://github.com/mateusvmv) for this hack in [`gist.github.com/korakot/ae95315ea6a3a3b33ee26203998a59a3`](https://gist.github.com/korakot/ae95315ea6a3a3b33ee26203998a59a3?permalink_comment_id=4715636#gistcomment-4715636)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c41f994-6a68-49b0-9b20-cd79f63c104c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This script sets up and spins up a Jupyter Notebook environment with a Rust kernel using Nix and IPC Proxy. \n",
    "!wget -qO- https://gist.github.com/wiseaidev/2af6bef753d48565d11bcd478728c979/archive/3f6df40db09f3517ade41997b541b81f0976c12e.tar.gz | tar xvz --strip-components=1\n",
    "!bash setup_evcxr_kernel.sh"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69efca5e",
   "metadata": {},
   "source": [
    "## Install Dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "508aa7d1",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep ndarray = {version = \"0.15.6\"}\n",
    "// or\n",
    "// :dep ndarray = { git = \"https://github.com/rust-ndarray/ndarray\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "36893f1a-cc12-4111-95ee-ed3806de6a2e",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep blas-src = { version = \"0.9\", features = [\"openblas\"]}\n",
    "// or\n",
    "// :dep blas-src = { git = \"https://github.com/blas-lapack-rs/blas-src\", features = [\"openblas\"]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f1799b6d-5cb0-4a7f-8131-f829da71dd04",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep ndarray-linalg = { version = \"0.16.0\", features = [\"openblas-static\"]}\n",
    "// or\n",
    "// :dep ndarray-linalg = { git = \"https://github.com/rust-ndarray/ndarray-linalg\", features = [\"openblas-static\"]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c6b1f064-6d58-4ad9-a601-0a1b2eb32e82",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep ndarray-rand = {version = \"0.14.0\"}\n",
    "// or\n",
    "// :dep ndarray-rand = { git = \"https://github.com/rust-ndarray/ndarray/tree/ndarray-rand-0.14.0\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bf35ac2",
   "metadata": {},
   "source": [
    "## Import Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "28a2e950",
   "metadata": {},
   "outputs": [],
   "source": [
    "use std::collections::{HashSet, HashMap};\n",
    "use ndarray::{array, Array, Array1, Array2, Array3, ShapeBuilder, rcarr1};\n",
    "use ndarray_linalg::convert::flatten;\n",
    "use ndarray_rand::RandomExt;\n",
    "use ndarray_rand::rand_distr::Uniform;\n",
    "use ndarray_linalg::solve::Inverse;\n",
    "use ndarray_linalg::solve::Determinant;\n",
    "use ndarray_linalg::trace::Trace;\n",
    "use ndarray_linalg::Solve;\n",
    "use ndarray_linalg::svd::SVD;\n",
    "use ndarray_linalg::Eig;\n",
    "use std::result::Result::{Err, Ok};"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcf17fb5",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9fbdbea",
   "metadata": {},
   "source": [
    "# 1. Vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a07f278",
   "metadata": {},
   "source": [
    "## Creating a Vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9618301b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let v: Vec<i32> = Vec::new();\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "59a85de5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let v = vec![1, 2, 3];\n",
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87d24192",
   "metadata": {},
   "source": [
    "## Accessing Vectors Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "00427d53",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "banana\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let v = vec![\"apple\", \"banana\", \"cherry\", \"date\"];\n",
    "{\n",
    "    let second = &v[1];\n",
    "    println!(\"{second}\")   \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "514bcefa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 5 cherries\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let v = vec![\n",
    "    (\"apple\", 3),\n",
    "    (\"banana\", 2),\n",
    "    (\"cherry\", 5),\n",
    "    (\"date\", 1),\n",
    "];\n",
    "\n",
    "{\n",
    "    // Get the quantity of cherries\n",
    "    let quantity = v.get(2).map(|(_, q)| q);\n",
    "\n",
    "    match quantity {\n",
    "        Some(q) => println!(\"There are {} cherries\", q),\n",
    "        None => println!(\"Cherries not found\"),\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cd41071",
   "metadata": {},
   "source": [
    "## Iterating over Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "495f5609",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let fruits = vec![(\"apple\", 3), (\"banana\", 2), (\"orange\", 5), (\"peach\", 4)];\n",
    "let mut sum = 0;\n",
    "for (_, num) in &fruits {\n",
    "    sum += num;\n",
    "}\n",
    "let avg = sum as f32 / fruits.len() as f32;\n",
    "avg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f48d4ff9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[20, 30, 40, 50, 60]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut values = vec![10, 20, 30, 40, 50];\n",
    "for value in values.iter_mut() {\n",
    "    *value += 10;\n",
    "}\n",
    "values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "90de7187",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value is 10\n",
      "The value is 20\n",
      "The value is 30\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let values = vec![10, 20, 30, 40, 50];\n",
    "for value in &values[0..3] {\n",
    "    println!(\"The value is {}\", value);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "ae7fe376",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value at index 0 is 10\n",
      "The value at index 1 is 20\n",
      "The value at index 2 is 30\n",
      "The value at index 3 is 40\n",
      "The value at index 4 is 50\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let values = vec![10, 20, 30, 40, 50];\n",
    "for (index, value) in values.iter().enumerate() {\n",
    "    println!(\"The value at index {} is {}\", index, value);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e47f94e",
   "metadata": {},
   "source": [
    "## Modifying a Vector"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eee3290e",
   "metadata": {},
   "source": [
    "## Adding elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "80e6952b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"apple\", \"banana\", \"orange\", \"mango\"]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut v = vec![\"apple\", \"banana\", \"orange\"];\n",
    "v.push(\"mango\");\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "ad909733",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"apple\", \"mango\", \"banana\", \"orange\", \"mango\"]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut v = vec![\"apple\", \"mango\", \"banana\", \"orange\"];\n",
    "v.insert(v.len(), \"mango\");\n",
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b3c1d2a",
   "metadata": {},
   "source": [
    "## Modifying Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "870bb137",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"apple\", \"pear\", \"grapefruit\"]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut v = vec![\"apple\", \"banana\", \"orange\"];\n",
    "v[1] = \"pear\";\n",
    "v[2] = \"grapefruit\";\n",
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c92ed341",
   "metadata": {},
   "source": [
    "## Removing Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "7feef72f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Removed element: \"mango\"\n",
      "[\"apple\", \"banana\", \"orange\"]\n"
     ]
    }
   ],
   "source": [
    "let mut v = vec![\"apple\", \"banana\", \"orange\", \"mango\"];\n",
    "let removed_element = v.pop();\n",
    "println!(\"Removed element: {:?}\", removed_element.unwrap());\n",
    "println!(\"{:?}\", v);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "29ffb323",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Removed element: orange\n",
      "[\"apple\", \"banana\", \"mango\"]\n"
     ]
    }
   ],
   "source": [
    "let mut v = vec![\"apple\", \"banana\", \"orange\", \"mango\"];\n",
    "let removed_element = v.remove(2);\n",
    "println!(\"Removed element: {}\", removed_element);\n",
    "println!(\"{:?}\", v);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "f94c2b89",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\"A\", \"fall\", \"day\"]\n"
     ]
    }
   ],
   "source": [
    "let mut v = vec![\"A\", \"warm\", \"fall\", \"warm\", \"day\"];\n",
    "let elem = \"warm\"; // element to remove\n",
    "v.retain(|x| *x != elem);\n",
    "println!(\"{:?}\", v);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "022ea1cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\"apple\", \"banana\", \"orange\", \"mango\"]\n"
     ]
    }
   ],
   "source": [
    "let mut v1 = vec![\"apple\", \"banana\"];\n",
    "let mut v2 = vec![\"orange\", \"mango\"];\n",
    "v1.extend(v2);\n",
    "println!(\"{:?}\", v1);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39246df6",
   "metadata": {},
   "source": [
    "## Filter & Map Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "23082b28",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "let v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];\n",
    "let odd_numbers: Vec<i32> = v.iter().filter(|x| *x % 2 != 0).map(|x| *x).collect();\n",
    "println!(\"{:?}\", odd_numbers);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "6426253a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\"HELLO\", \"WORLD\", \"RUST\"]\n"
     ]
    }
   ],
   "source": [
    "let v = vec![\"hello\", \"world\", \"rust\"];\n",
    "let uppercase_strings: Vec<String> = v.iter().map(|x| x.to_uppercase()).collect();\n",
    "println!(\"{:?}\", uppercase_strings);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc33be75",
   "metadata": {},
   "source": [
    "## Vector Length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "4482b571",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size: 3\n"
     ]
    }
   ],
   "source": [
    "let v = vec![\"hello\", \"world\", \"rust\"];\n",
    "println!(\"Size: {}\", v.len());"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cc237ff",
   "metadata": {},
   "source": [
    "## Check If Element Exists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "d3e08a18",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n"
     ]
    }
   ],
   "source": [
    "let v = vec![\"hello\", \"world\", \"rust\"];\n",
    "println!(\"{}\", v.contains(&\"hello\"));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d80b8dfe",
   "metadata": {},
   "source": [
    "## Reversing Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "42527078",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "let mut v = vec![1, 2, 3, 4, 5];\n",
    "v.reverse();\n",
    "println!(\"{:?}\", v);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7e800c4",
   "metadata": {},
   "source": [
    "## Maximum & Minimum Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "ccd3a8fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max element: 5\n",
      "Min element: 1\n"
     ]
    }
   ],
   "source": [
    "let v = vec![1, 2, 3, 4, 5];\n",
    "let max_element = *v.iter().max().unwrap();\n",
    "let min_element = *v.iter().min().unwrap();\n",
    "println!(\"Max element: {}\", max_element);\n",
    "println!(\"Min element: {}\", min_element);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20d5cecd",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c19ffa73",
   "metadata": {},
   "source": [
    "# 2. Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2e1904e",
   "metadata": {},
   "source": [
    "## Creating an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "ee35a980",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let days = [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"];\n",
    "days"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "6de49f6d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let a: [i32; 5] = [1, 2, 3, 4, 5];\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "39649f41",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0, 0, 0, 0]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let zeros = [0; 5];\n",
    "zeros"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1623c131",
   "metadata": {},
   "source": [
    "## Accessing Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "1d67169a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "let numbers = [1, 2, 3, 4, 5];\n",
    "println!(\"{}\", numbers[2]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e14e6060",
   "metadata": {},
   "source": [
    "## Modifying Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "87747cd7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 10, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "let mut numbers = [1, 2, 3, 4, 5];\n",
    "numbers[1] = 10;\n",
    "println!(\"{:?}\", numbers);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "066f1ecb",
   "metadata": {},
   "source": [
    "## Iterating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "9bd13f39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Winter\n",
      "Spring\n",
      "Summer\n",
      "Fall\n",
      "Winter\n",
      "Spring\n",
      "Summer\n",
      "Fall\n",
      "Winter\n",
      "Spring\n",
      "Summer\n",
      "Fall\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let seasons = [\"Winter\", \"Spring\", \"Summer\", \"Fall\"];\n",
    "for season in seasons {\n",
    "    println!(\"{season}\");\n",
    "}\n",
    "// or\n",
    "for index in 0..seasons.len() {\n",
    "    println!(\"{}\", seasons[index]);\n",
    "}\n",
    "// or\n",
    "for season in seasons.iter() {\n",
    "    println!(\"{}\", season);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9250988",
   "metadata": {},
   "source": [
    "## Slicing Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "ab883610",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let numbers = [1, 2, 3, 4, 5];\n",
    "{\n",
    "    let slice = &numbers[1..4];\n",
    "    println!(\"{:?}\", slice);   \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b24a7cba",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "481b817c",
   "metadata": {},
   "source": [
    "# 3. Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7c14a3a",
   "metadata": {},
   "source": [
    "## Creating a Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "f6e72ad6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\"Mahmoud\", 22, true, 6.6)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let person = (\"Mahmoud\", 22, true, 6.6);\n",
    "person"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "5fc1aaa7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\"Mahmoud\", 22, true, 6.6)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "person"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b6490a6",
   "metadata": {},
   "source": [
    "## Updating a Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "d8f2923c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\"Mahmoud\", 22, true)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut person = (\"Mahmoud\", 22, true);\n",
    "person"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "b9c03ba7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\"Mahmoud\", 21, true)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "person.1 = 21;\n",
    "person"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d2f74d3",
   "metadata": {},
   "source": [
    "## Destructuring a Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "4c75af5e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Mahmoud, Age: 22, Gender: Male\n"
     ]
    }
   ],
   "source": [
    "let (name, age, is_male) = (\"Mahmoud\", 22, true);\n",
    "println!(\"Name: {}, Age: {}, Gender: {}\", name, age, if is_male { \"Male\" } else { \"Female\" });"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "7e8a094e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Height: 6.6\n"
     ]
    }
   ],
   "source": [
    "let (_, _, _, height) = (\"Mahmoud\", 22, false, 6.6);\n",
    "println!(\"Height: {}\", height);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "736c6721",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Experience: 3\n"
     ]
    }
   ],
   "source": [
    "let person = (\"Mahmoud\", 3, true, 6.0);\n",
    "println!(\"Experience: {}\", person.1);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "906f3ca2",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "134a1baa",
   "metadata": {},
   "source": [
    "# 4. Hash Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d04ccd40",
   "metadata": {},
   "source": [
    "## Creating a Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "3ae9f4b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut my_set: HashSet<i32> = HashSet::new();\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "5854dc21",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 1, 2, 3}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let my_vector = vec![1, 2, 3, 4];\n",
    "let my_set: HashSet<i32> = my_vector.into_iter().collect();\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "5e96b0d7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let a = HashSet::from([1, 2, 3]);\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "49a506a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut my_set: HashSet<i32> = HashSet::new();\n",
    "my_set.insert(1);\n",
    "my_set.insert(2);\n",
    "my_set.insert(3);\n",
    "my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1235cb2a",
   "metadata": {},
   "source": [
    "## Removing elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "bb290fc0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 4, 3}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut my_set = HashSet::from([1, 2, 3, 4]);\n",
    "my_set.remove(&2); // removes 2 from the set\n",
    "my_set"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6d7237a",
   "metadata": {},
   "source": [
    "## Iterate over Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "f6222b0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1\n",
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let my_set = HashSet::from([1, 2, 3]);\n",
    "\n",
    "for element in &my_set {\n",
    "    println!(\"{}\", element);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52462a9e",
   "metadata": {},
   "source": [
    "## Sets Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "f3a6e972",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference of both sets: \n",
      "1\n",
      "Intersection of both sets: \n",
      "3\n",
      "2\n",
      "Union of both sets: \n",
      "3\n",
      "1\n",
      "2\n",
      "4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let set_a = HashSet::from([1, 2, 3]);\n",
    "let set_b = HashSet::from([4, 2, 3, 4]);\n",
    "\n",
    "// elements in set_a that are not in set_b\n",
    "let difference_set = set_a.difference(&set_b);\n",
    "\n",
    "// elements common to both set_a and set_b\n",
    "let intersection = set_a.intersection(&set_b);\n",
    "\n",
    "// elements in either set_a or set_b\n",
    "let union_set = set_a.union(&set_b);\n",
    "\n",
    "println!(\"Difference of both sets: \");\n",
    "    \n",
    "for element in difference_set {\n",
    "    println!(\"{}\", element);\n",
    "}\n",
    "\n",
    "println!(\"Intersection of both sets: \");\n",
    "\n",
    "for element in intersection {\n",
    "    println!(\"{}\", element);\n",
    "}\n",
    "\n",
    "println!(\"Union of both sets: \");\n",
    "\n",
    "for element in union_set {\n",
    "    println!(\"{}\", element); \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b4839c8",
   "metadata": {},
   "source": [
    "# 5. HashMaps"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15cf8966",
   "metadata": {},
   "source": [
    "## Creating a Hash Map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "0c0d051d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{\"Mahmoud\": 1, \"Ferris\": 2}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut employees_map = HashMap::new();\n",
    "\n",
    "// Insert elements to the HashMap\n",
    "employees_map.insert(\"Mahmoud\", 1);\n",
    "employees_map.insert(\"Ferris\", 2);\n",
    "\n",
    "employees_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "f465303d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: \"Mahmoud\", 2: \"Ferris\"}"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let employees_map: HashMap<i32, &str> = HashMap::from([\n",
    "    (1, \"Mahmoud\"),\n",
    "    (2, \"Ferris\"),\n",
    "]);\n",
    "employees_map"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84a9e45e",
   "metadata": {},
   "source": [
    "## Updating a Hash Map"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e18ec57",
   "metadata": {},
   "source": [
    "## Adding Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "17b8cc08",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{\"Mahmoud\": 1, \"Ferris\": 2}"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut employees_map = HashMap::new();\n",
    "// Insert elements to the HashMap\n",
    "employees_map.insert(\"Mahmoud\", 1);\n",
    "employees_map.insert(\"Ferris\", 2);\n",
    "employees_map"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c680bede",
   "metadata": {},
   "source": [
    "## Removing Elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "ea70ae18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut employees_map: HashMap<i32, String> = HashMap::new();\n",
    "\n",
    "// insert elements to hashmap\n",
    "employees_map.insert(1, String::from(\"Mahmoud\"));\n",
    "\n",
    "// remove elements from hashmap\n",
    "employees_map.remove(&1);\n",
    "employees_map"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e2e31d7",
   "metadata": {},
   "source": [
    "## Updating an Element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "a6492c83",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: \"Ferris\"}"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut employees_map: HashMap<i32, String> = HashMap::new();\n",
    "\n",
    "// insert elements to hashmap\n",
    "employees_map.insert(1, String::from(\"Mahmoud\"));\n",
    "\n",
    "// update the value of the element with key 1\n",
    "employees_map.insert(1, String::from(\"Ferris\"));\n",
    "employees_map"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62b2f167",
   "metadata": {},
   "source": [
    "## Access Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "d8744fe1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Mahmoud\""
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let employees_map: HashMap<i32, &str> = HashMap::from([\n",
    "    (1, \"Mahmoud\"),\n",
    "    (2, \"Ferris\"),\n",
    "]);\n",
    "\n",
    "{\n",
    "    let first_employee = employees_map.get(&1);\n",
    "    first_employee.unwrap()\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ac51c75",
   "metadata": {},
   "source": [
    "## Iterate over Hash Maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "fa99aefc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ferris\n",
      "Mahmoud\n",
      "Length of employees_map = 2\n"
     ]
    }
   ],
   "source": [
    "let mut employees_map: HashMap<i32, String> = HashMap::new();\n",
    "\n",
    "employees_map.insert(1, String::from(\"Mahmoud\"));\n",
    "employees_map.insert(2, String::from(\"Ferris\"));\n",
    "    \n",
    "// loop and print values of hashmap using values() method\n",
    "for employee in employees_map.values() {\n",
    "    println!(\"{}\", employee)\n",
    "}\n",
    "    \n",
    "// print the length of hashmap using len() method\n",
    "println!(\"Length of employees_map = {}\", employees_map.len());"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a21513e5",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50d3cf3c",
   "metadata": {},
   "source": [
    "# Ndarray for Data Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fa63883",
   "metadata": {},
   "source": [
    "## Initial Placeholders"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2b2d7ce",
   "metadata": {},
   "source": [
    "### Zeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "ccc43a24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0.0, 0.0, 0.0, 0.0]], shape=[1, 4], strides=[1, 1], layout=CFcf (0xf), const ndim=2"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let zeros = Array::<f64, _>::zeros((1, 4).f());\n",
    "zeros"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb790682",
   "metadata": {},
   "source": [
    "### Ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "81210537",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1.0, 1.0, 1.0, 1.0]], shape=[1, 4], strides=[4, 1], layout=CFcf (0xf), const ndim=2"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let ones = Array::<f64, _>::ones((1, 4));\n",
    "ones"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e8b1e19",
   "metadata": {},
   "source": [
    "### Range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "c4a375d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.0, 1.0, 2.0, 3.0, 4.0], shape=[5], strides=[1], layout=CFcf (0xf), const ndim=1"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let range = Array::<f64, _>::range(0., 5., 1.);\n",
    "range"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac222ad3",
   "metadata": {},
   "source": [
    "### Linspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "e505dca4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.0, 1.25, 2.5, 3.75, 5.0], shape=[5], strides=[1], layout=CFcf (0xf), const ndim=1"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let linspace = Array::<f64, _>::linspace(0., 5., 5);\n",
    "linspace"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5046edfe",
   "metadata": {},
   "source": [
    "### Fill"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "cd42e3e7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[2.0, 2.0, 2.0, 2.0]], shape=[1, 4], strides=[4, 1], layout=CFcf (0xf), const ndim=2"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut ones = Array::<f64, _>::ones((1, 4));\n",
    "ones.fill(2.);\n",
    "ones"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fa85065",
   "metadata": {},
   "source": [
    "### Eye"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "2edf46e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1.0, 0.0, 0.0, 0.0],\n",
       " [0.0, 1.0, 0.0, 0.0],\n",
       " [0.0, 0.0, 1.0, 0.0],\n",
       " [0.0, 0.0, 0.0, 1.0]], shape=[4, 4], strides=[4, 1], layout=Cc (0x5), const ndim=2"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let eye = Array::<f64, _>::eye(4);\n",
    "eye"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecf0c4d7",
   "metadata": {},
   "source": [
    "### Random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "ce61ef0a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[3.8224106202506203, 6.64094720699246, 9.454368791520007, 2.3125543314463393, 1.396546223588786],\n",
       " [1.648374869902045, 8.209199239430019, 3.486911941465447, 4.402403117231064, 5.900647270948909]], shape=[2, 5], strides=[5, 1], layout=Cc (0x5), const ndim=2"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let random = Array::random((2, 5), Uniform::new(0., 10.));\n",
    "random"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e254e3a",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bc21667",
   "metadata": {},
   "source": [
    "## Multidimensional Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e976ba2",
   "metadata": {},
   "source": [
    "### 1D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "c8f35187",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0, 2.0, 3.0, 4.0], shape=[4], strides=[1], layout=CFcf (0xf), const ndim=1"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let array_d1 = Array::from_vec(vec![1., 2., 3., 4.]);\n",
    "array_d1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "48a566ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1.0, 2.0, 3.0, 4.0]], shape=[1, 4], strides=[4, 1], layout=CFcf (0xf), const ndim=2"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let array_d11 = Array::from_shape_vec((1, 4), vec![1., 2., 3., 4.]);\n",
    "array_d11.unwrap()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "062b28d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[-1.01, 0.86, -4.6, 3.31, -4.81]], shape=[1, 5], strides=[5, 1], layout=CFcf (0xf), const ndim=2"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let array_d12 = array![\n",
    "    [-1.01,  0.86, -4.60,  3.31, -4.81]\n",
    "];\n",
    "array_d12"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d97c2af",
   "metadata": {},
   "source": [
    "### 2D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "cd02b590",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[-1.01, 0.86, -4.6, 3.31, -4.81],\n",
       " [3.98, 0.53, -7.04, 5.29, 3.55],\n",
       " [3.3, 8.26, -3.89, 8.2, -1.51],\n",
       " [4.43, 4.96, -7.66, -7.33, 6.18],\n",
       " [7.31, -6.43, -6.16, 2.47, 5.58]], shape=[5, 5], strides=[5, 1], layout=Cc (0x5), const ndim=2"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let array_d2 = array![\n",
    "    [-1.01,  0.86, -4.60,  3.31, -4.81],\n",
    "    [ 3.98,  0.53, -7.04,  5.29,  3.55],\n",
    "    [ 3.30,  8.26, -3.89,  8.20, -1.51],\n",
    "    [ 4.43,  4.96, -7.66, -7.33,  6.18],\n",
    "    [ 7.31, -6.43, -6.16,  2.47,  5.58],\n",
    "];\n",
    "array_d2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "d6b23e82",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1.0, 2.0],\n",
       " [3.0, 4.0]], shape=[2, 2], strides=[2, 1], layout=Cc (0x5), const ndim=2"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let array_d21 = Array::from_shape_vec((2, 2), vec![1., 2., 3., 4.]);\n",
    "array_d21.unwrap()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "07d746c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1.0, 2.0],\n",
       " [3.0, 4.0]], shape=[2, 2], strides=[2, 1], layout=Cc (0x5), const ndim=2"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut data = vec![1., 2., 3., 4.];\n",
    "let array_d22 = Array2::from_shape_vec((2, 2), data);\n",
    "array_d22.unwrap()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f46c649",
   "metadata": {},
   "source": [
    "### 3D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "f18cf162",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[[1.0],\n",
       "  [2.0]],\n",
       "\n",
       " [[3.0],\n",
       "  [4.0]]], shape=[2, 2, 1], strides=[2, 1, 1], layout=Cc (0x5), const ndim=3"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let mut data = vec![1., 2., 3., 4.];\n",
    "let array_d3 = Array3::from_shape_vec((2, 2, 1), data);\n",
    "array_d3.unwrap()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72f1d523",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dbe75b0",
   "metadata": {},
   "source": [
    "## Ndarray Arrays Manipulation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15eea038",
   "metadata": {},
   "source": [
    "### Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "4e4fcf59",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let array_d1 = Array::from_vec(vec![1., 2., 3., 4.]);\n",
    "array_d1[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "6a7be57b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let zeros = Array2::<f64>::zeros((2, 4));\n",
    "zeros[[1, 1]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cea545e8",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59da8b41",
   "metadata": {},
   "source": [
    "## Reshaping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "174cfee1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1.0, 2.0],\n",
       " [3.0, 4.0]], shape=[2, 2], strides=[2, 1], layout=Cc (0x5), const ndim=2"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let array_d1 = rcarr1(&[1., 2., 3., 4.]); // another way to create a 1D array\n",
    "let array_d2 = array_d1.reshape((2, 2));\n",
    "array_d2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70e5428a",
   "metadata": {},
   "source": [
    "## Flatten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "b1131262",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3.0, 2.0, 2.0, -2.0], shape=[4], strides=[1], layout=CFcf (0xf), const ndim=1"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let array_d2: Array2<f64> = array![[3., 2.], [2., -2.]];\n",
    "let array_flatten = flatten(array_d2);\n",
    "array_flatten"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffdf9eb3",
   "metadata": {},
   "source": [
    "## Transposing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "50e9c8b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1.0, 2.0],\n",
       " [3.0, 4.0]], shape=[2, 2], strides=[2, 1], layout=Cc (0x5), const ndim=2"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let array_d2 = Array::from_shape_vec((2, 2), vec![1., 2., 3., 4.]);\n",
    "array_d2.unwrap()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "45e7394a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1.0, 3.0],\n",
       " [2.0, 4.0]], shape=[2, 2], strides=[1, 2], layout=Ff (0xa), const ndim=2"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let array_d2 = Array::from_shape_vec((2, 2), vec![1., 2., 3., 4.]);\n",
    "let binding = array_d2.expect(\"Expect 2d matrix\");\n",
    "{\n",
    "    let array_d2t = binding.t();\n",
    "    array_d2t\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d5d0a9b",
   "metadata": {},
   "source": [
    "## Swapping Axes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "270f1cfb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1.0, 2.0],\n",
       " [3.0, 4.0]], shape=[2, 2], strides=[2, 1], layout=Cc (0x5), const ndim=2"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let array_d2 = Array::from_shape_vec((2, 2), vec![1., 2., 3., 4.]);\n",
    "array_d2.unwrap()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "87a7314e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1.0, 3.0],\n",
       " [2.0, 4.0]], shape=[2, 2], strides=[1, 2], layout=Ff (0xa), const ndim=2"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let array_d2 = Array::from_shape_vec((2, 2), vec![1., 2., 3., 4.]);\n",
    "let mut binding = array_d2.expect(\"Expect 2d matrix\");\n",
    "binding.swap_axes(0, 1);\n",
    "binding"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af252903",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd4017b8",
   "metadata": {},
   "source": [
    "## Linear Algebra"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fd47a2a",
   "metadata": {},
   "source": [
    "### 1. Matrix Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "bbd4bfbd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[13.0, 2.0],\n",
       " [2.0, 8.0]], shape=[2, 2], strides=[2, 1], layout=Cc (0x5), const ndim=2"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "extern crate blas_src;\n",
    "\n",
    "let a: Array2<f64> = array![[3., 2.], [2., -2.]];\n",
    "let b: Array2<f64> = array![[3., 2.], [2., -2.]];\n",
    "let c = a.dot(&b);\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25df6dcf",
   "metadata": {},
   "source": [
    "### 2. Inversion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "81937e77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The inverse of m1 is: [[-0.3333333333333333, 0.6666666666666666],\n",
      " [0.6666666666666666, -0.3333333333333333]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let array_d2 = Array::from_shape_vec((2, 2), vec![1., 2., 2., 1.]);\n",
    "\n",
    "match array_d2.expect(\"Matrix must be square & symetric!\").inv() {\n",
    "    Ok(inv) => {\n",
    "        println!(\"The inverse of m1 is: {}\", inv);\n",
    "    }\n",
    "    Err(err) => {\n",
    "        println!(\"{err}\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f8e19c7",
   "metadata": {},
   "source": [
    "### 3. Eigen Decomposition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "1b39fc5d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eigen values: [-3.759999999999999+2.706048780048134i, -3.759999999999999-2.706048780048134i, 0.00000000000000022759891370571733+0i]\n",
      "Eigen vectors: [[0.402993672209733+0.3965529218364603i, 0.402993672209733-0.3965529218364603i, 0.13921180485702092+0i],\n",
      " [0.5832417510526318+0.00000000000000006939572631647882i, 0.5832417510526318-0.00000000000000006939572631647882i, 0.9784706726517249+0i],\n",
      " [0.583241751052632+-0i, 0.583241751052632+0i, 0.15236540338584623+0i]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let array_d2 = array![\n",
    "    [-1.01,  0.86, -4.60],\n",
    "    [ 3.98,  0.53, -7.04],\n",
    "    [ 3.98,  0.53, -7.04],\n",
    "];\n",
    "match array_d2.eig() {\n",
    "    Ok((eigs, vecs)) => {\n",
    "        println!(\"Eigen values: {}\", eigs);\n",
    "        println!(\"Eigen vectors: {}\", vecs);\n",
    "    }\n",
    "    Err(err) => {\n",
    "        println!(\"{err}\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4b904ac",
   "metadata": {},
   "source": [
    "### 4. Singular Value Decomposition (SVD)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "55cbacd3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The left singular vectors are: [[-0.3167331446091065, -0.948514688924756, 0.0],\n",
      " [-0.6707011685937435, 0.22396415437963857, -0.7071067811865476],\n",
      " [-0.6707011685937436, 0.2239641543796386, 0.7071067811865475]], shape=[3, 3], strides=[3, 1], layout=Cc (0x5), const ndim=2\n",
      "The right singular vectors are: [[-0.4168301381758514, -0.0816682352525302, 0.9053081990455173],\n",
      " [0.8982609360852509, -0.18954008048752713, 0.39648688325344433],\n",
      " [0.13921180485702067, 0.9784706726517249, 0.1523654033858462]], shape=[3, 3], strides=[3, 1], layout=Cc (0x5), const ndim=2\n",
      "The sigma vector: [12.040590078046721, 3.051178554664221, 9.490164740574465e-18], shape=[3], strides=[1], layout=CFcf (0xf), const ndim=1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let array_d2 = array![\n",
    "    [-1.01,  0.86, -4.60],\n",
    "    [ 3.98,  0.53, -7.04],\n",
    "    [ 3.98,  0.53, -7.04],\n",
    "];\n",
    "match array_d2.svd(true, true) {\n",
    "    Ok((u, sigma, vt)) => {\n",
    "        println!(\"The left singular vectors are: {:?}\", u.unwrap());\n",
    "        println!(\"The right singular vectors are: {:?}\", vt.unwrap());\n",
    "        println!(\"The sigma vector: {:?}\", sigma);\n",
    "    }\n",
    "    Err(err) => {\n",
    "        println!(\"{err}\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aad382ce",
   "metadata": {},
   "source": [
    "### 5. Matrix Trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "8f924216",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of diagonal elements is: -7.52\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let array_d2 = array![\n",
    "    [-1.01,  0.86, -4.60],\n",
    "    [ 3.98,  0.53, -7.04],\n",
    "    [ 3.98,  0.53, -7.04],\n",
    "];\n",
    "match array_d2.trace() {\n",
    "    Ok(value) => {\n",
    "        println!(\"The sum of diagonal elements is: {:?}\", value);\n",
    "    }\n",
    "    Err(err) => {\n",
    "        println!(\"{err}\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57c50b2c",
   "metadata": {},
   "source": [
    "### 6. Matrix Determinant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "10c1d418",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The detexrminant of this matrix is: 2.822009292913204e-15\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let array_d2 = array![\n",
    "    [-1.01,  0.86, -4.60],\n",
    "    [ 3.98,  0.53, -7.04],\n",
    "    [ 3.98,  0.53, -7.04],\n",
    "];\n",
    "match array_d2.det() {\n",
    "    Ok(value) => {\n",
    "        println!(\"The detexrminant of this matrix is: {:?}\", value);\n",
    "    }\n",
    "    Err(err) => {\n",
    "        println!(\"{err}\");\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b781cded",
   "metadata": {},
   "source": [
    "### 7. Solving Linear Equations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "65e2a029",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-0.2, 0.8], shape=[2], strides=[1], layout=CFcf (0xf), const ndim=1"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// a11x0 + a12x1 = b1    --->    3 * x0 + 2 * x1 = 1\n",
    "// a21x0 + a22x1 = b2    --->    2 * x0 - 2 * x1 = -2:\n",
    "let a: Array2<f64> = array![[3., 2.], [2., -2.]];\n",
    "let b: Array1<f64> = array![1., -2.];\n",
    "let x = a.solve_into(b).unwrap();\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0928af19-8f44-4737-884e-0be745918c11",
   "metadata": {},
   "source": [
    "---\n",
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Rust",
   "language": "rust",
   "name": "rust"
  },
  "language_info": {
   "codemirror_mode": "rust",
   "file_extension": ".rs",
   "mimetype": "text/rust",
   "name": "Rust",
   "pygment_lexer": "rust",
   "version": ""
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}