Repository: sadrasabouri/pyrandwalk (language: python)

Issue:
Add string type state support
#### Description
Until now pyrandwalk just accept numbers(`int`s) as its states, it would be nice if we add other types support too.

For example we can take into consider a BiGram simulation like bellow:
#### Steps/Code to Reproduce
```
>>> lexicon = ['I', 'eat', 'food']
>>> bigram = np.array([[0.1, 0.8, 0.1], [0.3, 0.1, 0.6], [0.6, 0.3, 0.1]])
>>> rw = RandomWalk(lexicon, bigram)
>>> states, probs = rw.run()
```
#### Expected Behavior
```
>>> states
['I', 'eat', 'food', 'food', 'I', 'food', 'I', 'eat', 'food', 'I', 'eat']
>>> probs
[0.3, 0.8, 0.6, 0.1, 0.6, 0.1, 0.1, 0.8, 0.6, 0.6, 0.8]
```
#### Actual Behavior
```
Traceback (most recent call last):
    ...
IndexError: only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices
```
#### Operating System
Linux 5.4.0-80-generic #90-Ubuntu SMP Fri Jul 9 22:49:44 UTC 2021 x86_64 x86_64 x86_64 GNU/Linux

#### Python Version
Python 3.8.10
#### pyrandwalk Version (Use : `pyrandwalk.__version__`)
1.0


Discussion / hints:

Fix patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index effbff8..2b4aac9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,14 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+## [1.1] - 2021-08-25
+### Added
+- all input `state` type support
+- new examples
+- `paper.bib`
+- `paper.md`
+### Changes
+- `make_prob_dist` modified
 ## [1.0] - 2021-06-09
 ### Added
 - codefactor tests
@@ -34,6 +42,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - `get_typeof_classes` method
 - `README.md`
 
-[Unreleased]: https://github.com/sadrasabouri/pyrandwalk/compare/v1.0...dev
+[Unreleased]: https://github.com/sadrasabouri/pyrandwalk/compare/v1.1...dev
+[1.1]: https://github.com/sadrasabouri/pyrandwalk/compare/v1.0...v1.1
 [1.0]: https://github.com/sadrasabouri/pyrandwalk/compare/v0.09...v1.0
 [0.09]: https://github.com/sadrasabouri/pyrandwalk/compare/9113e4c...v0.09
diff --git a/Document/Document.ipynb b/Document/Document.ipynb
index b93ceab..dda530b 100644
--- a/Document/Document.ipynb
+++ b/Document/Document.ipynb
@@ -20,7 +20,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Version : 1.0\n",
+    "### Version : 1.1\n",
     "-----"
    ]
   },
@@ -47,12 +47,14 @@
     "            <li><a href=\"#RandomWalk\">RandomWalk</a></li>\n",
     "            <li><a href=\"#prob_sec\">prob_sec</a></li>\n",
     "            <li><a href=\"#run\">run</a></li>\n",
+    "            <li><a href=\"#final_dist\">final_dist</a></li>\n",
     "            <li><a href=\"#is_irreducible\">is_irreducible</a></li>\n",
     "            <li><a href=\"#trans_power\">trans_power</a></li>     \n",
     "            <li><a href=\"#get_edges\">get_edges</a></li>\n",
     "            <li><a href=\"#get_graph\">get_graph</a></li>\n",
     "            <li><a href=\"#plot_graph\">plot_graph</a></li>\n",
     "            <li><a href=\"#get_typeof_classes\">get_typeof_classes</a></li>\n",
+    "            <li><a href=\"#best_policy\">best_policy</a></li>\n",
     "        </ol>\n",
     "    <li><a href=\"#Examples\">Examples</a></li>\n",
     "    <li><a href=\"#References\">References</a></li>\n",
@@ -70,8 +72,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Pyrandwalk is a tool for simulating random walks, calculate the probability of given state sequences and etc.\n",
-    "Random walk is a representation of discrete-time, discrete-value Markov chain model using in stochastic processes."
+    "Pyrandwalk is an educational tool for simulating random walks, calculating the probability of given state sequences, etc. Random walk is a representation of the discrete-time, discrete-value Markov chain model used in stochastic processes."
    ]
   },
   {
@@ -86,7 +87,7 @@
    "metadata": {},
    "source": [
     "### Source code\n",
-    "- Download [Version 1.0](https://github.com/sadrasabouri/pyrandwalk/archive/v1.0.zip) or [Latest Source ](https://github.com/sadrasabouri/pyrandwalk/archive/dev.zip)\n",
+    "- Download [Version 1.1](https://github.com/sadrasabouri/pyrandwalk/archive/v1.1.zip) or [Latest Source ](https://github.com/sadrasabouri/pyrandwalk/archive/dev.zip)\n",
     "- Run `pip install -r requirements.txt` or `pip3 install -r requirements.txt` (Need root access)\n",
     "- Run `python3 setup.py install` or `python setup.py install` (Need root access)"
    ]
@@ -116,9 +117,14 @@
    },
    "outputs": [
     {
-     "output_type": "stream",
      "name": "stdout",
-     "text": "/usr/lib/python3/dist-packages/secretstorage/dhcrypto.py:15: CryptographyDeprecationWarning: int_from_bytes is deprecated, use int.from_bytes instead\n  from cryptography.utils import int_from_bytes\n/usr/lib/python3/dist-packages/secretstorage/util.py:19: CryptographyDeprecationWarning: int_from_bytes is deprecated, use int.from_bytes instead\n  from cryptography.utils import int_from_bytes\n"
+     "output_type": "stream",
+     "text": [
+      "/usr/lib/python3/dist-packages/secretstorage/dhcrypto.py:15: CryptographyDeprecationWarning: int_from_bytes is deprecated, use int.from_bytes instead\r\n",
+      "  from cryptography.utils import int_from_bytes\r\n",
+      "/usr/lib/python3/dist-packages/secretstorage/util.py:19: CryptographyDeprecationWarning: int_from_bytes is deprecated, use int.from_bytes instead\r\n",
+      "  from cryptography.utils import int_from_bytes\r\n"
+     ]
     }
    ],
    "source": [
@@ -293,7 +299,7 @@
     {
      "data": {
       "text/plain": [
-       "[2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]"
+       "[3, 4, 3, 2, 1, 2, 3, 4, 3, 4, 3]"
       ]
      },
      "execution_count": 8,
@@ -313,7 +319,7 @@
     {
      "data": {
       "text/plain": [
-       "[0.2, 0.25, 0.25, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]"
+       "[0.2, 0.75, 1.0, 0.25, 0.25, 0.75, 0.75, 0.75, 1.0, 0.75, 1.0]"
       ]
      },
      "execution_count": 9,
@@ -342,7 +348,7 @@
     {
      "data": {
       "text/plain": [
-       "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]"
+       "[3, 4, 3, 4, 3, 2, 3, 4, 3, 4, 3, 4, 3, 2, 3, 4, 3, 4, 3, 4, 3]"
       ]
      },
      "execution_count": 11,
@@ -363,25 +369,25 @@
      "data": {
       "text/plain": [
        "[0.2,\n",
+       " 0.75,\n",
        " 1.0,\n",
+       " 0.75,\n",
        " 1.0,\n",
+       " 0.25,\n",
+       " 0.75,\n",
+       " 0.75,\n",
        " 1.0,\n",
+       " 0.75,\n",
        " 1.0,\n",
+       " 0.75,\n",
        " 1.0,\n",
+       " 0.25,\n",
+       " 0.75,\n",
+       " 0.75,\n",
        " 1.0,\n",
+       " 0.75,\n",
        " 1.0,\n",
-       " 1.0,\n",
-       " 1.0,\n",
-       " 1.0,\n",
-       " 1.0,\n",
-       " 1.0,\n",
-       " 1.0,\n",
-       " 1.0,\n",
-       " 1.0,\n",
-       " 1.0,\n",
-       " 1.0,\n",
-       " 1.0,\n",
-       " 1.0,\n",
+       " 0.75,\n",
        " 1.0]"
       ]
      },
@@ -414,16 +420,16 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "4 --> 3  (p = 1.000)\n",
-      "3 --> 4  (p = 0.750)\n",
-      "4 --> 3  (p = 1.000)\n",
-      "3 --> 2  (p = 0.250)\n",
-      "2 --> 3  (p = 0.750)\n",
-      "3 --> 2  (p = 0.250)\n",
+      "2 --> 1  (p = 0.250)\n",
+      "1 --> 2  (p = 0.750)\n",
       "2 --> 3  (p = 0.750)\n",
       "3 --> 4  (p = 0.750)\n",
       "4 --> 3  (p = 1.000)\n",
-      "3 --> 4  (p = 0.750)\n"
+      "3 --> 2  (p = 0.250)\n",
+      "2 --> 1  (p = 0.250)\n",
+      "1 --> 0  (p = 0.250)\n",
+      "0 --> 0  (p = 1.000)\n",
+      "0 --> 0  (p = 1.000)\n"
      ]
     }
    ],
@@ -439,7 +445,7 @@
     {
      "data": {
       "text/plain": [
-       "[4, 3, 4, 3, 2, 3, 2, 3, 4, 3, 4]"
+       "[2, 1, 2, 3, 4, 3, 2, 1, 0, 0, 0]"
       ]
      },
      "execution_count": 14,
@@ -459,7 +465,7 @@
     {
      "data": {
       "text/plain": [
-       "[0.2, 1.0, 0.75, 1.0, 0.25, 0.75, 0.25, 0.75, 0.75, 1.0, 0.75]"
+       "[0.2, 0.25, 0.75, 0.75, 0.75, 1.0, 0.25, 0.25, 0.25, 1.0, 1.0]"
       ]
      },
      "execution_count": 15,
@@ -480,6 +486,73 @@
     "</ul>"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### final_dist\n",
+    "\n",
+    "Calculate final distribution of the random walk:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1., 0., 0., 0., 0.])"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "rw.final_dist()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<ul>\n",
+    "    <li> <span style=\"color:red;\">Notice </span> : added in version 1.</li>\n",
+    "</ul>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1., 0., 0., 0., 0.])"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "rw.final_dist(precision=10**(-2))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<ul>\n",
+    "    <li> <span style=\"color:red;\">Notice </span> : `precision` if float number indecating the precision of final distribution (default value 10**(-10)).</li>\n",
+    "</ul>"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -491,7 +564,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
@@ -500,7 +573,7 @@
        "False"
       ]
      },
-     "execution_count": 16,
+     "execution_count": 18,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -520,7 +593,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
@@ -533,7 +606,7 @@
        "       [0.    , 0.    , 0.25  , 0.    , 0.75  ]])"
       ]
      },
-     "execution_count": 17,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -553,7 +626,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
@@ -569,7 +642,7 @@
        " (4, 3, 1.0)]"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -589,7 +662,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -607,14 +680,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 576x396 with 1 Axes>"
+       "<AxesSubplot:title={'center':'My Random Walk Graph'}>"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
       ]
      },
      "metadata": {},
@@ -636,7 +719,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -645,7 +728,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
@@ -654,7 +737,7 @@
        "([0], array([[1.]]))"
       ]
      },
-     "execution_count": 22,
+     "execution_count": 24,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -665,7 +748,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
@@ -674,7 +757,7 @@
        "[1, 2, 3, 4]"
       ]
      },
-     "execution_count": 23,
+     "execution_count": 25,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -685,7 +768,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [
     {
@@ -697,7 +780,7 @@
        "       [0.  , 0.  , 1.  , 0.  ]])"
       ]
      },
-     "execution_count": 24,
+     "execution_count": 26,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -706,6 +789,38 @@
     "rw_class_types['transient'][1]"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### best_policy\n",
+    "\n",
+    "For making the best policy problems for your random walk you can easily:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'continue': [], 'stop': [0, 1, 2]}"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "states = [0, 1, 2]\n",
+    "trans = np.array([[1, 0, 0], [1/2, 0, 1/2], [0, 1, 0]])\n",
+    "rw = RandomWalk(states, trans, payoff=[0, 1, 4], cost=[1, 0, 2], discount=0.5)\n",
+    "rw.best_policy()"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -737,16 +852,16 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "<blockquote>1- Lawler, Gregory F. Introduction to stochastic processes. Chapman and Hall/CRC, 2018.</blockquote>\n",
-    "<blockquote>2- <a href=\"https://markusfeng.com/projects/graph/\">Markusfeng</a></blockquote>\n",
+    "<blockquote>1- Gregory F.Lawler, \"Introduction to Stochastic Processes\".</blockquote>\n",
+    "<blockquote>2- [Markusfeng](https://markusfeng.com/projects/graph/), \"Graph / Finite State Machine Designer\".</blockquote>\n",
     "<div>Icon made by <a href=\"https://www.flaticon.com/authors/becris\" title=\"Becris\">Becris</a> from <a href=\"https://www.flaticon.com/\" title=\"Flaticon\">www.flaticon.com</a></div>\n"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.7.5 64-bit",
-   "name": "python37564bitb5183b850c424c19822d4b729b3b8a98"
+   "display_name": "Python 3",
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -758,7 +873,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.5-final"
+   "version": "3.6.8-final"
   }
  },
  "nbformat": 4,
diff --git a/Document/Examples.ipynb b/Document/Examples.ipynb
index 72f7825..0025f07 100644
--- a/Document/Examples.ipynb
+++ b/Document/Examples.ipynb
@@ -20,7 +20,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Version : 1.0\n",
+    "### Version : 1.1\n",
     "-----"
    ]
   },
@@ -36,6 +36,14 @@
     "            <li><a href=\"#Exercise1_2\">#Exercise1_2</a></li>\n",
     "            <li><a href=\"#Exercise1_3\">#Exercise1_3</a></li>\n",
     "            <li><a href=\"#Exercise1_4\">#Exercise1_4</a></li>\n",
+    "            <li><a href=\"#Exercise1_5\">#Exercise1_5</a></li>\n",
+    "            <li><a href=\"#Exercise1_8\">#Exercise1_8</a></li>\n",
+    "        </ul>\n",
+    "        <li><a href=\"#\">Countable_Markov_Chains</a></li>\n",
+    "        <li><a href=\"#\">Continous_Time_Markov_Chains</a></li>\n",
+    "        <li><a href=\"#Optimal_Stopping\">Optimal_Stopping</a></li>\n",
+    "        <ul>\n",
+    "            <li><a href=\"#Exercise4_1\">#Exercise4_1</a></li>\n",
     "        </ul>\n",
     "    </ol>\n",
     "</ul>"
@@ -125,6 +133,401 @@
     "print(third_step_trans)\n",
     "print(\"ANSWER:\", third_step_trans[0, 1])"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercise1_3\n",
+    "\n",
+    "Consider a Markov chain with state space \\{1, 2, 3\\} and transition matrix\n",
+    "\n",
+    "$$\n",
+    "P =\n",
+    "\\left(\\begin{array}{cc} \n",
+    "0.4 & 0.2 & 0.4\\\\\n",
+    "0.6 & 0 & 0.4 \\\\\n",
+    "0.2 & 0.5 & 0.3\n",
+    "\\end{array}\\right)\n",
+    "$$\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "states = [1, 2, 3]\n",
+    "trans = np.array([[0.4, 0.2, 0.4],\n",
+    "                  [0.6,  0 , 0.4],\n",
+    "                  [0.2, 0.5, 0.3]])\n",
+    "rw = RandomWalk(states, trans)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "what is the probability in the long run that the chain is in state 1?\n",
+    "Solve this problem two different ways:\n",
+    "\n",
+    "1) by raising the matrix to a high power:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[0.37878788, 0.25757576, 0.36363636],\n",
+       "       [0.37878788, 0.25757576, 0.36363636],\n",
+       "       [0.37878788, 0.25757576, 0.36363636]])"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "rw.trans_power(1000)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "2) by directly computing the invariant probability vector as a left eigenvector:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.37878788, 0.25757576, 0.36363636])"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "rw.final_dist()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercise1_4\n",
+    "\n",
+    "Do the same with\n",
+    "\n",
+    "$$\n",
+    "P =\n",
+    "\\left(\\begin{array}{cc} \n",
+    "0.2 & 0.4 & 0.4\\\\\n",
+    "0.1 & 0.5 & 0.4 \\\\\n",
+    "0.6 & 0.3 & 0.1\n",
+    "\\end{array}\\right)\n",
+    "$$\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "states = [1, 2, 3]\n",
+    "trans = np.array([[0.2, 0.4, 0.4],\n",
+    "                  [0.1, 0.5, 0.4],\n",
+    "                  [0.6, 0.3, 0.1]])\n",
+    "rw = RandomWalk(states, trans)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "1) by raising the matrix to a high power:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[0.28205128, 0.41025641, 0.30769231],\n",
+       "       [0.28205128, 0.41025641, 0.30769231],\n",
+       "       [0.28205128, 0.41025641, 0.30769231]])"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "rw.trans_power(1000)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "2) by directly computing the invariant probability vector as a left eigenvector:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.28205128, 0.41025641, 0.30769231])"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "rw.final_dist()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercise1_5\n",
+    "\n",
+    "Consider the Markov chain with state space $ S = \\{0, ..., 5\\} $ and transition matrix:\n",
+    "\n",
+    "$$\n",
+    "P =\n",
+    "\\left(\\begin{array}{cc} \n",
+    "0.5 & 0.5 & 0 & 0 & 0 & 0\\\\\n",
+    "0.3 & 0.7 & 0 & 0 & 0 & 0 \\\\\n",
+    "0 & 0 & 0.1 & 0 & 0 & 0.9 \\\\\n",
+    "0.25 & 0.25 & 0 & 0 & 0.25 & 0.25 \\\\\n",
+    "0 & 0 & 0.7 & 0 & 0.3 & 0 \\\\\n",
+    "0 & 0.2 & 0 & 0.2 & 0.2 & 0.4 \\\\\n",
+    "\\end{array}\\right)\n",
+    "$$\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "states = list(range(6))\n",
+    "trans = np.array([[0.5, 0.5, 0  , 0  , 0  , 0  ],\n",
+    "                  [0.3, 0.7, 0  , 0  , 0  , 0  ],\n",
+    "                  [0  , 0  , 0.1, 0  , 0  , 0.9],\n",
+    "                  [.25, .25, 0  , 0  , .25, .25],\n",
+    "                  [0  , 0  , 0.7, 0  , 0.3, 0  ],\n",
+    "                  [0  , 0.2, 0  , 0.2, 0.2, 0.4]])\n",
+    "rw = RandomWalk(states, trans)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "What are the communication classes? Which ones are recurrent and which are transient?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "execute_result",
+     "data": {
+      "text/plain": "{'recurrent': ([0, 1],\n  array([[0.5, 0.5],\n         [0.3, 0.7]])),\n 'transient': ([2, 3, 4, 5],\n  array([[0.1 , 0.  , 0.  , 0.9 ],\n         [0.  , 0.  , 0.25, 0.25],\n         [0.7 , 0.  , 0.3 , 0.  ],\n         [0.  , 0.2 , 0.2 , 0.4 ]]))}"
+     },
+     "metadata": {},
+     "execution_count": 3
+    }
+   ],
+   "source": [
+    "rw.get_typeof_classes()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Suppose the system starts in state 0. What is the probability that it will be in state 0 at some large time? Answer the same question assuming the system starts in state 5."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": "0.37499999999998634\n8.081964030507363e-71\n"
+    }
+   ],
+   "source": [
+    "p_1000 = rw.trans_power(1000)\n",
+    "print(p_1000[0, 0])\n",
+    "print(p_1000[5, 5])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercise1_8\n",
+    "\n",
+    "Consider simple random walk on the graph below. (Recall that simple random walk on a graph is the Markov chain which at each time moves to an adjacent vertex, each adjacent vertex having the same probability):\n",
+    "\n",
+    "$$\n",
+    "P =\n",
+    "\\left(\\begin{array}{cc} \n",
+    "0 & 1/3 & 1/3 & 1/3 & 0 \\\\\n",
+    "1/3 & 0 & 1/3 & 0 & 1/3 \\\\\n",
+    "1/2 & 1/2 & 0 & 0 & 0 \\\\\n",
+    "1/2 & 0 & 0 & 0 & 1/2 \\\\\n",
+    "0 & 1/2 & 0 & 1/2 & 0 \\\\\n",
+    "\\end{array}\\right)\n",
+    "$$\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "states = list(range(5))\n",
+    "trans = np.array([[0, 1/3, 1/3, 1/3,   0],\n",
+    "                  [1/3, 0, 1/3,   0, 1/3],\n",
+    "                  [1/2, 1/2, 0,   0,   0],\n",
+    "                  [1/2,   0, 0,   0, 1/2],\n",
+    "                  [0  , 1/2, 0, 1/2,   0]])\n",
+    "rw = RandomWalk(states, trans)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "a) In the long run, what function of time is spent in vertex A?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": "0.2500000000000003\n"
+    }
+   ],
+   "source": [
+    "final_dist = rw.final_dist()\n",
+    "print(final_dist[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Optimal_Stopping"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Exercise4_1\n",
+    "Consider a simple random walk ($p = 1/2$) with absorbing boundaries on $\\{0,1,2,...,10\\}$. Suppose the fallowing payoff function is given:\n",
+    "\n",
+    "$$\n",
+    "[0,2,4,3,10,0,6,4,3,3,0]\n",
+    "$$\n",
+    "Find the optimal stopping rule and give the expected payoff starting at each site.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "states = list(range(11))\n",
+    "trans = np.array([[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
+    "                  [.5,0,.5, 0, 0, 0, 0, 0, 0, 0, 0],\n",
+    "                  [0, .5,0,.5, 0, 0, 0, 0, 0, 0, 0],\n",
+    "                  [0, 0, .5,0,.5, 0, 0, 0, 0, 0, 0],\n",
+    "                  [0, 0, 0, .5,0,.5, 0, 0, 0, 0, 0],\n",
+    "                  [0, 0, 0, 0, .5,0,.5, 0, 0, 0, 0],\n",
+    "                  [0, 0, 0, 0, 0, .5,0,.5, 0, 0, 0],\n",
+    "                  [0, 0, 0, 0, 0, 0, .5,0,.5, 0, 0],\n",
+    "                  [0, 0, 0, 0, 0, 0, 0, .5,0,.5, 0],\n",
+    "                  [0, 0, 0, 0, 0, 0, 0, 0, .5,0,.5],\n",
+    "                  [0, 0, 0, 0, 0, 0, 0 ,0, 0, 0, 1]])\n",
+    "rw = RandomWalk(states, trans, payoff=[0,2,4,3,10,0,6,4,3,3,0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": "{'continue': [1, 2, 3, 5, 6, 7, 8], 'stop': [0, 4, 9, 10]}\n"
+    }
+   ],
+   "source": [
+    "best_policy = rw.best_policy()\n",
+    "print(best_policy)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Which implies that it's better to stop in $[0, 4, 9, 10]$ and continue otherwise."
+   ]
   }
  ],
  "metadata": {
diff --git a/README.md b/README.md
index 7e8cdbf..720a71e 100644
--- a/README.md
+++ b/README.md
@@ -30,8 +30,7 @@
 ## Overview
 
 <p align="justify">	
-Pyrandwalk is a tool for simulating random walks, calculate the probability of given state sequences and etc.
-Random walk is a representation of discrete-time, discrete-value Markov chain model using in stochastic processes.
+Pyrandwalk is an educational tool for simulating random walks, calculating the probability of given state sequences, etc. Random walk is a representation of the discrete-time, discrete-value Markov chain model used in stochastic processes.
 </p>
 
 
@@ -66,7 +65,7 @@ Random walk is a representation of discrete-time, discrete-value Markov chain mo
 ## Installation
 
 ### Source code
-- Download [Version 1.0](https://github.com/sadrasabouri/pyrandwalk/archive/v1.0.zip) or [Latest Source ](https://github.com/sadrasabouri/pyrandwalk/archive/dev.zip)
+- Download [Version 1.1](https://github.com/sadrasabouri/pyrandwalk/archive/v1.1.zip) or [Latest Source ](https://github.com/sadrasabouri/pyrandwalk/archive/dev.zip)
 - Run `pip install -r requirements.txt` or `pip3 install -r requirements.txt` (Need root access)
 - Run `python3 setup.py install` or `python setup.py install` (Need root access)
 
diff --git a/paper/paper.bib b/paper/paper.bib
new file mode 100644
index 0000000..e4167ff
--- /dev/null
+++ b/paper/paper.bib
@@ -0,0 +1,18 @@
+@book{lawler2018introduction,
+  title={Introduction to stochastic processes},
+  author={Lawler, Gregory F},
+  year={2018},
+  publisher={Chapman and Hall/CRC}
+}
+@article{Haghighi2017,
+  doi = {10.21105/joss.00331},
+  url = {https://doi.org/10.21105/joss.00331},
+  year  = {2017},
+  month = {sep},
+  publisher = {The Open Journal},
+  volume = {2},
+  number = {17},
+  author = {Sepand Haghighi},
+  title = {Pyrgg: Python Random Graph Generator},
+  journal = {The Journal of Open Source Software}
+}
diff --git a/paper/paper.md b/paper/paper.md
new file mode 100644
index 0000000..3e872f6
--- /dev/null
+++ b/paper/paper.md
@@ -0,0 +1,35 @@
+---
+title: 'PyRandWalk: A Python Library for Random Walks Simulaton'
+tags:
+  - Python
+  - educational
+  - simulation
+  - probability
+  - Markov chains
+  - stochastic processes
+  - reinforcement learning
+authors:
+  - name: Sadra Sabouri
+    orcid: 0000-0003-1047-2346
+    affiliation: 1
+affiliations:
+ - name: Sharif University of Technology
+   index: 1
+date: 15 August 2021
+bibliography: paper.bib
+
+---
+
+# Summary
+
+Pyrandwalk is an educational tool for simulating random walks, calculating the probability of given state sequences, etc. Random walk is a representation of the discrete-time, discrete-value Markov chain model used in stochastic processes.
+
+The first idea of this paper is inherited from Pyrgg.[@Haghighi2017]
+
+# Statement of need
+
+There are classes of problems in which occurrences did not deterministically happen. In these types of problems each of the probable next states will be assigned to a probability showing its chance of happening. In some cases we use a simplification called Markov Assumption which suggests that each state is just correlated to its last one so we don't take into consideration before states.
+
+These types of problems are not only used in pure mathematics but also in many nowadays hot topics like Reinforcement Learning, Bigram Language Models, etc. Because understanding the mathematics behind the random walks and Markov chains needs good knowledge in statistics and probability and most of the new learners can not enter into these fields we decided to solve this issue by developing a Python library which gives a simple intuition about these rather hard problems called PyRandWalk.[@lawler2018introduction]
+
+# References
diff --git a/pyrandwalk/pyrandwalk_obj.py b/pyrandwalk/pyrandwalk_obj.py
index 1dbb11e..e90ef2f 100644
--- a/pyrandwalk/pyrandwalk_obj.py
+++ b/pyrandwalk/pyrandwalk_obj.py
@@ -97,8 +97,10 @@ def run(self, ntimes=10, show=False):
         states = [state]
         probabilities = [1 / len(self.S)]
         for i in range(ntimes):
-            next_state = np.random.choice(self.S, p=self.P[state])
-            probability = self.P[state, next_state]
+            state_idx = self.S.index(state)
+            next_state = np.random.choice(self.S, p=self.P[state_idx])
+            next_state_idx = self.S.index(next_state)
+            probability = self.P[state_idx, next_state_idx]
             states.append(next_state)
             probabilities.append(probability)
             if show is True:
diff --git a/pyrandwalk/pyrandwalk_param.py b/pyrandwalk/pyrandwalk_param.py
index 4b00df6..fcdfcb7 100644
--- a/pyrandwalk/pyrandwalk_param.py
+++ b/pyrandwalk/pyrandwalk_param.py
@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 """Parameters and constants."""
-PYRANDWALK_VERSION = "1.0"
+PYRANDWALK_VERSION = "1.1"
 
 RUN_PRINT = "{0} --> {1}  (p = {2:.3f})"
 
diff --git a/pyrandwalk/pyrandwalk_util.py b/pyrandwalk/pyrandwalk_util.py
index 19a9b85..e9c4ede 100644
--- a/pyrandwalk/pyrandwalk_util.py
+++ b/pyrandwalk/pyrandwalk_util.py
@@ -18,7 +18,7 @@ def make_prob_dist(freq, precision=10**(-10)):
     zero_probe_idx = final_dist < precision
     final_dist[zero_probe_idx] = 0
     final_dist = final_dist / np.sum(final_dist)
-    return final_dist
+    return np.real(final_dist)
 
 
 def is_prob_dist(dist, precision=10**(-10)):
diff --git a/setup.py b/setup.py
index 161df3d..11aa6f5 100644
--- a/setup.py
+++ b/setup.py
@@ -30,14 +30,14 @@ def read_description():
 setup(
     name='pyrandwalk',
     packages=['pyrandwalk'],
-    version='1.0',
+    version='1.1',
     description='Python Library for Random Walks',
     long_description=read_description(),
     long_description_content_type='text/markdown',
     author='Sadra Sabouri',
     author_email='sabouri.sadra@gmail.com',
     url='https://github.com/sadrasabouri/pyrandwalk',
-    download_url='https://github.com/sadrasabouri/pyrandwalk/tarball/v1.0',
+    download_url='https://github.com/sadrasabouri/pyrandwalk/tarball/v1.1',
     keywords="random-walk markov-chain stochastic-processes",
     project_urls={
         'Source': 'https://github.com/sadrasabouri/pyrandwalk',
@@ -45,7 +45,7 @@ def read_description():
     install_requires=get_requires(),
     python_requires='>=3.5',
     classifiers=[
-        'Development Status :: 3 - Alpha',
+        'Development Status :: 4 - Beta',
         'Intended Audience :: Developers',
         'Natural Language :: English',
         'License :: OSI Approved :: MIT License',


Test patch:
diff --git a/Test/function_test.py b/Test/function_test.py
index c9b75b1..03028b8 100644
--- a/Test/function_test.py
+++ b/Test/function_test.py
@@ -119,6 +119,32 @@
 [0, 1, 2]
 >>> policy['continue']
 []
+>>> np.random.seed(0)
+>>> states = ['I', 'eat', 'food']
+>>> trans = np.array([[0.1, 0.8, 0.1], [0.15, 0.05, 0.8], [0.8, 0.15, 0.05]])
+>>> rw = RandomWalk(states, trans)
+>>> states, probs = rw.run(show=True)
+I --> eat  (p = 0.800)
+eat --> food  (p = 0.800)
+food --> eat  (p = 0.150)
+eat --> food  (p = 0.800)
+food --> I  (p = 0.800)
+I --> eat  (p = 0.800)
+eat --> food  (p = 0.800)
+food --> I  (p = 0.800)
+I --> eat  (p = 0.800)
+eat --> food  (p = 0.800)
+>>> states
+['I', 'eat', 'food', 'eat', 'food', 'I', 'eat', 'food', 'I', 'eat', 'food']
+>>> probs
+[0.3333333333333333, 0.8, 0.8, 0.15, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8, 0.8]
+>>> rw.final_dist()
+array([0.34133043, 0.33805889, 0.32061069])
+>>> policy = rw.best_policy()
+>>> policy['stop']
+['I', 'eat', 'food']
+>>> policy['continue']
+[]
 >>> from pyrandwalk.pyrandwalk_util import *
 >>> make_prob_dist([1, 2, 2])
 array([0.2, 0.4, 0.4])