170100016_A3.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "170100016_A3.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OraBhWrkZgRt",
        "colab_type": "text"
      },
      "source": [
        "***\n",
        "#**Question 1**\n",
        "***\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A-USPpqk1iKJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# importing required libraries\n",
        "import numpy as np"
      ],
      "execution_count": 143,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wdYMC0jjZhHO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Function to calculate dissimilarity/similarity measure between two data points\n",
        "def dissimilarity_similarity(x,y,measure,args=None):\n",
        "  try:\n",
        "    if ((type(x) == list) or (type(x) == np.ndarray)) and ((type(y) == list) or (type(y) == np.ndarray)):\n",
        "      if len(x) != len(y):\n",
        "        print('Input data points are of different dimensions')\n",
        "      else:\n",
        "        if measure == 'EN':\n",
        "          dissimilarity = np.sqrt(np.sum(np.square(np.subtract(x,y))))\n",
        "          similarity = 1/(1+dissimilarity)\n",
        "          return dissimilarity,similarity\n",
        "        elif measure == 'HSN':\n",
        "          A = np.ones((len(x),len(x)))\n",
        "          dissimilarity = np.sqrt(np.matmul(np.matmul(np.subtract(x,y),A),np.subtract(x,y)))\n",
        "          similarity = 1/(1+dissimilarity)\n",
        "          return dissimilarity,similarity\n",
        "        elif measure == 'DN':\n",
        "          if type(args) == list:\n",
        "            if len(args) != len(x):\n",
        "              print('Diagonal matrix data dimension does not match with the dimensions of data points')\n",
        "            else:\n",
        "              dissimilarity = np.sqrt(np.matmul(np.matmul(np.subtract(x,y),np.diagflat(args)),np.subtract(x,y)))\n",
        "              similarity = 1/(1+dissimilarity)\n",
        "              return dissimilarity,similarity\n",
        "          else:\n",
        "            print('Invalid diagonal matrix data type. It must be vector.')\n",
        "        elif measure == 'MN':\n",
        "          mean = np.array(args).mean(0)\n",
        "          X = args-mean\n",
        "          A = np.linalg.inv((np.matmul(X,X.T))/(len(x)-1))\n",
        "          dissimilarity = np.sqrt(np.matmul(np.matmul(np.subtract(x,y),A),np.subtract(x,y)))\n",
        "          similarity = 1/(1+dissimilarity)\n",
        "          return dissimilarity,similarity\n",
        "        elif measure == 'LMN':\n",
        "          dissimilarity = np.power(np.sum(np.power(np.absolute(np.subtract(x,y)),args)),(1/args))\n",
        "          similarity = 1/(1+dissimilarity)\n",
        "          return dissimilarity,similarity\n",
        "        elif measure == 'CS':\n",
        "          similarity = (np.dot(x,y))/np.sqrt((np.sum(np.power(x,2)))*(np.sum(np.power(y,2)))) \n",
        "          dissimilarity = (1/similarity)-1\n",
        "          return dissimilarity,similarity\n",
        "        elif measure == 'OS':\n",
        "          similarity = (np.dot(x,y))/min((np.sum(np.power(x,2))),(np.sum(np.power(y,2))))\n",
        "          dissimilarity = (1/similarity)-1\n",
        "          return dissimilarity,similarity\n",
        "        elif measure == 'DS':\n",
        "          similarity = 2*(np.dot(x,y))/((np.sum(np.power(x,2)))+(np.sum(np.power(y,2))))\n",
        "          dissimilarity = (1/similarity)-1\n",
        "          return dissimilarity,similarity\n",
        "        elif measure == 'JS':\n",
        "          similarity = np.dot(x,y)/((np.sum(np.power(x,2)))+(np.sum(np.power(y,2)))-(np.dot(x,y)))\n",
        "          dissimilarity = (1/similarity)-1\n",
        "          return dissimilarity,similarity\n",
        "        else:\n",
        "          print('Invalid measure input.')\n",
        "    else:\n",
        "      print('Invalid input data type. Input data points should be an array.')\n",
        "  except:\n",
        "    print('Invalid input data type given')"
      ],
      "execution_count": 144,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kc6ujRo9ik4Z",
        "colab_type": "text"
      },
      "source": [
        "***\n",
        "#**Question 2**\n",
        "***"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "koppRaow1FAT",
        "colab_type": "text"
      },
      "source": [
        "**First aspect to be tested**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Atup7hR4ijl2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "61267f3a-5e98-4c3a-a52c-fc756c36984e"
      },
      "source": [
        "# Testing if the 2 vectors are close, then does it give high similarity values or not\n",
        "print(dissimilarity_similarity([7,1,3,4],[8,0,2,5],'CS'))\n",
        "print(dissimilarity_similarity([7,1,3,4],[8,0,2,5],'OS'))\n",
        "print(dissimilarity_similarity([7,1,3,4],[8,0,2,5],'DS'))\n",
        "print(dissimilarity_similarity([7,1,3,4],[8,0,2,5],'JS'))"
      ],
      "execution_count": 145,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(0.018493481005491752, 0.9818423177463695)\n",
            "(-0.08536585365853655, 1.0933333333333333)\n",
            "(0.024390243902439046, 0.9761904761904762)\n",
            "(0.04878048780487809, 0.9534883720930233)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qj3qwDfO1okT",
        "colab_type": "text"
      },
      "source": [
        "**Second aspect to be tested**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yziDn0YOu8TL",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 136
        },
        "outputId": "9d4a46ef-5c2d-459d-c32d-2871a313d1e8"
      },
      "source": [
        "# Testing if the 2 vectors are far away, then does it give high dissimilarity values or not\n",
        "print(dissimilarity_similarity([100,83,99,428],[8,0,2,5],'EN'))\n",
        "print(dissimilarity_similarity([100,83,99,428],[8,0,2,5],'HSN'))\n",
        "print(dissimilarity_similarity([100,83,99,428],[8,0,2,5],'DN',[4,9,6,5]))\n",
        "print(dissimilarity_similarity([100,94,86],[1,2,3],'MN',[[0,0,1],[0,0,4],[0,0,5]]))\n",
        "print(dissimilarity_similarity([100,83,99,428],[8,0,2,5],'LMN',7))\n",
        "print(dissimilarity_similarity([100,83,99,428],[8,0,2,5],'DS'))\n",
        "print(dissimilarity_similarity([100,83,99,428],[8,0,2,5],'JS'))"
      ],
      "execution_count": 146,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(451.3213932443265, 0.0022108173854598974)\n",
            "(695.0, 0.0014367816091954023)\n",
            "(1023.2086786183941, 0.0009763635291090774)\n",
            "(17164497458.731182, 5.825978898281483e-11)\n",
            "(423.00408268856313, 0.002358467856392114)\n",
            "(32.45554493307839, 0.029890411350355056)\n",
            "(64.91108986615679, 0.015171953642864396)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2srfW_Fj1rqY",
        "colab_type": "text"
      },
      "source": [
        "**Third aspect to be tested**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DRdJYvcuv3Gk",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "0e3d6d04-482e-4511-e5e4-8873ff24f899"
      },
      "source": [
        "# Testing if the functions give error message for invalid inputs\n",
        "print(dissimilarity_similarity([7,1,3],[8,0,2,5],'EN'))\n",
        "print(dissimilarity_similarity([\"fwe\"],'VER','HSN'))\n",
        "print(dissimilarity_similarity(['7','1','3','4'],[8,0,2,5],'DN',[4,9,6,5]))\n",
        "print(dissimilarity_similarity([1,2,3],['fsd',2],'MN',[[0,0,1],[0,0,4],[0,0,5]]))\n",
        "print(dissimilarity_similarity([7,1,3,4],[8,0,2,5],'CDRE'))"
      ],
      "execution_count": 147,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Input data points are of different dimensions\n",
            "None\n",
            "Invalid input data type. Input data points should be an array.\n",
            "None\n",
            "Invalid input data type given\n",
            "None\n",
            "Input data points are of different dimensions\n",
            "None\n",
            "Invalid measure input.\n",
            "None\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JcN6rSFW1vtl",
        "colab_type": "text"
      },
      "source": [
        "**Fourth aspect to be tested**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XNBppQK8xYy0",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 170
        },
        "outputId": "76ecfca0-b69a-4e24-b874-d09fcbc995bc"
      },
      "source": [
        "# Testing whether the dissimilarity value is 0 and similarity value is 1 if both the vectors are same (i.e. x = y) \n",
        "print(dissimilarity_similarity([10,53,82,0,-24],[10,53,82,0,-24],'EN'))\n",
        "print(dissimilarity_similarity([8,0,2,5],[8,0,2,5],'HSN'))\n",
        "print(dissimilarity_similarity([-4,-49,-200,-5],[-4,-49,-200,-5],'DN',[4,9,6,5]))\n",
        "print(dissimilarity_similarity([1,-24,300],[1,-24,300],'MN',[[0,0,1],[0,0,4],[0,0,5]]))\n",
        "print(dissimilarity_similarity([7.43,1.03,3.45,4.76],[7.43,1.03,3.45,4.76],'LMN',7))\n",
        "print(dissimilarity_similarity([1,1,1,1,1,1],[1,1,1,1,1,1],'CS'))\n",
        "print(dissimilarity_similarity([0.102],[0.102],'OS'))\n",
        "print(dissimilarity_similarity([10,0,10,0,10,0,10,0],[10,0,10,0,10,0,10,0],'DS'))\n",
        "print(dissimilarity_similarity([-5,24,-89,32,-49,-12,9.423,-23,-4,91],[-5,24,-89,32,-49,-12,9.423,-23,-4,91],'JS'))"
      ],
      "execution_count": 148,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(0.0, 1.0)\n",
            "(0.0, 1.0)\n",
            "(0.0, 1.0)\n",
            "(0.0, 1.0)\n",
            "(0.0, 1.0)\n",
            "(0.0, 1.0)\n",
            "(0.0, 1.0)\n",
            "(0.0, 1.0)\n",
            "(0.0, 1.0)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uvKK2DSm1yI1",
        "colab_type": "text"
      },
      "source": [
        "**Fifth aspect to be tested**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "finnkxCA10QJ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 187
        },
        "outputId": "32f59c08-c145-4f0a-f45c-f97411b5a126"
      },
      "source": [
        "# Testing if the Lebesgue norm approaches (1,0.5) as the value of alpha is gradually increased from 1 to infinity\n",
        "print(dissimilarity_similarity([7,1,3,4],[8,0,2,5],'LMN',1))\n",
        "print(dissimilarity_similarity([7,1,3,4],[8,0,2,5],'LMN',2))\n",
        "print(dissimilarity_similarity([7,1,3,4],[8,0,2,5],'LMN',3))\n",
        "print(dissimilarity_similarity([7,1,3,4],[8,0,2,5],'LMN',4))\n",
        "print(dissimilarity_similarity([7,1,3,4],[8,0,2,5],'LMN',5))\n",
        "print(dissimilarity_similarity([7,1,3,4],[8,0,2,5],'LMN',10))\n",
        "print(dissimilarity_similarity([7,1,3,4],[8,0,2,5],'LMN',100))\n",
        "print(dissimilarity_similarity([7,1,3,4],[8,0,2,5],'LMN',1000))\n",
        "print(dissimilarity_similarity([7,1,3,4],[8,0,2,5],'LMN',10000))\n",
        "print(dissimilarity_similarity([7,1,3,4],[8,0,2,5],'LMN',float('inf')))"
      ],
      "execution_count": 149,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(4.0, 0.2)\n",
            "(2.0, 0.3333333333333333)\n",
            "(1.5874010519681994, 0.3864882095643094)\n",
            "(1.4142135623730951, 0.4142135623730951)\n",
            "(1.3195079107728942, 0.43112592776921604)\n",
            "(1.148698354997035, 0.4653980386192365)\n",
            "(1.013959479790029, 0.49653431960024236)\n",
            "(1.0013872557113346, 0.4996534264652241)\n",
            "(1.0001386390456164, 0.49996534264102754)\n",
            "(1.0, 0.5)\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}