Defuzzyfying.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def open_left(x, alpha, beta):\n",
    "    if x <= alpha:\n",
    "        return 1 \n",
    "\n",
    "    elif alpha < x < beta:\n",
    "        return (beta - x)/ (beta - alpha)\n",
    "\n",
    "    else:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def open_right(x, a, b):\n",
    "    if x>= b:\n",
    "        return 1\n",
    "    elif x <= a:\n",
    "        return 0\n",
    "    else:\n",
    "        return (x-a)/(b-a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def triangular(x, a , b, c):\n",
    "    return max(min((x-a)/(b-a), (c-x)/(c-b)),0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fuzzifying(x):\n",
    "    '''\n",
    "    input x -> need to find the membership value for x\n",
    "    return -> which function it touches and what's the membership value\n",
    "    '''\n",
    "    NL, NM, NS, ZE, PS, PM, PL = 0, 0, 0, 0, 0, 0, 0\n",
    "    \n",
    "    if x >= 0 and x <= 60:\n",
    "        NL = open_left(x, 30, 60)\n",
    "        \n",
    "    if x >= 30 and x <= 90:\n",
    "        NM = triangular(x, 30, 60, 90)\n",
    "        \n",
    "    if x>= 60 and x <= 120:\n",
    "        NS = triangular(x, 60, 90, 120)\n",
    "        \n",
    "    if x >= 90 and x <= 150:\n",
    "        ZE = triangular(x, 90, 120, 150)\n",
    "        \n",
    "    if x>= 120 and x <= 180:\n",
    "        PS = triangular(x, 120, 150, 180)\n",
    "        \n",
    "    if x >= 150 and x <= 210:\n",
    "        PM = triangular(x, 150, 180, 210)\n",
    "        \n",
    "    if x>= 180 and x <= 210:\n",
    "        PL = open_right(x, 180, 210)\n",
    "        \n",
    "    return  NL, NM, NS, ZE, PS, PM, PL\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 0.3333333333333333 0.6666666666666666 0 0 0\n"
     ]
    }
   ],
   "source": [
    "speed_difference = 110\n",
    "NLSD, NMSD, NSSD, ZESD, PSSD, PMSD, PLSD = fuzzifying(speed_difference)\n",
    "print(NLSD, NMSD, NSSD, ZESD, PSSD, PMSD, PLSD)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 0.16666666666666666 0.8333333333333334 0 0 0\n"
     ]
    }
   ],
   "source": [
    "accelaration = 115\n",
    "NLAC, NMAC, NSAC, ZEAC, PSAC, PMAC, PLAC = fuzzifying(accelaration)\n",
    "print(NLAC, NMAC, NSAC, ZEAC, PSAC, PMAC, PLAC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Rules\n",
    "- R1: if SD is NL and A is ZE then TC is PL\n",
    "- R2: if SD is ZE and A is NL then TC is PL\n",
    "- R3: if SD is NM and A is ZE then TC is PM\n",
    "- R4: if SD is NS and A is PS then TC is PS\n",
    "- R5: if SD is PS and A is NS then TC is NS\n",
    "- R6: if SD is PL and A is ZE then TC is NL\n",
    "- R7: if SD is ZE and A is NS then TC is PS\n",
    "- R8: if SD is ZE and A is NM then TC is PM\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rule_comparison(TC1, TC2):\n",
    "    TC = 0\n",
    "    if TC1>TC2 and TC1 !=0 and TC2 !=0:\n",
    "        TC = TC2\n",
    "    else:\n",
    "        TC = TC1\n",
    "    \n",
    "    if TC1 == 0 and TC2 !=0:\n",
    "        TC = TC2\n",
    "        \n",
    "    if TC2 == 0 and TC1 !=0:\n",
    "        TC = TC1\n",
    "        \n",
    "    return TC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rule(NLSD, NMSD, NSSD, ZESD, PSSD, PMSD, PLSD, NLAC, NMAC, NSAC, ZEAC, PSAC, PMAC, PLAC):\n",
    "    # Rule 1\n",
    "    PLTC1 = min(NLSD, ZEAC)\n",
    "    # Rule 2\n",
    "    PLTC2 = min(ZESD, NLAC)\n",
    "    PLTC = rule_comparison(PLTC1, PLTC2)\n",
    "    \n",
    "    \n",
    "    PMTC1 = min(NMSD,ZEAC)\n",
    "    PMTC2 = min(ZESD,NMAC)\n",
    "    PMTC = rule_comparison(PMTC1, PMTC2)\n",
    "    \n",
    "    PSTC1 = min(NSSD,PSAC)\n",
    "    PSTC2 = min(ZESD,NSAC)\n",
    "    PSTC = rule_comparison(PSTC1, PSTC2)\n",
    "    \n",
    "    NSTC = min(PSSD,NSAC)\n",
    "    NLTC = min(PLSD,ZEAC)\n",
    "    \n",
    "    return PLTC, PMTC, PSTC, NSTC, NLTC\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 0.16666666666666666 0 0\n"
     ]
    }
   ],
   "source": [
    "PLTC, PMTC, PSTC, NSTC, NLTC = rule(NLSD,NMSD,NSSD,ZESD,PSSD,PMSD,PLSD,NLAC,NMAC,NSAC,ZEAC,PSAC,PMAC,PLAC)\n",
    "print(PLTC, PMTC, PSTC, NSTC, NLTC)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def areaTR(mu, a,b,c):\n",
    "    x1 = mu*(b-a) + a\n",
    "    x2 = c - mu*(c-b)\n",
    "    d1 = (c-a); d2 = x2-x1\n",
    "    a = (1/2)*mu*(d1 + d2)\n",
    "    return a # Returning area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def areaOL(mu, alpha, beta):\n",
    "    xOL = beta -mu*(beta - alpha)\n",
    "    return 1/2*mu*(beta+ xOL), beta/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def areaOR(mu, alpha, beta):\n",
    "    xOR = (beta - alpha)*mu + alpha\n",
    "    aOR = (1/2)*mu*((240 - alpha) + (240 -xOR))\n",
    "    return aOR, (240 - alpha)/2 + alpha"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def defuzzyfication(PLTC, PMTC, PSTC, NSTC, NLTC):\n",
    "    areaPL = 0; areaPM = 0; areaPS = 0; areaNS = 0; areaNL = 0;\n",
    "    cPL = 0; cPM = 0; cPS = 0; cNS = 0; cNL = 0;\n",
    "\n",
    "    if PLTC != 0:\n",
    "        #areaPL, cPL = areaOR(PLTC, 180, 210)\n",
    "        areaPL, cPL = areaOR(PLTC, 180, 210)\n",
    "                \n",
    "    if PMTC != 0:\n",
    "        areaPM = areaTR(PMTC, 150, 180, 210)\n",
    "        cPM = 180\n",
    "    \n",
    "    if PSTC != 0:\n",
    "        areaPS = areaTR(PSTC, 120, 150, 180)\n",
    "        cPS = 150\n",
    "          \n",
    "    if NSTC != 0:\n",
    "        areaNS = areaTR(NSTC, 60, 90, 120)\n",
    "        cNS = 90\n",
    "        \n",
    "    if NLTC !=0:\n",
    "        areaNL, cNL = areaOL(NLTC, 30, 60)\n",
    "        \n",
    "    numerator = areaPL*cPL + areaPM*cPM + areaPS*cPS + areaNS*cNS + areaNL*cNL\n",
    "    denominator = areaPL + areaPM + areaPS + areaNS + areaNL\n",
    "    if denominator ==0:\n",
    "        print(\"No rules exist to give the result\")\n",
    "        return 0\n",
    "    else:\n",
    "        crispOutput = numerator/denominator\n",
    "        return crispOutput"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "150.0"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "crispOutputFinal = defuzzyfication(PLTC, PMTC, PSTC, NSTC, NLTC)\n",
    "crispOutputFinal"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}