,
Antti Rask [aut, cph]| Title: | Generate Random Walks Compatible with the 'tidyverse' |
|---|---|
| Description: | Generates random walks of various types by providing a set of functions that are compatible with the 'tidyverse'. The functions provided in the package make it simple to create random walks with a variety of properties, such as how many simulations to run, how many steps to take, and the distribution of random walk itself. |
| Authors: | Steven Sanderson [aut, cre, cph]
,
Antti Rask [aut, cph] |
| Maintainer: | Steven Sanderson <[email protected]> |
| License: | MIT + file LICENSE |
| Version: | 0.1.0 |
| Built: | 2024-09-15 06:17:43 UTC |
| Source: | https://github.com/spsanderson/RandomWalker |
Create a Brownian Motion Tibble
brownian_motion( .num_walks = 25, .n = 100, .delta_time = 1, .initial_value = 0, .return_tibble = TRUE )brownian_motion( .num_walks = 25, .n = 100, .delta_time = 1, .initial_value = 0, .return_tibble = TRUE )
.num_walks |
Total number of simulations. |
.n |
Total time of the simulation. |
.delta_time |
Time step size. |
.initial_value |
Integer representing the initial value. |
.return_tibble |
The default is TRUE. If set to FALSE then an object of class matrix will be returned. |
Brownian Motion, also known as the Wiener process, is a continuous-time random process that describes the random movement of particles suspended in a fluid. It is named after the physicist Robert Brown, who first described the phenomenon in 1827.
The equation for Brownian Motion can be represented as:
W(t) = W(0) + sqrt(t) * Z
Where W(t) is the Brownian motion at time t, W(0) is the initial value of the Brownian motion, sqrt(t) is the square root of time, and Z is a standard normal random variable.
Brownian Motion has numerous applications, including modeling stock prices in financial markets, modeling particle movement in fluids, and modeling random walk processes in general. It is a useful tool in probability theory and statistical analysis.
A tibble/matrix
Steven P. Sanderson II, MPH
Other Generator Functions:
discrete_walk(),
geometric_brownian_motion(),
random_normal_drift_walk(),
random_normal_walk()
library(ggplot2) set.seed(123) brownian_motion() set.seed(123) brownian_motion() |> ggplot(aes(x = x, y = y, group = walk_number, color = walk_number)) + geom_line() + labs(title = "Brownian Motion", x = "Time", y = "Value") + theme_minimal() + theme(legend.position = "none")library(ggplot2) set.seed(123) brownian_motion() set.seed(123) brownian_motion() |> ggplot(aes(x = x, y = y, group = walk_number, color = walk_number)) + geom_line() + labs(title = "Brownian Motion", x = "Time", y = "Value") + theme_minimal() + theme(legend.position = "none")
A function to return the cumulative geometric mean of a vector.
cgmean(.x)cgmean(.x)
.x |
A numeric vector |
A function to return the cumulative geometric mean of a vector.
exp(cummean(log(.x)))
A numeric vector
Steven P. Sanderson II, MPH
Other Vector Function:
chmean(),
ckurtosis(),
cmean(),
cmedian(),
crange(),
csd(),
cskewness(),
cvar(),
euclidean_distance(),
kurtosis_vec(),
rw_range(),
skewness_vec()
x <- mtcars$mpg cgmean(x)x <- mtcars$mpg cgmean(x)
A function to return the cumulative harmonic mean of a vector.
chmean(.x)chmean(.x)
.x |
A numeric vector |
A function to return the cumulative harmonic mean of a vector.
1 / (cumsum(1 / .x))
A numeric vector
Steven P. Sanderson II, MPH
Other Vector Function:
cgmean(),
ckurtosis(),
cmean(),
cmedian(),
crange(),
csd(),
cskewness(),
cvar(),
euclidean_distance(),
kurtosis_vec(),
rw_range(),
skewness_vec()
x <- mtcars$mpg chmean(x)x <- mtcars$mpg chmean(x)
A function to return the cumulative kurtosis of a vector.
ckurtosis(.x)ckurtosis(.x)
.x |
A numeric vector |
A function to return the cumulative kurtosis of a vector.
A numeric vector
Steven P. Sanderson II, MPH
Other Vector Function:
cgmean(),
chmean(),
cmean(),
cmedian(),
crange(),
csd(),
cskewness(),
cvar(),
euclidean_distance(),
kurtosis_vec(),
rw_range(),
skewness_vec()
x <- mtcars$mpg ckurtosis(x)x <- mtcars$mpg ckurtosis(x)
A function to return the cumulative mean of a vector.
cmean(.x)cmean(.x)
.x |
A numeric vector |
A function to return the cumulative mean of a vector. It uses dplyr::cummean()
as the basis of the function.
A numeric vector
Steven P. Sanderson II, MPH
Other Vector Function:
cgmean(),
chmean(),
ckurtosis(),
cmedian(),
crange(),
csd(),
cskewness(),
cvar(),
euclidean_distance(),
kurtosis_vec(),
rw_range(),
skewness_vec()
x <- mtcars$mpg cmean(x)x <- mtcars$mpg cmean(x)
A function to return the cumulative median of a vector.
cmedian(.x)cmedian(.x)
.x |
A numeric vector |
A function to return the cumulative median of a vector.
A numeric vector
Steven P. Sanderson II, MPH
Other Vector Function:
cgmean(),
chmean(),
ckurtosis(),
cmean(),
crange(),
csd(),
cskewness(),
cvar(),
euclidean_distance(),
kurtosis_vec(),
rw_range(),
skewness_vec()
x <- mtcars$mpg cmedian(x)x <- mtcars$mpg cmedian(x)
Converts a snake_case string to Title Case.
convert_snake_to_title_case(string)convert_snake_to_title_case(string)
string |
A character string in snake_case format. |
This function is useful for formatting strings in a more readable way, especially when dealing with variable names or identifiers that use snake_case. This function takes a snake_case string and converts it to Title Case. It replaces underscores with spaces, capitalizes the first letter of each word, and replaces the substring "cum" with "cumulative" for better readability.
A character string converted to Title Case.
Antti Lennart Rask
Other Utility Functions:
generate_caption(),
rand_walk_helper()
convert_snake_to_title_case("hello_world") # "Hello World" convert_snake_to_title_case("this_is_a_test") # "This Is A Test" convert_snake_to_title_case("cumulative_sum") # "Cumulative Sum"convert_snake_to_title_case("hello_world") # "Hello World" convert_snake_to_title_case("this_is_a_test") # "This Is A Test" convert_snake_to_title_case("cumulative_sum") # "Cumulative Sum"
A function to return the cumulative range of a vector.
crange(.x)crange(.x)
.x |
A numeric vector |
A function to return the cumulative range of a vector. It uses max(.x[1:k]) - min(.x[1:k]) as
the basis of the function.
A numeric vector
Steven P. Sanderson II, MPH
Other Vector Function:
cgmean(),
chmean(),
ckurtosis(),
cmean(),
cmedian(),
csd(),
cskewness(),
cvar(),
euclidean_distance(),
kurtosis_vec(),
rw_range(),
skewness_vec()
x <- mtcars$mpg crange(x)x <- mtcars$mpg crange(x)
A function to return the cumulative standard deviation of a vector.
csd(.x)csd(.x)
.x |
A numeric vector |
A function to return the cumulative standard deviation of a vector.
A numeric vector. Note: The first entry will always be NaN.
Steven P. Sanderson II, MPH
Other Vector Function:
cgmean(),
chmean(),
ckurtosis(),
cmean(),
cmedian(),
crange(),
cskewness(),
cvar(),
euclidean_distance(),
kurtosis_vec(),
rw_range(),
skewness_vec()
x <- mtcars$mpg csd(x)x <- mtcars$mpg csd(x)
A function to return the cumulative skewness of a vector.
cskewness(.x)cskewness(.x)
.x |
A numeric vector |
A function to return the cumulative skewness of a vector.
A numeric vector
Steven P. Sanderson II, MPH
Other Vector Function:
cgmean(),
chmean(),
ckurtosis(),
cmean(),
cmedian(),
crange(),
csd(),
cvar(),
euclidean_distance(),
kurtosis_vec(),
rw_range(),
skewness_vec()
x <- mtcars$mpg cskewness(x)x <- mtcars$mpg cskewness(x)
A function to return the cumulative variance of a vector.
cvar(.x)cvar(.x)
.x |
A numeric vector |
A function to return the cumulative variance of a vector.
exp(cummean(log(.x)))
A numeric vector. Note: The first entry will always be NaN.
Steven P. Sanderson II, MPH
Other Vector Function:
cgmean(),
chmean(),
ckurtosis(),
cmean(),
cmedian(),
crange(),
csd(),
cskewness(),
euclidean_distance(),
kurtosis_vec(),
rw_range(),
skewness_vec()
x <- mtcars$mpg cvar(x)x <- mtcars$mpg cvar(x)
The discrete_walk function generates multiple random walks over discrete time periods.
Each step in the walk is determined by a probabilistic sample from specified upper and lower bounds.
This function is useful for simulating stochastic processes, such as stock price movements or
other scenarios where outcomes are determined by a random process.
discrete_walk( .num_walks = 25, .n = 100, .upper_bound = 1, .lower_bound = -1, .upper_probability = 0.5, .initial_value = 100 )discrete_walk( .num_walks = 25, .n = 100, .upper_bound = 1, .lower_bound = -1, .upper_probability = 0.5, .initial_value = 100 )
.num_walks |
Total number of simulations. |
.n |
Total time of the simulation. |
.upper_bound |
The upper bound of the random walk. |
.lower_bound |
The lower bound of the random walk. |
.upper_probability |
The probability of the upper bound. Default is 0.5. The lower bound is calculated as 1 - .upper_probability. |
.initial_value |
The initial value of the random walk. Default is 100. |
The function discrete_walk simulates random walks for a specified number of simulations
(.num_walks) over a given total time (.n). Each step in the walk is either the upper
bound or the lower bound, determined by a probability (.upper_probability). The initial
value of the walk is set by the user (.initial_value), and the cumulative sum, product,
minimum, and maximum of the steps are calculated for each walk. The results are returned
in a tibble with detailed attributes, including the parameters used for the simulation.
A tibble containing the simulated walks, with columns for the walk number, time period, and various cumulative metrics (sum, product, min, max).
Steven P. Sanderson II, MPH
Other Generator Functions:
brownian_motion(),
geometric_brownian_motion(),
random_normal_drift_walk(),
random_normal_walk()
library(ggplot2) set.seed(123) discrete_walk() set.seed(123) discrete_walk(.num_walks = 30, .n = 250, .upper_probability = 0.55) |> ggplot(aes(x = x, y = cum_sum)) + geom_line(aes(group = walk_number), alpha = .618, color = "steelblue") + theme_minimal() + theme(legend.position = "none") + geom_smooth(method = "lm", se = FALSE)library(ggplot2) set.seed(123) discrete_walk() set.seed(123) discrete_walk(.num_walks = 30, .n = 250, .upper_probability = 0.55) |> ggplot(aes(x = x, y = cum_sum)) + geom_line(aes(group = walk_number), alpha = .618, color = "steelblue") + theme_minimal() + theme(legend.position = "none") + geom_smooth(method = "lm", se = FALSE)
A function to calculate the Euclidean distance between two vectors.
euclidean_distance(.data, .x, .y, .pull_vector = FALSE)euclidean_distance(.data, .x, .y, .pull_vector = FALSE)
.data |
A data frame |
.x |
A numeric vector |
.y |
A numeric vector |
.pull_vector |
A boolean of TRUE or FALSE. Default is FALSE which will augment the distance to the data frame. TRUE will return a vector of the distances as the return. |
A function to calculate the Euclidean distance between two vectors. It uses
the formula sqrt((x - lag(x))^2 + (y - lag(y))^2). The function uses augments
the data frame with a new column called distance.
A numeric Vector of ditances
Steven P. Sanderson II, MPH
Other Vector Function:
cgmean(),
chmean(),
ckurtosis(),
cmean(),
cmedian(),
crange(),
csd(),
cskewness(),
cvar(),
kurtosis_vec(),
rw_range(),
skewness_vec()
set.seed(123) df <- rw30() euclidean_distance(df, x, y) euclidean_distance(df, x, y, TRUE) |> head(10)set.seed(123) df <- rw30() euclidean_distance(df, x, y) euclidean_distance(df, x, y, TRUE) |> head(10)
Generates a caption string based on provided attributes.
generate_caption(attributes)generate_caption(attributes)
attributes |
A list containing various attributes that may include
|
This function is useful for creating descriptive captions for plots or outputs based on the attributes provided. It ensures that only non-null attributes are included in the caption. This function constructs a caption string by checking various attributes provided in a list. It formats the caption based on the presence of specific attributes, such as dimensions, number of steps, and statistical parameters like mu and standard deviation (sd).
A character string representing the generated caption. If no attributes are provided, it returns an empty string.
Antti Lennart Rask
Other Utility Functions:
convert_snake_to_title_case(),
rand_walk_helper()
attrs <- list(dimension = 3, num_steps = 100, mu = 0.5, sd = 1.2) generate_caption(attrs) # "3 dimensions, 100 steps, mu = 0.5, sd = 1.2." attrs <- list(dimension = NULL, num_steps = 50, mu = NULL, sd = 2.0) generate_caption(attrs) # "50 steps, sd = 2.0."attrs <- list(dimension = 3, num_steps = 100, mu = 0.5, sd = 1.2) generate_caption(attrs) # "3 dimensions, 100 steps, mu = 0.5, sd = 1.2." attrs <- list(dimension = NULL, num_steps = 50, mu = NULL, sd = 2.0) generate_caption(attrs) # "50 steps, sd = 2.0."
Create a Geometric Brownian Motion.
geometric_brownian_motion( .num_walks = 25, .n = 100, .mu = 0, .sigma = 0.1, .initial_value = 100, .delta_time = 0.003, .return_tibble = TRUE )geometric_brownian_motion( .num_walks = 25, .n = 100, .mu = 0, .sigma = 0.1, .initial_value = 100, .delta_time = 0.003, .return_tibble = TRUE )
.num_walks |
Total number of simulations. |
.n |
Total time of the simulation, how many |
.mu |
Expected return |
.sigma |
Volatility |
.initial_value |
Integer representing the initial value. |
.delta_time |
Time step size. |
.return_tibble |
The default is TRUE. If set to FALSE then an object of class matrix will be returned. |
Geometric Brownian Motion (GBM) is a statistical method for modeling the evolution of a given financial asset over time. It is a type of stochastic process, which means that it is a system that undergoes random changes over time.
GBM is widely used in the field of finance to model the behavior of stock prices, foreign exchange rates, and other financial assets. It is based on the assumption that the asset's price follows a random walk, meaning that it is influenced by a number of unpredictable factors such as market trends, news events, and investor sentiment.
The equation for GBM is:
dS/S = mdt + sdW
where S is the price of the asset, t is time, m is the expected return on the asset, s is the volatility of the asset, and dW is a small random change in the asset's price.
GBM can be used to estimate the likelihood of different outcomes for a given asset, and it is often used in conjunction with other statistical methods to make more accurate predictions about the future performance of an asset.
This function provides the ability of simulating and estimating the parameters of a GBM process. It can be used to analyze the behavior of financial assets and to make informed investment decisions.
A tibble/matrix
Steven P. Sanderson II, MPH
Other Generator Functions:
brownian_motion(),
discrete_walk(),
random_normal_drift_walk(),
random_normal_walk()
library(ggplot2) set.seed(123) geometric_brownian_motion() set.seed(123) geometric_brownian_motion() |> ggplot(aes(x = x, y = y, group = walk_number, color = walk_number)) + geom_line() + labs(title = "Geometric Brownian Motion", x = "Time", y = "Value") + theme_minimal() + theme(legend.position = "none")library(ggplot2) set.seed(123) geometric_brownian_motion() set.seed(123) geometric_brownian_motion() |> ggplot(aes(x = x, y = y, group = walk_number, color = walk_number)) + geom_line() + labs(title = "Geometric Brownian Motion", x = "Time", y = "Value") + theme_minimal() + theme(legend.position = "none")
This function takes in a vector as it's input and will return the kurtosis of that vector. The length of this vector must be at least four numbers. The kurtosis explains the sharpness of the peak of a distribution of data.
((1/n) * sum(x - mu})^4) / ((()1/n) * sum(x - mu)^2)^2
kurtosis_vec(.x)kurtosis_vec(.x)
.x |
A numeric vector of length four or more. |
A function to return the kurtosis of a vector.
The kurtosis of a vector
Steven P. Sanderson II, MPH
https://en.wikipedia.org/wiki/Kurtosis
Other Vector Function:
cgmean(),
chmean(),
ckurtosis(),
cmean(),
cmedian(),
crange(),
csd(),
cskewness(),
cvar(),
euclidean_distance(),
rw_range(),
skewness_vec()
set.seed(123) kurtosis_vec(rnorm(100, 3, 2))set.seed(123) kurtosis_vec(rnorm(100, 3, 2))
A function to help build random walks by mutating a data frame.
rand_walk_helper(.data, .value)rand_walk_helper(.data, .value)
.data |
The data frame to mutate. |
.value |
The .initial_value to use. This is passed from the random walk function being called by the end user. |
A function to help build random walks by mutating a data frame. This mutation
adds the following columns to the data frame: cum_sum, cum_prod, cum_min,
cum_max, and cum_mean. The function is used internally by certain functions
that generate random walks.
A modified data frame/tibble with the following columns added:
cum_sum: Cumulative sum of y.
cum_prod: Cumulative product of y.
cum_min: Cumulative minimum of y.
cum_max: Cumulative maximum of y.
cum_mean: Cumulative mean of y.
Steven P. Sanderson II, MPH
Other Utility Functions:
convert_snake_to_title_case(),
generate_caption()
df <- data.frame( walk_number = factor(rep(1L:25L, each = 30L)), x = rep(1L:30L, 25L), y = rnorm(750L, 0L, 1L) ) rand_walk_helper(df, 100)df <- data.frame( walk_number = factor(rep(1L:25L, each = 30L)), x = rep(1L:30L, 25L), y = rnorm(750L, 0L, 1L) ) rand_walk_helper(df, 100)
This function generates a specified number of random walks, each consisting of a specified number of steps. The steps are generated from a normal distribution with a given mean and standard deviation. An additional drift term is added to each step to introduce a consistent directional component to the walks.
random_normal_drift_walk( .num_walks = 25, .n = 100, .mu = 0, .sd = 1, .drift = 0.1, .initial_value = 0 )random_normal_drift_walk( .num_walks = 25, .n = 100, .mu = 0, .sd = 1, .drift = 0.1, .initial_value = 0 )
.num_walks |
Integer. The number of random walks to generate. Default is 25. |
.n |
Integer. The number of steps in each random walk. Default is 100. |
.mu |
Numeric. The mean of the normal distribution used for generating steps. Default is 0. |
.sd |
Numeric. The standard deviation of the normal distribution used for generating steps. Default is 1. |
.drift |
Numeric. The drift term to be added to each step. Default is 0.1. |
.initial_value |
A numeric value indicating the initial value of the walks. Default is 0. |
This function generates multiple random walks with a specified drift. Each walk is generated using a normal distribution for the steps, with an additional drift term added to each step.
A tibble in long format with columns walk_number, x (step index),
and y (walk value). The tibble has attributes for the number of walks,
number of steps, mean, standard deviation, and drift.
Steven P. Sanderson II, MPH
Other Generator Functions:
brownian_motion(),
discrete_walk(),
geometric_brownian_motion(),
random_normal_walk()
library(ggplot2) set.seed(123) walks <- random_normal_drift_walk(.num_walks = 10, .n = 50, .mu = 0, .sd = 1.2, .drift = 0.05) ggplot(walks, aes(x = x, y = y, group = walk_number, color = walk_number)) + geom_line() + labs(title = "Random Walks with Drift", x = "Time", y = "Value") + theme_minimal() + theme(legend.position = "none")library(ggplot2) set.seed(123) walks <- random_normal_drift_walk(.num_walks = 10, .n = 50, .mu = 0, .sd = 1.2, .drift = 0.05) ggplot(walks, aes(x = x, y = y, group = walk_number, color = walk_number)) + geom_line() + labs(title = "Random Walks with Drift", x = "Time", y = "Value") + theme_minimal() + theme(legend.position = "none")
The random_normal_walk function is useful for simulating random processes
and can be applied in various fields such as finance, physics, and biology
to model different stochastic behaviors.
random_normal_walk( .num_walks = 25, .n = 100, .mu = 0, .sd = 0.1, .initial_value = 0, .samp = TRUE, .replace = TRUE, .sample_size = 0.8 )random_normal_walk( .num_walks = 25, .n = 100, .mu = 0, .sd = 0.1, .initial_value = 0, .samp = TRUE, .replace = TRUE, .sample_size = 0.8 )
.num_walks |
An integer specifying the number of random walks to generate. Default is 25. |
.n |
An integer specifying the number of steps in each walk. Default is 100. |
.mu |
A numeric value indicating the mean of the normal distribution. Default is 0. |
.sd |
A numeric value indicating the standard deviation of the normal distribution. Default is 0.1. |
.initial_value |
A numeric value indicating the initial value of the walks. Default is 0. |
.samp |
A logical value indicating whether to sample the normal distribution values. Default is TRUE. |
.replace |
A logical value indicating whether sampling is with replacement. Default is TRUE. |
.sample_size |
A numeric value between 0 and 1 specifying the proportion of |
This function generates multiple random walks, which are sequences of steps where each step is a random draw from a normal distribution. The user can specify the number of walks, the number of steps in each walk, and the parameters of the normal distribution (mean and standard deviation). The function also allows for sampling a proportion of the steps and optionally sampling with replacement.
The output tibble includes several computed columns for each walk, such as the cumulative sum, product, minimum, and maximum of the steps.
A tibble containing the generated random walks with the following columns:
walk_number: Factor representing the walk number.
x: Step index.
y: Normal distribution values.
cum_sum: Cumulative sum of y.
cum_prod: Cumulative product of y.
cum_min: Cumulative minimum of y.
cum_max: Cumulative maximum of y.
The tibble includes attributes for the function parameters.
Steven P. Sanderson II, MPH
Other Generator Functions:
brownian_motion(),
discrete_walk(),
geometric_brownian_motion(),
random_normal_drift_walk()
library(ggplot2) # Generate 10 random walks with 50 steps each set.seed(123) random_normal_walk(.num_walks = 10, .n = 50) # Generate random walks with different mean and standard deviation set.seed(123) random_normal_walk(.num_walks = 10, .n = 50, .samp = FALSE) set.seed(123) random_normal_walk(.num_walks = 2, .n = 100) |> ggplot(aes(x = x, y = y, group = walk_number, color = walk_number)) + geom_line() + labs(title = "Random Normal Walk", x = "Time", y = "Value") + theme_minimal() + theme(legend.position = "none")library(ggplot2) # Generate 10 random walks with 50 steps each set.seed(123) random_normal_walk(.num_walks = 10, .n = 50) # Generate random walks with different mean and standard deviation set.seed(123) random_normal_walk(.num_walks = 10, .n = 50, .samp = FALSE) set.seed(123) random_normal_walk(.num_walks = 2, .n = 100) |> ggplot(aes(x = x, y = y, group = walk_number, color = walk_number)) + geom_line() + labs(title = "Random Normal Walk", x = "Time", y = "Value") + theme_minimal() + theme(legend.position = "none")
A function to return the range of a vector.
rw_range(.x)rw_range(.x)
.x |
A numeric vector |
A function to return the range of a vector. It uses max(.x) - min(.x) as
the basis of the function.
A numeric vector
Steven P. Sanderson II, MPH
Other Vector Function:
cgmean(),
chmean(),
ckurtosis(),
cmean(),
cmedian(),
crange(),
csd(),
cskewness(),
cvar(),
euclidean_distance(),
kurtosis_vec(),
skewness_vec()
x <- mtcars$mpg rw_range(x)x <- mtcars$mpg rw_range(x)
Generate Random Walks
rw30()rw30()
The function generates random walks using the normal distribution with a
specified mean (mu) and standard deviation (sd).
Each walk is generated independently and stored in a tibble. The resulting
tibble is then pivoted into a long format for easier analysis.
A tibble in long format with columns walk, x, and value,
representing the random walks. Additionally, attributes num_walks,
num_steps, mu, and sd are attached to the tibble.
Steven P. Sanderson II, MPH
This function generates 30 random walks with 100 steps each and pivots the result into a long format tibble.
library(ggplot2) # Generate random walks and print the result set.seed(123) rw30() set.seed(123) rw30() |> ggplot(aes(x = x, y = y, color = walk_number, group = walk_number)) + geom_line() + theme_minimal() + theme(legend.position = "none") + labs( title = "30 Random Walks", x = "Step", y = "Value", color = "Walk Number" )library(ggplot2) # Generate random walks and print the result set.seed(123) rw30() set.seed(123) rw30() |> ggplot(aes(x = x, y = y, color = walk_number, group = walk_number)) + geom_line() + theme_minimal() + theme(legend.position = "none") + labs( title = "30 Random Walks", x = "Step", y = "Value", color = "Walk Number" )
This function takes in a vector as it's input and will return the skewness of that vector. The length of this vector must be at least four numbers. The skewness explains the 'tailedness' of the distribution of data.
((1/n) * sum(x - mu})^3) / ((()1/n) * sum(x - mu)^2)^(3/2)
skewness_vec(.x)skewness_vec(.x)
.x |
A numeric vector of length four or more. |
A function to return the skewness of a vector.
The skewness of a vector
Steven P. Sanderson II, MPH
https://en.wikipedia.org/wiki/Skewness
Other Vector Function:
cgmean(),
chmean(),
ckurtosis(),
cmean(),
cmedian(),
crange(),
csd(),
cskewness(),
cvar(),
euclidean_distance(),
kurtosis_vec(),
rw_range()
set.seed(123) skewness_vec(rnorm(100, 3, 2))set.seed(123) skewness_vec(rnorm(100, 3, 2))
Summarizes random walk data by computing statistical measures.
summarize_walks(.data, .value, .group_var) summarise_walks(.data, .value, .group_var)summarize_walks(.data, .value, .group_var) summarise_walks(.data, .value, .group_var)
.data |
A data frame or tibble containing random walk data. |
.value |
A column name (unquoted) representing the value to summarize. |
.group_var |
A column name (unquoted) representing the grouping variable. |
This function requires that the input data frame contains a column named 'walk_number' and that the value to summarize is provided. It computes statistics such as mean, median, variance, and quantiles for the specified value variable. #' This function summarizes a data frame containing random walk data by computing various statistical measures for a specified value variable, grouped by a specified grouping variable. It checks for necessary attributes and ensures that the data frame is structured correctly.
A tibble containing the summarized statistics for each group, including mean, median, range, quantiles, variance, standard deviation, and more.
Steven P. Sanderson II, MPH
library(dplyr) # Example data frame walk_data <- random_normal_walk(.initial_value = 100) # Summarize the walks summarize_walks(walk_data, cum_sum, walk_number) |> glimpse() summarize_walks(walk_data, y) |> glimpse() # Example with missing value variable # summarize_walks(walk_data, NULL, group) # This will trigger an error.library(dplyr) # Example data frame walk_data <- random_normal_walk(.initial_value = 100) # Summarize the walks summarize_walks(walk_data, cum_sum, walk_number) |> glimpse() summarize_walks(walk_data, y) |> glimpse() # Example with missing value variable # summarize_walks(walk_data, NULL, group) # This will trigger an error.
visualize_walks() visualizes the output of the random walk functions in the RandomWalker package, resulting in one or more ggplot2 plots put together in a patchwork composed of 1 or more patches.
visualize_walks(.data, .alpha = 0.7)visualize_walks(.data, .alpha = 0.7)
.data |
The input data. Assumed to be created by one of the random walk
functions in the RandomWalker package, but can be any data frame or tibble
that contains columns |
.alpha |
The alpha value for all the line charts in the visualization. Values range from 0 to 1. Default is 0.7. |
visualize_walks() generates visualizations of the random walks generated by the random walk functions in the RandomWalker package. These are the functions at the moment of writing:
brownian_motion()
discrete_walk()
geometric_brownian_motion()
random_normal_drift_walk()
random_normal_walk()
rw30()
It is possible there are more when you read this, but you can check the rest of the documentation for the current situation.
The visualization function is meant to be easy to use. No parameters needed,
but you can set the .alpha if the default value of 0.7 isn't to your
liking.
You can combine this function with many tidyverse functions (either before or after). There's one example below.
A patchwork composed of 1 or more patches
Antti Lennart Rask
# Generate random walks and visualize the result set.seed(123) rw30() |> visualize_walks() # Set the alpha value to be other than the default 0.7 set.seed(123) rw30() |> visualize_walks(.alpha = 0.5) # Use the function with an input that has alternatives for y set.seed(123) random_normal_walk() |> visualize_walks() # Use the pluck function from purrr to pick just one visualization set.seed(123) random_normal_walk() |> visualize_walks() |> purrr::pluck(2)# Generate random walks and visualize the result set.seed(123) rw30() |> visualize_walks() # Set the alpha value to be other than the default 0.7 set.seed(123) rw30() |> visualize_walks(.alpha = 0.5) # Use the function with an input that has alternatives for y set.seed(123) random_normal_walk() |> visualize_walks() # Use the pluck function from purrr to pick just one visualization set.seed(123) random_normal_walk() |> visualize_walks() |> purrr::pluck(2)