diff --git a/R/Treee.R b/R/Treee.R index d70d461..ebc7b46 100644 --- a/R/Treee.R +++ b/R/Treee.R @@ -71,9 +71,13 @@ #' #' @export #' -#' @references Wang, S. (2024). A New Forward Discriminant Analysis Framework -#' Based On Pillai's Trace and ULDA. \emph{arXiv preprint arXiv:2409.03136}. -#' Available at \url{https://arxiv.org/abs/2409.03136}. +#' @references Wang, S. (2024). FoLDTree: A ULDA-Based Decision Tree Framework +#' for Efficient Oblique Splits and Feature Selection. \emph{arXiv preprint +#' arXiv:2410.23147}. Available at \url{https://arxiv.org/abs/2410.23147}. +#' +#' Wang, S. (2024). A New Forward Discriminant Analysis Framework Based On +#' Pillai's Trace and ULDA. \emph{arXiv preprint arXiv:2409.03136}. Available +#' at \url{https://arxiv.org/abs/2409.03136}. #' #' @examples #' fit <- Treee(datX = iris[, -5], response = iris[, 5], verbose = FALSE) @@ -95,7 +99,7 @@ Treee <- function(datX, misClassCost = NULL, missingMethod = c("medianFlag", "newLevel"), kSample = -1, - verbose = TRUE){ # Change verbose to FALSE before CRAN submission + verbose = TRUE){ # Standardize the Arguments ----------------------------------------------- diff --git a/R/plot.R b/R/plot.R index ab333ed..246c22f 100644 --- a/R/plot.R +++ b/R/plot.R @@ -6,7 +6,7 @@ #' #' @section Overall Tree Structure: #' -#' A full tree diagram is displayed using [visNetwork] when `node` is not +#' A full tree diagram is displayed using \link[visNetwork]{visNetwork} when `node` is not #' specified (the default is `-1`). The color represents the most common #' (plurality) class within each node, and the size of each terminal node #' reflects its relative sample size. Below each node, the fraction of diff --git a/README.Rmd b/README.Rmd index cc86be3..a27943a 100644 --- a/README.Rmd +++ b/README.Rmd @@ -21,19 +21,28 @@ knitr::opts_chunk$set( ![CRAN Downloads](https://cranlogs.r-pkg.org/badges/grand-total/LDATree) -`LDATree` is an R modeling package for fitting classification trees. If you are unfamiliar with classification trees, here is a [tutorial](http://www.sthda.com/english/articles/35-statistical-machine-learning-essentials/141-cart-model-decision-tree-essentials/) about the traditional CART and its R implementation `rpart`. +`LDATree` is an R modeling package for fitting classification trees with oblique splits. + +* If you are unfamiliar with classification trees, here is a [tutorial](http://www.sthda.com/english/articles/35-statistical-machine-learning-essentials/141-cart-model-decision-tree-essentials/) about the traditional CART and its R implementation `rpart`. + +* More details about the LDATree can be found in Wang, S. (2024). *FoLDTree: A ULDA-Based Decision Tree Framework for Efficient Oblique Splits and Feature Selection*. arXiv preprint arXiv:2410.23147. [Link](https://arxiv.org/abs/2410.23147). ## Overview -Compared to other similar trees, `LDATree` sets itself apart in the following ways: +Compared to other similar trees, `LDATree` distinguishes itself in the following ways: + +* Using Uncorrelated Linear Discriminant Analysis (ULDA) from the `folda` package, it can **efficiently find oblique splits**. + +* It provides both ULDA and forward ULDA as the splitting rule and node model. Forward ULDA has intrinsic **variable selection**, which helps mitigate the influence of noise variables. -* It applies the idea of LDA (Linear Discriminant Analysis) when selecting variables, finding splits, and fitting models in terminal nodes. +* It automatically **handles missing values**. -* It addresses certain limitations of the R implementation of LDA (`MASS::lda`), such as handling missing values, dealing with more features than samples, and constant values within groups. +* It can output both predicted class and **class probability**. -* Re-implement LDA using the Generalized Singular Value Decomposition (GSVD), LDATree offers quick response, particularly with large datasets. +* It supports **downsampling**, which can be used to balance classes or accelerate the model fitting process. + +* It includes several **visualization** tools to provide deeper insights into the data. -* The package also includes several visualization tools to provide deeper insights into the data. ## Installation @@ -41,16 +50,18 @@ Compared to other similar trees, `LDATree` sets itself apart in the following wa install.packages("LDATree") ``` -The CRAN version is an outdated one from 08/2023. Please stay tune for the latest version, which will be released around 10/2024. Meanwhile, feel free to try the undocumented version bellow. +You can install the development version of `LDATree` from [GitHub](https://github.com/) with: ```{r,fig.asp=0.618,out.width = "80%",fig.align = "center", eval=FALSE} -library(devtools) -install_github('Moran79/LDATree') +# install.packages("devtools") +devtools::install_github('Moran79/LDATree') ``` -## Usage +## Basic Usage + +We offer two main tree types in the `LDATree` package: LDATree and FoLDTree. For the splitting rule and node model, LDATree uses ULDA, while FoLDTree uses forward ULDA. -To build an LDATree: +To build an LDATree (or FoLDTree): ```{r,fig.asp=0.618,out.width = "100%",fig.align = "center"} library(LDATree) @@ -58,10 +69,11 @@ set.seed(443) diamonds <- as.data.frame(ggplot2::diamonds)[sample(53940, 2000),] datX <- diamonds[, -2] response <- diamonds[, 2] # we try to predict "cut" -fit <- Treee(datX = datX, response = response, verbose = FALSE) +fit <- Treee(datX = datX, response = response, verbose = FALSE) # by default, it is a pre-stopping FoLDTree +# fit <- Treee(datX = datX, response = response, verbose = FALSE, ldaType = "all", pruneMethod = "post") # if you want to fit a post-pruned LDATree. ``` -To plot the LDATree: +To plot the LDATree (or FoLDTree): ```{r,fig.asp=0.618,out.width = "80%",fig.align = "center", eval=FALSE} # View the overall tree. @@ -76,7 +88,7 @@ plot(fit) plot(fit, datX = datX, response = response, node = 1) # 2. Density plot on the first LD score -plot(fit, datX = datX, response = response, node = 3) +plot(fit, datX = datX, response = response, node = 7) # 3. A message plot(fit, datX = datX, response = response, node = 2) @@ -96,6 +108,11 @@ predictions <- predict(fit, datX, type = "all") head(predictions) ``` +More examples can be found in the [vignette](https://iamwangsiyu.com/LDATree/articles/LDATree.html). + +## References + +* Wang, S. (2024). FoLDTree: A ULDA-based decision tree framework for efficient oblique splits and feature selection. *arXiv preprint*, arXiv:2410.23147. Retrieved from https://arxiv.org/abs/2410.23147. ## Getting help diff --git a/README.md b/README.md index a0e9cab..2517cdc 100644 --- a/README.md +++ b/README.md @@ -11,30 +11,39 @@ status](https://www.r-pkg.org/badges/version/LDATree)](https://CRAN.R-project.or ![CRAN Downloads](https://cranlogs.r-pkg.org/badges/grand-total/LDATree) -`LDATree` is an R modeling package for fitting classification trees. If -you are unfamiliar with classification trees, here is a -[tutorial](http://www.sthda.com/english/articles/35-statistical-machine-learning-essentials/141-cart-model-decision-tree-essentials/) -about the traditional CART and its R implementation `rpart`. +`LDATree` is an R modeling package for fitting classification trees with +oblique splits. + +- If you are unfamiliar with classification trees, here is a + [tutorial](http://www.sthda.com/english/articles/35-statistical-machine-learning-essentials/141-cart-model-decision-tree-essentials/) + about the traditional CART and its R implementation `rpart`. + +- More details about the LDATree can be found in Wang, S. (2024). + *FoLDTree: A ULDA-Based Decision Tree Framework for Efficient Oblique + Splits and Feature Selection*. arXiv preprint arXiv:2410.23147. + [Link](https://arxiv.org/abs/2410.23147). ## Overview -Compared to other similar trees, `LDATree` sets itself apart in the +Compared to other similar trees, `LDATree` distinguishes itself in the following ways: -- It applies the idea of LDA (Linear Discriminant Analysis) when - selecting variables, finding splits, and fitting models in terminal - nodes. +- Using Uncorrelated Linear Discriminant Analysis (ULDA) from the + `folda` package, it can **efficiently find oblique splits**. + +- It provides both ULDA and forward ULDA as the splitting rule and node + model. Forward ULDA has intrinsic **variable selection**, which helps + mitigate the influence of noise variables. + +- It automatically **handles missing values**. -- It addresses certain limitations of the R implementation of LDA - (`MASS::lda`), such as handling missing values, dealing with more - features than samples, and constant values within groups. +- It can output both predicted class and **class probability**. -- Re-implement LDA using the Generalized Singular Value Decomposition - (GSVD), LDATree offers quick response, particularly with large - datasets. +- It supports **downsampling**, which can be used to balance classes or + accelerate the model fitting process. -- The package also includes several visualization tools to provide - deeper insights into the data. +- It includes several **visualization** tools to provide deeper insights + into the data. ## Installation @@ -42,18 +51,21 @@ following ways: install.packages("LDATree") ``` -The CRAN version is an outdated one from 08/2023. Please stay tune for -the latest version, which will be released around 10/2024. Meanwhile, -feel free to try the undocumented version bellow. +You can install the development version of `LDATree` from +[GitHub](https://github.com/) with: ``` r -library(devtools) -install_github('Moran79/LDATree') +# install.packages("devtools") +devtools::install_github('Moran79/LDATree') ``` -## Usage +## Basic Usage -To build an LDATree: +We offer two main tree types in the `LDATree` package: LDATree and +FoLDTree. For the splitting rule and node model, LDATree uses ULDA, +while FoLDTree uses forward ULDA. + +To build an LDATree (or FoLDTree): ``` r library(LDATree) @@ -61,10 +73,11 @@ set.seed(443) diamonds <- as.data.frame(ggplot2::diamonds)[sample(53940, 2000),] datX <- diamonds[, -2] response <- diamonds[, 2] # we try to predict "cut" -fit <- Treee(datX = datX, response = response, verbose = FALSE) +fit <- Treee(datX = datX, response = response, verbose = FALSE) # by default, it is a pre-stopping FoLDTree +# fit <- Treee(datX = datX, response = response, verbose = FALSE, ldaType = "all", pruneMethod = "post") # if you want to fit a post-pruned LDATree. ``` -To plot the LDATree: +To plot the LDATree (or FoLDTree): ``` r # View the overall tree. @@ -84,7 +97,7 @@ plot(fit, datX = datX, response = response, node = 1) ``` r # 2. Density plot on the first LD score -plot(fit, datX = datX, response = response, node = 3) +plot(fit, datX = datX, response = response, node = 7) ``` @@ -118,6 +131,15 @@ head(predictions) #> 6 Ideal 6 4.827312e-03 0.061274797 0.1978061 0.027410359 0.7086815 ``` +More examples can be found in the +[vignette](https://iamwangsiyu.com/LDATree/articles/LDATree.html). + +## References + +- Wang, S. (2024). FoLDTree: A ULDA-based decision tree framework for + efficient oblique splits and feature selection. *arXiv preprint*, + arXiv:2410.23147. Retrieved from . + ## Getting help If you encounter a clear bug, please file an issue with a minimal diff --git a/cran-comments.md b/cran-comments.md index f058604..2f59e95 100644 --- a/cran-comments.md +++ b/cran-comments.md @@ -1,9 +1,11 @@ -## Resubmission (08/25/2023) +# R CMD Check Results -Sorry for the inconvenience! +> New maintainer: +> Siyu Wang +> Old maintainer(s): +> Siyu Wang +> +> 0 errors ✔ | 0 warnings ✔ | 1 note ✖ -This is a resubmission. In this version I have: +I have changed my email. Thanks for your time! -* increment the version number from 0.1.1 to 0.1.2 - -* Fixed one HTML plot in the vignette due to a CRAN check error for flavor r-release-macos-x86_64. The error message is *Pandoc is required to build R Markdown vignettes but not available. Please make sure it is installed.* diff --git a/man/LDATree-package.Rd b/man/LDATree-package.Rd index a50b588..bb49c3b 100644 --- a/man/LDATree-package.Rd +++ b/man/LDATree-package.Rd @@ -4,11 +4,11 @@ \name{LDATree-package} \alias{LDATree} \alias{LDATree-package} -\title{LDATree: Classification Trees with Linear Discriminant Analysis at Terminal Nodes} +\title{LDATree: Oblique Classification Trees with Uncorrelated Linear Discriminant Analysis Splits} \description{ \if{html}{\figure{logo.png}{options: style='float: right' alt='logo' width='120'}} -A classification tree method that uses LDA (Linear Discriminant Analysis) for variable selection, split determination, and model fitting in terminal nodes. It automatically handles missing values and offers visualization tools. +A classification tree method that uses Uncorrelated Linear Discriminant Analysis (ULDA) for variable selection, split determination, and model fitting in terminal nodes. It automatically handles missing values and offers visualization tools. For more details, see Wang (2024) \doi{10.48550/arXiv.2410.23147}. } \seealso{ Useful links: @@ -20,7 +20,7 @@ Useful links: } \author{ -\strong{Maintainer}: Siyu Wang \email{swang739@wisc.edu} (\href{https://orcid.org/0009-0005-2098-7089}{ORCID}) [copyright holder] +\strong{Maintainer}: Siyu Wang \email{iamwangsiyu@gmail.com} (\href{https://orcid.org/0009-0005-2098-7089}{ORCID}) [copyright holder] } \keyword{internal} diff --git a/man/Treee.Rd b/man/Treee.Rd index 298cc5a..cfc3527 100644 --- a/man/Treee.Rd +++ b/man/Treee.Rd @@ -117,7 +117,11 @@ plot(fit) # plot the overall tree plot(fit, datX = iris[, -5], response = iris[, 5], node = 1) # plot a certain node } \references{ -Wang, S. (2024). A New Forward Discriminant Analysis Framework -Based On Pillai's Trace and ULDA. \emph{arXiv preprint arXiv:2409.03136}. -Available at \url{https://arxiv.org/abs/2409.03136}. +Wang, S. (2024). FoLDTree: A ULDA-Based Decision Tree Framework +for Efficient Oblique Splits and Feature Selection. \emph{arXiv preprint +arXiv:2410.23147}. Available at \url{https://arxiv.org/abs/2410.23147}. + +Wang, S. (2024). A New Forward Discriminant Analysis Framework Based On +Pillai's Trace and ULDA. \emph{arXiv preprint arXiv:2409.03136}. Available +at \url{https://arxiv.org/abs/2409.03136}. } diff --git a/man/figures/README-plot1-1.png b/man/figures/README-plot1-1.png index 8b1748e..10c38e0 100644 Binary files a/man/figures/README-plot1-1.png and b/man/figures/README-plot1-1.png differ diff --git a/man/figures/README-plot2-2.png b/man/figures/README-plot2-2.png index d19b33a..1518bbb 100644 Binary files a/man/figures/README-plot2-2.png and b/man/figures/README-plot2-2.png differ diff --git a/man/plot.Treee.Rd b/man/plot.Treee.Rd index b4c89f5..9d7d1cb 100644 --- a/man/plot.Treee.Rd +++ b/man/plot.Treee.Rd @@ -33,7 +33,7 @@ edges, while individual nodes are scatter/density plots using \code{ggplot2}. \section{Overall Tree Structure}{ -A full tree diagram is displayed using \link{visNetwork} when \code{node} is not +A full tree diagram is displayed using \link[visNetwork]{visNetwork} when \code{node} is not specified (the default is \code{-1}). The color represents the most common (plurality) class within each node, and the size of each terminal node reflects its relative sample size. Below each node, the fraction of diff --git a/tests/testthat/test-Treee.R b/tests/testthat/test-Treee.R index b299967..944e2a5 100644 --- a/tests/testthat/test-Treee.R +++ b/tests/testthat/test-Treee.R @@ -3,7 +3,7 @@ test_that("folda: work on tibble", { dat <- ggplot2::diamonds[1:100,] fit <- Treee(dat[, -2], response = dat[[2]], verbose = FALSE) result <- predict(fit, dat) - expect_equal(result[1:4], c("Very Good", "Ideal", "Ideal", "Premium")) + expect_equal(result[1:4], c("Ideal", "Premium", "Premium", "Very Good")) }) test_that("folda: all columns are constant", { diff --git a/vignettes/LDATree.Rmd b/vignettes/LDATree.Rmd index 985ff58..106ff38 100644 --- a/vignettes/LDATree.Rmd +++ b/vignettes/LDATree.Rmd @@ -15,102 +15,107 @@ knitr::opts_chunk$set( library(LDATree) ``` -`LDATree` is an R modeling package for fitting classification trees. If you are unfamiliar with classification trees, here is a [tutorial](http://www.sthda.com/english/articles/35-statistical-machine-learning-essentials/141-cart-model-decision-tree-essentials/) about the traditional CART and its R implementation `rpart`. +`LDATree` is an R modeling package for fitting classification trees with oblique splits. -Compared to other similar trees, `LDATree` sets itself apart in the following ways: +* If you are unfamiliar with classification trees, here is a [tutorial](http://www.sthda.com/english/articles/35-statistical-machine-learning-essentials/141-cart-model-decision-tree-essentials/) about the traditional CART and its R implementation `rpart`. -* It applies the idea of LDA (Linear Discriminant Analysis) when selecting variables, finding splits, and fitting models in terminal nodes. +* More details about the LDATree can be found in Wang, S. (2024). *FoLDTree: A ULDA-Based Decision Tree Framework for Efficient Oblique Splits and Feature Selection*. arXiv preprint arXiv:2410.23147. [Link](https://arxiv.org/abs/2410.23147). -* It addresses certain limitations of the R implementation of LDA (`MASS::lda`), such as handling missing values, dealing with more features than samples, and constant values within groups. -* Re-implement LDA using the Generalized Singular Value Decomposition (GSVD), LDATree offers quick response, particularly with large datasets. +# Why use the `LDATree` package? -* The package also includes several visualization tools to provide deeper insights into the data. +Compared to other similar trees, `LDATree` distinguishes itself in the following ways: -# Build the Tree +* Using Uncorrelated Linear Discriminant Analysis (ULDA) from the `folda` package, it can **efficiently find oblique splits**. -Currently, `LDATree` offers two methods to construct a tree: +* It provides both ULDA and forward ULDA as the splitting rule and node model. Forward ULDA has intrinsic **variable selection**, which helps mitigate the influence of noise variables. -1. The first method utilizes a direct-stopping rule, halting the growth process once specific conditions are satisfied. +* It automatically **handles missing values**. -1. The second approach involves pruning: it permits the building of a larger tree, which is then pruned using cross-validation. +* It can output both predicted class and **class probability**. -```{r,fig.asp=0.618,out.width = "100%",fig.align = "center", echo=TRUE} -# mpg <- as.data.frame(ggplot2::mpg) -# datX <- mpg[, -5] # All predictors without Y -# response <- mpg[, 5] # we try to predict "cyl" (number of cylinders) -# -# # Build a tree using direct-stopping rule -# fit <- Treee(datX = datX, response = response, pruneMethod = "pre", verbose = FALSE) -# -# # Build a tree using cross-validation -# set.seed(443) -# fitCV <- Treee(datX = datX, response = response, pruneMethod = "post", verbose = FALSE) -``` +* It supports **downsampling**, which can be used to balance classes or accelerate the model fitting process. -# Plot the Tree +* It includes several **visualization** tools to provide deeper insights into the data. -`LDATree` offers two plotting methods： -1. You can use `plot` directly to view the full tree diagram. +# Basic Usage of `LDATree` -1. To check the individual plot for the node that you are interested in, you have to input the (training) data and specify the node index. +We offer two main tree types in the `LDATree` package: LDATree and FoLDTree. For the splitting rule and node model, LDATree uses ULDA, while FoLDTree uses forward ULDA. -## Overall Plot +To build an LDATree (or FoLDTree): -```{r,fig.asp=0.618,out.width = "100%",fig.align = "center", echo=TRUE} -# View the overall tree -# plot(fit) # Tips: Try clicking on the nodes... +```{r,fig.asp=0.618,out.width = "100%",fig.align = "center"} +library(LDATree) +set.seed(443) +diamonds <- as.data.frame(ggplot2::diamonds)[sample(53940, 2000),] +datX <- diamonds[, -2] +response <- diamonds[, 2] # we try to predict "cut" +fit <- Treee(datX = datX, response = response, verbose = FALSE) # by default, it is a pre-stopping FoLDTree +# fit <- Treee(datX = datX, response = response, verbose = FALSE, ldaType = "all", pruneMethod = "post") # if you want to fit a post-pruned LDATree. ``` -## Individual Plots +To plot the LDATree (or FoLDTree): -```{r,fig.asp=0.618,out.width = "100%",fig.align = "center", echo=TRUE} +```{r,fig.asp=0.618,out.width = "80%",fig.align = "center", eval=FALSE} +# View the overall tree. +plot(fit) +``` + +```{r out.width = '100%',fig.align = "center", echo = FALSE} +knitr::include_graphics("README-plot1-1.png") +``` + +```{r,echo=TRUE, eval=FALSE} # Three types of individual plots -# # 1. Scatter plot on first two LD scores -# plot(fit, datX = datX, response = response, node = 1) -# -# # 2. Density plot on the first LD score -# plot(fit, datX = datX, response = response, node = 3) -# -# # 3. A message -# plot(fit, datX = datX, response = response, node = 2) +# 1. Scatter plot on first two LD scores +plot(fit, datX = datX, response = response, node = 1) +``` + +```{r, out.width = '100%',fig.align = "center", echo = FALSE} +knitr::include_graphics("README-plot2-1.png") ``` -# Make Predictions +```{r,echo=TRUE, eval=FALSE} +# 2. Density plot on the first LD score +plot(fit, datX = datX, response = response, node = 7) +``` + +```{r, out.width = '100%',fig.align = "center", echo = FALSE} +knitr::include_graphics("README-plot2-2.png") +``` + +```{r} +# 3. A message +plot(fit, datX = datX, response = response, node = 2) +``` + +To make predictions: ```{r,fig.asp=0.618,out.width = "100%",fig.align = "center", echo=TRUE} -# Prediction only -# predictions <- predict(fit, datX) -# head(predictions) +# Prediction only. +predictions <- predict(fit, datX) +head(predictions) ``` ```{r,fig.asp=0.618,out.width = "100%",fig.align = "center", echo=TRUE} # A more informative prediction -# predictions <- predict(fit, datX, type = "all") -# head(predictions) +predictions <- predict(fit, datX, type = "all") +head(predictions) ``` -# Missing Values -For missing values, you do not need to specify anything (unless you want to); `LDATree` will handle it. By default, it fills in missing numerical variables with their median and adds a missing flag. For missing factor variables, it assigns a new level. For more options, please refer to `help(Treee)`. +# Additional Features -```{r,fig.asp=0.618,out.width = "100%",fig.align = "center", echo=TRUE} -# -# datXmissing <- datX -# for(i in 1:10) datXmissing[sample(234,20),i] <- NA -# fitMissing <- Treee(datX = datXmissing, response = response, pruneMethod = "post", verbose = FALSE) -# plot(fitMissing, datX = datXmissing, response = response, node = 1) -``` +* **Missing values**: The solution to the missing value problem is inherited from the `folda` package. Check [here](https://iamwangsiyu.com/folda/articles/folda.html#handling-missing-values) for more details. -# LDA/GSVD +* **Downsampling**: Optional downsampling occurs only when fitting the ULDA model. Check [here](https://iamwangsiyu.com/folda/articles/folda.html#downsampling) for more details. -As we re-implement the LDA/GSVD and apply it in the model fitting, a by-product is the `ldaGSVD` function. Feel free to play with it and see how it compares to `MASS::lda`. +* **`misClassCost`**: This parameter is useful in situations where misclassifying certain classes has a more severe impact than others. Check [here](https://iamwangsiyu.com/folda/articles/folda.html#additional-features) for more details. -```{r,fig.asp=0.618,out.width = "100%",fig.align = "center", echo=TRUE} -# fitLDAgsvd <- ldaGSVD(datX = datX, response = response) -# predictionsLDAgsvd <- predict(fitLDAgsvd, newdata = datX) -# mean(predictionsLDAgsvd == response) # Training error -``` +# References + +* Wang, S. (2024). A new forward discriminant analysis framework based on Pillai's trace and ULDA. *arXiv preprint*, arXiv:2409.03136. Retrieved from https://arxiv.org/abs/2409.03136. +* Wang, S. (2024). FoLDTree: A ULDA-based decision tree framework for efficient oblique splits and feature selection. *arXiv preprint*, arXiv:2410.23147. Retrieved from https://arxiv.org/abs/2410.23147. diff --git a/vignettes/README-plot1-1.png b/vignettes/README-plot1-1.png new file mode 100644 index 0000000..10c38e0 Binary files /dev/null and b/vignettes/README-plot1-1.png differ diff --git a/vignettes/README-plot2-1.png b/vignettes/README-plot2-1.png new file mode 100644 index 0000000..a03a3dd Binary files /dev/null and b/vignettes/README-plot2-1.png differ diff --git a/vignettes/README-plot2-2.png b/vignettes/README-plot2-2.png new file mode 100644 index 0000000..1518bbb Binary files /dev/null and b/vignettes/README-plot2-2.png differ