Random Walk R package (RandomWalk)

  ggplot2::ggplot(RandomWalk::srwalk(time_to_maturity = 4, scale = 100, seed = 5), 
                  ggplot2::aes(time_periods, random_walk_path)) +
  ggplot2::geom_line() +
  ggplot2::theme(axis.line = ggplot2::element_blank(), 
                 axis.text.x = ggplot2::element_blank(),
                 axis.text.y = ggplot2::element_blank(), 
                 axis.ticks = ggplot2::element_blank(),
                 axis.title.x = ggplot2::element_blank(),
                 axis.title.y = ggplot2::element_blank(), 
                 legend.position = "none"
                 # panel.background = ggplot2::element_blank(),
                 # panel.border = ggplot2::element_blank(),
                 # panel.grid.major = ggplot2::element_blank(),
                 # panel.grid.minor = ggplot2::element_blank(), 
                 # plot.background = ggplot2::element_blank()
                 )

Introduction

The aim of this package is to provide a way to create and manipulate either discrete Random Walk or Brownian Motion or even list of them. It would be noticed that the construction of Brownian Motion is made by taking the limit of a Scaled Random Walk as its step size goes to zero. The Brownian Motion could therefore be read as a continously stepped Random Walk.

By convention the time step size of a Random Walk (with no scale defined) is 1. It means that the value of the Non-Scaled Random Walk updates each time increment of one. Furthermore the increments of a Non-Scaled (Unscaled) Random Walk are either 1 or -1, depending on chance (with a Symmetric Non-Scaled Random Walk, getting 1 or -1 as increment is just as likely to occur.) All that preceed points out that at each time step the value of the random walk is sure to be the former one plus or minus 1.

Unlike the Unscaled Random Walk the increments of a Scaled Random Walk is defined by the following formula: $\sqrt{scale}^{-1}$. Further more its time step size is no longer one but are defined by the value of scale and is $\frac{time_to_maturity}{scale}$

Finally and Also in contrast with the Scaled / Unscaled Random Walk, the Brownian Motion has neither natural increments not discrete time step. Each value taken by its increments, from time $t_k$ to $t_l$ (with $k < l$) is randomly computed using the Normal Law with $mean = 0$ and $variance = t_l - t_k$: $$N \sim \left(0, t_l - t_k \right)$$

The package also implements some properties of the Random Walk and Brownian Motion Either to validate some test cases or directly for added functionalities.

Among the following ones:

:exclamation: The special case of Brownian Motion and Random Walk is that they incur the same Quadratic Variation among all the different paths.

Notes

For more technical informations and example of usage of the RandomWalk package, feel free to have a look inside the vignettes repository.

Functions provided by the package

Key functions

Getters and Setters

Description of the functions as they was created and defined

The following lines do not fully give a bunch of examples of usage of the package functions.

Instead of giving such examples, they provide an brief description of the arguments the package functions take as well as the way these agruments are defined (along with the default value they take)

srwalkGenerator

Summary

This function return a R list of multiple data.frame s. Each one contains the following variables:

  1. time_periods: Ordered vector from 0 up to T(time_to_maturity). It represents a partition of the period of time where the random walk evolved. The partition step of this vector depends on the variable scale.
  2. random_walk_path: Provides all the random values taken by the sampled random walk.

Arguments

| Arguments | Default | Description | |---|---|---| | time_to_maturity | 100 | Final time up to the Random Walk goes | | prob | 0.5 | Probability of occurence of head and tail for each step | | scale | 1 | Define the partition of the time period and the scale of up and down factors of the increments, following the rule: $\sqrt{scale}^{-1}$| | seed | 1 | It fixes initial value of the pseudo random number generation in order to get reproducible experiments. | | n | 1 | Number of Random Walk generated by the function |

Example of usage

library(RandomWalk)
# The following line set the variable @sampled with a list of 20
# data.frame of Adapted random walk.
Sampled <- srwalkGenerator(time_to_maturity = 500, 
                           seed = 7,
                           n = 20)

The previous Sampled Random Walks could be reduce to its graphical representation:

ggplot2::ggplot(dplyr::bind_rows(Sampled, .id = "uid")
                , ggplot2::aes(x = time_periods, 
                               y = random_walk_path,
                               group = uid)) +
ggplot2::geom_line(alpha = .5) + 
ggplot2::labs(title = "Random Walk paths from multiple random experiments", 
              caption = "Random Walks",
              x = 'Time periods',
              y = 'Random Walk')

srwalk

Summary

This function is defined to be the constructor of a unique Sampled Random Walk. It returns a unique S3 object with classes as follow:

```{R echo=FALSE} c("sampled_randomwalk", "data.frame")

srwalk() outputs a data.frame which contains each time step along 
with the associated Sampled Random Walk value, arranged as follow:

1. *time_periods*: Ordered vector from 0 up to T(time_to_maturity). It represents 
  a partition of the period of time where the random walk evolved. 
  The partition step of this vector depends on the variable _scale_.
1. *random_walk_path*: Provides all the random values taken by the sampled 
    random walk.  


#### Arguments

| Arguments | Default | Description |
|---|---|---|
| time_to_maturity | 100 | Final time up to the Random Walk goes |
| prob | 0.5 | Probability of occurence of head and tail for each step |
| scale | 1 | Define the partition of the time period and the scale of up and down factors of the increments, following the rule: $\sqrt{scale}^{-1}$|
| seed | 1 | It fixes initial value of the pseudo random number generation in order to get reproducible experiments. |
| n | 1 | Number of Random Walk generated by the function |


#### Example of usage

```r
library(RandomWalk)
# Generate a 150 steps Unscale Symmetric Random Walk
srw <- srwalk(time_to_maturity =  150)
library(knitr)
library(kableExtra)
kable(head(srw))

trwalkGenerator

| Arguments | Default | Description | |---|---|---| | time_to_maturity | 100 | Final time up to the Random Walk goes | | prob | 0.5 | Probability of occurence of head and tail for each step | | scale | 1 | Define the partition of the time period. The scale of up and down factors of the Random Walk follows the rule: $sqrt(scale)^{-1}$ | | full | FALSE | Number of Brownian Motion generated by the function |

This function returns all the values the Random Walk could take along with their associated probabilities. Either the argument full is set to FALSE and only the last time period is return or it is set to TRUE and all the periods are then provided.

It returns a uniq S3 object with classes as follow:

```{R echo=FALSE} class(trwalkGenerator())

#### Example of usage

```r
library(RandomWalk)
# Generate the distribution of a 150 steps Symmetric Random Walk
trwalkGenerator(time_to_maturity =  150, full = T)

# Generate the distribution of a Symmetric Random walk from time 0 to 4.
# It only returns the last time distribution along with the associated 
# probabilities
trwalkGenerator(time_to_maturity = 4, scale = 2)

The last example gives the following result:

library(knitr)
library(kableExtra)
kable(trwalkGenerator(time_to_maturity = 4, scale = 2) )

With expectation and variance:

# Declare the Theoretical Random Walk
trw <- trwalkGenerator(time_to_maturity = 4, scale = 2) 
# Expectation:
(Exp <- sum(trw[, 'Pr'] * trw[, 'Mt']))

# Variance (Which is, according to the theory, equal to time_to_maturity): 
sum(trw[, 'Pr'] * trw[, 'Mt'] ^ 2) - Exp

sbmotionGenerator

| Arguments | Default | Description | |---|---|---| | time_to_maturity | Maximum time up to the Brownian Motion evolves | | scale | It defines the time partition between each unit of time. For instance if the scale is 100, the time step [0,1] will be cut in 100 parts. | | seed | With same seed, 2 exeriments will(would, in fact not yet the case when the param scale is different) give the same output. It therefore provides reproducibles experiments. |

This function returns a R list of multiple data.frames. Each one contains the following variables:

  1. time_period: Ordered vector from 0 up to T(time_to_maturity). It represents the time period in which the Brownian Motion evolved. The partition step of this vector depends on the variable scale.
  2. brownian_motion_path: All random values taken by the Sampled Brownian Motion.

Example of usage

library(RandomWalk)
# The following line set the variable @sampled with a list of 20
# data.frame of Adapted random walk.
Sampled <- sbmotionGenerator(time_to_maturity = 4, scale = 100, n = 30)

The above example generates a list of 5 specifics Brownian Motion. To get an idea of what it represents, the following chart presents the pathes of those previous Brownian motion:

  ggplot2::ggplot(Sampled[[1]], 
                  ggplot2::aes(time_periods, brownian_motion_path)) +
  ggplot2::geom_point() +
  ggplot2::labs(title = 'Uniq Brownian Motion path with time to maturity fixed at 4',
                caption = 'Uniq Brownian Motion path',
                x = 'Time period',
                y = 'Brownian motion')
ggplot2::ggplot(dplyr::bind_rows(Sampled, .id = "uniqueID"), 
                ggplot2::aes(x = time_periods, y = brownian_motion_path, group = uniqueID)) + 
  ggplot2::geom_point(ggplot2::aes(colour = uniqueID)) + 
  ggplot2::theme(legend.position = 'none') +
  ggplot2::labs(title = 'Multiple Brownian Motions path with time to maturity fixed at 4',
                caption = 'Multiple Brownian Motions paths',
                x = 'Time period',
                y = 'Brownian motion')

sbmotion

| Arguments | Default | Description | |---|---|---| | time_to_maturity | Maximum time up to the Brownian Motion evolves | | scale | It defines the time partition between each unit of time. For instance if the scale is 100, the time step [0,1] will be cut in 100 parts. | | seed | With same seed, 2 exeriments will(would, in fact not yet the case when the param scale is different) give the same output. It therefore provides reproducibles experiments. | | n | Number of samples generated by the function |

This function returns a data.frame containing the following variables:

  1. time_period: Ordered vector from 0 up to T(time_to_maturity). It represents the time period in which the Brownian Motion evolved. The partition step of this vector depends on the variable scale.
  2. brownian_motion_path: All random values taken by the Sampled Brownian Motion.

Example of usage

library(RandomWalk)
# The following line set the variable @sampled with a list of 20
# data.frame of Adapted random walk.
Sampled <- sbmotion(time_to_maturity = 4, scale = 100)

The above example generates a list of 5 specifics Brownian Motion. To get an idea of what it represents, the following chart presents the pathes of those previous Brownian motion:

  ggplot2::ggplot(Sampled, 
                  ggplot2::aes(time_periods, brownian_motion_path)) +
  ggplot2::geom_point() +
  ggplot2::labs(title = 'Brownian Motion path with time to maturity fixed at 4',
                caption = 'Brownian Motion path',
                x = 'Time period',
                y = 'Brownian Motion')


AnthonyTedde/RandomProcesses documentation built on Dec. 14, 2021, 10:39 a.m.