Upload 13 files

funcionesR/Functions.R

@@ -0,0 +1,483 @@
+# Setup of a Correlation Lower Panel in Scatterplot Matrix
+myPanel.hist <- function(x, ...){
+  usr <- par("usr"); on.exit(par(usr))
+  # Para definir región de graficiación
+  par(usr = c(usr[1:2], 0, 1.5) )
+  # Para obtener una lista que guarde las marcas de clase y conteos en cada una:
+  h <- hist(x, plot = FALSE)
+  breaks <- h$breaks;
+  nB <- length(breaks)
+  y <- h$counts; y <- y/max(y)
+  # Para dibujar los histogramas
+  rect(breaks[-nB], 0, breaks[-1], y, col="cyan", ...)
+}
+
+# Setup of a Boxplot Diagonal Panel in Scatterplot Matrix
+myPanel.box <- function(x, ...){
+  usr <- par("usr", bty = 'n')
+  on.exit(par(usr))
+  par(usr = c(-1, 1, min(x) - 0.5, max(x) + 0.5))
+  b <- boxplot(x, plot = F)
+  whisker.i <- b$stats[1,]
+  whisker.s <- b$stats[5,]
+  hinge.i <- b$stats[2,]
+  mediana <- b$stats[3,]
+  hinge.s <- b$stats[4,]
+  rect(-0.5, hinge.i, 0.5, mediana, col = 'gray')
+  segments(0, hinge.i, 0, whisker.i, lty = 2)
+  segments(-0.1, whisker.i, 0.1, whisker.i)
+  rect(-0.5, mediana, 0.5, hinge.s, col = 'gray')
+  segments(0, hinge.s, 0, whisker.s, lty = 2)
+  segments(-0.1, whisker.s, 0.1, whisker.s)
+}
+
+# Setup of a Correlation Lower Panel in Scatterplot Matrix
+myPanel.cor <- function(x, y, digits = 2, prefix = "", cex.cor){
+  usr <- par("usr"); on.exit(par(usr = usr))
+  par(usr = c(0, 1, 0, 1))
+  r <- cor(x, y)
+  txt <- format(c(r, 0.123456789), digits = digits)[1]
+  txt <- paste(prefix, txt, sep = "")
+  if(missing(cex.cor))
+    cex = 0.4/strwidth(txt)
+  text(0.5, 0.5, txt, cex = 1 + 1.5*abs(r))
+}
+
+# Ordinary or Studentized residuals QQ-plot with Shapiro-Wilk normal test results
+myQQnorm <- function(modelo, student = F, ...){
+  if(student){
+    res <- rstandard(modelo)
+    lab.plot <- "Normal Q-Q Plot of Studentized Residuals"
+  } else {
+    res <- residuals(modelo)
+    lab.plot <- "Normal Q-Q Plot of Residuals"
+  }
+  shapiro <- shapiro.test(res)
+  shapvalue <- ifelse(shapiro$p.value < 0.001, "P value < 0.001", paste("P value = ", round(shapiro$p.value, 4), sep = ""))
+  shapstat <- paste("W = ", round(shapiro$statistic, 4), sep = "")
+  q <- qqnorm(res, plot.it = FALSE)
+  qqnorm(res, main = lab.plot, ...)
+  qqline(res, lty = 2, col = 2)
+  text(min(q$x, na.rm = TRUE), max(q$y, na.rm = TRUE)*0.95, pos = 4, 'Shapiro-Wilk Test', col = "blue", font = 2)
+  text(min(q$x, na.rm = TRUE), max(q$y, na.rm = TRUE)*0.80, pos = 4, shapstat, col = "blue", font = 3)
+  text(min(q$x, na.rm = TRUE), max(q$y, na.rm = TRUE)*0.65, pos = 4, shapvalue, col = "blue", font = 3)
+}
+
+# Table of Summary Statistics
+mySumStats <- function(lm.model){
+  stats <- summary(lm.model)
+  RMSE <- stats$sigma
+  R2 <- stats$r.squared
+  adjR2 <- stats$adj.r.squared 
+  result <- data.frame(Root_MSE = RMSE, R_square = R2, Adj_R_square = adjR2, row.names = "")
+  format(result, digits = 6)
+}
+
+# Extract estimated and standardized coefficients, their 95% CI's and VIF's
+myCoefficients <- function(lm.model, dataset){
+  coeff <- coef(lm.model)
+  scaled.data <- as.data.frame(scale(dataset))
+  coef.std <- c(0, coef(lm(update(formula(lm.model), ~.+0), scaled.data)))
+  limites <- confint(lm.model, level = 0.95)
+  vifs <- c(0, vif(lm.model))
+  result <- data.frame(Estimation = coeff, Coef.Std = coef.std, Limits = limites, Vif = vifs)
+  names(result)[3:4] <- c("Limit_2.5%","Limit_97.5%")
+  cat("Estimated and standardized coefficients, their 95% CI's and VIF's", "\n")
+  result
+}
+
+# Analysis of Variance Table
+myAnova <- function(lm.model){
+  SSq <- unlist(anova(lm.model)["Sum Sq"])
+  k <- length(SSq) - 1
+  SSR <- sum(SSq[1:k])
+  SSE <- SSq[(k + 1)]
+  MSR <- SSR/k
+  df.error <- unlist(anova(lm.model)["Df"])[k + 1]
+  MSE <- SSE/df.error
+  F0 <- MSR/MSE
+  PV <- pf(F0, k, df.error, lower.tail = F)
+  result<-data.frame(Sum_of_Squares = format(c(SSR, SSE), digits = 6), DF = format(c(k, df.error), digits = 6),
+                     Mean_Square = format(c(MSR, MSE), digits = 6), F_Value = c(format(F0, digits = 6), ''),
+                     P_value = c(format(PV, digits = 6), ''), row.names = c("Model", "Error"))
+  result
+}
+
+# Diagnostics table for Leverage and Influence observations
+myInfluence <- function(model, infl = influence(model), covr = F){
+  is.influential <- function(infmat, n, covr = F){
+    d <- dim(infmat)
+    colrm <- if(covr) 4L else 3L
+    k <- d[[length(d)]] - colrm
+    if (n <= k) 
+      stop("too few cases i with h_ii > 0), n < k")
+    absmat <- abs(infmat)
+    r <- if(!covr){
+      if(is.matrix(infmat)){
+        cbind(absmat[, 1L:k] > 2/sqrt(n), # > 1,
+              absmat[, k + 1] > 2 * sqrt(k/n), # > 3 * sqrt(k/(n - k)),
+              infmat[, k + 2] > 1, # pf(infmat[, k + 3], k, n - k) > 0.5,
+              infmat[, k + 3] > 2 * p / n) # infmat[, k + 4] > (3 * k)/n)
+      } else {
+        c(absmat[, 1L:k] > 2/sqrt(n), # > 1, 
+          absmat[, k + 1] > 2 * sqrt(k/n), # > 3 * sqrt(k/(n - k)),
+          infmat[, k + 3] > 1, # pf(infmat[, , k + 3], k, n - k) > 0.5, 
+          infmat[, k + 4] > 2 * p / n) # > (3 * k)/n)
+      }
+    } else {
+      if(is.matrix(infmat)){
+        cbind(absmat[, 1L:k] > 2/sqrt(n), # > 1,
+              absmat[, k + 1] > 2 * sqrt(k/n), # > 3 * sqrt(k/(n - k)),
+              abs(1 - infmat[, k + 2]) > 3 * p / n, # > (3 * k)/(n - k),
+              infmat[, k + 3] > 1, # pf(infmat[, k + 3], k, n - k) > 0.5,
+              infmat[, k + 4] > 2 * p / n) # infmat[, k + 4] > (3 * k)/n)
+      } else {
+        c(absmat[, 1L:k] > 2/sqrt(n), # > 1, 
+          absmat[, k + 1] > 2 * sqrt(k/n), # > 3 * sqrt(k/(n - k)),
+          abs(1 - infmat[, , k + 2]) > 3 * p / n, # > (3 * k)/(n - k), 
+          infmat[, k + 3] > 1, # pf(infmat[, , k + 3], k, n - k) > 0.5, 
+          infmat[, k + 4] > 2 * p / n) # > (3 * k)/n)
+      }
+    }
+    attributes(r) <- attributes(infmat)
+    r
+  }
+  p <- model$rank
+  e <- weighted.residuals(model)
+  s <- sqrt(sum(e^2, na.rm = TRUE)/df.residual(model))
+  mqr <- stats:::qr.lm(model)
+  xxi <- chol2inv(mqr$qr, mqr$rank)
+  si <- infl$sigma
+  h <- infl$hat
+  is.mlm <- is.matrix(e)
+  cf <- if (is.mlm){
+    aperm(infl$coefficients, c(1L, 3:2))
+  } else infl$coefficients
+  dfbetas <- cf/outer(infl$sigma, sqrt(diag(xxi)))
+  vn <- variable.names(model)
+  vn[vn == "(Intercept)"] <- "1_"
+  dimnames(dfbetas)[[length(dim(dfbetas))]] <- paste0("dfb.", abbreviate(vn))
+  dffits <- e * sqrt(h)/(si * (1 - h))
+  if(any(ii <- is.infinite(dffits))) dffits[ii] <- NaN
+  if(covr) cov.ratio <- (si/s)^(2 * p)/(1 - h)
+  cooks.d <- if (inherits(model, "glm")){ 
+    (infl$pear.res/(1 - h))^2 * h/(summary(model)$dispersion * p)
+  } else ((e/(s * (1 - h)))^2 * h)/p
+  infmat <- if(is.mlm){
+    dns <- dimnames(dfbetas)
+    dns[[3]] <- c(dns[[3]], "dffit", "cov.r", 
+                  "cook.d", "hat")
+    a <- array(dfbetas, dim = dim(dfbetas) + c(0, 0, 3 + 1), dimnames = dns)
+    a[, , "dffit"] <- dffits
+    if(covr) a[, , "cov.r"] <- cov.ratio
+    a[, , "cook.d"] <- cooks.d
+    a[, , "hat"] <- h
+    a
+  } else {
+    if(covr){
+      cbind(dfbetas, dffit = dffits, cov.r = cov.ratio, cook.d = cooks.d, hat = h)
+    } else cbind(dfbetas, dffit = dffits, cook.d = cooks.d, hat = h)
+  }
+  infmat[is.infinite(infmat)] <- NaN
+  is.inf <- is.influential(infmat, sum(h > 0))
+  ans <- list(infmat = infmat, is.inf = is.inf, call = model$call)
+  class(ans) <- "infl"
+  ans
+}
+
+# Extract Collinearity Diagnostics
+myCollinDiag <- function(lm.model, center = F){
+  if(center == F){
+    X <- model.matrix(lm.model)
+    eigen <- prcomp(X, center = FALSE, scale = TRUE)$sdev^2
+    cond.idx <- colldiag(lm.model)
+    cond.idx$pi <- round(cond.idx$pi, 6)
+    result <- data.frame(Eigen_Value = format(eigen, digits = 5),
+                         Condition_Index = cond.idx$condindx, 
+                         cond.idx$pi)
+    names(result)[2:3] <- c('Condition_Index','Intercept')
+    cat("Collinearity Diagnostics", "\n", 
+        paste0(rep("", 3+sum(nchar(names(result)[1:2])))), "Variance Decomposition Proportions", "\n")
+  }
+  else{
+    X <- model.matrix(lm.model)[, -1]
+    eigen <- prcomp(X, center = TRUE, scale = TRUE)$sdev^2
+    cond.idx <- colldiag(lm.model, center = TRUE, scale = TRUE)
+    cond.idx$pi <- round(cond.idx$pi, 6)
+    result <- data.frame(Eigen_Value = format(eigen, digits = 5),
+                         Condition_Index = cond.idx$condindx,
+                         cond.idx$pi)
+    names(result)[2] <- 'Condition_Index'
+    cat("Collinearity Diagnostics (intercept adjusted)", "\n", 
+        paste0(rep("", 3+sum(nchar(names(result)[1:2])))), "Variance Decomposition Proportions", "\n")
+  }
+  result
+}
+
+# All Posible Regressions Table
+myAllRegTable <- function(lm.model, response = model.response(model.frame(lm.model)), MSE = F){
+  regTable <- summary(regsubsets(model.matrix(lm.model)[, -1], response,
+                                 nbest = 2^(lm.model$rank - 1) - 1, really.big = T))
+  pvCount <- as.vector(apply(regTable$which[, -1], 1, sum))
+  pvIDs <- apply(regTable$which[, -1], 1, function(x) as.character(paste(colnames(model.matrix(lm.model)[, -1])[x],
+                                                                         collapse = " ")))
+  result <- if(MSE){
+    data.frame(k = pvCount, R_sq = round(regTable$rsq, 3), adj_R_sq = round(regTable$adjr2, 3),
+               MSE = round(regTable$rss/(nrow(model.matrix(lm.model)[,-1]) - (pvCount + 1)), 3),
+               Cp = round(regTable$cp, 3), Variables_in_model = pvIDs)
+  } else {
+    data.frame(k = pvCount, R_sq = round(regTable$rsq, 3), adj_R_sq = round(regTable$adjr2, 3),
+               SSE = round(regTable$rss, 3),
+               Cp = round(regTable$cp, 3), Variables_in_model = pvIDs)
+  }
+  format(result, digits = 6)
+}
+
+# Summary table and Plots of the Best of All Posible Models by Criterion
+# Cp Criterion
+myCp_criterion <- function(lm.model, response = model.response(model.frame(lm.model))){
+  Cp <- leaps(model.matrix(lm.model)[, -1], response, method = "Cp", nbest = 1) # The Best model by number of parameters
+  var_in_model <- apply(Cp$which, 1, 
+                        function(x) as.character(paste(colnames(model.matrix(lm.model)[, -1])[x], collapse = " ")))
+  Cp_result <- data.frame(k = Cp$size - 1, p = Cp$size, Cp = Cp$Cp, Variables.in.model = var_in_model)
+  plot(Cp$size, Cp$Cp, type = "b", xlab = "p", ylab = '', xaxt = "n", cex = 2, ylim = c(0, max(Cp$Cp)), las = 1)
+  axis(1, at = Cp$size, labels = Cp$size)
+  mtext('Cp', 2, las = 1, adj = 3)
+  abline(a = 0, b = 1, lty = 2, col = 2)
+  cat("Models are Indexed in rows", "\n")
+  print(Cp_result, row.names = F)
+}
+
+# R2 Criterion
+myR2_criterion <- function(lm.model, response = model.response(model.frame(lm.model))){
+  R2 <- leaps(model.matrix(lm.model)[, -1], response, method = "r2", nbest = 1) #Mejor modelo para cada p
+  var_in_model <- apply(R2$which, 1,
+                        function(x) as.character(paste(colnames(model.matrix(lm.model)[, -1])[x], collapse = " ")))
+  R2_result <- data.frame(k = R2$size - 1, p = R2$size, R2 = R2$r2, Variables.in.model = var_in_model)
+  plot(R2$size, R2$r2, type = "b", xlab = "p", ylab = "", xaxt = "n", cex = 2, las = 1)
+  axis(1, at = R2$size, labels = R2$size)
+  mtext("R2", 2, las = 1, adj = 4)
+  cat("Models are Indexed in rows", "\n")
+  print(R2_result, row.names = F)
+}
+
+# adjR2 Criterion
+myAdj_R2_criterion <- function(lm.model, response = model.response(model.frame(lm.model))){
+  adjR2 <- leaps(model.matrix(lm.model)[, -1], response, method = "adjr2", nbest = 1)
+  var_in_model <- apply(adjR2$which, 1,
+                        function(x) as.character(paste(colnames(model.matrix(lm.model)[, -1])[x], collapse = " ")))
+  adjR2_result <- data.frame(k = adjR2$size - 1, p = adjR2$size, adjR2 = adjR2$adjr2, Variables.in.model = var_in_model)
+  plot(adjR2$size, adjR2$adjr2, type = "b", xlab = "p", ylab = "", xaxt = "n", cex = 2, las = 1)
+  axis(1, at = adjR2$size, labels = adjR2$size)
+  mtext("adj_R2", 2, las = 1, adj = 2.2)
+  cat("Models are Indexed in rows", "\n")
+  print(adjR2_result, row.names = F)
+}
+
+myStepwise <- function(full.model, alpha.to.enter, alpha.to.leave, initial.model = lm(model.response(model.frame(full.model)) ~ 1)){
+  ###################################################################################
+  #                                                                                 #
+  # Function to perform a stepwise linear regression using F tests of significance, #
+  # based on the function developed by Paul A. Rubin (rubin@msu.edu)                #
+  # URL = https://orinanobworld.blogspot.com/2011/02/stepwise-regression-in-r.html  #
+  #                                                                                 #
+  ###################################################################################
+  #                                                                                 #
+  # full.model    : model containing all possible terms                             #
+  # alpha.to.enter: significance level above which a variable may enter             #
+  # alpha.to.leave: significance level below which a variable may be deleted        #
+  # initial.model : first model to consider. By default the first model is the one  #
+  #                 without predictors                                              #
+  ###################################################################################
+  #
+  # fit the full model
+  full <- lm(full.model);
+  # attach predictor variables in full model
+  attach(as.data.frame(model.matrix(full.model)[, -1]), warn.conflicts = F);
+  # MSE of full model
+  msef <- (summary(full)$sigma)^2;
+  # sample size
+  n <- length(full$residuals);
+  # this is the current model
+  current <- lm(initial.model);
+  # process each model until we break out of the loop
+  while(TRUE){
+    # summary output for the current model
+    temp <- summary(current);
+    # list of terms in the current model
+    rnames <- rownames(temp$coefficients);
+    # write the model description
+    print(temp$coefficients);
+    # current model's size
+    p <- dim(temp$coefficients)[1];
+    # MSE for current model
+    mse <- (temp$sigma)^2;
+    # Mallow's cp
+    cp <- (n - p)*mse / msef - (n - 2 * p);
+    # show the fit
+    fit <- sprintf("\nS = %f, R-sq = %f, R-sq(adj) = %f, C-p = %f",
+                   temp$sigma, temp$r.squared, temp$adj.r.squared, cp);
+    write(fit, file = "");
+    # print a separator
+    write("=====", file = "");
+    # don't try to drop a term if only one is left
+    if(p > 1){
+      # looks for significance of terms based on F tests
+      d <- drop1(current, test = "F");
+      # maximum p-value of any term (have to skip the intercept to avoid an NA)
+      pmax <- max(d[-1, 6]);
+      # we have a candidate for deletion
+      if(pmax > alpha.to.leave){
+        # name of variable to delete
+        var <- rownames(d)[d[, 6] == pmax];
+        # if an intercept is present, it will be the first name in the list
+        if(length(var) > 1){
+          # there also could be ties for worst p-value, a safe solution to 
+          # both issues is taking the second entry if there is more than one 
+          var <- var[2];
+        }
+        # print out the variable to be dropped
+        write(paste("--- Dropping", var, "\n"), file="");
+        # current formula
+        f <- formula(current);
+        # modify the formula to drop the chosen variable (by subtracting it)
+        f <- as.formula(paste(f[2], "~", paste(f[3], var, sep=" - ")));
+        # fit the modified model
+        current <- lm(f);
+        # return to the top of the loop
+        next;
+      }
+      # if we get here, we failed to drop a term; try adding one
+    }
+    # note: add1 throws an error if nothing can be added (current == full), which
+    # we trap with tryCatch
+    # looks for significance of possible additions based on F tests
+    a <- tryCatch(add1(current, scope = full.model, test = "F"), error = function(e) NULL);
+    if(is.null(a)){
+      # there are no unused variables (or something went splat), so we bail out
+      break;
+    }
+    # minimum p-value of any term (skipping the intercept again)
+    pmin <- min(a[-1, 6]);
+    # we have a candidate for addition to the model
+    if(pmin < alpha.to.enter){
+      # name of variable to add
+      var <- rownames(a)[a[,6] == pmin];
+      # same issue with ties, intercept as above
+      if(length(var) > 1){
+        var <- var[2];
+      }
+      # print the variable being added
+      write(paste("+++ Adding", var, "\n"), file="");
+      # current formula
+      f <- formula(current);
+      # modify the formula to add the chosen variable
+      f <- as.formula(paste(f[2], "~", paste(f[3], var, sep=" + ")));
+      # fit the modified model
+      current <- lm(f);
+      # return to the top of the loop
+      next;
+    }
+    # if we get here, we failed to make any changes to the model; time to punt
+    break;
+  }
+  # detach predictor variables in full model
+  detach(as.data.frame(model.matrix(full.model)[,-1]));
+  current
+}
+
+myBackward <- function(base.full, alpha.to.leave = 0.05, verbose = T){
+  ###################################################################################
+  #                                                                                 #
+  # Function to perform a backward linear regression using F tests of significance, #
+  # based on the function developed by Joris Meys                                   #
+  # URL = https://codeday.me/es/qa/20190117/101609.html                             #
+  #                                                                                 #
+  ###################################################################################
+  #                                                                                 #
+  # base.full     : dataset(Y, X1...)                                               #
+  # alpha.to.leave: the significance level below which a variable may be deleted    #
+  # verbose       : if TRUE, prints F-tests, dropped var and resulting model after  #
+  #                                                                                 #
+  ###################################################################################
+  #
+  has.interaction <- function(x, terms){
+    ###############################################################################
+    #                                                                             #
+    # Function has.interaction developed by Joris Meys, checks whether x is part  #
+    # of a term in terms, which is a vector with names of terms from a model      #
+    #                                                                             #
+    ###############################################################################
+    #
+    out <- sapply(terms, function(i){
+      sum(1 - (strsplit(x, ":")[[1]] %in% strsplit(i, ":")[[1]])) == 0
+    }
+    )
+    return(sum(out) > 0)
+  }
+  
+  counter <- 1
+  # check input
+  #if(!is(model, "lm")) stop(paste(deparse(substitute(model)),"is not an lm object\n"))
+  # calculate scope for drop1 function
+  attach(base.full)
+  model <- lm(base.full)
+  terms <- attr(model$terms, "term.labels")
+  # set scopevars to all terms
+  scopevars <- terms
+  # Backward model selection:
+  while(TRUE){
+    # extract the test statistics from drop.
+    test <- drop1(model, scope = scopevars, test = "F")
+    if(verbose){
+      cat("-------------STEP ", counter, "-------------\n",
+          "The drop statistics : \n")
+      print(test)
+    }
+    pval <- test[, dim(test)[2]]
+    names(pval) <- rownames(test)
+    pval <- sort(pval, decreasing = T)
+    if(sum(is.na(pval)) > 0){
+      stop(paste("Model", deparse(substitute(model)), "is invalid. Check if all coefficients are estimated."))
+    }
+    # check if all significant
+    if(pval[1] < alpha.to.leave){
+      # stops the loop if all remaining vars are sign.
+      break
+    }
+    # select var to drop
+    i <- 1
+    while(TRUE){
+      dropvar <- names(pval)[i]
+      check.terms <- terms[-match(dropvar, terms)]
+      x <- has.interaction(dropvar, check.terms)
+      if(x){
+        i = i + 1
+        next
+      } else {
+        break
+      }
+      # end while(T) drop var
+    }
+    # stops the loop if var to remove is significant
+    if(pval[i] < alpha.to.leave){
+      break
+    }
+    if(verbose){
+      cat("\n--------\nTerm dropped in step", counter, ":", dropvar, "\n--------\n\n")
+    }
+    # update terms, scopevars and model
+    scopevars <- scopevars[-match(dropvar, scopevars)]
+    terms <- terms[-match(dropvar, terms)]
+    formul <- as.formula(paste(".~.-", dropvar))
+    model <- update(model, formul)
+    if(length(scopevars) == 0){
+      warning("All variables are thrown out of the model.\n", "No model could be specified.")
+      return()
+    }
+    counter <- counter + 1
+    # end while(T) main loop
+  }
+  detach(base.full)
+  return(model)
+}

funcionesR/funciones.R

@@ -0,0 +1,1014 @@
+
+
+#### Plot of the confidence intervals and confidence ellipsoid:
+
+representa1c_f <- function(x){
+  x1 <- x[,1]
+  x2 <- x[,2]
+
+  x <- cbind(x1,x2)
+  n <- nrow(x)
+
+ci.x1 <- c(mean(x1)-(sqrt(var(x1))*qt(0.975,df=n-1)/sqrt(n)),
+        mean(x1)+(sqrt(var(x1))*qt(0.975,df=n-1)/sqrt(n)))
+
+ci.x2 <- c(mean(x2)-(sqrt(var(x2))*qt(0.975,df=n-1)/sqrt(n)),
+          mean(x2)+(sqrt(var(x2))*qt(0.975,df=n-1)/sqrt(n)))
+
+plot(ellipse(cor(x1,x2),c(mean(x1),mean(x2))),type="l",
+       main="Plot of Confidence Ellipsoid and
+     Confidence Intervals",
+       xlab=expression(paste(mu)[1]),
+     ylab=expression(paste(mu)[2]) )
+
+abline(v=ci.x1,lty=2,col="red")
+abline(h=ci.x2,lty=2,col="blue")
+
+legend("topleft","Confidence Intervals of",bty="n")
+
+legend(300,230,c(expression(paste(mu)[1]),
+                 expression(paste(mu)[2])),
+       lty=2,col=c("red","blue"),bty="n")
+
+}
+
+#mu=c(rep(0,2) )
+#sigma<-round(genPositiveDefMat("eigen",dim=2)$Sigma  , 4)
+#dt <- round(mvrnorm(n=100, mu,sigma),4)
+#representa1c_f(dt)
+
+
+## Funci?n R Para gr?fico de dispersi?n de puntos
+representa=function(x){
+  med=apply(x,2,mean)
+  plot(x[,1],x[,2],xlab=TeX('$X_1$'),ylab=TeX('$X_2$'),
+       pch=20,
+       xlim=c(min(x[,1])-1,max(x[,1])+1),
+       ylim=c(min(x[,2])-1,max(x[,2])+1),
+       main = TeX('Datos NB para\ \
+                  $\\underline{\\mu}$\ y $\\Sigma$'))
+  points(med[1],med[2],pch=19,col="blue")
+  abline(h=med[2],lty=2,col="red",lwd=1.5)
+  abline(v=med[1],lty=2,col="red",lwd=1.5)
+}
+
+## Funci?n R para gr?fico de dispersi?n de puntos
+## junto a un contorno de probabilidad para n-peque?o
+
+representa1c_np=function(x,alfa){
+  p=ncol(x)
+  n=nrow(x)
+  med=apply(x,2,mean)
+  sc=var(x)
+  s=sc*(n-1)/n
+  auto=eigen(s)
+  v=auto$vectors
+  lambda=auto$values
+  k<-((n-1)*p)/(n-p)
+  f_crit<-qf(1-alfa,p,n-p)
+  c<-k*f_crit
+  plot(x[,1],x[,2],xlab=TeX('$X_1$'),ylab=TeX('$X_2$'),pch=20,
+       xlim=c(min(x[,1])-1,max(x[,1])+1),
+       ylim=c(min(x[,2])-1,max(x[,2])+1),
+       main = TeX('Datos NB con\ \ $\\underline{\\mu}$\ y $\\Sigma$ \ \ elipse \ \ kF \ \ del \ \ $(1-\\alpha)\\%$'))
+  points(med[1],med[2],pch=19,col="blue")
+  abline(h=med[2],lty=2,col="red",lwd=1.5)
+  abline(v=med[1],lty=2,col="red",lwd=1.5)
+  teta=seq(0,2*pi,length=101)
+  medr=matrix(rep(med,101),byrow=TRUE,nrow=101)
+  elipse01=medr+sqrt(c)*t(sqrt(lambda[1])*v[,1]%*%t(cos(teta))+sqrt(lambda[2])*v[,2]%*%t(sin(teta)))
+  lines(elipse01,col="blue",type="l")
+}
+
+## Funci?n R para gr?fico de dispersi?n de puntos
+## junto a un contorno de probabilidad para n-grande
+
+representa1c_ng=function(x,alfa){
+  p=ncol(x)
+  n=nrow(x)
+  med=apply(x,2,mean)
+  sc=var(x)
+  s=sc*(n-1)/n
+  auto=eigen(s)
+  v=auto$vectors
+  lambda=auto$values
+  chi_crit<-qchisq(alfa,2)
+  c<-chi_crit
+  plot(x[,1],x[,2],xlab=TeX('$X_1$'),ylab=TeX('$X_2$'),pch=20,
+       xlim=c(min(x[,1])-1,max(x[,1])+1),
+       ylim=c(min(x[,2])-1,max(x[,2])+1),
+       main = TeX('Datos NB con\ \ $\\underline{\\mu}$\ y $\\Sigma$ \ \ elipse \ \ $\\chi^2$ \ \ del \ \ $(1-\\alpha)\\%$'))
+  points(med[1],med[2],pch=19,col="blue")
+  abline(h=med[2],lty=2,col="red",lwd=1.5)
+  abline(v=med[1],lty=2,col="red",lwd=1.5)
+  teta=seq(0,2*pi,length=101)
+  medr=matrix(rep(med,101),byrow=TRUE,nrow=101)
+  elipse01=medr+sqrt(c)*t(sqrt(lambda[1])*v[,1]%*%t(cos(teta))+sqrt(lambda[2])*v[,2]%*%t(sin(teta)))
+  lines(elipse01,col="blue",type="l")
+}
+
+## Funci?n R para gr?fico de dispersi?n de puntos
+## junto a un contorno de probabilidad para n-peque?a
+
+representa2c_np=function(x,alfa1,alfa2){ # Los datos se encuentran en la matriz x
+  p=ncol(x)     ##  N?mero de variables=2
+  n=nrow(x)     ##  N?mero de individuos
+  #####--- C?lculo del vector de medias y matriz de covarianzas
+  med=apply(x,2,mean)
+  sc=cov(x)           ## S
+  s=sc*(n-1)/n        ## Sn
+  #####--- Diagonalizaci?n de s
+  auto=eigen(s)
+  v=auto$vectors      ## Vectores propios
+  lambda=auto$values  ## Valores  propios
+
+  k<-((n-1)*p)/(n-p)
+  f1_crit<-qf(1-alfa1,p,n-p)
+  f2_crit<-qf(1-alfa2,p,n-p)
+  c1<-k*f1_crit
+  c2<-k*f2_crit
+  #####--- Gr?fico de Dispersi?n
+  library(latex2exp)
+  plot(x[,1],x[,2],xlab="",ylab="",pch=20, xlim=c(min(x[,1])-1,max(x[,1])+1), ylim=c(min(x[,2])-1,max(x[,2])+1),
+       main = TeX('Datos NB con\ \ $\\underline{\\mu}$\ y $\\Sigma$ \ \ elipse \ \ kF \ \ del \ \ $(1-\\alpha_1)\\%$ \ \ y \ \ $(1-\\alpha_2)\\%$'))
+  points(med[1],med[2],pch=19,col="blue")
+  abline(h=med[2],lty=2,col="red",lwd=1.5)
+  abline(v=med[1],lty=2,col="red",lwd=1.5)
+  ####### Gr?fico de la Elipse
+  teta=seq(0,2*pi,length=101)   ## Vector con los ángulos
+  #####--- Truco para repetir el vector de medias k veces, en 101 filas
+  medr=matrix(rep(med,101),byrow=TRUE,nrow=101)
+  elipse01=medr+sqrt(c1)*t(sqrt(lambda[1])*v[,1]%*%t(cos(teta))+sqrt(lambda[2])*v[,2]%*%t(sin(teta)))  ## contorno eliptico del alfa1%
+  elipse02=medr+sqrt(c2)*t(sqrt(lambda[1])*v[,1]%*%t(cos(teta))+sqrt(lambda[2])*v[,2]%*%t(sin(teta)))  ## contorno eliptico del alfa2%
+  lines(elipse01,col="blue")
+  lines(elipse02,col="red")
+}
+
+
+## Funci?n R para gr?fico de dispersi?n de puntos
+## junto a un contorno de probabilidad para n-grande
+
+representa2c_ng=function(x,alfa1,alfa2){ # Los datos se encuentran en la matriz x
+  p=ncol(x)     ##  N?mero de variables=2
+  n=nrow(x)     ##  N?mero de individuos
+  #####--- C?lculo del vector de medias y matriz de covarianzas
+  med=apply(x,2,mean)
+  sc=cov(x)           ## S
+  s=sc*(n-1)/n        ## Sn
+  #####--- Diagonalizaci?n de s
+  auto=eigen(s)
+  v=auto$vectors      ## Vectores propios
+  lambda=auto$values  ## Valores  propios
+
+  c1<-qchisq(alfa1,2)
+  c2<-qchisq(alfa2,2)
+  #####--- Gr?fico de Dispersi?n
+  library(latex2exp)
+  plot(x[,1],x[,2],xlab="",ylab="",pch=20, xlim=c(min(x[,1])-1,max(x[,1])+1), ylim=c(min(x[,2])-1,max(x[,2])+1),
+  main = TeX('Datos NB con\ \ $\\underline{\\mu}$\ y $\\Sigma$ \ \ elipse \ \ $\\chi^2$ \ \ del \ \ $(1-\\alpha_1)\\%$ \ \ y \ \ $(1-\\alpha_2)\\%$'))
+  points(med[1],med[2],pch=19,col="blue")
+  abline(h=med[2],lty=2,col="red",lwd=1.5)
+  abline(v=med[1],lty=2,col="red",lwd=1.5)
+  ####### Gr?fico de la Elipse
+  teta=seq(0,2*pi,length=101)   ## Vector con los ángulos
+  #####--- Truco para repetir el vector de medias k veces, en 101 filas
+  medr=matrix(rep(med,101),byrow=TRUE,nrow=101)
+  elipse01=medr+sqrt(c1)*t(sqrt(lambda[1])*v[,1]%*%t(cos(teta))+sqrt(lambda[2])*v[,2]%*%t(sin(teta)))  ## contorno eliptico del alfa1%
+  elipse02=medr+sqrt(c2)*t(sqrt(lambda[1])*v[,1]%*%t(cos(teta))+sqrt(lambda[2])*v[,2]%*%t(sin(teta)))  ## contorno eliptico del alfa2%
+  lines(elipse01,col="blue")
+  lines(elipse02,col="red")
+}
+
+## Funci?n R que grafica Superficies de NB,
+## junto a contornos de probabilidad
+
+superficie_NB<- function(mu = c(1,2), sigma){ # por cambiar
+x<-seq(-sigma[1,1]-1.5,sigma[2,2]+1.5,len=50)
+y<-seq(-sigma[1,1]-1.5,sigma[2,2]+1.5,len=50)
+fun <- function(x, y)dmvnorm(c(x, y), mean=mu, sigma=sigma)
+fun <- Vectorize(fun)
+z<-outer(x,y,fun)
+persp(x, y, z, theta=-10, phi=20, expand=0.8, axes=FALSE,box=F)
+}
+
+contorno_NB<- function(mu = c(1,2), sigma){ # por cambiar 
+  x<-seq(-sigma[1,1]-1.5,sigma[2,2]+1.5,len=50)
+  y<-seq(-sigma[1,1]-1.5,sigma[2,2]+1.5,len=50)
+  fun <- function(x, y)dmvnorm(c(x, y), mean=mu, sigma=sigma)
+  fun <- Vectorize(fun)
+  z<-outer(x,y,fun)
+  niveles <- c(max(z)-0.01,0.05,0.01)
+  contour(x,y,z, nlevels=length(niveles),
+    levels=niveles,labels=niveles,lwd=1.5,
+    xlab="",ylab="",
+    main="Contornos de verosimilitud del 99%, 95%",
+    cex.main=0.85,col="blue",lty=2)
+  abline(v=mu[1],lty=2,col="red",lwd=2)
+  abline(h=mu[2],lty=2,col="red",lwd=2)
+}
+
+## Regi?n o Elipse de Confianza del (1-alfa)1005 para mu
+
+elipse_conf<- function(datos, alfa1, N){
+  p<-2
+  n=nrow(datos)
+  centro=apply(datos,2,mean)
+  S=var(datos)
+  k<-((n-1)*p)/(n-p)
+  f_critico<-qf(1-alfa1,p,n-p)
+  c2<-k*f_critico
+  c<-sqrt(c2)/sqrt(n)
+  r <- S[1,2]/sqrt(S[1,1]*S[2,2])
+  Q <- matrix(0, 2, 2) # construye una matriz nula Q
+  Q[1,1] <- sqrt(S[1,1]%*%(1+r)/2) # transformacion del circulo
+  Q[1,2] <- -sqrt(S[1,1]%*%(1-r)/2) # unitario a una elipse
+  Q[2,1] <- sqrt(S[2,2]%*%(1+r)/2)
+  Q[2,2] <- sqrt(S[2,2]%*%(1-r)/2)
+  alpha <- seq(0, by = (2*pi)/N, length = N)
+  # define angulos para graficar
+  Z <- cbind(cos(alpha), sin(alpha)) # Define coordenadas
+  #de puntos sobre circulo unitario
+  X <- t(centro + c*Q%*%t(Z)) # Define coordenadas de puntos
+  #sobre la elipse
+  plot(X[,1], X[,2],type="l",
+       xlab=TeX('$\\mu_1$'),ylab=TeX('$\\mu_2$'),
+       main = TeX("Elipse:\ \ $n(\\underline{\\bar{X}}-\\underline{\\mu})^T
+\\textbf{S^{-1}}(\\underline{\\bar{X}}-\\underline{\\mu})=c^2$ \ \ del \ \ $(1-\\alpha)100\\% $"))
+  points(centro[1],centro[2],pch=19,col="blue")
+  abline(v=centro[1],lty=2,col="red",lwd=2)
+abline(h=centro[2],lty=2,col="red",lwd=2)
+}
+
+## Regi?n o Elipse de Confianza para mu con IC-T^2
+## Individuales
+elipse_conf_IC_T2<- function(datos, alfa1, N){
+  p<-2
+  n=nrow(datos)
+  centro=apply(datos,2,mean)
+  S=var(datos)
+  k<-((n-1)*p)/(n-p)
+  f_critico<-qf(1-alfa1,p,n-p)
+  c2<-k*f_critico
+  c<-sqrt(c2)/sqrt(n)
+  r <- S[1,2]/sqrt(S[1,1]*S[2,2])
+  Q <- matrix(0, 2, 2) # construye una matriz nula Q
+  Q[1,1] <- sqrt(S[1,1]%*%(1+r)/2) # transformacion del circulo
+  Q[1,2] <- -sqrt(S[1,1]%*%(1-r)/2) # unitario a una elipse
+  Q[2,1] <- sqrt(S[2,2]%*%(1+r)/2)
+  Q[2,2] <- sqrt(S[2,2]%*%(1-r)/2)
+  alpha <- seq(0, by = (2*pi)/N, length = N)
+  # define angulos para graficar
+  Z <- cbind(cos(alpha), sin(alpha)) # Define coordenadas
+  #de puntos sobre circulo unitario
+  X <- t(centro + c*Q%*%t(Z)) # Define coordenadas de puntos
+  #sobre la elipse
+  limu1<-centro[1]-sqrt(c2)*sqrt(S[1,1]/n)
+  lsmu1<-centro[1]+sqrt(c2)*sqrt(S[1,1]/n)
+  limu2<-centro[2]-sqrt(c2)*sqrt(S[2,2]/n)
+  lsmu2<-centro[2]+sqrt(c2)*sqrt(S[2,2]/n)
+  plot(X[,1], X[,2],type='l',xaxt = "n",yaxt = "n",xlab=TeX('$\\mu_1$'),ylab=TeX('$\\mu_2$'),
+       main = TeX("IC: T^2\ \ -----") )
+  axis(1, at = c(round(limu1,3),
+                 round(centro[1],3),
+                 round(lsmu1,3)),
+       labels = c(round(limu1,3),
+                  round(centro[1],3),
+                  round(lsmu1,3)),las=2,cex.axis = 0.7)
+  axis(2, at = c(round(limu2,3),
+                 round(centro[2],3),
+                 round(lsmu2,3)),
+       labels = c(round(limu2,3),
+                  round(centro[2],3),
+                  round(lsmu2,3)),las=2,cex.axis = 0.7)
+  abline(v=limu1,lty=2,col="blue",lwd=2)
+  abline(v=lsmu1,lty=2,col="blue",lwd=2)
+  abline(h=limu2,lty=2,col="blue",lwd=2)
+  abline(h=lsmu2,lty=2,col="blue",lwd=2)
+  abline(v=centro[1],lty=3,col="gray",lwd=2)
+  abline(h=centro[2],lty=3,col="gray",lwd=2)
+}
+
+
+elipse_conf_IC13_T2<- function(datos, alfa1, N){
+  p<-2
+  n=nrow(datos)
+  centro=apply(datos,2,mean)
+  S=var(datos)
+  k<-((n-1)*p)/(n-p)
+  f_critico<-qf(1-alfa1,p,n-p)
+  c2<-k*f_critico
+  c<-sqrt(c2)/sqrt(n)
+  r <- S[1,2]/sqrt(S[1,1]*S[2,2])
+  Q <- matrix(0, 2, 2) # construye una matriz nula Q
+  Q[1,1] <- sqrt(S[1,1]%*%(1+r)/2) # transformacion del circulo
+  Q[1,2] <- -sqrt(S[1,1]%*%(1-r)/2) # unitario a una elipse
+  Q[2,1] <- sqrt(S[2,2]%*%(1+r)/2)
+  Q[2,2] <- sqrt(S[2,2]%*%(1-r)/2)
+  alpha <- seq(0, by = (2*pi)/N, length = N)
+  # define angulos para graficar
+  Z <- cbind(cos(alpha), sin(alpha)) # Define coordenadas
+  #de puntos sobre circulo unitario
+  X <- t(centro + c*Q%*%t(Z)) # Define coordenadas de puntos
+  #sobre la elipse
+  limu1<-centro[1]-sqrt(c2)*sqrt(S[1,1]/n)
+  lsmu1<-centro[1]+sqrt(c2)*sqrt(S[1,1]/n)
+  limu2<-centro[2]-sqrt(c2)*sqrt(S[2,2]/n)
+  lsmu2<-centro[2]+sqrt(c2)*sqrt(S[2,2]/n)
+  plot(X[,1], X[,2],type='l',xaxt = "n",yaxt = "n",
+       xlab=TeX('$\\mu_1$'),ylab=TeX('$\\mu_3$'),
+       main = TeX("Elipse:\ \ $n(\\underline{\\bar{X}}-\\underline{\\mu})^T
+\\textbf{S^{-1}}(\\underline{\\bar{X}}-\\underline{\\mu})=c^2$\ \ \ Con\ \ \ \ IC: T^2\ \ -----") )
+  axis(1, at = c(round(limu1,3),
+                 round(centro[1],3),
+                 round(lsmu1,3)),
+       labels = c(round(limu1,3),
+                  round(centro[1],3),
+                  round(lsmu1,3)),las=2,cex.axis = 0.7)
+  axis(2, at = c(round(limu2,3),
+                 round(centro[2],3),
+                 round(lsmu2,3)),
+       labels = c(round(limu2,3),
+                  round(centro[2],3),
+                  round(lsmu2,3)),las=2,cex.axis = 0.7)
+abline(v=limu1,lty=2,col="red",lwd=2)
+  abline(v=lsmu1,lty=2,col="red",lwd=2)
+  abline(h=limu2,lty=2,col="red",lwd=2)
+  abline(h=lsmu2,lty=2,col="red",lwd=2)
+  abline(v=centro[1],lty=3,col="gray",lwd=2)
+  abline(h=centro[2],lty=3,col="gray",lwd=2)
+}
+
+
+elipse_conf_IC23_T2<- function(datos, alfa1, N){
+  p<-2
+  n=nrow(datos)
+  centro=apply(datos,2,mean)
+  S=var(datos)
+  k<-((n-1)*p)/(n-p)
+  f_critico<-qf(1-alfa1,p,n-p)
+  c2<-k*f_critico
+  c<-sqrt(c2)/sqrt(n)
+  r <- S[1,2]/sqrt(S[1,1]*S[2,2])
+  Q <- matrix(0, 2, 2) # construye una matriz nula Q
+  Q[1,1] <- sqrt(S[1,1]%*%(1+r)/2) # transformacion del circulo
+  Q[1,2] <- -sqrt(S[1,1]%*%(1-r)/2) # unitario a una elipse
+  Q[2,1] <- sqrt(S[2,2]%*%(1+r)/2)
+  Q[2,2] <- sqrt(S[2,2]%*%(1-r)/2)
+  alpha <- seq(0, by = (2*pi)/N, length = N)
+  # define angulos para graficar
+  Z <- cbind(cos(alpha), sin(alpha)) # Define coordenadas
+  #de puntos sobre circulo unitario
+  X <- t(centro + c*Q%*%t(Z)) # Define coordenadas de puntos
+  #sobre la elipse
+  limu1<-centro[1]-sqrt(c2)*sqrt(S[1,1]/n)
+  lsmu1<-centro[1]+sqrt(c2)*sqrt(S[1,1]/n)
+  limu2<-centro[2]-sqrt(c2)*sqrt(S[2,2]/n)
+  lsmu2<-centro[2]+sqrt(c2)*sqrt(S[2,2]/n)
+  plot(X[,1], X[,2],type='l',xaxt = "n",yaxt = "n",
+       xlab=TeX('$\\mu_2$'),ylab=TeX('$\\mu_3$'),
+       main = TeX("Elipse:\ \ $n(\\underline{\\bar{X}}-\\underline{\\mu})^T
+\\textbf{S^{-1}}(\\underline{\\bar{X}}-\\underline{\\mu})=c^2$\ \ \ Con\ \ \ \ IC: T^2\ \ -----") )
+  axis(1, at = c(round(limu1,3),
+                 round(centro[1],3),
+                 round(lsmu1,3)),
+       labels = c(round(limu1,3),
+                  round(centro[1],3),
+                  round(lsmu1,3)),las=2,cex.axis = 0.7)
+  axis(2, at = c(round(limu2,3),
+                 round(centro[2],3),
+                 round(lsmu2,3)),
+       labels = c(round(limu2,3),
+                  round(centro[2],3),
+                  round(lsmu2,3)),las=2,cex.axis = 0.7)
+abline(v=limu1,lty=2,col="red",lwd=2)
+  abline(v=lsmu1,lty=2,col="red",lwd=2)
+  abline(h=limu2,lty=2,col="red",lwd=2)
+  abline(h=lsmu2,lty=2,col="red",lwd=2)
+  abline(v=centro[1],lty=3,col="gray",lwd=2)
+  abline(h=centro[2],lty=3,col="gray",lwd=2)
+}
+
+## Regi?n o Elipse de Confianza para mu con IC-Bonferroni
+### Individuales
+elipse_conf_IC_BONF<- function(datos, alfa1, N){
+  p<-2
+  n=nrow(datos)
+  centro=apply(datos,2,mean)
+  S=var(datos)
+  k<-((n-1)*p)/(n-p)
+  f_critico<-qf(1-alfa1,p,n-p)
+  c2<-k*f_critico
+  c<-sqrt(c2)/sqrt(n)
+  t_critico<-qt(1-alfa1/(2*p),n-1)
+  r <- S[1,2]/sqrt(S[1,1]*S[2,2])
+  Q <- matrix(0, 2, 2) # construye una matriz nula Q
+  Q[1,1] <- sqrt(S[1,1]%*%(1+r)/2) # transformacion del circulo
+  Q[1,2] <- -sqrt(S[1,1]%*%(1-r)/2) # unitario a una elipse
+  Q[2,1] <- sqrt(S[2,2]%*%(1+r)/2)
+  Q[2,2] <- sqrt(S[2,2]%*%(1-r)/2)
+  alpha <- seq(0, by = (2*pi)/N, length = N)
+  # define angulos para graficar
+  Z <- cbind(cos(alpha), sin(alpha)) # Define coordenadas
+  #de puntos sobre circulo unitario
+  X <- t(centro + c*Q%*%t(Z)) # Define coordenadas de puntos
+  #sobre la elipse
+  limu1<-centro[1]-sqrt(c2)*sqrt(S[1,1]/n)
+  lsmu1<-centro[1]+sqrt(c2)*sqrt(S[1,1]/n)
+  limu2<-centro[2]-sqrt(c2)*sqrt(S[2,2]/n)
+  lsmu2<-centro[2]+sqrt(c2)*sqrt(S[2,2]/n)
+  limu1b<-centro[1]-t_critico*sqrt(S[1,1]/n)
+  lsmu1b<-centro[1]+t_critico*sqrt(S[1,1]/n)
+  limu2b<-centro[2]-t_critico*sqrt(S[2,2]/n)
+  lsmu2b<-centro[2]+t_critico*sqrt(S[2,2]/n)
+  plot(X[,1], X[,2],type='l',xaxt = "n",yaxt = "n",
+       xlab=TeX('$\\mu_1$'),ylab=TeX('$\\mu_2$'),
+       main = TeX("IC: T^2\ \ ----- \ \ $\ \ \ e \ \ $\ \ IC-Bonferroni \ \ ..... \ \ $") )
+  axis(1, at = c(round(limu1,3),round(limu1b,3),
+                 round(centro[1],3),round(lsmu1b,3),
+                 round(lsmu1,3)),
+       labels = c(round(limu1,3),round(limu1b,3),
+                  round(centro[1],3),round(lsmu1b,3),
+                  round(lsmu1,3)),las=2,cex.axis = 0.7)
+axis(2, at = c(round(limu2,3),round(limu2b,3),
+                 round(centro[2],3),round(lsmu2b,3),
+                 round(lsmu2,3)),
+       labels = c(round(limu2,3),round(limu2b,3),
+                  round(centro[2],3),round(lsmu2b,3),
+                  round(lsmu2,3)),las=2,cex.axis = 0.7)
+  abline(v=limu1,lty=2,col="blue",lwd=2)
+  abline(v=lsmu1,lty=2,col="blue",lwd=2)
+  abline(h=limu2,lty=2,col="blue",lwd=2)
+  abline(h=lsmu2,lty=2,col="blue",lwd=2)
+  abline(v=limu1b,lty=3,col="red",lwd=2)
+  abline(v=lsmu1b,lty=3,col="red",lwd=2)
+  abline(h=limu2b,lty=3,col="red",lwd=2)
+  abline(h=lsmu2b,lty=3,col="red",lwd=2)
+  abline(v=centro[1],lty=3,col="gray",lwd=2)
+  abline(h=centro[2],lty=3,col="gray",lwd=2)
+}
+
+
+## Regi?n o Elipse de Confianza para mu con IC-Bonferroni
+### Individuales
+elipse_conf_IC_tstud<- function(datos, alfa1, N){
+  p<-2
+  n=nrow(datos)
+  centro=apply(datos,2,mean)
+  S=var(datos)
+  k<-((n-1)*p)/(n-p)
+  f_critico<-qf(1-alfa1,p,n-p)
+  c2<-k*f_critico
+  c<-sqrt(c2)/sqrt(n)
+  t_critico<-qt(1-alfa1/(2*p),n-1)
+  t2_critico<-qt(1-alfa1/2,n-1)
+  r <- S[1,2]/sqrt(S[1,1]*S[2,2])
+  Q <- matrix(0, 2, 2) # construye una matriz nula Q
+  Q[1,1] <- sqrt(S[1,1]%*%(1+r)/2) # transformacion del circulo
+  Q[1,2] <- -sqrt(S[1,1]%*%(1-r)/2) # unitario a una elipse
+  Q[2,1] <- sqrt(S[2,2]%*%(1+r)/2)
+  Q[2,2] <- sqrt(S[2,2]%*%(1-r)/2)
+  alpha <- seq(0, by = (2*pi)/N, length = N)
+  # define angulos para graficar
+  Z <- cbind(cos(alpha), sin(alpha)) # Define coordenadas
+  #de puntos sobre circulo unitario
+  X <- t(centro + c*Q%*%t(Z)) # Define coordenadas de puntos
+  #sobre la elipse
+  limu1<-centro[1]-sqrt(c2)*sqrt(S[1,1]/n)
+  lsmu1<-centro[1]+sqrt(c2)*sqrt(S[1,1]/n)
+  limu2<-centro[2]-sqrt(c2)*sqrt(S[2,2]/n)
+  lsmu2<-centro[2]+sqrt(c2)*sqrt(S[2,2]/n)
+  limu1b<-centro[1]-t_critico*sqrt(S[1,1]/n)
+  lsmu1b<-centro[1]+t_critico*sqrt(S[1,1]/n)
+  limu2b<-centro[2]-t_critico*sqrt(S[2,2]/n)
+  lsmu2b<-centro[2]+t_critico*sqrt(S[2,2]/n)
+  limu1t<-centro[1]-t2_critico*sqrt(S[1,1]/n)
+  lsmu1t<-centro[1]+t2_critico*sqrt(S[1,1]/n)
+  limu2t<-centro[2]-t2_critico*sqrt(S[2,2]/n)
+  lsmu2t<-centro[2]+t2_critico*sqrt(S[2,2]/n)
+  plot(X[,1], X[,2],type='l',xaxt = "n",yaxt = "n",
+       xlab=TeX('$\\mu_1$'),ylab=TeX('$\\mu_2$'),
+       main = TeX("IC: t-Student, \ -.-.-.- \ IC: T^2\ \ ----- \ \ $\ \ \ e \ \ $\ \ IC-Bonferroni \ \ ..... \ \ $") )
+  axis(1, at = c(round(limu1,3),round(limu1b,3),
+                 round(limu1t,3),
+                 round(centro[1],3),round(lsmu1t,3),round(lsmu1b,3),
+                 round(lsmu1,3)),
+       labels = c(round(limu1,3),round(limu1b,3),
+                  round(limu1t,3),
+                  round(centro[1],3),round(lsmu1t,3),round(lsmu1b,3),
+                  round(lsmu1,3)),las=2,cex.axis = 0.7)
+  axis(2, at = c(round(limu2,3),round(limu2b,3),
+                 round(limu2t,3),
+                 round(centro[2],3),round(lsmu2t,3),round(lsmu2b,3),
+                 round(lsmu2,3)),
+       labels = c(round(limu2,3),round(limu2b,3),
+                  round(limu2t,3),
+                  round(centro[2],3),round(lsmu2t,3),round(lsmu2b,3),
+                  round(lsmu2,3)),las=2,cex.axis = 0.7)
+  abline(v=limu1,lty=2,col="blue",lwd=2)
+  abline(v=lsmu1,lty=2,col="blue",lwd=2)
+  abline(h=limu2,lty=2,col="blue",lwd=2)
+  abline(h=lsmu2,lty=2,col="blue",lwd=2)
+  abline(v=limu1b,lty=3,col="red",lwd=2)
+  abline(v=lsmu1b,lty=3,col="red",lwd=2)
+  abline(h=limu2b,lty=3,col="red",lwd=2)
+  abline(h=lsmu2b,lty=3,col="red",lwd=2)
+  abline(v=limu1t,lty=4,col="gray",lwd=2)
+  abline(v=lsmu1t,lty=4,col="gray",lwd=2)
+  abline(h=limu2t,lty=4,col="gray",lwd=2)
+  abline(h=lsmu2t,lty=4,col="gray",lwd=2)
+  abline(v=centro[1],lty=3,col="gray",lwd=2)
+  abline(h=centro[2],lty=3,col="gray",lwd=2)
+}
+
+
+#######################################################
+#######      Resumenes descriptivos varios ############
+#######################################################
+
+asimetria=function(x) {
+  m3=mean((x-mean(x))^3)
+  skew=m3/(sd(x)^3)
+  skew}
+
+#### obtenci?n del coeficiente de curtosis muestral
+
+kurtosis=function(x) {
+  m4=mean((x-mean(x))^4)
+  kurt=m4/(sd(x)^4)
+  kurt}
+
+#######################################
+# Scatterplot con Histogramas paralelos
+
+scatterhist = function(x, y, xlab="", ylab=""){
+  zones=matrix(c(2,0,1,3), ncol=2, byrow=TRUE)
+  layout(zones, widths=c(4/5,1/5), heights=c(1/5,4/5))
+  xhist = hist(x, plot=FALSE)
+  yhist = hist(y, plot=FALSE)
+  top = max(c(xhist$counts, yhist$counts))
+  par(mar=c(3,3,1,1))
+  plot(x,y)
+  par(mar=c(0,3,1,1))
+  barplot(xhist$counts, axes=FALSE, ylim=c(0, top), space=0)
+  par(mar=c(3,0,1,1))
+  barplot(yhist$counts, axes=FALSE, xlim=c(0, top), space=0, horiz=TRUE)
+  par(oma=c(3,3,0,0))
+  mtext(xlab, side=1, line=1, outer=TRUE, adj=0,
+        at=.8 * (mean(x) - min(x))/(max(x)-min(x)))
+  mtext(ylab, side=2, line=1, outer=TRUE, adj=0,
+        at=(.8 * (mean(y) - min(y))/(max(y) - min(y))))
+}
+
+##############################
+## Función para Gráfico de perfiles para cada variable
+makeProfilePlot <- function(mylist,names)
+{
+  require(RColorBrewer)
+  # find out how many variables we want to include
+  numvariables <- length(mylist)
+  # choose 'numvariables' random colours
+  colours <- brewer.pal(numvariables,"Set1")
+  # find out the minimum and maximum values of the variables:
+  mymin <- 1e+20
+  mymax <- 1e-20
+  for (i in 1:numvariables)
+  {
+    vectori <- mylist[[i]]
+    mini <- min(vectori)
+    maxi <- max(vectori)
+    if (mini < mymin) { mymin <- mini }
+    if (maxi > mymax) { mymax <- maxi }
+  }
+  # plot the variables
+  for (i in 1:numvariables)
+  {
+    vectori <- mylist[[i]]
+    namei <- names[i]
+    colouri <- colours[i]
+    if (i == 1) { plot(vectori,col=colouri,type="l",ylim=c(mymin,mymax)) }
+    else         { points(vectori, col=colouri,type="l")                                     }
+    lastxval <- length(vectori)
+    lastyval <- vectori[length(vectori)]
+    text((lastxval-10),(lastyval),namei,col="black",cex=0.6)
+  }
+}
+
+
+#########################
+# Setup of a Correlation Lower Panel in Scatterplot Matrix
+myPanel.hist <- function(x, ...){
+  usr <- par("usr")
+  on.exit(par(usr))
+  # Para definir región de graficiación
+  par(usr = c(usr[1:2], 0, 1.5) )
+  # Para obtener una lista que guarde las marcas de clase y conteos en cada una:
+  h <- hist(x, plot = FALSE)
+  breaks <- h$breaks;
+  nB <- length(breaks)
+  y <- h$counts; y <- y/max(y)
+  # Para dibujar los histogramas
+  rect(breaks[-nB], 0, breaks[-1], y, col="cyan", ...)
+}
+
+#########################
+# Setup of a Boxplot Diagonal Panel in Scatterplot Matrix
+myPanel.box <- function(x, ...){
+  usr <- par("usr", bty = 'n')
+  on.exit(par(usr))
+  par(usr = c(-1, 1, min(x) - 0.5, max(x) + 0.5))
+  b <- boxplot(x, plot = F)
+  whisker.i <- b$stats[1,]
+  whisker.s <- b$stats[5,]
+  hinge.i <- b$stats[2,]
+  mediana <- b$stats[3,]
+  hinge.s <- b$stats[4,]
+  rect(-0.5, hinge.i, 0.5, mediana, col = 'gray')
+  segments(0, hinge.i, 0, whisker.i, lty = 2)
+  segments(-0.1, whisker.i, 0.1, whisker.i)
+  rect(-0.5, mediana, 0.5, hinge.s, col = 'gray')
+  segments(0, hinge.s, 0, whisker.s, lty = 2)
+  segments(-0.1, whisker.s, 0.1, whisker.s)
+}
+
+#######################
+# Setup of a Correlation Lower Panel in Scatterplot Matrix
+myPanel.cor <- function(x, y, digits = 2, prefix = "", cex.cor){
+  usr <- par("usr")
+  on.exit(par(usr = usr))
+  par(usr = c(0, 1, 0, 1))
+  r <- cor(x, y)
+  txt <- format(c(r, 0.123456789), digits = digits)[1]
+  txt <- paste(prefix, txt, sep = "")
+  if(missing(cex.cor))
+    cex = 0.4/strwidth(txt)
+  text(0.5, 0.5, txt, cex = 1 + 1.5*abs(r))
+}
+
+# QQ-plot with Shapiro-Wilk normal test
+QQnorm <- function(datos){
+    lab.plot <- "Normal Q-Q Plot of Datos Crudos"
+  shapiro <- shapiro.test(datos)
+  shapvalue <- ifelse(shapiro$p.value < 0.001,
+      "P value < 0.001", paste("P value = ",
+        round(shapiro$p.value, 4), sep = ""))
+  shapstat <- paste("W = ", round(shapiro$statistic, 4),
+                    sep = "")
+  q <- qqnorm(datos, plot.it = FALSE)
+  qqnorm(datos, main = lab.plot)
+  qqline(datos, lty = 1, col = 2)
+  text(min(q$x, na.rm = TRUE), max(q$y,
+      na.rm = TRUE)*0.95, pos = 4,
+      'Shapiro-Wilk Test', col = "blue", font = 2)
+  text(min(q$x, na.rm = TRUE), max(q$y,
+      na.rm = TRUE)*0.80, pos = 4, shapstat,
+      col = "blue", font = 3)
+  text(min(q$x, na.rm = TRUE), max(q$y, na.rm = TRUE)*0.65,
+       pos = 4, shapvalue, col = "blue", font = 3)
+}
+
+# QQ-plot with Shapiro-Wilk normal test (datos transformados)
+QQnorm_transf <- function(datos){
+  lab.plot <- "Normal Q-Q Plot of Datos Transformados"
+  shapiro <- shapiro.test(datos)
+
+  shapvalue <- ifelse(shapiro$p.value < 0.001,
+          "P value < 0.001", paste("P value = ",
+          round(shapiro$p.value, 4), sep = ""))
+
+  shapstat <- paste("W = ", round(shapiro$statistic, 4),
+                    sep = "")
+
+  q <- qqnorm(datos, plot.it = FALSE)
+  qqnorm(datos, main = lab.plot)
+  qqline(datos, lty = 2, col = 2)
+
+  text(min(q$x, na.rm = TRUE),
+       max(q$y-0.2, na.rm = TRUE)*0.95, pos = 4,
+       'Shapiro-Wilk Test', col = "blue", font = 2)
+
+  text(min(q$x, na.rm = TRUE),
+       max(q$y-0.7, na.rm = TRUE)*0.80, pos = 4,
+       shapstat, col = "blue", font = 3)
+
+  text(min(q$x, na.rm = TRUE),
+       max(q$y-1.5, na.rm = TRUE)*0.65, pos = 4,
+       shapvalue, col = "blue", font = 3)
+}
+
+######## coeficiente de asimetría
+asimetria=function(x) {
+  m3=mean((x-mean(x))^3)
+  skew=m3/(sd(x)^3)
+  skew}
+
+####### Coeficiente de Kurtosis
+kurtosis=function(x) {
+  m4=mean((x-mean(x))^4)
+  kurt=m4/(sd(x)^4)
+  kurt}
+
+##########################
+##########################
+
+## Función para Gráfico de perfiles para cada variable
+makeProfilePlot <- function(mylist,names)
+{
+  require(RColorBrewer)
+  # find out how many variables we want to include
+  numvariables <- length(mylist)
+  # choose 'numvariables' random colours
+  colours <- brewer.pal(numvariables,"Set1")
+  # find out the minimum and maximum values of the variables:
+  mymin <- 1e+20
+  mymax <- 1e-20
+  for (i in 1:numvariables)
+  {
+    vectori <- mylist[[i]]
+    mini <- min(vectori)
+    maxi <- max(vectori)
+    if (mini < mymin) { mymin <- mini }
+    if (maxi > mymax) { mymax <- maxi }
+  }
+  # plot the variables
+  for (i in 1:numvariables)
+  {
+    vectori <- mylist[[i]]
+    namei <- names[i]
+    colouri <- colours[i]
+    if (i == 1) { plot(vectori,col=colouri,type="l",ylim=c(mymin,mymax)) }
+    else         { points(vectori, col=colouri,type="l")                                     }
+    lastxval <- length(vectori)
+    lastyval <- vectori[length(vectori)]
+    text((lastxval-10),(lastyval),namei,col="black",cex=0.6)
+  }
+}
+
+
+## Función para Resumen descriptivo por grupos
+resumen_xgrupos <- function(misdatos,grupos)
+{
+  # se hallan los nombres de las variables
+  nombres_misdatos <- c(names(grupos),names(as.data.frame(misdatos)))
+  # se halla la media dentro de cada grupo
+  grupos <- grupos[,1] # nos aseguramos de que la var grupos no sea una lista
+  medias <- aggregate(as.matrix(misdatos) ~ grupos, FUN = mean)
+  names(medias) <- nombres_misdatos
+  # se hallan las desv-estandar dentro de cada grupos:
+  sds <- aggregate(as.matrix(misdatos) ~ grupos, FUN = sd)
+  names(sds) <- nombres_misdatos
+  # se hallan las varianzas dentro de cada grupos:
+  varianzas <- aggregate(as.matrix(misdatos) ~ grupos, FUN = var)
+  names(varianzas) <- nombres_misdatos
+  # se hallan las medianas dentro de cada grupos:
+  medianas <- aggregate(as.matrix(misdatos) ~ grupos, FUN = median)
+  names(medianas) <- nombres_misdatos
+  # se hallan los tama?os muestrales de cada grupo:
+  tamanos_n <- aggregate(as.matrix(misdatos) ~ grupos, FUN = length)
+  names(tamanos_n) <- nombres_misdatos
+  list(Medias=medias,Desviaciones_Estandar=sds,
+       Varianzas=varianzas, Medianas=medianas,
+       Tamanos_Muestrales=tamanos_n)
+}
+
+##################################################
+#########           PH-AM               ##########
+##################################################
+
+## Función creada para la Prueba M-Box de Matrices de Var-Cov, ie. para
+## Sigam_1=SIgma_2, pob. Normal
+prueba_M_Box2=function(x,y,alfa){
+  g<-2
+  n=nrow(x);m=nrow(y);p=ncol(x)
+  s1=var(x);s2=var(y)
+  v<-n+m-2
+  sp<-( (n-1)*s1+(m-1)*s2 )/v
+  M<-v*log( det(sp) )-( (n-1)*log( det(s1) ) + (m-1)*log( det(s2) ) )
+  u<-( ( 1/(n-1) ) + ( 1/(m-1) ) - (1/v) )*( (2*p^2 + 3*p - 1)/(6*(p+1)*(g-1)) )
+  c<-(1-u)*M
+  df=( p*(p+1)*(g-1) )/2  # Grados de liber del num de la chi-cuadrado
+  chi_tabla=qchisq(1-alfa,df) # Valor crítico de la chi o Chi-de la tabla
+  valor_p=1-pchisq(c,df)  # valor-p de la prueba
+  resultados=data.frame(M=M,U=u,C=c,df=df,Chi_Tabla=chi_tabla,Valor_p=valor_p)
+  format(resultados, digits = 6)
+}
+
+
+## Función creada para la prueba de igualdad de medias, ie. para:
+## mu_1-mu_2=mu_0, sigmas iguales, pob. Normal
+HT2_sigmas_iguales=function(x,y,mu_0,alfa){
+  mux=apply(x,2,mean);muy=apply(y,2,mean)
+  sx<-var(x);sy<-var(y)
+  n=nrow(x);m=nrow(y);p=ncol(x)
+  df1=p;df2<-n+m-p-1 # Grados de libertad del num y denom de la F
+  sp<-( (n-1)*sx + (m-1)*sy )/(n+m-2)
+  T_2<-( (n*m)/(n+m) )*t(mux-muy-mu_0)%*%solve(sp)%*%(mux-muy-mu_0)
+  k<-( (n+m-2)*p )/(n+m-p-1)
+  F0<-(1/k)*T_2               # Estad?stica F_0=(1/k)T2
+  F_tabla=qf(1-alfa,df1,df2)  # Valor cr?tico de la F o F-de la Tabla
+  valor_p=1-pf(F0,df1,df2)    # valor-p de la prueba
+  resultados<-data.frame(T2=T_2,k=k,F0=F0,
+                   df1=df1,df2=df2,F_Tabla=F_tabla,Valor_p=valor_p)
+  cat("El vector mu0 es:", mu_0 )
+  format(resultados, digits = 6)
+}
+
+
+## Función creada para la prueba de igualdad de medias, ie. para:
+## mu_1-mu_2=mu_0, sigmas iguales, n-grande
+HT2_sigmas_iguales_ngrande=function(x,y,mu_0,alfa){
+  mux=apply(x,2,mean);muy=apply(y,2,mean)
+  sx<-var(x);sy<-var(y)
+  n=nrow(x);m=nrow(y);p=ncol(x)
+  df=p      # Grados de libertad de la chi-cuadrado
+  sp<-( (n-1)*sx + (m-1)*sy )/(n+m-2)
+  chi_2<-( (n*m)/(n+m) )*t(mux-muy-mu_0)%*%solve(sp)%*%(mux-muy-mu_0)
+  chi_tabla=qchisq(1-alfa,df)  # Valor de la chi_cuadrado, ie. chi_Tabla
+  valor_p=1-pchisq(chi_2,df)    # valor-p de la prueba
+  resultados<-data.frame(Chi2=chi_2,df=df,
+                   Chi_Tabla=chi_tabla,Valor_p=valor_p)
+  cat("El vector mu0 es:", mu_0 )
+  format(resultados, digits = 6)
+}
+
+## Función para PH de mu_x-mu_y=mu_0, sigmas diferentes y desconocidas,
+## Poba. Normal -Aproximación de: Nel y Van Der Merwe (1986) para v
+HT2_sigmas_diferentes=function(x,y,mu_0,alfa){
+  mux=apply(x,2,mean);muy=apply(y,2,mean)
+  sx<-var(x);sy<-var(y)
+  n=nrow(x);m=nrow(y);p=ncol(x)
+  v1<-(1/n)*sx;v2<-(1/m)*sy
+  se<-v1+v2
+  v<-( sum(diag(se%*%se)) +
+         sum(diag(se))^2 )/( (1/(n-1))*(sum(diag(v1%*%v1)) +
+                                          sum(diag(v1))^2) +
+                               ( 1/(m-1) )*(sum(diag(v2%*%v2)) +
+                                              sum(diag(v2))^2) )
+  v<-ceiling(v)
+  df1=p;df2<-v-p+1  # Grados de libertad de la F
+  sp<-( (n-1)*sx + (m-1)*sy )/(n+m-2)
+  T_2<-t(mux-muy-mu_0)%*%solve(se)%*%(mux-muy-mu_0)
+  k<-(v*p)/(v-p+1)
+  F0<-(1/k)*T_2
+  F_tabla=qf(1-alfa,df1,df2)
+  valor_p=1-pf(F0,df1,df2)
+  resultados=data.frame(T_2=T_2,v=v,k=k,F0=F0,
+                  df1=df1,df2=df2,F_Tabla=F_tabla,Valor_p=valor_p)
+  cat("El vector mu0 es:", mu_0 )
+  format(resultados, digits = 6)
+}
+
+
+## Función para PH de mu_x-mu_y=mu_0, sigmas diferentes y desconocidas,
+## Poba. Normal-Aproximación de Krishnamoorty and Yu (2004)
+## texto-Guía con: p+p^2 en el numerador de v
+HT2_sigmas_diferentes_texto_guia=function(x,y,mu_0,alfa){
+  mux=apply(x,2,mean);muy=apply(y,2,mean)
+  sx<-var(x);sy<-var(y)
+  n=nrow(x);m=nrow(y);p=ncol(x)
+  v1<-(1/n)*sx;v2<-(1/m)*sy
+  se<-v1+v2
+  numer<-p+(p^2)
+  den1<-sum( diag( (v1%*%solve(se))%*%(v1%*%solve(se)) ) )
+             + sum( ( diag( v1%*%solve(se) ) )^2 )
+  den2<-sum( diag( (v2%*%solve(se))%*%(v2%*%solve(se)) ) )
+             + sum( ( diag( v2%*%solve(se) ) )^2 )
+  v<-(numer)/( den1/n + den2/m )
+v<-ceiling(v)
+  df1=p;df2<-v-p+1  # Grados de libertad de la F
+  #sp<-( (n-1)*sx + (m-1)*sy )/(n+m-2)
+  T_2<-t(mux-muy-mu_0)%*%solve(se)%*%(mux-muy-mu_0)
+  k<-(v*p)/(v-p+1)
+  F0<-(1/k)*T_2
+  F_tabla=qf(1-alfa,df1,df2)
+  valor_p=1-pf(F0,df1,df2)
+  resultados=data.frame(T_2=T_2,v=v,k=k,F0=F0,
+                  df1=df1,df2=df2,F_Tabla=F_tabla,Valor_p=valor_p)
+  cat("El vector mu0 es:", mu_0 )
+  format(resultados, digits = 6)
+}
+
+
+## Función para la PH de mu=mu_0-pob. Normal
+HT2_mu0=function(x,mu_0,alfa){
+  mu=apply(x,2,mean);s=var(x)
+#  mu <- as.vector(mu)
+  n=nrow(x);p=ncol(x)
+  df1=p;df2=n-p
+  T2<-n*t(mu-mu_0)%*%solve(s)%*%(mu-mu_0)
+  k<-( (n-1)*p )/(n-p)
+  F0<-(1/k)*T2
+  F_tabla=qf(1-alfa,df1,df2)
+  valor_p=1-pf(F0,df1,df2)
+  resultados=data.frame(T2=T2,K=k,F0=F0,df1=df1,df2=df2,
+                  F_Tabla=F_tabla,Valor_p=valor_p)
+  cat("El vector mu0 es:", mu_0 )
+  format(resultados, digits = 6)
+}
+
+## Función para la PH de mu=mu_0-n-grande
+HT2_mu0_ngrande=function(x,mu_0,alfa){
+  mu=apply(x,2,mean);s=var(x)
+  n=nrow(x);p=ncol(x)
+  df=p
+  chi_2<-n*t(mu-mu_0)%*%solve(s)%*%(mu-mu_0)
+  chi_tabla=qchisq(1-alfa,df)
+  valor_p=1-pchisq(chi_2,df)
+  resultados=data.frame(Chi_2=chi_2,df=df,Chi_Tabla=chi_tabla,
+                        Valor_p=valor_p)
+  cat("El vector mu0 es:", mu_0 )
+  format(resultados, digits = 6)
+}
+
+
+## Función Creada para la PH de: CU=mu_0-Pob. Normal
+HT2_CU=function(x,C,delta_0,alfa){
+  mu=as.vector(apply(x,2,mean));s=var(x)
+  n=nrow(x);p=ncol(x)
+  k<-nrow(C)        ## n?mero de contrastes
+  df1=k
+  df2=n-k
+  T2<-n*t(C%*%mu-delta_0)%*%solve(C%*%s%*%t(C))%*%(C%*%mu-delta_0)
+  c<-( (n-1)*k )/(n-k)
+  F0<-(1/c)*T2
+  F_tabla=qf(1-alfa,df1,df2)
+  valor_p=1-pf(F0,df1,df2)
+  resultados=data.frame(T2=T2,c=c,F0=F0,df1=df1,df2=df2,
+                  F_Tabla=F_tabla,Valor_p=valor_p)
+  cat("El vector mu0 es:", delta_0 )
+  format(resultados, digits = 6)
+}
+
+## Función Creada para la PH de: CU=mu_0,  n-Grande
+HT2_CU_ngrande=function(x,C,delta_0,alfa){
+  mu=as.vector(apply(x,2,mean));s=var(x)
+  n=nrow(x);p=ncol(x)
+  k<-nrow(C)
+  df1=k
+  chi2<-n*t(C%*%mu-delta_0)%*%solve(C%*%s%*%t(C))%*%(C%*%mu-delta_0)
+  chi_tabla=qchisq(1-alfa,df1)
+  valor_p=1-pchisq(chi2,df1)
+  resultados=data.frame(Chi2=chi2,df1=df1,
+                  Chi_Tabla=chi_tabla,Valor_p=valor_p)
+  cat("El vector mu0 es:", delta_0 )
+  format(resultados, digits = 6)
+}
+
+
+## Función para la PH de Razón de Ver. una Matriz de Var-Cov: ie.
+## Sigma=Sigma_0, n-grande
+sigma_sigma0_ngrande=function(x,Sigma_0,alfa){
+  x=as.matrix(x)
+  Sigma=as.matrix(Sigma_0)
+  p=ncol(x);n=nrow(x)
+  S=var(x)
+  ## Construcción del Estadístico de Prueba
+  mesa=S%*%solve(Sigma_0)
+  lamda_est= n*sum( diag(mesa) ) - n*log( det(S) ) +
+    n*log( det(Sigma_0) ) - n*p
+  #c<-1- (1/(6*(n-1)) )*(2*p+1-(2/(p+1)))
+  #ctest<-c*test
+  df=0.5*p*(p+1)    ## grados de libertad de la chi-2
+  chi_tabla=qchisq(1-alfa,df)
+  valor_p=1-pchisq(lamda_est,df)
+  result=data.frame(Landa_est = lamda_est,df=df,
+              Chi_Tabla=chi_tabla,Valor_P=valor_p)
+  format(result, digits = 6)
+}
+
+
+## Función para la PH de Razón de Ver. una Matriz de Var-Cov: ie.
+## Sigma=Sigma_0, n-pequeña
+sigma_sigma0_npqna=function(x,Sigma_0,alfa){
+  x=as.matrix(x)
+  Sigma=as.matrix(Sigma_0)
+  p=ncol(x);n=nrow(x)
+  S=var(x)
+  ## Construcción del Estadístico de Prueba
+  mesa=S%*%solve(Sigma_0)
+  lamda_est= n*sum( diag(mesa) ) - n*log( det(S) ) +
+    n*log( det(Sigma_0) ) - n*p
+  c<-1- ( 1/( 6*(n-1) ) )*( 2*p+1-( 2/(p+1) ) )
+  lamda_1_est<-c*lamda_est
+  df=0.5*p*(p+1)
+  chi_tabla=qchisq(1-alfa,df)
+  valor_p=1-pchisq(lamda_1_est,df)
+  result=data.frame(Lamda1_est=lamda_1_est,c=c, df=df,
+              Chi_Tabla=chi_tabla,Valor_P=valor_p)
+  format(result, digits = 5)
+}
+
+
+#Funcion generadora de elementos ui #nuevo
+generateInfo <- function() {
+  tagList(
+    img(src = 'escudo2.png', height = 250, width = 'auto', style = "display: block; margin-left: auto; margin-right: auto;"),
+    tags$p('Raul Perez'),
+    tags$p('Freddy Hernandez'),
+    tags$p('Juan Vanegas'),
+    tags$p('Universidad Nacional de Colombia sede Medellin')
+  )
+}
+
+
+
+

funcionesR/paquetes.R

@@ -0,0 +1,39 @@
+
+
+if(!require(pacman)) install.packages("pacman");
+
+pacman::p_load(
+  pacman,
+  flexdashboard,
+  rio,             # importación/exportación de datos
+  here,            # localizar archivos
+  tidyverse,       # gestión y visualización de datos
+  flexdashboard,   # versiones dashboard de informes R Markdown
+  shiny,           # figuras interactivas
+  plotly,           # figuras interactivas
+  knitr,
+  HH,
+  car,
+  rgl,
+  sampling,
+  ggplo2,
+  kableExtra,
+  FactoMineR,    ### Fucntion: PCA(x,x,x,x)
+  ade4,          ### Function: dudi.pca(x,x,x,x)
+  stats,         ### FUNCTIONS: prcomp and princomp
+  factoextra,    ### Extract and Visualize the Results of
+  ### Multivariate Data Analyse
+  gridExtra,
+  corrplot,
+  DT,
+  verbatim,
+  ade4
+)
+
+
+if (!require('devtools')) install.packages('devtools')
+devtools::install_github('fhernanb/stests', force=TRUE)
+
+
+
+