randomwalk.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from copy import deepcopy\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(\"/Users/zargham/Documents/GitHub/cadcad-ri\")\n",
    "from cadcad.spaces import space, EmptySpace #, Bit, Real\n",
    "from cadcad.dynamics import block\n",
    "from cadcad.points import Point\n",
    "from cadcad.systems import Experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "@space\n",
    "class CartesianPlane:\n",
    "    x:float\n",
    "    y:float\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "cadcad.points.Point[cadcad.spaces.space.<locals>.NewSpace]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Point[CartesianPlane]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "@block\n",
    "def randomVectorGenerator(input:Point[EmptySpace])->Point[CartesianPlane]:\n",
    "    #generate RNG\n",
    "    dx = np.random.randn()\n",
    "    dy = np.random.randn()\n",
    "\n",
    "    data = {'x':dx, 'y':dy}\n",
    "\n",
    "    return Point(CartesianPlane, data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "@block\n",
    "def randomWalk(state:Point[CartesianPlane], input:Point[CartesianPlane])->Point[CartesianPlane]:\n",
    "\n",
    "    xplus = state['x'] + input['x']\n",
    "    yplus = state['y'] + input['x']\n",
    "\n",
    "    data = {'x':xplus, 'y':yplus}\n",
    "\n",
    "    return Point(CartesianPlane, data)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[cadcad.points.Point[cadcad.spaces.space.<locals>.NewSpace], cadcad.points.Point[cadcad.spaces.space.<locals>.NewSpace]]\n"
     ]
    }
   ],
   "source": [
    "print(randomWalk.domain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "initial_state = Point(CartesianPlane, {'x':0.0, 'y':0.0})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point in space CartesianPlane has data\n",
      "{\n",
      "    \"x\": 0.0,\n",
      "    \"y\": 0.0\n",
      "}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(initial_state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#experiment_params = {\"iteration_n\": 2, \"steps\": 10}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#experiment_params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Empty space EmptySpace\n"
     ]
    }
   ],
   "source": [
    "print(EmptySpace) #shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cadcad.points.Point[cadcad.spaces.space.<locals>.NewSpace]\n"
     ]
    }
   ],
   "source": [
    "print(Point[EmptySpace]) #class of points of that shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point in space EmptySpace has data\n",
      "{}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(Point(EmptySpace, {})) #instance of point of that shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point in space EmptySpace has data\n",
      "{}\n",
      "\n",
      "Point in space EmptySpace has data\n",
      "{}\n",
      "\n",
      "Point in space EmptySpace has data\n",
      "{}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#concrete set of points of that shape (the empty shape on has one point so they are all the same)\n",
    "collection_of_emptypoints = set([Point(EmptySpace, {}) for _ in range(3)]) \n",
    "for pt in collection_of_emptypoints:\n",
    "    print(pt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Space CartesianPlane has dimensions {'x': 'float', 'y': 'float'}\n"
     ]
    }
   ],
   "source": [
    "print(CartesianPlane) #shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cadcad.points.Point[cadcad.spaces.space.<locals>.NewSpace]\n"
     ]
    }
   ],
   "source": [
    "print(Point[CartesianPlane]) #class of points of that shape -- \"abstract set\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point in space CartesianPlane has data\n",
      "{\n",
      "    \"x\": 0.5,\n",
      "    \"y\": -7.0\n",
      "}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(Point(CartesianPlane, {'x':0.5, 'y':-7.0})) #instance of point of that shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Point in space CartesianPlane has data\n",
      "{\n",
      "    \"x\": 0.6181195890258943,\n",
      "    \"y\": -0.9761076376426581\n",
      "}\n",
      "\n",
      "Point in space CartesianPlane has data\n",
      "{\n",
      "    \"x\": 0.5537716794684937,\n",
      "    \"y\": 0.6946261412032961\n",
      "}\n",
      "\n",
      "Point in space CartesianPlane has data\n",
      "{\n",
      "    \"x\": -0.05110896377507021,\n",
      "    \"y\": 1.263925859933002\n",
      "}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#concrete collection of instances of points of this shape, \"concrete set\"\n",
    "collection_of_points = set([randomVectorGenerator(Point(EmptySpace, {})) for _ in range(3) ])\n",
    "for pt in collection_of_points:\n",
    "    print(pt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'x': -1.037178561217844, 'y': -1.037178561217844}\n",
      "{'x': -0.42779422009898294, 'y': -0.42779422009898294}\n",
      "{'x': 0.7955975598431376, 'y': 0.7955975598431376}\n",
      "{'x': 2.1557623704417295, 'y': 2.1557623704417295}\n",
      "{'x': 0.06482418542826274, 'y': 0.06482418542826274}\n",
      "{'x': 1.4444974656943788, 'y': 1.4444974656943788}\n",
      "{'x': 0.9600788980117521, 'y': 0.9600788980117521}\n",
      "{'x': 2.6600463924140376, 'y': 2.6600463924140376}\n",
      "{'x': 0.34957465463001824, 'y': 0.34957465463001824}\n",
      "{'x': 1.2886564514915821, 'y': 1.2886564514915821}\n"
     ]
    }
   ],
   "source": [
    " # this \"concrete set\" of points is a trajectory since it represents the evolution of system over time\n",
    " # not all concrete sets are trajectories, but all trajectories are concrete sets.\n",
    " # the trajectories class should be \n",
    "points = [initial_state]\n",
    "for t in range(1,11):\n",
    "    rng = randomVectorGenerator(Point(EmptySpace, {}))\n",
    "    pt = randomWalk(state=points[t-1], input=rng)\n",
    "    print(pt.data)\n",
    "    points.append(pt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "concreteSetOfCartesianPoints = set[Point[CartesianPlane]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set[cadcad.points.Point[cadcad.spaces.space.<locals>.NewSpace]]\n"
     ]
    }
   ],
   "source": [
    "print(concreteSetOfCartesianPoints)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "orderedListOfCartesianPoints = list[Point[CartesianPlane]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py10",
   "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.4"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "1a8de16e480ce6c374d7a7a0f904964a05926e5b58eea6a17940b28a68c7d599"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}