Multiple Dispatch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e6bc3dc4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "person_info (generic function with 4 methods)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "struct Person\n",
    "    name::String\n",
    "end\n",
    "\n",
    "struct Student\n",
    "    name::String\n",
    "    grade::Int\n",
    "end\n",
    "\n",
    "struct Group\n",
    "    name::String\n",
    "    group::String\n",
    "end\n",
    "\n",
    "person_info(p::Person) = println(\"The name of the person: \",p.name)\n",
    "person_info(p::Student) = println(\"Name of the student: \",p.name *\" and their grade: \",p.grade)\n",
    "person_info(p::Group) = println(\"Name of the group: \"*p.name *\" and their group: \"*p.group)\n",
    "person_info(_) = throw(ArgumentError(\"Type Error\")) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "24e1d375",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The name of the person: John\n",
      "Name of the student: Alice and their grade: 10\n",
      "Name of the group: Bob and their group: Team A\n"
     ]
    },
    {
     "ename": "LoadError",
     "evalue": "ArgumentError: Type Error",
     "output_type": "error",
     "traceback": [
      "ArgumentError: Type Error",
      "",
      "Stacktrace:",
      " [1] person_info(::String)",
      "   @ Main .\\In[6]:18",
      " [2] top-level scope",
      "   @ In[7]:11"
     ]
    }
   ],
   "source": [
    "# Test cases\n",
    "p = Person(\"John\")\n",
    "s = Student(\"Alice\", 10)\n",
    "g = Group(\"Bob\", \"Team A\")\n",
    "\n",
    "person_info(p)  # Output: Name: John\n",
    "person_info(s)  # Output: Name: Alice, Grade: 10\n",
    "person_info(g)  # Output: Name: Bob, Group: Team A\n",
    "\n",
    "# Error case\n",
    "person_info(\"Not a person\")  # Throws ArgumentError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "dc72503d",
   "metadata": {},
   "outputs": [],
   "source": [
    "struct Range{T}\n",
    "    start::T\n",
    "    step::T\n",
    "    stop::T\n",
    "end\n",
    "\n",
    "function Base.getindex(r::Range,i::T) where T\n",
    "    if i<1 || i > ceil(Int, (r.stop - r.start) / r.step) + 1\n",
    "        throw(ArgumentError(\"Incorrect Parameter\"))\n",
    "    end\n",
    "    return r.start + (i-1)*r.step\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "349f5ca2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "0.5\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "# Test the range\n",
    "r = Range(0.0, 0.5, 1.0)\n",
    "println(r[1])  # Should print 0.0\n",
    "println(r[2])  # Should print 0.5\n",
    "println(r[3])  # Should print 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "56341ddc",
   "metadata": {},
   "outputs": [],
   "source": [
    "function Base.iterate(r::Range,state::T = 1) where T\n",
    "    if state < 1 || state > ceil(Int, (r.stop - r.start) / r.step) + 1\n",
    "        return nothing\n",
    "    end\n",
    "    value = r.start + (state - 1) * r.step\n",
    "    return (value, state + 1)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d56543b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "r = 0.0\n",
      "r = 0.5\n",
      "r = 1.0\n"
     ]
    }
   ],
   "source": [
    "# Extend length function for MyRange\n",
    "function Base.length(r::Range{T}) where T\n",
    "    return ceil(Int, (r.stop - r.start) / r.step) + 1\n",
    "end\n",
    "\n",
    "# Test iterate for MyRange by using it in a for loop\n",
    "for r in Range(0.0, 0.5, 1.0)\n",
    "    @show r\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "1e926db0",
   "metadata": {},
   "outputs": [],
   "source": [
    "struct CustomIterator\n",
    "    n::Int\n",
    "    current::Float64\n",
    "    step::Int\n",
    "end\n",
    "\n",
    "function Base.iterate(itr::CustomIterator, state=1)\n",
    "    if state > itr.n\n",
    "        return nothing\n",
    "    elseif state == 1\n",
    "        return (itr.current, 2)\n",
    "    elseif itr.step % 2 == 0\n",
    "        itr.current *= rand()\n",
    "    else\n",
    "        itr.current /= rand()\n",
    "    end\n",
    "    return (itr.current, state + 1)\n",
    "end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "511e171f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18ee8602",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b717741",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fa8e5cf2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RationalNumber(5, 10) = RationalNumber(1, 2)\n",
      "r2 + r3 = RationalNumber(5, 6)\n",
      "r2 - r3 = RationalNumber(1, 6)\n",
      "r2 * r3 = RationalNumber(1, 6)\n",
      "r2 / r3 = RationalNumber(3, 2)\n"
     ]
    }
   ],
   "source": [
    "struct RationalNumber <: Real\n",
    "    numerator::Int\n",
    "    denominator::Int\n",
    "\n",
    "    function RationalNumber(numerator::Int, denominator::Int)\n",
    "        num, denom = simplify(numerator, denominator)\n",
    "        return new(num, denom)\n",
    "    end\n",
    "end\n",
    "\n",
    "function simplify(n::Integer, d::Integer)\n",
    "    g = gcd(n, d)\n",
    "    m = d < 0 ? -1 : 1\n",
    "    return (m * n ÷ g, m * d ÷ g)\n",
    "end\n",
    "\n",
    "import Base: +, -, *, /\n",
    "\n",
    "+(r1::RationalNumber, r2::RationalNumber) = RationalNumber(r1.numerator * r2.denominator + r2.numerator * r1.denominator,\n",
    "                                                            r1.denominator * r2.denominator)\n",
    "-(r1::RationalNumber, r2::RationalNumber) = RationalNumber(r1.numerator * r2.denominator - r2.numerator * r1.denominator,\n",
    "                                                            r1.denominator * r2.denominator)\n",
    "*(r1::RationalNumber, r2::RationalNumber) = RationalNumber(r1.numerator * r2.numerator, r1.denominator * r2.denominator)\n",
    "/(r1::RationalNumber, r2::RationalNumber) = RationalNumber(r1.numerator * r2.denominator, r1.denominator * r2.numerator)\n",
    "\n",
    "# Test the RationalNumber type\n",
    "r1 = RationalNumber(5, 10)\n",
    "println(\"RationalNumber(5, 10) = \", r1)  # Output: RationalNumber(1, 2)\n",
    "\n",
    "r2 = RationalNumber(1, 2)\n",
    "r3 = RationalNumber(1, 3)\n",
    "\n",
    "println(\"r2 + r3 = \", r2 + r3)  # Output: RationalNumber(5, 6)\n",
    "println(\"r2 - r3 = \", r2 - r3)  # Output: RationalNumber(1, 6)\n",
    "println(\"r2 * r3 = \", r2 * r3)  # Output: RationalNumber(1, 6)\n",
    "println(\"r2 / r3 = \", r2 / r3)  # Output: RationalNumber(3, 2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "95aacb7d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RationalNumber(1, 2)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "RationalNumber(5,10)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.10.0",
   "language": "julia",
   "name": "julia-1.10"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}