vk_v4_0.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.special import gamma as gamma_function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cuckoo():\n",
    "    \n",
    "    X_min = 0\n",
    "    X_max = 100\n",
    "    alpha_min = 0.9\n",
    "    alpha_max = 1.0\n",
    "    pa_min = 0.05\n",
    "    pa_max = 0.25\n",
    "    N_nest = 25\n",
    "    N_itertotal = 100\n",
    "    gamma = 0.1          # noise factor\n",
    "    lamda = 1.5          # constant used in le'vy flight\n",
    "    \n",
    "    total_nodes = 0\n",
    "    anchor_percent = 0\n",
    "    t_range = 0 # transmission range\n",
    "    \n",
    "    X_anchor = []\n",
    "    X_unknown = []\n",
    "    \n",
    "    X_loc = []\n",
    "\n",
    "    \n",
    "    def __init__(self, total_nodes=100, anchor_percent = 0.20, t_range = 25):\n",
    "        self.total_nodes = total_nodes\n",
    "        self.anchor_percent = anchor_percent\n",
    "        self.t_range = t_range\n",
    "        self.M = int(self.anchor_percent * self.total_nodes) # no. of anchor nodes\n",
    "        self.N = self.total_nodes - self.M # no. of unknown nodes\n",
    "        var1 = 10\n",
    "        \n",
    "        \n",
    "        for i in range(self.M):\n",
    "            x_anchor = np.random.randint(100)\n",
    "            y_anchor = np.random.randint(100)\n",
    "            self.X_anchor.append([x_anchor, y_anchor])\n",
    "        \n",
    "        for i in range(self.N):\n",
    "            x_unknown = np.random.randint(100)\n",
    "            y_unknown = np.random.randint(100)\n",
    "            self.X_unknown.append([x_unknown, y_unknown])\n",
    "        \n",
    "        self.X_unknown = np.array(self.X_unknown)\n",
    "        self.X_anchor = np.array(self.X_anchor)\n",
    "    \n",
    "        self.X_anchor_og = self.X_anchor.copy()\n",
    "        self.X_unknown_og = self.X_unknown.copy()\n",
    "    \n",
    "    def show_field(self):\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        plt.plot(self.X_unknown[:, 0], self.X_unknown[:, 1], 'ro', label=\"Unknown Node\")\n",
    "        plt.plot(self.X_anchor[:, 0], self.X_anchor[:, 1], 'go', label=\"Anchor Node\")\n",
    "        plt.legend()\n",
    "        plt.grid()\n",
    "        plt.show()\n",
    "        \n",
    "        \n",
    "    # step size (alpha)\n",
    "    def alpha(self, n_iter):\n",
    "        return self.alpha_max - ((n_iter/ self.N_itertotal) * (self.alpha_max - self.alpha_min)) # returns step size value\n",
    "\n",
    "    # Le'vy flight function\n",
    "    def levy(self):\n",
    "        temp = np.power(((gamma_function(1 + self.lamda) * np.sin(np.pi * (self.lamda /2))) / (gamma_function((1 + self.lamda)/2) * self.lamda * np.power(2, ((self.lamda - 1)/2)) )), 1/self.lamda)\n",
    "        u = np.random.normal(0, temp)\n",
    "        v = np.random.normal(0,1)\n",
    "        r = u / (np.power(abs(v), (1/self.lamda)))\n",
    "\n",
    "        return r  # random walk value\n",
    "\n",
    "    \n",
    "    # location limit tester\n",
    "    def limiter(self, point):\n",
    "        x = point[0]\n",
    "        y = point[1]\n",
    "        if x > self.X_max and y > self.X_max:\n",
    "            x,y = self.X_max, self.X_max\n",
    "            # X_j = X_rand\n",
    "        elif x > self.X_max and self.X_min < y < self.X_max:\n",
    "            x,y = self.X_max, y\n",
    "            # X_j = X_rand\n",
    "        elif x > self.X_max and y < self.X_min:\n",
    "            x,y = self.X_max, self.X_min\n",
    "            # X_j = X_rand\n",
    "        elif self.X_min < x < self.X_max and y < self.X_min:\n",
    "            x,y = x, self.X_min\n",
    "            # X_j = X_rand\n",
    "        elif x < self.X_min and y < self.X_min:\n",
    "            x,y = self.X_min, self.X_min\n",
    "            # X_j = X_rand\n",
    "        elif x < self.X_min and self.X_min < y < self.X_max:\n",
    "            x,y = self.X_min, y\n",
    "            # X_j = X_rand\n",
    "        elif x < self.X_min and y > self.X_max:\n",
    "            x,y = self.X_min, self.X_max\n",
    "            # X_j = X_rand\n",
    "        elif self.X_min < x < self.X_max and y > self.X_max:\n",
    "            x,y = x, self.X_max\n",
    "            # X_j = X_rand\n",
    "\n",
    "        return [x,y]\n",
    "\n",
    "    \n",
    "    def neighbours(self, node, anchors):\n",
    "        x = node[0]\n",
    "        y = node[1]\n",
    "        X_anchor = anchors\n",
    "                \n",
    "        l = []\n",
    "        for j in range(len(X_anchor)): # for every anchor nodes\n",
    "            dist_real = np.power((np.power((x - X_anchor[j][0]), 2) + np.power((y - X_anchor[j][1]), 2)), 0.5)\n",
    "            dist_err = dist_real + np.random.normal(0, (self.gamma*dist_real))\n",
    "\n",
    "            if dist_err < self.t_range:\n",
    "                l.append(X_anchor[j])\n",
    "                \n",
    "        return l # neighbouring anchors coordinates\n",
    "\n",
    "    def objective(self, node, n_anchors):\n",
    "        \"\"\"objective function (to minimize)\"\"\"\n",
    "        x = node[0]\n",
    "        y = node[1]\n",
    "        \n",
    "        l = self.neighbours(node, n_anchors)\n",
    "        m = len(l)\n",
    "        rerror = []\n",
    "        if len(l) >= 3:\n",
    "            for ancn in l:\n",
    "                dist_real = np.power((np.power((x - ancn[0]), 2) + np.power((y - ancn[1]), 2)), 0.5)\n",
    "                dist_err = dist_real + np.random.normal(0, (self.gamma*dist_real))\n",
    "                rerror.append(np.power(dist_real - dist_err,2))\n",
    "\n",
    "        return np.sum(rerror)/m or None # mean of square of ranging error\n",
    "\n",
    "    \n",
    "    def mod_cs(self, N_anchor):\n",
    "        X_nest = []\n",
    "        for i in range(self.N_nest):\n",
    "            x_nest = np.random.randint(100)\n",
    "            y_nest = np.random.randint(100)\n",
    "            X_nest.append([x_nest, y_nest])\n",
    "        \n",
    "        Obj_X_nest = []\n",
    "        for i in range(len(X_nest)):\n",
    "            Obj_X_nest.append(self.objective(X_nest[i], N_anchor))\n",
    "        \n",
    "#         print(Obj_X_nest)\n",
    "        \n",
    "        N_iter = 0\n",
    "        fmins = []\n",
    "        while(N_iter < self.N_itertotal):\n",
    "            N_iter += 1\n",
    "            X_js = []\n",
    "            for i in range(len(X_nest)):\n",
    "                X_j = X_nest[i].copy()\n",
    "                X_j[0] = X_j[0] + self.alpha(N_iter) * self.levy()\n",
    "                X_j[1] = X_j[1] + self.alpha(N_iter) * self.levy()\n",
    "                \n",
    "                X_j = self.limiter(X_j)\n",
    "                \n",
    "                F_j = self.objective(X_j, N_anchor) or np.inf\n",
    "                \n",
    "                rand_k = np.random.randint(0, len(X_nest))\n",
    "                \n",
    "                F_k = self.objective(X_nest[rand_k], N_anchor) or np.inf\n",
    "                \n",
    "                if F_j > F_k:\n",
    "                    X_j[0] = X_nest[rand_k][0]\n",
    "                    X_j[1] = X_nest[rand_k][1]\n",
    "                    F_j = F_k\n",
    "\n",
    "                X_js.append(X_j)\n",
    "                \n",
    "            Obj_X_js = []\n",
    "            for i in range(len(X_js)):\n",
    "                Obj_X_js.append(self.objective(X_js[i], N_anchor))\n",
    "            \n",
    "            Obj_X_js = np.array([np.inf if i is None else i for i in Obj_X_js])\n",
    "            F_min = Obj_X_js[np.argmin(Obj_X_js)]\n",
    "#             print(F_min)\n",
    "            best_sol = X_js[np.argmin(Obj_X_js)]\n",
    "            \n",
    "            Pa_j = []\n",
    "            \n",
    "            for i in Obj_X_js:\n",
    "                K = i - F_min\n",
    "                if K < 1:\n",
    "                    Pa_j.append(self.pa_min + (self.pa_max - self.pa_min) * K)\n",
    "                else:\n",
    "                    Pa_j.append(self.pa_max / N_iter)\n",
    "\n",
    "            \n",
    "            for i in range(len(Pa_j)):\n",
    "                rand_temp = np.random.uniform(0, 1)\n",
    "                if rand_temp < Pa_j[i]:\n",
    "                    my_x = np.random.randint(100)\n",
    "                    my_y = np.random.randint(100)\n",
    "                    if (self.objective(X_js[i], N_anchor) or np.inf) > (self.objective([my_x, my_y], N_anchor) or np.inf):\n",
    "                        X_js[i] = [my_x, my_y]\n",
    "            \n",
    "            \n",
    "            Obj_X_js = []\n",
    "            for i in range(len(X_js)):\n",
    "                Obj_X_js.append(self.objective(X_js[i], N_anchor))\n",
    "            \n",
    "            Obj_X_js = np.array([np.inf if i is None else i for i in Obj_X_js])\n",
    "            F_min = Obj_X_js[np.argmin(Obj_X_js)]\n",
    "#             print(F_min)\n",
    "            fmins.append(F_min)\n",
    "            best_sol = X_js[np.argmin(Obj_X_js)]\n",
    "            X_nest = X_js.copy()\n",
    "        \n",
    "        return best_sol\n",
    "        \n",
    "        plt.plot(fmins)\n",
    "        plt.show()\n",
    "\n",
    "                \n",
    "                \n",
    "    \n",
    "    def update_Unknown(self, indexes):        \n",
    "        \"\"\"Updating Unknown List\"\"\"\n",
    "        \n",
    "        X_unknown_temp = []\n",
    "        for j in range(len(self.X_unknown)):\n",
    "            if j in indexes:\n",
    "                pass\n",
    "            else:\n",
    "                X_unknown_temp.append(X_unknown[j])\n",
    "\n",
    "        self.X_unknown = np.array(X_unknown_temp)\n",
    "        \n",
    "    \n",
    "    \n",
    "    \n",
    "    def main(self):\n",
    "        \n",
    "        localised_indexes = []\n",
    "        for i in range(len(self.X_unknown)):\n",
    "            nn = self.neighbours(self.X_unknown[i], self.X_anchor)\n",
    "            if len(nn) >= 3:\n",
    "                updated_node_location = self.mod_cs(nn)\n",
    "                \n",
    "                self.X_loc.append([updated_node_location, self.X_unknown[i]])\n",
    "                \n",
    "                # Updated \n",
    "                X_anchor_temp = list(self.X_anchor)\n",
    "                X_anchor_temp.append(updated_node_location)\n",
    "                self.X_anchor = np.array(X_anchor_temp)\n",
    "                \n",
    "                localised_indexes.append(i)\n",
    "        \n",
    "        self.update_Unknown(localised_indexes)\n",
    "                \n",
    "\n",
    "                \n",
    "            \n",
    "            \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "coco = Cuckoo(anchor_percent=0.1, t_range=25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:135: RuntimeWarning: invalid value encountered in double_scalars\n"
     ]
    }
   ],
   "source": [
    "coco.main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[[73.38875569448518, 86.31653683776035], array([18,  5])],\n",
       " [[23.47531910549326, 58.51205066254022], array([68,  9])],\n",
       " [[94.25912367978563, 79.34045808122536], array([35, 62])],\n",
       " [[8.45167160607242, 48.40373080264544], array([53, 93])],\n",
       " [[0.8571490702001885, 25.169236951497183], array([52, 29])],\n",
       " [[0, 38.50844469658718], array([87, 69])],\n",
       " [[58.40946333680078, 85.93877824726208], array([ 4, 16])],\n",
       " [[78.67075904546819, 97.46711491523055], array([29, 84])],\n",
       " [[88.62789979495014, 29.5629379475935], array([ 8, 16])],\n",
       " [[97.27017705504485, 74.8337890132122], array([19, 27])],\n",
       " [[18.7962941560699, 0.8614390334815106], array([72, 97])],\n",
       " [[2.9111905906447246, 32.94906577351051], array([82, 83])],\n",
       " [[62.59067148201403, 48.77309766261991], array([40,  0])],\n",
       " [[11.282260614314223, 87.74328018830217], array([80, 48])],\n",
       " [[1.6169054213109957, 85.65705089604266], array([85, 39])],\n",
       " [[5.1989721979533705, 73.86517937561513], array([67, 15])],\n",
       " [[65.9850647756191, 29.320871408239864], array([63, 95])],\n",
       " [[39.516661789848044, 68.15912596455291], array([26,  8])],\n",
       " [[0, 46.843569343790605], array([77, 35])],\n",
       " [[32.48291509945834, 0.4992405974530916], array([86, 35])],\n",
       " [[76.8211590296432, 100], array([65, 46])],\n",
       " [[38.99829106647611, 31.418833593846397], array([81,  5])],\n",
       " [[91.12104934821858, 22.231231848713055], array([98, 89])],\n",
       " [[10.798366884490797, 80.22683775776271], array([48, 14])],\n",
       " [[46.438275455780946, 4.532845720496059], array([30, 82])],\n",
       " [[100, 8.053965664552614], array([ 9, 94])],\n",
       " [[17.61666970585177, 22.490303664498786], array([82, 87])],\n",
       " [[99.44062418244656, 67.51336991712762], array([24, 80])],\n",
       " [[58.66556644143798, 34.28589725454898], array([78, 70])],\n",
       " [[3.947595859118058, 0.09855671731608442], array([29, 45])],\n",
       " [[96.68312201173542, 16.82472438058332], array([56, 72])],\n",
       " [[46.14056129154276, 98.73065058503343], array([52, 51])],\n",
       " [[46.380224292294145, 0], array([16, 65])],\n",
       " [[68.14780791168147, 4.088831670410552], array([14, 68])],\n",
       " [[72.91230187529862, 85.6238791884173], array([ 7, 27])],\n",
       " [[15.554284107530696, 56.95546613935177], array([66, 37])],\n",
       " [[27.04098944309921, 54.01923014211455], array([90, 54])],\n",
       " [[90.01746575510411, 88.07824200669407], array([94, 39])],\n",
       " [[61.600313540358734, 93.43758420679937], array([49,  2])],\n",
       " [[82.9078725004324, 34.72123565274855], array([32, 70])],\n",
       " [[99.4086580225468, 99.69706924256906], array([61, 26])],\n",
       " [[19.002080940612682, 71.28867858689193], array([77, 52])],\n",
       " [[15.528858854429622, 94.12026674940131], array([67, 73])],\n",
       " [[68.40281171718654, 1.0148262743443717], array([71, 69])],\n",
       " [[43.95914591632082, 43.21494554407578], array([96,  8])],\n",
       " [[57.657799658064775, 55.44340654433015], array([4, 8])],\n",
       " [[6.913302261190253, 57.9679579114226], array([72, 57])],\n",
       " [[2.215631661530364, 41.795136617619704], array([98, 28])],\n",
       " [[25.805825421944547, 53.389116043595905], array([90, 78])],\n",
       " [[0, 48.852144789932375], array([62, 52])],\n",
       " [[20.397337597166565, 45.23802748708917], array([66,  6])],\n",
       " [[82.36853566840307, 33.131777458233664], array([43, 92])],\n",
       " [[25.065952037964944, 12.202964584209209], array([ 4, 84])],\n",
       " [[96.63632391573364, 95.5104868442721], array([12, 41])],\n",
       " [[10.665739169397469, 0.0888393886767116], array([87,  8])],\n",
       " [[74.76700222537823, 40.521803750258165], array([50, 94])],\n",
       " [[9.170393944762235, 90.81794945018876], array([42, 25])],\n",
       " [[66.92790541354105, 100], array([45,  9])],\n",
       " [[99.81109424083718, 66.76622230269182], array([91, 12])],\n",
       " [[4.124101915510703, 13.095306939060823], array([67, 32])],\n",
       " [[59.2453843563647, 19.637960765515906], array([24, 83])],\n",
       " [[2.0553488577875645, 66.63292139751623], array([71, 41])],\n",
       " [[4.716644766838491, 36.38837233961417], array([82, 66])],\n",
       " [[2.9551297459964156, 9.814933966085132], array([52, 45])],\n",
       " [[6.090194818044149, 21.21383261789692], array([26, 89])],\n",
       " [[4.594649731739047, 95.10743064348135], array([47, 39])],\n",
       " [[96.35287284149321, 56.23722391893869], array([ 9, 60])],\n",
       " [[80.72527819800763, 88.87397158500421], array([87,  6])],\n",
       " [[46.084649949711505, 92.49313209473019], array([68,  2])],\n",
       " [[21.77527075769527, 0], array([83, 88])],\n",
       " [[82.2028493906505, 4.440840698248026], array([ 9, 85])],\n",
       " [[96.3191083716529, 2.5691409569489485], array([35, 95])],\n",
       " [[94.81537400089607, 2.298389615790728], array([33, 29])],\n",
       " [[35.48920278808354, 4.561907009833422], array([48, 81])],\n",
       " [[96.86114188877896, 15.323893516663455], array([26, 42])],\n",
       " [[1.5565969968277702, 90.93676577869475], array([73, 41])],\n",
       " [[33.584548071279904, 60.91290724982588], array([93, 36])],\n",
       " [[66.8473609840319, 94.8389154445145], array([88, 34])],\n",
       " [[52.797967982541664, 61.53761590154631], array([63,  1])],\n",
       " [[94.69975729921693, 47.602098913053524], array([13, 57])]]"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coco.X_loc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [0.5586032962287517,0.6017524859504793,0.7813999837819767,0.46606363790524846,1.0247709434914343,1.252005912323164,0.7495009374755108,0.561087541248166,0.6173482423311187,0.7023584934592145,0.5555991502481207,0.2347329658872088,0.7689648691600328,0.42170816132227973,0.25106692688462434,1.015593603834578,0.409359463643792,0.23540883134280907,0.5913839305269655,0.600203577388256,0.5000388726258884,0.47597790189065975,0.3658604050896738,0.49870120762058423,1.0246665774750374,0.22224505802313932,0.48748272031646006,0.2721460419888341,0.38653619800686356,0.2615371220932912,0.6958970282936564,0.36899753381356065,0.2039305516189484,0.17151067125529823,0.48919234541387874,0.39500189054510565,0.3530413033536565,0.5591781993082433,0.7749257166059389,0.3368538823421103,0.11406348593214892,0.1550569530750901,0.1974787800028229,0.3971344522252228,0.5281760365228262,0.27339861412968086,0.21166372780804943,0.5555694651180548,0.24039256191025846,0.2507917463528349,0.26165577892959974,0.2902138425532703,0.09274393957755404,0.14342988579925614,0.09482794773206088,0.10777099278167086,0.2167607678878698,0.08407868156026704,0.4162032579761468,0.19392965695433126,0.1531513524666788,0.10250629296185206,0.10944110289909664,0.3372574640392889,0.09181169924020706,0.16634369946602098,0.461380034902016,0.10096995500968431,0.5163841659356835,0.4100570120780608,0.3305394441703243,0.12650693376928016,0.4605351112395287,0.4704711004480148,0.39490322471822437,0.18080358326668763,0.40822830771771684,0.23356350554663777,0.22729262817308193,0.24627316532161503,0.16842430253528257,0.4886667259598101,0.17134357949552495,0.3237412112321077,0.21311484660525568,0.40680583941819976,0.2780304862894268,0.31027772973891987,0.07095677497515178,0.2835606346307872,0.19350661176946501,0.2259702437046537,0.23069606587795344,0.10291948260618343,0.3505927932052159,0.520609285578258,0.552334894422106,0.34428465409389686,0.20672654684411254,0.1638661522394548,]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6, 68],\n",
       "       [25, 10],\n",
       "       [33, 61],\n",
       "       [60, 22],\n",
       "       [38,  4],\n",
       "       [ 4, 30],\n",
       "       [14, 53],\n",
       "       [20,  5],\n",
       "       [70, 65],\n",
       "       [31, 27],\n",
       "       [13, 98],\n",
       "       [31, 91],\n",
       "       [39, 68],\n",
       "       [60, 75],\n",
       "       [80, 76],\n",
       "       [26, 88],\n",
       "       [65, 83],\n",
       "       [ 0, 53],\n",
       "       [92, 78],\n",
       "       [69,  4]])"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coco.X_anchor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'numpy.ndarray' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-161-76a7edd66aa4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcoco\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mX_anchor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'numpy.ndarray' object has no attribute 'append'"
     ]
    }
   ],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x3e9fb0>]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(98,70, 'b.')\n",
    "plt.plot(6,35, 'g.')\n",
    "plt.plot(77,20, 'b.')\n",
    "plt.plot(68,11, 'b.')\n",
    "plt.plot(64,4, 'r.')\n",
    "plt.plot(76,23, 'r.')\n",
    "plt.plot(53,29, 'r.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no\n"
     ]
    }
   ],
   "source": [
    "if np.inf > np.nan:\n",
    "    print('yes1')\n",
    "elif np.nan > np.inf:\n",
    "    print('yes2')\n",
    "elif np.nan > 10:\n",
    "    print('yes2')\n",
    "elif 10 > np.nan:\n",
    "    print('yes2')\n",
    "else:\n",
    "    print('no')"
   ]
  },
  {
   "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.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}