stateMachine_postDiscussion1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State_0\n",
      "\n",
      "baseCycles= 52374\n",
      "startCycles= 0\n",
      "samplingTime= 2000\n",
      "globalSamplingTime=2000\n",
      "optTime= 469            \n",
      "configTime= 250\n",
      "timeLeft= 49655\n",
      "opt_timeLeft=39724\n",
      "newStateCycles= 42443\n",
      "\n",
      "State_0\n",
      "\n",
      "baseCycles= 45002\n",
      "startCycles= 52374\n",
      "samplingTime= 3626\n",
      "globalSamplingTime=56000\n",
      "optTime= 451            \n",
      "configTime= 259\n",
      "timeLeft= 40666\n",
      "opt_timeLeft=32533\n",
      "newStateCycles= 36869\n",
      "\n",
      "State_1\n",
      "\n",
      "baseCycles= 5421\n",
      "startCycles= 97376\n",
      "samplingTime= 2624\n",
      "globalSamplingTime=100000\n",
      "optTime= 523            \n",
      "configTime= 260\n",
      "timeLeft= 2014\n",
      "opt_timeLeft=1611\n",
      "newStateCycles= 5018\n",
      "\n",
      "\n",
      "type of BASE = <type 'list'>\n",
      "\n",
      "BASE[0]= 52374, OPT[0]=42443\n",
      "BASE[1]= 45002, OPT[1]=36869\n",
      "BASE[2]= 5421, OPT[2]=5018\n",
      "\n",
      "Total Base = 102797, Total Opt = 84330\n",
      "Total Speed Up = 1.218985\n"
     ]
    }
   ],
   "source": [
    "from random import *\n",
    "import numpy as nm\n",
    "from scipy.stats import truncnorm\n",
    "\n",
    "seed (None)\n",
    "\n",
    "## Global variables\n",
    "global N\n",
    "global STATE0, STATE1\n",
    "global BASE, OPT\n",
    "global PDM, GREEDY\n",
    "global iCache, dCache\n",
    "\n",
    "\n",
    "## Instantiating global variables\n",
    "N = 100000\n",
    "## BASE list has all the base cycle values that were generated\n",
    "## OPT list has the optimized values for that cycle post optimization\n",
    "\n",
    "BASE = []\n",
    "OPT = []\n",
    "STATE0 = {'meanCycle': 50000, 'stdDev': 5000, 'min': 30000, 'max': 70000, 'base': BASE, 'opt': OPT}\n",
    "STATE1 = {'meanCycle': 5000, 'stdDev': 500, 'min': 1000, 'max': 7000, 'base': BASE, 'opt': OPT}\n",
    "\n",
    "#PDM = {'freqSampling': 2000, 'lat': 500, 'stdDev': 20, 'quality': 0.8}\n",
    "#GREEDY = {'freqSampling': 4000, 'lat': 1500, 'stdDev': 100, 'quality': 0.9}\n",
    "\n",
    "#iCache = {'lat': 250, 'stdDev': 10, 'quality': 0.2}\n",
    "#dCache = {'lat': 400, 'stdDev': 50, 'quality': 0.3}\n",
    "\n",
    "## name key added to print the name\n",
    "PDM = {'name': 'PDM', 'freqSampling': 2000, 'lat': 500, 'stdDev': 20, 'quality': 0.8}\n",
    "GREEDY = {'name': 'GREEDY', 'freqSampling': 4000, 'lat': 1500, 'stdDev': 100, 'quality': 0.9}\n",
    "\n",
    "iCache = {'name': 'iCahche', 'lat': 250, 'stdDev': 10, 'quality': 0.2}\n",
    "dCache = {'name': 'dCache', 'lat': 400, 'stdDev': 50, 'quality': 0.3}\n",
    "\n",
    "def state_0():\n",
    "    print \"State_0\"\n",
    "    ## Lets take that the mean values of cycles in state0 is 50000 and std Dev is 5000\n",
    "    global STATE0, BASE, OPT\n",
    "    \n",
    "    #cycle = STATE0['meanCycle']\n",
    "    #stdDev = STATE0['stdDev']\n",
    "    \n",
    "    ## Creating a dictionary of list to keep track of our base cycles and optimized cycles\n",
    "    ## base and opt are the lists corressponding to base and optimized cycles\n",
    "    #base = []\n",
    "    #opt = []\n",
    "    \n",
    "    #state0 = {'BASE': base, 'OPT': opt}\n",
    "    \n",
    "    ## Creating a base cycle and appending it to the list base\n",
    "    \n",
    "    ## baseCycles for the state at the current execution time\n",
    "    ## random number from the normal distribution with mean=STATE1['meanCycle']\n",
    "    ## and stdDev = STATE1['stdDev']\n",
    "    #baseCycles = round(nm.random.normal(STATE0['meanCycle'], STATE0['stdDev']))\n",
    "    baseCycles = round(getTruncatedNormal(STATE0['meanCycle'], STATE0['stdDev'],\\\n",
    "                                         STATE0['min'], STATE0['max']))\n",
    "    BASE.append(baseCycles)\n",
    "    \n",
    "    ## For the first iteration we need to start with time=0\n",
    "    if (len(BASE) == 1):\n",
    "        optStateCycles = getOptCycles(baseCycles, 0, PDM, iCache)\n",
    "    else:\n",
    "        ## startCycles for next iteration is the baseCycle from previous state\n",
    "        optStateCycles = getOptCycles(baseCycles, getTotalCycles(BASE, len(BASE)-1), PDM, iCache)\n",
    "    \n",
    "    OPT.append(optStateCycles)\n",
    "    \n",
    "    ## \n",
    "    #for i in range(len(BASE)):\n",
    "        #print \"BASE[%d] = %f\" %(i, BASE[i])\n",
    "    \n",
    "    if random() < 0.9:\n",
    "        return state_1\n",
    "    else:\n",
    "        return state_0\n",
    "\n",
    "def state_1():\n",
    "    print \"State_1\"\n",
    "    \n",
    "    ##\n",
    "    global STATE1, BASE, OPT\n",
    "    \n",
    "    ## baseCycles for the state at the current execution time\n",
    "    ## random number from the normal distribution with mean=STATE1['meanCycle']\n",
    "    ## and stdDev = STATE1['stdDev']\n",
    "    #baseCycles = round(nm.random.normal(STATE1['meanCycle'], STATE1['stdDev']))\n",
    "    baseCycles = round(getTruncatedNormal(STATE1['meanCycle'], STATE1['stdDev'],\\\n",
    "                                         STATE1['min'], STATE1['max']))\n",
    "    BASE.append(baseCycles)\n",
    "    \n",
    "    if (len(BASE) == 1):\n",
    "        optStateCycles = getOptCycles(baseCycles, 0, PDM, iCache)\n",
    "    else:\n",
    "        optStateCycles = getOptCycles(baseCycles, getTotalCycles(BASE, len(BASE)-1), PDM, iCache)\n",
    "    \n",
    "    OPT.append(optStateCycles)\n",
    "    \n",
    "    #for i in range(len(BASE)):\n",
    "        #print \"BASE[%d]= %f\" %(i, BASE[i])\n",
    "        \n",
    "    if random() > 0.3:\n",
    "        return state_0\n",
    "    else:\n",
    "        return state_1\n",
    "    \n",
    "    \n",
    "## Other functions\n",
    "\n",
    "## sum() => internal function can also be used\n",
    "## Usage sum(list)\n",
    "def getTotalCycles(list1, index):\n",
    "    tot = 0\n",
    "    for i in range(index):\n",
    "        tot = tot + list1[i]\n",
    "    return tot\n",
    "\n",
    "###############################################\n",
    "\n",
    "## getOptCycles takes in input basecycle, time at which the state started,\n",
    "## method and technique applied and returns the optimized time for that state, that method \n",
    "## and technique\n",
    "\n",
    "## baseCycles => is generated randomly based on mean and variance for a state\n",
    "## startCycles => is the time at which the previous state finished. Start of this state in globale\n",
    "## time\n",
    "## method => method, PDM, GREEDY, GENERIC\n",
    "## method['lat'] => gives the latency time for the method\n",
    "## tech => technique applied, iCache, dCache, ROB etc.\n",
    "\n",
    "def getOptCycles(baseCycles, startCycles, method, tech):\n",
    "    #print \"method= %s\\n%s['freqSampling'] = %d\" %(method, method, method['freqSampling'])\n",
    "    #print \"Type of Method = %s\" %(type(method))\n",
    "    samplingRate = method['freqSampling']\n",
    "    \n",
    "    ## samplingTime is the time in the state where the technique will sample for optimisation\n",
    "    ## If the startCyles is 0 => Starting the simulation\n",
    "    ## startCycles is divisible by sampling rate => We discussed to go on to the next \n",
    "    ## sampling cycle\n",
    "    if (startCycles % samplingRate == 0 or startCycles == 0):\n",
    "        samplingTime = samplingRate\n",
    "    elif (startCycles % samplingRate != 0):\n",
    "        ## Since we know the starting time, we divide it by samplingRate to see how much \n",
    "        ## it is above the samplingRate. Now we subtract it from the samplingRate to get \n",
    "        ## how further down will the next sampling be done.\n",
    "        ## We multiply 2*samplingRate since the program will take at least freqSampling\n",
    "        ## to optimize.\n",
    "        #samplingTime = startCycles + (samplingRate - nm.remainder(startCycles, samplingRate))\n",
    "        samplingTime = (2*samplingRate) - nm.remainder(startCycles, samplingRate)\n",
    "    \n",
    "    if (samplingTime > baseCycles):\n",
    "        print \"Sampling Time greater than baseCycles ==> No optimisation possible\\n\"\n",
    "        print \"baseCycles= %d\\nsamplingTime= %d\\n\" %(baseCycles, samplingTime)\n",
    "        return baseCycles\n",
    "    else:\n",
    "        ## globalSamplingTime => Gives the sampling time with respect to global time\n",
    "        globalSamplingTime = startCycles + samplingTime\n",
    "\n",
    "        ## optTime => Represents the time taken by method to optimize\n",
    "        optTime = round(nm.random.normal(method['lat'], method['stdDev']))\n",
    "\n",
    "        ## configTime => Represents the time taken by technique to configure\n",
    "        configTime = round(nm.random.normal(tech['lat'], tech['stdDev']))\n",
    "\n",
    "        ## timeleft => Represents the time left after sampling and optimisation and configuration time\n",
    "        timeLeft = baseCycles - (samplingTime + optTime + configTime)\n",
    "        if (timeLeft < 0):\n",
    "            print \"Cannot optimize because there is no time left for optimisation\\n\"\n",
    "            print \"timeLeft < 0\\n\"\n",
    "            print \"baseCycles= %d\\nstartCycles= %d\\nsamplingTime= %d\\nglobalSamplingTime=%d\\noptTime= %d\\\n",
    "        \\nconfigTime= %d\\ntimeLeft= %d\\n\"\\\n",
    "        % (baseCycles, startCycles, samplingTime, globalSamplingTime, optTime, \\\n",
    "           configTime, timeLeft)\n",
    "            return baseCycles\n",
    "        \n",
    "        else:\n",
    "            ## this time is now optimized according to the method\n",
    "            opt_timeLeft = round(method['quality']*timeLeft)\n",
    "\n",
    "            newStateCycles = samplingTime + optTime + configTime + opt_timeLeft\n",
    "\n",
    "            print \"\\nbaseCycles= %d\\nstartCycles= %d\\nsamplingTime= %d\\nglobalSamplingTime=%d\\noptTime= %d\\\n",
    "            \\nconfigTime= %d\\ntimeLeft= %d\\nopt_timeLeft=%d\\nnewStateCycles= %d\\n\"\\\n",
    "            % (baseCycles, startCycles, samplingTime, globalSamplingTime, optTime, \\\n",
    "               configTime, timeLeft, opt_timeLeft, newStateCycles)\n",
    "\n",
    "            ## returning the optimized time the state takes because of the technique and method applied\n",
    "            return newStateCycles\n",
    "\n",
    "#######################################################    \n",
    "\n",
    "## getTruncatedNormal gets random number by normal distribution within 'low' and 'up' given\n",
    "## the mean and standard deviation of the numbers.\n",
    "## rvs ==> is random variable continuous \n",
    "## Refer ==> https://stackoverflow.com/questions/36894191/how-to-get-a-normal-distribution-within-a-range-in-numpy\n",
    "\n",
    "def getTruncatedNormal (mean, stdDev, low, up):\n",
    "    return truncnorm ((low-mean)/stdDev, (up-mean)/stdDev, loc=mean, scale=stdDev).rvs()\n",
    "\n",
    "#print \"truncated Normal number between %d and %d with mean=%d and stdDev = %d is %d\"\\\n",
    "#% (numMin, numMax, numMean, numSd, getTruncatedNormal(numMean, numSd, numMin, numMax).rvs() )    \n",
    "################\n",
    "    \n",
    "state = state_0\n",
    "\n",
    "count = 0\n",
    "\n",
    "while state:\n",
    "    state = state()\n",
    "    ## when the sum of base goes above N we stop\n",
    "    ## Stops close to the maximum number of cycles that we want to execute\n",
    "    if sum(BASE) > N:\n",
    "        ## state => None. while loop stops\n",
    "        state = None\n",
    "\n",
    "\n",
    "print \"\\ntype of BASE = %s\\n\" %(type(BASE))\n",
    "#totalBaseCycles = getTotalCycles(BASE, len(BASE))\n",
    "\n",
    "for i in range(len(BASE)):\n",
    "    print \"BASE[%d]= %d, OPT[%d]=%d\" %(i, BASE[i], i, OPT[i])\n",
    "    \n",
    "#print \"\\nTotal Base Cycles = %d\" %(totalBaseCycles)\n",
    "\n",
    "### \n",
    "#getOptCycles(BASE[1], BASE[0], PDM, iCache)\n",
    "\n",
    "print \"\\nTotal Base = %d, Total Opt = %d\\nTotal Speed Up = %f\" \\\n",
    "% (sum(BASE), sum(OPT), sum(BASE)/sum(OPT))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "baseCycles= 52374\n",
      "startCycles= 0\n",
      "samplingTime= 2000\n",
      "globalSamplingTime=2000\n",
      "optTime= 492            \n",
      "configTime= 250\n",
      "timeLeft= 49632\n",
      "opt_timeLeft=39706\n",
      "newStateCycles= 42448\n",
      "\n",
      "\n",
      "baseCycles= 45002\n",
      "startCycles= 52374\n",
      "samplingTime= 3626\n",
      "globalSamplingTime=56000\n",
      "optTime= 515            \n",
      "configTime= 236\n",
      "timeLeft= 40625\n",
      "opt_timeLeft=32500\n",
      "newStateCycles= 36877\n",
      "\n",
      "\n",
      "baseCycles= 5421\n",
      "startCycles= 97376\n",
      "samplingTime= 2624\n",
      "globalSamplingTime=100000\n",
      "optTime= 508            \n",
      "configTime= 250\n",
      "timeLeft= 2039\n",
      "opt_timeLeft=1631\n",
      "newStateCycles= 5013\n",
      "\n",
      "\n",
      "############################\n",
      "\n",
      "Ooptimisation Method = PDM , Tech = iCahche\n",
      "BASE[0]= 52374, optList[0]=42448\n",
      "BASE[1]= 45002, optList[1]=36877\n",
      "BASE[2]= 5421, optList[2]=5013\n",
      "\n",
      "Total Base = 102797, Total Opt = 84338\n",
      "Total Speed Up = 1.218869\n",
      "\n",
      "############################\n",
      "\n",
      "\n",
      "baseCycles= 52374\n",
      "startCycles= 0\n",
      "samplingTime= 4000\n",
      "globalSamplingTime=4000\n",
      "optTime= 1542            \n",
      "configTime= 267\n",
      "timeLeft= 46565\n",
      "opt_timeLeft=41909\n",
      "newStateCycles= 47718\n",
      "\n",
      "\n",
      "baseCycles= 45002\n",
      "startCycles= 52374\n",
      "samplingTime= 7626\n",
      "globalSamplingTime=60000\n",
      "optTime= 1535            \n",
      "configTime= 257\n",
      "timeLeft= 35584\n",
      "opt_timeLeft=32026\n",
      "newStateCycles= 41444\n",
      "\n",
      "Sampling Time greater than baseCycles ==> No optimisation possible\n",
      "\n",
      "baseCycles= 5421\n",
      "samplingTime= 6624\n",
      "\n",
      "\n",
      "############################\n",
      "\n",
      "Ooptimisation Method = GREEDY , Tech = iCahche\n",
      "BASE[0]= 52374, optList[0]=47718\n",
      "BASE[1]= 45002, optList[1]=41444\n",
      "BASE[2]= 5421, optList[2]=5421\n",
      "\n",
      "Total Base = 102797, Total Opt = 94583\n",
      "Total Speed Up = 1.086844\n",
      "\n",
      "############################\n",
      "\n",
      "\n",
      "baseCycles= 52374\n",
      "startCycles= 0\n",
      "samplingTime= 2000\n",
      "globalSamplingTime=2000\n",
      "optTime= 510            \n",
      "configTime= 403\n",
      "timeLeft= 49461\n",
      "opt_timeLeft=39569\n",
      "newStateCycles= 42482\n",
      "\n",
      "\n",
      "baseCycles= 45002\n",
      "startCycles= 52374\n",
      "samplingTime= 3626\n",
      "globalSamplingTime=56000\n",
      "optTime= 498            \n",
      "configTime= 324\n",
      "timeLeft= 40554\n",
      "opt_timeLeft=32443\n",
      "newStateCycles= 36891\n",
      "\n",
      "\n",
      "baseCycles= 5421\n",
      "startCycles= 97376\n",
      "samplingTime= 2624\n",
      "globalSamplingTime=100000\n",
      "optTime= 510            \n",
      "configTime= 333\n",
      "timeLeft= 1954\n",
      "opt_timeLeft=1563\n",
      "newStateCycles= 5030\n",
      "\n",
      "\n",
      "############################\n",
      "\n",
      "Ooptimisation Method = PDM , Tech = dCache\n",
      "BASE[0]= 52374, optList[0]=42482\n",
      "BASE[1]= 45002, optList[1]=36891\n",
      "BASE[2]= 5421, optList[2]=5030\n",
      "\n",
      "Total Base = 102797, Total Opt = 84403\n",
      "Total Speed Up = 1.217931\n",
      "\n",
      "############################\n",
      "\n",
      "\n",
      "baseCycles= 52374\n",
      "startCycles= 0\n",
      "samplingTime= 4000\n",
      "globalSamplingTime=4000\n",
      "optTime= 1425            \n",
      "configTime= 298\n",
      "timeLeft= 46651\n",
      "opt_timeLeft=41986\n",
      "newStateCycles= 47709\n",
      "\n",
      "\n",
      "baseCycles= 45002\n",
      "startCycles= 52374\n",
      "samplingTime= 7626\n",
      "globalSamplingTime=60000\n",
      "optTime= 1524            \n",
      "configTime= 511\n",
      "timeLeft= 35341\n",
      "opt_timeLeft=31807\n",
      "newStateCycles= 41468\n",
      "\n",
      "Sampling Time greater than baseCycles ==> No optimisation possible\n",
      "\n",
      "baseCycles= 5421\n",
      "samplingTime= 6624\n",
      "\n",
      "\n",
      "############################\n",
      "\n",
      "Ooptimisation Method = GREEDY , Tech = dCache\n",
      "BASE[0]= 52374, optList[0]=47709\n",
      "BASE[1]= 45002, optList[1]=41468\n",
      "BASE[2]= 5421, optList[2]=5421\n",
      "\n",
      "Total Base = 102797, Total Opt = 94598\n",
      "Total Speed Up = 1.086672\n",
      "\n",
      "############################\n",
      "\n"
     ]
    }
   ],
   "source": [
    "## Once BASE is created, we can use it to get speedup for \n",
    "## various METHODS and TECHNIQUES\n",
    "\n",
    "## create OPT list for each Method\n",
    "global PDM_OPT, GREEDY_OPT\n",
    "\n",
    "## name key added to print the name\n",
    "PDM = {'name': 'PDM', 'freqSampling': 2000, 'lat': 500, 'stdDev': 20, 'quality': 0.8}\n",
    "GREEDY = {'name': 'GREEDY', 'freqSampling': 4000, 'lat': 1500, 'stdDev': 100, 'quality': 0.9}\n",
    "\n",
    "iCache = {'name': 'iCahche', 'lat': 250, 'stdDev': 10, 'quality': 0.2}\n",
    "dCache = {'name': 'dCache', 'lat': 400, 'stdDev': 50, 'quality': 0.3}\n",
    "\n",
    "PDM_OPT = []\n",
    "GREEDY_OPT = []\n",
    "\n",
    "## Create a list of methods, do not create strings 'PDM' XX\n",
    "METHOD = [PDM, GREEDY]\n",
    "TECH = [iCache, dCache]\n",
    "\n",
    "## Create METHOD_LIST in one to one coresspondence to METHOD List\n",
    "METHOD_LIST = [PDM_OPT, GREEDY_OPT]\n",
    "\n",
    "for i in range(len(TECH)):\n",
    "    ## Instantiating optimizations lists to 0, for next iteration.\n",
    "    ## Will have to do this for all the lists.\n",
    "    ## Doing this does not help, python refers variables, hence \n",
    "    ## METHOD_LIST[j] = [] works to instantiate the lists.\n",
    "    #PDM_OPT = []\n",
    "    #GREEDY_OPT = []\n",
    "    #print (\"\\ni= %d, len(PDM_OPT)= %d, len(GREEDY_OPT)= %d\\n\") %(i, len(PDM_OPT), len(GREEDY_OPT))\n",
    "    for j in range(len(METHOD)):\n",
    "        METHOD_LIST[j] = []\n",
    "        for b in range(len(BASE)):\n",
    "            #print \"Ooptimisation Method = %s , Tech = %s\" %(METHOD[j], TECH[i])\n",
    "            #print \"Type of method = %s type of PDM variable=%s\\nb=%d type of b=%s\" \\\n",
    "            #%(type(METHOD[j]), type(PDM), b, type(b))\n",
    "            if (b==0):\n",
    "                optCycle = getOptCycles(BASE[b], getTotalCycles(BASE, 0), METHOD[j], TECH[i])\n",
    "            else:\n",
    "                optCycle = getOptCycles(BASE[b], getTotalCycles(BASE, b), METHOD[j], TECH[i])\n",
    "            \n",
    "            optList = METHOD_LIST[j]\n",
    "            #print \"\\nname= %s, optList len = %d\\n\" %(METHOD_LIST[j], len(optList))\n",
    "            optList.append(optCycle)\n",
    "        \n",
    "        print \"\\n############################\\n\"\n",
    "        print \"Ooptimisation Method = %s , Tech = %s\" %(METHOD[j]['name'], TECH[i]['name'])\n",
    "        for k in range(len(BASE)):\n",
    "            print \"BASE[%d]= %d, optList[%d]=%d\" %(k, BASE[k], k, optList[k])\n",
    "        print \"\\nTotal Base = %d, Total Opt = %d\\nTotal Speed Up = %f\" \\\n",
    "        % (sum(BASE), sum(optList), sum(BASE)/sum(optList))\n",
    "        print \"\\n############################\\n\"\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num = 20.429250\n",
      "st0['base]= [1, 2, 3]\n",
      "st0['opt]= [4, 5, 6]\n",
      "Sum of list1 = 6\n",
      "length list1= 3, type= <type 'list'>\n",
      "Rounding these number\n",
      "2.09 = 2\n",
      "2.49 = 2\n",
      "2.51 = 3\n",
      "2.98 = 3\n",
      "\n",
      "Remiander = 1\n",
      "\n",
      "loop 1\n",
      "\n",
      "length of list3 = 0\n",
      "Random Number between 5 and 100 is [ 5.12699724]\n",
      "truncated Normal number between 5 and 100 with mean=35 and stdDev = 20 is 6\n",
      "max of bc = 13\n"
     ]
    }
   ],
   "source": [
    "import numpy as nm\n",
    "from scipy.stats import truncnorm\n",
    "\n",
    "## Seed can be fixed to get replicable results\n",
    "nm.random.seed(None)\n",
    "\n",
    "## Here the mean is 20 and variance is 2\n",
    "num = nm.random.normal(20, 2)\n",
    "print \"num = %f\" %(num)\n",
    "\n",
    "## Creating dictionary of lists\n",
    "\n",
    "list1 = [1,2,3]\n",
    "list2 = [4,5,6]\n",
    "st0 = {'base': list1, 'opt': list2}\n",
    "summ = sum(list1)\n",
    "print \"st0['base]= %s\\nst0['opt]= %s\" %(st0['base'], st0['opt'])\n",
    "print \"Sum of list1 = %d\" %(summ)\n",
    "\n",
    "print \"length list1= %d, type= %s\" %(len(list1), type(list1))\n",
    "\n",
    "### rounding , rounds off to the int closest to it.\n",
    "### 2.4 => 2 , 2.5 => 3 (in case of equal it rounds off to further int) \n",
    "print \"Rounding these number\"\n",
    "print \"2.09 = %d\\n2.49 = %d\\n2.51 = %d\\n2.98 = %d\" %(round(2.09), round(2.49), round(2.51), round(2.98))\n",
    "\n",
    "## Remainder\n",
    "print \"\\nRemiander = %d\\n\" %(nm.remainder(10,3))\n",
    "\n",
    "## if else loop\n",
    "a = 24\n",
    "b = 4\n",
    "if (a % b == 0 ):\n",
    "    print \"loop 1\"\n",
    "elif (a % b != 0):\n",
    "    print \"loop2\"\n",
    "\n",
    "## length of a list\n",
    "list3 = []\n",
    "print \"\\nlength of list3 = %d\" %(len(list3))\n",
    "\n",
    "## truncated normal distribution random number generation\n",
    "numMin = 5\n",
    "numMax = 100\n",
    "numMean = 35\n",
    "numSd = 20\n",
    "print \"Random Number between %d and %d is %s\" %(numMin, numMax, truncnorm.rvs(numMin, numMax, size=1))\n",
    "\n",
    "def getTruncatedNormal (mean, stdDev, low, up):\n",
    "    return truncnorm ((low-mean)/stdDev, (up-mean)/stdDev, loc=mean, scale=stdDev).rvs()\n",
    "print \"truncated Normal number between %d and %d with mean=%d and stdDev = %d is %d\"\\\n",
    "% (numMin, numMax, numMean, numSd, getTruncatedNormal(numMean, numSd, numMin, numMax) )\n",
    "\n",
    "## max of a list \n",
    "bc = [1, 2, 13, 4]\n",
    "print \"max of bc = %d\" %(max(bc))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}