Aftab_PIAIC102905_Quater_02.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled0.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyOMkf3mrt1RVHlUklwMuhwW",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/AftabUfaq/PIAIC_QUARTER_02/blob/main/Aftab_PIAIC102905_Quater_02.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y_gp82U5dZqE"
      },
      "source": [
        "Name: Aftab\r\n",
        "\r\n",
        "Student ID: PIAIC102905\r\n",
        "\r\n",
        "Quarter No: Q2\r\n",
        "\r\n",
        "Assignment: 01\r\n",
        "\r\n",
        "Numpy 50 function Implemetation\r\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bq_UNmd_d269"
      },
      "source": [
        "Intorduction to NUmpy: \r\n",
        "NumPy is a Python package. It stands for 'Numerical Python'. It is a library consisting of multidimensional array objects and a collection of routines for processing of array."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3hC6fDEMeDT7"
      },
      "source": [
        "# function 1 sin\r\n",
        "# Python program explaining\r\n",
        "# sin() function\r\n",
        " \r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        " \r\n",
        "in_array = [0, math.pi / 2, np.pi / 3, np.pi]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "Sin_Values = np.sin(in_array)\r\n",
        "print (\"\\nSine values : \\n\", Sin_Values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EG5-9orVeRKM"
      },
      "source": [
        "Function 2 cos"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p-F1QpaBeVy5"
      },
      "source": [
        "#  function 2 cos\r\n",
        "# Python program explaining\r\n",
        "# cos() function\r\n",
        " \r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        " \r\n",
        "in_array = [0, math.pi / 2, np.pi / 3, np.pi]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "cos_Values = np.cos(in_array)\r\n",
        "print (\"\\nCosine values : \\n\", cos_Values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HQw89BzFexdO"
      },
      "source": [
        "# function 3 sinh\r\n",
        "# Python3 program explaining\r\n",
        "# sinh() function\r\n",
        " \r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        " \r\n",
        "in_array = [0, math.pi / 2, np.pi / 3, np.pi]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "Sinh_Values = np.sinh(in_array)\r\n",
        "print (\"\\nSine Hyperbolic values : \\n\", Sinh_Values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8c1vxo5Qe5pG"
      },
      "source": [
        "# function 4 cosh\r\n",
        "# Python3 program explaining\r\n",
        "# cosh() function\r\n",
        " \r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        " \r\n",
        "in_array = [0, math.pi / 2, np.pi / 3, np.pi]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "cosh_Values = np.cosh(in_array)\r\n",
        "print (\"\\ncosine Hyperbolic values : \\n\", cosh_Values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BAfIR1_6fC34"
      },
      "source": [
        "# function 5 around: numpy.around(arr, decimals = 0, out = None) : This mathematical function helps user to evenly round array elements to the given number of decimals.\r\n",
        "# Python program explaining\r\n",
        "# around() function\r\n",
        " \r\n",
        "import numpy as np\r\n",
        " \r\n",
        "in_array = [.5, 1.5, 2.5, 3.5, 4.5, 10.1]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "round_off_values = np.around(in_array)\r\n",
        "print (\"\\nRounded values : \\n\", round_off_values)\r\n",
        " \r\n",
        " \r\n",
        "in_array = [.53, 1.54, .71]\r\n",
        "print (\"\\nInput array : \\n\", in_array)\r\n",
        " \r\n",
        "round_off_values = np.around(in_array)\r\n",
        "print (\"\\nRounded values : \\n\", round_off_values)\r\n",
        " \r\n",
        "in_array = [.5538, 1.33354, .71445]\r\n",
        "print (\"\\nInput array : \\n\", in_array)\r\n",
        " \r\n",
        "round_off_values = np.around(in_array, decimals = 3)\r\n",
        "print (\"\\nRounded values : \\n\", round_off_values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QmYLdOX4faXu"
      },
      "source": [
        "# Function 6 round_: numpy.round_(arr, decimals = 0, out = None) : This mathematical function round an array to the given number of decimals.\r\n",
        "# Python program explaining\r\n",
        "# round_() function\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "in_array = [.5, 1.5, 2.5, 3.5, 4.5, 10.1]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "round_off_values = np.round_(in_array)\r\n",
        "print (\"\\nRounded values : \\n\", round_off_values)\r\n",
        " \r\n",
        " \r\n",
        "in_array = [.53, 1.54, .71]\r\n",
        "print (\"\\nInput array : \\n\", in_array)\r\n",
        " \r\n",
        "round_off_values = np.round_(in_array)\r\n",
        "print (\"\\nRounded values : \\n\", round_off_values)\r\n",
        " \r\n",
        "in_array = [.5538, 1.33354, .71445]\r\n",
        "print (\"\\nInput array : \\n\", in_array)\r\n",
        " \r\n",
        "round_off_values = np.round_(in_array, decimals = 3)\r\n",
        "print (\"\\nRounded values : \\n\", round_off_values)\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bdZZtHStf1sU"
      },
      "source": [
        "# function 7 tan: tan()\tCompute tangent element-wise.\r\n",
        "# Python program explaining\r\n",
        "# tan() function\r\n",
        " \r\n",
        "\r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        " \r\n",
        "in_array = [0, math.pi / 2, np.pi / 3, np.pi]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "cos_Values = np.tan(in_array)\r\n",
        "print (\"\\ntan Values values : \\n\", cos_Values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "02rTyI9sgMxH"
      },
      "source": [
        "# function 8 arcsin: arcsin()\tInverse sine, element-wise. \r\n",
        "# Python program explaining\r\n",
        "# arcsin() function\r\n",
        " \r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        " \r\n",
        "in_array = [0, math.pi / 2, np.pi / 3, np.pi]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "cos_Values = np.arcsin(in_array)\r\n",
        "print (\"\\nArcsin values : \\n\", cos_Values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bGWBfwHlgz_a"
      },
      "source": [
        "# function 9 arccos: arccos()\tTrigonometric inverse cosine, element-wise. \r\n",
        "#Python program explaining\r\n",
        "# arccos() function\r\n",
        " \r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        " \r\n",
        "in_array = [0, math.pi / 2, np.pi / 3, np.pi]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "cos_Values = np.arccos(in_array)\r\n",
        "print (\"\\narccos values : \\n\", cos_Values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "08_xR-R4hFBd"
      },
      "source": [
        "# function 10 \r\n",
        "#Python program explaining\r\n",
        "# arctan() function\r\n",
        " \r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        " \r\n",
        "in_array = [0, math.pi / 2, np.pi / 3, np.pi]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "arctan_Values = np.arctan(in_array)\r\n",
        "print (\"\\nCosine values : \\n\", arctan_Values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pNrzrpvahT6e"
      },
      "source": [
        "# function 11 \r\n",
        "#Python program explaining\r\n",
        "# degrees() function Convert angles from radians to degrees. \r\n",
        " \r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        " \r\n",
        "in_array = [0, math.pi / 2, np.pi / 3, np.pi]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "arctan_Values = np.degrees(in_array)\r\n",
        "print (\"\\Degress values : \\n\", arctan_Values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hAXGP7gQi4RU"
      },
      "source": [
        "# function 12 rad2deg()\tConvert angles from radians to degrees.\r\n",
        "# Python program explaining\r\n",
        "# rad2deg function\r\n",
        " \r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        " \r\n",
        "in_array = [0, math.pi / 2, np.pi / 3, np.pi]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "rad2deg_Values = np.rad2deg(in_array)\r\n",
        "print (\"\\nrad2deg values : \\n\", rad2deg_Values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zzrzHQvjjPYN"
      },
      "source": [
        "# function 13 deg2rad\tConvert angles from degrees to radians.\r\n",
        "# Python program explaining\r\n",
        "# deg2rad function\r\n",
        " \r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        " \r\n",
        "in_array = [0, math.pi / 2, np.pi / 3, np.pi]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "rad2deg_Values = np.deg2rad(in_array)\r\n",
        "print (\"\\nrad2deg values : \\n\", rad2deg_Values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KJvClm2ijfzf"
      },
      "source": [
        "# function 14 radians()\tConvert angles from degrees to radians.\r\n",
        "# Python program explaining\r\n",
        "# rad2deg function\r\n",
        " \r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        " \r\n",
        "in_array = [0, math.pi / 2, np.pi / 3, np.pi]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "rad2deg_Values = np.radians(in_array)\r\n",
        "print (\"\\nrad2deg values : \\n\", rad2deg_Values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qDVB4s7xjyni"
      },
      "source": [
        "# function 15 hypot()\tGiven the “legs” of a right triangle, return its hypotenuse.\r\n",
        "# Python program explaining\r\n",
        "# hypot function\r\n",
        " \r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        " \r\n",
        "in_array = [0, math.pi / 2, np.pi / 3, np.pi]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "rad2deg_Values = np.hypot(in_array)\r\n",
        "print (\"\\nrad2deg values : \\n\", rad2deg_Values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ox14hjX0j-sh"
      },
      "source": [
        "# function 16 rint()\tRound to nearest integer towards zero.\r\n",
        "# Python program explaining\r\n",
        " \r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        " \r\n",
        "in_array = [0, math.pi / 2, np.pi / 3, np.pi]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "rad2deg_Values = np.rint(in_array)\r\n",
        "print (\"\\nrad2deg values : \\n\", rad2deg_Values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vQ38ozE3kXWg"
      },
      "source": [
        "# function 17 fix()\tRound to nearest integer towards zero..\r\n",
        "# Python program explaining\r\n",
        " \r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        " \r\n",
        "in_array = [0, math.pi / 2, np.pi / 3, np.pi]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "rad2deg_Values = np.fix(in_array)\r\n",
        "print (\"\\nrad2deg values : \\n\", rad2deg_Values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gdvAPNR3kekb"
      },
      "source": [
        "# function 18 floor()\tReturn the floor of the input, element-wise.\r\n",
        "# Python program explaining\r\n",
        " \r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        " \r\n",
        "in_array = [0, math.pi / 2, np.pi / 3, np.pi]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "rad2deg_Values = np.floor(in_array)\r\n",
        "print (\"\\nrad2deg values : \\n\", rad2deg_Values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "77ht3Wi4kg4p"
      },
      "source": [
        "# function 19 ceil()\tReturn the ceiling of the input, element-wise.\r\n",
        "# Python program explaining\r\n",
        " \r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        " \r\n",
        "in_array = [0, math.pi / 2, np.pi / 3, np.pi]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "rad2deg_Values = np.ceil(in_array)\r\n",
        "print (\"\\nrad2deg values : \\n\", rad2deg_Values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_AdkBWeKkhYP"
      },
      "source": [
        "# function 20 trunc()\tReturn the truncated value of the input, element-wise.\r\n",
        "# Python program explaining\r\n",
        " \r\n",
        "import numpy as np\r\n",
        "import math\r\n",
        " \r\n",
        "in_array = [0, math.pi / 2, np.pi / 3, np.pi]\r\n",
        "print (\"Input array : \\n\", in_array)\r\n",
        " \r\n",
        "rad2deg_Values = np.trunc(in_array)\r\n",
        "print (\"\\nrad2deg values : \\n\", rad2deg_Values)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hzca5EmJk863"
      },
      "source": [
        "# function 21 exp to find exponent of a function \r\n",
        "# Python program explaining\r\n",
        "# exp() function\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "in_array = [1, 3, 5]\r\n",
        "print (\"Input array : \", in_array)\r\n",
        " \r\n",
        "out_array = np.exp(in_array)\r\n",
        "print (\"Output array : \", out_array)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LI5Uk0hik9dP"
      },
      "source": [
        "# function 22 numpy.log(x[, out] = ufunc ‘log1p’) : This mathematical function helps user to calculate Natural logarithm of x where x belongs to all the input array elements.\r\n",
        "#Natural logarithm log is the inverse of the exp(), so that log(exp(x)) = x. The natural logarithm is log in base e.\r\n",
        "\r\n",
        "# Python program explaining\r\n",
        "# log() function\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "in_array = [1, 3, 5, 2**8]\r\n",
        "print (\"Input array : \", in_array)\r\n",
        " \r\n",
        "out_array = np.log(in_array)\r\n",
        "print (\"Output array : \", out_array)\r\n",
        " \r\n",
        " \r\n",
        "print(\"\\nnp.log(4**4) : \", np.log(4**4))\r\n",
        "print(\"np.log(2**8) : \", np.log(2**8))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pfcC3H-Bk9xF"
      },
      "source": [
        "# function 23 expm1()\tCalculate exp(x) – 1 for all elements in the array.\r\n",
        "# Python program explaining\r\n",
        "\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "in_array = [1, 3, 5, 2**8]\r\n",
        "print (\"Input array : \", in_array)\r\n",
        " \r\n",
        "out_array = np.expm1(in_array)\r\n",
        "print (\"Output array : \", out_array)\r\n",
        " \r\n",
        " \r\n",
        "print(\"\\nnp.log(4**4) : \", np.expm1(4**4))\r\n",
        "print(\"np.log(2**8) : \", np.expm1(2**8))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HJi5hkK5k9-D"
      },
      "source": [
        "# function 24 exp2()\tCalculate 2**p for all p in the input array.\r\n",
        "# Python program explaining\r\n",
        "\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "in_array = [1, 3, 5, 2**8]\r\n",
        "print (\"Input array : \", in_array)\r\n",
        " \r\n",
        "out_array = np.exp2(in_array)\r\n",
        "print (\"Output array : \", out_array)\r\n",
        " \r\n",
        " \r\n",
        "print(\"\\nnp.exp2(4**4) : \", np.exp2(4**4))\r\n",
        "print(\"np.exp2(2**8) : \", np.exp2(2**8))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KJi9OyPAk-OW"
      },
      "source": [
        "# function 25  log10()\tReturn the base 10 logarithm of the input array, element-wise.\r\n",
        "# Python program explaining\r\n",
        " \r\n",
        "import numpy as np\r\n",
        " \r\n",
        "in_array = [1, 3, 5, 2**8]\r\n",
        "print (\"Input array : \", in_array)\r\n",
        " \r\n",
        "out_array = np.log10(in_array)\r\n",
        "print (\"Output array : \", out_array)\r\n",
        " \r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F86TEQvuk-Z9"
      },
      "source": [
        "# function 26 log2()\tBase-2 logarithm of x.\r\n",
        "# Python program explaining\r\n",
        " \r\n",
        "import numpy as np\r\n",
        " \r\n",
        "in_array = [1, 3, 5, 2**8]\r\n",
        "print (\"Input array : \", in_array)\r\n",
        " \r\n",
        "out_array = np.log2(in_array)\r\n",
        "print (\"Output array : \", out_array)\r\n",
        " \r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2QoICa-ck-lD"
      },
      "source": [
        "# function 27 log1p()\tReturn the natural logarithm of one plus the input array, element-wise.\r\n",
        "# Python program explaining\r\n",
        " \r\n",
        "import numpy as np\r\n",
        " \r\n",
        "in_array = [1, 3, 5, 2**8]\r\n",
        "print (\"Input array : \", in_array)\r\n",
        " \r\n",
        "out_array = np.log1p(in_array)\r\n",
        "print (\"Output array : \", out_array)\r\n",
        " "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pgYQ5S6Ak-xb"
      },
      "source": [
        "# function 28 logaddexp()\tLogarithm of the sum of exponentiations of the inputs.\r\n",
        "# Python program explaining\r\n",
        " \r\n",
        "import numpy as np\r\n",
        " \r\n",
        "in_array = [1, 3, 5, 2**8]\r\n",
        "print (\"Input array : \", in_array)\r\n",
        " \r\n",
        "out_array = np.logaddexp(in_array)\r\n",
        "print (\"Output array : \", out_array)\r\n",
        " "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aQccZnRtk-9k"
      },
      "source": [
        "# function 29 logaddexp2()\tLogarithm of the sum of exponentiations of the inputs.\r\n",
        "# Python program explaining\r\n",
        " \r\n",
        "import numpy as np\r\n",
        " \r\n",
        "in_array = [1, 3, 5, 2**8]\r\n",
        "print (\"Input array : \", in_array)\r\n",
        " \r\n",
        "out_array = np.logaddexp2(in_array)\r\n",
        "print (\"Output array : \", out_array)\r\n",
        " "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3BidHLIQk_Jv"
      },
      "source": [
        "# function 30 numpy.reciprocal(x, /, out=None, *, where=True) : This mathematical function is used to\r\n",
        "# Python program explaining\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "in_num = 2.0\r\n",
        "print (\"Input  number : \", in_num)\r\n",
        " \r\n",
        "out_num = np.reciprocal(in_num)\r\n",
        "print (\"Output number : \", out_num)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q6Ej2D0JoLjV"
      },
      "source": [
        "# function 31 numpy.divide(arr1, arr2, out = None, where = True, casting = ‘same_kind’, order = ‘K’, dtype = None) : Array element from first array is divided by elements from second element (all happens element-wise). Both arr1 and arr2 must have same shape and element in arr2 must not be zero; otherwise it will raise an error.\r\n",
        "# Python program explaining\r\n",
        "# divide() function\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "# input_array\r\n",
        "arr1 = [2, 27, 2, 21, 23]\r\n",
        "arr2 = [2, 3, 4, 5, 6]\r\n",
        "print (\"arr1         : \", arr1)\r\n",
        "print (\"arr2         : \", arr2)\r\n",
        " \r\n",
        "# output_array\r\n",
        "out = np.divide(arr1, arr2)\r\n",
        "print (\"\\nOutput array : \\n\", out)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "42JXiRokodUm"
      },
      "source": [
        "# function 32 add()\tAdd arguments element-wise.\r\n",
        "# Python program explaining\r\n",
        "# divide() function\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "# input_array\r\n",
        "arr1 = [2, 27, 2, 21, 23]\r\n",
        "arr2 = [2, 3, 4, 5, 6]\r\n",
        "print (\"arr1         : \", arr1)\r\n",
        "print (\"arr2         : \", arr2)\r\n",
        " \r\n",
        "# output_array\r\n",
        "out = np.add(arr1, arr2)\r\n",
        "print (\"\\nOutput array : \\n\", out)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vSEorP6CofhX"
      },
      "source": [
        "# function 33 positive()\tNumerical positive, element-wise.\r\n",
        "# Python program explaining\r\n",
        "# divide() function\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "# input_array\r\n",
        "arr1 = [2, 27, 2, 21, 23]\r\n",
        "arr2 = [2, 3, 4, 5, 6]\r\n",
        "print (\"arr1         : \", arr1)\r\n",
        "print (\"arr2         : \", arr2)\r\n",
        " \r\n",
        "# output_array\r\n",
        "out = np.positive(arr1, arr2)\r\n",
        "print (\"\\nOutput array : \\n\", out)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sxBGomMtof4S"
      },
      "source": [
        "# function 34 negative()\tNumerical negative, element-wise.\r\n",
        "# Python program explaining\r\n",
        "# divide() function\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "# input_array\r\n",
        "arr1 = [2, 27, 2, 21, 23]\r\n",
        "arr2 = [2, 3, 4, 5, 6]\r\n",
        "print (\"arr1         : \", arr1)\r\n",
        "print (\"arr2         : \", arr2)\r\n",
        " \r\n",
        "# output_array\r\n",
        "out = np.negative(arr1, arr2)\r\n",
        "print (\"\\nOutput array : \\n\", out)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NuwD4pxNogDC"
      },
      "source": [
        "# function 35 multiply()\tMultiply arguments element-wise.\r\n",
        "# Python program explaining\r\n",
        "# divide() function\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "# input_array\r\n",
        "arr1 = [2, 27, 2, 21, 23]\r\n",
        "arr2 = [2, 3, 4, 5, 6]\r\n",
        "print (\"arr1         : \", arr1)\r\n",
        "print (\"arr2         : \", arr2)\r\n",
        " \r\n",
        "# output_array\r\n",
        "out = np.multiply(arr1, arr2)\r\n",
        "print (\"\\nOutput array : \\n\", out)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BS2dciKAogQv"
      },
      "source": [
        "# function 36 power()\tFirst array elements raised to powers from second array, element-wise. \r\n",
        "# Python program explaining\r\n",
        "# divide() function\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "# input_array\r\n",
        "arr1 = [2, 27, 2, 21, 23]\r\n",
        "arr2 = [2, 3, 4, 5, 6]\r\n",
        "print (\"arr1         : \", arr1)\r\n",
        "print (\"arr2         : \", arr2)\r\n",
        " \r\n",
        "# output_array\r\n",
        "out = np.power(arr1, arr2)\r\n",
        "print (\"\\nOutput array : \\n\", out)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0hFTSNkeogd7"
      },
      "source": [
        "# Function 37 subtract()\tSubtract arguments, element-wise. \r\n",
        "# Python program explaining\r\n",
        "# divide() function\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "# input_array\r\n",
        "arr1 = [2, 27, 2, 21, 23]\r\n",
        "arr2 = [2, 3, 4, 5, 6]\r\n",
        "print (\"arr1         : \", arr1)\r\n",
        "print (\"arr2         : \", arr2)\r\n",
        " \r\n",
        "# output_array\r\n",
        "out = np.subtract(arr1, arr2)\r\n",
        "print (\"\\nOutput array : \\n\", out)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lJBSLoVZogrW"
      },
      "source": [
        "# Function 38 true_divide()\tReturns a true division of the inputs, element-wise.\r\n",
        "# Python program explaining\r\n",
        "# divide() function\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "# input_array\r\n",
        "arr1 = [2, 27, 2, 21, 23]\r\n",
        "arr2 = [2, 3, 4, 5, 6]\r\n",
        "print (\"arr1         : \", arr1)\r\n",
        "print (\"arr2         : \", arr2)\r\n",
        " \r\n",
        "# output_array\r\n",
        "out = np.true_divide(arr1, arr2)\r\n",
        "print (\"\\nOutput array : \\n\", out)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8RhF4VT8og6K"
      },
      "source": [
        "# Function 39 floor_divide()\tReturn the largest integer smaller or equal to the division of the inputs.\r\n",
        "# Python program explaining\r\n",
        "# divide() function\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "# input_array\r\n",
        "arr1 = [2, 27, 2, 21, 23]\r\n",
        "arr2 = [2, 3, 4, 5, 6]\r\n",
        "print (\"arr1         : \", arr1)\r\n",
        "print (\"arr2         : \", arr2)\r\n",
        " \r\n",
        "# output_array\r\n",
        "out = np.floor_divide(arr1, arr2)\r\n",
        "print (\"\\nOutput array : \\n\", out)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mHcklxZXohJa"
      },
      "source": [
        "# Function 40 float_power()\tFirst array elements raised to powers from second array, element-wise.\r\n",
        "# Python program explaining\r\n",
        "# divide() function\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "# input_array\r\n",
        "arr1 = [2, 27, 2, 21, 23]\r\n",
        "arr2 = [2, 3, 4, 5, 6]\r\n",
        "print (\"arr1         : \", arr1)\r\n",
        "print (\"arr2         : \", arr2)\r\n",
        " \r\n",
        "# output_array\r\n",
        "out = np.float_power(arr1, arr2)\r\n",
        "print (\"\\nOutput array : \\n\", out)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "juVBJucxohZS"
      },
      "source": [
        "# Function 41 mod()\tReturn the element-wise remainder of division.\r\n",
        "# Python program explaining\r\n",
        "# divide() function\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "# input_array\r\n",
        "arr1 = [2, 27, 2, 21, 23]\r\n",
        "arr2 = [2, 3, 4, 5, 6]\r\n",
        "print (\"arr1         : \", arr1)\r\n",
        "print (\"arr2         : \", arr2)\r\n",
        " \r\n",
        "# output_array\r\n",
        "out = np.mod(arr1, arr2)\r\n",
        "print (\"\\nOutput array : \\n\", out)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B1_tDxYZohpK"
      },
      "source": [
        "# Function 42 remainder()\tReturn element-wise remainder of division.\r\n",
        "# Python program explaining\r\n",
        "# divide() function\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "# input_array\r\n",
        "arr1 = [2, 27, 2, 21, 23]\r\n",
        "arr2 = [2, 3, 4, 5, 6]\r\n",
        "print (\"arr1         : \", arr1)\r\n",
        "print (\"arr2         : \", arr2)\r\n",
        " \r\n",
        "# output_array\r\n",
        "out = np.remainder(arr1, arr2)\r\n",
        "print (\"\\nOutput array : \\n\", out)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wH5H80UPqF0R"
      },
      "source": [
        "# Function 43 divmod()\tReturn element-wise quotient and remainder simultaneously.\r\n",
        "\r\n",
        "# Python program explaining\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "# input_array\r\n",
        "arr1 = [2, 27, 2, 21, 23]\r\n",
        "arr2 = [2, 3, 4, 5, 6]\r\n",
        "print (\"arr1         : \", arr1)\r\n",
        "print (\"arr2         : \", arr2)\r\n",
        " \r\n",
        "# output_array\r\n",
        "out = np.divmod(arr1, arr2)\r\n",
        "print (\"\\nOutput array : \\n\", out)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Efpq_5NPqVVE"
      },
      "source": [
        "# Function 44 numpy.isreal(array) : Test element-wise whether it is a real number or not(not infinity or not Not a Number) and return the result as a boolean array.\r\n",
        "# Python Program illustrating\r\n",
        "# numpy.isreal() method\r\n",
        "  \r\n",
        "import numpy as geek \r\n",
        " \r\n",
        "print(\"Is Real : \", geek.isreal([1+1j, 0j]), \"\\n\")\r\n",
        " \r\n",
        "print(\"Is Real : \", geek.isreal([1, 0]), \"\\n\")\r\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nXEQBHZ8qcr7"
      },
      "source": [
        "# Function 45 numpy.conj(x[, out] = ufunc ‘conjugate’) : This function helps the user to conjugate any complex number.\r\n",
        "# The conjugate of a complex number is obtained by changing the sign of its imaginary part. If the complex number is 2+5j then its conjugate is 2-5j.\r\n",
        "# Python3 code demonstrate conj() function\r\n",
        " \r\n",
        "#importing numpy\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "in_complx1 = 2+4j\r\n",
        "out_complx1 = np.conj(in_complx1)\r\n",
        "print (\"Output conjugated complex number of  2+4j : \", out_complx1)\r\n",
        " \r\n",
        "in_complx2 =5-8j\r\n",
        "out_complx2 = np.conj(in_complx2)\r\n",
        "print (\"Output conjugated complex number of 5-8j: \", out_complx2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9F_sN-IvqrF_"
      },
      "source": [
        "# Function 46 numpy.cbrt(arr, out = None, ufunc ‘cbrt’) : This mathematical function helps user to calculate cube root of x for all x being the array elements.\r\n",
        "# Python program explaining\r\n",
        "# cbrt () function\r\n",
        "  \r\n",
        "import numpy as np\r\n",
        "  \r\n",
        "arr1 = [1, 27000, 64, -1000]\r\n",
        "print (\"cbrt Value of arr1 : \\n\", np.cbrt(arr1))\r\n",
        "  \r\n",
        "arr2 = [1024 ,-128]\r\n",
        "print (\"\\ncbrt Value of arr2 : \", np.cbrt(arr2))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "peyevqU4q4Tj"
      },
      "source": [
        "# Function 47 numpy.clip() : This function is used to Clip (limit) the values in an array.\r\n",
        "# Given an interval, values outside the interval are clipped to the interval edges. For example, if an interval of [0, 1] is specified, values smaller than 0 become 0, and values larger than 1 become 1.\r\n",
        "# Python3 code demonstrate clip() function\r\n",
        " \r\n",
        "# importing the numpy\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "in_array = [1, 2, 3, 4, 5, 6, 7, 8 ]\r\n",
        "print (\"Input array : \", in_array)\r\n",
        " \r\n",
        "out_array = np.clip(in_array, a_min = 2, a_max = 6)\r\n",
        "print (\"Output array : \", out_array)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IakBPIoaq4YK"
      },
      "source": [
        "# Function 48 convolve()\tReturns the discrete, linear convolution of two one-dimensional sequences.\r\n",
        "\r\n",
        "# importing the numpy\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "in_array = [1, 2, 3, 4, 5, 6, 7, 8 ]\r\n",
        "print (\"Input array : \", in_array)\r\n",
        " \r\n",
        "out_array = np.convolve(in_array, a_min = 2, a_max = 6)\r\n",
        "print (\"Output array : \", out_array)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_uFnrU_lrP9c"
      },
      "source": [
        "# Function 49 sqrt()\tReturn the non-negative square-root of an array, element-wise. \r\n",
        "# importing the numpy\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "in_array = [1, 2, 3, 4, 5, 6, 7, 8 ]\r\n",
        "print (\"Input array : \", in_array)\r\n",
        " \r\n",
        "out_array = np.sqrt(in_array, a_min = 2, a_max = 6)\r\n",
        "print (\"Output array : \", out_array)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hEo2Sxn8rbbm"
      },
      "source": [
        "# Function 50 square()\tReturn the element-wise square of the input.\r\n",
        "import numpy as np\r\n",
        " \r\n",
        "in_array = [1, 2, 3, 4, 5, 6, 7, 8 ]\r\n",
        "print (\"Input array : \", in_array)\r\n",
        " \r\n",
        "out_array = np.square(in_array, a_min = 2, a_max = 6)\r\n",
        "print (\"Output array : \", out_array)"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}