analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.3126925639607743\n"
     ]
    }
   ],
   "source": [
    "from dandelion_utils.generateStemLength import generateStemLength\n",
    "from dandelion_utils.reviseStemLength import reviseStemLength_uniform\n",
    "\n",
    "from dataclasses import dataclass\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.stats import norm\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "\n",
    "\n",
    "class Params:\n",
    "    def __init__(self, stemMin: int, stemMax: int, numberOfStemPeers: int, Peer1, Peer2) -> None:\n",
    "        self.stemMin = stemMin\n",
    "        self.stemMax = stemMax\n",
    "        self.numberOfStemPeers = numberOfStemPeers\n",
    "        self.Peer1 = Peer1\n",
    "        self.Peer2 = Peer2\n",
    "\n",
    "    def __repr__(self):\n",
    "        return self.long_description()\n",
    "\n",
    "    def long_description(self):\n",
    "        return f'StemMin: {self.stemMin}, StemMax: {self.stemMax}, StemPeers: {self.numberOfStemPeers}, ReductionMin: {self.Peer1}, ReductionMax: {self.Peer2}'\n",
    "\n",
    "    def short_description(self):\n",
    "        return f'{self.stemMin}-{self.stemMax}, {self.numberOfStemPeers}p, {self.Peer1}-{self.Peer2}r'\n",
    "\n",
    "    def data_description(self):\n",
    "        return {\"Min\": self.stemMin,\n",
    "                \"Max\": self.stemMax,\n",
    "                \"Peers\": self.numberOfStemPeers,\n",
    "                \"Peer1\": self.Peer1,\n",
    "                \"Peer2\": self.Peer2}\n",
    "\n",
    "\n",
    "class Sweep:\n",
    "    def __init__(self, params: Params, num_runs: int, hops: list[int], startingStemLengths: list[int]) -> None:\n",
    "        self.params = params.data_description(),\n",
    "        self.num_runs = num_runs\n",
    "        self.startingStemLengths = startingStemLengths\n",
    "        self.hops = hops\n",
    "        self.hops_mean = np.mean(self.hops)\n",
    "        self.hops_median = np.median(self.hops)\n",
    "        self.hops_stdd = np.std(self.hops)\n",
    "        self.hops_min = np.min(self.hops)\n",
    "        self.hops_max = np.max(self.hops)\n",
    "        self.starting_stem_mean = np.mean(self.startingStemLengths)\n",
    "        self.starting_stem_median = np.median(self.startingStemLengths)\n",
    "        self.starting_stem_stdd = np.std(self.startingStemLengths)\n",
    "        self.starting_stem_min = np.min(self.startingStemLengths)\n",
    "        self.starting_stem_max = np.max(self.startingStemLengths)\n",
    "\n",
    "    def describe_sweep(self):\n",
    "        print(f\"NUMBER RUNS: {self.num_runs}\")\n",
    "        print(f\"HOPS:\")\n",
    "        print(f\"  - Mean: {self.hops_mean}\")\n",
    "        print(f\"  - Median: {self.hops_median}\")\n",
    "        print(f\"  - StdD: {self.hops_stdd}\")\n",
    "        print(f\"  - Min: {self.hops_min}\")\n",
    "        print(f\"  - Max: {self.hops_max}\")\n",
    "\n",
    "    def plot_sweep(self):\n",
    "        _title = self.params\n",
    "        plt.hist(self.hops, bins=[3,4,5,6,7,8,9,10])\n",
    "        plt.gca().set(title=_title, ylabel='count')\n",
    "\n",
    "    def export(self):\n",
    "        e = {\"stemMin\": self.params[0][\"Min\"],\n",
    "             \"stemMax\": self.params[0][\"Max\"],\n",
    "             \"numberOfStemPeers\": self.params[0][\"Peers\"],\n",
    "             \"stemReductionMin\": self.params[0][\"ReductionMin\"],\n",
    "             \"stemReductionMax\": self.params[0][\"ReductionMax\"],\n",
    "             \"hops_mean\": self.hops_mean,\n",
    "             \"hops_median\": self.hops_median,\n",
    "             \"hops_stdd\": self.hops_stdd,\n",
    "             \"hops_min\": self.hops_min,\n",
    "             \"hops_max\": self.hops_max,\n",
    "             \"starting_stem_mean\": self.starting_stem_mean,\n",
    "             \"starting_stem_median\": self.starting_stem_median,\n",
    "             \"starting_stem_stdd\": self.starting_stem_stdd,\n",
    "             \"starting_stem_min\": self.starting_stem_min,\n",
    "             \"starting_stem_max\": self.starting_stem_max\n",
    "             }\n",
    "        return e\n",
    "\n",
    "\n",
    "def printConstants(params: Params):\n",
    "    print(\"USING CONSTANTS:\")\n",
    "    print(f\"  - StemMin: {params.stemMin}\")\n",
    "    print(f\"  - StemMax: {params.stemMax}\")\n",
    "    print(f\"  - numberOfStemPeers: {params.numberOfStemPeers}\")\n",
    "    print(f\"  - p1: {params.Peer1}\")\n",
    "    print(f\"  - p2: {params.Peer2}\")\n",
    "\n",
    "\n",
    "def random_stem_hops(params: Params):\n",
    "    # Generate a random initial stem length\n",
    "    # stemLength = generateStemLength(params.stemMin, params.stemMax)\n",
    "    stemLength = params.stemMin\n",
    "    startingStemLength = stemLength\n",
    "    hops = 0\n",
    "    while stemLength > 0:\n",
    "        hops += 1\n",
    "        temp_stems = []\n",
    "        # This simulates the message being passed to multiple \"stem peers\",\n",
    "        # of the multiple paths that the message takes, we are always going\n",
    "        # to chose the shortest path.\n",
    "        random_reduction = [params.Peer1, params.Peer2]\n",
    "        for x in range(params.numberOfStemPeers):\n",
    "            temp_stems.append(stemLength - random.choice(random_reduction))\n",
    "        stemLength = min(temp_stems)\n",
    "    return hops, startingStemLength\n",
    "\n",
    "\n",
    "def single_sweep(params: Params, num_runs=10000):\n",
    "    hops = []\n",
    "    startingStemLengths = []\n",
    "    while len(hops) < num_runs:\n",
    "        num_hops, startingStemLength = stem_hops(params)\n",
    "        hops.append(num_hops)\n",
    "        startingStemLengths.append(startingStemLength)\n",
    "    return Sweep(params, num_runs, hops, startingStemLengths)\n",
    "\n",
    "\n",
    "def stem_hops(params: Params):\n",
    "    # Generate a random initial stem length\n",
    "    # stemLength = generateStemLength(params.stemMin, params.stemMax)\n",
    "    stemLength = params.stemMin\n",
    "    startingStemLength = stemLength\n",
    "    hops = 0\n",
    "    while stemLength > 0:\n",
    "        hops += 1\n",
    "        temp_stems = []\n",
    "        # This simulates the message being passed to multiple \"stem peers\",\n",
    "        # of the multiple paths that the message takes, we are always going\n",
    "        # to chose the shortest path.\n",
    "        \n",
    "        for x in range(params.numberOfStemPeers):\n",
    "            temp_stems.append(stemLength - random.choice(params.Peer1))\n",
    "        stemLength = min(temp_stems)\n",
    "    return hops, startingStemLength\n",
    "\n",
    "def generate_data():\n",
    "    width = 2  # variance\n",
    "    min_hops = 3\n",
    "    additonal_hops = 1\n",
    "    stemlength_min = min_hops * (width)\n",
    "    stemlength_max = (min_hops + additonal_hops) * (width)\n",
    "    stemlength_choices = range(stemlength_min, stemlength_max)\n",
    "    delta = range(1, width+1)  # stemRevision = 0 to delta_width sampled uniformly\n",
    "    print(f'stemLength = {min_hops* (width)} - {(min_hops + additonal_hops) * (width)}')\n",
    "    results = []\n",
    "\n",
    "    stemlength = random.choice(stemlength_choices)\n",
    "\n",
    "    params = Params(stemMin=stemlength, stemMax=stemlength, numberOfStemPeers=2, Peer1=delta, Peer2=delta)\n",
    "    #print(params)\n",
    "    x = single_sweep(params)\n",
    "    #results.append(x)\n",
    "\n",
    "    # params = Params(stemMin = 3, stemMax = 7, numberOfStemPeers = 2, StemReductionMin = 1.25, StemReductionMax = 1.33)\n",
    "    # x = single_sweep(params)\n",
    "    # print(params)\n",
    "    x.describe_sweep()\n",
    "    x.plot_sweep()\n",
    "    #df = pd.DataFrame.from_records(results)\n",
    "    #df.to_csv(\"results.csv\")\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    print(random.normalvariate(0.2,4 ))\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.5 64-bit ('3.10.5')",
   "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.10.5"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "fac5810790acb4d9d2c04307a4be1a90e3ee9379ddbaed44a05c8df0cba075cf"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}