Motion Simulator v1-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "30e38df8",
   "metadata": {},
   "source": [
    "# Motion Simulator version 1.0\n",
    "\n",
    "**Ver 1:**\n",
    "\n",
    "- Implement the input section (see plan on OneNote)\n",
    "- Implement the Processing (see plan on OneNote)\n",
    "- Output: print out the array of points "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6518bfb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import libraries\n",
    "\n",
    "# Numerical Python - Library for fast numerical vector and matrix calculations\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d30b38fc",
   "metadata": {},
   "source": [
    "## Input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e4228a32",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the numer of time steps\n",
    "N = 100\n",
    "\n",
    "# Set the time step\n",
    "dt = 0.1\n",
    "\n",
    "# Define function for 2D trajectory\n",
    "# Input: - time t\n",
    "# output: - position vector at time t \n",
    "def trajectory(t):\n",
    "    # linear motion with velocity (1,1)\n",
    "    return np.array([t,t])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b60264ad",
   "metadata": {},
   "source": [
    "##  Processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "99408a29",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialise variables\n",
    "t = 0\n",
    "points = np.zeros((N+1,2))\n",
    "\n",
    "# Calculate the N points on the trajectory for times with a time step dt apart\n",
    "for i in range(N+1):\n",
    "  # call function trajectory with time t\n",
    "  points[i] = trajectory(t)\n",
    "  # save the new point in array points\n",
    "  # update the time by the time step\n",
    "  t += dt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f266058",
   "metadata": {},
   "source": [
    "## Output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3bbcb783",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.   0. ]\n",
      " [ 0.1  0.1]\n",
      " [ 0.2  0.2]\n",
      " [ 0.3  0.3]\n",
      " [ 0.4  0.4]\n",
      " [ 0.5  0.5]\n",
      " [ 0.6  0.6]\n",
      " [ 0.7  0.7]\n",
      " [ 0.8  0.8]\n",
      " [ 0.9  0.9]\n",
      " [ 1.   1. ]\n",
      " [ 1.1  1.1]\n",
      " [ 1.2  1.2]\n",
      " [ 1.3  1.3]\n",
      " [ 1.4  1.4]\n",
      " [ 1.5  1.5]\n",
      " [ 1.6  1.6]\n",
      " [ 1.7  1.7]\n",
      " [ 1.8  1.8]\n",
      " [ 1.9  1.9]\n",
      " [ 2.   2. ]\n",
      " [ 2.1  2.1]\n",
      " [ 2.2  2.2]\n",
      " [ 2.3  2.3]\n",
      " [ 2.4  2.4]\n",
      " [ 2.5  2.5]\n",
      " [ 2.6  2.6]\n",
      " [ 2.7  2.7]\n",
      " [ 2.8  2.8]\n",
      " [ 2.9  2.9]\n",
      " [ 3.   3. ]\n",
      " [ 3.1  3.1]\n",
      " [ 3.2  3.2]\n",
      " [ 3.3  3.3]\n",
      " [ 3.4  3.4]\n",
      " [ 3.5  3.5]\n",
      " [ 3.6  3.6]\n",
      " [ 3.7  3.7]\n",
      " [ 3.8  3.8]\n",
      " [ 3.9  3.9]\n",
      " [ 4.   4. ]\n",
      " [ 4.1  4.1]\n",
      " [ 4.2  4.2]\n",
      " [ 4.3  4.3]\n",
      " [ 4.4  4.4]\n",
      " [ 4.5  4.5]\n",
      " [ 4.6  4.6]\n",
      " [ 4.7  4.7]\n",
      " [ 4.8  4.8]\n",
      " [ 4.9  4.9]\n",
      " [ 5.   5. ]\n",
      " [ 5.1  5.1]\n",
      " [ 5.2  5.2]\n",
      " [ 5.3  5.3]\n",
      " [ 5.4  5.4]\n",
      " [ 5.5  5.5]\n",
      " [ 5.6  5.6]\n",
      " [ 5.7  5.7]\n",
      " [ 5.8  5.8]\n",
      " [ 5.9  5.9]\n",
      " [ 6.   6. ]\n",
      " [ 6.1  6.1]\n",
      " [ 6.2  6.2]\n",
      " [ 6.3  6.3]\n",
      " [ 6.4  6.4]\n",
      " [ 6.5  6.5]\n",
      " [ 6.6  6.6]\n",
      " [ 6.7  6.7]\n",
      " [ 6.8  6.8]\n",
      " [ 6.9  6.9]\n",
      " [ 7.   7. ]\n",
      " [ 7.1  7.1]\n",
      " [ 7.2  7.2]\n",
      " [ 7.3  7.3]\n",
      " [ 7.4  7.4]\n",
      " [ 7.5  7.5]\n",
      " [ 7.6  7.6]\n",
      " [ 7.7  7.7]\n",
      " [ 7.8  7.8]\n",
      " [ 7.9  7.9]\n",
      " [ 8.   8. ]\n",
      " [ 8.1  8.1]\n",
      " [ 8.2  8.2]\n",
      " [ 8.3  8.3]\n",
      " [ 8.4  8.4]\n",
      " [ 8.5  8.5]\n",
      " [ 8.6  8.6]\n",
      " [ 8.7  8.7]\n",
      " [ 8.8  8.8]\n",
      " [ 8.9  8.9]\n",
      " [ 9.   9. ]\n",
      " [ 9.1  9.1]\n",
      " [ 9.2  9.2]\n",
      " [ 9.3  9.3]\n",
      " [ 9.4  9.4]\n",
      " [ 9.5  9.5]\n",
      " [ 9.6  9.6]\n",
      " [ 9.7  9.7]\n",
      " [ 9.8  9.8]\n",
      " [ 9.9  9.9]\n",
      " [10.  10. ]]\n"
     ]
    }
   ],
   "source": [
    "print(points)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f5b03e9",
   "metadata": {},
   "source": [
    "## Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d4d788ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "print(arr)\n",
    "\n",
    "print(type(arr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4b24934d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((100,2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "6d2ac133",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "29.900000000000155"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "points[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "04de6d55",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1;31mType:\u001b[0m            ndarray\n",
       "\u001b[1;31mString form:\u001b[0m     [29.9 29.9]\n",
       "\u001b[1;31mLength:\u001b[0m          2\n",
       "\u001b[1;31mFile:\u001b[0m            c:\\programdata\\anaconda3\\lib\\site-packages\\numpy\\__init__.py\n",
       "\u001b[1;31mDocstring:\u001b[0m       <no docstring>\n",
       "\u001b[1;31mClass docstring:\u001b[0m\n",
       "ndarray(shape, dtype=float, buffer=None, offset=0,\n",
       "        strides=None, order=None)\n",
       "\n",
       "An array object represents a multidimensional, homogeneous array\n",
       "of fixed-size items.  An associated data-type object describes the\n",
       "format of each element in the array (its byte-order, how many bytes it\n",
       "occupies in memory, whether it is an integer, a floating point number,\n",
       "or something else, etc.)\n",
       "\n",
       "Arrays should be constructed using `array`, `zeros` or `empty` (refer\n",
       "to the See Also section below).  The parameters given here refer to\n",
       "a low-level method (`ndarray(...)`) for instantiating an array.\n",
       "\n",
       "For more information, refer to the `numpy` module and examine the\n",
       "methods and attributes of an array.\n",
       "\n",
       "Parameters\n",
       "----------\n",
       "(for the __new__ method; see Notes below)\n",
       "\n",
       "shape : tuple of ints\n",
       "    Shape of created array.\n",
       "dtype : data-type, optional\n",
       "    Any object that can be interpreted as a numpy data type.\n",
       "buffer : object exposing buffer interface, optional\n",
       "    Used to fill the array with data.\n",
       "offset : int, optional\n",
       "    Offset of array data in buffer.\n",
       "strides : tuple of ints, optional\n",
       "    Strides of data in memory.\n",
       "order : {'C', 'F'}, optional\n",
       "    Row-major (C-style) or column-major (Fortran-style) order.\n",
       "\n",
       "Attributes\n",
       "----------\n",
       "T : ndarray\n",
       "    Transpose of the array.\n",
       "data : buffer\n",
       "    The array's elements, in memory.\n",
       "dtype : dtype object\n",
       "    Describes the format of the elements in the array.\n",
       "flags : dict\n",
       "    Dictionary containing information related to memory use, e.g.,\n",
       "    'C_CONTIGUOUS', 'OWNDATA', 'WRITEABLE', etc.\n",
       "flat : numpy.flatiter object\n",
       "    Flattened version of the array as an iterator.  The iterator\n",
       "    allows assignments, e.g., ``x.flat = 3`` (See `ndarray.flat` for\n",
       "    assignment examples; TODO).\n",
       "imag : ndarray\n",
       "    Imaginary part of the array.\n",
       "real : ndarray\n",
       "    Real part of the array.\n",
       "size : int\n",
       "    Number of elements in the array.\n",
       "itemsize : int\n",
       "    The memory use of each array element in bytes.\n",
       "nbytes : int\n",
       "    The total number of bytes required to store the array data,\n",
       "    i.e., ``itemsize * size``.\n",
       "ndim : int\n",
       "    The array's number of dimensions.\n",
       "shape : tuple of ints\n",
       "    Shape of the array.\n",
       "strides : tuple of ints\n",
       "    The step-size required to move from one element to the next in\n",
       "    memory. For example, a contiguous ``(3, 4)`` array of type\n",
       "    ``int16`` in C-order has strides ``(8, 2)``.  This implies that\n",
       "    to move from element to element in memory requires jumps of 2 bytes.\n",
       "    To move from row-to-row, one needs to jump 8 bytes at a time\n",
       "    (``2 * 4``).\n",
       "ctypes : ctypes object\n",
       "    Class containing properties of the array needed for interaction\n",
       "    with ctypes.\n",
       "base : ndarray\n",
       "    If the array is a view into another array, that array is its `base`\n",
       "    (unless that array is also a view).  The `base` array is where the\n",
       "    array data is actually stored.\n",
       "\n",
       "See Also\n",
       "--------\n",
       "array : Construct an array.\n",
       "zeros : Create an array, each element of which is zero.\n",
       "empty : Create an array, but leave its allocated memory unchanged (i.e.,\n",
       "        it contains \"garbage\").\n",
       "dtype : Create a data-type.\n",
       "\n",
       "Notes\n",
       "-----\n",
       "There are two modes of creating an array using ``__new__``:\n",
       "\n",
       "1. If `buffer` is None, then only `shape`, `dtype`, and `order`\n",
       "   are used.\n",
       "2. If `buffer` is an object exposing the buffer interface, then\n",
       "   all keywords are interpreted.\n",
       "\n",
       "No ``__init__`` method is needed because the array is fully initialized\n",
       "after the ``__new__`` method.\n",
       "\n",
       "Examples\n",
       "--------\n",
       "These examples illustrate the low-level `ndarray` constructor.  Refer\n",
       "to the `See Also` section above for easier ways of constructing an\n",
       "ndarray.\n",
       "\n",
       "First mode, `buffer` is None:\n",
       "\n",
       ">>> np.ndarray(shape=(2,2), dtype=float, order='F')\n",
       "array([[0.0e+000, 0.0e+000], # random\n",
       "       [     nan, 2.5e-323]])\n",
       "\n",
       "Second mode:\n",
       "\n",
       ">>> np.ndarray((2,), buffer=np.array([1,2,3]),\n",
       "...            offset=np.int_().itemsize,\n",
       "...            dtype=int) # offset = 1*itemsize, i.e. skip first element\n",
       "array([2, 3])\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "points?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "0a84a418",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0.])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "points[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11f2079a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}