B) RoadMap 2 - Torch Main2 - Mathematical Operators.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Roadmap 2 - Mathematical operations\n",
    "\n",
    "\n",
    "    1.1.   torch.add     - Adds the scalar value to each element of the input input\n",
    "    1.2.   torch.addcdiv - out_i= tensor_i + value × [tensor_1]/[tensor_2]\n",
    "    1.3.   torch.addcmul - out_i= tensor_i + value × [tensor_1]*[tensor_2]\n",
    "    1.4.   torch.div     - Divides each element of the input input with the scalar value\n",
    "    1.5.   torch.mul     - Multiples each element of the input input with the scalar value\n",
    "    \n",
    "    \n",
    "    2.1.   torch.ceil    - Returns a new tensor with the ceil of the elements of input, the smallest integer\n",
    "                              greater than or equal to each element.\n",
    "    2.2.   torch.clamp   - Clamp all elements in input into the range [ min, max ] and return a resulting tensor\n",
    "    2.3.   torch.floor   - Returns a new tensor with the floor of the elements of input, the largest integer less \n",
    "                              than or equal to each element.\n",
    "    2.4.   torch.round   - Returns a new tensor with each of the elements of input rounded to the closest integer.\n",
    "    2.5.   torch.trunc   - Returns a new tensor with the truncated integer values of the elements of input\n",
    "\n",
    "    \n",
    "    3.1.   torch.asin    - Returns a new tensor with the arcsine of the elements of input\n",
    "    3.2.   torch.acos    - Returns a new tensor with the arccosine of the elements of input\n",
    "    3.3.   torch.atan    - Returns a new tensor with the arctangent of the elements of input\n",
    "    3.4.   torch.atan2   - Returns a new tensor with the arctangent of the elements of input1 and input2.\n",
    "    3.5.   torch.cos     - Returns a new tensor with the cosine of the elements of input\n",
    "    3.6.   torch.sin     - Returns a new tensor with the Sine of the elements of input\n",
    "    3.7.   torch.tan     - Returns a new tensor with the Tangent of the elements of input\n",
    "    3.8.   torch.cosh    - Returns a new tensor with the hyperbolic cosine of the elements of input\n",
    "    3.9.   torch.sinh    - Returns a new tensor with the hyperbolic sine of the elements of input\n",
    "    3.10.  torch.tanh    - Returns a new tensor with the Hyperbolic Tangent of the elements of input\n",
    "\n",
    "\n",
    "    4.1.   torch.argmax   - Returns the indices of the maximum values of a tensor across a dimension.\n",
    "    4.2.   torch.argmin   - Returns the indices of the minimum values of a tensor across a dimension.\n",
    "    4.3.   torch.mean     - Returns the mean value of all elements in the input tensor.\n",
    "    4.4.   torch.median   - Returns the median value of all elements in the input tensor.\n",
    "    4.5.   torch.mode     - Returns the mode value of all elements in the input tensor.\n",
    "    4.6.   torch.prod     - Returns the product of all elements in the input tensor.\n",
    "    4.7.   torch.std      - Returns the standard deviation value of all elements in the input tensor.\n",
    "    4.8.   torch.sum      - Returns the sum of all elements in the input tensor.\n",
    "    4.9.   torch.var      - Returns the variance of all elements in the input tensor.\n",
    "\n",
    "    \n",
    "    5.1.   torch.erf      - Computes the error function of each element.\n",
    "    5.2.   torch.erfc     - Computes the complementary error function of each element. \n",
    "    5.3.   torch.erfinv   - Computes the inverse error function of each element.\n",
    "    5.4.   torch.exp      - Returns a new tensor with the exponential of the elements of input\n",
    "    5.5.   torch.expm1    - Returns a new tensor with the exponential of the elements minus 1 of input\n",
    "    5.6.   torch.fmod     - Computes the element-wise remainder of division.\n",
    "    5.7.   torch.abs      - Computes the element-wise absolute value of the given input tensor.\n",
    "    5.8.   torch.frac     - Computes the fractional portion of each element in tensor\n",
    "    5.9.   torch.log      - Returns a new tensor with the logarithm of the elements. Base of log - e\n",
    "    5.10.  torch.log10    - Returns a new tensor with the logarithm of the elements. Base of log - 10\n",
    "    5.11.  torch.log1p    - Returns a new tensor with the logarithm of the elements (1 + input).\n",
    "    5.12.  torch.log2     - Returns a new tensor with the logarithm of the elements of input. Base of log - 2\n",
    "    5.13.  torch.neg      - Returns a new tensor with the negative of the elements of input\n",
    "    5.14.  torch.pow      - Takes the power of each element in input with exponent.\n",
    "    5.15.  torch.reciprocal - Returns a new tensor with the reciprocal of the elements of input\n",
    "    5.16.  torch.rsqrt    - Returns a new tensor with the reciprocal of the square-root of each element.\n",
    "    5.17.  torch.sigmoid  - Returns a new tensor with the sigmoid of the elements of input\n",
    "    5.18.  torch.sign     - Returns a new tensor with the sign of the elements of input.\n",
    "    5.19.  torch.sqrt     - Returns a new tensor with the square-root of each of the elements of input.\n",
    "    5.20.  torch.norm     - Returns the normalized value of all elements in the input tensor.\n",
    "           \n",
    "\n",
    "    6.1.   torch.eq      - Computes element-wise equality\n",
    "    6.2.   torch.ge      - Computes element-wise greater-than-equality\n",
    "    6.3.   torch.gt      - Computes element-wise greater-than function\n",
    "    6.4.   torch.le      - Computes element-wise less-than-equality\n",
    "    6.5.   torch.lt      - Computes element-wise less-than function\n",
    "    6.6.   torch.max     - Returns the maximum value of all elements in the input tensor.\n",
    "    6.7.   torch.min     - Returns the minimum value of all elements in the input tensor.\n",
    "    \n",
    "    \n",
    "    7.1.   torch.cumprod   - Returns the cumulative product of elements of input in the dimension dim.\n",
    "    7.2.   torch.cumsum    - Returns the cumulative sum of elements of input in the dimension dim.\n",
    "    7.3.   torch.logsumexp - Returns the log of summed exponentials of each row of the input tensor in the \n",
    "                                given dimension dim\n",
    "    7.4.   torch.einsum    - This function provides a way of computing multilinear expressions using the Einstein  \n",
    "                                summation convention.\n",
    "    7.5.   torch.histc     - Computes the histogram of a tensor.\n",
    "\n",
    "\n",
    "    8.1.   torch.unique    - Returns the unique scalar elements of the input tensor as a 1-D tensor.\n",
    "    8.2.   torch.sort      - Sorts the elements of the input tensor.\n",
    "    8.3.   torch.topk      - Returns the k largest elements of the given input tensor along a given dimension.\n",
    "    8.4.   torch.bincount  - Count the frequency of each value in an array of non-negative ints.\n",
    "    8.5.   torch.trace     - Returns the sum of the elements of the diagonal of the input 2-D matrix.\n",
    "    8.6.   torch.tril      - Returns the lower triangular part of the matrix (2-D tensor) input\n",
    "    8.7.   torch.triu      - Returns the upper triangular part of the matrix (2-D tensor) input\n",
    "           \n",
    "           \n",
    "    9.1.   torch.lerp      - Does a linear interpolation of two tensors start and end based on a scalar weight and \n",
    "                               returns the resulting out tensor.              \n",
    "    9.2.   torch.dist      - Returns the lp-norm of (input - other)\n",
    "    9.3.   torch.fft       - Complex-to-complex Discrete Fourier Transform\n",
    "    9.4.   torch.ifft      - Complex-to-complex Inverse Discrete Fourier Transform\n",
    "    9.5.   torch.stft      - Short time fourier transform \n",
    "    9.6.   torch.cross     - Returns the cross product of vectors in dimension dim of input and other\n",
    "    9.7.   torch.diag      - If input is a vector (1-D tensor), then returns a 2-D square tensor with the elements \n",
    "                              of input as the diagonal. If input is a matrix (2-D tensor), then returns a 1-D tensor \n",
    "                              with the diagonal elements of input.\n",
    "\n",
    " \n",
    "    10.1.  torch.bartlett_window \n",
    "    10.2.  torch.blacman_window\n",
    "    10.3.  torch.hamming_window\n",
    "    10.4.  torch.hann_window\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import sys\n",
    "import torch\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Way - 1\n",
      "x_in =  tensor([-0.2313, -0.3780, -0.6219, -0.7886])\n",
      "x_out =  tensor([29.7687, 29.6220, 29.3781, 29.2114])\n",
      "\n",
      "\n",
      "Way - 2\n",
      "x_in =  tensor([ 0.5229, -0.6687,  0.8674,  0.7196])\n",
      "x_other =  tensor([-0.0500,  0.7724, -2.0346,  1.0681])\n",
      "x_out =  tensor([  0.0231,   7.0552, -19.4790,  11.4010])\n"
     ]
    }
   ],
   "source": [
    "# Add\n",
    "\n",
    "'''\n",
    "1.1 torch.add - Adds the scalar value to each element of the input input and returns a new resulting tensor.\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "scalar = 30\n",
    "\n",
    "x_out = torch.add(x_in, scalar)\n",
    "\n",
    "print(\"Way - 1\")\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)\n",
    "print(\"\\n\")\n",
    "\n",
    "\n",
    "'''\n",
    "1.2. torch.add - Each element of the tensor other is multiplied by the scalar value and added to each element \n",
    "    of the tensor input. The resulting tensor is returned.\n",
    "    out=input+value×other\n",
    "        - input (Tensor) – the first input tensor\n",
    "        - value (Number) – the scalar multiplier for other\n",
    "        - other (Tensor) – the second input tensor\n",
    "    \n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "x_other = torch.randn(4)\n",
    "value = 10\n",
    "\n",
    "x_out = torch.add(x_in, value, x_other)\n",
    "\n",
    "print(\"Way - 2\")\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_other = \", x_other)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([[-0.8749, -1.7497,  0.4427]])\n",
      "x_1 =  tensor([[-0.8120],\n",
      "        [-1.1762],\n",
      "        [-0.1106]])\n",
      "x_2 =  tensor([[-1.8205,  0.7799,  1.1930]])\n",
      "x_out =  tensor([[-0.8303, -1.8538,  0.3746],\n",
      "        [-0.8103, -1.9005,  0.3441],\n",
      "        [-0.8688, -1.7639,  0.4334]])\n"
     ]
    }
   ],
   "source": [
    "# AddCDivide\n",
    "\n",
    "'''\n",
    "1.2. torch.addcdiv - out_i= tensor_i + value × [tensor_1]/[tensor_2]\n",
    "    - tensor (Tensor) – the tensor to be added\n",
    "    - value (Number, optional) – multiplier for tensor1./tensor2\n",
    "    - tensor1 (Tensor) – the numerator tensor\n",
    "    - tensor2 (Tensor) – the denominator tensor\n",
    "    - out (Tensor, optional) – the output tensor\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(1, 3)\n",
    "x_1 = torch.randn(3, 1)\n",
    "x_2 = torch.randn(1, 3)\n",
    "x_out = torch.addcdiv(x_in, 0.1, x_1, x_2)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_1 = \", x_1)\n",
    "print(\"x_2 = \", x_2)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([[ 0.0474, -0.0077,  0.5210]])\n",
      "x_1 =  tensor([[-0.1808],\n",
      "        [ 2.7871],\n",
      "        [ 0.9743]])\n",
      "x_2 =  tensor([[-0.5375,  1.3692, -0.3947]])\n",
      "x_out =  tensor([[ 0.0571, -0.0325,  0.5281],\n",
      "        [-0.1024,  0.3739,  0.4110],\n",
      "        [-0.0050,  0.1257,  0.4825]])\n"
     ]
    }
   ],
   "source": [
    "# AddCMul\n",
    "\n",
    "'''\n",
    "1.3. torch.addcmul - out_i= tensor_i + value × [tensor_1]*[tensor_2]\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(1, 3)\n",
    "x_1 = torch.randn(3, 1)\n",
    "x_2 = torch.randn(1, 3)\n",
    "x_out = torch.addcmul(x_in, 0.1, x_1, x_2)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_1 = \", x_1)\n",
    "print(\"x_2 = \", x_2)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Way - 1\n",
      "x_in =  tensor([-0.1566,  0.6254, -0.2437, -0.4520])\n",
      "x_out =  tensor([-0.0391,  0.1563, -0.0609, -0.1130])\n",
      "\n",
      "\n",
      "Way - 2\n",
      "x_in =  tensor([-0.0340, -0.3144, -0.6453,  0.3580])\n",
      "x_other =  tensor([ 0.0359, -1.0047,  0.2577, -0.2396])\n",
      "x_out =  tensor([-0.9481,  0.3129, -2.5038, -1.4946])\n"
     ]
    }
   ],
   "source": [
    "# Div\n",
    "\n",
    "'''\n",
    "1.4 torch.div - Divides each element of the input input with the scalar value and returns a new resulting tensor.\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "scalar = 4\n",
    "\n",
    "x_out = torch.div(x_in, scalar)\n",
    "\n",
    "print(\"Way - 1\")\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)\n",
    "print(\"\\n\")\n",
    "\n",
    "\n",
    "'''\n",
    "1.4. torch.div - Each element of the tensor input is divided by each element of the tensor other. \n",
    "        The resulting tensor is returned. The shapes of input and other must be broadcastable..\n",
    "        out = [input_1]/[input_2]\n",
    "        - nput (Tensor) – the numerator tensor\n",
    "        - other (Tensor) – the denominator tensor\n",
    "        - out (Tensor, optional) – the output tensor\n",
    "    \n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "x_other = torch.randn(4)\n",
    "value = 10\n",
    "\n",
    "x_out = torch.div(x_in, x_other)\n",
    "\n",
    "print(\"Way - 2\")\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_other = \", x_other)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Way - 1\n",
      "x_in =  tensor([ 0.4431,  0.5666, -0.0768,  0.5726])\n",
      "x_out =  tensor([ 1.7724,  2.2665, -0.3073,  2.2905])\n",
      "\n",
      "\n",
      "Way - 2\n",
      "x_in =  tensor([-0.4963, -1.0388, -0.8180,  0.9160])\n",
      "x_other =  tensor([ 0.9045,  0.3083, -0.5704,  0.2018])\n",
      "x_out =  tensor([-0.4489, -0.3203,  0.4666,  0.1849])\n"
     ]
    }
   ],
   "source": [
    "# Mul\n",
    "\n",
    "'''\n",
    "1.5 torch.mul - Multiples each element of the input input with the scalar value and returns a new resulting tensor.\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "scalar = 4\n",
    "\n",
    "x_out = torch.mul(x_in, scalar)\n",
    "\n",
    "print(\"Way - 1\")\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)\n",
    "print(\"\\n\")\n",
    "\n",
    "\n",
    "'''\n",
    "1.5. torch.mul - Each element of the tensor input is multiplied by each element of the Tensor other. \n",
    "        The resulting tensor is returned.\n",
    "    \n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "x_other = torch.randn(4)\n",
    "value = 10\n",
    "\n",
    "x_out = torch.mul(x_in, x_other)\n",
    "\n",
    "print(\"Way - 2\")\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_other = \", x_other)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([-1.0539, -1.4979, -0.1004, -0.0199, -0.1471])\n",
      "x_out =  tensor([-1., -1., -0., -0., -0.])\n"
     ]
    }
   ],
   "source": [
    "# CEIL\n",
    "\n",
    "'''\n",
    "2.1. torch.ceil - Returns a new tensor with the ceil of the elements of input, \n",
    "    the smallest integer greater than or equal to each element.\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(5)\n",
    "x_out = torch.ceil(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([ 0.9116, -0.0254, -1.0809, -0.1355,  2.1283, -0.9493, -0.1871,  1.0525])\n",
      "x_out =  tensor([ 0.5000, -0.0254, -0.5000, -0.1355,  0.5000, -0.5000, -0.1871,  0.5000])\n"
     ]
    }
   ],
   "source": [
    "# CLAMP\n",
    "\n",
    "'''\n",
    "2.2. torch.clamp - Clamp all elements in input into the range [ min, max ] and return a resulting tensor\n",
    "        - input (Tensor) – the input tensor\n",
    "        - min (Number) – lower-bound of the range to be clamped to\n",
    "        - max (Number) – upper-bound of the range to be clamped to\n",
    "        - out (Tensor, optional) – the output tensor\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(8)\n",
    "x_out = torch.clamp(x_in, min=-0.5, max=0.5)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([ 0.2633,  0.0557, -0.7051, -0.1001, -1.0198])\n",
      "x_out =  tensor([ 0.,  0., -1., -1., -2.])\n"
     ]
    }
   ],
   "source": [
    "# FLOOR\n",
    "\n",
    "'''\n",
    "2.3. torch.floor - Returns a new tensor with the floor of the elements of input, \n",
    "        the largest integer less than or equal to each element.\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(5)\n",
    "x_out = torch.floor(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([ 0.1651, -1.0110, -1.1610,  0.1297, -0.6755])\n",
      "x_out =  tensor([ 0., -2., -2.,  0., -1.])\n"
     ]
    }
   ],
   "source": [
    "# Round\n",
    "\n",
    "'''\n",
    "2.4. torch.round - Returns a new tensor with each of the elements of input rounded to the closest integer.\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(5)\n",
    "x_out = torch.floor(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([-0.1239,  0.9974, -1.4709, -0.4768])\n",
      "x_out =  tensor([-0.,  0., -1., -0.])\n"
     ]
    }
   ],
   "source": [
    "# Truncating\n",
    "\n",
    "'''\n",
    "2.5. torch.trunc - Returns a new tensor with the truncated integer values of the elements of input\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "x_out = torch.trunc(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([-0.8244,  0.1314,  1.8311, -0.4891])\n",
      "x_out =  tensor([-0.9692,  0.1318,     nan, -0.5110])\n"
     ]
    }
   ],
   "source": [
    "# Arc-Sine\n",
    "\n",
    "'''\n",
    "3.1. torch.asin - Returns a new tensor with the arcsine of the elements of input\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "x_out = torch.asin(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([-0.8532,  2.0393,  0.4980,  1.4514])\n",
      "x_out =  tensor([2.5928,    nan, 1.0495,    nan])\n"
     ]
    }
   ],
   "source": [
    "# Arc-Cosine\n",
    "\n",
    "'''\n",
    "3.2. torch.acos - Returns a new tensor with the arccosine of the elements of input\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "x_out = torch.acos(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([ 0.1275, -0.0550,  0.0560, -0.5383])\n",
      "x_out =  tensor([ 0.1268, -0.0549,  0.0560, -0.4938])\n"
     ]
    }
   ],
   "source": [
    "# Arc-Tan\n",
    "\n",
    "'''\n",
    "3.3. torch.atan - Returns a new tensor with the arctangent of the elements of input\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "x_out = torch.atan(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_1 =  tensor([ 1.6449, -1.5211, -1.0983])\n",
      "x_2 =  tensor([0.0641, 0.4416, 0.5303])\n",
      "x_out =  tensor([ 1.5318, -1.2882, -1.1210])\n"
     ]
    }
   ],
   "source": [
    "# Arc-Tan2\n",
    "\n",
    "'''\n",
    "3.4. torch.atan2 - Returns a new tensor with the arctangent of the elements of input1 and input2.\n",
    "        - input1 (Tensor) – the first input tensor\n",
    "        - input2 (Tensor) – the second input tensor\n",
    "        - out (Tensor, optional) – the output tensor\n",
    "'''\n",
    "\n",
    "\n",
    "x_1 = torch.randn(3)\n",
    "x_2 = torch.randn(3)\n",
    "x_out = torch.atan2(x_1, x_2)\n",
    "\n",
    "print(\"x_1 = \", x_1)\n",
    "print(\"x_2 = \", x_2)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([-0.3259, -1.4602, -0.3902,  1.3573])\n",
      "x_out =  tensor([0.9474, 0.1103, 0.9248, 0.2119])\n"
     ]
    }
   ],
   "source": [
    "# Cosine\n",
    "\n",
    "'''\n",
    "3.5. torch.cos - Returns a new tensor with the cosine of the elements of input\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "x_out = torch.cos(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([-0.0164,  1.0798, -0.3860, -0.9051])\n",
      "x_out =  tensor([-0.0164,  0.8819, -0.3765, -0.7865])\n"
     ]
    }
   ],
   "source": [
    "# Sine\n",
    "\n",
    "'''\n",
    "3.6. torch.sin - Returns a new tensor with the Sine of the elements of input\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "x_out = torch.sin(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([ 0.5083, -0.6640,  0.4518, -0.2980])\n",
      "x_out =  tensor([ 0.5572, -0.7826,  0.4853, -0.3071])\n"
     ]
    }
   ],
   "source": [
    "# Tan\n",
    "\n",
    "'''\n",
    "3.7. torch.tan - Returns a new tensor with the Tangent of the elements of input\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "x_out = torch.tan(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([-0.1815, -0.8318, -0.2322,  0.2420])\n",
      "x_out =  tensor([1.0165, 1.3664, 1.0271, 1.0294])\n"
     ]
    }
   ],
   "source": [
    "# Hyperbolic Cosine\n",
    "\n",
    "'''\n",
    "3.8. torch.cosh - Returns a new tensor with the hyperbolic cosine of the elements of input\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "x_out = torch.cosh(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([ 0.0431,  0.0284,  0.9755, -0.9838])\n",
      "x_out =  tensor([ 0.0432,  0.0284,  1.1377, -1.1503])\n"
     ]
    }
   ],
   "source": [
    "# Hyperbolic Sine\n",
    "\n",
    "'''\n",
    "3.9. torch.sin - Returns a new tensor with the hyperbolic sine of the elements of input\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "x_out = torch.sinh(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([ 0.3061,  0.8543, -0.9381,  1.1520])\n",
      "x_out =  tensor([ 0.2969,  0.6933, -0.7344,  0.8184])\n"
     ]
    }
   ],
   "source": [
    "# Hyperbolic tangent\n",
    "\n",
    "'''\n",
    "3.10. torch.tanh - Returns a new tensor with the Hyperbolic Tangent of the elements of input\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "x_out = torch.tanh(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([-1.1446,  0.0086,  0.1336, -0.3165])\n",
      "x_out =  tensor(2)\n"
     ]
    }
   ],
   "source": [
    "# Argmax\n",
    "\n",
    "'''\n",
    "4.1. torch.argmax - Returns the indices of the maximum values of a tensor across a dimension.\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "x_out = torch.argmax(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([ 1.0571,  0.0773, -1.7247,  0.4579])\n",
      "x_out =  tensor(2)\n"
     ]
    }
   ],
   "source": [
    "# Argmin\n",
    "\n",
    "'''\n",
    "4.2. torch.argmin - Returns the indices of the minimum values of a tensor across a dimension.\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "x_out = torch.argmin(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([1., 2., 3., 4., 5.])\n",
      "x_out =  tensor(3.)\n"
     ]
    }
   ],
   "source": [
    "# Compute Mean\n",
    "\n",
    "'''\n",
    "4.3. torch.mean - Returns the mean value of all elements in the input tensor.\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([1.,2.,3.,4.,5.])\n",
    "x_out = torch.mean(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([1., 2., 3., 4., 5.])\n",
      "x_out =  tensor(3.)\n"
     ]
    }
   ],
   "source": [
    "# Compute Median\n",
    "\n",
    "'''\n",
    "4.4. torch.median - Returns the median value of all elements in the input tensor.\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([1.,2.,3.,4.,5.])\n",
    "x_out = torch.median(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([1., 2., 3., 4., 5., 1.])\n",
      "x_out =  torch.return_types.mode(\n",
      "values=tensor(1.),\n",
      "indices=tensor(5))\n"
     ]
    }
   ],
   "source": [
    "# Compute Mode\n",
    "\n",
    "'''\n",
    "4.5. torch.mode - Returns the mode value of all elements in the input tensor.\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([1.,2.,3.,4.,5.,1.0])\n",
    "x_out = torch.mode(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([1., 2., 3., 4., 5., 1.])\n",
      "x_out =  tensor(120.)\n"
     ]
    }
   ],
   "source": [
    "# Compute Product of all elements in tensor\n",
    "\n",
    "'''\n",
    "4.6. torch.prod - Returns the product of all elements in the input tensor.\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([1.,2.,3.,4.,5.,1.0])\n",
    "x_out = torch.prod(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([1., 2., 3., 4., 5., 1.])\n",
      "x_out =  tensor(1.6330)\n"
     ]
    }
   ],
   "source": [
    "# Compute Std Deviation\n",
    "\n",
    "'''\n",
    "4.7. torch.std - Returns the standard deviation value of all elements in the input tensor.\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([1.,2.,3.,4.,5.,1.0])\n",
    "x_out = torch.std(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([1., 2., 3., 4., 5., 1.])\n",
      "x_out =  tensor(16.)\n"
     ]
    }
   ],
   "source": [
    "# Compute Sum of all elements in tensor\n",
    "\n",
    "'''\n",
    "4.8. torch.sum - Returns the sum of all elements in the input tensor.\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([1.,2.,3.,4.,5.,1.0])\n",
    "x_out = torch.sum(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([1., 2., 3., 4., 5., 1.])\n",
      "x_out =  tensor(2.6667)\n"
     ]
    }
   ],
   "source": [
    "# Find variance of all elements from a tensor\n",
    "\n",
    "'''\n",
    "4.9. torch.var - Returns the variance of all elements in the input tensor.\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([1.,2.,3.,4.,5.,1.0])\n",
    "x_out = torch.var(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using erf\n",
      "x_in =  tensor([ 0.3236,  1.0342, -0.5976,  0.5781, -0.4041])\n",
      "x_out =  tensor([ 0.3528,  0.8564, -0.6020,  0.5864, -0.4323])\n",
      "\n",
      "\n",
      "Using erfc\n",
      "x_in =  tensor([-0.1442,  0.4102, -1.7177, -1.6994, -0.7293])\n",
      "x_out =  tensor([1.1616, 0.5618, 1.9849, 1.9838, 1.6976])\n",
      "\n",
      "\n",
      "Using erfinv\n",
      "x_in =  tensor([-0.0819, -2.3847,  1.7459, -1.7639, -0.2544])\n",
      "x_out =  tensor([-0.0727,     nan,     nan,     nan, -0.2294])\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Error Functions\n",
    "\n",
    "'''\n",
    "5.1 torch.erf - Computes the error function of each element. \n",
    "'''\n",
    "\n",
    "x_in = torch.randn(5)\n",
    "x_out = torch.erf(x_in)\n",
    "\n",
    "print(\"Using erf\")\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)\n",
    "print(\"\\n\")\n",
    "\n",
    "\n",
    "'''\n",
    "5.2 torch.erfc - Computes the complementary error function of each element. \n",
    "'''\n",
    "\n",
    "x_in = torch.randn(5)\n",
    "x_out = torch.erfc(x_in)\n",
    "\n",
    "print(\"Using erfc\")\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)\n",
    "print(\"\\n\")\n",
    "\n",
    "\n",
    "'''\n",
    "5.3 torch.erfinv - Computes the inverse error function of each element.\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(5)\n",
    "x_out = torch.erfinv(x_in)\n",
    "\n",
    "print(\"Using erfinv\")\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)\n",
    "print(\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using exp\n",
      "x_in =  tensor([-7.2379e-01,  4.0003e-01, -5.4729e-04, -1.5560e+00,  8.3928e-01])\n",
      "x_out =  tensor([0.4849, 1.4919, 0.9995, 0.2110, 2.3147])\n",
      "\n",
      "\n",
      "Using expm1\n",
      "x_in =  tensor([-0.4012,  0.1406,  1.2204,  1.0226,  0.4754])\n",
      "x_out =  tensor([-0.3305,  0.1509,  2.3884,  1.7804,  0.6086])\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Exponential\n",
    "\n",
    "'''\n",
    "5.4. torch.exp - Returns a new tensor with the exponential of the elements of input\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(5)\n",
    "x_out = torch.exp(x_in)\n",
    "\n",
    "print(\"Using exp\")\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)\n",
    "print(\"\\n\")\n",
    "\n",
    "\n",
    "'''\n",
    "5.5. torch.expm1 - Returns a new tensor with the exponential of the elements minus 1 of input\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(5)\n",
    "x_out = torch.expm1(x_in)\n",
    "\n",
    "print(\"Using expm1\")\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)\n",
    "print(\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([20, 14, 15, 17,  8])\n",
      "x_out =  tensor([0, 0, 1, 1, 0])\n"
     ]
    }
   ],
   "source": [
    "# Element wise remainder\n",
    "\n",
    "'''\n",
    "5.6. torch.fmod - Computes the element-wise remainder of division.\n",
    "        - input (Tensor) – the dividend\n",
    "        - divisor (Tensor or float) – the divisor, which may be either a number or a tensor of the same shape as \n",
    "            the dividend\n",
    "        - out (Tensor, optional) – the output tensor\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([20, 14, 15, 17, 8])\n",
    "x_out = torch.fmod(x_in, 2.0)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([-1, -2,  3])\n",
      "x_out =  tensor([1, 2, 3])\n"
     ]
    }
   ],
   "source": [
    "# Absolute\n",
    "\n",
    "'''\n",
    "5.7. torch.abs - Computes the element-wise absolute value of the given input tensor.\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([-1, -2, 3])\n",
    "x_out = torch.abs(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([20.4000, 14.3442, 15.0000, 17.1231,  8.0000])\n",
      "x_out =  tensor([0.4000, 0.3442, 0.0000, 0.1231, 0.0000])\n"
     ]
    }
   ],
   "source": [
    "# Element wise fraction portion\n",
    "\n",
    "'''\n",
    "5.8. torch.frac - Computes the fractional portion of each element in tensor\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([20.4, 14.344243, 15, 17.12312, 8.0])\n",
    "x_out = torch.frac(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using log\n",
      "x_in =  tensor([20.4000, 14.2000, 15.3000, 17.1000,  8.0000])\n",
      "x_out =  tensor([3.0155, 2.6532, 2.7279, 2.8391, 2.0794])\n",
      "\n",
      "\n",
      "Using log10\n",
      "x_in =  tensor([20.4000, 14.2000, 15.3000, 17.1000,  8.0000])\n",
      "x_out =  tensor([1.3096, 1.1523, 1.1847, 1.2330, 0.9031])\n",
      "\n",
      "\n",
      "Using log1p\n",
      "x_in =  tensor([20.4000, 14.2000, 15.3000, 17.1000,  8.0000])\n",
      "x_out =  tensor([3.0634, 2.7213, 2.7912, 2.8959, 2.1972])\n",
      "\n",
      "\n",
      "Using log2\n",
      "x_in =  tensor([20.4000, 14.2000, 15.3000, 17.1000,  8.0000])\n",
      "x_out =  tensor([4.3505, 3.8278, 3.9355, 4.0959, 3.0000])\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Logarithmic function\n",
    "\n",
    "'''\n",
    "5.9 torch.log - Returns a new tensor with the natural logarithm of the elements of input. Base of log - e\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([20.4, 14.2, 15.3, 17.1, 8.0])\n",
    "x_out = torch.log(x_in)\n",
    "\n",
    "print(\"Using log\")\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)\n",
    "print(\"\\n\")\n",
    "\n",
    "\n",
    "'''.5.10/ torch.log10 - Returns a new tensor with the natural logarithm of the elements of input. Base of log - 10\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([20.4, 14.2, 15.3, 17.1, 8.0])\n",
    "x_out = torch.log10(x_in)\n",
    "\n",
    "print(\"Using log10\")\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)\n",
    "print(\"\\n\")\n",
    "\n",
    "\n",
    "'''\n",
    "5.11. torch.log1p - Returns a new tensor with the natural logarithm of (1 + input).\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([20.4, 14.2, 15.3, 17.1, 8.0])\n",
    "x_out = torch.log1p(x_in)\n",
    "\n",
    "print(\"Using log1p\")\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)\n",
    "print(\"\\n\")\n",
    "\n",
    "\n",
    "'''\n",
    "5.12. torch.log2 - Returns a new tensor with the natural logarithm of the elements of input. Base of log - 2\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([20.4, 14.2, 15.3, 17.1, 8.0])\n",
    "x_out = torch.log2(x_in)\n",
    "\n",
    "print(\"Using log2\")\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)\n",
    "print(\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([ 0.9953,  1.2785, -0.3237, -0.0192,  0.3062])\n",
      "x_out =  tensor([-0.9953, -1.2785,  0.3237,  0.0192, -0.3062])\n"
     ]
    }
   ],
   "source": [
    "# Element wise negative \n",
    "\n",
    "'''\n",
    "5.13. torch.neg - Returns a new tensor with the negative of the elements of input\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(5)\n",
    "x_out = torch.neg(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([-1.4586,  0.1480, -0.1435,  1.4438,  0.1217])\n",
      "x_out =  tensor([-3.1033e+00,  3.2438e-03, -2.9545e-03,  3.0095e+00,  1.8013e-03])\n"
     ]
    }
   ],
   "source": [
    "# Pow\n",
    "\n",
    "'''\n",
    "5.14. torch.pow - Takes the power of each element in input with exponent and returns a tensor with the result.\n",
    "        - input (Tensor) – the input tensor\n",
    "        - exponent (float or tensor) – the exponent value\n",
    "        - out (Tensor, optional) – the output tensor\n",
    "'''\n",
    "x_in = torch.randn(5)\n",
    "x_out = torch.pow(x_in, 3.0)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([2.4000, 1.2000, 5.3000, 0.1000, 0.8000])\n",
      "x_out =  tensor([ 0.4167,  0.8333,  0.1887, 10.0000,  1.2500])\n"
     ]
    }
   ],
   "source": [
    "# Reciprocal\n",
    "\n",
    "'''\n",
    "5.15. torch.reciprocal - Returns a new tensor with the reciprocal of the elements of input\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([2.4, 1.2, 5.3, 0.1, 0.8])\n",
    "x_out = torch.reciprocal(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([2.4000, 1.2000, 5.3000, 0.1000, 0.8000])\n",
      "x_out =  tensor([0.6455, 0.9129, 0.4344, 3.1623, 1.1180])\n"
     ]
    }
   ],
   "source": [
    "# Squareroot-reciprocal\n",
    "\n",
    "'''\n",
    "5.16. torch.rsqrt - Returns a new tensor with the reciprocal of the square-root of each of the elements of input.\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([2.4, 1.2, 5.3, 0.1, 0.8])\n",
    "x_out = torch.rsqrt(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([ 1.1347, -1.0309, -1.8333, -0.8273,  1.3684])\n",
      "x_out =  tensor([0.7567, 0.2629, 0.1378, 0.3042, 0.7971])\n"
     ]
    }
   ],
   "source": [
    "# Sigmoid\n",
    "\n",
    "'''\n",
    "5.17. torch.sigmoid - Returns a new tensor with the sigmoid of the elements of input\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(5)\n",
    "x_out = torch.sigmoid(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([-0.6759, -1.4407, -0.7870,  0.2751,  0.9584])\n",
      "x_out =  tensor([-1., -1., -1.,  1.,  1.])\n"
     ]
    }
   ],
   "source": [
    "# Getting sign of element\n",
    "\n",
    "'''\n",
    "5.18. torch.sign - Returns a new tensor with the sign of the elements of input.\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(5)\n",
    "x_out = torch.sign(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([ 2.4000, -1.2000,  5.3000,  0.1000,  0.8000])\n",
      "x_out =  tensor([1.5492,    nan, 2.3022, 0.3162, 0.8944])\n"
     ]
    }
   ],
   "source": [
    "# Square-root\n",
    "\n",
    "'''\n",
    "5.19. torch.sqrt - Returns a new tensor with the square-root of each of the elements of input.\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([2.4, -1.2, 5.3, 0.1, 0.8])\n",
    "x_out = torch.sqrt(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([1., 2., 3., 4., 5., 1.])\n",
      "x_out =  tensor(7.4833)\n"
     ]
    }
   ],
   "source": [
    "# Compute Norm\n",
    "\n",
    "'''\n",
    "5.20. torch.norm - Returns the normalized value of all elements in the input tensor.\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([1.,2.,3.,4.,5.,1.0])\n",
    "x_out = torch.norm(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_1 =  tensor([1., 2., 3., 4., 5., 1.])\n",
      "x_2 =  tensor([ 1.0000,  2.0000, 13.9000,  4.0000,  9.0000,  1.4000])\n",
      "x_out =  tensor([ True,  True, False,  True, False, False])\n"
     ]
    }
   ],
   "source": [
    "# Element wise Equality\n",
    "\n",
    "'''\n",
    "6.1. torch.eq - Computes element-wise equality\n",
    "        - input (Tensor) – the tensor to compare\n",
    "        - other (Tensor or float) – the tensor or value to compare\n",
    "        - out (Tensor, optional) – the output tensor. Must be a ByteTensor\n",
    "'''\n",
    "\n",
    "x_1 = torch.tensor([1.,2.,3.,4.,5.,1.0])\n",
    "x_2 = torch.tensor([1.,2.,13.9,4.,9.,1.4])\n",
    "x_out = torch.eq(x_1, x_2)\n",
    "\n",
    "print(\"x_1 = \", x_1)\n",
    "print(\"x_2 = \", x_2)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Greater than Equal to Function \n",
      "x_1 =  tensor([1., 2., 3., 4., 5., 1.])\n",
      "x_2 =  tensor([ 1.0000,  2.0000, 13.9000,  4.0000,  9.0000,  1.4000])\n",
      "x_out =  tensor([ True,  True, False,  True, False, False])\n",
      "\n",
      "\n",
      "Greater than function\n",
      "x_1 =  tensor([1., 2., 3., 4., 5., 1.])\n",
      "x_2 =  tensor([ 1.0000,  2.0000, 13.9000,  4.0000,  9.0000,  1.4000])\n",
      "x_out =  tensor([False, False, False, False, False, False])\n"
     ]
    }
   ],
   "source": [
    "# Element wise Greater-Than function\n",
    "\n",
    "'''\n",
    "6.2. torch.ge - Computes element-wise greater-than-equality\n",
    "        - input (Tensor) – the tensor to compare\n",
    "        - other (Tensor or float) – the tensor or value to compare\n",
    "        - out (Tensor, optional) – the output tensor. Must be a ByteTensor\n",
    "'''\n",
    "\n",
    "x_1 = torch.tensor([1.,2.,3.,4.,5.,1.0])\n",
    "x_2 = torch.tensor([1.,2.,13.9,4.,9.,1.4])\n",
    "x_out = torch.ge(x_1, x_2)\n",
    "\n",
    "print(\"Greater than Equal to Function \")\n",
    "print(\"x_1 = \", x_1)\n",
    "print(\"x_2 = \", x_2)\n",
    "print(\"x_out = \", x_out)\n",
    "print(\"\\n\")\n",
    "\n",
    "\n",
    "\n",
    "'''\n",
    "6.3. torch.gt - Computes element-wise greater-than function\n",
    "        - input (Tensor) – the tensor to compare\n",
    "        - other (Tensor or float) – the tensor or value to compare\n",
    "        - out (Tensor, optional) – the output tensor. Must be a ByteTensor\n",
    "'''\n",
    "\n",
    "x_1 = torch.tensor([1.,2.,3.,4.,5.,1.0])\n",
    "x_2 = torch.tensor([1.,2.,13.9,4.,9.,1.4])\n",
    "x_out = torch.gt(x_1, x_2)\n",
    "\n",
    "print(\"Greater than function\")\n",
    "print(\"x_1 = \", x_1)\n",
    "print(\"x_2 = \", x_2)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Less than Equal to Function \n",
      "x_1 =  tensor([1., 2., 3., 4., 5., 1.])\n",
      "x_2 =  tensor([ 1.0000,  2.0000, 13.9000,  4.0000,  9.0000,  1.4000])\n",
      "x_out =  tensor([True, True, True, True, True, True])\n",
      "\n",
      "\n",
      "Less than function\n",
      "x_1 =  tensor([1., 2., 3., 4., 5., 1.])\n",
      "x_2 =  tensor([ 1.0000,  2.0000, 13.9000,  4.0000,  9.0000,  1.4000])\n",
      "x_out =  tensor([False, False,  True, False,  True,  True])\n"
     ]
    }
   ],
   "source": [
    "# Element wise Less-Than function\n",
    "\n",
    "'''\n",
    "6.4. torch.le - Computes element-wise less-than-equality\n",
    "        - input (Tensor) – the tensor to compare\n",
    "        - other (Tensor or float) – the tensor or value to compare\n",
    "        - out (Tensor, optional) – the output tensor. Must be a ByteTensor\n",
    "'''\n",
    "\n",
    "x_1 = torch.tensor([1.,2.,3.,4.,5.,1.0])\n",
    "x_2 = torch.tensor([1.,2.,13.9,4.,9.,1.4])\n",
    "x_out = torch.le(x_1, x_2)\n",
    "\n",
    "print(\"Less than Equal to Function \")\n",
    "print(\"x_1 = \", x_1)\n",
    "print(\"x_2 = \", x_2)\n",
    "print(\"x_out = \", x_out)\n",
    "print(\"\\n\")\n",
    "\n",
    "\n",
    "\n",
    "'''\n",
    "6.5. torch.lt - Computes element-wise less-than function\n",
    "        - input (Tensor) – the tensor to compare\n",
    "        - other (Tensor or float) – the tensor or value to compare\n",
    "        - out (Tensor, optional) – the output tensor. Must be a ByteTensor\n",
    "'''\n",
    "\n",
    "x_1 = torch.tensor([1.,2.,3.,4.,5.,1.0])\n",
    "x_2 = torch.tensor([1.,2.,13.9,4.,9.,1.4])\n",
    "x_out = torch.lt(x_1, x_2)\n",
    "\n",
    "print(\"Less than function\")\n",
    "print(\"x_1 = \", x_1)\n",
    "print(\"x_2 = \", x_2)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([1., 2., 3., 4., 5., 1.])\n",
      "x_out_max =  tensor(5.)\n",
      "x_out_min =  tensor(1.)\n"
     ]
    }
   ],
   "source": [
    "# Extracting min and max element\n",
    "\n",
    "'''\n",
    "6.6. torch.max - Returns the maximum value of all elements in the input tensor.\n",
    "6.7. torch.min - Returns the minimum value of all elements in the input tensor.\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([1.,2.,3.,4.,5.,1.0])\n",
    "x_out_max = torch.max(x_in)\n",
    "x_out_min = torch.min(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out_max = \", x_out_max)\n",
    "print(\"x_out_min = \", x_out_min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([1, 2, 3, 4, 3, 2, 1])\n",
      "Cumulative product first row =  tensor([  1,   2,   6,  24,  72, 144, 144])\n"
     ]
    }
   ],
   "source": [
    "# Cumulative Product\n",
    "\n",
    "'''\n",
    "7.1. torch.cumprod - Returns the cumulative product of elements of input in the dimension dim.\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([1,2,3,4,3,2,1])\n",
    "x_out_first_row = torch.cumprod(x_in, dim=0)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"Cumulative product first row = \", x_out_first_row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([1, 2, 3, 4, 3, 2, 1])\n",
      "Cumulative sum first row =  tensor([ 1,  3,  6, 10, 13, 15, 16])\n"
     ]
    }
   ],
   "source": [
    "# Cumulative Sum\n",
    "\n",
    "'''\n",
    "7.2. torch.cumsum - Returns the cumulative sum of elements of input in the dimension dim.\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([1,2,3,4,3,2,1])\n",
    "x_out_first_row = torch.cumsum(x_in, dim=0)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"Cumulative sum first row = \", x_out_first_row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([ 0.8156, -0.1216,  0.4197,  0.0339, -1.0695])\n",
      "x_out =  tensor(1.7992)\n"
     ]
    }
   ],
   "source": [
    "# Log to Sum of Exponentials\n",
    "\n",
    "'''\n",
    "7.3. torch.logsumexp - Returns the log of summed exponentials of each \n",
    "        row of the input tensor in the given dimension dim. The computation is numerically stabilized.\n",
    "            - input (Tensor) – the input tensor\n",
    "            - dim (int or tuple of python:ints) – the dimension or dimensions to reduce\n",
    "            - keepdim (bool) – whether the output tensor has dim retained or not\n",
    "            - out (Tensor, optional) – the output tensor\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(5)\n",
    "x_out = torch.logsumexp(x_in, dim=0)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_1 =  tensor([1, 2, 3, 4])\n",
      "x_2 =  tensor([-1, -2,  3,  4])\n",
      "x_out =  tensor([[-1, -2,  3,  4],\n",
      "        [-2, -4,  6,  8],\n",
      "        [-3, -6,  9, 12],\n",
      "        [-4, -8, 12, 16]])\n"
     ]
    }
   ],
   "source": [
    "# Einstein Summation Convention\n",
    "\n",
    "'''\n",
    "7.4. torch.einsum - This function provides a way of computing multilinear expressions \n",
    "    (i.e. sums of products) using the Einstein summation convention.\n",
    "'''\n",
    "\n",
    "x_1 = torch.tensor([1, 2, 3, 4])\n",
    "x_2 = torch.tensor([-1, -2, 3, 4])\n",
    "\n",
    "x_out = torch.einsum('i,j->ij', (x_1,x_2))  # outer product\n",
    "\n",
    "print(\"x_1 = \", x_1)\n",
    "print(\"x_2 = \", x_2)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([  1.,   2.,   3.,   4.,  10.,  11.,  12.,  13., 100., 101., 102.])\n",
      "histogram -  tensor([8., 0., 3.])\n"
     ]
    }
   ],
   "source": [
    "# Compute Histogram of tensor\n",
    "\n",
    "'''\n",
    "7.5. torch.histc - Computes the histogram of a tensor.\n",
    "        - input (Tensor) – the input tensor\n",
    "        - bins (int) – number of histogram bins\n",
    "        - min (int) – lower end of the range (inclusive)\n",
    "        - max (int) – upper end of the range (inclusive)\n",
    "        - out (Tensor, optional) – the output tensor\n",
    "\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([1., 2., 3., 4., 10., 11., 12., 13., 100.,101., 102.])\n",
    "hist = torch.histc(x_in, bins=3, min=0, max=150)\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"histogram - \", hist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([1., 2., 3., 4., 5., 1.])\n",
      "x_out =  tensor([1., 2., 3., 4., 5.])\n"
     ]
    }
   ],
   "source": [
    "# Extract unique elements from a tensor\n",
    "\n",
    "'''\n",
    "8.1. torch.unique - Returns the unique scalar elements of the input tensor as a 1-D tensor.\n",
    "        - input (Tensor) – the input tensor\n",
    "        - sorted (bool) – Whether to sort the unique elements in ascending order before returning as output.\n",
    "        - return_inverse (bool) – Whether to also return the indices for where elements in the original input \n",
    "            ended up in the returned unique list.\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([1.,2.,3.,4.,5.,1.0])\n",
    "x_out = torch.unique(x_in, sorted=True)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([-0.5736,  0.4717, -0.7588,  0.6308, -0.3786, -0.3158, -1.0450,  0.1311,\n",
      "         1.5776, -0.0115])\n",
      "x_out =  tensor([-1.0450, -0.7588, -0.5736, -0.3786, -0.3158, -0.0115,  0.1311,  0.4717,\n",
      "         0.6308,  1.5776])\n",
      "indices =  tensor([6, 2, 0, 4, 5, 9, 7, 1, 3, 8])\n"
     ]
    }
   ],
   "source": [
    "# Sorting a tensor\n",
    "\n",
    "'''\n",
    "8.2. torch.sort - Sorts the elements of the input tensor along a given dimension in ascending order by value.\n",
    "        - input (Tensor) – the input tensor\n",
    "        - dim (int, optional) – the dimension to sort along\n",
    "        - descending (bool, optional) – controls the sorting order (ascending or descending)\n",
    "        - out (tuple, optional) – the output tuple of (Tensor, LongTensor) that can be optionally given to be used as output buffers\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(10)\n",
    "x_out, indices = torch.sort(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)\n",
    "print(\"indices = \", indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([-0.4450, -1.2155, -0.5813, -0.0745, -0.8010, -2.6278, -0.6903,  1.2702,\n",
      "         1.7772, -0.0308])\n",
      "top K elements =  tensor([ 1.7772,  1.2702, -0.0308])\n",
      "Indices of top K elements =  tensor([8, 7, 9])\n"
     ]
    }
   ],
   "source": [
    "# Getting top-K Elements from tensor\n",
    "\n",
    "'''\n",
    "8.3. torch.topk - Returns the k largest elements of the given input tensor along a given dimension.\n",
    "        - input (Tensor) – the input tensor\n",
    "        - k (int) – the k in “top-k”\n",
    "        - dim (int, optional) – the dimension to sort along\n",
    "        - largest (bool, optional) – controls whether to return largest or smallest elements\n",
    "        - sorted (bool, optional) – controls whether to return the elements in sorted order\n",
    "        - out (tuple, optional) – the output tuple of (Tensor, LongTensor) that can be optionally given to be \n",
    "            used as output buffers\n",
    "\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(10)\n",
    "x_out, indices = torch.topk(x_in, 3)\n",
    "\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"top K elements = \", x_out)\n",
    "print(\"Indices of top K elements = \", indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([1, 2, 3, 2, 1, 4, 5, 4, 6, 6])\n",
      "x_out =  tensor([0, 2, 2, 1, 2, 1, 2])\n"
     ]
    }
   ],
   "source": [
    "# Bin Count\n",
    "\n",
    "'''\n",
    "8.4. torch.bitcount - Count the frequency of each value in an array of non-negative ints.\n",
    "        - input (Tensor) – 1-d int tensor\n",
    "        - weights (Tensor) – optional, weight for each value in the input tensor. Should be of same size as input tensor.\n",
    "        - minlength (int) – optional, min number of bins. Should be non-negative.\n",
    "'''\n",
    "\n",
    "x_in = torch.tensor([1,2,3,2,1,4,5,4,6,6])\n",
    "x_out = torch.bincount(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([[1., 2., 3.],\n",
      "        [4., 5., 6.],\n",
      "        [7., 8., 9.]])\n",
      "trace =  tensor(15.)\n"
     ]
    }
   ],
   "source": [
    "# Compute trace of 2D matrix\n",
    "\n",
    "'''\n",
    "8.5. torch.trace - Returns the sum of the elements of the diagonal of the input 2-D matrix.\n",
    "'''\n",
    "\n",
    "x_in = torch.arange(1., 10.).view(3, 3) # Resizing using view\n",
    "trace = torch.trace(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"trace = \", trace)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input -  tensor([[-0.1694,  0.2934, -0.1465],\n",
      "        [-0.8273,  1.1799,  0.0102],\n",
      "        [ 0.3673,  0.6113, -0.4526]])\n",
      "Lower triangular matrix -  tensor([[-0.1694,  0.0000,  0.0000],\n",
      "        [-0.8273,  1.1799,  0.0000],\n",
      "        [ 0.3673,  0.6113, -0.4526]])\n",
      "Upper triangular matrix -  tensor([[-0.1694,  0.0000,  0.0000],\n",
      "        [-0.8273,  1.1799,  0.0000],\n",
      "        [ 0.3673,  0.6113, -0.4526]])\n"
     ]
    }
   ],
   "source": [
    "# Extract upper and lower trangular tensors\n",
    "\n",
    "'''\n",
    "8.6. torch.tril - Returns the lower triangular part of the matrix (2-D tensor) input, \n",
    "        the other elements of the result tensor out are set to 0.\n",
    "'''\n",
    "\n",
    "'''\n",
    "8.7. torch.triu - Returns the upper triangular part of the matrix (2-D tensor) input, \n",
    "        the other elements of the result tensor out are set to 0.\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(3, 3)\n",
    "\n",
    "x_l = torch.tril(x_in)\n",
    "x_u = torch.tril(x_in)\n",
    "\n",
    "print(\"Input - \", x_in)\n",
    "print(\"Lower triangular matrix - \", x_l)\n",
    "print(\"Upper triangular matrix - \", x_u)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start =  tensor([1., 2., 3., 4.])\n",
      "end =  tensor([10., 10., 10., 10.])\n",
      "interp =  tensor([5.5000, 6.0000, 6.5000, 7.0000])\n"
     ]
    }
   ],
   "source": [
    "# Linear Interpolation\n",
    "\n",
    "'''\n",
    "9.1. torch.lerp - oes a linear interpolation of two tensors start and end based on a scalar weight and \n",
    "    returns the resulting out tensor.\n",
    "        - start (Tensor) – the tensor with the starting points\n",
    "        - end (Tensor) – the tensor with the ending points\n",
    "        - weight (float) – the weight for the interpolation formula\n",
    "        - out (Tensor, optional) – the output tensor\n",
    "'''\n",
    "\n",
    "start = torch.arange(1., 5.)\n",
    "end = torch.empty(4).fill_(10)\n",
    "interp = torch.lerp(start, end, 0.5)\n",
    "\n",
    "print(\"start = \", start)\n",
    "print(\"end = \", end)\n",
    "print(\"interp = \", interp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_1 =  tensor([-0.5014, -1.5406,  0.6566, -1.4585])\n",
      "x_2 =  tensor([ 1.0054, -1.8375, -0.4761, -0.4371])\n",
      "x_out =  tensor(3.9578)\n"
     ]
    }
   ],
   "source": [
    "# LP-Norm\n",
    "\n",
    "'''\n",
    "9.2. torch.dist - Returns the lp-norm of (input - other)\n",
    "        - input (Tensor) – the input tensor\n",
    "        - other (Tensor) – the Right-hand-side input tensor\n",
    "        - p (float, optional) – the norm to be computed\n",
    "'''\n",
    "\n",
    "x_1 = torch.randn(4)\n",
    "x_2 = torch.randn(4)\n",
    "\n",
    "x_out = torch.dist(x_1, x_2, p=1)\n",
    "\n",
    "print(\"x_1 = \", x_1)\n",
    "print(\"x_2 = \", x_2)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([[-0.4266,  0.4356],\n",
      "        [ 0.7266, -1.1945],\n",
      "        [-0.5247,  0.2099]])\n",
      "x_fft =  tensor([[-0.2247, -0.5490],\n",
      "        [-1.7439, -0.1557],\n",
      "        [ 0.6887,  2.0114]])\n",
      "x_ifft =  tensor([[-0.4266,  0.4356],\n",
      "        [ 0.7266, -1.1945],\n",
      "        [-0.5247,  0.2099]])\n"
     ]
    }
   ],
   "source": [
    "# Discrete FFT\n",
    "\n",
    "'''\n",
    "9.3. torch.fft - Complex-to-complex Discrete Fourier Transform\n",
    "        - input (Tensor) – the input tensor of at least signal_ndim + 1 dimensions\n",
    "        - signal_ndim (int) – the number of dimensions in each signal. signal_ndim can only be 1, 2 or 3\n",
    "        - normalized (bool, optional) – controls whether to return normalized results. Default: False\n",
    "'''\n",
    "\n",
    "'''\n",
    "Uses\n",
    "    - Image sharpening, edge detection,smoothing are a few common applications.\n",
    "    - Image filter design\n",
    "    - Weiner Deconvolution is a popular deconv method to de-blur the blurred images. Deconvolution is more \n",
    "        easily done in frequency domain (2D FFT is used to convert to freq. domain). \n",
    "'''\n",
    "\n",
    "\n",
    "x_in = x = torch.randn(3, 2)\n",
    "x_out = torch.fft(x_in, 1)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_fft = \", x_out)\n",
    "\n",
    "\n",
    "'''\n",
    "9.4. torch.ifft - Complex-to-complex Inverse Discrete Fourier Transform\n",
    "        - input (Tensor) – the input tensor of at least signal_ndim + 1 dimensions\n",
    "        - signal_ndim (int) – the number of dimensions in each signal. signal_ndim can only be 1, 2 or 3\n",
    "        - normalized (bool, optional) – controls whether to return normalized results. Default: False\n",
    "'''\n",
    "\n",
    "x_out_ifft = torch.ifft(x_out, 1)\n",
    "print(\"x_ifft = \", x_out_ifft)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([[ 0.0873,  0.3097],\n",
      "        [-0.9329, -0.5255],\n",
      "        [-0.5552, -1.3255]])\n",
      "x_fft =  tensor([[[[ 0.0873,  0.0000],\n",
      "          [ 0.3097,  0.0000]]],\n",
      "\n",
      "\n",
      "        [[[-0.9329,  0.0000],\n",
      "          [-0.5255,  0.0000]]],\n",
      "\n",
      "\n",
      "        [[[-0.5552,  0.0000],\n",
      "          [-1.3255,  0.0000]]]])\n"
     ]
    }
   ],
   "source": [
    "# Short time Fourtier Transform\n",
    "\n",
    "'''\n",
    "9.5. torch.stft\n",
    "        - input (Tensor) – the input tensor\n",
    "        - n_fft (int, optional) – size of Fourier transform\n",
    "        - hop_length (int) – the distance between neighboring sliding window frames. \n",
    "            Default: None (treated as equal to floor(n_fft / 4))\n",
    "        - win_length (int) – the size of window frame and STFT filter. Default: None (treated as equal to n_fft)\n",
    "        - window (Tensor, optional) – the optional window function. Default: None (treated as window of all :math:`1`s)\n",
    "        - center (bool, optional) – whether to pad input on both sides so that the t-th frame is centered at \n",
    "            time t×hop_length. Default: True\n",
    "        - pad_mode (string, optional) – controls the padding method used when center is True. Default: \"reflect\"\n",
    "        - normalized (bool, optional) – controls whether to return the normalized STFT results Default: False\n",
    "        - onesided (bool, optional) – controls whether to return half of results to avoid redundancy Default: True\n",
    "'''\n",
    "\n",
    "'''\n",
    "Uses\n",
    "    - Used to analyse music data\n",
    "'''\n",
    "\n",
    "x_in = x = torch.randn(3, 2)\n",
    "x_out = torch.stft(x_in, 1, 1)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"x_fft = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_1 =  tensor([[ 1.1527,  0.7574,  1.1231],\n",
      "        [ 0.6044,  1.6323, -0.2233],\n",
      "        [ 0.1655, -0.5989,  0.4700]])\n",
      "x_2 =  tensor([[-0.0880, -0.3038,  2.2624],\n",
      "        [-0.6783,  0.7465,  0.0616],\n",
      "        [ 0.4991, -1.0001,  0.3942]])\n",
      "x_out =  tensor([[ 0.4139, -1.1854, -0.1170],\n",
      "        [-0.5900,  0.9395,  0.6206],\n",
      "        [-0.7287,  1.0613,  0.5745]])\n"
     ]
    }
   ],
   "source": [
    "# Cross product of vectors\n",
    "\n",
    "'''\n",
    "9.6. torch.cross - Returns the cross product of vectors in dimension dim of input and other\n",
    "        - input (Tensor) – the input tensor\n",
    "        - other (Tensor) – the second input tensor\n",
    "        - dim (int, optional) – the dimension to take the cross-product in.\n",
    "        - out (Tensor, optional) – the output tensor\n",
    "'''\n",
    "\n",
    "x_1 = torch.randn(3, 3)\n",
    "x_2 = torch.randn(3, 3)\n",
    "\n",
    "x_out = torch.cross(x_1, x_2)\n",
    "\n",
    "print(\"x_1 = \", x_1)\n",
    "print(\"x_2 = \", x_2)\n",
    "print(\"x_out = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_in =  tensor([ 1.3826,  0.7320, -0.2635,  0.2178])\n",
      "Diagonal matrix =  tensor([[ 1.3826,  0.0000,  0.0000,  0.0000],\n",
      "        [ 0.0000,  0.7320,  0.0000,  0.0000],\n",
      "        [ 0.0000,  0.0000, -0.2635,  0.0000],\n",
      "        [ 0.0000,  0.0000,  0.0000,  0.2178]])\n"
     ]
    }
   ],
   "source": [
    "# Create a diagonal matrix or extract diagonal elements\n",
    "\n",
    "'''\n",
    "9.7. torch.diag - If input is a vector (1-D tensor), then returns a 2-D square tensor with the elements of input as \n",
    "        the diagonal. If input is a matrix (2-D tensor), then returns a 1-D tensor with the diagonal elements of input.\n",
    "        - input (Tensor) – the input tensor\n",
    "        - diagonal (int, optional) – the diagonal to consider.\n",
    "            - If diagonal = 0, it is the main diagonal.\n",
    "            - If diagonal > 0, it is above the main diagonal.\n",
    "            - If diagonal < 0, it is below the main diagonal.\n",
    "        - out (Tensor, optional) – the output tensor\n",
    "'''\n",
    "\n",
    "x_in = torch.randn(4)\n",
    "x_out = torch.diag(x_in)\n",
    "\n",
    "print(\"x_in = \", x_in)\n",
    "print(\"Diagonal matrix = \", x_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample Bartlett Window =  tensor([0.0000, 0.6667, 0.6667])\n",
      "\n",
      "\n",
      "Sample Blackman Window =  tensor([-2.9802e-08,  1.0000e+00, -2.9802e-08])\n",
      "\n",
      "\n",
      "Sample Hamming Window =  tensor([0.0800, 1.0000, 0.0800])\n",
      "\n",
      "\n",
      "Sample Hann Window =  tensor([0., 1., 0.])\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Filter Windows\n",
    "\n",
    "'''\n",
    "Information\n",
    "    - In signal processing, a window function (also known as an apodization function or tapering function[1]) \n",
    "        is a mathematical function that is zero-valued outside of some chosen interval. For instance, \n",
    "        a function that is constant inside the interval and zero elsewhere is called a rectangular window\n",
    "    - Used as an fir filter\n",
    "'''\n",
    "\n",
    "\n",
    "'''\n",
    "10.1. torch.bartlett_window \n",
    "        - window_length (int) – the size of returned window\n",
    "        - periodic (bool, optional) – If True, returns a window to be used as periodic function. \n",
    "            If False, return a symmetric window.\n",
    "        - dtype (torch.dtype, optional) – the desired data type of returned tensor. \n",
    "            Default: if None, uses a global default (see torch.set_default_tensor_type()). \n",
    "            Only floating point types are supported.\n",
    "        - layout (torch.layout, optional) – the desired layout of returned window tensor. \n",
    "            Only torch.strided (dense layout) is supported.\n",
    "        - device (torch.device, optional) – the desired device of returned tensor. \n",
    "            Default: if None, uses the current device for the default tensor type (see torch.set_default_tensor_type()). \n",
    "            device will be the CPU for CPU tensor types and the current CUDA device for CUDA tensor types.\n",
    "        - requires_grad (bool, optional) – If autograd should record operations on the returned tensor. Default: False\n",
    "'''\n",
    "\n",
    "x_out = torch.bartlett_window(3, True)\n",
    "print(\"Sample Bartlett Window = \", x_out)\n",
    "print(\"\\n\")\n",
    "\n",
    "\n",
    "\n",
    "'''\n",
    "10.2. torch.blacman_window\n",
    "        - window_length (int) – the size of returned window\n",
    "        - periodic (bool, optional) – If True, returns a window to be used as periodic function. \n",
    "            If False, return a symmetric window.\n",
    "        - dtype (torch.dtype, optional) – the desired data type of returned tensor. \n",
    "            Default: if None, uses a global default (see torch.set_default_tensor_type()). \n",
    "            Only floating point types are supported.\n",
    "        - layout (torch.layout, optional) – the desired layout of returned window tensor. \n",
    "            Only torch.strided (dense layout) is supported.\n",
    "        - device (torch.device, optional) – the desired device of returned tensor. \n",
    "            Default: if None, uses the current device for the default tensor type (see torch.set_default_tensor_type()). \n",
    "            device will be the CPU for CPU tensor types and the current CUDA device for CUDA tensor types.\n",
    "        - requires_grad (bool, optional) – If autograd should record operations on the returned tensor. Default: False.\n",
    "\n",
    "'''\n",
    "\n",
    "x_out = torch.blackman_window(3, False)\n",
    "print(\"Sample Blackman Window = \", x_out)\n",
    "print(\"\\n\")\n",
    "\n",
    "\n",
    "'''\n",
    "10.3. torch.hamming_window\n",
    "        - window_length (int) – the size of returned window\n",
    "        - periodic (bool, optional) – If True, returns a window to be used as periodic function. \n",
    "            If False, return a symmetric window.\n",
    "        - dtype (torch.dtype, optional) – the desired data type of returned tensor. \n",
    "            Default: if None, uses a global default (see torch.set_default_tensor_type()). \n",
    "            Only floating point types are supported.\n",
    "        - layout (torch.layout, optional) – the desired layout of returned window tensor. \n",
    "            Only torch.strided (dense layout) is supported.\n",
    "        - device (torch.device, optional) – the desired device of returned tensor. \n",
    "            Default: if None, uses the current device for the default tensor type (see torch.set_default_tensor_type()). \n",
    "            device will be the CPU for CPU tensor types and the current CUDA device for CUDA tensor types.\n",
    "        - requires_grad (bool, optional) – If autograd should record operations on the returned tensor. Default: False.\n",
    "'''\n",
    "\n",
    "\n",
    "x_out = torch.hamming_window(3, False)\n",
    "print(\"Sample Hamming Window = \", x_out)\n",
    "print(\"\\n\")\n",
    "\n",
    "\n",
    "'''\n",
    "10.4. torch.hann_window\n",
    "        - window_length (int) – the size of returned window\n",
    "        - periodic (bool, optional) – If True, returns a window to be used as periodic function. \n",
    "            If False, return a symmetric window.\n",
    "        - dtype (torch.dtype, optional) – the desired data type of returned tensor. \n",
    "            Default: if None, uses a global default (see torch.set_default_tensor_type()). \n",
    "            Only floating point types are supported.\n",
    "        - layout (torch.layout, optional) – the desired layout of returned window tensor. \n",
    "            Only torch.strided (dense layout) is supported.\n",
    "        - device (torch.device, optional) – the desired device of returned tensor. \n",
    "            Default: if None, uses the current device for the default tensor type (see torch.set_default_tensor_type()). \n",
    "            device will be the CPU for CPU tensor types and the current CUDA device for CUDA tensor types.\n",
    "        - requires_grad (bool, optional) – If autograd should record operations on the returned tensor. Default: False.\n",
    "'''\n",
    "\n",
    "x_out = torch.hann_window(3, False)\n",
    "print(\"Sample Hann Window = \", x_out)\n",
    "print(\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Author - Tessellate Imaging - https://www.tessellateimaging.com/\n",
    "\n",
    "## Monk Library - https://github.com/Tessellate-Imaging/monk_v1\n",
    "\n",
    "    Monk is an opensource low-code tool for computer vision and deep learning\n",
    "\n",
    "### Monk features\n",
    "- low-code\n",
    "- unified wrapper over major deep learning framework - keras, pytorch, gluoncv\n",
    "- syntax invariant wrapper\n",
    "\n",
    "\n",
    "### Enables\n",
    "- to create, manage and version control deep learning experiments\n",
    "- to compare experiments across training metrics\n",
    "- to quickly find best hyper-parameters\n",
    "\n",
    "\n",
    "### At present it only supports transfer learning, but we are working each day to incorporate\n",
    "- GUI based custom model creation\n",
    "- various object detection and segmentation algorithms\n",
    "- deployment pipelines to cloud and local platforms\n",
    "- acceleration libraries such as TensorRT\n",
    "- preprocessing and post processing libraries\n",
    "\n",
    "## To contribute to Monk AI or Pytorch RoadMap repository raise an issue in the git-repo or dm us on linkedin \n",
    " - Abhishek - https://www.linkedin.com/in/abhishek-kumar-annamraju/\n",
    " - Akash - https://www.linkedin.com/in/akashdeepsingh01/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}