7-calculus-tutorial-part-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0f6d8195-c607-4a0a-babe-00ea6cf6d575",
   "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": "5a69893a-9677-4256-9ce2-69a9189931ea",
   "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": "0ad92c1a",
   "metadata": {},
   "source": [
    "## The Derivative Function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c73a9c6",
   "metadata": {},
   "source": [
    "#### $y = x^3 - 2x^2 + 3x - 4$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7a076a18",
   "metadata": {},
   "outputs": [],
   "source": [
    "fn f(x: f64) -> f64 {\n",
    "    x.powi(3) - 2.0 * x.powi(2) + 3.0 * x - 4.0\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "43cee4c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "fn derivative(f: fn(f64) -> f64, x: f64) -> f64 {\n",
    "    let delta_x = 1.0 / 1_000_000.0;\n",
    "    (f(x + delta_x) - f(x)) / delta_x\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "62eac785",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The derivative at x = 2 is: 7.000004001334048\n"
     ]
    }
   ],
   "source": [
    "let x_value = 2.0;\n",
    "let result = derivative(f, x_value);\n",
    "println!(\"The derivative at x = {} is: {}\", x_value, result);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f39cc3a1",
   "metadata": {},
   "source": [
    "### Example 1: Exploring a Trigonometric Function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29cd5843",
   "metadata": {},
   "source": [
    "#### $y = \\sin(x)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4ffc4a08",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Derivatives of sin(x):\n",
      "-3 -0.989992426175812\n",
      "-2 -0.4161463817986544\n",
      "-1 0.540302726670383\n",
      "0 0.9999999999998334\n",
      "1 0.5403018851213304\n",
      "2 -0.41614729129335615\n",
      "3 -0.9899925672851584\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn sin_function(x: f64) -> f64 {\n",
    "    x.sin()\n",
    "}\n",
    "\n",
    "println!(\"Derivatives of sin(x):\");\n",
    "for i in -3..=3 {\n",
    "    println!(\"{} {}\", i, derivative(sin_function, i as f64));\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47f78b64",
   "metadata": {},
   "source": [
    "### Example 2: Analyzing an Exponential Growth Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "60802361",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Derivatives of e^x:\n",
      "-3 0.04978709326752817\n",
      "-2 0.1353353508704025\n",
      "-1 0.3678796250961014\n",
      "1 2.7182831874306146\n",
      "2 7.38905979424942\n",
      "0 1.0000004999621837\n",
      "3 20.08554696786291\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn exponential_function(x: f64) -> f64 {\n",
    "    x.exp()\n",
    "}\n",
    "\n",
    "println!(\"Derivatives of e^x:\");\n",
    "for i in -3..=3 {\n",
    "    println!(\"{} {}\", i, derivative(exponential_function, i as f64));\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d225608d",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c8745b4",
   "metadata": {},
   "source": [
    "## Tangent Line Equation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35c17559",
   "metadata": {},
   "source": [
    "### The Equation of Tangent Lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "502bbabb",
   "metadata": {},
   "outputs": [],
   "source": [
    "fn f(x: f64) -> f64 {\n",
    "    // Define the curve equation here, for example, a quadratic function\n",
    "    // Let's use f(x) = x^2 - 3x + 2 as an example\n",
    "    x.powi(2) - 3.0 * x + 2.0\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "170eccd7",
   "metadata": {},
   "outputs": [],
   "source": [
    "fn slope(x1: f64, y1: f64, x2: f64, y2: f64) -> f64 {\n",
    "    (y2 - y1) / (x2 - x1)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8be2678e",
   "metadata": {},
   "outputs": [],
   "source": [
    "fn derivative(f: fn(f64) -> f64, x: f64) -> f64 {\n",
    "    const EPSILON: f64 = 1e-8;\n",
    "    let x1 = x - EPSILON;\n",
    "    let x2 = x + EPSILON;\n",
    "    let y1 = f(x1);\n",
    "    let y2 = f(x2);\n",
    "    (y2 - y1) / (x2 - x1)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "354d1ee0",
   "metadata": {},
   "outputs": [],
   "source": [
    "fn tangent_line(f: fn(f64) -> f64, x: f64) {\n",
    "    let m = derivative(f, x);\n",
    "    let y0 = f(x);\n",
    "    let b = y0 - m * x;\n",
    "\n",
    "    println!(\"Equation of the tangent line at x = {:.2} is: y = {:.2}x + {:.2}\", x, m, b);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4af4fba5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Equation of the tangent line at x = -0.48 is: y = -3.96x + 1.77\n",
      "Equation of the tangent line at x = 0.67 is: y = -1.66x + 1.55\n"
     ]
    }
   ],
   "source": [
    "let point_a_x = -0.48;\n",
    "let point_b_x = 0.67;\n",
    "\n",
    "tangent_line(f, point_a_x);\n",
    "tangent_line(f, point_b_x);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bc36c3f",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ef5ff91",
   "metadata": {},
   "source": [
    "## Calculating Integrals"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0fcf383",
   "metadata": {},
   "source": [
    "### Using Trapezoids"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcc71505",
   "metadata": {},
   "source": [
    "1. Convert angle from degrees to radians:\n",
    " \n",
    "#### $\\text{angle_in_radians} = \\text{angle} \\times \\frac{\\pi}{180}$\n",
    "\n",
    "#### $\\text{arc_length} = \\text{radius} \\times \\text{angle_in_radians}$\n",
    "\n",
    "3. Calculate the base length:\n",
    "\n",
    "#### $\\text{base_length} = 2 \\times \\text{radius} \\times \\sin(\\text{angle_in_radians})$\n",
    "\n",
    "4. Numerical integration using trapezoidal rule:\n",
    "\n",
    "#### $\\text{integral} = \\text{trap_integral}(f, 0, \\text{angle_in_radians}, 100)$\n",
    "\n",
    "   Where \n",
    "\n",
    "#### $ f(x) = \\text{radius} \\times \\cos(\\text{angle_in_radians}) \\times x$\n",
    "\n",
    "5. Area of circle sector:\n",
    "\n",
    "#### $\\text{area} = \\text{integral} - 0.5 \\times \\text{base_length} \\times \\text{arc_length}$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "581805c4",
   "metadata": {},
   "source": [
    "### Exercise 1: Finding the Area of a Circle Sector Using Trapezoids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "18116dd4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of a 30° sector: 5.95\n",
      "Area of a 45° sector: 12.79\n",
      "Area of a 60° sector: 21.30\n",
      "Area of a 90° sector: 39.27\n",
      "Area of a 150° sector: 47.56\n",
      "Area of a 120° sector: 50.83\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::f64::consts::PI;\n",
    "\n",
    "fn circle_sector_area(radius: f64, angle: f64) -> f64 {\n",
    "    let angle_in_radians = angle * PI / 180.0;\n",
    "    let arc_length = radius * angle_in_radians;\n",
    "    let base_length = 2.0 * radius * angle_in_radians.sin();\n",
    "\n",
    "    trap_integral(|x| radius * angle_in_radians.cos() * x, 0.0, angle_in_radians, 100) - 0.5 * base_length * arc_length\n",
    "}\n",
    "\n",
    "fn trap_integral<F>(f: F, a: f64, b: f64, num_trapezoids: usize) -> f64\n",
    "where\n",
    "    F: Fn(f64) -> f64,\n",
    "{\n",
    "    let width = (b - a) / num_trapezoids as f64;\n",
    "    let mut integral = 0.0;\n",
    "\n",
    "    for i in 0..num_trapezoids {\n",
    "        let x0 = a + i as f64 * width;\n",
    "        let x1 = x0 + width;\n",
    "        let y0 = f(x0);\n",
    "        let y1 = f(x1);\n",
    "        integral += 0.5 * width * (y0 + y1);\n",
    "    }\n",
    "\n",
    "    integral\n",
    "}\n",
    "\n",
    "    let radius = 5.0;\n",
    "    let angles = [30.0, 45.0, 60.0, 90.0, 120.0, 150.0];\n",
    "\n",
    "    for angle in angles.iter() {\n",
    "        let area = circle_sector_area(radius, *angle).abs();\n",
    "        println!(\"Area of a {}° sector: {:.2}\", angle, area);\n",
    "    }\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf9a4a80",
   "metadata": {},
   "source": [
    "### Exercise 2: Finding the Area of a Circle Sector Using Simpson's Rule"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a6cd5e2",
   "metadata": {},
   "source": [
    "1. Convert angle from degrees to radians:\n",
    "\n",
    "#### $\\text{angle_in_radians} = \\text{angle} \\times \\frac{\\pi}{180}$\n",
    "\n",
    "2. Calculate the arc length:\n",
    "\n",
    "#### $\\text{arc_length} = \\text{radius} \\times \\text{angle_in_radians}$\n",
    "\n",
    "3. Calculate the base length:\n",
    "\n",
    "#### $\\text{base_length} = 2 \\times \\text{radius} \\times \\sin(\\text{angle_in_radians})$\n",
    "\n",
    "4. Numerical integration using Simpson's rule:\n",
    "\n",
    "#### $\\text{integral} = \\text{simpson_integral}(f, 0, \\text{angle_in_radians}, 100)$\n",
    "\n",
    "Where\n",
    "\n",
    "#### $f(x) = \\text{radius} \\times \\cos(\\text{angle_in_radians}) \\times x$\n",
    "\n",
    "5. Area of circle sector:\n",
    "\n",
    "#### $\\text{area} = \\text{integral} - 0.5 \\times \\text{base_length} \\times \\text{arc_length}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "34cf606a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of a 30° sector: 5.95\n",
      "Area of a 45° sector: 12.79\n",
      "Area of a 60° sector: 21.30\n",
      "Area of a 90° sector: 39.27\n",
      "Area of a 120° sector: 50.83\n",
      "Area of a 150° sector: 47.56\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::f64::consts::PI;\n",
    "\n",
    "fn circle_sector_area(radius: f64, angle: f64) -> f64 {\n",
    "    let angle_in_radians = angle * PI / 180.0;\n",
    "    let arc_length = radius * angle_in_radians;\n",
    "    let base_length = 2.0 * radius * angle_in_radians.sin();\n",
    "\n",
    "    simpson_integral(|x| radius * angle_in_radians.cos() * x, 0.0, angle_in_radians, 100) - 0.5 * base_length * arc_length\n",
    "}\n",
    "\n",
    "fn simpson_integral<F>(f: F, a: f64, b: f64, num_intervals: usize) -> f64\n",
    "where\n",
    "    F: Fn(f64) -> f64,\n",
    "{\n",
    "    let h = (b - a) / (2.0 * num_intervals as f64);\n",
    "    let mut integral = f(a) + f(b);\n",
    "\n",
    "    for i in 1..(2 * num_intervals) {\n",
    "        let x = a + h * i as f64;\n",
    "        integral += if i % 2 == 0 { 2.0 } else { 4.0 } * f(x);\n",
    "    }\n",
    "\n",
    "    integral *= h / 3.0;\n",
    "    integral\n",
    "}\n",
    "\n",
    "let radius = 5.0;\n",
    "let angles = [30.0, 45.0, 60.0, 90.0, 120.0, 150.0];\n",
    "\n",
    "for angle in angles.iter() {\n",
    "    let area = circle_sector_area(radius, *angle).abs();\n",
    "    println!(\"Area of a {}° sector: {:.2}\", angle, area);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd9685d2",
   "metadata": {},
   "source": [
    "### Exercise 3: Finding the Area of a Circle Sector Using A Direct Formula"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "261ad753",
   "metadata": {},
   "source": [
    "#### $\\text{Area} = \\frac{\\text{angle_in_radians}}{2} \\times \\text{radius}^2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "652cb1f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of a 30° sector: 6.54\n",
      "Area of a 45° sector: 9.82\n",
      "Area of a 60° sector: 13.09\n",
      "Area of a 90° sector: 19.63\n",
      "Area of a 150° sector: 32.72\n",
      "Area of a 120° sector: 26.18\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "use std::f64::consts::PI;\n",
    "\n",
    "fn circle_sector_area(radius: f64, angle: f64) -> f64 {\n",
    "    let angle_in_radians = angle * PI / 180.0;\n",
    "    let area = (angle_in_radians / 2.0) * radius.powf(2.0);\n",
    "    area\n",
    "}\n",
    "\n",
    "    let radius = 5.0;\n",
    "    let angles = [30.0, 45.0, 60.0, 90.0, 120.0, 150.0];\n",
    "\n",
    "for angle in angles.iter() {\n",
    "    let area = circle_sector_area(radius, *angle).abs();\n",
    "    println!(\"Area of a {}° sector: {:.2}\", angle, area);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bbd0e9d",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e6efbe7",
   "metadata": {},
   "source": [
    "### Using Integrals to Solve Applied Problems"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "87e70bae",
   "metadata": {},
   "outputs": [],
   "source": [
    "fn f(x: f64) -> f64 {\n",
    "    x.sqrt()\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c23377c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "use std::f64::consts::PI;\n",
    "\n",
    "fn vol_solid(f: fn(f64) -> f64, a: f64, b: f64) -> f64 {\n",
    "    let mut volume = 0.0;\n",
    "    let num_slices = 1000;\n",
    "    let width = (b - a) / num_slices as f64;\n",
    "    for i in 0..num_slices {\n",
    "        let x = a + i as f64 * width;\n",
    "        let r = f(x);\n",
    "        let vol = PI * r.powi(2) * width;\n",
    "        volume += vol;\n",
    "    }\n",
    "    volume\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c36ae51a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5692255304681022"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let result = vol_solid(f, 0.0, 1.0);\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fa27228",
   "metadata": {},
   "source": [
    "### Exercise: Volume of a Cone"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b08209f9",
   "metadata": {},
   "source": [
    "1. Line segment `f(x) = x`:\n",
    "\n",
    "#### $f(x) = x$\n",
    "\n",
    "2. Volume of a cone using a given number of cylinders:\n",
    "\n",
    "#### $\\text{vol_cone}(f, a, b) = \\sum_{i=0}^{n-1} \\pi \\cdot r_i^2 \\cdot \\text{width}$\n",
    "\n",
    "Where:\n",
    "- `f` represents the function for the line segment.\n",
    "- `a` and `b` are the interval limits for the line segment.\n",
    "- `n` is the number of cylinders (num\\_cylinders in Rust code).\n",
    "- `r_i` is the value of `f(x)` for each cylinder.\n",
    "- `width` is the width of each cylinder, calculated as `(b - a) / n`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "99d5f34b",
   "metadata": {},
   "outputs": [],
   "source": [
    "fn f(x: f64) -> f64 {\n",
    "    x\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "c46aa2c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "fn vol_cone(f: fn(f64) -> f64, a: f64, b: f64) -> f64 {\n",
    "    let mut volume = 0.0;\n",
    "    let num_cylinders = 10000;\n",
    "    let width = (b - a) / num_cylinders as f64;\n",
    "\n",
    "    for i in 0..num_cylinders {\n",
    "        let x = a + i as f64 * width;\n",
    "        let r = f(x);\n",
    "        let vol = PI * r.powi(2) * width;\n",
    "        volume += vol;\n",
    "    }\n",
    "\n",
    "    volume\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "c3157aa2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Volume of the cone: 130.88\n"
     ]
    }
   ],
   "source": [
    "let result = vol_cone(f, 0.0, 5.0);\n",
    "println!(\"Volume of the cone: {:.2}\", result);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca4687e0",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ebace14",
   "metadata": {},
   "source": [
    "## Using Derivatives to Solve Optimization Problems"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd5059fd",
   "metadata": {},
   "source": [
    "### Exercise 1: Maximizing a Cubic Function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b0b1506",
   "metadata": {},
   "source": [
    "The Newton-Raphson method is based on the following iteration formula:\n",
    "\n",
    "#### $x_{n+1} = x_n - \\frac{f(x_n)}{f'(x_n)}$\n",
    "\n",
    "Where:\n",
    "- `x_n` is the current approximation for the critical point (initially set to the `initial_guess`).\n",
    "- `x_{n+1}` is the next approximation.\n",
    "- `f(x_n)` and `f'(x_n)` are the function value and derivative at `x_n`, respectively.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6421eac2",
   "metadata": {},
   "source": [
    "1. Cubic function:\n",
    "\n",
    "#### $f(x) = -x^3 + 3x^2 + 9x - 8$\n",
    "\n",
    "2. Derivative of the cubic function:\n",
    "\n",
    "#### $f'(x) = -3x^2 + 6x + 9$\n",
    "\n",
    "3. Newton-Raphson iteration formula:\n",
    "\n",
    "#### $x_{n+1} = x_n - \\frac{f(x_n)}{f'(x_n)}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "e9b923e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Local maximum at x = 0.75\n"
     ]
    }
   ],
   "source": [
    "fn f(x: f64) -> f64 {\n",
    "    -x.powi(3) + 3.0 * x.powi(2) + 9.0 * x - 8.0\n",
    "}\n",
    "\n",
    "fn f_prime(x: f64) -> f64 {\n",
    "    -3.0 * x.powi(2) + 6.0 * x + 9.0\n",
    "}\n",
    "\n",
    "fn newton_method(f: fn(f64) -> f64, f_prime: fn(f64) -> f64, initial_guess: f64, max_iterations: usize) -> f64 {\n",
    "    let mut x = initial_guess;\n",
    "    let mut iterations = 0;\n",
    "    let tolerance = 1e-6;\n",
    "\n",
    "    while iterations < max_iterations {\n",
    "        let delta = f(x) / f_prime(x);\n",
    "        x -= delta;\n",
    "\n",
    "        if delta.abs() < tolerance {\n",
    "            break;\n",
    "        }\n",
    "\n",
    "        iterations += 1;\n",
    "    }\n",
    "\n",
    "    x\n",
    "}\n",
    "\n",
    "let critical_point = newton_method(f, f_prime, 0.0, 100);\n",
    "println!(\"Local maximum at x = {:.2}\", critical_point);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3180fa95",
   "metadata": {},
   "source": [
    "### Exercise 2: Minimizing Total Cost"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eebcb45f",
   "metadata": {},
   "source": [
    "1. Cost function:\n",
    "\n",
    "#### $\\text{cost}(x) = 5000 + 20x$\n",
    "\n",
    "2. Revenue function:\n",
    "\n",
    "#### $\\text{revenue}(x) = 50x$\n",
    "\n",
    "3. Profit function:\n",
    "\n",
    "#### $\\text{profit}(x) = \\text{revenue}(x) - \\text{cost}(x)$\n",
    "\n",
    "4. Derivative of the profit function:\n",
    "\n",
    "#### $\\text{profit_prime}(x) = 50 - 20$\n",
    "\n",
    "5. Newton-Raphson iteration formula:\n",
    "\n",
    "#### $x_{n+1} = x_n - \\frac{\\text{profit}(x_n)}{\\text{profit_prime}(x_n)}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "6f7622aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal price: $166.67\n"
     ]
    }
   ],
   "source": [
    "fn cost(x: f64) -> f64 {\n",
    "    5000.0 + 20.0 * x\n",
    "}\n",
    "\n",
    "fn revenue(x: f64) -> f64 {\n",
    "    50.0 * x\n",
    "}\n",
    "\n",
    "fn profit(x: f64) -> f64 {\n",
    "    revenue(x) - cost(x)\n",
    "}\n",
    "\n",
    "fn profit_prime(x: f64) -> f64 {\n",
    "    50.0 - 20.0\n",
    "}\n",
    "\n",
    "fn newton_method(f: fn(f64) -> f64, f_prime: fn(f64) -> f64, initial_guess: f64, max_iterations: usize) -> f64 {\n",
    "    let mut x = initial_guess;\n",
    "    let mut iterations = 0;\n",
    "    let tolerance = 1e-6;\n",
    "\n",
    "    while iterations < max_iterations {\n",
    "        let delta = f(x) / f_prime(x);\n",
    "        x -= delta;\n",
    "\n",
    "        if delta.abs() < tolerance {\n",
    "            break;\n",
    "        }\n",
    "\n",
    "        iterations += 1;\n",
    "    }\n",
    "\n",
    "    x\n",
    "}\n",
    "\n",
    "let optimal_price = newton_method(profit, profit_prime, 50.0, 100);\n",
    "println!(\"Optimal price: ${:.2}\", optimal_price);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b758ba9",
   "metadata": {},
   "source": [
    "### Exercise 3: Maximizing Profit in a Market"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d02bc6ea",
   "metadata": {},
   "source": [
    "1. Demand Function:\n",
    "\n",
    "The demand function `demand(x)` represents the quantity of the product demanded by consumers at a given price `x`. It is defined as:\n",
    "\n",
    "#### $\\text{demand}(x) = 100 - x$\n",
    "\n",
    "2. Supply Function:\n",
    "\n",
    "The supply function `supply(x)` represents the quantity of the product supplied by producers at a given price `x`. It is defined as:\n",
    "\n",
    "#### $\\text{supply}(x) = 20 + 2x$\n",
    "\n",
    "3. Profit Function:|\n",
    "\n",
    "The profit function `profit(x)` calculates the profit obtained from selling `x` units of the product at a given price. It is defined as the difference between the revenue (price times quantity) and the total cost:\n",
    "\n",
    "#### $\\text{profit}(x) = \\text{demand}(x) \\cdot x - (20 + 2x) \\cdot x$\n",
    "\n",
    "4. Derivative of the Profit Function:\n",
    "\n",
    "To maximize the profit, we find the critical points of the profit function. The derivative of the profit function with respect to `x`, denoted as `profit_prime(x)`, represents the rate of change of profit with respect to the quantity `x`:\n",
    "\n",
    "#### $\\text{profit_prime}(x) = \\text{demand}(x) - 2x - (20 + 2x)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "81a14b23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Equilibrium quantity: 0.00 units\n"
     ]
    }
   ],
   "source": [
    "fn demand(x: f64) -> f64 {\n",
    "    100.0 - x\n",
    "}\n",
    "\n",
    "fn supply(x: f64) -> f64 {\n",
    "    20.0 + 2.0 * x\n",
    "}\n",
    "\n",
    "fn price(x: f64) -> f64 {\n",
    "    (demand(x) + supply(x)) / 2.0\n",
    "}\n",
    "\n",
    "fn profit(x: f64) -> f64 {\n",
    "    price(x) * x - (20.0 + 2.0 * x) * x\n",
    "}\n",
    "\n",
    "fn profit_prime(x: f64) -> f64 {\n",
    "    100.0 - 4.0 * x\n",
    "}\n",
    "\n",
    "fn newton_method(f: fn(f64) -> f64, f_prime: fn(f64) -> f64, initial_guess: f64, max_iterations: usize) -> f64 {\n",
    "    let mut x = initial_guess;\n",
    "    let mut iterations = 0;\n",
    "    let tolerance = 1e-6;\n",
    "\n",
    "    while iterations < max_iterations {\n",
    "        let delta = f(x) / f_prime(x);\n",
    "        x -= delta;\n",
    "\n",
    "        if delta.abs() < tolerance {\n",
    "            break;\n",
    "        }\n",
    "\n",
    "        iterations += 1;\n",
    "    }\n",
    "\n",
    "    x\n",
    "}\n",
    "\n",
    "let equilibrium_quantity = newton_method(profit, profit_prime, 20.0, 100);\n",
    "println!(\"Equilibrium quantity: {:.2} units\", equilibrium_quantity);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fde5f6a",
   "metadata": {},
   "source": [
    "### Exercise 4: Minimizing Loss"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28000683",
   "metadata": {},
   "source": [
    "1. Stock Value Function:\n",
    "\n",
    "The stock value function `stock_value(t)` represents the value of the stock at time `t`. It is defined as:\n",
    "\n",
    "#### $\\text{stock_value}(t) = 1000 - 20t + 3t^2$\n",
    "\n",
    "2. Stock Loss Function:\n",
    "\n",
    "The stock loss function `stock_loss(t)` represents the loss incurred from holding the stock at time `t`. It is defined as the difference between the initial investment (1000 units) and the value of the stock at time `t`:\n",
    "\n",
    "#### $\\text{stock_loss}(t) = 1000 - \\text{stock_value}(t)$\n",
    "\n",
    "3. Derivative of the Stock Value Function:\n",
    "\n",
    "To find the time of minimum loss, we need to find the critical point of the stock loss function. For that, we calculate the derivative of the stock value function with respect to `t`, denoted as `stock_value_prime(t)`. It represents the rate of change of the stock value with respect to time `t`:\n",
    "\n",
    "#### $\\text{stock_value_prime}(t) = -20 + 6t$\n",
    "\n",
    "4. Derivative of the Stock Loss Function:\n",
    "\n",
    "The derivative of the stock loss function with respect to `t`, denoted as `stock_loss_prime(t)`, can be obtained as the negative of the derivative of the stock value function:\n",
    "\n",
    "#### $\\text{stock_loss_prime}(t) = -\\text{stock_value_prime}(t)$\n",
    "\n",
    "5. Newton-Raphson Method:\n",
    "\n",
    "The Newton-Raphson method is used to find the time of minimum loss, which corresponds to the critical point of the stock loss function.\n",
    "\n",
    "6. Finding Time of Minimum Loss and Minimum Loss Amount:\n",
    "\n",
    "In the `main` function, we use the `newton_method` to find the time at which the stock experiences the minimum loss and calculate the corresponding minimum loss amount using the `stock_loss` function:\n",
    "\n",
    "#### $\\text{Time of minimum loss:} \\text{time_min_loss} \\text{months}$\n",
    "#### $\\text{Minimum loss:} \\text{{min_loss}}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "9d3d1fd3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time of minimum loss: 6.67 months\n",
      "Minimum loss: $-0.00\n"
     ]
    }
   ],
   "source": [
    "fn stock_value(t: f64) -> f64 {\n",
    "    1000.0 - 20.0 * t + 3.0 * t.powi(2)\n",
    "}\n",
    "\n",
    "fn stock_loss(t: f64) -> f64 {\n",
    "    1000.0 - stock_value(t)\n",
    "}\n",
    "\n",
    "fn stock_value_prime(t: f64) -> f64 {\n",
    "    -20.0 + 6.0 * t\n",
    "}\n",
    "\n",
    "fn stock_loss_prime(t: f64) -> f64 {\n",
    "    -stock_value_prime(t)\n",
    "}\n",
    "\n",
    "fn newton_method(f: fn(f64) -> f64, f_prime: fn(f64) -> f64, initial_guess: f64, max_iterations: usize) -> f64 {\n",
    "    let mut x = initial_guess;\n",
    "    let mut iterations = 0;\n",
    "    let tolerance = 1e-6;\n",
    "\n",
    "    while iterations < max_iterations {\n",
    "        let delta = f(x) / f_prime(x);\n",
    "        x -= delta;\n",
    "\n",
    "        if delta.abs() < tolerance {\n",
    "            break;\n",
    "        }\n",
    "\n",
    "        iterations += 1;\n",
    "    }\n",
    "\n",
    "    x\n",
    "}\n",
    "\n",
    "let time_min_loss = newton_method(stock_loss, stock_loss_prime, 5.0, 100);\n",
    "let min_loss = stock_loss(time_min_loss);\n",
    "\n",
    "println!(\"Time of minimum loss: {:.2} months\", time_min_loss);\n",
    "println!(\"Minimum loss: ${:.2}\", min_loss);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a1e851a",
   "metadata": {},
   "source": [
    "### Exercise 5: Maximizing Crop Yield"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "694f2a80",
   "metadata": {},
   "source": [
    "1. Objective Function:\n",
    "\n",
    "#### $\\text{crop_yield}(length, width) = \\text{length} \\times \\text{width}$\n",
    "\n",
    "2. Partial Derivatives:\n",
    "\n",
    "#### $\\frac{\\partial \\text{crop_yield}}{\\partial \\text{length}} = \\text{width}$\n",
    "#### $\\frac{\\partial \\text{crop_yield}}{\\partial \\text{width}} = \\text{length}$\n",
    "\n",
    "3. Jacobian Determinant:\n",
    "#### $\\text{determinant} = \\frac{\\partial \\text{crop_yield}}{\\partial \\text{length}} \\times \\frac{\\partial \\text{crop_yield}}{\\partial \\text{width}} - \\frac{\\partial \\text{crop_yield}}{\\partial \\text{width}} \\times \\frac{\\partial \\text{crop_yield}}{\\partial \\text{length}}$\n",
    "\n",
    "4. Newton's Method Updates:\n",
    "#### $\\text{length}_{\\text{new}} = \\text{length}_{\\text{old}} - \\frac{\\frac{\\partial \\text{crop_yield}}{\\partial \\text{width}} \\times \\Delta y - \\frac{\\partial \\text{crop_yield}}{\\partial \\text{length}} \\times \\Delta x}{\\text{determinant}}$\n",
    "#### $\\text{width}_{\\text{new}} = \\text{width}_{\\text{old}} - \\frac{\\frac{\\partial \\text{crop_yield}}{\\partial \\text{length}} \\times \\Delta x - \\frac{\\partial \\text{crop|_yield}}{\\partial \\text{width}} \\times \\Delta y}{\\text{determinant}}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "ec9f12b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximized crop yield: 400.00 square meters\n",
      "Dimensions of the rectangular field: 20.00 meters x 20.00 meters\n"
     ]
    }
   ],
   "source": [
    "fn crop_yield(length: f64, width: f64) -> f64 {\n",
    "    length * width\n",
    "}\n",
    "\n",
    "fn crop_yield_prime_length(length: f64, width: f64) -> f64 {\n",
    "    width\n",
    "}\n",
    "\n",
    "fn crop_yield_prime_width(length: f64, width: f64) -> f64 {\n",
    "    length\n",
    "}\n",
    "\n",
    "fn newton_method_2d(\n",
    "    f_prime_x: fn(f64, f64) -> f64,\n",
    "    f_prime_y: fn(f64, f64) -> f64,\n",
    "    initial_guess_x: f64,\n",
    "    initial_guess_y: f64,\n",
    "    max_iterations: usize,\n",
    ") -> (f64, f64) {\n",
    "    let mut x = initial_guess_x;\n",
    "    let mut y = initial_guess_y;\n",
    "    let tolerance = 1e-6;\n",
    "\n",
    "    for _ in 0..max_iterations {\n",
    "        let delta_x = f_prime_x(x, y);\n",
    "        let delta_y = f_prime_y(x, y);\n",
    "\n",
    "        let determinant = delta_x * delta_y - crop_yield_prime_width(x, y) * crop_yield_prime_length(x, y);\n",
    "        if determinant.abs() < 1e-6 {\n",
    "            break;\n",
    "        }\n",
    "\n",
    "        let delta_length = (crop_yield_prime_width(x, y) * delta_y - delta_x * crop_yield_prime_length(x, y)) / determinant;\n",
    "        let delta_width = (delta_x * crop_yield_prime_width(x, y) - delta_y * crop_yield_prime_length(x, y)) / determinant;\n",
    "\n",
    "        x -= delta_length;\n",
    "        y -= delta_width;\n",
    "\n",
    "        if delta_length.abs() < tolerance && delta_width.abs() < tolerance {\n",
    "            break;\n",
    "        }\n",
    "    }\n",
    "\n",
    "    (x, y)\n",
    "}\n",
    "\n",
    "let (length, width) = newton_method_2d(crop_yield_prime_length, crop_yield_prime_width, 20.0, 20.0, 100);\n",
    "let yield_max = crop_yield(length, width);\n",
    "\n",
    "println!(\"Maximized crop yield: {:.2} square meters\", yield_max);\n",
    "println!(\"Dimensions of the rectangular field: {:.2} meters x {:.2} meters\", length, width);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90817bb2",
   "metadata": {},
   "source": [
    "<hr />"
   ]
  }
 ],
 "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
}