Logic_Gates.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mvharsh/Deep-Learning/blob/main/Logic_Gates.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Perceptron - Logic Gates**"
      ],
      "metadata": {
        "id": "jXcU42O1KfFZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **AND GATE**"
      ],
      "metadata": {
        "id": "ZHRObJ0RLT0q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# importing Python library\n",
        "import numpy as np\n",
        "\n",
        "\n",
        "# design Perceptron Model\n",
        "def perceptronModel(x, w, b):\n",
        "    v = np.dot(w, x) + b\n",
        "    if v < 1.5:\n",
        "      return 0\n",
        "    else:\n",
        "      return 1\n",
        "\n",
        "# AND Logic Function\n",
        "# w1 = 1, w2 = 1, b = 0\n",
        "def AND_logicFunction(x):\n",
        "    w = np.array([1, 1])\n",
        "    b = 0\n",
        "    return perceptronModel(x, w, b)\n",
        "\n",
        "# testing the Perceptron Model\n",
        "test1 = np.array([0, 1])\n",
        "test2 = np.array([1, 1])\n",
        "test3 = np.array([0, 0])\n",
        "test4 = np.array([1, 0])\n",
        "\n",
        "print(\"AND({}, {}) = {}\".format(0, 1, AND_logicFunction(test1)))\n",
        "print(\"AND({}, {}) = {}\".format(1, 1, AND_logicFunction(test2)))\n",
        "print(\"AND({}, {}) = {}\".format(0, 0, AND_logicFunction(test3)))\n",
        "print(\"AND({}, {}) = {}\".format(1, 0, AND_logicFunction(test4)))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KFIulBkbKltM",
        "outputId": "643b633d-3691-4364-9bca-8913d4e2b11a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "AND(0, 1) = 0\n",
            "AND(1, 1) = 1\n",
            "AND(0, 0) = 0\n",
            "AND(1, 0) = 0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **OR GATE**"
      ],
      "metadata": {
        "id": "H4VmlIHaMMhn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# importing Python library\n",
        "import numpy as np\n",
        "\n",
        "# design Perceptron Model\n",
        "def perceptronModel(x, w, b):\n",
        "    v = np.dot(w, x) + b\n",
        "    if v > 0:\n",
        "      return 1\n",
        "    else:\n",
        "      return 0\n",
        "\n",
        "# OR Logic Function\n",
        "# w1 = 1, w2 = 1, b = 0\n",
        "def OR_logicFunction(x):\n",
        "    w = np.array([1, 1])\n",
        "    b = 0\n",
        "    return perceptronModel(x, w, b)\n",
        "\n",
        "# testing the Perceptron Model\n",
        "test1 = np.array([0, 1])\n",
        "test2 = np.array([1, 1])\n",
        "test3 = np.array([0, 0])\n",
        "test4 = np.array([1, 0])\n",
        "\n",
        "print(\"OR({}, {}) = {}\".format(0, 1, OR_logicFunction(test1)))\n",
        "print(\"OR({}, {}) = {}\".format(1, 1, OR_logicFunction(test2)))\n",
        "print(\"OR({}, {}) = {}\".format(0, 0, OR_logicFunction(test3)))\n",
        "print(\"OR({}, {}) = {}\".format(1, 0, OR_logicFunction(test4)))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-fClmst_MLaI",
        "outputId": "5e598f4b-25fe-4947-fa54-6fce8475a0b8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "OR(0, 1) = 1\n",
            "OR(1, 1) = 1\n",
            "OR(0, 0) = 0\n",
            "OR(1, 0) = 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **XOR GATE**"
      ],
      "metadata": {
        "id": "GIp9haavQhh3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# importing Python library\n",
        "import numpy as np\n",
        "\n",
        "# design Perceptron Model\n",
        "def perceptronModel(x, w, b):\n",
        "    v = np.dot(w, x) + b\n",
        "    if v == 1:\n",
        "      return 1\n",
        "    else:\n",
        "      return 0\n",
        "\n",
        "# XOR Logic Function\n",
        "# w1 = 1, w2 = 1, b = 0\n",
        "def XOR_logicFunction(x):\n",
        "    w = np.array([1, 1])\n",
        "    b = 0\n",
        "    return perceptronModel(x, w, b)\n",
        "\n",
        "# testing the Perceptron Model\n",
        "test1 = np.array([0, 1])\n",
        "test2 = np.array([1, 1])\n",
        "test3 = np.array([0, 0])\n",
        "test4 = np.array([1, 0])\n",
        "\n",
        "print(\"XOR({}, {}) = {}\".format(0, 1, XOR_logicFunction(test1)))\n",
        "print(\"XOR({}, {}) = {}\".format(1, 1, XOR_logicFunction(test2)))\n",
        "print(\"XOR({}, {}) = {}\".format(0, 0, XOR_logicFunction(test3)))\n",
        "print(\"XOR({}, {}) = {}\".format(1, 0, XOR_logicFunction(test4)))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PRnfSZcjQk9m",
        "outputId": "153fb214-e8bb-4a4d-9665-e4094dd9976c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "XOR(0, 1) = 1\n",
            "XOR(1, 1) = 0\n",
            "XOR(0, 0) = 0\n",
            "XOR(1, 0) = 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **NAND GATE**"
      ],
      "metadata": {
        "id": "UXTj2yt5SXVG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# importing Python library\n",
        "import numpy as np\n",
        "\n",
        "# design Perceptron Model\n",
        "def perceptronModel(x, w, b):\n",
        "    v = np.dot(w, x) + b\n",
        "    if v < 2:\n",
        "      return 1\n",
        "    else:\n",
        "      return 0\n",
        "\n",
        "# NAND Logic Function\n",
        "# w1 = 1, w2 = 1, b = 0\n",
        "def NAND_logicFunction(x):\n",
        "    w = np.array([1, 1])\n",
        "    b = 0\n",
        "    return perceptronModel(x, w, b)\n",
        "\n",
        "# testing the Perceptron Model\n",
        "test1 = np.array([0, 1])\n",
        "test2 = np.array([1, 1])\n",
        "test3 = np.array([0, 0])\n",
        "test4 = np.array([1, 0])\n",
        "\n",
        "print(\"NAND({}, {}) = {}\".format(0, 1, NAND_logicFunction(test1)))\n",
        "print(\"NAND({}, {}) = {}\".format(1, 1, NAND_logicFunction(test2)))\n",
        "print(\"NAND({}, {}) = {}\".format(0, 0, NAND_logicFunction(test3)))\n",
        "print(\"NAND({}, {}) = {}\".format(1, 0, NAND_logicFunction(test4)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x1pAR2sgSaNO",
        "outputId": "4bf1ef6e-941c-49fb-ea4e-9682a9964dd7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "NAND(0, 1) = 1\n",
            "NAND(1, 1) = 0\n",
            "NAND(0, 0) = 1\n",
            "NAND(1, 0) = 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **NOR GATE**"
      ],
      "metadata": {
        "id": "OGgKT4NZTXip"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# importing Python library\n",
        "import numpy as np\n",
        "\n",
        "# design Perceptron Model\n",
        "def perceptronModel(x, w, b):\n",
        "    v = np.dot(w, x) + b\n",
        "    if v > 0:\n",
        "      return 0\n",
        "    else:\n",
        "      return 1\n",
        "\n",
        "# NOR Logic Function\n",
        "# w1 = 1, w2 = 1, b = 0\n",
        "def NOR_logicFunction(x):\n",
        "    w = np.array([1, 1])\n",
        "    b = 0\n",
        "    return perceptronModel(x, w, b)\n",
        "\n",
        "# testing the Perceptron Model\n",
        "test1 = np.array([0, 1])\n",
        "test2 = np.array([1, 1])\n",
        "test3 = np.array([0, 0])\n",
        "test4 = np.array([1, 0])\n",
        "\n",
        "print(\"NOR({}, {}) = {}\".format(0, 1, NOR_logicFunction(test1)))\n",
        "print(\"NOR({}, {}) = {}\".format(1, 1, NOR_logicFunction(test2)))\n",
        "print(\"NOR({}, {}) = {}\".format(0, 0, NOR_logicFunction(test3)))\n",
        "print(\"NOR({}, {}) = {}\".format(1, 0, NOR_logicFunction(test4)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mWlg3uK0TZrK",
        "outputId": "5d8ae914-8233-4cb0-f4ae-398766c7cf26"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "NOR(0, 1) = 0\n",
            "NOR(1, 1) = 0\n",
            "NOR(0, 0) = 1\n",
            "NOR(1, 0) = 0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **XNOR GATE**"
      ],
      "metadata": {
        "id": "eORuNFmLW9Gz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# importing Python library\n",
        "import numpy as np\n",
        "\n",
        "# design Perceptron Model\n",
        "def perceptronModel(x, w, b):\n",
        "    v = np.dot(w, x) + b\n",
        "    if v == 1:\n",
        "      return 0\n",
        "    else:\n",
        "      return 1\n",
        "\n",
        "# XNOR Logic Function\n",
        "# w1 = 1, w2 = 1, b = 0\n",
        "def XNOR_logicFunction(x):\n",
        "    w = np.array([1, 1])\n",
        "    b = 0\n",
        "    return perceptronModel(x, w, b)\n",
        "\n",
        "# testing the Perceptron Model\n",
        "test1 = np.array([0, 1])\n",
        "test2 = np.array([1, 1])\n",
        "test3 = np.array([0, 0])\n",
        "test4 = np.array([1, 0])\n",
        "\n",
        "print(\"XNOR({}, {}) = {}\".format(0, 1, XNOR_logicFunction(test1)))\n",
        "print(\"XNOR({}, {}) = {}\".format(1, 1, XNOR_logicFunction(test2)))\n",
        "print(\"XNOR({}, {}) = {}\".format(0, 0, XNOR_logicFunction(test3)))\n",
        "print(\"XNOR({}, {}) = {}\".format(1, 0, XNOR_logicFunction(test4)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tVsyAPeFW_bE",
        "outputId": "c76fbddd-62dd-4fcd-ebb3-1a7c3fdffcfa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "XNOR(0, 1) = 0\n",
            "XNOR(1, 1) = 1\n",
            "XNOR(0, 0) = 1\n",
            "XNOR(1, 0) = 0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **NOT GATE**"
      ],
      "metadata": {
        "id": "CmjBxiEvh9JX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# importing Python library\n",
        "import numpy as np\n",
        "\n",
        "\n",
        "# design Perceptron Model\n",
        "def perceptronModel(x, w, b):\n",
        "    v = np.dot(w, x) + b\n",
        "    if v == 0:\n",
        "      return 1\n",
        "    else:\n",
        "      return 0\n",
        "\n",
        "# AND Logic Function\n",
        "# w1 = 1, b = 0\n",
        "def NOT_logicFunction(x):\n",
        "    w = 1\n",
        "    b = 0\n",
        "    return perceptronModel(x, w, b)\n",
        "\n",
        "# testing the Perceptron Model\n",
        "test1 = 0\n",
        "test2 = 1\n",
        "\n",
        "print(\"NOT({}) = {}\".format(0, NOT_logicFunction(test1)))\n",
        "print(\"NOT({}) = {}\".format(1, NOT_logicFunction(test2)))\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UsWZg4EZiIjP",
        "outputId": "25cc0690-025b-42c0-c87d-c6f5d77358d0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "NOT(0) = 1\n",
            "NOT(1) = 0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Thresholding Function Model**"
      ],
      "metadata": {
        "id": "yzTCkB62LJrO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **AND GATE**"
      ],
      "metadata": {
        "id": "PdO1lJm9MG0A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# importing Python library\n",
        "import numpy as np\n",
        "\n",
        "# design Threshold function Model\n",
        "def ThresholdModel(x):\n",
        "    v = np.sum(x)\n",
        "    if v < 2:\n",
        "      return 0\n",
        "    else:\n",
        "      return 1\n",
        "\n",
        "\n",
        "# testing the Perceptron Model\n",
        "test1 = np.array([0, 1])\n",
        "test2 = np.array([1, 1])\n",
        "test3 = np.array([0, 0])\n",
        "test4 = np.array([1, 0])\n",
        "\n",
        "print(\"AND({}, {}) = {}\".format(0, 1, ThresholdModel(test1)))\n",
        "print(\"AND({}, {}) = {}\".format(1, 1, ThresholdModel(test2)))\n",
        "print(\"AND({}, {}) = {}\".format(0, 0, ThresholdModel(test3)))\n",
        "print(\"AND({}, {}) = {}\".format(1, 0, ThresholdModel(test4)))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fSvh806oLKEm",
        "outputId": "38941161-6957-43ab-c736-89d394590b32"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "AND(0, 1) = 0\n",
            "AND(1, 1) = 1\n",
            "AND(0, 0) = 0\n",
            "AND(1, 0) = 0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **OR GATE**"
      ],
      "metadata": {
        "id": "dIbnEnwhOBsR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# importing Python library\n",
        "import numpy as np\n",
        "\n",
        "# design Threshold function Model\n",
        "def ThresholdModel(x):\n",
        "    v = np.sum(x)\n",
        "    if v > 0:\n",
        "      return 1\n",
        "    else:\n",
        "      return 0\n",
        "\n",
        "\n",
        "# testing the Perceptron Model\n",
        "test1 = np.array([0, 1])\n",
        "test2 = np.array([1, 1])\n",
        "test3 = np.array([0, 0])\n",
        "test4 = np.array([1, 0])\n",
        "\n",
        "print(\"OR({}, {}) = {}\".format(0, 1, ThresholdModel(test1)))\n",
        "print(\"OR({}, {}) = {}\".format(1, 1, ThresholdModel(test2)))\n",
        "print(\"OR({}, {}) = {}\".format(0, 0, ThresholdModel(test3)))\n",
        "print(\"OR({}, {}) = {}\".format(1, 0, ThresholdModel(test4)))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CzI6S6nbODmo",
        "outputId": "24bcb013-7d57-4638-8b43-b40691a60ca3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "OR(0, 1) = 1\n",
            "OR(1, 1) = 1\n",
            "OR(0, 0) = 0\n",
            "OR(1, 0) = 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **XOR GATE**"
      ],
      "metadata": {
        "id": "OOG8j31tQ_g3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# importing Python library\n",
        "import numpy as np\n",
        "\n",
        "# design Threshold function Model\n",
        "def ThresholdModel(x):\n",
        "    v = np.sum(x)\n",
        "    if v == 1:\n",
        "      return 1\n",
        "    else:\n",
        "      return 0\n",
        "\n",
        "\n",
        "# testing the Perceptron Model\n",
        "test1 = np.array([0, 1])\n",
        "test2 = np.array([1, 1])\n",
        "test3 = np.array([0, 0])\n",
        "test4 = np.array([1, 0])\n",
        "\n",
        "print(\"XOR({}, {}) = {}\".format(0, 1, ThresholdModel(test1)))\n",
        "print(\"XOR({}, {}) = {}\".format(1, 1, ThresholdModel(test2)))\n",
        "print(\"XOR({}, {}) = {}\".format(0, 0, ThresholdModel(test3)))\n",
        "print(\"XOR({}, {}) = {}\".format(1, 0, ThresholdModel(test4)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g2XwV3jORKw9",
        "outputId": "a6b349e5-b110-4343-eded-8cbc03a5a670"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "XOR(0, 1) = 1\n",
            "XOR(1, 1) = 0\n",
            "XOR(0, 0) = 0\n",
            "XOR(1, 0) = 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **NAND GATE**"
      ],
      "metadata": {
        "id": "oKZHqZHVZwD9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# importing Python library\n",
        "import numpy as np\n",
        "\n",
        "# design Threshold function Model\n",
        "def ThresholdModel(x):\n",
        "    v = np.sum(x)\n",
        "    if v < 2:\n",
        "      return 1\n",
        "    else:\n",
        "      return 0\n",
        "\n",
        "\n",
        "# testing the Perceptron Model\n",
        "test1 = np.array([0, 1])\n",
        "test2 = np.array([1, 1])\n",
        "test3 = np.array([0, 0])\n",
        "test4 = np.array([1, 0])\n",
        "\n",
        "print(\"NAND({}, {}) = {}\".format(0, 1, ThresholdModel(test1)))\n",
        "print(\"NAND({}, {}) = {}\".format(1, 1, ThresholdModel(test2)))\n",
        "print(\"NAND({}, {}) = {}\".format(0, 0, ThresholdModel(test3)))\n",
        "print(\"NAND({}, {}) = {}\".format(1, 0, ThresholdModel(test4)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SBEOfjVjZ3nE",
        "outputId": "36006a82-afd7-4549-d105-f8a5c3a138c2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "NAND(0, 1) = 1\n",
            "NAND(1, 1) = 0\n",
            "NAND(0, 0) = 1\n",
            "NAND(1, 0) = 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **NOR GATE**"
      ],
      "metadata": {
        "id": "u0RVHk-qauTE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# importing Python library\n",
        "import numpy as np\n",
        "\n",
        "# design Threshold function Model\n",
        "def ThresholdModel(x):\n",
        "    v = np.sum(x)\n",
        "    if v > 0:\n",
        "      return 0\n",
        "    else:\n",
        "      return 1\n",
        "\n",
        "\n",
        "# testing the Perceptron Model\n",
        "test1 = np.array([0, 1])\n",
        "test2 = np.array([1, 1])\n",
        "test3 = np.array([0, 0])\n",
        "test4 = np.array([1, 0])\n",
        "\n",
        "print(\"NOR({}, {}) = {}\".format(0, 1, ThresholdModel(test1)))\n",
        "print(\"NOR({}, {}) = {}\".format(1, 1, ThresholdModel(test2)))\n",
        "print(\"NOR({}, {}) = {}\".format(0, 0, ThresholdModel(test3)))\n",
        "print(\"NOR({}, {}) = {}\".format(1, 0, ThresholdModel(test4)))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5IjZN2fUaum0",
        "outputId": "16fadbb3-20bb-44b5-e93b-6c7603549bcb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "NOR(0, 1) = 0\n",
            "NOR(1, 1) = 0\n",
            "NOR(0, 0) = 1\n",
            "NOR(1, 0) = 0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **XNOR GATE**"
      ],
      "metadata": {
        "id": "U1edCI2FbTnT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# importing Python library\n",
        "import numpy as np\n",
        "\n",
        "# design Threshold function Model\n",
        "def ThresholdModel(x):\n",
        "    v = np.sum(x)\n",
        "    if v == 1:\n",
        "      return 0\n",
        "    else:\n",
        "      return 1\n",
        "\n",
        "\n",
        "# testing the Perceptron Model\n",
        "test1 = np.array([0, 1])\n",
        "test2 = np.array([1, 1])\n",
        "test3 = np.array([0, 0])\n",
        "test4 = np.array([1, 0])\n",
        "\n",
        "print(\"XNOR({}, {}) = {}\".format(0, 1, ThresholdModel(test1)))\n",
        "print(\"XNOR({}, {}) = {}\".format(1, 1, ThresholdModel(test2)))\n",
        "print(\"XNOR({}, {}) = {}\".format(0, 0, ThresholdModel(test3)))\n",
        "print(\"XNOR({}, {}) = {}\".format(1, 0, ThresholdModel(test4)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a-AdN-TebSro",
        "outputId": "62e495ed-eb99-4337-987f-cc43d47e6b0f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "XNOR(0, 1) = 0\n",
            "XNOR(1, 1) = 1\n",
            "XNOR(0, 0) = 1\n",
            "XNOR(1, 0) = 0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **NOT GATE**"
      ],
      "metadata": {
        "id": "kG1hm9gSjExI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# importing Python library\n",
        "import numpy as np\n",
        "\n",
        "# design Threshold function Model\n",
        "def ThresholdModel(v):\n",
        "    if v == 1:\n",
        "      return 0\n",
        "    else:\n",
        "      return 1\n",
        "\n",
        "\n",
        "# testing the Perceptron Model\n",
        "test1 = 0\n",
        "test2 = 1\n",
        "\n",
        "print(\"NOT({}) = {}\".format(0, ThresholdModel(test1)))\n",
        "print(\"NOT({}) = {}\".format(1, ThresholdModel(test2)))\n"
      ],
      "metadata": {
        "id": "P5I6Ni31jHj3",
        "outputId": "ffa9d9ae-47bf-45dc-d740-a7aee4015768",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "NOT(0) = 1\n",
            "NOT(1) = 0\n"
          ]
        }
      ]
    }
  ]
}