Assignment1/Vasantha_204102302/ML ( Assignment-1) (2).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1.Print hello world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "print('Hello World!')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2.Algebraic expressions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter the value of a =5\n",
      "enter the value of b =10\n",
      "c=a+b= 15\n",
      "d=a-b= -5\n",
      "e=a*b= 50\n",
      "f=a/b= 0.5\n",
      "g=a%b= 5\n"
     ]
    }
   ],
   "source": [
    "a=int(input('enter the value of a ='))\n",
    "b=int(input('enter the value of b ='))\n",
    "c=a+b\n",
    "d=a-b\n",
    "e=a*b\n",
    "f=a/b\n",
    "g=a%b\n",
    "print('c=a+b=',c)\n",
    "print('d=a-b=',d)\n",
    "print('e=a*b=',e)\n",
    "print('f=a/b=',f)\n",
    "print('g=a%b=',g)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3.Factorial of a number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter the value of x=5\n",
      "factorial of a number is = 120\n"
     ]
    }
   ],
   "source": [
    "num=1\n",
    "x=int(input('enter the value of x='))\n",
    "while x<x+1:       \n",
    "    num=num*x\n",
    "    x-=1\n",
    "    if x==0:\n",
    "         break\n",
    "print('factorial of a number is =',num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4.Prime numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 5, 7, 11, 13, 17, 19, 23, 29]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list=[]\n",
    "def prime(a,b):\n",
    "    for i in range(a,b+1):\n",
    "        if i>1:\n",
    "            for j in range(2,i):\n",
    "                if i % j == 0:\n",
    "                    break\n",
    "            else:\n",
    "                    list.append(i)\n",
    "    return list\n",
    "prime(3,30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5.Lcm of two numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Lcm of x and y is= 12\n"
     ]
    }
   ],
   "source": [
    "def compute_Lcm(x, y):\n",
    "    if x > y:\n",
    "        greater = x\n",
    "    else:\n",
    "        greater = y\n",
    "\n",
    "    while(True):\n",
    "        if((greater % x == 0) and (greater % y == 0)):\n",
    "            Lcm = greater\n",
    "            break\n",
    "        greater += 1\n",
    "    print('The Lcm of x and y is=',Lcm)\n",
    "compute_Lcm(12,6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6.Bubblesort algorithm(descending order)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[66, 54, 35, 33, 23, 16, 12, 11, 9, 8, 6, 5, 3, 2, 1]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def bubble(arr):\n",
    "    n=len(arr)\n",
    "    for i in range(n-1):\n",
    "        for j in range(0,n-i-1):\n",
    "            if arr[j]<arr[j+1]:\n",
    "                arr[j],arr[j+1]=arr[j+1],arr[j]\n",
    "    return arr\n",
    "bubble([3,1,5,2,6,8,9,12,11,33,23,54,66,16,35])\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7.Ascending order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  2  3  5  6  8  9 11 12 16 23 33 35 54 66]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "bubble=np.array([3,1,5,2,6,8,9,12,11,33,23,54,66,16,35])\n",
    "bubble[::1].sort()\n",
    "print(bubble)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8.Print matrix in range (-2,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter rows=3\n",
      "enter columns=3\n",
      "[[ 1 -2  1]\n",
      " [ 4 -2  0]\n",
      " [ 0  1  1]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "m= int(input('enter rows='))\n",
    "n= int(input('enter columns='))\n",
    "a=np.random.randint(-2,5,size=(m,n))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9.Multiply two matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter number  [0] [0]1\n",
      "enter number  [0] [1]2\n",
      "enter number  [0] [2]3\n",
      "enter number  [1] [0]4\n",
      "enter number  [1] [1]5\n",
      "enter number  [1] [2]6\n",
      "enter number  [2] [0]7\n",
      "enter number  [2] [1]8\n",
      "enter number  [2] [2]9\n",
      "enter number  [0] [0]1\n",
      "enter number  [0] [1]2\n",
      "enter number  [0] [2]3\n",
      "enter number  [1] [0]4\n",
      "enter number  [1] [1]5\n",
      "enter number  [1] [2]6\n",
      "enter number  [2] [0]7\n",
      "enter number  [2] [1]8\n",
      "enter number  [2] [2]9\n",
      "first matrix is =\n",
      "1 2 3 \n",
      "4 5 6 \n",
      "7 8 9 \n",
      "second matrix is =\n",
      "1 2 3 \n",
      "4 5 6 \n",
      "7 8 9 \n",
      "multiplication of two matrices is = \n",
      "30 36 42 \n",
      "66 81 96 \n",
      "102 126 150 \n"
     ]
    }
   ],
   "source": [
    "m = []\n",
    "for i in range(3):\n",
    "    a = []\n",
    "    for j in range(3):\n",
    "        j = int(input(\"enter number  [\"+str(i)+\"] [\"+str(j)+\"]\"))\n",
    "        a.append(j)\n",
    "    m.append(a)\n",
    "n = []\n",
    "for i in range(3):\n",
    "    b = []\n",
    "    for j in range(3):\n",
    "        j =  int(input(\"enter number  [\"+str(i)+\"] [\"+str(j)+\"]\"))\n",
    "        b.append(j)\n",
    "    n.append(b)\n",
    "print(\"first matrix is =\")\n",
    "for i in range (3):\n",
    "    for j in range(3):\n",
    "        print(m[i][j],end=\" \")\n",
    "    print()\n",
    "print(\"second matrix is =\")\n",
    "for i in range (3):\n",
    "    for j in range(3):\n",
    "        print(m[i][j],end=\" \")\n",
    "    print()\n",
    "result = [[0,0,0],[0,0,0],[0,0,0]]\n",
    "for i in range(3):\n",
    "    for j in range(3):\n",
    "        for k in range(3):\n",
    "            result[i][j] = result[i][j] + m[i][k]*n[k][j]\n",
    "print(\"multiplication of two matrices is = \")\n",
    "for i in range(3):\n",
    "    for j in range(3):\n",
    "        print(result[i][j],end = \" \")\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10.Write file operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[305 980 385 126 554 527 444 369 560 119 885 713 406 154 671 611 439 566\n",
      " 304 939 348 528 738  93 442 682 688 847 644 155  16 175 416  91 251 939\n",
      " 328 102 923 995 967 226 154 524 609 897 875 238  32 540 587 675 122 730\n",
      " 774 858 890 670 185 403 762 793  34 610 188 932  65 185 304 232 917 202\n",
      " 614 744 138 539  99 229 947 708 583 213 917 446  86 952 611 467 152  73\n",
      " 856 814 195 801 645 469 282 595 999 372]\n"
     ]
    }
   ],
   "source": [
    "import csv\n",
    "from numpy import random \n",
    "import numpy as np\n",
    "n = random.randint(1000,size=(100))\n",
    "print(n)\n",
    "file=\"File.csv\"\n",
    "with open(file, 'w') as csvfile:\n",
    "    csvwriter = csv.writer(csvfile)\n",
    "    csvwriter.writerow(['Num'])\n",
    "    csvwriter.writerow(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 11. Read file operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "import numpy\n",
    "reader=[]\n",
    "csv.reader(open(\"Random.csv\",\"rb\"),delimiter=\",\")\n",
    "x = reader\n",
    "result = numpy.array(x).astype(\"float\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 12.Complex number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c1 = (5+6j)\n",
      "c2 = (7+8j)\n",
      "addition = (12+14j)\n",
      "subraction = (-2-2j)\n",
      "multiplication = (-13+82j)\n",
      "division = (0.7345132743362832+0.017699115044247787j)\n",
      "absolute value c1 = 7.810249675906654\n",
      "absolute value c2 = 10.63014581273465\n",
      "phase c1 = 0.8760580505981934\n",
      "phase c2 = 0.8519663271732721\n",
      "conj c1 = (5-6j)\n",
      "conj c2 = (7-8j)\n"
     ]
    }
   ],
   "source": [
    "import cmath\n",
    "from math import sqrt\n",
    "\n",
    "class Complex(object):\n",
    "\n",
    "    def __init__(self, real, imag):\n",
    "        self.real = real\n",
    "        self.imag = imag\n",
    "        \n",
    "    def __add__(self, other):\n",
    "        return Complex(self.real + other.real, self.imag + other.imag)\n",
    "\n",
    "    def __sub__(self, other):\n",
    "        return Complex(self.real - other.real, self.imag - other.imag)\n",
    "    \n",
    "    def __mul__(self, other):\n",
    "        return Complex((self.real * other.real) - (self.imag * other.imag),\n",
    "            (self.imag * other.real) + (self.real * other.imag))\n",
    "\n",
    "    def __div__(self, other):\n",
    "        r = (other.real**2 + other.imag**2)\n",
    "        return Complex((self.real*other.real - self.imag*other.imag)/r,\n",
    "            (self.imag*other.real + self.real*other.imag)/r)\n",
    "\n",
    "    def __abs__(self):\n",
    "        return ((self.real**2) + (self.imag**2))**0.5\n",
    "    \n",
    "    def __conjugate__(self):\n",
    "        return complex(self.real,-self.imag)\n",
    "    def __phase__(self):\n",
    "        return cmath.phase(self)\n",
    "    \n",
    "    \n",
    "c1=complex(5,6)\n",
    "c2=complex(7,8)\n",
    "print('c1 =',c1)\n",
    "print('c2 =',c2)\n",
    "addition=c1+c2\n",
    "print('addition =',addition)\n",
    "subraction=c1-c2\n",
    "print('subraction =',subraction)\n",
    "multiplication=c1*c2\n",
    "print('multiplication =',multiplication)\n",
    "division=c1/c2\n",
    "print('division =',division)\n",
    "absolute_value =(c1.real**2+c1.imag**2)**0.5\n",
    "print('absolute value c1 =',absolute_value)\n",
    "absolute_value =(c2.real**2+c2.imag**2)**0.5\n",
    "print('absolute value c2 =',absolute_value)\n",
    "phase =cmath.phase(c1)\n",
    "print('phase c1 =',phase )\n",
    "phase =cmath.phase(c2)\n",
    "print('phase c2 =',phase )\n",
    "conjugate=complex(c1.real,-c1.imag)\n",
    "print('conj c1 =',conjugate)\n",
    "conjugate=complex(c2.real,-c2.imag)\n",
    "print('conj c2 =',conjugate)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 13.Plot the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "x = np.arange(-10,10)\n",
    "y = 3*x+2\n",
    "plt.xlim(-10,10)\n",
    "plt.plot(x, y,label='y=3x+2',c='r')\n",
    "plt.title('Graph of y=2x+1')\n",
    "plt.xlabel('X-AXIS', c='b')\n",
    "plt.ylabel('Y-AXIS', c='b')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}