Notes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4d52fc1f",
   "metadata": {},
   "source": [
    "# Notes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "41842d78",
   "metadata": {},
   "outputs": [
    {
     "ename": "ModuleNotFoundError",
     "evalue": "No module named 'scipy'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_32023/963655667.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mscipy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mspatial\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mdistance\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mpandas\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0mvietoris_risp_complex\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \"\"\"\n",
      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'scipy'"
     ]
    }
   ],
   "source": [
    "from scipy.spatial import distance\n",
    "import pandas as pd\n",
    "\n",
    "class vietoris_risp_complex:\n",
    "    \"\"\"\n",
    "    Class object producing the Vietoris-Rips Complex of a dataset.\n",
    "    Inspired from the process provided by Adam Punnoose: \n",
    "    > https://github.com/adampunnoose/Vietoris-Rips-complex-Python\n",
    "    \"\"\"\n",
    "    def __init__(self, \n",
    "                 data:          pd.DataFrame, \n",
    "                 min_radius:    float,\n",
    "                 max_radius:    float,\n",
    "                 n_radius_step: float) -> None:\n",
    "        \"\"\"\n",
    "        Initializes the object's parameters and internal data\n",
    "        \"\"\"\n",
    "        self.data         = data\n",
    "        self.max_distance = 0\n",
    "        self.min_distance = float(\"inf\")\n",
    "        self.n_datapoints = data.shape[0]\n",
    "        self.n_dimensions = data.shape[1]\n",
    "        self.radii_range  = np.round(np.linspace(min_radius,\n",
    "                                                 max_radius,\n",
    "                                                 n_radius_step),\n",
    "                                     4)\n",
    "        self.complexes    = {radius:None for radius in self.radii_range}\n",
    "        self.dst          = lambda a, b: distance.euclidian(a, b)\n",
    "    def compute_max_distance() -> None:\n",
    "        \"\"\"\n",
    "        Computes the maximum distance between points in the input dataset.\n",
    "        \"\"\"\n",
    "        for point in range(0, self.n_datapoints):\n",
    "            for point_2 in range(point+1, self.n_datapoints):\n",
    "                d = self.dst(self.data[point], self.data[point_2])\n",
    "                if d > self.max_distance:\n",
    "                    self.max_distance = d\n",
    "    def compute_min_distance() -> None:\n",
    "        \"\"\"\n",
    "        Computes the maximum distance between points in the input dataset.\n",
    "        \"\"\"\n",
    "        for point in range(0, self.n_datapoints):\n",
    "            for point_2 in range(point+1, self.n_datapoints):\n",
    "                d = self.dst(self.data[point], self.data[point_2])\n",
    "                if d < self.min_distance:\n",
    "                    self.min_distance = d\n",
    "    def compute_vietoris_rips_complex():\n",
    "        \"\"\"\n",
    "        \n",
    "        \"\"\"\n",
    "        \n",
    "\n",
    "#This program calculates the Vietoris-Rips Complex for 2 and 3 \n",
    "#dimensional points\n",
    "import pandas as pd\n",
    "\n",
    "class VRC: \n",
    "    \n",
    "    def __init__(self, path):\n",
    "        #read template and import data into project space\n",
    "        data = pd.read_csv(path)\n",
    "        self.numDimensions = int(data.values[0,0]);\n",
    "        self.points = []\n",
    "        self.numPoints = int(data.values[0,1]);\n",
    "        if(self.numDimensions == 3 or self.numDimensions == 2):\n",
    "            self.points = self.ExtractPoints(self.numPoints, self.numDimensions, data)\n",
    "        else: \n",
    "            print(\"Please pick either 2 or 3 dimensions\")\n",
    "\n",
    "    def ExtractPoints(self, numPoints,dimensions, data):\n",
    "        output = []\n",
    "        if dimensions == 3:\n",
    "            for i in range(numPoints):\n",
    "                insert = [data.values[i,2], data.values[i,3], data.values[i,4]]\n",
    "                output.append(insert)\n",
    "        elif dimensions == 2:\n",
    "            for i in range(numPoints):\n",
    "                insert = [data.values[i,2], data.values[i,3], 0]\n",
    "                output.append(insert)\n",
    "        return output\n",
    "        \n",
    "    def distP(self, p1, p2):\n",
    "        #input: 2 arrays of size = 3\n",
    "        #output: distance between points\n",
    "        distance = ( ((p1[0] - p2[0])**2) + \n",
    "                     ((p1[1] - p2[1])**2) +\n",
    "                     ((p1[2] - p2[2])**2)  )**(.5)\n",
    "        return distance;\n",
    "    def maxDist(self):\n",
    "        #intput: list of points\n",
    "        #output: array: [max distance, point1, point2]\n",
    "        maxD = 0\n",
    "        point1 = -1\n",
    "        point2 = -1\n",
    "        distance = -1\n",
    "        \n",
    "        for x in range(len(self.points)):\n",
    "            for y in range(x + 1, len(self.points)):\n",
    "                distance = self.distP(self.points[x], self.points[y])\n",
    "                if distance > maxD:\n",
    "                    maxD = distance\n",
    "                    point1 = x\n",
    "                    point2 = y\n",
    "        ans = [maxD, point1, point2]\n",
    "        return ans\n",
    "    \n",
    "    def minDist(self):\n",
    "        #intput: list of points\n",
    "        #output: array: [minimum distance, point1, point2]\n",
    "            \n",
    "        minD = 11.7e308\n",
    "        point1 = -1\n",
    "        point2 = -1\n",
    "        distance = -1\n",
    "        \n",
    "        for x in range(len(self.points)):\n",
    "            for y in range(x + 1, len(self.points)):\n",
    "                distance = self.distP(self.points[x], self.points[y])\n",
    "                if distance < minD:\n",
    "                    minD = distance\n",
    "                    point1 = x\n",
    "                    point2 = y\n",
    "        ans = [minD, point1, point2]\n",
    "        return ans\n",
    "    \n",
    "    def edges(self, points, R):\n",
    "        #input: points list and R\n",
    "        #output: List of all edges \n",
    "        \n",
    "        group1 = []\n",
    "        \n",
    "        for x in range(len(points)):\n",
    "            group2 = []\n",
    "            for y in range(x + 1, len(points)):\n",
    "                if self.distP(points[x], points[y]) <= R:\n",
    "                    group2.append(y)\n",
    "            \n",
    "            group1.append(group2)\n",
    "            \n",
    "        return group1\n",
    "    \n",
    "    def edgeTable(self, edgeList):\n",
    "        #input: edge list from \"edges\" function\n",
    "        #output: n by n table displaying all connected edges\n",
    "            #n = number of points in the list of points \n",
    "        \n",
    "        \n",
    "        table = [[False]*len(edgeList) for _ in range(len(edgeList))]\n",
    "        \n",
    "        for x in range(len(edgeList)):\n",
    "            for y in range(len(edgeList[x])):\n",
    "                \n",
    "                table[x][edgeList[x][y]] = True\n",
    "        return table\n",
    "    \n",
    "    def tableSimplexComparison(self, array, table,  tableColumn):\n",
    "        #intput: \n",
    "            #array = simplex to be tested \n",
    "            #table = n by n table of edges\n",
    "            #tableColumn = point to be checked if it is connected to simplicie in array\n",
    "        #output: boolean, true if point is connected to inputted simplicie\n",
    "        \n",
    "        output = True\n",
    "        for i in range(len(array)):\n",
    "            if(table[tableColumn][array[i]] != True):\n",
    "                output = False\n",
    "        return output\n",
    "    \n",
    "    def insertionArray(self, array, j):\n",
    "        insertion = []\n",
    "        insertion.append(j)\n",
    "        \n",
    "        for i in range(len(array)):\n",
    "            insertion.append(array[i])\n",
    "        return insertion\n",
    "    \n",
    "    \n",
    "    def zeroSimplex(self, edgeList):\n",
    "        output = []\n",
    "        for x in range(len(edgeList)):\n",
    "            output.append(x)\n",
    "        return output\n",
    "    \n",
    "    def oneSimplex(self, edgeList):\n",
    "        output = [];\n",
    "        \n",
    "        for x in range(len(edgeList)):\n",
    "            if len(edgeList[x]) != 0:\n",
    "                for y in range(len(edgeList[x])):\n",
    "                    insertion = [];\n",
    "                    insertion.append(x)\n",
    "                    insertion.append(edgeList[x][y])\n",
    "                    output.append(insertion)\n",
    "        return output\n",
    "    \n",
    "    def twoPlusSimplex(self, simplexList, EdgeTable, simplex):\n",
    "        output = []\n",
    "        if simplex < 2:\n",
    "            print(\"Must input a simplex value of 2 or more\")\n",
    "        else:\n",
    "            for i in range(len(simplexList)): #iterated for every simplex in inputted list\n",
    "                for j in range(simplexList[i][0], -1, -1):\n",
    "                    if self.tableSimplexComparison(simplexList[i], EdgeTable, j) == True:\n",
    "                        output.append(self.insertionArray(simplexList[i], j))\n",
    "        \n",
    "        return output\n",
    "    \n",
    "    def printResults(self):\n",
    "        #print initial points\n",
    "        print(\"list of Points: \")\n",
    "        \n",
    "        for i in range(len(self.points)):\n",
    "            print(\"Point \" , i ,\": \" , self.points[i])\n",
    "        print(\"\\n Simplicies: \")\n",
    "        for i in self.allSimplex:\n",
    "            print(i)\n",
    "                \n",
    "        \n",
    "    def calculateVRC(self, radius):\n",
    "        #calulate Veitoris-Rips complex with the inputted value of radius\n",
    "        maxList = self.maxDist()\n",
    "        minList = self.minDist()\n",
    "        maxD = maxList[0]\n",
    "        minD = minList[0]\n",
    "        self.allSimplex = []\n",
    "        \n",
    "        if radius >  minD:\n",
    "            \n",
    "        \n",
    "            self.edgeList = self.edges(self.points, radius)\n",
    "            self.edgeTable = self.edgeTable(self.edgeList)\n",
    "            \n",
    "            self.zeroSimplexV = self.zeroSimplex(self.edgeList)\n",
    "            self.oneSimplexV = self.oneSimplex(self.edgeList)\n",
    "            self.twoSimplex = self.twoPlusSimplex(self.oneSimplexV, self.edgeTable, 2)\n",
    "            self.threeSimplex = self.twoPlusSimplex(self.twoSimplex, self.edgeTable, 3)\n",
    "            \n",
    "            #combine all simplicies into one \n",
    "            self.allSimplex = self.zeroSimplexV + self.oneSimplexV + self.twoSimplex + self.threeSimplex\n",
    "            self.printResults()\n",
    "            \n",
    "            \n",
    "        else: \n",
    "            print(\"Please use a radius that is bigger that \", minD)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "44108bac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list of Points: \n",
      "Point  0 :  [19.0, 13.0, 17.0]\n",
      "Point  1 :  [1.0, 6.0, 11.0]\n",
      "Point  2 :  [15.0, 20.0, 7.0]\n",
      "Point  3 :  [1.0, 8.0, 4.0]\n",
      "Point  4 :  [10.0, 6.0, 4.0]\n",
      "Point  5 :  [1.0, 10.0, 14.0]\n",
      "Point  6 :  [18.0, 4.0, 5.0]\n",
      "Point  7 :  [6.0, 15.0, 6.0]\n",
      "Point  8 :  [19.0, 20.0, 20.0]\n",
      "\n",
      " Simplicies: \n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "[0, 8]\n",
      "[1, 3]\n",
      "[1, 4]\n",
      "[1, 5]\n",
      "[1, 7]\n",
      "[2, 7]\n",
      "[3, 4]\n",
      "[3, 5]\n",
      "[3, 7]\n",
      "[4, 6]\n",
      "[4, 7]\n",
      "[5, 7]\n",
      "[1, 3, 4]\n",
      "[1, 3, 5]\n",
      "[1, 3, 7]\n",
      "[3, 4, 7]\n",
      "[1, 4, 7]\n",
      "[3, 5, 7]\n",
      "[1, 5, 7]\n",
      "[1, 3, 4, 7]\n",
      "[1, 3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "x = VRC(\"data/test.csv\")\n",
    "x.calculateVRC(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14e7ca69",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}