From f1d5a56106aa89fbeb26af834b52fc627bdda2f5 Mon Sep 17 00:00:00 2001 From: arcaldwell49 Date: Fri, 20 Apr 2018 17:47:09 -0500 Subject: [PATCH 1/2] Addition of jamovi function --- R/datambicorr.b.R | 292 ++++++++++++++++++++++++++ R/datambicorr.h.R | 396 ++++++++++++++++++++++++++++++++++++ R/datambinpind.b.R | 294 ++++++++++++++++++++++++++ R/datambinpind.h.R | 310 ++++++++++++++++++++++++++++ R/datambinppair.b.R | 263 ++++++++++++++++++++++++ R/datambinppair.h.R | 350 +++++++++++++++++++++++++++++++ R/datambipaired.b.R | 294 ++++++++++++++++++++++++++ R/datambipaired.h.R | 387 +++++++++++++++++++++++++++++++++++ R/datambitwo.b.R | 306 ++++++++++++++++++++++++++++ R/datambitwo.h.R | 374 ++++++++++++++++++++++++++++++++++ jamovi/0000.yaml | 46 +++++ jamovi/datambicorr.a.yaml | 99 +++++++++ jamovi/datambicorr.r.yaml | 198 ++++++++++++++++++ jamovi/datambicorr.u.yaml | 76 +++++++ jamovi/datambinpind.a.yaml | 107 ++++++++++ jamovi/datambinpind.r.yaml | 134 ++++++++++++ jamovi/datambinpind.u.yaml | 47 +++++ jamovi/datambinppair.a.yaml | 93 +++++++++ jamovi/datambinppair.r.yaml | 150 ++++++++++++++ jamovi/datambinppair.u.yaml | 55 +++++ jamovi/datambipaired.a.yaml | 103 ++++++++++ jamovi/datambipaired.r.yaml | 167 +++++++++++++++ jamovi/datambipaired.u.yaml | 59 ++++++ jamovi/datambitwo.a.yaml | 117 +++++++++++ jamovi/datambitwo.r.yaml | 150 ++++++++++++++ jamovi/datambitwo.u.yaml | 49 +++++ 26 files changed, 4916 insertions(+) create mode 100644 R/datambicorr.b.R create mode 100644 R/datambicorr.h.R create mode 100644 R/datambinpind.b.R create mode 100644 R/datambinpind.h.R create mode 100644 R/datambinppair.b.R create mode 100644 R/datambinppair.h.R create mode 100644 R/datambipaired.b.R create mode 100644 R/datambipaired.h.R create mode 100644 R/datambitwo.b.R create mode 100644 R/datambitwo.h.R create mode 100644 jamovi/0000.yaml create mode 100644 jamovi/datambicorr.a.yaml create mode 100644 jamovi/datambicorr.r.yaml create mode 100644 jamovi/datambicorr.u.yaml create mode 100644 jamovi/datambinpind.a.yaml create mode 100644 jamovi/datambinpind.r.yaml create mode 100644 jamovi/datambinpind.u.yaml create mode 100644 jamovi/datambinppair.a.yaml create mode 100644 jamovi/datambinppair.r.yaml create mode 100644 jamovi/datambinppair.u.yaml create mode 100644 jamovi/datambipaired.a.yaml create mode 100644 jamovi/datambipaired.r.yaml create mode 100644 jamovi/datambipaired.u.yaml create mode 100644 jamovi/datambitwo.a.yaml create mode 100644 jamovi/datambitwo.r.yaml create mode 100644 jamovi/datambitwo.u.yaml diff --git a/R/datambicorr.b.R b/R/datambicorr.b.R new file mode 100644 index 0000000..cfa2ca2 --- /dev/null +++ b/R/datambicorr.b.R @@ -0,0 +1,292 @@ + +# This file is a generated template, your changes will not be overwritten + +dataMBIcorrClass <- if (requireNamespace('jmvcore')) R6::R6Class( + "dataMBIcorrClass", + inherit = dataMBIcorrBase, + private = list( + .init = function() { + + + MBI <- self$results$mbi + desc <- self$results$desc + + confint <- self$options$confint / 100 + + + for (pair in self$options$pairs) { + MBI$setRow(rowKey=pair, list(i1=pair[[1]], i2=pair[[2]])) + desc$setRow(rowKey=pair, list(`name[1]`=pair[[1]], `name[2]`=pair[[2]])) + } + + + + + + + }, + + .run = function() { + + MBI <- self$results$mbi + desc <- self$results$desc + + + conf.int <- (self$options$confint)/100 + SWC <- self$options$SWC + threshold <- (0.5*log((1+SWC)/(1-SWC))) + + for (pair in self$options$pairs) { + + if (is.null(pair[[1]])) + next() + if (is.null(pair[[2]])) + next() + + i1 <- jmvcore::toNumeric(self$data[[ pair[[1]] ]]) + i2 <- jmvcore::toNumeric(self$data[[ pair[[2]] ]]) + data <- data.frame(i1=i1, i2=i2) + data <- na.omit(data) + n <- nrow(data) + i1 <- data$i1 + i2 <- data$i2 + m1 <- base::mean(i1) + m2 <- base::mean(i2) + med1 <- stats::median(i1) + med2 <- stats::median(i2) + sd1 <- stats::sd(i1) + sd2 <- stats::sd(i2) + se1 <- sd1/sqrt(n) + se2 <- sd2/sqrt(n) + + if (self$options$spear) { + + result <- stats::cor.test(i1, i2, method="spearman", exact=F, conf.level=conf.int) + + type_Spear <- paste("Spearman") + type_Spear2 <- paste("rho =") + p_Spear <- unname(result$p.value) + correl_Spear <- unname(result$estimate) + z_Spear <- (0.5 * + log((1 + correl_Spear)/(1 - correl_Spear))) + + zSE_Spear <- (1/sqrt(n-3)) + + Positive_Spear <- round(100 * (1 - stats::pnorm(threshold, mean = z_Spear, sd = (1/sqrt(n - 3)))), digits = 1) + Negative_Spear <- round(100 * (stats::pnorm(-threshold, mean = z_Spear, sd = (1/sqrt(n - 3)))), digits = 1) + Trivial_Spear <- round(100 - Positive_Spear - Negative_Spear, digits = 1) + + + lower <- ifelse(Negative_Spear < 0.5, "Most Unlikely", ifelse(Negative_Spear < + 5, "Very Unlikely", ifelse(Negative_Spear < 25, "Unlikely", + ifelse(Negative_Spear < 75, "Possibly", ifelse(Negative_Spear < 95, + "Likely", ifelse(Negative_Spear < 99, "Most Likely", ifelse(Negative_Spear >= + 99, "Almost Certainly"))))))) + trivial2 <- ifelse(Trivial_Spear < 0.5, "Most Unlikely", ifelse(Trivial_Spear < + 5, "Very Unlikely", ifelse(Trivial_Spear < 25, "Unlikely", + ifelse(Trivial_Spear < 75, "Possibly", ifelse(Trivial_Spear < 95, + "Likely", ifelse(Trivial_Spear < 99, "Most Likely", ifelse(Trivial_Spear >= + 99, "Almost Certainly"))))))) + higher <- ifelse(Positive_Spear < 0.5, "Most Unlikely", ifelse(Positive_Spear < + 5, "Very Unlikely", ifelse(Positive_Spear < 25, "Unlikely", + ifelse(Positive_Spear < 75, "Possibly", ifelse(Positive_Spear < 95, + "Likely", ifelse(Positive_Spear < 99, "Most Likely", ifelse(Positive_Spear >= + 99, "Almost Certainly"))))))) + + + + + table <- matrix(c("Negative", "Trivial", "Positive", Negative_Spear, + Trivial_Spear, Positive_Spear), nrow = 2, byrow = T) + infer <- which.max(table[2, ]) + infer2 <- ifelse(correl_Spear < 0, "Negative", "Positive") + infer3 <- ifelse(infer == 1, lower, ifelse(infer == 2, trivial2, + ifelse(infer == 3, higher))) + + mag <- ifelse(abs(correl_Spear) < 0.1 || infer == 2, "Trivial", ifelse(abs(correl_Spear) < + 0.3, "Small", ifelse(abs(correl_Spear) < 0.5, "Moderate", ifelse(abs(correl_Spear) < + 0.7, "Large", ifelse(abs(correl_Spear) < 0.9, "Very Large", ifelse(abs(correl_Spear) >= + 0.9, "Very Large")))))) + + Inference_Spear <- ifelse(abs(Positive_Spear) >= 5 && abs(Negative_Spear) > 5, + paste("Unclear Association."), + paste(infer3, mag, infer2, "Correlation.", + sep = " ")) + + + #Save result for Pearson + MBI$setRow(rowKey=pair, list( + `type[1]`=type_Spear, `p[1]`=p_Spear, + `type_Spear2[1]`=type_Spear2, `correl[1]`=correl_Spear, `z[1]`=z_Spear, + `zSE[1]`=zSE_Spear, `Positive[1]`=Positive_Spear, + `Trivial[1]`=Trivial_Spear, `Negative[1]`=Negative_Spear, + `Inference[1]`=Inference_Spear)) + + #MBI$setRow(rowKey=pair, list( + # `type_Spear[1]`=type_Spear, `p_Spear[1]`=p_Spear, + # `type_Spear2[1]`=type_Spear2, `correl_Spear[1]`=correl_Spear, `z_Spear[1]`=z_Spear, + # `zSE_Spear[1]`=zSE_Spear, `Positive_Spear[1]`=Positive_Spear, + # `Trivial_Spear[1]`=Trivial_Spear, `Negative_Spear[1]`=Negative_Spear, + # `Inference_Spear[1]`=Inference_Spear)) + + } + + if (self$options$pearson) { + + result <- stats::cor.test(i1, i2, method="pearson", exact=F, conf.level=conf.int) + + type_Pear <- paste("Pearson") + type_Pear2 <- paste("r =") + p_Pear <- unname(result$p.value) + correl_Pear <- unname(result$estimate) + z_Pear <- (0.5 * + log((1 + correl_Pear)/(1 - correl_Pear))) + + zSE_Pear <- (1/sqrt(n-3)) + + Positive_Pear <- round(100 * (1 - stats::pnorm(threshold, mean = z_Pear, sd = (1/sqrt(n - 3)))), digits = 1) + Negative_Pear <- round(100 * (stats::pnorm(-threshold, mean = z_Pear, sd = (1/sqrt(n - 3)))), digits = 1) + Trivial_Pear <- round(100 - Positive_Pear - Negative_Pear, digits = 1) + + + lower <- ifelse(Negative_Pear < 0.5, "Most Unlikely", ifelse(Negative_Pear < + 5, "Very Unlikely", ifelse(Negative_Pear < 25, "Unlikely", + ifelse(Negative_Pear < 75, "Possibly", ifelse(Negative_Pear < 95, + "Likely", ifelse(Negative_Pear < 99, "Most Likely", ifelse(Negative_Pear >= + 99, "Almost Certainly"))))))) + trivial2 <- ifelse(Trivial_Pear < 0.5, "Most Unlikely", ifelse(Trivial_Pear < + 5, "Very Unlikely", ifelse(Trivial_Pear < 25, "Unlikely", + ifelse(Trivial_Pear < 75, "Possibly", ifelse(Trivial_Pear < 95, + "Likely", ifelse(Trivial_Pear < 99, "Most Likely", ifelse(Trivial_Pear >= + 99, "Almost Certainly"))))))) + higher <- ifelse(Positive_Pear < 0.5, "Most Unlikely", ifelse(Positive_Pear < + 5, "Very Unlikely", ifelse(Positive_Pear < 25, "Unlikely", + ifelse(Positive_Pear < 75, "Possibly", ifelse(Positive_Pear < 95, + "Likely", ifelse(Positive_Pear < 99, "Most Likely", ifelse(Positive_Pear >= + 99, "Almost Certainly"))))))) + + + + + + table <- matrix(c("Negative", "Trivial", "Positive", Negative_Pear, + Trivial_Pear, Positive_Pear), nrow = 2, byrow = T) + infer <- which.max(table[2, ]) + infer2 <- ifelse(correl_Pear < 0, "Negative", "Positive") + infer3 <- ifelse(infer == 1, lower, ifelse(infer == 2, trivial2, + ifelse(infer == 3, higher))) + mag <- ifelse(abs(correl_Pear) < 0.1 || infer == 2, "Trivial", ifelse(abs(correl_Pear) < + 0.3, "Small", ifelse(abs(correl_Pear) < 0.5, "Moderate", ifelse(abs(correl_Pear) < + 0.7, "Large", ifelse(abs(correl_Pear) < 0.9, "Very Large", ifelse(abs(correl_Pear) >= + 0.9, "Very Large")))))) + + Inference_Pear <- ifelse(abs(Positive_Pear) >= 5 && abs(Negative_Pear) > 5, + paste("Unclear Association."), + paste(infer3, mag, infer2, "Correlation.", + sep = " ")) + + + +#Save result for Pearson + + MBI$setRow(rowKey=pair, list( + `type[0]`=type_Pear, `p[0]`=p_Pear, + `type_Pear2[0]`=type_Pear2, `correl[0]`=correl_Pear, `z[0]`=z_Pear, + `zSE[0]`=zSE_Pear, `Positive[0]`=Positive_Pear, + `Trivial[0]`=Trivial_Pear, `Negative[0]`=Negative_Pear, + `Inference[0]`=Inference_Pear)) + + #MBI$setRow(rowKey=pair, list( + # type_Pear=type_Pear, p_Pear=unname(result$p.value), + # type_Pear2=type_Pear2, correl_Pear=correl_Pear, z_Pear=z_Pear, + # zSE_Pear=zSE_Pear, Positive_Pear=Positive_Pear, + # Trivial_Pear=Trivial_Pear, Negative_Pear=Negative_Pear, + # Inference_Pear=Inference_Pear)) + + } + + if (self$options$kendall) { + + result <- stats::cor.test(i1, i2, method="kendall", exact=F, conf.level=conf.int) + + type_Ken <- paste("Kendall") + type_Ken2 <- paste("tau =") + p_Ken <- unname(result$p.value) + correl_Ken <- unname(result$estimate) + z_Ken <- (0.5 * + log((1 + correl_Ken)/(1 - correl_Ken))) + + zSE_Ken <- (1/sqrt(n-3)) + + Positive_Ken <- round(100 * (1 - stats::pnorm(threshold, mean = z_Ken, sd = (1/sqrt(n - 3)))), digits = 1) + Negative_Ken <- round(100 * (stats::pnorm(-threshold, mean = z_Ken, sd = (1/sqrt(n - 3)))), digits = 1) + Trivial_Ken <- round(100 - Positive_Ken - Negative_Ken, digits = 1) + + + lower <- ifelse(Negative_Ken < 0.5, "Most Unlikely", ifelse(Negative_Ken < + 5, "Very Unlikely", ifelse(Negative_Ken < 25, "Unlikely", + ifelse(Negative_Ken < 75, "Possibly", ifelse(Negative_Ken < 95, + "Likely", ifelse(Negative_Ken < 99, "Most Likely", ifelse(Negative_Ken >= + 99, "Almost Certainly"))))))) + trivial2 <- ifelse(Trivial_Ken < 0.5, "Most Unlikely", ifelse(Trivial_Ken < + 5, "Very Unlikely", ifelse(Trivial_Ken < 25, "Unlikely", + ifelse(Trivial_Ken < 75, "Possibly", ifelse(Trivial_Ken < 95, + "Likely", ifelse(Trivial_Ken < 99, "Most Likely", ifelse(Trivial_Ken >= + 99, "Almost Certainly"))))))) + higher <- ifelse(Positive_Ken < 0.5, "Most Unlikely", ifelse(Positive_Ken < + 5, "Very Unlikely", ifelse(Positive_Ken < 25, "Unlikely", + ifelse(Positive_Ken < 75, "Possibly", ifelse(Positive_Ken < 95, + "Likely", ifelse(Positive_Ken < 99, "Most Likely", ifelse(Positive_Ken >= + 99, "Almost Certainly"))))))) + + + + + table <- matrix(c("Negative", "Trivial", "Positive", Negative_Ken, + Trivial_Ken, Positive_Ken), nrow = 2, byrow = T) + infer <- which.max(table[2, ]) + infer2 <- ifelse(correl_Ken < 0, "Negative", "Positive") + infer3 <- ifelse(infer == 1, lower, ifelse(infer == 2, trivial2, + ifelse(infer == 3, higher))) + mag <- ifelse(abs(correl_Ken) < 0.1 || infer == 2, "Trivial", ifelse(abs(correl_Ken) < + 0.3, "Small", ifelse(abs(correl_Ken) < 0.5, "Moderate", ifelse(abs(correl_Ken) < + 0.7, "Large", ifelse(abs(correl_Ken) < 0.9, "Very Large", ifelse(abs(correl_Ken) >= + 0.9, "Very Large")))))) + + Inference_Ken <- ifelse(abs(Positive_Ken) >= 5 && abs(Negative_Ken) > 5, + paste("Unclear Association."), + paste(infer3, mag, infer2, "Correlation.", + sep = " ")) + + #Save result for Pearson + MBI$setRow(rowKey=pair, list( + `type[2]`=type_Ken, `p[2]`=p_Ken, + `type_Ken2[2]`=type_Ken2, `correl[2]`=correl_Ken, `z[2]`=z_Ken, + `zSE[2]`=zSE_Ken, `Positive[2]`=Positive_Ken, + `Trivial[2]`=Trivial_Ken, `Negative[2]`=Negative_Ken, + `Inference[2]`=Inference_Ken)) + + # MBI$setRow(rowKey=pair, list( + # type_Ken=type_Ken, p_Ken=unname(result$p.value), + # type_Ken2=type_Ken2, correl_Ken=correl_Ken, z_Ken=z_Ken, + # zSE_Ken=zSE_Ken, Positive_Ken=Positive_Ken, + # Trivial_Ken=Trivial_Ken, Negative_Ken=Negative_Ken, + # Inference_Ken=Inference_Ken)) + + } + + #Save result for Descriptives + desc$setRow(rowKey=pair, list( + `n[1]`=n, `m[1]`=m1, `med[1]`=med1, `sd[1]`=sd1, `se[1]`=se1, + `n[2]`=n, `m[2]`=m2, `med[2]`=med2, `sd[2]`=sd2, `se[2]`=se2)) + + + } + + + # `self$data` contains the data + # `self$options` contains the options + # `self$results` contains the results object (to populate) + + }) +) diff --git a/R/datambicorr.h.R b/R/datambicorr.h.R new file mode 100644 index 0000000..252e37c --- /dev/null +++ b/R/datambicorr.h.R @@ -0,0 +1,396 @@ + +# This file is automatically generated, you probably don't want to edit this + +dataMBIcorrOptions <- if (requireNamespace('jmvcore')) R6::R6Class( + "dataMBIcorrOptions", + inherit = jmvcore::Options, + public = list( + initialize = function( + pairs = NULL, + pearson = TRUE, + spear = FALSE, + kendall = FALSE, + SESOI = 0.1, + confint = 90, + desc = FALSE, ...) { + + super$initialize( + package='mbir', + name='dataMBIcorr', + requiresData=TRUE, + ...) + + private$..pairs <- jmvcore::OptionPairs$new( + "pairs", + pairs, + suggested=list( + "continuous"), + permitted=list( + "continuous", + "nominal", + "ordinal")) + private$..pearson <- jmvcore::OptionBool$new( + "pearson", + pearson, + default=TRUE) + private$..spear <- jmvcore::OptionBool$new( + "spear", + spear, + default=FALSE) + private$..kendall <- jmvcore::OptionBool$new( + "kendall", + kendall, + default=FALSE) + private$..SESOI <- jmvcore::OptionNumber$new( + "SESOI", + SESOI, + min=0.01, + max=0.9, + default=0.1) + private$..confint <- jmvcore::OptionNumber$new( + "confint", + confint, + min=50, + max=99.9, + default=90) + private$..desc <- jmvcore::OptionBool$new( + "desc", + desc, + default=FALSE) + + self$.addOption(private$..pairs) + self$.addOption(private$..pearson) + self$.addOption(private$..spear) + self$.addOption(private$..kendall) + self$.addOption(private$..SESOI) + self$.addOption(private$..confint) + self$.addOption(private$..desc) + }), + active = list( + pairs = function() private$..pairs$value, + pearson = function() private$..pearson$value, + spear = function() private$..spear$value, + kendall = function() private$..kendall$value, + SESOI = function() private$..SESOI$value, + confint = function() private$..confint$value, + desc = function() private$..desc$value), + private = list( + ..pairs = NA, + ..pearson = NA, + ..spear = NA, + ..kendall = NA, + ..SESOI = NA, + ..confint = NA, + ..desc = NA) +) + +dataMBIcorrResults <- if (requireNamespace('jmvcore')) R6::R6Class( + inherit = jmvcore::Group, + active = list( + text = function() private$.items[["text"]], + mbi = function() private$.items[["mbi"]], + desc = function() private$.items[["desc"]]), + private = list(), + public=list( + initialize=function(options) { + super$initialize( + options=options, + name="", + title="MBI for Correlation") + self$add(jmvcore::Preformatted$new( + options=options, + name="text", + title="MBI for Correlation")) + self$add(jmvcore::Table$new( + options=options, + name="mbi", + title="Magnitude Based Inference: Correlation", + rows="(pairs)", + clearWith=list( + "confint", + "SESOI"), + columns=list( + list( + `name`="i1", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="i2", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="b[0]", + `title`="", + `type`="text", + `content`="Pearson's r", + `visible`="(pearson)"), + list( + `name`="correl[0]", + `title`="", + `type`="Number", + `visible`="(pearson)"), + list( + `name`="p[0]", + `title`="p", + `type`="Number", + `format`="zto,pvalue", + `visible`="(pearson)"), + list( + `name`="Negative[0]", + `type`="Number", + `title`="Negative (%)", + `visible`="(pearson)"), + list( + `name`="Trivial[0]", + `type`="Number", + `title`="Trivial (%)", + `visible`="(pearson)"), + list( + `name`="Positive[0]", + `type`="Number", + `title`="Positive (%)", + `visible`="(pearson)"), + list( + `name`="Inference[0]", + `title`="Inference", + `type`="text", + `visible`="(pearson)"), + list( + `name`="b[1]", + `title`="", + `type`="text", + `content`="Spearman's rho", + `visible`="(spear)"), + list( + `name`="correl[1]", + `title`="", + `type`="Number", + `visible`="(spear)"), + list( + `name`="p[1]", + `title`="p", + `type`="Number", + `format`="zto,pvalue", + `visible`="(spear)"), + list( + `name`="Negative[1]", + `type`="Number", + `title`="Negative (%)", + `visible`="(spear)"), + list( + `name`="Trivial[1]", + `type`="Number", + `title`="Trivial (%)", + `visible`="(spear)"), + list( + `name`="Positive[1]", + `type`="Number", + `title`="Positive (%)", + `visible`="(spear)"), + list( + `name`="Inference[1]", + `title`="Inference", + `type`="text", + `visible`="(spear)"), + list( + `name`="b[2]", + `title`="", + `type`="text", + `content`="Kendall's tau-b", + `visible`="(kendall)"), + list( + `name`="correl[2]", + `title`="", + `type`="Number", + `visible`="(kendall)"), + list( + `name`="p[2]", + `title`="p", + `type`="Number", + `format`="zto,pvalue", + `visible`="(kendall)"), + list( + `name`="Negative[2]", + `type`="Number", + `title`="Negative (%)", + `visible`="(kendall)"), + list( + `name`="Trivial[2]", + `type`="Number", + `title`="Trivial (%)", + `visible`="(kendall)"), + list( + `name`="Positive[2]", + `type`="Number", + `title`="Positive (%)", + `visible`="(kendall)"), + list( + `name`="Inference[2]", + `title`="Inference", + `type`="text", + `visible`="(kendall)")))) + self$add(jmvcore::Table$new( + options=options, + name="desc", + title="Descriptives", + visible="(desc)", + rows="(pairs)", + clearWith=list( + "group"), + columns=list( + list( + `name`="name[1]", + `title`="", + `type`="text"), + list( + `name`="n[1]", + `title`="N", + `type`="integer"), + list( + `name`="m[1]", + `title`="Mean", + `type`="number"), + list( + `name`="med[1]", + `title`="Median", + `type`="number"), + list( + `name`="sd[1]", + `title`="SD", + `type`="number"), + list( + `name`="se[1]", + `title`="SE", + `type`="number"), + list( + `name`="name[2]", + `title`="", + `type`="text"), + list( + `name`="n[2]", + `title`="N", + `type`="integer"), + list( + `name`="m[2]", + `title`="Mean", + `type`="number"), + list( + `name`="med[2]", + `title`="Median", + `type`="number"), + list( + `name`="sd[2]", + `title`="SD", + `type`="number"), + list( + `name`="se[2]", + `title`="SE", + `type`="number"))))})) + +dataMBIcorrBase <- if (requireNamespace('jmvcore')) R6::R6Class( + "dataMBIcorrBase", + inherit = jmvcore::Analysis, + public = list( + initialize = function(options, data=NULL, datasetId="", analysisId="", revision=0) { + super$initialize( + package = 'mbir', + name = 'dataMBIcorr', + version = c(1,0,0), + options = options, + results = dataMBIcorrResults$new(options=options), + data = data, + datasetId = datasetId, + analysisId = analysisId, + revision = revision, + pause = NULL, + completeWhenFilled = FALSE) + })) + +#' MBI for Correlation +#' +#' +#' +#' @examples +#' \dontrun{ +#' +#' data('bugs', package = 'jmv') +#' +#' mbir::dataMBIcorr( +#' data = data, +#' pairs = list( +#' list( +#' i1="LDLF", +#' i2="LDHF"))) +#' +#' # +#' # Magnitude Based Inference: Correlation +#' # ------------------------------------------------------------------------------------------------------------------------------------------------- +#' # p Negative (\%) Trivial (\%) Positive (\%) Inference +#' # ------------------------------------------------------------------------------------------------------------------------------------------------- +#' # LDLF LDHF Pearson's r 0.577 < .001 0.00 0.00 100 Almost Certainly Large Positive Correlation. +#' # ------------------------------------------------------------------------------------------------------------------------------------------------- +#' # +#' # +#'} +#' @param data the data as a data frame +#' @param pairs a list of vectors of strings naming variables to pair from +#' \code{data} +#' @param pearson \code{TRUE} (default) or \code{FALSE}, provide Pearson's R +#' @param spear \code{TRUE} or \code{FALSE} (default), provide Spearman's rho +#' @param kendall \code{TRUE} or \code{FALSE} (default), provide Kendall's +#' tau-b +#' @param SESOI a number, default (r=0.1) that defines the bounds for +#' magnitude-based inference +#' @param confint 90\% (default), confidence interval for magnitude-based +#' inference +#' @param desc \code{TRUE} or \code{FALSE} (default), provide descriptive +#' statistics +#' @return A results object containing: +#' \tabular{llllll}{ +#' \code{results$text} \tab \tab \tab \tab \tab a preformatted \cr +#' \code{results$mbi} \tab \tab \tab \tab \tab a table \cr +#' \code{results$desc} \tab \tab \tab \tab \tab a table \cr +#' } +#' +#' Tables can be converted to data frames with \code{asDF} or \code{\link{as.data.frame}}. For example: +#' +#' \code{results$mbi$asDF} +#' +#' \code{as.data.frame(results$mbi)} +#' +#' @export +dataMBIcorr <- function( + data, + pairs, + pearson = TRUE, + spear = FALSE, + kendall = FALSE, + SESOI = 0.1, + confint = 90, + desc = FALSE) { + + if ( ! requireNamespace('jmvcore')) + stop('dataMBIcorr requires jmvcore to be installed (restart may be required)') + + options <- dataMBIcorrOptions$new( + pairs = pairs, + pearson = pearson, + spear = spear, + kendall = kendall, + SESOI = SESOI, + confint = confint, + desc = desc) + + results <- dataMBIcorrResults$new( + options = options) + + analysis <- dataMBIcorrClass$new( + options = options, + data = data) + + analysis$run() + + analysis$results +} diff --git a/R/datambinpind.b.R b/R/datambinpind.b.R new file mode 100644 index 0000000..58317b3 --- /dev/null +++ b/R/datambinpind.b.R @@ -0,0 +1,294 @@ + +# This file is a generated template, your changes will not be overwritten + +dataMBInpindClass <- if (requireNamespace('jmvcore')) R6::R6Class( + "dataMBInpindClass", + inherit = dataMBInpindBase, + private = list( + .init = function() { + + + table <- self$results$ttest + EffSize <- self$results$effect + MBI <- self$results$mbi + desc <- self$results$desc + + + EffSize$getColumn('rLL')$setSuperTitle(jmvcore::format('{}% Confidence Interval', self$options$confint)) + EffSize$getColumn('rUL')$setSuperTitle(jmvcore::format('{}% Confidence Interval', self$options$confint)) + + groupName <- self$options$group + groups <- NULL + if ( ! is.null(groupName)) + groups <- base::levels(self$data[[groupName]]) + if (length(groups) != 2) + groups <- c('Group 1', 'Group 2') + + desc <- self$results$desc + for (key in desc$rowKeys) { + desc$setRow(rowKey=key, values=list( + `name[1]`=groups[1], + `name[2]`=groups[2])) + } + + + + }, + .run = function() { + + if (is.null(self$options$group) || length(self$options$deps) == 0) + return() + + table <- self$results$ttest + EffSize <- self$results$effect + MBI <- self$results$mbi + desc <- self$results$desc + + conf.int <- (self$options$confint)/100 + SWC <- self$options$SWC + + groupName <- self$options$group + group <- self$data[[groupName]] + group <- as.factor(group) + group <- droplevels(group) + + groupLevels <- base::levels(group) + if (length(groupLevels) != 2) + jmvcore::reject("Grouping variable must have exactly 2 levels", code="grouping_var_must_have_2_levels") + + + for (depName in self$options$deps) { + + + dep <- self$data[[depName]] + dep <- jmvcore::toNumeric(dep) + dataTTest <- data.frame(dep=dep, group=group) + dataTTest <- na.omit(dataTTest) + + n <- tapply(dataTTest$dep, dataTTest$group, length) + n1 <- n[1] + n2 <- n[2] + n3 <- n1+n2 + + v <- tapply(dataTTest$dep, dataTTest$group, function(x) jmvcore::tryNaN(var(x))) + v1 <- v[1] + v2 <- v[2] + + m <- tapply(dataTTest$dep, dataTTest$group, function(x) jmvcore::tryNaN(mean(x))) + m1 <- m[1] + m2 <- m[2] + + med <- tapply(dataTTest$dep, dataTTest$group, function(x) jmvcore::tryNaN(median(x))) + med1 <- med[1] + med2 <- med[2] + + se <- sqrt(v/n) + se1 <- se[1] + se2 <- se[2] + + sd <- sqrt(v) + sd1 <- sd[1] + sd2 <- sd[2] + + + rank <- stats::wilcox.test(dep ~ group, dataTTest, + paired = FALSE, + conf.int = T, + conf.level = conf.int, + na.action = na.omit, + correct = F, + exact = F + ) + + suppressWarnings(warning(rank)) + diff <- rank$estimate + + r <- ifelse(diff < 0, + stats::qnorm(rank$p.value / 2) / sqrt(n3), + abs(stats::qnorm(rank$p.value / 2) / sqrt(n3))) + + r.LL <-( (exp(2 * ((SWC * log((1 + r) / (1 - r) + )) + ( + stats::qnorm((( + 100 - + (100 * conf.int) + ) / 100 / 2)) / sqrt(n3 - 3) + ))) - 1) / (exp(2 * + ((SWC * log((1 + r) / + (1 - r) + )) + ( + stats::qnorm((( + 100 - + (100 * conf.int) + ) / 100 / 2)) / sqrt(n3 - 3) + ))) + 1) ) + + rLL <- as.numeric(r.LL) + + r.UL <- ((exp(2 * ((SWC * log((1 + r) / (1 - r) + )) - ( + stats::qnorm((( + 100 - + (100 * conf.int) + ) / 100 / 2)) / sqrt(n3 - 3) + ))) - 1) / (exp(2 * + ((SWC * log((1 + r) / + (1 - r) + )) - ( + stats::qnorm((( + 100 - + (100 * conf.int) + ) / 100 / 2)) / sqrt(n3 - 3) + ))) + 1)) + + rUL <- as.numeric(r.UL) + + level <- paste(as.character(100 * conf.int), "%", sep = "") + + positive.r <- + round(100 * (1 - stats::pnorm( + 0.1, mean = (SWC * + log((1 + r) / + (1 - r))), sd = (1 / sqrt(n3 - 3)) + )), digits = 1) + negative.r <- round(100 * (stats::pnorm( + -0.1, mean = (SWC * + log((1 + r) / + (1 - r))), sd = (1 / sqrt(n3 - 3)) + )), digits = 1) + trivial.r <- round(100 - positive.r - negative.r, digits = 1) + lower.r <- ifelse(negative.r < 0.5, + "Most Unlikely", + ifelse( + negative.r < 5, + "Very Unlikely", + ifelse( + negative.r < + 25, + "Unlikely", + ifelse( + negative.r < 75, + "Possibly", + ifelse( + negative.r < 95, + "Likely", + ifelse( + negative.r < + 99, + "Most Likely", + ifelse(negative.r >= 99, + "Almost Certainly") + ) + ) + ) + ) + )) + trivial2.r <- ifelse(trivial.r < 0.5, + "Most Unlikely", + ifelse( + trivial.r < 5, + "Very Unlikely", + ifelse( + trivial.r < + 25, + "Unlikely", + ifelse( + trivial.r < 75, + "Possibly", + ifelse( + trivial.r < 95, + "Likely", + ifelse( + trivial.r < + 99, + "Most Likely", + ifelse(trivial.r >= 99, + "Almost Certainly") + ) + ) + ) + ) + )) + higher.r <- ifelse(positive.r < 0.5, + "Most Unlikely", + ifelse( + positive.r < 5, + "Very Unlikely", + ifelse( + positive.r < + 25, + "Unlikely", + ifelse( + positive.r < 75, + "Possibly", + ifelse( + positive.r < 95, + "Likely", + ifelse( + positive.r < + 99, + "Most Likely", + ifelse(positive.r >= 99, + "Almost Certainly") + ) + ) + ) + ) + )) + table.r <- matrix(c("Negative", "Trivial","Positive",negative.r,trivial.r,positive.r), + nrow = 2, + byrow = T + ) + + + + infer.r <- which.max(table.r[2,]) + + infer3.r <- ifelse(infer.r == 1, + lower.r, + ifelse(infer.r == + 2, trivial2.r, ifelse(infer.r == 3, higher.r))) + + mag.r <- ifelse(abs(r) < 0.1 || infer.r == 2, + "Trivial", + ifelse(abs(r) < 0.3, "Small", ifelse( + abs(r) < 0.5, + "Moderate", ifelse( + abs(r) < 0.7, + "Large", + ifelse(abs(r) < + 0.9, "Very Large", ifelse(abs(r) >= 0.9, "Very Large")) + ) + ))) + + Inference <- ifelse(abs(positive.r) >= 5 && abs(negative.r) > 5, + paste("Unclear Difference."), + paste(infer3.r, mag.r, "Effect Size",sep = " ")) + + table$setRow(rowKey=depName, list( + statistic=rank$statistic, + p=rank$p.value)) + + #effect size + EffSize$setRow(rowKey=depName, list( + r=r, + rLL=rLL, + rUL=rUL)) + + MBI$setRow(rowKey=depName, list( + inference=Inference, + negative=negative.r, + trivial=trivial.r, + positive=positive.r)) + + desc$setRow(rowKey=depName, list( + `n[1]`=n[1], `m[1]`=m[1], `med[1]`=med[1], `sd[1]`=sd[1], `se[1]`=se[1], + `n[2]`=n[2], `m[2]`=m[2], `med[2]`=med[2], `sd[2]`=sd[2], `se[2]`=se[2])) + + } + # `self$data` contains the data + # `self$options` contains the options + # `self$results` contains the results object (to populate) + + }) +) diff --git a/R/datambinpind.h.R b/R/datambinpind.h.R new file mode 100644 index 0000000..956dba0 --- /dev/null +++ b/R/datambinpind.h.R @@ -0,0 +1,310 @@ + +# This file is automatically generated, you probably don't want to edit this + +dataMBInpindOptions <- if (requireNamespace('jmvcore')) R6::R6Class( + "dataMBInpindOptions", + inherit = jmvcore::Options, + public = list( + initialize = function( + deps = NULL, + group = NULL, + SESOI = 0.5, + confint = 90, + desc = FALSE, ...) { + + super$initialize( + package='mbir', + name='dataMBInpind', + requiresData=TRUE, + ...) + + private$..deps <- jmvcore::OptionVariables$new( + "deps", + deps, + suggested=list( + "continuous"), + permitted=list( + "continuous", + "nominal", + "ordinal"), + rejectInf=FALSE) + private$..group <- jmvcore::OptionVariable$new( + "group", + group, + suggested=list( + "nominal", + "ordinal")) + private$..SESOI <- jmvcore::OptionNumber$new( + "SESOI", + SESOI, + min=0, + default=0.5) + private$..confint <- jmvcore::OptionNumber$new( + "confint", + confint, + min=50, + max=99.9, + default=90) + private$..desc <- jmvcore::OptionBool$new( + "desc", + desc, + default=FALSE) + + self$.addOption(private$..deps) + self$.addOption(private$..group) + self$.addOption(private$..SESOI) + self$.addOption(private$..confint) + self$.addOption(private$..desc) + }), + active = list( + deps = function() private$..deps$value, + group = function() private$..group$value, + SESOI = function() private$..SESOI$value, + confint = function() private$..confint$value, + desc = function() private$..desc$value), + private = list( + ..deps = NA, + ..group = NA, + ..SESOI = NA, + ..confint = NA, + ..desc = NA) +) + +dataMBInpindResults <- if (requireNamespace('jmvcore')) R6::R6Class( + inherit = jmvcore::Group, + active = list( + text = function() private$.items[["text"]], + ttest = function() private$.items[["ttest"]], + effect = function() private$.items[["effect"]], + mbi = function() private$.items[["mbi"]], + desc = function() private$.items[["desc"]]), + private = list(), + public=list( + initialize=function(options) { + super$initialize( + options=options, + name="", + title="MBI for Independent Samples (non-parametric)") + self$add(jmvcore::Preformatted$new( + options=options, + name="text", + title="MBI for Mann-Whitney")) + self$add(jmvcore::Table$new( + options=options, + name="ttest", + title="Mann-Whitney U-Test", + rows="(deps)", + columns=list( + list( + `name`="var", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="statistic", + `type`="number"), + list( + `name`="p", + `type`="number", + `format`="zto,pvalue")))) + self$add(jmvcore::Table$new( + options=options, + name="effect", + title="Effect Size", + rows="(deps)", + clearWith=list( + "confint", + "SESOI"), + columns=list( + list( + `name`="var", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="r", + `type`="number", + `title`="Effect Size (r)"), + list( + `name`="rLL", + `type`="number", + `title`="Lower", + `superTitle`="Confidence Interval"), + list( + `name`="rUL", + `type`="number", + `title`="Upper", + `superTitle`="Confidence Interval")))) + self$add(jmvcore::Table$new( + options=options, + name="mbi", + title="Magnitude Based Inference", + rows="(deps)", + columns=list( + list( + `name`="var", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="negative", + `type`="number", + `title`="Negative", + `superTitle`="MBI (%)"), + list( + `name`="trivial", + `type`="number", + `title`="Trivial", + `superTitle`="MBI (%)"), + list( + `name`="positive", + `type`="number", + `title`="Positive", + `superTitle`="MBI (%)"), + list( + `name`="inference", + `title`="Inference", + `type`="text")))) + self$add(jmvcore::Table$new( + options=options, + name="desc", + title="Descriptives", + visible="(desc)", + rows="(deps)", + clearWith=list( + "group"), + columns=list( + list( + `name`="name[1]", + `title`="", + `type`="text"), + list( + `name`="n[1]", + `title`="N", + `type`="integer"), + list( + `name`="m[1]", + `title`="Mean", + `type`="number"), + list( + `name`="med[1]", + `title`="Median", + `type`="number"), + list( + `name`="sd[1]", + `title`="SD", + `type`="number"), + list( + `name`="se[1]", + `title`="SE", + `type`="number"), + list( + `name`="name[2]", + `title`="", + `type`="text"), + list( + `name`="n[2]", + `title`="N", + `type`="integer"), + list( + `name`="m[2]", + `title`="Mean", + `type`="number"), + list( + `name`="med[2]", + `title`="Median", + `type`="number"), + list( + `name`="sd[2]", + `title`="SD", + `type`="number"), + list( + `name`="se[2]", + `title`="SE", + `type`="number"))))})) + +dataMBInpindBase <- if (requireNamespace('jmvcore')) R6::R6Class( + "dataMBInpindBase", + inherit = jmvcore::Analysis, + public = list( + initialize = function(options, data=NULL, datasetId="", analysisId="", revision=0) { + super$initialize( + package = 'mbir', + name = 'dataMBInpind', + version = c(1,0,0), + options = options, + results = dataMBInpindResults$new(options=options), + data = data, + datasetId = datasetId, + analysisId = analysisId, + revision = revision, + pause = NULL, + completeWhenFilled = FALSE) + })) + +#' MBI for Independent Samples (non-parametric) +#' +#' +#' +#' @examples +#' \dontrun{ +#' +#' data('bugs', package = 'jmv') +#' +#' mbir::dataMBInpind( +#' data = bugs, +#' deps = "LDLF", +#' group = "Gender") +#'} +#' @param data the data as a data frame +#' @param deps a vector of strings naming the dependent variables +#' @param group a string naming the grouping variable, must have 2 levels +#' @param SESOI a number that defines the bounds for magnitude-based inference +#' @param confint 90\% (default) confidence intervals for effect sizes +#' @param desc \code{TRUE} or \code{FALSE} (default), provide descriptive +#' statistics +#' @return A results object containing: +#' \tabular{llllll}{ +#' \code{results$text} \tab \tab \tab \tab \tab a preformatted \cr +#' \code{results$ttest} \tab \tab \tab \tab \tab a table \cr +#' \code{results$effect} \tab \tab \tab \tab \tab a table \cr +#' \code{results$mbi} \tab \tab \tab \tab \tab a table \cr +#' \code{results$desc} \tab \tab \tab \tab \tab a table \cr +#' } +#' +#' Tables can be converted to data frames with \code{asDF} or \code{\link{as.data.frame}}. For example: +#' +#' \code{results$ttest$asDF} +#' +#' \code{as.data.frame(results$ttest)} +#' +#' @export +dataMBInpind <- function( + data, + deps, + group, + SESOI = 0.5, + confint = 90, + desc = FALSE) { + + if ( ! requireNamespace('jmvcore')) + stop('dataMBInpind requires jmvcore to be installed (restart may be required)') + + options <- dataMBInpindOptions$new( + deps = deps, + group = group, + SESOI = SESOI, + confint = confint, + desc = desc) + + results <- dataMBInpindResults$new( + options = options) + + analysis <- dataMBInpindClass$new( + options = options, + data = data) + + analysis$run() + + analysis$results +} diff --git a/R/datambinppair.b.R b/R/datambinppair.b.R new file mode 100644 index 0000000..b979e0e --- /dev/null +++ b/R/datambinppair.b.R @@ -0,0 +1,263 @@ + +# This file is a generated template, your changes will not be overwritten + +dataMBInppairClass <- if (requireNamespace('jmvcore')) R6::R6Class( + "dataMBInppairClass", + inherit = dataMBInppairBase, + private = list( + .init = function(){ + + table <- self$results$ttest + EffSize <- self$results$effect + MBI <- self$results$mbi + desc <- self$results$desc + + + + for (pair in self$options$pairs) { + table$setRow(rowKey=pair, list(i1=pair[[1]], i2=pair[[2]])) + EffSize$setRow(rowKey=pair, list(i1=pair[[1]], i2=pair[[2]])) + MBI$setRow(rowKey=pair, list(i1=pair[[1]], i2=pair[[2]])) + desc$setRow(rowKey=pair, list(`name[1]`=pair[[1]], `name[2]`=pair[[2]])) + } + + EffSize$getColumn('rLL')$setSuperTitle(jmvcore::format('{}% Confidence Interval', self$options$confint)) + EffSize$getColumn('rUL')$setSuperTitle(jmvcore::format('{}% Confidence Interval', self$options$confint)) + + + }, + .run = function() { + + table <- self$results$ttest + EffSize <- self$results$effect + MBI <- self$results$mbi + desc <- self$results$desc + + conf.int <- (self$options$confint)/100 + SWC <- self$options$SWC + + for (pair in self$options$pairs) { + + if (is.null(pair[[1]])) + next() + if (is.null(pair[[2]])) + next() + + #Gather descriptives + i1 <- jmvcore::toNumeric(self$data[[pair[[1]] ]]) + i2 <- jmvcore::toNumeric(self$data[[pair[[2]] ]]) + data <- data.frame(i1=i1, i2=i2) + data <- na.omit(data) + n <- nrow(data) + i1 <- data$i1 + i2 <- data$i2 + m1 <- base::mean(i1) + m2 <- base::mean(i2) + med1 <- stats::median(i1) + med2 <- stats::median(i2) + sd1 <- stats::sd(i1) + sd2 <- stats::sd(i2) + se1 <- sd1/sqrt(n) + se2 <- sd2/sqrt(n) + + rank <- stats::wilcox.test(x=i1, y=i2, + paired = TRUE, + conf.int = T, + conf.level = conf.int, + na.action = na.omit, + correct = F, + exact = F) + suppressWarnings(warning(rank)) + diff <- rank$estimate + + r <- ifelse(diff < 0, + stats::qnorm(rank$p.value / 2) / sqrt(n), + abs(stats::qnorm(rank$p.value / 2) / sqrt(n))) + + r.LL <-( (exp(2 * ((SWC * log((1 + r) / (1 - r) + )) + ( + stats::qnorm((( + 100 - + (100 * conf.int) + ) / 100 / 2)) / sqrt(n - 3) + ))) - 1) / (exp(2 * + ((SWC * log((1 + r) / + (1 - r) + )) + ( + stats::qnorm((( + 100 - + (100 * conf.int) + ) / 100 / 2)) / sqrt(n - 3) + ))) + 1) ) + + rLL <- as.numeric(r.LL) + + r.UL <- ((exp(2 * ((SWC * log((1 + r) / (1 - r) + )) - ( + stats::qnorm((( + 100 - + (100 * conf.int) + ) / 100 / 2)) / sqrt(n - 3) + ))) - 1) / (exp(2 * + ((SWC * log((1 + r) / + (1 - r) + )) - ( + stats::qnorm((( + 100 - + (100 * conf.int) + ) / 100 / 2)) / sqrt(n - 3) + ))) + 1)) + + rUL <- as.numeric(r.UL) + + level <- paste(as.character(100 * conf.int), "%", sep = "") + + positive.r <- + round(100 * (1 - stats::pnorm( + 0.1, mean = (SWC * + log((1 + r) / + (1 - r))), sd = (1 / sqrt(n - 3)) + )), digits = 1) + negative.r <- round(100 * (stats::pnorm( + -0.1, mean = (SWC * + log((1 + r) / + (1 - r))), sd = (1 / sqrt(n - 3)) + )), digits = 1) + trivial.r <- round(100 - positive.r - negative.r, digits = 1) + lower.r <- ifelse(negative.r < 0.5, + "Most Unlikely", + ifelse( + negative.r < 5, + "Very Unlikely", + ifelse( + negative.r < + 25, + "Unlikely", + ifelse( + negative.r < 75, + "Possibly", + ifelse( + negative.r < 95, + "Likely", + ifelse( + negative.r < + 99, + "Most Likely", + ifelse(negative.r >= 99, + "Almost Certainly") + ) + ) + ) + ) + )) + trivial2.r <- ifelse(trivial.r < 0.5, + "Most Unlikely", + ifelse( + trivial.r < 5, + "Very Unlikely", + ifelse( + trivial.r < + 25, + "Unlikely", + ifelse( + trivial.r < 75, + "Possibly", + ifelse( + trivial.r < 95, + "Likely", + ifelse( + trivial.r < + 99, + "Most Likely", + ifelse(trivial.r >= 99, + "Almost Certainly") + ) + ) + ) + ) + )) + higher.r <- ifelse(positive.r < 0.5, + "Most Unlikely", + ifelse( + positive.r < 5, + "Very Unlikely", + ifelse( + positive.r < + 25, + "Unlikely", + ifelse( + positive.r < 75, + "Possibly", + ifelse( + positive.r < 95, + "Likely", + ifelse( + positive.r < + 99, + "Most Likely", + ifelse(positive.r >= 99, + "Almost Certainly") + ) + ) + ) + ) + )) + table.r <- matrix(c("Negative", "Trivial","Positive",negative.r,trivial.r,positive.r), + nrow = 2, + byrow = T + ) + + + + infer.r <- which.max(table.r[2,]) + + infer3.r <- ifelse(infer.r == 1, + lower.r, + ifelse(infer.r == + 2, trivial2.r, ifelse(infer.r == 3, higher.r))) + + mag.r <- ifelse(abs(r) < 0.1 || infer.r == 2, + "Trivial", + ifelse(abs(r) < 0.3, "Small", ifelse( + abs(r) < 0.5, + "Moderate", ifelse( + abs(r) < 0.7, + "Large", + ifelse(abs(r) < + 0.9, "Very Large", ifelse(abs(r) >= 0.9, "Very Large")) + ) + ))) + + Inference <- ifelse(abs(positive.r) >= 5 && abs(negative.r) > 5, + paste("Unclear Difference."), + paste(infer3.r, mag.r, "Effect Size",sep = " ")) + + table$setRow(rowKey=pair, list( + statistic=rank$statistic, + p=rank$p.value)) + + #effect size + EffSize$setRow(rowKey=pair, list( + r=r, + rLL=rLL, + rUL=rUL)) + + MBI$setRow(rowKey=pair, list( + inference=Inference, + negative=negative.r, + trivial=trivial.r, + positive=positive.r)) + + #Descriptives results + desc$setRow(rowKey=pair, list( + `n[1]`=n, `m[1]`=m1, `med[1]`=med1, `sd[1]`=sd1, `se[1]`=se1, + `n[2]`=n, `m[2]`=m2, `med[2]`=med2, `sd[2]`=sd2, `se[2]`=se2)) + + } + + # `self$data` contains the data + # `self$options` contains the options + # `self$results` contains the results object (to populate) + + }) +) diff --git a/R/datambinppair.h.R b/R/datambinppair.h.R new file mode 100644 index 0000000..6980bf1 --- /dev/null +++ b/R/datambinppair.h.R @@ -0,0 +1,350 @@ + +# This file is automatically generated, you probably don't want to edit this + +dataMBInppairOptions <- if (requireNamespace('jmvcore')) R6::R6Class( + "dataMBInppairOptions", + inherit = jmvcore::Options, + public = list( + initialize = function( + pairs = NULL, + SESOI = 0.5, + confint = 90, + desc = FALSE, ...) { + + super$initialize( + package='mbir', + name='dataMBInppair', + requiresData=TRUE, + ...) + + private$..pairs <- jmvcore::OptionPairs$new( + "pairs", + pairs, + suggested=list( + "continuous"), + permitted=list( + "continuous", + "nominal", + "ordinal")) + private$..SESOI <- jmvcore::OptionNumber$new( + "SESOI", + SESOI, + min=0, + default=0.5) + private$..confint <- jmvcore::OptionNumber$new( + "confint", + confint, + min=50, + max=99.9, + default=90) + private$..desc <- jmvcore::OptionBool$new( + "desc", + desc, + default=FALSE) + + self$.addOption(private$..pairs) + self$.addOption(private$..SESOI) + self$.addOption(private$..confint) + self$.addOption(private$..desc) + }), + active = list( + pairs = function() private$..pairs$value, + SESOI = function() private$..SESOI$value, + confint = function() private$..confint$value, + desc = function() private$..desc$value), + private = list( + ..pairs = NA, + ..SESOI = NA, + ..confint = NA, + ..desc = NA) +) + +dataMBInppairResults <- if (requireNamespace('jmvcore')) R6::R6Class( + inherit = jmvcore::Group, + active = list( + text = function() private$.items[["text"]], + ttest = function() private$.items[["ttest"]], + effect = function() private$.items[["effect"]], + mbi = function() private$.items[["mbi"]], + desc = function() private$.items[["desc"]]), + private = list(), + public=list( + initialize=function(options) { + super$initialize( + options=options, + name="", + title="MBI for Paired Samples (non-parametric)") + self$add(jmvcore::Preformatted$new( + options=options, + name="text", + title="MBI for Wilcoxon signed-rank test")) + self$add(jmvcore::Table$new( + options=options, + name="ttest", + title="Wilcoxon signed-rank test", + rows="(pairs)", + clearWith=list( + "confint", + "SESOI"), + columns=list( + list( + `name`="i1", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="i2", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="statistic", + `type`="number"), + list( + `name`="p", + `type`="number", + `format`="zto,pvalue")))) + self$add(jmvcore::Table$new( + options=options, + name="effect", + title="Effect Size", + rows="(pairs)", + clearWith=list( + "confint", + "SESOI"), + columns=list( + list( + `name`="i1", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="i2", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="r", + `type`="number", + `title`="Effect Size (r)"), + list( + `name`="rLL", + `type`="number", + `title`="Lower", + `superTitle`="Confidence Interval"), + list( + `name`="rUL", + `type`="number", + `title`="Upper", + `superTitle`="Confidence Interval")))) + self$add(jmvcore::Table$new( + options=options, + name="mbi", + title="Magnitude Based Inference", + rows="(pairs)", + clearWith=list( + "confint", + "SESOI"), + columns=list( + list( + `name`="i1", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="i2", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="negative", + `type`="number", + `title`="Negative", + `superTitle`="MBI (%)"), + list( + `name`="trivial", + `type`="number", + `title`="Trivial", + `superTitle`="MBI (%)"), + list( + `name`="positive", + `type`="number", + `title`="Positive", + `superTitle`="MBI (%)"), + list( + `name`="inference", + `title`="Inference", + `type`="text")))) + self$add(jmvcore::Table$new( + options=options, + name="desc", + title="Descriptives", + visible="(desc)", + rows="(pairs)", + clearWith=list( + "group"), + columns=list( + list( + `name`="name[1]", + `title`="", + `type`="text"), + list( + `name`="n[1]", + `title`="N", + `type`="integer"), + list( + `name`="m[1]", + `title`="Mean", + `type`="number"), + list( + `name`="med[1]", + `title`="Median", + `type`="number"), + list( + `name`="sd[1]", + `title`="SD", + `type`="number"), + list( + `name`="se[1]", + `title`="SE", + `type`="number"), + list( + `name`="name[2]", + `title`="", + `type`="text"), + list( + `name`="n[2]", + `title`="N", + `type`="integer"), + list( + `name`="m[2]", + `title`="Mean", + `type`="number"), + list( + `name`="med[2]", + `title`="Median", + `type`="number"), + list( + `name`="sd[2]", + `title`="SD", + `type`="number"), + list( + `name`="se[2]", + `title`="SE", + `type`="number"))))})) + +dataMBInppairBase <- if (requireNamespace('jmvcore')) R6::R6Class( + "dataMBInppairBase", + inherit = jmvcore::Analysis, + public = list( + initialize = function(options, data=NULL, datasetId="", analysisId="", revision=0) { + super$initialize( + package = 'mbir', + name = 'dataMBInppair', + version = c(1,0,0), + options = options, + results = dataMBInppairResults$new(options=options), + data = data, + datasetId = datasetId, + analysisId = analysisId, + revision = revision, + pause = NULL, + completeWhenFilled = FALSE) + })) + +#' MBI for Paired Samples (non-parametric) +#' +#' +#' +#' @examples +#' \dontrun{ +#' +#' data('bugs', package = 'jmv') +#' +#' mbir::dataMBInppair( +#' data = bugs, +#' pairs = list( +#' list( +#' i1="LDHF", +#' i2="LDLF"))) +#' +#' # Wilcoxon signed-rank test +#' # --------------------------------------- +#' # statistic p +#' # --------------------------------------- +#' # LDHF LDLF 2250 < .001 +#' # --------------------------------------- +#' # +#' # +#' +#' # +#' # Effect Size +#' # ------------------------------------------------- +#' # Effect Size Lower Upper +#' # ------------------------------------------------- +#' # LDHF LDLF 0.585 0.458 0.689 +#' # ------------------------------------------------- +#' # +#' # +#' +#' # +#' # Magnitude Based Inference +#' # ----------------------------------------------------------------------------------------- +#' # Negative Trivial Positive Inference +#' # ----------------------------------------------------------------------------------------- +#' # LDHF LDLF 0.00 0.00 100 Almost Certainly Large Effect Size +#' # ----------------------------------------------------------------------------------------- +#' # +#' # +#'} +#' @param data the data as a data frame +#' @param pairs a list of vectors of strings naming variables to pair from +#' \code{data} +#' @param SESOI a number that defines the bounds for magnitude-based inference +#' @param confint 90\% (default), confidence interval for magnitude-based +#' inference +#' @param desc \code{TRUE} or \code{FALSE} (default), provide descriptive +#' statistics +#' @return A results object containing: +#' \tabular{llllll}{ +#' \code{results$text} \tab \tab \tab \tab \tab a preformatted \cr +#' \code{results$ttest} \tab \tab \tab \tab \tab a table \cr +#' \code{results$effect} \tab \tab \tab \tab \tab a table \cr +#' \code{results$mbi} \tab \tab \tab \tab \tab a table \cr +#' \code{results$desc} \tab \tab \tab \tab \tab a table \cr +#' } +#' +#' Tables can be converted to data frames with \code{asDF} or \code{\link{as.data.frame}}. For example: +#' +#' \code{results$ttest$asDF} +#' +#' \code{as.data.frame(results$ttest)} +#' +#' @export +dataMBInppair <- function( + data, + pairs, + SESOI = 0.5, + confint = 90, + desc = FALSE) { + + if ( ! requireNamespace('jmvcore')) + stop('dataMBInppair requires jmvcore to be installed (restart may be required)') + + options <- dataMBInppairOptions$new( + pairs = pairs, + SESOI = SESOI, + confint = confint, + desc = desc) + + results <- dataMBInppairResults$new( + options = options) + + analysis <- dataMBInppairClass$new( + options = options, + data = data) + + analysis$run() + + analysis$results +} diff --git a/R/datambipaired.b.R b/R/datambipaired.b.R new file mode 100644 index 0000000..52777e5 --- /dev/null +++ b/R/datambipaired.b.R @@ -0,0 +1,294 @@ + +# This file is a generated template, your changes will not be overwritten + +dataMBIpairedClass <- if (requireNamespace('jmvcore')) R6::R6Class( + "dataMBIpairedClass", + inherit = dataMBIpairedBase, + private = list( + .init = function(){ + + table <- self$results$ttest + EffSize <- self$results$effect + MBI <- self$results$mbi + desc <- self$results$desc + + + + for (pair in self$options$pairs) { + table$setRow(rowKey=pair, list(i1=pair[[1]], i2=pair[[2]])) + EffSize$setRow(rowKey=pair, list(i1=pair[[1]], i2=pair[[2]])) + MBI$setRow(rowKey=pair, list(i1=pair[[1]], i2=pair[[2]])) + desc$setRow(rowKey=pair, list(`name[1]`=pair[[1]], `name[2]`=pair[[2]])) + } + + EffSize$getColumn('diffLL')$setSuperTitle(jmvcore::format('{}% Confidence Interval', self$options$confint)) + EffSize$getColumn('diffUL')$setSuperTitle(jmvcore::format('{}% Confidence Interval', self$options$confint)) + EffSize$getColumn('dLL')$setSuperTitle(jmvcore::format('{}% Confidence Interval', self$options$confint)) + EffSize$getColumn('dUL')$setSuperTitle(jmvcore::format('{}% Confidence Interval', self$options$confint)) + + + }, + .run = function() { + + + table <- self$results$ttest + EffSize <- self$results$effect + MBI <- self$results$mbi + desc <- self$results$desc + + conf.int <- (self$options$confint)/100 + SWC <- self$options$SWC + + for (pair in self$options$pairs) { + + if (is.null(pair[[1]])) + next() + if (is.null(pair[[2]])) + next() + + #Gather descriptives + i1 <- jmvcore::toNumeric(self$data[[pair[[1]] ]]) + i2 <- jmvcore::toNumeric(self$data[[pair[[2]] ]]) + data <- data.frame(i1=i1, i2=i2) + data <- na.omit(data) + n <- nrow(data) + i1 <- data$i1 + i2 <- data$i2 + m1 <- base::mean(i1) + m2 <- base::mean(i2) + med1 <- stats::median(i1) + med2 <- stats::median(i2) + sd1 <- stats::sd(i1) + sd2 <- stats::sd(i2) + se1 <- sd1/sqrt(n) + se2 <- sd2/sqrt(n) + + result <- t.test(i1, i2, paired=TRUE) + corr <- cor.test(x=i1,y=i2) + corr <- unname(corr$estimate) + + #Mean Difference + mdiff <- m1-m2 + diffSE <- sqrt(((sd1^2/n)+(sd2^2/n))-(2*corr*(sd1/sqrt(n))*(sd2/sqrt(n)))) + diffLL <- mdiff+diffSE*qt((1-conf.int)/2,n) + diffUL <- mdiff-diffSE*qt((1-conf.int)/2,n) + + #Effect Size + d <- (result$statistic/sqrt(n)) + + LL <- d - (stats::qt((( + 100 - (100 * conf.int) + ) / 100) / 2, + result$parameter)) * abs(d) / stats::qt(result$p.value / + 2, + result$parameter) + + UL <- d + (stats::qt((( + 100 - (100 * conf.int) + ) / 100) / 2, + result$parameter)) * abs(d) / stats::qt(result$p.value / + 2, + result$parameter) + type <- paste("Cohen's d") + + #Hedges Correlation + if (result$parameter < 30) { + type <- paste("Hedge's g") + d <- d * (1 - (3 / (4 * ( + result$parameter - 1 + )))) + LL <- LL * (1 - (3 / (4 * ( + result$parameter - 1 + )))) + UL <- UL * (1 - (3 / (4 * ( + result$parameter - 1 + )))) + } + + + + #Correct for correlation + if (self$options$correl==TRUE) { + + d <- d * sqrt(2*(1 - corr)) + + LL <- d - (stats::qt((( + 100 - (100 * conf.int) + ) / 100) / 2, + result$parameter)) * abs(d) / stats::qt(result$p.value / + 2, + result$parameter) + UL <- d + (stats::qt((( + 100 - (100 * conf.int) + ) / 100) / 2, + result$parameter)) * abs(d) / stats::qt(result$p.value / + 2, + result$parameter) + } + + + ###MBI + negative <- round(100 * (ifelse((d--SWC) > 0, + stats::pt((d--SWC) / abs(d) * abs(result$statistic), + result$parameter, + lower.tail = F + ), + (1 - stats::pt((-SWC - d) / abs(d) * + abs(result$statistic), + result$parameter, + lower.tail = F + )) + )), + digits = 1) + positive <- round(100 * (ifelse((d - SWC) > 0, + (1 - stats::pt((d - + SWC) / + abs(d) * abs(result$statistic), + result$parameter, + lower.tail = F + )), + stats::pt((SWC - d) / abs(d) * abs(result$statistic), + result$parameter, + lower.tail = F + ) + )), digits = 1) + trivial <- round((100 - positive - negative), digits = 1) + + lower <- ifelse(negative < 0.5, + "Most Unlikely", + ifelse( + negative < + 5, + "Very Unlikely", + ifelse( + negative < 25, + "Unlikely", + ifelse( + negative < 75, + "Possibly", + ifelse( + negative < + 95, + "Likely", + ifelse( + negative < 99, + "Most Likely", + ifelse(negative >= 99, "Almost Certainly") + ) + ) + ) + ) + )) + trivial2 <- ifelse(trivial < 0.5, + "Most Unlikely", + ifelse( + trivial < + 5, + "Very Unlikely", + ifelse( + trivial < 25, + "Unlikely", + ifelse( + trivial < 75, + "Possibly", + ifelse( + trivial < + 95, + "Likely", + ifelse( + trivial < 99, + "Most Likely", + ifelse(trivial >= 99, "Almost Certainly") + ) + ) + ) + ) + )) + higher <- ifelse(positive < 0.5, + "Most Unlikely", + ifelse( + positive < + 5, + "Very Unlikely", + ifelse( + positive < 25, + "Unlikely", + ifelse( + positive < 75, + "Possibly", + ifelse( + positive < + 95, + "Likely", + ifelse( + positive < 99, + "Most Likely", + ifelse(positive >= 99, "Almost Certainly") + ) + ) + ) + ) + )) + + table2 <- matrix( + c("Lower", "Trivial", "Higher", negative, + trivial, positive), + nrow = 2, + byrow = T + ) + + infer <- which.max(table2[2,]) + infer2 <- ifelse(infer == 1, lower, ifelse(infer == 2, + trivial2, ifelse(infer == 3, higher))) + mag <- ifelse(abs(d) < 0.2 || infer == 2, + "Trivial", + ifelse(abs(d) < 0.6, "Small", ifelse( + abs(d) < 1.2, + "Moderate", ifelse(abs(d) < 2, "Large", ifelse(abs(d) >= + 2, "Very Large")) + ))) + + dir <- ifelse(d < 0, "Decrease.", "Increase.") + + infer3 <- ifelse(abs(positive) >= 5 && abs(negative) > 5, + paste("Unclear Difference."), + paste(infer2, mag, dir, sep = " ")) + + #Add MBI results + + #Results + #T-test and effect size + table$setRow(rowKey=pair, list( + t=result$statistic, + df=result$parameter, + p=result$p.value)) + + #effect size + EffSize$setRow(rowKey=pair, list( + mdiff=mdiff, + diffLL=diffLL, + diffUL=diffUL, + type=type, + d=d, + dLL=LL, + dUL=UL)) + + #MBI results + MBI$setRow(rowKey=pair, list( + inference=infer3, + negative=negative, + trivial=trivial, + positive=positive)) + + #Descriptives results + desc$setRow(rowKey=pair, list( + `n[1]`=n, `m[1]`=m1, `med[1]`=med1, `sd[1]`=sd1, `se[1]`=se1, + `n[2]`=n, `m[2]`=m2, `med[2]`=med2, `sd[2]`=sd2, `se[2]`=se2)) + + } + # `self$data` contains the data + # `self$options` contains the options + # `self$results` contains the results object (to populate) + + }) +) diff --git a/R/datambipaired.h.R b/R/datambipaired.h.R new file mode 100644 index 0000000..27aef78 --- /dev/null +++ b/R/datambipaired.h.R @@ -0,0 +1,387 @@ + +# This file is automatically generated, you probably don't want to edit this + +dataMBIpairedOptions <- if (requireNamespace('jmvcore')) R6::R6Class( + "dataMBIpairedOptions", + inherit = jmvcore::Options, + public = list( + initialize = function( + pairs = NULL, + correl = TRUE, + SESOI = 0.5, + confint = 90, + desc = FALSE, ...) { + + super$initialize( + package='mbir', + name='dataMBIpaired', + requiresData=TRUE, + ...) + + private$..pairs <- jmvcore::OptionPairs$new( + "pairs", + pairs, + suggested=list( + "continuous"), + permitted=list( + "continuous", + "nominal", + "ordinal")) + private$..correl <- jmvcore::OptionBool$new( + "correl", + correl, + default=TRUE) + private$..SESOI <- jmvcore::OptionNumber$new( + "SESOI", + SESOI, + min=0, + default=0.5) + private$..confint <- jmvcore::OptionNumber$new( + "confint", + confint, + min=50, + max=99.9, + default=90) + private$..desc <- jmvcore::OptionBool$new( + "desc", + desc, + default=FALSE) + + self$.addOption(private$..pairs) + self$.addOption(private$..correl) + self$.addOption(private$..SESOI) + self$.addOption(private$..confint) + self$.addOption(private$..desc) + }), + active = list( + pairs = function() private$..pairs$value, + correl = function() private$..correl$value, + SESOI = function() private$..SESOI$value, + confint = function() private$..confint$value, + desc = function() private$..desc$value), + private = list( + ..pairs = NA, + ..correl = NA, + ..SESOI = NA, + ..confint = NA, + ..desc = NA) +) + +dataMBIpairedResults <- if (requireNamespace('jmvcore')) R6::R6Class( + inherit = jmvcore::Group, + active = list( + text = function() private$.items[["text"]], + ttest = function() private$.items[["ttest"]], + effect = function() private$.items[["effect"]], + mbi = function() private$.items[["mbi"]], + desc = function() private$.items[["desc"]]), + private = list(), + public=list( + initialize=function(options) { + super$initialize( + options=options, + name="", + title="MBI for Paired Samples") + self$add(jmvcore::Preformatted$new( + options=options, + name="text", + title="MBI for Paired Samples")) + self$add(jmvcore::Table$new( + options=options, + name="ttest", + title="Paired Samples T-Test", + rows="(pairs)", + clearWith=list( + "confint", + "SESOI"), + columns=list( + list( + `name`="i1", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="i2", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="t", + `type`="number"), + list( + `name`="df", + `type`="integer"), + list( + `name`="p", + `type`="number", + `format`="zto,pvalue")))) + self$add(jmvcore::Table$new( + options=options, + name="effect", + title="Effect Size", + rows="(pairs)", + clearWith=list( + "confint", + "SESOI"), + columns=list( + list( + `name`="i1", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="i2", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="mdiff", + `type`="number", + `title`="Mean Difference"), + list( + `name`="diffLL", + `type`="number", + `title`="Lower", + `superTitle`="Confidence Interval"), + list( + `name`="diffUL", + `type`="number", + `title`="Upper", + `superTitle`="Confidence Interval"), + list( + `name`="type", + `title`="", + `type`="text"), + list( + `name`="d", + `type`="number", + `title`="Effect Size"), + list( + `name`="dLL", + `type`="number", + `title`="Lower", + `superTitle`="Confidence Interval"), + list( + `name`="dUL", + `type`="number", + `title`="Upper", + `superTitle`="Confidence Interval")))) + self$add(jmvcore::Table$new( + options=options, + name="mbi", + title="Magnitude Based Inference", + rows="(pairs)", + clearWith=list( + "confint", + "SESOI"), + columns=list( + list( + `name`="i1", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="i2", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="negative", + `type`="number", + `title`="Negative", + `superTitle`="MBI (%)"), + list( + `name`="trivial", + `type`="number", + `title`="Trivial", + `superTitle`="MBI (%)"), + list( + `name`="positive", + `type`="number", + `title`="Positive", + `superTitle`="MBI (%)"), + list( + `name`="inference", + `title`="Inference", + `type`="text")))) + self$add(jmvcore::Table$new( + options=options, + name="desc", + title="Descriptives", + visible="(desc)", + rows="(pairs)", + clearWith=list( + "group"), + columns=list( + list( + `name`="name[1]", + `title`="", + `type`="text"), + list( + `name`="n[1]", + `title`="N", + `type`="integer"), + list( + `name`="m[1]", + `title`="Mean", + `type`="number"), + list( + `name`="med[1]", + `title`="Median", + `type`="number"), + list( + `name`="sd[1]", + `title`="SD", + `type`="number"), + list( + `name`="se[1]", + `title`="SE", + `type`="number"), + list( + `name`="name[2]", + `title`="", + `type`="text"), + list( + `name`="n[2]", + `title`="N", + `type`="integer"), + list( + `name`="m[2]", + `title`="Mean", + `type`="number"), + list( + `name`="med[2]", + `title`="Median", + `type`="number"), + list( + `name`="sd[2]", + `title`="SD", + `type`="number"), + list( + `name`="se[2]", + `title`="SE", + `type`="number"))))})) + +dataMBIpairedBase <- if (requireNamespace('jmvcore')) R6::R6Class( + "dataMBIpairedBase", + inherit = jmvcore::Analysis, + public = list( + initialize = function(options, data=NULL, datasetId="", analysisId="", revision=0) { + super$initialize( + package = 'mbir', + name = 'dataMBIpaired', + version = c(1,0,0), + options = options, + results = dataMBIpairedResults$new(options=options), + data = data, + datasetId = datasetId, + analysisId = analysisId, + revision = revision, + pause = NULL, + completeWhenFilled = FALSE) + })) + +#' MBI for Paired Samples +#' +#' +#' +#' @examples +#' \dontrun{ +#' # MBI for Paired Samples +#' +#' data('bugs', package = 'jmv') +#' +#' mbir::dataMBIpaired( +#' data = bugs, +#' pairs = list( +#' list( +#' i1="LDLF", +#' i2="LDHF"))) +#' +#' +#' +#' # +#' # Paired Samples T-Test +#' # ----------------------------------------- +#' # t df p +#' # ----------------------------------------- +#' # LDLF LDHF -6.65 90 < .001 +#' # ----------------------------------------- +#' # +#' # +#' +#' # +#' # Effect Size +#' # ----------------------------------------------------------------------------------------------------- +#' # Mean Difference Lower Upper Effect Size Lower Upper +#' # ----------------------------------------------------------------------------------------------------- +#' # LDLF LDHF -1.66 -2.08 -1.25 Cohen's d -0.641 -0.802 -0.481 +#' # ----------------------------------------------------------------------------------------------------- +#' # +#' # +#' +#' # +#' # Magnitude Based Inference +#' # -------------------------------------------------------------------------------- +#' # Negative Trivial Positive Inference +#' # -------------------------------------------------------------------------------- +#' # LDLF LDHF 92.7 7.30 0.00 Likely Moderate Decrease. +#' # -------------------------------------------------------------------------------- +#' # +#' # +#'} +#' @param data the data as a data frame +#' @param pairs a list of vectors of strings naming variables to pair from +#' \code{data} +#' @param correl \code{TRUE} (default) or \code{FALSE} , corrects the +#' standardized effect size for correlation between measurements +#' @param SESOI a number that defines the bounds for magnitude-based inference +#' @param confint 90\% (default), confidence interval for magnitude-based +#' inference +#' @param desc \code{TRUE} or \code{FALSE} (default), provide descriptive +#' statistics +#' @return A results object containing: +#' \tabular{llllll}{ +#' \code{results$text} \tab \tab \tab \tab \tab a preformatted \cr +#' \code{results$ttest} \tab \tab \tab \tab \tab a table \cr +#' \code{results$effect} \tab \tab \tab \tab \tab a table \cr +#' \code{results$mbi} \tab \tab \tab \tab \tab a table \cr +#' \code{results$desc} \tab \tab \tab \tab \tab a table \cr +#' } +#' +#' Tables can be converted to data frames with \code{asDF} or \code{\link{as.data.frame}}. For example: +#' +#' \code{results$ttest$asDF} +#' +#' \code{as.data.frame(results$ttest)} +#' +#' @export +dataMBIpaired <- function( + data, + pairs, + correl = TRUE, + SESOI = 0.5, + confint = 90, + desc = FALSE) { + + if ( ! requireNamespace('jmvcore')) + stop('dataMBIpaired requires jmvcore to be installed (restart may be required)') + + options <- dataMBIpairedOptions$new( + pairs = pairs, + correl = correl, + SESOI = SESOI, + confint = confint, + desc = desc) + + results <- dataMBIpairedResults$new( + options = options) + + analysis <- dataMBIpairedClass$new( + options = options, + data = data) + + analysis$run() + + analysis$results +} diff --git a/R/datambitwo.b.R b/R/datambitwo.b.R new file mode 100644 index 0000000..5f86555 --- /dev/null +++ b/R/datambitwo.b.R @@ -0,0 +1,306 @@ + +# This file is a generated template, your changes will not be overwritten + +dataMBItwoClass <- if (requireNamespace('jmvcore')) R6::R6Class( + "dataMBItwoClass", + inherit = dataMBItwoBase, + private = list( + .init = function() { + + + table <- self$results$ttest + EffSize <- self$results$effect + MBI <- self$results$mbi + desc <- self$results$desc + + EffSize$getColumn('diffLL')$setSuperTitle(jmvcore::format('{}% Confidence Interval', self$options$confint)) + EffSize$getColumn('diffUL')$setSuperTitle(jmvcore::format('{}% Confidence Interval', self$options$confint)) + EffSize$getColumn('dLL')$setSuperTitle(jmvcore::format('{}% Confidence Interval', self$options$confint)) + EffSize$getColumn('dUL')$setSuperTitle(jmvcore::format('{}% Confidence Interval', self$options$confint)) + + groupName <- self$options$group + + groups <- NULL + if ( ! is.null(groupName)) + groups <- base::levels(self$data[[groupName]]) + if (length(groups) != 2) + groups <- c('Group 1', 'Group 2') + + desc <- self$results$desc + for (key in desc$rowKeys) { + desc$setRow(rowKey=key, values=list( + `name[1]`=groups[1], + `name[2]`=groups[2])) + } + + if ( ! self$options$varEq) + table$setNote('varEq', "Welch's, unequal variances, t-test") + + }, + + + .run = function() { + + if (is.null(self$options$group) || length(self$options$deps) == 0) + return() + + table <- self$results$ttest + EffSize <- self$results$effect + MBI <- self$results$mbi + desc <- self$results$desc + + + + conf.int <- (self$options$confint)/100 + SWC <- self$options$SWC + + groupName <- self$options$group + group <- self$data[[groupName]] + group <- as.factor(group) + group <- droplevels(group) + + groupLevels <- base::levels(group) + if (length(groupLevels) != 2) + jmvcore::reject("Grouping variable must have exactly 2 levels", code="grouping_var_must_have_2_levels") + + for (depName in self$options$deps) { + + #formula <- jmvcore::constructFormula(dep, self$options$group) + #formula <- as.formula(formula) + + #result <- t.test(formula, self$data, var.equal=self$options$varEq) + + dep <- self$data[[depName]] + dep <- jmvcore::toNumeric(dep) + dataTTest <- data.frame(dep=dep, group=group) + dataTTest <- na.omit(dataTTest) + + n <- tapply(dataTTest$dep, dataTTest$group, length) + n1 <- n[1] + n2 <- n[2] + + v <- tapply(dataTTest$dep, dataTTest$group, function(x) jmvcore::tryNaN(var(x))) + v1 <- v[1] + v2 <- v[2] + + m <- tapply(dataTTest$dep, dataTTest$group, function(x) jmvcore::tryNaN(mean(x))) + m1 <- m[1] + m2 <- m[2] + + med <- tapply(dataTTest$dep, dataTTest$group, function(x) jmvcore::tryNaN(median(x))) + med1 <- med[1] + med2 <- med[2] + + se <- sqrt(v/n) + se1 <- se[1] + se2 <- se[2] + + sd <- sqrt(v) + sd1 <- sd[1] + sd2 <- sd[2] + + result <- t.test(dep ~ group, dataTTest, var.equal=self$options$varEq) + + mdiff <- unname(result$estimate[1]-result$estimate[2]) + diffLL <- unname(result$conf.int[1]) + diffUL <- unname(result$conf.int[2]) + + ind.stdr <- sqrt(1 / n[1] + 1 / n[2]) + + d <- result$statistic * ind.stdr + + LL <- d - (stats::qt((( + 100 - (100 * conf.int) + ) / 100) / 2, + result$parameter)) * abs(d) / stats::qt(result$p.value / + 2, + result$parameter) + + UL <- d + (stats::qt((( + 100 - (100 * conf.int) + ) / 100) / 2, + result$parameter)) * abs(d) / stats::qt(result$p.value / + 2, + result$parameter) + type <- paste("Cohen's d") + + if (result$parameter < 30) { + type <- paste("Hedge's g") + d <- d * (1 - (3 / (4 * ( + result$parameter - 1 + )))) + LL <- LL * (1 - (3 / (4 * ( + result$parameter - 1 + )))) + UL <- UL * (1 - (3 / (4 * ( + result$parameter - 1 + )))) + } + + negative <- round(100 * (ifelse((d--SWC) > 0, + stats::pt((d--SWC) / abs(d) * abs(result$statistic), + result$parameter, + lower.tail = F + ), + (1 - stats::pt((-SWC - d) / abs(d) * + abs(result$statistic), + result$parameter, + lower.tail = F + )) + )), + digits = 1) + positive <- round(100 * (ifelse((d - SWC) > 0, + (1 - stats::pt((d - + SWC) / + abs(d) * abs(result$statistic), + result$parameter, + lower.tail = F + )), + stats::pt((SWC - d) / abs(d) * abs(result$statistic), + result$parameter, + lower.tail = F + ) + )), digits = 1) + trivial <- round((100 - positive - negative), digits = 1) + + lower <- ifelse(negative < 0.5, + "Most Unlikely", + ifelse( + negative < + 5, + "Very Unlikely", + ifelse( + negative < 25, + "Unlikely", + ifelse( + negative < 75, + "Possibly", + ifelse( + negative < + 95, + "Likely", + ifelse( + negative < 99, + "Most Likely", + ifelse(negative >= 99, "Almost Certainly") + ) + ) + ) + ) + )) + trivial2 <- ifelse(trivial < 0.5, + "Most Unlikely", + ifelse( + trivial < + 5, + "Very Unlikely", + ifelse( + trivial < 25, + "Unlikely", + ifelse( + trivial < 75, + "Possibly", + ifelse( + trivial < + 95, + "Likely", + ifelse( + trivial < 99, + "Most Likely", + ifelse(trivial >= 99, "Almost Certainly") + ) + ) + ) + ) + )) + higher <- ifelse(positive < 0.5, + "Most Unlikely", + ifelse( + positive < + 5, + "Very Unlikely", + ifelse( + positive < 25, + "Unlikely", + ifelse( + positive < 75, + "Possibly", + ifelse( + positive < + 95, + "Likely", + ifelse( + positive < 99, + "Most Likely", + ifelse(positive >= 99, "Almost Certainly") + ) + ) + ) + ) + )) + + table2 <- matrix( + c("Lower", "Trivial", "Higher", negative, + trivial, positive), + nrow = 2, + byrow = T + ) + + infer <- which.max(table2[2,]) + infer2 <- ifelse(infer == 1, lower, ifelse(infer == 2, + trivial2, ifelse(infer == 3, higher))) + mag <- ifelse(abs(d) < 0.2 || infer == 2, + "Trivial", + ifelse(abs(d) < 0.6, "Small", ifelse( + abs(d) < 1.2, + "Moderate", ifelse(abs(d) < 2, "Large", ifelse(abs(d) >= + 2, "Very Large")) + ))) + + dir <- ifelse(d < 0, "Decrease.", "Increase.") + + infer3 <- ifelse(abs(positive) >= 5 && abs(negative) > 5, + paste("Unclear Difference."), + paste(infer2, mag, dir, sep = " ")) + + table$setRow(rowKey=depName, list( + t=result$statistic, + df=result$parameter, + p=result$p.value)) + + #effect size + EffSize$setRow(rowKey=depName, list( + mdiff=mdiff, + diffLL=diffLL, + diffUL=diffUL, + type=type, + d=d, + dLL=LL, + dUL=UL)) + + MBI$setRow(rowKey=depName, list( + inference=infer3, + negative=negative, + trivial=trivial, + positive=positive)) + + desc$setRow(rowKey=depName, list( + `n[1]`=n[1], `m[1]`=m[1], `med[1]`=med[1], `sd[1]`=sd[1], `se[1]`=se[1], + `n[2]`=n[2], `m[2]`=m[2], `med[2]`=med[2], `sd[2]`=sd[2], `se[2]`=se[2])) + #desc$setRow(rowKey=dep, values=list( + # `n[1]`=n[1], m[1]=m[1], med[1]=med[1], sd[1]=sd[1], se[1]=se[1], + #n[2]=n[2], m[2]=m[2], med[2]=med[2], sd[2]=sd[2], se[2]=se[2])) + + } + + + + + + # `self$data` contains the data + # `self$options` contains the options + # `self$results` contains the results object (to populate) + + } + ) +) diff --git a/R/datambitwo.h.R b/R/datambitwo.h.R new file mode 100644 index 0000000..e760a49 --- /dev/null +++ b/R/datambitwo.h.R @@ -0,0 +1,374 @@ + +# This file is automatically generated, you probably don't want to edit this + +dataMBItwoOptions <- if (requireNamespace('jmvcore')) R6::R6Class( + "dataMBItwoOptions", + inherit = jmvcore::Options, + public = list( + initialize = function( + deps = NULL, + group = NULL, + varEq = TRUE, + SESOI = 0.5, + confint = 90, + desc = FALSE, ...) { + + super$initialize( + package='mbir', + name='dataMBItwo', + requiresData=TRUE, + ...) + + private$..deps <- jmvcore::OptionVariables$new( + "deps", + deps, + suggested=list( + "continuous"), + permitted=list( + "continuous", + "nominal", + "ordinal"), + rejectInf=FALSE) + private$..group <- jmvcore::OptionVariable$new( + "group", + group, + suggested=list( + "nominal", + "ordinal")) + private$..varEq <- jmvcore::OptionBool$new( + "varEq", + varEq, + default=TRUE) + private$..SESOI <- jmvcore::OptionNumber$new( + "SESOI", + SESOI, + min=0, + default=0.5) + private$..confint <- jmvcore::OptionNumber$new( + "confint", + confint, + min=50, + max=99.9, + default=90) + private$..desc <- jmvcore::OptionBool$new( + "desc", + desc, + default=FALSE) + + self$.addOption(private$..deps) + self$.addOption(private$..group) + self$.addOption(private$..varEq) + self$.addOption(private$..SESOI) + self$.addOption(private$..confint) + self$.addOption(private$..desc) + }), + active = list( + deps = function() private$..deps$value, + group = function() private$..group$value, + varEq = function() private$..varEq$value, + SESOI = function() private$..SESOI$value, + confint = function() private$..confint$value, + desc = function() private$..desc$value), + private = list( + ..deps = NA, + ..group = NA, + ..varEq = NA, + ..SESOI = NA, + ..confint = NA, + ..desc = NA) +) + +dataMBItwoResults <- if (requireNamespace('jmvcore')) R6::R6Class( + inherit = jmvcore::Group, + active = list( + text = function() private$.items[["text"]], + ttest = function() private$.items[["ttest"]], + effect = function() private$.items[["effect"]], + mbi = function() private$.items[["mbi"]], + desc = function() private$.items[["desc"]]), + private = list(), + public=list( + initialize=function(options) { + super$initialize( + options=options, + name="", + title="MBI for Independent Samples T-Test") + self$add(jmvcore::Preformatted$new( + options=options, + name="text", + title="Independent Samples Magnitude-Based Inference")) + self$add(jmvcore::Table$new( + options=options, + name="ttest", + title="Independent Samples T-Test", + rows="(deps)", + columns=list( + list( + `name`="var", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="t", + `type`="number"), + list( + `name`="df", + `type`="integer"), + list( + `name`="p", + `type`="number", + `format`="zto,pvalue")))) + self$add(jmvcore::Table$new( + options=options, + name="effect", + title="Effect Size", + rows="(deps)", + clearWith=list( + "confint", + "SESOI"), + columns=list( + list( + `name`="var", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="mdiff", + `type`="number", + `title`="Mean Difference"), + list( + `name`="diffLL", + `type`="number", + `title`="Lower", + `superTitle`="Confidence Interval"), + list( + `name`="diffUL", + `type`="number", + `title`="Upper", + `superTitle`="Confidence Interval"), + list( + `name`="type", + `title`="", + `type`="text"), + list( + `name`="d", + `type`="number", + `title`="Effect Size"), + list( + `name`="dLL", + `type`="number", + `title`="Lower", + `superTitle`="Confidence Interval"), + list( + `name`="dUL", + `type`="number", + `title`="Upper", + `superTitle`="Confidence Interval")))) + self$add(jmvcore::Table$new( + options=options, + name="mbi", + title="Magnitude Based Inference", + rows="(deps)", + columns=list( + list( + `name`="var", + `title`="", + `type`="text", + `content`="($key)"), + list( + `name`="negative", + `type`="number", + `title`="Negative", + `superTitle`="MBI (%)"), + list( + `name`="trivial", + `type`="number", + `title`="Trivial", + `superTitle`="MBI (%)"), + list( + `name`="positive", + `type`="number", + `title`="Positive", + `superTitle`="MBI (%)"), + list( + `name`="inference", + `title`="Inference", + `type`="text")))) + self$add(jmvcore::Table$new( + options=options, + name="desc", + title="Descriptives", + visible="(desc)", + rows="(deps)", + clearWith=list( + "group"), + columns=list( + list( + `name`="name[1]", + `title`="", + `type`="text"), + list( + `name`="n[1]", + `title`="N", + `type`="integer"), + list( + `name`="m[1]", + `title`="Mean", + `type`="number"), + list( + `name`="med[1]", + `title`="Median", + `type`="number"), + list( + `name`="sd[1]", + `title`="SD", + `type`="number"), + list( + `name`="se[1]", + `title`="SE", + `type`="number"), + list( + `name`="name[2]", + `title`="", + `type`="text"), + list( + `name`="n[2]", + `title`="N", + `type`="integer"), + list( + `name`="m[2]", + `title`="Mean", + `type`="number"), + list( + `name`="med[2]", + `title`="Median", + `type`="number"), + list( + `name`="sd[2]", + `title`="SD", + `type`="number"), + list( + `name`="se[2]", + `title`="SE", + `type`="number"))))})) + +dataMBItwoBase <- if (requireNamespace('jmvcore')) R6::R6Class( + "dataMBItwoBase", + inherit = jmvcore::Analysis, + public = list( + initialize = function(options, data=NULL, datasetId="", analysisId="", revision=0) { + super$initialize( + package = 'mbir', + name = 'dataMBItwo', + version = c(1,0,0), + options = options, + results = dataMBItwoResults$new(options=options), + data = data, + datasetId = datasetId, + analysisId = analysisId, + revision = revision, + pause = NULL, + completeWhenFilled = TRUE) + })) + +#' MBI for Independent Samples +#' +#' +#' +#' @examples +#' \dontrun{ +#' +#' data('bugs', package = 'jmv') +#' +#' mbir::dataMBItwo( +#' data = bugs, +#' deps = "LDLF", +#' group = "Gender") +#' +#' # +#' # Independent Samples T-Test +#' # ------------------------------- +#' # t df p +#' # ------------------------------- +#' # LDLF 1.47 60 0.147 +#' # ------------------------------- +#' # Note. Welch's, unequal +#' # variances, t-test +#' # +#' # +#' +#' # +#' # Effect Size +#' # ---------------------------------------------------------------------------------------------- +#' # Mean Difference Lower Upper Effect Size Lower Upper +#' # ---------------------------------------------------------------------------------------------- +#' # LDLF 0.857 -0.309 2.02 Cohen's d 0.330 -0.0450 0.705 +#' # ---------------------------------------------------------------------------------------------- +#' # +#' # +#' +#' # +#' # Magnitude Based Inference +#' # ----------------------------------------------------------------------- +#' # Negative Trivial Positive Inference +#' # ----------------------------------------------------------------------- +#' # LDLF 0.00 77.4 22.6 Likely Trivial Increase. +#' # ----------------------------------------------------------------------- +#' # +#' # +#'} +#' @param data the data as a data frame +#' @param deps a vector of strings naming the dependent variables +#' @param group a string naming the grouping variable, must have 2 levels +#' @param varEq \code{TRUE} or \code{FALSE} (default), assume equal variances +#' @param SESOI a number that defines the bounds for magnitude-based inference +#' @param confint 90\% (default) confidence intervals for effect sizes +#' @param desc \code{TRUE} or \code{FALSE} (default), provide descriptive +#' statistics +#' @return A results object containing: +#' \tabular{llllll}{ +#' \code{results$text} \tab \tab \tab \tab \tab a preformatted \cr +#' \code{results$ttest} \tab \tab \tab \tab \tab a table \cr +#' \code{results$effect} \tab \tab \tab \tab \tab a table \cr +#' \code{results$mbi} \tab \tab \tab \tab \tab a table \cr +#' \code{results$desc} \tab \tab \tab \tab \tab a table \cr +#' } +#' +#' Tables can be converted to data frames with \code{asDF} or \code{\link{as.data.frame}}. For example: +#' +#' \code{results$ttest$asDF} +#' +#' \code{as.data.frame(results$ttest)} +#' +#' @export +dataMBItwo <- function( + data, + deps, + group, + varEq = TRUE, + SESOI = 0.5, + confint = 90, + desc = FALSE) { + + if ( ! requireNamespace('jmvcore')) + stop('dataMBItwo requires jmvcore to be installed (restart may be required)') + + options <- dataMBItwoOptions$new( + deps = deps, + group = group, + varEq = varEq, + SESOI = SESOI, + confint = confint, + desc = desc) + + results <- dataMBItwoResults$new( + options = options) + + analysis <- dataMBItwoClass$new( + options = options, + data = data) + + analysis$run() + + analysis$results +} diff --git a/jamovi/0000.yaml b/jamovi/0000.yaml new file mode 100644 index 0000000..eb9bbf0 --- /dev/null +++ b/jamovi/0000.yaml @@ -0,0 +1,46 @@ +--- +title: mbir - Magnitude Based Inference +name: mbir +version: 0.0.1 +jms: '1.0' +authors: + - Aaron Caldwell & Kyle Peterson +maintainer: Aaron R Caldwell +date: '2018-04-09' +type: R +description: >- + This jamovi module allows practitioners and researchers a wholesale approach for + deriving magnitude-based inferences from raw data in a point-and-click + fashion. +analyses: + - title: MBI for Independent Samples + name: dataMBItwo + ns: mbir + menuGroup: mbir + menuTitle: MBI for Independent Samples + - title: MBI for Paired Samples + name: dataMBIpaired + ns: mbir + menuGroup: mbir + menuTitle: MBI for Paired Samples + - title: MBI for Correlation + name: dataMBIcorr + ns: mbir + menuGroup: mbir + menuTitle: MBI for Correlation + - title: MBI for Independent Samples (non-parametric) + name: dataMBInpind + ns: mbir + menuGroup: mbir + menuTitle: MBI for Independent Samples + menuSubgroup: Non-Parametric + menuSubtitle: Mann-Whitney U test + - title: MBI for Paired Samples (non-parametric) + name: dataMBInppair + ns: mbir + menuGroup: mbir + menuTitle: MBI for Paired Samples + menuSubgroup: Non-Parametric + menuSubtitle: Wilcoxon signed-rank test + +... diff --git a/jamovi/datambicorr.a.yaml b/jamovi/datambicorr.a.yaml new file mode 100644 index 0000000..87a7851 --- /dev/null +++ b/jamovi/datambicorr.a.yaml @@ -0,0 +1,99 @@ +--- +name: dataMBIcorr +title: MBI for Correlation +menuGroup: mbir +version: '1.0.0' +jas: '1.1' + +description: + R: + usage: | + + data('bugs', package = 'jmv') + + mbir::dataMBIcorr( + data = data, + pairs = list( + list( + i1="LDLF", + i2="LDHF"))) + + # + # Magnitude Based Inference: Correlation + # ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + # p Negative (%) Trivial (%) Positive (%) Inference + # ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + # LDLF LDHF Pearson's r 0.577 < .001 0.00 0.00 100 Almost Certainly Large Positive Correlation. + # ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── + # + # + + +options: + - name: data + type: Data + description: + R: the data as a data frame + + - name: pairs + title: Paired Variables + type: Pairs + suggested: [continuous] + permitted: [continuous, nominal, ordinal] + description: + R: a list of vectors of strings naming variables to pair from `data` + + + - name: pearson + title: Pearson + type: Bool + default: true + description: + R: > + `TRUE` (default) or `FALSE`, provide Pearson's R + + - name: spear + title: Spearman + type: Bool + default: false + description: + R: > + `TRUE` or `FALSE` (default), provide Spearman's rho + + - name: kendall + title: Kendall's + type: Bool + default: false + description: + R: > + `TRUE` or `FALSE` (default), provide Kendall's tau-b + + - name: SWC + title: Threshold Bound (correlation coefficient) + type: Number + min: 0.01 + max: 0.9 + default: 0.1 + description: + R: > + a number, default (r=0.1) that defines the bounds for magnitude-based inference + + - name: confint + title: Confidence Interval (%) + type: Number + min: 50.0 + max: 99.9 + default: 90 + description: + R: > + 90% (default), confidence interval for magnitude-based inference + + - name: desc + title: Descriptive statistics + type: Bool + default: false + description: + R: > + `TRUE` or `FALSE` (default), provide descriptive statistics + +... diff --git a/jamovi/datambicorr.r.yaml b/jamovi/datambicorr.r.yaml new file mode 100644 index 0000000..d445bb7 --- /dev/null +++ b/jamovi/datambicorr.r.yaml @@ -0,0 +1,198 @@ +--- +name: dataMBIcorr +title: MBI for Correlation +jrs: '1.1' + +items: + - name: text + title: MBI for Correlation + type: Preformatted + + - name: mbi + title: "Magnitude Based Inference: Correlation" + type: Table + rows: (pairs) + clearWith: + - confint + - SWC + columns: + - name: i1 + title: '' + type: text + content: ($key) + - name: i2 + title: '' + type: text + content: ($key) + - name: b[0] + title: '' + type: text + content: Pearson's r + visible: (pearson) + - name: correl[0] + title: "" + type: Number + visible: (pearson) + - name: p[0] + title: "p" + type: Number + format: zto,pvalue + visible: (pearson) + #- name: z[0] + # title: "Fisher's z" + # type: Number + # visible: (pearson) + #- name: zSE[0] + # title: "+/- SE" + # type: Number + # visible: (pearson) + - name: Negative[0] + type: Number + title: Negative (%) + visible: (pearson) + - name: Trivial[0] + type: Number + title: Trivial (%) + visible: (pearson) + - name: Positive[0] + type: Number + title: Positive (%) + visible: (pearson) + - name: Inference[0] + title: Inference + type: text + visible: (pearson) + - name: b[1] + title: '' + type: text + content: Spearman's rho + visible: (spear) + - name: correl[1] + title: "" + type: Number + visible: (spear) + - name: p[1] + title: "p" + type: Number + format: zto,pvalue + visible: (spear) + #- name: z[1] + # title: "Fisher's z" + # type: Number + # visible: (spear) + #- name: zSE[1] + # title: "+/- SE" + # type: Number + # visible: (spear) + - name: Negative[1] + type: Number + title: Negative (%) + visible: (spear) + - name: Trivial[1] + type: Number + title: Trivial (%) + visible: (spear) + - name: Positive[1] + type: Number + title: Positive (%) + visible: (spear) + - name: Inference[1] + title: Inference + type: text + visible: (spear) + - name: b[2] + title: '' + type: text + content: Kendall's tau-b + visible: (kendall) + - name: correl[2] + title: "" + type: Number + visible: (kendall) + - name: p[2] + title: "p" + type: Number + format: zto,pvalue + visible: (kendall) + #- name: z[2] + # title: "Fisher's z" + # type: Number + # visible: (kendall) + #- name: zSE[2] + # title: "+/- SE" + # type: Number + # visible: (kendall) + - name: Negative[2] + type: Number + title: Negative (%) + visible: (kendall) + - name: Trivial[2] + type: Number + title: Trivial (%) + visible: (kendall) + - name: Positive[2] + type: Number + title: Positive (%) + visible: (kendall) + - name: Inference[2] + title: Inference + type: text + visible: (kendall) + + - name: desc + title: Descriptives + type: Table + visible: (desc) + rows: (pairs) + clearWith: + - group + + columns: + - name: name[1] + title: "" + type: text + + - name: n[1] + title: "N" + type: integer + + - name: m[1] + title: Mean + type: number + + - name: med[1] + title: Median + type: number + + - name: sd[1] + title: SD + type: number + + - name: se[1] + title: SE + type: number + + - name: name[2] + title: "" + type: text + + - name: n[2] + title: "N" + type: integer + + - name: m[2] + title: Mean + type: number + + - name: med[2] + title: Median + type: number + + - name: sd[2] + title: SD + type: number + + - name: se[2] + title: SE + type: number +... diff --git a/jamovi/datambicorr.u.yaml b/jamovi/datambicorr.u.yaml new file mode 100644 index 0000000..03adf8b --- /dev/null +++ b/jamovi/datambicorr.u.yaml @@ -0,0 +1,76 @@ +title: MBI for Correlation +name: dataMBIcorr +jus: '2.0' +stage: 0 +compilerMode: tame +children: + - type: VariableSupplier + suggested: + - continuous + permitted: + - continuous + - ordinal + persistentItems: true + stretchFactor: 1 + children: + - type: TargetLayoutBox + label: Paired Variables + children: + - type: VariablesListBox + name: pairs + fullRowSelect: true + isTarget: true + columns: + - name: i1 + stretchFactor: 1 + template: + type: VariableLabel + - name: i2 + stretchFactor: 1 + template: + type: VariableLabel + + + - type: LayoutBox + margin: large + stretchFactor: 1 + children: + - type: LayoutBox + cell: + column: 0 + row: 0 + stretchFactor: 1 + children: + - type: Label + label: Type of Correlation + children: + - type: CheckBox + name: pearson + - type: CheckBox + name: spear + - type: CheckBox + name: kendall + + - type: LayoutBox + margin: large + stretchFactor: 1 + children: + - type: LayoutBox + cell: + column: 0 + row: 0 + stretchFactor: 1 + children: + - type: Label + label: Options + children: + - type: TextBox + name: SWC + format: number + inputPattern: '[0-9]+' + - type: TextBox + name: confint + format: number + inputPattern: '[0-9]+' + - type: CheckBox + name: desc diff --git a/jamovi/datambinpind.a.yaml b/jamovi/datambinpind.a.yaml new file mode 100644 index 0000000..30ddb53 --- /dev/null +++ b/jamovi/datambinpind.a.yaml @@ -0,0 +1,107 @@ +--- +name: dataMBInpind +title: MBI for Independent Samples (non-parametric) +menuGroup: mbir +menuSubgroup: Non-Parametric +menuTitle: MBI for Independent Samples +menuSubtitle: Mann-Whitney U test +version: '1.0.0' +jas: '1.1' + + +description: + R: + usage: | + + data('bugs', package = 'jmv') + + mbir::dataMBInpind( + data = bugs, + deps = "LDLF", + group = "Gender") + + # + # Mann-Whitney U-Test + # ────────────────────────────── + # statistic p + # ────────────────────────────── + # LDLF 1054 0.237 + # ────────────────────────────── + # + # + + # + # Effect Size + # ─────────────────────────────────────────────── + # Effect Size (r) Lower Upper + # ─────────────────────────────────────────────── + # LDLF 0.123 -0.0503 0.290 + # ─────────────────────────────────────────────── + # + # + + # + # Magnitude Based Inference + # ───────────────────────────────────────────────────────────────────────── + # Negative Trivial Positive Inference + # ───────────────────────────────────────────────────────────────────────── + # LDLF 1.70 39.3 59.0 Possibly Small Effect Size + # ───────────────────────────────────────────────────────────────────────── + # + # + + +options: + - name: data + type: Data + description: + R: the data as a data frame + + - name: deps + title: Dependent Variables + type: Variables + suggested: + - continuous + permitted: + - continuous + - nominal + - ordinal + rejectInf: false + description: + R: a vector of strings naming the dependent variables + + - name: group + title: Grouping Variable + type: Variable + suggested: + - nominal + - ordinal + description: + R: a string naming the grouping variable, must have 2 levels + + - name: SWC + title: Smallest Worthwhile Change (effect size) + type: Number + min: 0 + default: 0.5 + description: + R: a number that defines the bounds for magnitude-based inference + + - name: confint + title: Confidence Interval (%) + type: Number + min: 50.0 + max: 99.9 + default: 90 + description: + R: > + 90% (default) confidence intervals for effect sizes + + - name: desc + title: Descriptive statistics + type: Bool + default: false + description: + R: > + `TRUE` or `FALSE` (default), provide descriptive statistics +... diff --git a/jamovi/datambinpind.r.yaml b/jamovi/datambinpind.r.yaml new file mode 100644 index 0000000..194f36e --- /dev/null +++ b/jamovi/datambinpind.r.yaml @@ -0,0 +1,134 @@ +--- +name: dataMBInpind +title: MBI for Independent Samples (non-parametric) +jrs: '1.1' + +items: + - name: text + title: MBI for Mann-Whitney + type: Preformatted + + - name: ttest + title: Mann-Whitney U-Test + type: Table + rows: (deps) + columns: + - name: var + title: '' + type: text + content: ($key) + - name: statistic + type: number + - name: p + type: number + format: zto,pvalue + + + - name: effect + title: Effect Size + type: Table + rows: (deps) + clearWith: + - confint + - SWC + columns: + - name: var + title: '' + type: text + content: ($key) + - name: r + type: number + title: Effect Size (r) + - name: rLL + type: number + title: Lower + superTitle: Confidence Interval + - name: rUL + type: number + title: Upper + superTitle: Confidence Interval + + - name: mbi + title: Magnitude Based Inference + type: Table + rows: (deps) + columns: + - name: var + title: '' + type: text + content: ($key) + - name: negative + type: number + title: Negative + superTitle: MBI (%) + - name: trivial + type: number + title: Trivial + superTitle: MBI (%) + - name: positive + type: number + title: Positive + superTitle: MBI (%) + - name: inference + title: Inference + type: text + + + - name: desc + title: Descriptives + type: Table + visible: (desc) + rows: (deps) + clearWith: + - group + + columns: + - name: name[1] + title: "" + type: text + + - name: n[1] + title: "N" + type: integer + + - name: m[1] + title: Mean + type: number + + - name: med[1] + title: Median + type: number + + - name: sd[1] + title: SD + type: number + + - name: se[1] + title: SE + type: number + + - name: name[2] + title: "" + type: text + + - name: n[2] + title: "N" + type: integer + + - name: m[2] + title: Mean + type: number + + - name: med[2] + title: Median + type: number + + - name: sd[2] + title: SD + type: number + + - name: se[2] + title: SE + type: number + +... diff --git a/jamovi/datambinpind.u.yaml b/jamovi/datambinpind.u.yaml new file mode 100644 index 0000000..7c11dc7 --- /dev/null +++ b/jamovi/datambinpind.u.yaml @@ -0,0 +1,47 @@ +title: MBI for Independent Samples (non-parametric) +name: dataMBInpind +jus: '2.0' +stage: 0 +compilerMode: tame +children: + - type: VariableSupplier + persistentItems: false + stretchFactor: 1 + children: + - type: TargetLayoutBox + label: Dependent Variables + children: + - type: VariablesListBox + name: deps + isTarget: true + - type: TargetLayoutBox + label: Grouping Variable + children: + - type: VariablesListBox + name: group + maxItemCount: 1 + isTarget: true + + - type: LayoutBox + margin: large + stretchFactor: 1 + children: + - type: LayoutBox + cell: + column: 0 + row: 0 + stretchFactor: 1 + children: + - type: Label + label: Options + children: + - type: TextBox + name: SWC + format: number + inputPattern: '[0-9]+' + - type: TextBox + name: confint + format: number + inputPattern: '[0-9]+' + - type: CheckBox + name: desc diff --git a/jamovi/datambinppair.a.yaml b/jamovi/datambinppair.a.yaml new file mode 100644 index 0000000..a38ca2c --- /dev/null +++ b/jamovi/datambinppair.a.yaml @@ -0,0 +1,93 @@ +--- +name: dataMBInppair +title: MBI for Paired Samples (non-parametric) +menuGroup: mbir +menuSubgroup: Non-Parametric +menuTitle: MBI for Paired Samples +menuSubtitle: Wilcoxon signed-rank test +version: '1.0.0' +jas: '1.1' + +description: + R: + usage: | + + data('bugs', package = 'jmv') + + mbir::dataMBInppair( + data = bugs, + pairs = list( + list( + i1="LDHF", + i2="LDLF"))) + + # Wilcoxon signed-rank test + # ─────────────────────────────────────── + # statistic p + # ─────────────────────────────────────── + # LDHF LDLF 2250 < .001 + # ─────────────────────────────────────── + # + # + + # + # Effect Size + # ───────────────────────────────────────────────── + # Effect Size Lower Upper + # ───────────────────────────────────────────────── + # LDHF LDLF 0.585 0.458 0.689 + # ───────────────────────────────────────────────── + # + # + + # + # Magnitude Based Inference + # ───────────────────────────────────────────────────────────────────────────────────────── + # Negative Trivial Positive Inference + # ───────────────────────────────────────────────────────────────────────────────────────── + # LDHF LDLF 0.00 0.00 100 Almost Certainly Large Effect Size + # ───────────────────────────────────────────────────────────────────────────────────────── + # + # + + +options: + - name: data + type: Data + description: + R: the data as a data frame + + - name: pairs + title: Paired Variables + type: Pairs + suggested: [continuous] + permitted: [continuous, nominal, ordinal] + description: + R: a list of vectors of strings naming variables to pair from `data` + + - name: SWC + title: Smallest worthwhile change (effect size) + type: Number + min: 0 + default: 0.5 + description: + R: a number that defines the bounds for magnitude-based inference + + - name: confint + title: Confidence Interval (%) + type: Number + min: 50.0 + max: 99.9 + default: 90 + description: + R: > + 90% (default), confidence interval for magnitude-based inference + + - name: desc + title: Descriptive statistics + type: Bool + default: false + description: + R: > + `TRUE` or `FALSE` (default), provide descriptive statistics +... diff --git a/jamovi/datambinppair.r.yaml b/jamovi/datambinppair.r.yaml new file mode 100644 index 0000000..37b0af1 --- /dev/null +++ b/jamovi/datambinppair.r.yaml @@ -0,0 +1,150 @@ +--- +name: dataMBInppair +title: MBI for Paired Samples (non-parametric) +jrs: '1.1' + +items: + - name: text + title: MBI for Wilcoxon signed-rank test + type: Preformatted + + - name: ttest + title: Wilcoxon signed-rank test + type: Table + rows: (pairs) + clearWith: + - confint + - SWC + columns: + - name: i1 + title: '' + type: text + content: ($key) + - name: i2 + title: '' + type: text + content: ($key) + - name: statistic + type: number + - name: p + type: number + format: zto,pvalue + + - name: effect + title: Effect Size + type: Table + rows: (pairs) + clearWith: + - confint + - SWC + columns: + - name: i1 + title: '' + type: text + content: ($key) + - name: i2 + title: '' + type: text + content: ($key) + - name: r + type: number + title: Effect Size (r) + - name: rLL + type: number + title: Lower + superTitle: Confidence Interval + - name: rUL + type: number + title: Upper + superTitle: Confidence Interval + + - name: mbi + title: Magnitude Based Inference + type: Table + rows: (pairs) + clearWith: + - confint + - SWC + columns: + - name: i1 + title: '' + type: text + content: ($key) + - name: i2 + title: '' + type: text + content: ($key) + - name: negative + type: number + title: Negative + superTitle: MBI (%) + - name: trivial + type: number + title: Trivial + superTitle: MBI (%) + - name: positive + type: number + title: Positive + superTitle: MBI (%) + - name: inference + title: Inference + type: text + + - name: desc + title: Descriptives + type: Table + visible: (desc) + rows: (pairs) + clearWith: + - group + + columns: + - name: name[1] + title: "" + type: text + + - name: n[1] + title: "N" + type: integer + + - name: m[1] + title: Mean + type: number + + - name: med[1] + title: Median + type: number + + - name: sd[1] + title: SD + type: number + + - name: se[1] + title: SE + type: number + + - name: name[2] + title: "" + type: text + + - name: n[2] + title: "N" + type: integer + + - name: m[2] + title: Mean + type: number + + - name: med[2] + title: Median + type: number + + - name: sd[2] + title: SD + type: number + + - name: se[2] + title: SE + type: number + +... diff --git a/jamovi/datambinppair.u.yaml b/jamovi/datambinppair.u.yaml new file mode 100644 index 0000000..d44f1a8 --- /dev/null +++ b/jamovi/datambinppair.u.yaml @@ -0,0 +1,55 @@ +title: MBI for non-parametric; paired samples +name: dataMBInppair +jus: '2.0' +stage: 0 +compilerMode: tame +children: + - type: VariableSupplier + suggested: + - continuous + permitted: + - continuous + - ordinal + persistentItems: true + stretchFactor: 1 + children: + - type: TargetLayoutBox + label: Paired Variables + children: + - type: VariablesListBox + name: pairs + fullRowSelect: true + isTarget: true + columns: + - name: i1 + stretchFactor: 1 + template: + type: VariableLabel + - name: i2 + stretchFactor: 1 + template: + type: VariableLabel + + - type: LayoutBox + margin: large + stretchFactor: 1 + children: + - type: LayoutBox + cell: + column: 0 + row: 0 + stretchFactor: 1 + children: + - type: Label + label: Options + children: + - type: TextBox + name: SWC + format: number + inputPattern: '[0-9]+' + - type: TextBox + name: confint + format: number + inputPattern: '[0-9]+' + - type: CheckBox + name: desc diff --git a/jamovi/datambipaired.a.yaml b/jamovi/datambipaired.a.yaml new file mode 100644 index 0000000..c314fe1 --- /dev/null +++ b/jamovi/datambipaired.a.yaml @@ -0,0 +1,103 @@ +--- +name: dataMBIpaired +title: MBI for Paired Samples +menuGroup: mbir +version: '1.0.0' +jas: '1.1' + +description: + R: + usage: | + # MBI for Paired Samples + + data('bugs', package = 'jmv') + + mbir::dataMBIpaired( + data = bugs, + pairs = list( + list( + i1="LDLF", + i2="LDHF"))) + + + + # + # Paired Samples T-Test + # ───────────────────────────────────────── + # t df p + # ───────────────────────────────────────── + # LDLF LDHF -6.65 90 < .001 + # ───────────────────────────────────────── + # + # + + # + # Effect Size + # ───────────────────────────────────────────────────────────────────────────────────────────────────── + # Mean Difference Lower Upper Effect Size Lower Upper + # ───────────────────────────────────────────────────────────────────────────────────────────────────── + # LDLF LDHF -1.66 -2.08 -1.25 Cohen's d -0.641 -0.802 -0.481 + # ───────────────────────────────────────────────────────────────────────────────────────────────────── + # + # + + # + # Magnitude Based Inference + # ──────────────────────────────────────────────────────────────────────────────── + # Negative Trivial Positive Inference + # ──────────────────────────────────────────────────────────────────────────────── + # LDLF LDHF 92.7 7.30 0.00 Likely Moderate Decrease. + # ──────────────────────────────────────────────────────────────────────────────── + # + # + +options: + - name: data + type: Data + description: + R: the data as a data frame + + - name: pairs + title: Paired Variables + type: Pairs + suggested: [continuous] + permitted: [continuous, nominal, ordinal] + description: + R: a list of vectors of strings naming variables to pair from `data` + + - name: correl + title: "Apply correction for correlation between the measurements? (Lakens, 2013)" + type: Bool + default: true + description: + R: > + `TRUE` (default) or `FALSE` , corrects the standardized effect size for correlation between measurements + + - name: SWC + title: Smallest worthwhile change (Effect Size) + type: Number + min: 0 + default: 0.5 + description: + R: a number that defines the bounds for magnitude-based inference + + - name: confint + title: Confidence Interval (%) + type: Number + min: 50.0 + max: 99.9 + default: 90 + description: + R: > + 90% (default), confidence interval for magnitude-based inference + + - name: desc + title: Descriptive statistics + type: Bool + default: false + description: + R: > + `TRUE` or `FALSE` (default), provide descriptive statistics + + +... diff --git a/jamovi/datambipaired.r.yaml b/jamovi/datambipaired.r.yaml new file mode 100644 index 0000000..33545ae --- /dev/null +++ b/jamovi/datambipaired.r.yaml @@ -0,0 +1,167 @@ +--- +name: dataMBIpaired +title: MBI for Paired Samples +jrs: '1.1' + +items: + - name: text + title: MBI for Paired Samples + type: Preformatted + + - name: ttest + title: Paired Samples T-Test + type: Table + rows: (pairs) + clearWith: + - confint + - SWC + columns: + - name: i1 + title: '' + type: text + content: ($key) + - name: i2 + title: '' + type: text + content: ($key) + - name: t + type: number + - name: df + type: integer + - name: p + type: number + format: zto,pvalue + + + - name: effect + title: Effect Size + type: Table + rows: (pairs) + clearWith: + - confint + - SWC + columns: + - name: i1 + title: '' + type: text + content: ($key) + - name: i2 + title: '' + type: text + content: ($key) + - name: mdiff + type: number + title: Mean Difference + - name: diffLL + type: number + title: Lower + superTitle: Confidence Interval + - name: diffUL + type: number + title: Upper + superTitle: Confidence Interval + - name: type + title: '' + type: text + - name: d + type: number + title: Effect Size + - name: dLL + type: number + title: Lower + superTitle: Confidence Interval + - name: dUL + type: number + title: Upper + superTitle: Confidence Interval + + - name: mbi + title: Magnitude Based Inference + type: Table + rows: (pairs) + clearWith: + - confint + - SWC + columns: + - name: i1 + title: '' + type: text + content: ($key) + - name: i2 + title: '' + type: text + content: ($key) + - name: negative + type: number + title: Negative + superTitle: MBI (%) + - name: trivial + type: number + title: Trivial + superTitle: MBI (%) + - name: positive + type: number + title: Positive + superTitle: MBI (%) + - name: inference + title: Inference + type: text + + - name: desc + title: Descriptives + type: Table + visible: (desc) + rows: (pairs) + clearWith: + - group + + columns: + - name: name[1] + title: "" + type: text + + - name: n[1] + title: "N" + type: integer + + - name: m[1] + title: Mean + type: number + + - name: med[1] + title: Median + type: number + + - name: sd[1] + title: SD + type: number + + - name: se[1] + title: SE + type: number + + - name: name[2] + title: "" + type: text + + - name: n[2] + title: "N" + type: integer + + - name: m[2] + title: Mean + type: number + + - name: med[2] + title: Median + type: number + + - name: sd[2] + title: SD + type: number + + - name: se[2] + title: SE + type: number + +... diff --git a/jamovi/datambipaired.u.yaml b/jamovi/datambipaired.u.yaml new file mode 100644 index 0000000..58a4f50 --- /dev/null +++ b/jamovi/datambipaired.u.yaml @@ -0,0 +1,59 @@ +title: MBI for Paired Samples T-Test +name: dataMBIpaired +jus: '2.0' +stage: 0 +compilerMode: tame +children: + - type: VariableSupplier + suggested: + - continuous + permitted: + - continuous + - ordinal + persistentItems: true + stretchFactor: 1 + children: + - type: TargetLayoutBox + label: Paired Variables + children: + - type: VariablesListBox + name: pairs + fullRowSelect: true + isTarget: true + columns: + - name: i1 + stretchFactor: 1 + template: + type: VariableLabel + - name: i2 + stretchFactor: 1 + template: + type: VariableLabel + + - type: LayoutBox + margin: large + stretchFactor: 1 + children: + - type: LayoutBox + cell: + column: 0 + row: 0 + stretchFactor: 1 + children: + - type: Label + label: Options + children: + - type: CheckBox + name: correl + - type: TextBox + name: SWC + format: number + inputPattern: '[0-9]+' + - type: TextBox + name: confint + format: number + inputPattern: '[0-9]+' + - type: CheckBox + name: desc + + diff --git a/jamovi/datambitwo.a.yaml b/jamovi/datambitwo.a.yaml new file mode 100644 index 0000000..d62550d --- /dev/null +++ b/jamovi/datambitwo.a.yaml @@ -0,0 +1,117 @@ +--- +name: dataMBItwo +title: MBI for Independent Samples +menuGroup: mbir +version: '1.0.0' +jas: '1.1' + +description: + R: + usage: | + + data('bugs', package = 'jmv') + + mbir::dataMBItwo( + data = bugs, + deps = "LDLF", + group = "Gender") + + # + # Independent Samples T-Test + # ─────────────────────────────── + # t df p + # ─────────────────────────────── + # LDLF 1.47 60 0.147 + # ─────────────────────────────── + # Note. Welch's, unequal + # variances, t-test + # + # + + # + # Effect Size + # ────────────────────────────────────────────────────────────────────────────────────────────── + # Mean Difference Lower Upper Effect Size Lower Upper + # ────────────────────────────────────────────────────────────────────────────────────────────── + # LDLF 0.857 -0.309 2.02 Cohen's d 0.330 -0.0450 0.705 + # ────────────────────────────────────────────────────────────────────────────────────────────── + # + # + + # + # Magnitude Based Inference + # ─────────────────────────────────────────────────────────────────────── + # Negative Trivial Positive Inference + # ─────────────────────────────────────────────────────────────────────── + # LDLF 0.00 77.4 22.6 Likely Trivial Increase. + # ─────────────────────────────────────────────────────────────────────── + # + # + + + +completeWhenFilled: true + +options: + - name: data + type: Data + description: + R: the data as a data frame + + - name: deps + title: Dependent Variables + type: Variables + suggested: + - continuous + permitted: + - continuous + - nominal + - ordinal + rejectInf: false + description: + R: a vector of strings naming the dependent variables + + - name: group + title: Grouping Variable + type: Variable + suggested: + - nominal + - ordinal + description: + R: a string naming the grouping variable, must have 2 levels + + - name: varEq + title: Assume equal variances + type: Bool + default: true + description: + R: > + `TRUE` or `FALSE` (default), assume equal variances + + - name: SESOI + title: Smallest worthwhile difference (Effect Size) + type: Number + min: 0 + default: 0.5 + description: + R: a number that defines the bounds for magnitude-based inference + + - name: confint + title: Confidence Interval (%) + type: Number + min: 50.0 + max: 99.9 + default: 90 + description: + R: > + 90% (default) confidence intervals for effect sizes + + - name: desc + title: Descriptive statistics + type: Bool + default: false + description: + R: > + `TRUE` or `FALSE` (default), provide descriptive statistics + +... diff --git a/jamovi/datambitwo.r.yaml b/jamovi/datambitwo.r.yaml new file mode 100644 index 0000000..2139983 --- /dev/null +++ b/jamovi/datambitwo.r.yaml @@ -0,0 +1,150 @@ +--- +name: dataMBItwo +title: MBI for Independent Samples T-Test +jrs: '1.1' + +items: + - name: text + title: Independent Samples Magnitude-Based Inference + type: Preformatted + + - name: ttest + title: Independent Samples T-Test + type: Table + rows: (deps) + columns: + - name: var + title: '' + type: text + content: ($key) + - name: t + type: number + - name: df + type: integer + - name: p + type: number + format: zto,pvalue + + + - name: effect + title: Effect Size + type: Table + rows: (deps) + clearWith: + - confint + - SWC + columns: + - name: var + title: '' + type: text + content: ($key) + - name: mdiff + type: number + title: Mean Difference + - name: diffLL + type: number + title: Lower + superTitle: Confidence Interval + - name: diffUL + type: number + title: Upper + superTitle: Confidence Interval + - name: type + title: '' + type: text + - name: d + type: number + title: Effect Size + - name: dLL + type: number + title: Lower + superTitle: Confidence Interval + - name: dUL + type: number + title: Upper + superTitle: Confidence Interval + + - name: mbi + title: Magnitude Based Inference + type: Table + rows: (deps) + columns: + - name: var + title: '' + type: text + content: ($key) + - name: negative + type: number + title: Negative + superTitle: MBI (%) + - name: trivial + type: number + title: Trivial + superTitle: MBI (%) + - name: positive + type: number + title: Positive + superTitle: MBI (%) + - name: inference + title: Inference + type: text + + + - name: desc + title: Descriptives + type: Table + visible: (desc) + rows: (deps) + clearWith: + - group + + columns: + - name: name[1] + title: "" + type: text + + - name: n[1] + title: "N" + type: integer + + - name: m[1] + title: Mean + type: number + + - name: med[1] + title: Median + type: number + + - name: sd[1] + title: SD + type: number + + - name: se[1] + title: SE + type: number + + - name: name[2] + title: "" + type: text + + - name: n[2] + title: "N" + type: integer + + - name: m[2] + title: Mean + type: number + + - name: med[2] + title: Median + type: number + + - name: sd[2] + title: SD + type: number + + - name: se[2] + title: SE + type: number + +... diff --git a/jamovi/datambitwo.u.yaml b/jamovi/datambitwo.u.yaml new file mode 100644 index 0000000..827dd00 --- /dev/null +++ b/jamovi/datambitwo.u.yaml @@ -0,0 +1,49 @@ +title: MBI for Independent Samples +name: dataMBItwo +jus: '2.0' +stage: 0 +compilerMode: tame +children: + - type: VariableSupplier + persistentItems: false + stretchFactor: 1 + children: + - type: TargetLayoutBox + label: Dependent Variables + children: + - type: VariablesListBox + name: deps + isTarget: true + - type: TargetLayoutBox + label: Grouping Variable + children: + - type: VariablesListBox + name: group + maxItemCount: 1 + isTarget: true + + - type: LayoutBox + margin: large + stretchFactor: 1 + children: + - type: LayoutBox + cell: + column: 0 + row: 0 + stretchFactor: 1 + children: + - type: Label + label: Options + children: + - type: CheckBox + name: varEq + - type: TextBox + name: SWC + format: number + inputPattern: '[0-9]+' + - type: TextBox + name: confint + format: number + inputPattern: '[0-9]+' + - type: CheckBox + name: desc From 44ef7a104abc2077b6b3886074f6645f98f1387c Mon Sep 17 00:00:00 2001 From: arcaldwell49 Date: Fri, 20 Apr 2018 17:53:30 -0500 Subject: [PATCH 2/2] Changed for SWC from SESOI notation --- R/datambicorr.h.R | 22 +++++++++++----------- R/datambinpind.h.R | 22 +++++++++++----------- R/datambinppair.h.R | 26 +++++++++++++------------- R/datambipaired.h.R | 26 +++++++++++++------------- R/datambitwo.h.R | 22 +++++++++++----------- 5 files changed, 59 insertions(+), 59 deletions(-) diff --git a/R/datambicorr.h.R b/R/datambicorr.h.R index 252e37c..189b716 100644 --- a/R/datambicorr.h.R +++ b/R/datambicorr.h.R @@ -10,7 +10,7 @@ dataMBIcorrOptions <- if (requireNamespace('jmvcore')) R6::R6Class( pearson = TRUE, spear = FALSE, kendall = FALSE, - SESOI = 0.1, + SWC = 0.1, confint = 90, desc = FALSE, ...) { @@ -41,9 +41,9 @@ dataMBIcorrOptions <- if (requireNamespace('jmvcore')) R6::R6Class( "kendall", kendall, default=FALSE) - private$..SESOI <- jmvcore::OptionNumber$new( - "SESOI", - SESOI, + private$..SWC <- jmvcore::OptionNumber$new( + "SWC", + SWC, min=0.01, max=0.9, default=0.1) @@ -62,7 +62,7 @@ dataMBIcorrOptions <- if (requireNamespace('jmvcore')) R6::R6Class( self$.addOption(private$..pearson) self$.addOption(private$..spear) self$.addOption(private$..kendall) - self$.addOption(private$..SESOI) + self$.addOption(private$..SWC) self$.addOption(private$..confint) self$.addOption(private$..desc) }), @@ -71,7 +71,7 @@ dataMBIcorrOptions <- if (requireNamespace('jmvcore')) R6::R6Class( pearson = function() private$..pearson$value, spear = function() private$..spear$value, kendall = function() private$..kendall$value, - SESOI = function() private$..SESOI$value, + SWC = function() private$..SWC$value, confint = function() private$..confint$value, desc = function() private$..desc$value), private = list( @@ -79,7 +79,7 @@ dataMBIcorrOptions <- if (requireNamespace('jmvcore')) R6::R6Class( ..pearson = NA, ..spear = NA, ..kendall = NA, - ..SESOI = NA, + ..SWC = NA, ..confint = NA, ..desc = NA) ) @@ -108,7 +108,7 @@ dataMBIcorrResults <- if (requireNamespace('jmvcore')) R6::R6Class( rows="(pairs)", clearWith=list( "confint", - "SESOI"), + "SWC"), columns=list( list( `name`="i1", @@ -341,7 +341,7 @@ dataMBIcorrBase <- if (requireNamespace('jmvcore')) R6::R6Class( #' @param spear \code{TRUE} or \code{FALSE} (default), provide Spearman's rho #' @param kendall \code{TRUE} or \code{FALSE} (default), provide Kendall's #' tau-b -#' @param SESOI a number, default (r=0.1) that defines the bounds for +#' @param SWC a number, default (r=0.1) that defines the bounds for #' magnitude-based inference #' @param confint 90\% (default), confidence interval for magnitude-based #' inference @@ -367,7 +367,7 @@ dataMBIcorr <- function( pearson = TRUE, spear = FALSE, kendall = FALSE, - SESOI = 0.1, + SWC = 0.1, confint = 90, desc = FALSE) { @@ -379,7 +379,7 @@ dataMBIcorr <- function( pearson = pearson, spear = spear, kendall = kendall, - SESOI = SESOI, + SWC = SWC, confint = confint, desc = desc) diff --git a/R/datambinpind.h.R b/R/datambinpind.h.R index 956dba0..4e5c8ab 100644 --- a/R/datambinpind.h.R +++ b/R/datambinpind.h.R @@ -8,7 +8,7 @@ dataMBInpindOptions <- if (requireNamespace('jmvcore')) R6::R6Class( initialize = function( deps = NULL, group = NULL, - SESOI = 0.5, + SWC = 0.5, confint = 90, desc = FALSE, ...) { @@ -34,9 +34,9 @@ dataMBInpindOptions <- if (requireNamespace('jmvcore')) R6::R6Class( suggested=list( "nominal", "ordinal")) - private$..SESOI <- jmvcore::OptionNumber$new( - "SESOI", - SESOI, + private$..SWC <- jmvcore::OptionNumber$new( + "SWC", + SWC, min=0, default=0.5) private$..confint <- jmvcore::OptionNumber$new( @@ -52,20 +52,20 @@ dataMBInpindOptions <- if (requireNamespace('jmvcore')) R6::R6Class( self$.addOption(private$..deps) self$.addOption(private$..group) - self$.addOption(private$..SESOI) + self$.addOption(private$..SWC) self$.addOption(private$..confint) self$.addOption(private$..desc) }), active = list( deps = function() private$..deps$value, group = function() private$..group$value, - SESOI = function() private$..SESOI$value, + SWC = function() private$..SWC$value, confint = function() private$..confint$value, desc = function() private$..desc$value), private = list( ..deps = NA, ..group = NA, - ..SESOI = NA, + ..SWC = NA, ..confint = NA, ..desc = NA) ) @@ -114,7 +114,7 @@ dataMBInpindResults <- if (requireNamespace('jmvcore')) R6::R6Class( rows="(deps)", clearWith=list( "confint", - "SESOI"), + "SWC"), columns=list( list( `name`="var", @@ -259,7 +259,7 @@ dataMBInpindBase <- if (requireNamespace('jmvcore')) R6::R6Class( #' @param data the data as a data frame #' @param deps a vector of strings naming the dependent variables #' @param group a string naming the grouping variable, must have 2 levels -#' @param SESOI a number that defines the bounds for magnitude-based inference +#' @param SWC a number that defines the bounds for magnitude-based inference #' @param confint 90\% (default) confidence intervals for effect sizes #' @param desc \code{TRUE} or \code{FALSE} (default), provide descriptive #' statistics @@ -283,7 +283,7 @@ dataMBInpind <- function( data, deps, group, - SESOI = 0.5, + SWC = 0.5, confint = 90, desc = FALSE) { @@ -293,7 +293,7 @@ dataMBInpind <- function( options <- dataMBInpindOptions$new( deps = deps, group = group, - SESOI = SESOI, + SWC = SWC, confint = confint, desc = desc) diff --git a/R/datambinppair.h.R b/R/datambinppair.h.R index 6980bf1..ff5db72 100644 --- a/R/datambinppair.h.R +++ b/R/datambinppair.h.R @@ -7,7 +7,7 @@ dataMBInppairOptions <- if (requireNamespace('jmvcore')) R6::R6Class( public = list( initialize = function( pairs = NULL, - SESOI = 0.5, + SWC = 0.5, confint = 90, desc = FALSE, ...) { @@ -26,9 +26,9 @@ dataMBInppairOptions <- if (requireNamespace('jmvcore')) R6::R6Class( "continuous", "nominal", "ordinal")) - private$..SESOI <- jmvcore::OptionNumber$new( - "SESOI", - SESOI, + private$..SWC <- jmvcore::OptionNumber$new( + "SWC", + SWC, min=0, default=0.5) private$..confint <- jmvcore::OptionNumber$new( @@ -43,18 +43,18 @@ dataMBInppairOptions <- if (requireNamespace('jmvcore')) R6::R6Class( default=FALSE) self$.addOption(private$..pairs) - self$.addOption(private$..SESOI) + self$.addOption(private$..SWC) self$.addOption(private$..confint) self$.addOption(private$..desc) }), active = list( pairs = function() private$..pairs$value, - SESOI = function() private$..SESOI$value, + SWC = function() private$..SWC$value, confint = function() private$..confint$value, desc = function() private$..desc$value), private = list( ..pairs = NA, - ..SESOI = NA, + ..SWC = NA, ..confint = NA, ..desc = NA) ) @@ -85,7 +85,7 @@ dataMBInppairResults <- if (requireNamespace('jmvcore')) R6::R6Class( rows="(pairs)", clearWith=list( "confint", - "SESOI"), + "SWC"), columns=list( list( `name`="i1", @@ -111,7 +111,7 @@ dataMBInppairResults <- if (requireNamespace('jmvcore')) R6::R6Class( rows="(pairs)", clearWith=list( "confint", - "SESOI"), + "SWC"), columns=list( list( `name`="i1", @@ -144,7 +144,7 @@ dataMBInppairResults <- if (requireNamespace('jmvcore')) R6::R6Class( rows="(pairs)", clearWith=list( "confint", - "SESOI"), + "SWC"), columns=list( list( `name`="i1", @@ -300,7 +300,7 @@ dataMBInppairBase <- if (requireNamespace('jmvcore')) R6::R6Class( #' @param data the data as a data frame #' @param pairs a list of vectors of strings naming variables to pair from #' \code{data} -#' @param SESOI a number that defines the bounds for magnitude-based inference +#' @param SWC a number that defines the bounds for magnitude-based inference #' @param confint 90\% (default), confidence interval for magnitude-based #' inference #' @param desc \code{TRUE} or \code{FALSE} (default), provide descriptive @@ -324,7 +324,7 @@ dataMBInppairBase <- if (requireNamespace('jmvcore')) R6::R6Class( dataMBInppair <- function( data, pairs, - SESOI = 0.5, + SWC = 0.5, confint = 90, desc = FALSE) { @@ -333,7 +333,7 @@ dataMBInppair <- function( options <- dataMBInppairOptions$new( pairs = pairs, - SESOI = SESOI, + SWC = SWC, confint = confint, desc = desc) diff --git a/R/datambipaired.h.R b/R/datambipaired.h.R index 27aef78..df73654 100644 --- a/R/datambipaired.h.R +++ b/R/datambipaired.h.R @@ -8,7 +8,7 @@ dataMBIpairedOptions <- if (requireNamespace('jmvcore')) R6::R6Class( initialize = function( pairs = NULL, correl = TRUE, - SESOI = 0.5, + SWC = 0.5, confint = 90, desc = FALSE, ...) { @@ -31,9 +31,9 @@ dataMBIpairedOptions <- if (requireNamespace('jmvcore')) R6::R6Class( "correl", correl, default=TRUE) - private$..SESOI <- jmvcore::OptionNumber$new( - "SESOI", - SESOI, + private$..SWC <- jmvcore::OptionNumber$new( + "SWC", + SWC, min=0, default=0.5) private$..confint <- jmvcore::OptionNumber$new( @@ -49,20 +49,20 @@ dataMBIpairedOptions <- if (requireNamespace('jmvcore')) R6::R6Class( self$.addOption(private$..pairs) self$.addOption(private$..correl) - self$.addOption(private$..SESOI) + self$.addOption(private$..SWC) self$.addOption(private$..confint) self$.addOption(private$..desc) }), active = list( pairs = function() private$..pairs$value, correl = function() private$..correl$value, - SESOI = function() private$..SESOI$value, + SWC = function() private$..SWC$value, confint = function() private$..confint$value, desc = function() private$..desc$value), private = list( ..pairs = NA, ..correl = NA, - ..SESOI = NA, + ..SWC = NA, ..confint = NA, ..desc = NA) ) @@ -93,7 +93,7 @@ dataMBIpairedResults <- if (requireNamespace('jmvcore')) R6::R6Class( rows="(pairs)", clearWith=list( "confint", - "SESOI"), + "SWC"), columns=list( list( `name`="i1", @@ -122,7 +122,7 @@ dataMBIpairedResults <- if (requireNamespace('jmvcore')) R6::R6Class( rows="(pairs)", clearWith=list( "confint", - "SESOI"), + "SWC"), columns=list( list( `name`="i1", @@ -173,7 +173,7 @@ dataMBIpairedResults <- if (requireNamespace('jmvcore')) R6::R6Class( rows="(pairs)", clearWith=list( "confint", - "SESOI"), + "SWC"), columns=list( list( `name`="i1", @@ -335,7 +335,7 @@ dataMBIpairedBase <- if (requireNamespace('jmvcore')) R6::R6Class( #' \code{data} #' @param correl \code{TRUE} (default) or \code{FALSE} , corrects the #' standardized effect size for correlation between measurements -#' @param SESOI a number that defines the bounds for magnitude-based inference +#' @param SWC a number that defines the bounds for magnitude-based inference #' @param confint 90\% (default), confidence interval for magnitude-based #' inference #' @param desc \code{TRUE} or \code{FALSE} (default), provide descriptive @@ -360,7 +360,7 @@ dataMBIpaired <- function( data, pairs, correl = TRUE, - SESOI = 0.5, + SWC = 0.5, confint = 90, desc = FALSE) { @@ -370,7 +370,7 @@ dataMBIpaired <- function( options <- dataMBIpairedOptions$new( pairs = pairs, correl = correl, - SESOI = SESOI, + SWC = SWC, confint = confint, desc = desc) diff --git a/R/datambitwo.h.R b/R/datambitwo.h.R index e760a49..7fa03d0 100644 --- a/R/datambitwo.h.R +++ b/R/datambitwo.h.R @@ -9,7 +9,7 @@ dataMBItwoOptions <- if (requireNamespace('jmvcore')) R6::R6Class( deps = NULL, group = NULL, varEq = TRUE, - SESOI = 0.5, + SWC = 0.5, confint = 90, desc = FALSE, ...) { @@ -39,9 +39,9 @@ dataMBItwoOptions <- if (requireNamespace('jmvcore')) R6::R6Class( "varEq", varEq, default=TRUE) - private$..SESOI <- jmvcore::OptionNumber$new( - "SESOI", - SESOI, + private$..SWC <- jmvcore::OptionNumber$new( + "SWC", + SWC, min=0, default=0.5) private$..confint <- jmvcore::OptionNumber$new( @@ -58,7 +58,7 @@ dataMBItwoOptions <- if (requireNamespace('jmvcore')) R6::R6Class( self$.addOption(private$..deps) self$.addOption(private$..group) self$.addOption(private$..varEq) - self$.addOption(private$..SESOI) + self$.addOption(private$..SWC) self$.addOption(private$..confint) self$.addOption(private$..desc) }), @@ -66,14 +66,14 @@ dataMBItwoOptions <- if (requireNamespace('jmvcore')) R6::R6Class( deps = function() private$..deps$value, group = function() private$..group$value, varEq = function() private$..varEq$value, - SESOI = function() private$..SESOI$value, + SWC = function() private$..SWC$value, confint = function() private$..confint$value, desc = function() private$..desc$value), private = list( ..deps = NA, ..group = NA, ..varEq = NA, - ..SESOI = NA, + ..SWC = NA, ..confint = NA, ..desc = NA) ) @@ -125,7 +125,7 @@ dataMBItwoResults <- if (requireNamespace('jmvcore')) R6::R6Class( rows="(deps)", clearWith=list( "confint", - "SESOI"), + "SWC"), columns=list( list( `name`="var", @@ -321,7 +321,7 @@ dataMBItwoBase <- if (requireNamespace('jmvcore')) R6::R6Class( #' @param deps a vector of strings naming the dependent variables #' @param group a string naming the grouping variable, must have 2 levels #' @param varEq \code{TRUE} or \code{FALSE} (default), assume equal variances -#' @param SESOI a number that defines the bounds for magnitude-based inference +#' @param SWC a number that defines the bounds for magnitude-based inference #' @param confint 90\% (default) confidence intervals for effect sizes #' @param desc \code{TRUE} or \code{FALSE} (default), provide descriptive #' statistics @@ -346,7 +346,7 @@ dataMBItwo <- function( deps, group, varEq = TRUE, - SESOI = 0.5, + SWC = 0.5, confint = 90, desc = FALSE) { @@ -357,7 +357,7 @@ dataMBItwo <- function( deps = deps, group = group, varEq = varEq, - SESOI = SESOI, + SWC = SWC, confint = confint, desc = desc)