Upload 3 files

global.R

@@ -0,0 +1,102 @@
+
+
+if(!require(pacman)) install.packages("pacman");
+
+#library(shiny)
+#library(shinythemes)
+#library(car)
+#library(leaps)
+# library(tidyverse)
+# library(magrittr)
+# library(MVN)
+# library(MASS)
+# library(mvtnorm)
+
+pacman::p_load(
+  pacman,
+  shiny,
+  shinythemes,
+  leaps,
+  tidyverse,       # gestión y visualización de datos
+  magrittr,
+  ### para NM
+  MVN,
+  MASS,
+  mvtnorm,
+  mvnormtest,
+  clusterGeneration,
+
+  flexdashboard,
+  ### para lectura de datos
+  rio,             # importación/exportación de datos
+  here,            # localizar archivos
+  readxl,
+
+  flexdashboard,   # versiones dashboard de informes R Markdown
+
+  plotly,           # figuras interactivas
+
+  knitr,
+  HH,
+  car,
+  rgl,
+  sampling,
+  ### para ACP
+  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,
+  latex2exp,
+  ### para pruebas varias
+  rrcov,
+  ICSNP,
+  ppcc,
+  ICS,
+
+  bslib,
+  goftest,
+  robustbase,
+  mixtools,
+  ergm,
+  biotools,
+  gtsummary,
+  tools,
+  xfun
+
+)
+
+# library(clusterGeneration)
+# library(DT)
+# library(latex2exp)
+
+# library(rrcov)
+# library(ICSNP)
+# library(ppcc)
+# library(ICS)
+#library(mvnormtest)
+
+#library(readxl)
+
+# library(bslib)
+# library(goftest)
+# library(robustbase)
+# library(mixtools)
+# library(ergm)
+
+
+source("funcionesR/funciones.R")
+#source("modulos/sfasdf.R")
+
+#source("funcionesR/paquetes.R")
+
+if (!require('devtools')) install.packages('devtools')
+devtools::install_github('fhernanb/stests', force=TRUE)
+
+
+
+library(stests)

server.R

@@ -0,0 +1,1352 @@
+
+server <- function(input, output, session) {
+
+  ### CREACION DE FUNCIONES REACTIVAS  ###
+  {
+    dataM <- reactive({
+
+      if(input$dataInput==1){
+
+        inFile <- input$archivo   ## Load example data.
+
+        if(is.null(inFile)) {
+          # Generación de datos de muestra
+          p <- sample(2:10,1)
+          mu=c(rep(0,p) )
+          sigma<-round(genPositiveDefMat("eigen",dim=p)$Sigma  , 4)
+          dt <- round(mvrnorm(n=100, mu,sigma),4)
+          dt <- as.data.frame(dt)
+          colnames(dt) <- paste("X",1:ncol(dt),sep = "")
+        }  else { ## Descargar Datos.
+          dt <- read.csv(inFile$datapath,
+                         header=input$header,
+                         sep=input$sep,
+                         quote=input$quote)
+
+          DT::datatable(dt)
+        }
+        return(dt)
+
+      } else
+
+        {
+        inFile <- input$upload
+
+        # mySep <- switch(input$fileSepDF,
+        #                 '1'=",",
+        #                 '2'="\t",
+        #                 '3'=";",
+        #                 '4'=" "
+        # )
+
+        if (is.null(input$upload)){
+          return(NULL)
+        }
+        if (file.info(inFile$datapath)$size <= 20485800){
+          # data <- read.table(inFile$datapath,
+          #                    sep = mySep,
+          #                    header = input$myHead,
+          #                    fill = TRUE,
+          #                    dec = ifelse(input$decimal,
+          #                                 "," , ".")
+          # )
+
+          data <- rio::import(here::here(inFile$datapath))
+
+        } else print("El Tamaño del Archivo es
+                             mayor a 10 MB y no se Puede
+                             Descargado.")
+          }
+
+      return(data)
+
+    })
+
+
+    # Funciones reactivas para Variables
+    variables <- reactive({
+
+      return(input$variables)
+    })
+
+    # Funciones reactivas para las Variables seleccionadas
+    rt <- reactive({
+
+      tmp <- dataM() %>%
+        dplyr::select(input$variables)
+      return(tmp)
+    })
+
+  }
+
+  ###  FIN DE FUNCIONES REACTIVAS ###
+
+  ####  CREACION DE FUNCIONES DE OBSERVACIÓN ####
+
+  {
+
+    # Selecting the category for responseVar.
+
+    observe({
+      data_tmp <- dataM()
+      if(!is.null(data_tmp)){
+        updateSelectizeInput(session = session,
+                          inputId = "variables",
+                          choices = colnames(data_tmp),
+                          selected = data_tmp)
+      } else {
+        updateSelectizeInput(session = session,
+                          inputId = "variables",
+                          choices = "",
+                          selected = "")
+      }
+    })
+
+  }
+
+  ######  CREACION DE FUNCIONES DE OBSERVACIÓN	#######
+
+  ####  CREACIÓN DE LAS DEFINICIONES DE LAS SALIDAS DE DATOS ####
+
+  ####  CREACIÓN DE LAS DEFINICIONES DE LAS SALIDAS DE DATOS ####
+  {
+    output$tabla1 <- renderDataTable({
+      if(input$tabs1 == "Datos"){
+        DT::datatable(dataM(),
+                      #rownames=FALSE,
+                      #filter = "top",
+                      options = list(
+                        pageLength = 5,
+                        lengthMenu = c(5,10,15,20,25,-1) )
+        )
+      }
+    }
+    )
+
+  }
+
+  {
+    output$tabla2 <- renderDataTable({
+
+      if(input$tabs1 == "Datos"){
+        DT::datatable(rt(),
+                      #rownames=FALSE,
+                      #filter = "top",
+                      options = list(
+                        pageLength = 5,
+                        lengthMenu = c(5,10,15,20,25,-1) )
+        )
+      }
+    }
+    )
+
+  }
+
+
+#### Dos Poblaciones
+
+  ### CREACION DE FUNCIONES REACTIVAS  ###
+  {
+    dataMa <- reactive({
+      #    dataMa <- reactive({  ## Data input.
+      if(input$dataInputa==1){  ## Load example data.
+
+        inFilea <- input$archivo
+        if(is.null(inFilea)) {
+          # Generación de datos de muestra
+          p <- sample(4:10,1)
+          mu=c(rep(0,p) )
+          sigma<-round(genPositiveDefMat("eigen",dim=p)$Sigma  , 4)
+          dta <- round(mvrnorm(n=100, mu,sigma),4)
+          dta <- as.data.frame(dta)
+          colnames(dta) <- paste("X",1:ncol(dta),sep = "")
+          dta <- mutate(dta,
+                       Grupos=as.factor(c(rep(1,nrow(dta)/2),
+                                          rep(2,nrow(dta)/2)) ) )
+        }  else { ## Descargar Datos.
+          dta <- read.csv(inFilea$datapath,
+                         header=input$header,
+                         sep=input$sep,
+                         quote=input$quote)
+
+          DT::datatable(dta)
+        }
+        return(dta)
+
+      } else {  ## Cargar Datos
+        inFilea <- input$uploada
+        mySepa <- switch(input$fileSepDFa,
+                        '1'=",",
+                        '2'="\t",
+                        '3'=";",
+                        '4'=""
+        )
+        if (is.null(input$uploada)){
+          return(NULL)
+        }
+        if (file.info(inFilea$datapath)$size <= 20485800){
+          # dataa <- read.table(inFilea$datapath,
+          #                    sep = mySepa,
+          #                    header = input$myHeada,
+          #                    fill = TRUE,
+          #                    dec = ifelse(input$decimal,
+          #                                 "," , "."
+          #                    )
+          # )
+
+          dataa <- rio::import(here::here(inFilea$datapath))
+
+        } else print("El Tamaño del Archivo es
+                             mayor a 10 MB y no se Puede
+                             Descargado.")
+      }
+      return(dataa)
+    })
+
+
+    # Funciones reactivas para Variables
+    variables1a <- reactive({
+      return(input$variables1a)
+    })
+
+    # Funciones reactivas para las Variables seleccionadas
+    #        rt2a <- reactive({
+    #            tmp <- rt2a() %>%
+    #                dplyr::select(input$variables1)
+    #            return(tmp)
+    #        })
+
+    # Funciones reactivas para Variables
+    variables2a <- reactive({
+      return(input$variables2a)
+    })
+
+    # Funciones reactivas para las Variables seleccionadas
+    #       rt3a <- reactive({
+    #           tmp <- rt3a() %>%
+    #               dplyr::select(input$variables2)
+    #           return(tmp)
+    #       })
+
+    # Funciones reactivas para las Variables seleccionadas
+    # Funciones reactivas para las Variables seleccionadas
+    rt2a <- reactive({
+      tmp2a <- dataMa() %>%  dplyr::filter(Grupos=="1") %>%
+        dplyr::select(input$variables1a)
+      #dplyr::select(input$pob1)
+      return(tmp2a)
+    })
+
+    # Funciones reactivas para las Variables seleccionadas
+    rt3a <- reactive({
+      tmp3a <- dataMa() %>% dplyr::filter(Grupos=="2") %>%
+        dplyr::select(input$variables2a)
+      # dplyr::select(input$pob2)
+      return(tmp3a)
+    })
+
+  }
+
+  ###  FIN DE FUNCIONES REACTIVAS ###
+
+  ####  CREACION DE FUNCIONES DE OBSERVACIÓN ####
+
+  {
+
+    # Selecting the category for responseVar.
+
+    observe({
+      data_tmpa <- dataMa()
+      if(!is.null(data_tmpa)){
+        updateSelectInput(session = session,
+                          inputId = "variables1a",
+                          choices = colnames(data_tmpa),
+                          selected = data_tmpa)
+      } else {
+        updateSelectInput(session = session,
+                          inputId = "variables1a",
+                          choices = "",
+                          selected = "")
+      }
+    })
+
+    observe({
+      data_tmpa <- dataMa()
+      if(!is.null(data_tmpa)){
+        updateSelectInput(session = session,
+                          inputId = "variables2a",
+                          choices = colnames(data_tmpa),
+                          selected = data_tmpa)
+      } else {
+        updateSelectInput(session = session,
+                          inputId = "variables2a",
+                          choices = "",
+                          selected = "")
+      }
+    })
+
+
+  }
+
+
+  {
+    observeEvent(input$sobre_datos_2Pob, {
+    showModal(
+      modalDialog("",
+                #tagList(
+              tags$p("Para el caso de dos poblaciones se carga un
+                     solo archivo de datos, el cual debe traer
+                     una columna de nombre: ",
+              tags$b( tags$em("Grupos,") )  ,
+              "cuyos valores se etiquetan con los
+                     números 1 y 2." )
+                #)
+          )
+    )
+  }
+  )
+  }
+
+
+  {
+    observeEvent(input$sobre_datos_muestra, {
+      showModal(
+        modalDialog("",
+                    #tagList(
+                    tags$p("Los ",
+                     tags$b( tags$em("Datos de Ejemplos,") )  ,
+                     "se refiere a un conjunto de datos normales
+                      p-variados (con p entre 2 y 10) que se generan
+                      cada vez que ejecutas la aplicación con los
+                      cuales puedes probar la App.
+                      Igualmente puedes cargar tus propios datos
+                      mediante la opción: Cargar Datos.
+                     " )
+                    #)
+        )
+      )
+    }
+    )
+  }
+
+
+
+  ######  CREACION DE FUNCIONES DE OBSERVACIÓN	#######
+
+  ####  CREACIÓN DE LAS DEFINICIONES DE LAS SALIDAS DE DATOS ####
+
+  ####  CREACIÓN DE LAS DEFINICIONES DE LAS SALIDAS DE DATOS ####
+  {
+    output$tabla1a <- renderDataTable({
+      if(input$tabs2 == "Datos:"){
+        DT::datatable(dataMa(),
+                      #rownames=FALSE,
+                      #filter = "top",
+                      options = list(
+                        pageLength = 5,
+                        lengthMenu = c(5,10,15,20,25,-1) )
+        )
+      }
+    }
+    )
+
+  }
+
+
+  {
+    output$tabla2a <- renderDataTable({
+      if(input$tabs2 == "Datos:"){
+        DT::datatable(rt2a(),
+                      #rownames=FALSE,
+                      #filter = "top",
+                      options = list(
+                        pageLength = 5,
+                        lengthMenu = c(5,10,15,20,25,-1) )
+        )
+      }
+    }
+    )
+
+  }
+
+
+  {
+    output$tabla3a <- renderDataTable({
+      if(input$tabs2 == "Datos:"){
+        DT::datatable(rt3a(),
+                      #rownames=FALSE,
+                      #filter = "top",
+                      options = list(
+                        pageLength = 5,
+                        lengthMenu = c(5,10,15,20,25,-1) )
+        )
+      }
+    }
+    )
+
+  }
+
+
+  ##### Datos para PH mu1_=mu0
+
+
+
+  ####  FIN CREACIÓN DE LAS DEFINICIONES DE LAS SALIDAS DE DATOS ####
+
+  #### INICIO DE LAS SALIDAS DE RESULTADOS ####
+
+
+  ### TDODO SOBRE PRUEBAS DE NORMALIDAD
+
+  ## --------------------------------------------------
+  ## ------ Seleccion de PH_NU-Usando-R: --------------
+
+  prueba_nu <- reactive({
+
+    dt <-  rt()
+
+    if(input$PH_NU_Seleccionada == 1){
+
+      prueba <- mvn(dt,univariateTest=c("SW") )
+
+    }
+    else
+      if(input$PH_NU_Seleccionada ==2){
+
+        prueba <- mvn(dt,univariateTest=c("CVM") )
+      }
+    else
+      if(input$PH_NU_Seleccionada ==3){
+
+        prueba <- mvn(dt,univariateTest=c("Lillie") )
+      }
+    else
+      if(input$PH_NU_Seleccionada ==4){
+
+        prueba <- mvn(dt,univariateTest=c("SF") )
+      }
+    else
+      if(input$PH_NU_Seleccionada ==5){
+
+        prueba <- mvn(dt,univariateTest=c("AD") )
+      }
+
+    prueba$univariateNormality
+
+  })
+
+  output$Res_NU <- renderTable({
+    prueba_nu()
+  }, align='c', bordered = TRUE)
+
+
+
+  ## ------------------------------------------------------------
+  ## --- Resultados de la PH_NU Seleccionada Usando-R: ----------
+
+  output$resultados_PH_NU <- renderText({
+
+    if(input$PH_NU_Seleccionada ==1){
+      mensaje='- Los Resultados de la Prueba de Shapiro-Wilk son:'
+    }
+    else
+      if(input$PH_NU_Seleccionada ==2){
+        mensaje='- Los Resultados de la Prueba de
+                            Cramer-von Mises son:'
+      }
+    else
+      if(input$PH_NU_Seleccionada ==3){
+        mensaje='- Los Resultados de la Prueba de
+                            Lilliefors son:'
+      }
+    else
+      if(input$PH_NU_Seleccionada ==4){
+        mensaje='- Los Resultados de la Prueba de
+                            Shapiro-Francia  son:'
+      }
+    else
+      if(input$PH_NU_Seleccionada ==5){
+        mensaje='- Los Resultados de la Prueba de
+                            Anderson-Darling   son:'
+      }
+
+    mensaje
+
+  })
+
+
+  ## --------------------------------------------------------------------
+  ## ------ Seleccion de Gráficos Univariados en la PH_NU-Usando-R: -----
+
+  graficos_nu <- reactive({
+
+    dt <-  rt()
+
+    if(input$Grafico_Seleccionado ==1){
+
+      prueba <- mvn(dt,multivariatePlot=c("qq") ) #cambio
+
+    }
+    else
+      if(input$Grafico_Seleccionado ==2){
+
+        prueba <- mvn(dt,univariatePlot=c("histogram") )
+      }
+    else
+      if(input$Grafico_Seleccionado ==3){
+
+        prueba <- mvn(dt,univariatePlot=c("box") )
+      }
+    else
+      if(input$Grafico_Seleccionado ==4){
+
+        prueba <- mvn(dt,univariatePlot=c("scatter") )
+      }
+
+    prueba$univariatePlot
+
+  })
+
+
+  output$Graf_NU <- renderPlot({
+    graficos_nu()
+  })
+
+
+  ## ------------------------------------------------------------
+  ## --- Resultados de la PH_NM Seleccionada Usando-R: ----------
+
+
+  output$resultados_PH_NM <- renderText({
+
+    if(input$PH_NM_Seleccionada ==1){
+      mensaje='- Los Resultados de la Prueba de Mardia son:'
+    }
+    else
+      if(input$PH_NM_Seleccionada ==2){
+        mensaje='- Los Resultados de la Prueba de
+                            Henze-Zirkler son:'
+      }
+    else
+      if(input$PH_NM_Seleccionada ==3){
+        mensaje='- Los Resultados de la Prueba de
+                            Royston son:'
+      }
+    else
+      if(input$PH_NM_Seleccionada ==4){
+        mensaje='- Los Resultados de la Prueba de
+                            Doornik-Hansen son:'
+      }
+    # else
+    #   if(input$PH_NM_Seleccionada ==5){
+    #     mensaje='- Los Resultados de la Prueba de
+    #                         Shapiro-Wilk- son:'
+    #   }
+
+
+    mensaje
+
+  })
+
+  ## --------------------------------------------------
+  ## ------ Seleccion de PH_NM-Usando-R: --------------
+
+  prueba_nm_mvn <- reactive({
+
+    dt <-  rt()
+
+    if(input$PH_NM_Seleccionada == 1){
+
+      prueba <- mvn(dt,mvnTest=c("mardia") )
+
+    }
+    else
+      if(input$PH_NM_Seleccionada ==2){
+
+        prueba <- mvn(dt,mvnTest=c("hz") )
+      }
+    else
+      if(input$PH_NM_Seleccionada ==3){
+
+        prueba <- mvn(dt,mvnTest=c("royston") )
+      }
+    else
+      if(input$PH_NM_Seleccionada ==4){
+
+        prueba <- mvn(dt,mvnTest=c("dh") )
+      }
+    # else
+    #   if(input$PH_NM_Seleccionada ==5){
+    #
+    #     prueba <- mshapiro.test(t(dt))
+    #   }
+
+    prueba$multivariateNormality
+
+  })
+
+
+  output$Res_NM <- renderTable({
+    prueba_nm_mvn()
+  }, align='c', bordered = TRUE)
+
+
+  # ### PNM-Shapiro-Wilk
+  #
+  # prueba_sw_mvn <- reactive({
+  #   dt <-  rt()
+  #   if(input$PH_NM_Seleccionada == 5){
+  #     prueba <- mshapiro.test(t(dt))
+  #   }
+  #   else{
+  #     prueba$multivariateNormality
+  #   }
+  #   prueba
+  # })
+  #
+  #
+  # output$Res_NM_SW <- renderPrint({
+  #   prueba_sw_mvn()
+  # })
+
+
+  ## ----------------------------------------------------------------------
+  ## ------ Seleccion de Gráficos Multivariados en la PH_NM-Usando-R: -----
+
+
+  graficos_nm <- reactive({
+
+    dt <-  rt()
+
+    #    dt <-  dataM()
+
+    if(input$Grafico_Multi_Seleccionado ==1){
+
+      prueba <- mvn(dt,multivariatePlot=c("qq"),
+                    multivariateOutlierMethod="quan",
+                    showOutliers=TRUE )
+
+    }
+    else
+      if(input$Grafico_Multi_Seleccionado ==2){
+
+        prueba <- mvn(dt,multivariatePlot=c("persp") )
+
+        #        prueba2 <- representa1c_np(dataM()[,1:2],input$alfa)
+      }
+    else
+      if(input$Grafico_Multi_Seleccionado ==3){
+
+        prueba <- mvn(dt,multivariatePlot=c("contour") )
+      }
+
+    prueba$multivariatePlot
+    #    prueba2
+
+  })
+
+
+  output$Graf_NM <- renderPlot({
+    graficos_nm()
+  })
+
+
+
+
+  ## ------------------------------------------------------------
+  ## --- Resumen Descriptivo de los Datos Utilizados ------------
+
+  output$PH_RD <- renderTable({
+    dt <-  rt()
+    res<-mvn(dt,mvnTest=c("mardia") )
+    res$Descriptive
+  }, align='c', bordered = TRUE)
+
+
+  ### Mas resúmenes Descriptivos
+
+  output$Res_Descriptivos_Varios <- renderTable({
+    dt <-  rt()
+    coef_asim <- apply(dt,2,asimetria)
+    coef_kurt <-  apply(dt,2,kurtosis)
+    Res_Des <- data.frame(Asimetría=coef_asim,Kurtosis=coef_kurt)
+    Res_Des
+  })
+
+
+  ## ----------------------------------------------------------------------
+  ## ------ Seleccion de Otros-Gráficos Varios -----
+
+
+  graficos_elipses <- reactive({
+
+    dt <-  rt()
+
+    if(input$Graficos_Varios ==1){
+
+      grafico <- representa(dt)
+
+    }
+    else
+      if(input$Graficos_Varios ==2){
+
+        grafico <- representa1c_np(dt,0.05)
+
+      }
+    else
+      if(input$Graficos_Varios ==3){
+
+        grafico <- representa1c_ng(dt,0.05)
+      }
+    else
+      if(input$Graficos_Varios ==4){
+
+        grafico <- representa2c_np(dt,0.01,0.05)
+      }
+    else
+      if(input$Graficos_Varios ==5){
+
+        grafico <- representa2c_ng(dt,0.01,0.05)
+      }
+    else
+      if(input$Graficos_Varios ==6){
+
+        grafico <- superficie_NB(apply(dt,2,mean),var( dt ) )
+      }
+    else
+      if(input$Graficos_Varios ==7){
+
+        grafico <- contorno_NB(apply(dt,2,mean),var( dt ) )
+      }
+    else
+      if(input$Graficos_Varios ==8){
+
+        grafico <- elipse_conf(dt,0.05,1000)
+      }
+    else
+      if(input$Graficos_Varios ==9){
+
+        grafico <- elipse_conf_IC_T2(dt,0.05,1000)
+      }
+    else
+      if(input$Graficos_Varios ==10){
+
+        grafico <- elipse_conf_IC_BONF(dt,0.05,1000)
+      }
+    else
+      if(input$Graficos_Varios ==11){
+
+        grafico <- elipse_conf_IC_tstud(dt,0.05,1000)
+      }
+
+    grafico
+    #    prueba2
+
+  })
+
+
+  output$elipses <- renderPlot({
+    graficos_elipses()
+  })
+
+
+  ### TDODO SOBRE PRUEBAS DE HIPÓSTESIS: H : mu=mu_0
+
+  ## ------------------------------------------------------------
+  ## --- PH_MU_0-Usando Función de Usuario: HT2_mu0(...) --------
+
+  # PH : mu_0 con función de Usuario
+
+  output$PH_mu0 <- renderTable({
+    mu_0 <- as.numeric(unlist(strsplit(input$mu0,",")))
+    dt <-  rt()
+    res3 <- HT2_mu0(dt,mu_0,input$alfa)
+    res3
+  }, align='c', bordered = TRUE)
+
+
+  ## ------------------------------------------------------------------------
+  ## -- Conclusiones de la PH_MU_0-Usando Función de Usuario: HT2_mu0(...) --
+
+  output$conclus2 <- renderText({
+    mu_0 <- as.numeric(unlist(strsplit(input$mu0,",")))
+    dt <-  rt()
+    res5 <- HT2_mu0(dt,mu_0,input$alfa)
+
+    ifelse(as.numeric(res5[7]) < input$alfa ,
+           paste(strong('Como p = '), res5[7]  , ' < ' ,
+                 input$alfa , withMathJax(' = \\( \\alpha \\); ') , strong('entonces,
+               se rechaza H0') , sep="") ,
+           paste('Como p = ' , res5[7] ,
+                 ' > ' , input$alfa ,  withMathJax(' = \\( \\alpha \\) ; '),
+                 strong('entonces, No se rechaza H0')
+           ))
+  })
+
+
+  ## -----------------------------------------------------
+  ## ---------- Selección de la PH_MU_0-Usando-R ---------
+
+  prueba_mu0r <- reactive({
+
+    mu_0 <- as.numeric(unlist(strsplit(input$mu0,",")))
+
+    dt <-  rt()
+
+    if(input$PruebaAnalitica == 1){
+
+      prueba <- T2.test(dt, mu = mu_0 , conf.level = 1-input$alfa)
+
+    }
+    else
+      if(input$PruebaAnalitica ==2){
+
+        prueba <- HotellingsT2(dt,mu=mu_0,test="f")
+
+      }
+
+    prueba
+
+  })
+
+  output$Res_MU0r <- renderPrint({
+    prueba_mu0r()
+  })
+
+
+  ## -----------------------------------------------------------
+  ## --- PH_MU_0_N_Grande-Usando Función de Usuario:
+  ## ---  HT2_mu0_ngrande(...) --------
+
+  # PH : mu_0 con función de Usuario
+
+  output$PH_mu0_ng <- renderTable({
+    mu_0 <- as.numeric(unlist(strsplit(input$mu0,",")))
+    dt <- rt()
+    res6 <- HT2_mu0_ngrande(dt,mu_0,input$alfa)
+    res6
+  }, align='c', bordered = TRUE)
+
+
+  ## ----------------------------------------------------------------
+  ## -- Conclusiones de la PH_MU_0_N_Grande-Usando Función de Usuario:
+  ## -- HT2_mu0_ngrande(...) --
+
+  output$conclus2_mu0_ng <- renderText({
+
+    mu_0 <- as.numeric(unlist(strsplit(input$mu0,",")))
+
+    dt <-  rt()
+
+    res8 <- HT2_mu0_ngrande(dt,mu_0,input$alfa)
+
+    ifelse(as.numeric(res8[4]) < input$alfa ,
+           paste(strong('Como p = '), res8[4]  , ' < ' ,
+                 input$alfa , withMathJax(' = \\( \\alpha \\) ; ') , strong('entonces,
+               se rechaza H0') , sep="") ,
+           paste('Como p = ' , res8[4] ,
+                 ' > ' , input$alfa ,  withMathJax(' = \\( \\alpha \\) ; '),
+                 strong('entonces,
+               No se rechaza H0')  ))
+  })
+
+
+
+  ## --------------------------------------------------------------
+  ## ---------- Selección de la PH_MU_0_N_Grande Usando-R ---------
+
+  prueba_mu0r_ng <- reactive({
+
+    mu_0 <- as.numeric(unlist(strsplit(input$mu0,",")))
+
+    dt <-  rt()
+
+    if(input$PruebaAnalitica_ng ==1)
+
+      prueba <- HotellingsT2(dt,mu=mu_0,test="chi")
+
+    prueba
+
+  })
+
+  output$Res_MU0r_ng <- renderPrint({
+    prueba_mu0r_ng()
+  })
+
+
+
+  ############# H_0 : sigma=sigma_0
+
+  output$mat_var_cov <- renderTable({
+    dt <-  rt()
+       s <- var(rt())
+
+         round(s,4)
+  })
+
+  output$mat_var_cov_sigma0 <- renderTable({
+    dt <-  rt()
+    sigma00 <- as.numeric(unlist(strsplit(input$sigma0,",")))
+
+    sigma_0 <- matrix(c(sigma00), nrow=ncol(rt()),
+                      ncol=ncol(rt()),byrow=TRUE)
+
+    sigma_0
+    })
+
+
+  ## ------------------------------------------------------------
+  ## --- PH_Sigma=Sigma_0-Usando Función de Usuario:
+  ##     sigma_sigma0_npqna(...) --------
+
+  # PH : mu_0 con función de Usuario
+
+  output$PH_Sigma0 <- renderTable({
+    dt <-  rt()
+#    mu_0 <- as.numeric(unlist(strsplit(input$mu0,",")))
+
+    sigma00 <- as.numeric(unlist(strsplit(input$sigma0,",")))
+
+    sigma_0 <- matrix(c(sigma00), nrow=ncol(rt()),
+                        ncol=ncol(rt()),byrow=TRUE)
+    #dt <-  rt()
+    res <- sigma_sigma0_npqna(dt,sigma_0,input$alfa_sigma)
+    res
+  }, align='c', bordered = TRUE)
+
+
+  ## ------------------------------------------------------------------------
+  ## -- Conclusiones de la PH_Sigma=Sigma_0-Usando Función de Usuario:
+  ##     sigma_sigma0_npqna(...) --------
+
+  output$conclus_sigma0 <- renderText({
+    dt <-  rt()
+    #    mu_0 <- as.numeric(unlist(strsplit(input$mu0,",")))
+
+    sigma00 <- as.numeric(unlist(strsplit(input$sigma0,",")))
+
+    sigma_0 <- matrix(c(sigma00), nrow=ncol(rt()),
+                      ncol=ncol(rt()),byrow=TRUE)
+    #dt <-  rt()
+    res <- sigma_sigma0_npqna(dt,sigma_0,input$alfa_sigma)
+    res
+
+    ifelse(as.numeric(res[5]) < input$alfa_sigma ,
+           paste(strong('Como p = '), res[5]  , ' < ' ,
+                 input$alfa_sigma , withMathJax(' = \\( \\alpha \\); ') , strong('entonces,
+               se rechaza H0') , sep="") ,
+           paste('Como p = ' , res[5] ,
+                 ' > ' , input$alfa_sigma ,  withMathJax(' = \\( \\alpha \\) ; '),
+                 strong('entonces, No se rechaza H0')
+           ))
+  })
+
+
+  ## ------------------------------------------------------------
+  ## --- PH_Sigma=Sigma_0-Usando Función de Usuario:
+  ##     sigma_sigma0_ngrande(...) --------
+
+  # PH : mu_0 con función de Usuario
+
+  output$PH_Sigma0_ng <- renderTable({
+    dt <-  rt()
+    #    mu_0 <- as.numeric(unlist(strsplit(input$mu0,",")))
+
+    sigma00 <- as.numeric(unlist(strsplit(input$sigma0,",")))
+
+    sigma_0 <- matrix(c(sigma00), nrow=ncol(rt()),
+                      ncol=ncol(rt()),byrow=TRUE)
+    #dt <-  rt()
+    res <- sigma_sigma0_ngrande(dt,sigma_0,input$alfa_sigma)
+    res
+  }, align='c', bordered = TRUE)
+
+
+  ## ------------------------------------------------------------------------
+  ## -- Conclusiones de la PH_Sigma=Sigma_0-Usando Función de Usuario:
+  ##     sigma_sigma0_ngrande(...) --------
+
+  output$conclus_sigma0_ng <- renderText({
+    dt <-  rt()
+    #    mu_0 <- as.numeric(unlist(strsplit(input$mu0,",")))
+
+    sigma00 <- as.numeric(unlist(strsplit(input$sigma0,",")))
+
+    sigma_0 <- matrix(c(sigma00), nrow=ncol(rt()),
+                      ncol=ncol(rt()),byrow=TRUE)
+    #dt <-  rt()
+    res <- sigma_sigma0_ngrande(dt,sigma_0,input$alfa_sigma)
+    res
+
+    ifelse(as.numeric(res[4]) < input$alfa_sigma ,
+           paste(strong('Como p = '), res[4]  , ' < ' ,
+                 input$alfa_sigma , withMathJax(' = \\( \\alpha \\); ') , strong('entonces,
+               se rechaza H0') , sep="") ,
+           paste('Como p = ' , res[4] ,
+                 ' > ' , input$alfa_sigma ,  withMathJax(' = \\( \\alpha \\) ; '),
+                 strong('entonces, No se rechaza H0')
+           ))
+  })
+
+
+######## Usando-R
+
+  ## -----------------------------------------------------
+  ## ---------- Selección de la PH: Sigma=sigma_0-Usando-R ---------
+
+  prueba_sigma0_r <- reactive({
+    dt <-  rt()
+
+    S <- matrix(var(dt),ncol=ncol(rt()) )
+
+    n <- nrow(dt)
+
+    sigma00 <- as.numeric(unlist(strsplit(input$sigma0,",")))
+
+    sigma_0 <- matrix(c(sigma00), nrow=ncol(rt()),
+                      ncol=ncol(rt()),byrow=TRUE)
+
+    if(input$Prueba_sigma == 1){
+
+      prueba <- one_covar_matrix_test(sigma_0, S, n, method = "lrt")
+
+    }
+    else
+      if(input$Prueba_sigma ==2){
+
+        prueba <- one_covar_matrix_test(sigma_0, S, n, method='modlrt1')
+
+      }
+    else
+      if(input$Prueba_sigma ==3){
+
+        prueba <- one_covar_matrix_test(sigma_0, S, n, method='modlrt2')
+
+      }
+
+
+    prueba
+
+  })
+
+  output$Res_sigma0r <- renderPrint({
+    prueba_sigma0_r()
+  })
+
+
+
+
+
+
+
+
+#### INICIO SALIDAS RESULTADOS DE: PH : mu_1=_mu_2
+
+####  FIN CREACIÓN DE LAS DEFINICIONES DE LAS SALIDAS DE DATOS ####
+
+    #### INICIO DE LAS SALIDAS DE RESULTADOS ####
+
+  ### TDODO SOBRE PRUEBAS DE HIPÓTESIS: H : mu_1=_mu_2
+
+  ## ------------------------------------------------------------
+  ## --- PH_MU1=MU2-Usando Función de Usuario: HT2_sigmas_iguales(...) --------
+
+  output$PH_mu1_mu2_FU <- renderTable({
+    mu_0 <- as.numeric(unlist(strsplit(input$mu0a,",")))
+    dt1 <-  rt2a()
+    dt2 <-  rt3a()
+    res3 <- HT2_sigmas_iguales(dt1,dt2,mu_0,input$alfaa)
+    res3
+  }, align='c', bordered = TRUE)
+
+
+  ## ------------------------------------------------------------------------
+  ## -- Conclusiones de la PH_MU1=MU2-Usando Función de Usuario: HT2_sigmas_iguales(...) --
+
+  output$conclus2a <- renderText({
+    mu_0 <- as.numeric(unlist(strsplit(input$mu0a,",")))
+    dt1 <-  rt2a()
+    dt2 <-  rt3a()
+    res5 <- HT2_sigmas_iguales(dt1,dt2,mu_0,input$alfaa)
+    ifelse(as.numeric(res5[7]) < input$alfaa ,
+           paste(strong('Como p = '), res5[7]  , ' < ' ,
+                 input$alfaa , withMathJax(' = \\( \\alpha \\); ') , strong('entonces,
+               se rechaza H0') , sep="") ,
+           paste('Como p = ' , res5[7] ,
+                 ' > ' , input$alfaa ,  withMathJax(' = \\( \\alpha \\) ; '),
+                 strong('entonces, No se rechaza H0')
+           ))
+  })
+
+
+  ## ------------------------------------------------------------
+  ## --- PH_MU1=MU2-Usando Función de Usuario: HT2_sigmas_diferentes(...) --------
+
+  output$PH_mu1_mu2_FU_sigmas_dif <- renderTable({
+    mu_0 <- as.numeric(unlist(strsplit(input$mu0a,",")))
+    dt1 <-  rt2a()
+    dt2 <-  rt3a()
+    res3 <- HT2_sigmas_diferentes(dt1,dt2,mu_0,input$alfaa)
+    res3
+  }, align='c', bordered = TRUE)
+
+
+  ## ------------------------------------------------------------------------
+  ## -- Conclusiones de la PH_MU_0-Usando Función de Usuario: HT2_sigmas_iguales(...) --
+
+  output$conclus4a <- renderText({
+    mu_0 <- as.numeric(unlist(strsplit(input$mu0a,",")))
+    dt1 <-  rt2a()
+    dt2 <-  rt3a()
+    res5 <- HT2_sigmas_diferentes(dt1,dt2,mu_0,input$alfaa)
+    ifelse(as.numeric(res5[8]) < input$alfaa ,
+           paste(strong('Como p = '), res5[8]  , ' < ' ,
+                 input$alfaa , withMathJax(' = \\( \\alpha \\); ') , strong('entonces,
+               se rechaza H0') , sep="") ,
+           paste('Como p = ' , res5[8] ,
+                 ' > ' , input$alfaa ,  withMathJax(' = \\( \\alpha \\) ; '),
+                 strong('entonces, No se rechaza H0')
+           ))
+  })
+
+
+
+
+  ## -----------------------------------------------------
+  ## ---------- Selección de la PH_MU1=MU2-Usando-R ---------
+
+  prueba_mu0r2 <- reactive({
+
+    mu_0 <- as.numeric(unlist(strsplit(input$mu0a,",")))
+
+    dt1 <-  rt2a()
+    dt2 <-  rt3a()
+
+    if(input$PruebaAnaliticaa == 1){
+
+      prueba <- T2.test(dt1, dt2, mu = mu_0 , conf.level = 1-input$alfaa)
+
+    }
+    else
+      if(input$PruebaAnaliticaa ==2){
+
+        prueba <- HotellingsT2(dt1,dt2,mu=mu_0,test="f")
+
+      }
+
+    prueba
+
+  })
+
+  output$Res_mu1_mu2_R <- renderPrint({
+    prueba_mu0r2()
+  })
+
+
+  ## ------------------------------------------------------------
+  ## --- PH_MU1=MU2-Usando Función de Usuario: HT2_sigmas_iguales_ngrande(...) --------
+
+  output$PH_mu1_mu2_FU_NG <- renderTable({
+    mu_0 <- as.numeric(unlist(strsplit(input$mu0a,",")))
+    dt1 <-  rt2a()
+    dt2 <-  rt3a()
+    res3 <- HT2_sigmas_iguales_ngrande(dt1,dt2,mu_0,input$alfaa)
+    res3
+  }, align='c', bordered = TRUE)
+
+
+  ## ------------------------------------------------------------------------
+  ## -- Conclusiones de la PH_MU_0-Usando Función de Usuario: HT2_sigmas_iguales_ngrande(...) --
+
+  output$conclus3a <- renderText({
+    mu_0 <- as.numeric(unlist(strsplit(input$mu0a,",")))
+    dt1 <-  rt2a()
+    dt2 <-  rt3a()
+    res5 <- HT2_sigmas_iguales_ngrande(dt1,dt2,mu_0,input$alfaa)
+    ifelse(as.numeric(res5[4]) < input$alfaa ,
+           paste(strong('Como p = '), res5[4]  , ' < ' ,
+                 input$alfaa , withMathJax(' = \\( \\alpha \\); ') , strong('entonces,
+               se rechaza H0') , sep="") ,
+           paste('Como p = ' , res5[4] ,
+                 ' > ' , input$alfaa ,  withMathJax(' = \\( \\alpha \\) ; '),
+                 strong('entonces, No se rechaza H0')
+           ))
+  })
+
+
+
+  ## -----------------------------------------------------
+  ## ---------- Selección de la PH_MU1_MU2-Usando-R-NG ---------
+
+  prueba_mu0r_ng2 <- reactive({
+
+    mu_0 <- as.numeric(unlist(strsplit(input$mu0a,",")))
+
+    dt1 <-  rt2a()
+    dt2 <-  rt3a()
+
+    if(input$PruebaAnalitica_nga == 1){
+
+      prueba <- HotellingsT2(dt1, dt2, mu = mu_0
+                             ,test="chi")
+
+    }
+    else
+      if(input$PruebaAnaliticaa ==2){
+
+        prueba <- HotellingsT2(dt1,dt2,mu=mu_0,test="chi")
+
+      }
+
+    prueba
+
+  })
+
+  output$Res_mu1_mu2_R_NG <- renderPrint({
+    prueba_mu0r_ng2()
+  })
+
+
+  ## ------------------------------------------------------------
+  ## --- PH_Mu1=Mu2-PAREADA, Usando Función de Usuario: HT2_pareadas(...) --------
+
+  output$PH_mu1_mu2_FU_MPareadas <- renderTable({
+    dt1 <-  rt2a()
+    dt2 <-  rt3a()
+    res <- HT2_pareadas(dt1,dt2,input$alfa1a)
+    res
+  }, align='c', bordered = TRUE)
+
+
+  ## ------------------------------------------------------------------------
+  ## -- Conclusiones de la PH_MU_0-Usando Función de Usuario: HT2_pareadas(...) --
+
+  output$conclus6a <- renderText({
+    dt1 <-  rt2a()
+    dt2 <-  rt3a()
+    res5 <- HT2_pareadas(dt1,dt2,input$alfa1a)
+
+    ifelse(as.numeric(res5[7]) < input$alfa1a ,
+           paste(strong('Como p = '), res5[7]  , ' < ' ,
+                 input$alfa1a , withMathJax(' = \\( \\alpha \\); ') , strong('entonces,
+               se rechaza H0') , sep="") ,
+           paste('Como p = ' , res5[7] ,
+                 ' > ' , input$alfa1a ,  withMathJax(' = \\( \\alpha \\) ; '),
+                 strong('entonces, No se rechaza H0')
+           ))
+  })
+
+  ## ------------------------------------------------------------
+  ## --- PH_Mu1=Mu2-Muestra Pareada Usando R (...) --------
+
+  ## -----------------------------------------------------
+  ## ---------- Selección de la PH para: sigma1=sigma2-Usando-R, M-Pareada ---------
+
+  prueba_mu0r92 <- reactive({
+    dt1 <-  rt2a()
+    dt2 <-  rt3a()
+
+    dt <- as.data.frame(rbind(dt1,dt2) )
+
+    Grupos <-  as.factor(
+      c( rep(1,nrow(dt1)) , rep(2,nrow(dt2) ) ) )
+
+    #    dt <- as.matrix(dt)
+
+    if(input$Prueba_mp == 1){
+
+      prueba <- ergm::approx.hotelling.diff.test(dt1,dt2,
+                                                 assume.indep = FALSE,
+                                                 var.equal = FALSE)
+
+    }
+    else
+      if(input$Prueba_mp == 2){
+
+        prueba <- ergm::approx.hotelling.diff.test(dt1,dt2,
+                                                   assume.indep = FALSE,
+                                                   var.equal = FALSE)
+
+      }
+
+    prueba
+
+  })
+
+  output$Res_mu1_mu2_R_MPareadas <- renderPrint({
+    prueba_mu0r92()
+  })
+
+
+  ## ------------------------------------------------------------
+  ## --- PH_sigma1=sigma2-Usando Función de Usuario: prueba_M_Box2(...) --------
+
+  output$PH_sigma1_sigma2_FU <- renderTable({
+    #    mu_0 <- as.numeric(unlist(strsplit(input$mu0,",")))
+    dt1 <-  rt2a()
+    dt2 <-  rt3a()
+    res <- prueba_M_Box2(dt1,dt2,input$alfa2a)
+    res
+  }, align='c', bordered = TRUE)
+
+
+  ## ------------------------------------------------------------------------
+  ## -- Conclusiones de la PH_sigma1=sigma2-Usando Función de Usuario: prueba_M_Box2(...) --
+
+  output$conclus8a <- renderText({
+    dt1 <-  rt2a()
+    dt2 <-  rt3a()
+    res5 <- prueba_M_Box2(dt1,dt2,input$alfa2a)
+    ifelse(as.numeric(res5[6]) < input$alfa2a ,
+           paste(strong('Como p = '), res5[6]  , ' < ' ,
+                 input$alfa2a , withMathJax(' = \\( \\alpha \\); ') , strong('entonces,
+               se rechaza H0') , sep="") ,
+           paste('Como p = ' , res5[6] ,
+                 ' > ' , input$alfa2a ,  withMathJax(' = \\( \\alpha \\) ; '),
+                 strong('entonces, No se rechaza H0')
+           ))
+  })
+
+
+  ## -----------------------------------------------------
+  ## ---------- Selección de la PH para: sigma1=sigma2-Usando-R ---------
+
+  prueba_mu0r82 <- reactive({
+    dt1 <-  rt2a()
+    dt2 <-  rt3a()
+
+    dt <- as.data.frame(rbind(dt1,dt2) )
+
+    Grupos <-  as.factor(
+      c( rep(1,nrow(dt1)) , rep(2,nrow(dt2) ) ) )
+
+    #    dt <- as.matrix(dt)
+
+    if(input$Prueba_box == 1){
+
+      prueba <- biotools::boxM(dt,Grupos)
+
+    }
+    else
+      if(input$Prueba_box == 2){
+
+        prueba <- biotools::boxM(dt,Grupos)
+
+      }
+
+    prueba
+
+  })
+
+  output$Res_sigma1_sigma2_R <- renderPrint({
+    prueba_mu0r82()
+  })
+
+
+
+
+
+}
+
+
+

ui.R

@@ -0,0 +1,1155 @@
+
+# Define UI for application
+ui <- fluidPage(
+  
+  
+  tags$head(
+    tags$link(rel="stylesheet",
+              href="https://cdn.jsdelivr.net/npm/katex@0.10.1/dist/katex.min.css",
+              integrity="sha384-dbVIfZGuN1Yq7/1Ocstc1lUEm+AT+/rCkibIcC/OmWo5f0EA48Vf8CytHzGrSwbQ",
+              crossorigin="anonymous"),
+    HTML('<script defer src="https://cdn.jsdelivr.net/npm/katex@0.10.1/dist/katex.min.js" integrity="sha384-2BKqo+exmr9su6dir+qCw08N2ZKRucY4PrGQPPWU1A7FtlCGjmEGFqXCv5nyM5Ij" crossorigin="anonymous"></script>'),
+    HTML('<script defer src="https://cdn.jsdelivr.net/npm/katex@0.10.1/dist/contrib/auto-render.min.js" integrity="sha384-kWPLUVMOks5AQFrykwIup5lo0m3iMkkHrD0uJ4H5cjeGihAutqP0yW0J6dpFiVkI" crossorigin="anonymous"></script>'),
+    HTML('
+    <script>
+      document.addEventListener("DOMContentLoaded", function(){
+        renderMathInElement(document.body, {
+          delimiters: [{left: "$", right: "$", display: false}]
+        });
+      })
+    </script>')
+  ),
+  
+  
+  
+  #theme = shinytheme("simplex"),
+  theme = shinytheme("cerulean"),
+  #        theme = shinytheme("united"),
+  #         theme = shinytheme("journal"),
+  
+  # Application title
+  withMathJax(),
+  tags$style(type="text/css",
+             "body {padding-top: 5px;
+                color: purple; background-color: white}"),
+  
+  titlePanel(h2("Pruebas de Hipótesis Multivariadas",
+                style={'background-color:aquamarine;'})),
+  
+  #########################################################
+  #########################################################
+  #### INICIO TABSETPANEL-GLOBAL DE UNA Y DOS POBLACIONES
+  #########################################################
+  #########################################################
+  
+  tabsetPanel(
+    
+    #########################################################
+    #########################################################
+    #### INICIO TABPANEL-DE UNA POBLACIÓN
+    #########################################################
+    #########################################################
+    
+    tabPanel(h4("PH para una población",style={'color:#e905f5;'}),
+             
+             #  position = "fixed-top",
+             
+             # Sidebar
+             tabsetPanel(
+               id = "tabs1",
+               type = "pills",
+               
+               ################################################ 
+               ### Inicio del tabPanel Datos
+               ################################################
+               
+               tabPanel("Datos",
+                        # Barra de Opciones de Datos
+                        div(
+                          sidebarPanel(
+                            conditionalPanel(condition = "input.tabs1 == 'Datos'",
+                                             radioButtons("dataInput",HTML("Para interactuar con esta aplicacion usted puede usar los datos simulados o cargar sus propios datos. <br> Por favor elija una de las siguientes opciones:"),  
+                                                          #radioButtons("dataInput","Elegir los Datos a Usar:",
+                                                          list("Datos simulados" = 1,"Cargar datos" = 2), selected = 1),
+                                             
+                                             conditionalPanel(condition = "input.dataInput=='2'",
+                                                              fileInput("upload","Descargue su arhivo delimitado (10MB_max):",multiple = FALSE,
+                                                                        accept = c(
+                                                                          "text/csv",
+                                                                          "text/comma-separated-values,text/plain",
+                                                                          "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                                                                          ".csv",
+                                                                          ".xlsx"),
+                                                                        buttonLabel = "Cargar"),
+                                                              radioButtons("fileSepDF","Separador de datos:",list("Coma" = 1,"Tabulador" = 2,"Semicoma" = 3,"Espacio" = 4),selected = 1),
+                                                              checkboxInput("myHead","Variables en la fila-1",value = TRUE),
+                                                              
+                                                              conditionalPanel("input.fileSepDF!='1'",
+                                                                               checkboxInput("decimal","Usa la coma como decimal",value = FALSE))
+                                             ),
+                                             selectizeInput("variables","Variables a usar",choices = NULL,selected = NULL,multiple = TRUE),
+                                             generateInfo())
+                          )# fin de barra lateral (de sidebar Panel)
+                        ),  # fin Barra opciones de datos ie. el Div
+                        ####  Panel principal del panel-1
+                        mainPanel(
+                          fluidRow(column(width=8,
+                                          tags$h3(
+                                            # tagList(
+                                            tags$li(
+                                              actionLink("sobre_datos_muestra","  ",icon("info")),
+                                              class="dropdown",
+                                              tags$code("Conjunto de datos completo")
+                                            )
+                                            #)
+                                          )
+                          )),
+                          hr(),
+                          dataTableOutput('tabla1'),
+                          hr(),
+                          h3(p(code("Conjunto de datos filtrado"))),
+                          hr(),
+                          dataTableOutput('tabla2')
+                        )  ## fin del mainPanel
+               ),  ## fin del tabPanel Datos
+               
+               ################################################
+               ### Inicio del tabPanel Pruebas de Normalidad
+               ################################################
+               
+               tabPanel("Pruebas de normalidad",
+                        sidebarLayout(
+                          sidebarPanel(
+                            selectInput("PH_NU_Seleccionada",p("Normalidad univariada:",style=" text-align:center"),
+                                        choices=c("SW:Shapiro-Wilk"=1,
+                                                  "CMV:Cramer-von Mises"=2,
+                                                  "Lilliefors"=3,
+                                                  "SF:Shapiro-Francia"=4,
+                                                  "AD:Anderson-Darling"=5),
+                                        selected = 1),
+                            
+                            selectInput("Grafico_Seleccionado",p("Grafico univariado",style=" text-align:center"),
+                                        choices=c("QQ-Plot"=1,
+                                                  "Histograma"=2,
+                                                  "Box-Plot"=3,
+                                                  "Scatter-Plot"=4),
+                                        selected = 2),
+                            
+                            selectInput("PH_NM_Seleccionada",p("Normalidad multivariada:",style=" text-align:center"),
+                                        choices=c("Mardia"=1,
+                                                  "hz:Henze-Zirkler"=2,
+                                                  "Royston"=3,
+                                                  "dh:Doornik-Hansen"=4),
+                                        #                       "Shapiro-Wilk-NM"=5),
+                                        selected = 3),
+                            
+                            selectInput("Grafico_Multi_Seleccionado",p("Gráfico multivariado:",style=" text-align:center"),
+                                        choices=c("QQ-Plot_Chi_Cuadrado"=1,
+                                                  "Perspectivas"=2,
+                                                  "Contonros"=3),
+                                        selected = 1),
+                            
+                            selectInput("Graficos_Varios",p("Otros gráficos:",style=" text-align:center"),
+                                        choices=c("Dispersión"=1,
+                                                  "Disp_1Elipse_np"=2,
+                                                  # "Disp_1Elipse_ng"=3,
+                                                  "Disp_2Elipses_np"=4,
+                                                  #"Disp_2Elipses_ng"=5,
+                                                  "Superficie_NB"=6,
+                                                  "contornos_NB"=7,
+                                                  "elipse_conf"=8,
+                                                  "elipse_conf_IC_T2"=9,
+                                                  "elipse_conf_IC_BONF"=10,
+                                                  "elipse_conf_IC_tstud"=11),
+                                        selected = 2),
+                            generateInfo(),
+                          ),  #### fin de sidebarPanel-contenidos PNU
+                          
+                          #############################################
+                          ## Inicio Panel Principal de Derecha PH-NORM
+                          #############################################
+                          
+                          mainPanel(
+                            tabsetPanel(type = "pills",
+                                        
+                                        ##############################
+                                        ## Inicio Panel de PH NU
+                                        ##############################
+                                        
+                                        tabPanel(withMathJax("\\(H_0 : Datos\\sim N_1\\)"),
+                                                 br(),
+                                                 fluidRow(column(width=8,
+                                                                 h4(p("Resumen descriptivo de los datos",
+                                                                      style="color:black;text-align:center")) ,
+                                                                 style="background-color:lavender;border-radius: 10px")),
+                                                 br(),
+                                                 tableOutput('PH_RD'),
+                                                 br(),
+                                                 fluidRow(column(width=8,
+                                                                 h4(p("Coeficientes de asimetría y kurtosis univariados",
+                                                                      style="color:black;text-align:center")),
+                                                                 style="background-color:lavender;border-radius: 10px")),
+                                                 br(),
+                                                 tableOutput('Res_Descriptivos_Varios'),
+                                                 
+                                                 #### PH de N_1
+                                                 hr(),
+                                                 fluidRow(column(width=8,
+                                                                 h4(p("PH Sobre normalidad univariada",
+                                                                      style="color:black;text-align:center")),
+                                                                 style="background-color:lavender;border-radius: 10px")),
+                                                 br(),
+                                                 withMathJax(),
+                                                 fluidRow(column(width=8,
+                                                                 p('$$\\begin{cases}
+                H_0: \\ \\ \\text{Las variables individuales son NU} \\\\
+                H_a: \\ \\ \\text{Las variables individuales no son NU}
+                \\end{cases}
+                $$',
+                                                                   style="color:black;border:1px solid black;
+                background-color:white"))),
+                                                 br(),
+                                                 h4(textOutput("resultados_PH_NU"),
+                                                    style={'color:red;'}),
+                                                 
+                                                 br(),
+                                                 tableOutput('Res_NU'),
+                                                 br(),
+                                                 fluidRow(column(width=8,
+                                                                 p(tags$em("Puedes consultar las ayudas de las funciones del R
+                          usadas para estas pruebas en:",
+                                                                           tags$a("MVN::mvn()",
+                                                                                  href="https://rdrr.io/cran/MVN/man/mvn.html"
+                                                                           )
+                                                                 ),".")
+                                                 )),
+                                                 br(),
+                                                 withMathJax(),
+                                                 fluidRow(column(width=8,
+                                                                 p(em("No se rechaza \\(  H_0 \\) si valor p de la prueba
+               es mayor o igual que \\( \\alpha \\) para un nivel
+               de significancia del \\( (1-\\alpha)100\\% \\),  en
+               caso contrario se rechaza."),
+                                                                   style="background-color:#a9f1a86b"
+                                                                 ))),
+                                                 br(),
+                                                 
+                                                 fluidRow(column(width=8,
+                                                                 h4(p("Graficos univariados de los datos",
+                                                                      style="color:black;text-align:center")),
+                                                                 style="background-color:lavender;border-radius: 10px")),
+                                                 br(),
+                                                 plotOutput('Graf_NU'),
+                                                 br()
+                                        ),  # Fin del panel de PH NU
+                                        
+                                        ##############################
+                                        ## Inicio Panel de PH NM
+                                        ##############################
+                                        tabPanel(withMathJax("\\(H_0 : Datos\\sim N_p\\)"),
+                                                 br(),
+                                                 fluidRow(column( width=8,
+                                                                  h4(p("PH Sobre normalidad multivarida (NM)",
+                                                                       style="color:black;text-align:center")),
+                                                                  style="background-color:lavender;border-radius: 10px")),
+                                                 br(),
+                                                 withMathJax(),
+                                                 fluidRow(column(width=8,
+                                                                 p('$$\\begin{cases}
+              H_0: \\ \\ \\text{Los datos son NM} \\\\
+              H_a: \\ \\ \\text{Los datos no son NM}
+              \\end{cases}$$',
+                                                                   style="color:black;border:1px solid black;
+              background-color:white"))),
+                                                 br(),
+                                                 h4(textOutput("resultados_PH_NM"),
+                                                    style={'color:red;'}),
+                                                 br(),
+                                                 tableOutput('Res_NM'),
+                                                 # br(),
+                                                 #       tableOutput('Res_NM_SW'),
+                                                 br(),
+                                                 withMathJax(),
+                                                 fluidRow(column(width=8,
+                                                                 p(em("No se rechaza \\(  H_0 \\) si valor p de la prueba
+               es mayor o igual que \\( \\alpha \\) para un nivel
+               de significancia del \\( (1-\\alpha)100\\% \\),  en
+               caso contrario se rechaza."),
+                                                                   style="background-color:#a9f1a86b"
+                                                                 ))),
+                                                 br(),
+                                                 fluidRow(column(width=8,
+                                                                 h4(p("Graficos multivariados de los datos",
+                                                                      style="color:black;text-align:center")),
+                                                                 style="background-color:lavender;border-radius: 10px")),
+                                                 br(),
+                                                 plotOutput('Graf_NM'),
+                                                 
+                                                 ## Otros gráficos
+                                                 hr(),
+                                                 fluidRow(column(width=8,
+                                                                 h4(p("Otros gráficos de interés",
+                                                                      style="color:black;text-align:center")) ,
+                                                                 style="background-color:lavender;border-radius: 10px")),
+                                                 br(),
+                                                 plotOutput('elipses'),
+                                                 br()
+                                        ),  # Fin del panel de PH NM
+                                        
+                                        ###################################################
+                                        #### Inicio del panel de Teoría
+                                        ###################################################
+                                        tabPanel("Teoría", "123"
+                                                 
+                                        ), #### Fin del panel de Teoría
+                                        
+                            ) #end tabsetPanel-pills ie. del panel derecho de salidas
+                          ) # end mainPanel ie. del panel pricipal
+                        ) ### fin del sidebarLayout
+               ),  ### fin del tabPanel: Pruebas de normalidad
+               
+               
+               ################################################
+               ### Inicio del tabPanel Pruebas: Mu=Mu0
+               ################################################
+               
+               tabPanel("\\(H_0 : \\underline{\\mu}=\\underline{\\mu}_0 \\)",
+                        sidebarLayout(
+                          sidebarPanel(textInput('mu0',
+                                                 HTML('Por favor ingrese el vector \\( \\underline{\\mu}_0 \\)  para la 
+                    PH \\( H_0 \\)  :  \\( \\underline{\\mu} =
+                    \\underline{\\mu}_0  \\). \n Por ejemplo si el vector \\(\\mu_0\\)\ es (0,0,0), usted debe ingresar 0,0,0')), # Arreglar el mu
+                                       hr(),
+                                       numericInput("alfa", p("Ingrese el valor de \\( \\alpha \\)"),value = 0.05),
+                                       selectInput("PruebaAnalitica", p("Elija la prueba a usar para n pequeña:",
+                                                                        style="text-align:center"),
+                                                   choices=c("T2.test"=1,"HotellingsT2"=2),
+                                                   selected = 1),
+                                       hr(),
+                                       selectInput("PruebaAnalitica_ng",p("Prueba a usar para n grande:"
+                                                                          ,style="text-align:center"),
+                                                   choices=c("HotellingsT2"=1),selected = 1),
+                                       generateInfo()
+                          ),  #### Find del sidebarPanel
+                          
+                          ################################################
+                          ## Inicio Panel Principal de Derecha PH-Mu=Mu0
+                          ################################################
+                          
+                          mainPanel(
+                            tabsetPanel(type = "pills",
+                                        
+                                        ##################################
+                                        ## Inicio Panel de PH Mu=Mu0, FU
+                                        ##################################
+                                        
+                                        tabPanel("Función-Usuario",
+                                                 br(),
+                                                 fluidRow(column(width=8,
+                                                                 h4(p("PH sobre el vector de medias usando una FU para n pequeña",
+                                                                      style="color:black;text-align:center")),
+                                                                 style="background-color:lavender;border-radius: 10px")),
+                                                 br(),
+                                                 withMathJax(),
+                                                 fluidRow(column(width=6,
+                                                                 p('$$\\begin{cases}
+                H_0: \\ \\ \\underline{\\mu}=\\underline{\\mu}_0 \\\\
+                H_a: \\ \\ \\underline{\\mu}\\neq\\underline{\\mu}_0
+                \\end{cases}$$',
+                                                                   style="color:black;border:1px solid black;
+                background-color:white"))),
+                                                 br(),
+                                                 tableOutput('PH_mu0'),
+                                                 br(),
+                                                 withMathJax(),
+                                                 fluidRow(column(width=8,
+                                                                 p(tags$em("Puedes consultar algo sobre la teoría
+                            utilizada para este tipo de pruebas en:  "),
+                                                                   tags$a("Dar click acá:", href="parte1mu0.pdf")
+                                                                 )
+                                                 )),
+                                                 br(),
+                                                 withMathJax(),
+                                                 fluidRow(column(width=8,
+                                                                 p(em("No se rechaza \\(  H_0 \\) si valor p de la prueba
+               es mayor o igual que \\( \\alpha \\) para un nivel
+               de significancia del \\( (1-\\alpha)100\\% \\),  en
+               caso contrario se rechaza."),
+                                                                   style="background-color:#a9f1a86b"
+                                                                 ))),
+                                                 br(),
+                                                 tableOutput('conclus2'),
+                                                 
+                                                 hr(),    ### FU n-Grande
+                                                 fluidRow(column( width=8,
+                                                                  h4(p("PH sobre el vector de medias usando una FU para n grande",
+                                                                       style="color:black;text-align:center")),
+                                                                  style="background-color:lavender;border-radius: 10px")),
+                                                 br(),
+                                                 tableOutput('PH_mu0_ng'),
+                                                 br(),
+                                                 tableOutput('conclus2_mu0_ng'),
+                                                 br()
+                                                 
+                                        ), # Fin del tabPanel de: Mu=Mu0, FU
+                                        
+                                        ########################################
+                                        ## Inicio Panel de PH Mu=Mu0, USANDO-R
+                                        #######################################
+                                        
+                                        tabPanel("Usando-R",
+                                                 br(),
+                                                 fluidRow(column(width=8,
+                                                                 h4(p("PH sobre el vector de medias usando R para n pequeña",
+                                                                      style="color:black;text-align:center")),
+                                                                 style="background-color:lavender;border-radius: 10px")),
+                                                 br(),
+                                                 verbatimTextOutput("Res_MU0r"),
+                                                 br(),
+                                                 fluidRow(column(width=8,
+                                                                 p(tags$em("Para mayor informacion sobre las funciones usadas consultar los siguientes enlaces:",
+                                                                           tags$a("rrcov::T2.test()",
+                                                                                  href="https://rdrr.io/cran/rrcov/man/T2.test.html"
+                                                                           ),
+                                                                           tags$a(",  icsnp::HotellingsT2()",
+                                                                                  href="https://rdrr.io/cran/ICSNP/man/HotellingsT.html"
+                                                                           )
+                                                                 ),".")
+                                                 )),
+                                                 br(),
+                                                 withMathJax(),
+                                                 fluidRow(column(width=8,
+                                                                 p(em("No se rechaza \\(  H_0 \\) si valor p de la prueba
+                es mayor o igual que \\( \\alpha \\) para un nivel
+                de significancia del \\( (1-\\alpha)100\\% \\),  en
+                caso contrario se rechaza."),
+                                                                   style="background-color:#a9f1a86b"
+                                                                 ))),
+                                                 br(),
+                                                 textOutput("Conclus_PH_mu0r"),
+                                                 
+                                                 ### Usando-r N-Grande
+                                                 hr(),
+                                                 fluidRow(column( width=8,
+                                                                  h4(p("PH sobre el vector de medias usando R para n grande",
+                                                                       style="color:black;text-align:center")),
+                                                                  style="background-color:lavender;border-radius: 10px")),
+                                                 br(),
+                                                 verbatimTextOutput("Res_MU0r_ng"),
+                                                 br()
+                                                 
+                                        ), # Fin del tabPanel de: Mu=Mu0, Usando-R
+                                        
+                                        ###########################################
+                                        ## Inicio Panel de Teoría
+                                        ##########################################
+                                        
+                                        tabPanel("Teoría",
+                                                 br(),
+                                                 withMathJax(),
+                                                 fluidRow(column(width=8,
+                                                                 tags$a("Ver la documentación teórica acá:",
+                                                                        href=" ")
+                                                 ))
+                                                 
+                                        )  #### Fin del tabPanel: Teoría
+                                        
+                            )  ### Fin del tabsetPanel (de pills)
+                          ) ### Fin del mainPanel ie. del panel pricipal
+                        )  ### Fin del sidebarLayout
+               ),  ### Fin del tabPanel Mu=Mu0
+               
+               ################################################
+               ### Inicio del tabPanel: Sigma=Sigma0
+               ################################################
+               
+               tabPanel("\\(H_0 : \\mathbf{\\Sigma}=\\mathbf{\\Sigma}_0 \\)",
+                        sidebarLayout(
+                          sidebarPanel(textInput('sigma0',
+                                                 HTML('Matriz \\( \\mathbf{\\Sigma}_0 \\)  para
+                    PH: \\( H_0 \\)  :  \\( \\mathbf{\\Sigma} =
+                    \\mathbf{\\Sigma}_0  \\) Ejemplo Input: 1,0,0;0,1,0;0,0,1')),
+                                       hr(),
+                                       numericInput("alfa_sigma",
+                                                    p("Valor de \\( \\alpha \\)"),value = 0.05),
+                                       selectInput("Prueba_sigma",
+                                                   p("Prueba a usar para n pequeña:",
+                                                     style="text-align:center"),
+                                                   choices=c("LRT test-Mardia (1979)"=1,
+                                                             "LRT1 test Rencher-Christensen (2012)"=2,
+                                                             "LRT2 test Rencher-Christensen (2012)"=3),
+                                                   selected = 1),
+                                       hr(),
+                                       selectInput("Prueba_sigma_ng",
+                                                   p("Prueba a usar para n grande:"
+                                                     ,style="text-align:center"),
+                                                   choices=c("HotellingsT2"=1),selected = 1),
+                                       generateInfo()
+                          ),  #### Find del sidebarPanel
+                          
+                          mainPanel(
+                            tabsetPanel(
+                              type = "pills",
+                              
+                              tabPanel("Función de Usuario:",
+                                       br(),
+                                       fluidRow(column(width=8,
+                                                       h4(p("PH sobre la matriz de Var-Cov usando una FU para n pequeña",
+                                                            style="color:black;text-align:center")),
+                                                       style="background-color:lavender;border-radius: 10px")),
+                                       br(),
+                                       withMathJax(),
+                                       fluidRow(column(width=6,
+                                                       p('$$\\begin{cases}
+                H_0: \\ \\ \\mathbf{\\Sigma}=\\mathbf{\\Sigma}_0 \\\\
+                H_a: \\ \\ \\mathbf{\\Sigma}\\neq\\mathbf{\\Sigma}_0
+                \\end{cases}$$',
+                                                         style="color:black;border:1px solid black;
+                background-color:white"))),
+                                       br(),
+                                       withMathJax(),
+                                       fluidRow(column(width=8,
+                                                       p(tags$strong(
+                                                         helpText("La matriz de Varianzas-Covarianzas
+                                 muestral-$\\mathbf{S}$
+                                 de los datos es:" )
+                                                       )
+                                                       )
+                                       )),
+                                       br(),
+                                       tableOutput('mat_var_cov'),
+                                       br(),
+                                       withMathJax(),
+                                       fluidRow(column(width=8,
+                                                       p(tags$strong(
+                                                         helpText("La matriz de Varianzas-Covarianzas-
+                                 $\\Sigma_0$ propuesta es:") )
+                                                       )
+                                       )),
+                                       br(),
+                                       tableOutput('mat_var_cov_sigma0'),
+                                       br(),
+                                       tableOutput('PH_Sigma0'),
+                                       br(),
+                                       withMathJax(),
+                                       fluidRow(column(width=8,
+                                                       p(tags$em("Puedes consultar algo sobre la teoría
+                            utilizada para este tipo de pruebas en:  "),
+                                                         tags$a("Dar click acá:", href="parte2mu0.pdf")
+                                                       )
+                                       )),
+                                       br(),
+                                       withMathJax(),
+                                       fluidRow(column(width=8,
+                                                       p(em("No se rechaza \\(  H_0 \\) si valor p de la prueba
+               es mayor o igual que \\( \\alpha \\) para un nivel
+               de significancia del \\( (1-\\alpha)100\\% \\),  en
+               caso contrario se rechaza."),
+                                                         style="background-color:#a9f1a86b"
+                                                       ))),
+                                       br(),
+                                       tableOutput('conclus_sigma0'),
+                                       
+                                       ### FU n-Grande
+                                       hr(),
+                                       fluidRow(column(width=8,
+                                                       h4(p("PH sobre la matriz de Var-Cov usando una FU n grande",
+                                                            style="color:black;text-align:center")),
+                                                       style="background-color:lavender;border-radius: 10px")),
+                                       br(),
+                                       tableOutput('PH_Sigma0_ng'),
+                                       br(),
+                                       tableOutput('conclus_sigma0_ng'),
+                                       br()
+                                       
+                              ),
+                              
+                              ########### usando-r
+                              
+                              tabPanel("Usando-R",
+                                       br(),
+                                       fluidRow(column(width=8,
+                                                       h4(p("PH sobre la matriz de Var-Cov usando R para n pequeña",
+                                                            style="color:black;text-align:center")),
+                                                       style="background-color:lavender;border-radius: 10px")),
+                                       br(),
+                                       verbatimTextOutput("Res_sigma0r"),
+                                       br(),
+                                       fluidRow(column(width=8,
+                                                       p(tags$em("Puedes consultar las ayudas de las funciones del R
+                          usadas para estas pruebas en:",
+                                                                 tags$a("stets::one_covar_matrix_test()",
+                                                                        href="https://fhernanb.github.io/stests/reference/one_covar_matrix_test.html"
+                                                                 )
+                                                       ),".")
+                                       )),
+                                       br(),
+                                       withMathJax(),
+                                       fluidRow(column(width=8,
+                                                       p(em("No se rechaza \\(  H_0 \\) si valor p de la prueba
+                es mayor o igual que \\( \\alpha \\) para un nivel
+                de significancia del \\( (1-\\alpha)100\\% \\),  en
+                caso contrario se rechaza."),
+                                                         style="background-color:#a9f1a86b"
+                                                       ))),
+                                       br(),
+                                       textOutput("Conclus_PH_sigma0r"),
+                                       
+                                       ### Usando-r N-Grande
+                                       hr(),
+                                       fluidRow(column( width=8,
+                                                        h4(p("PH sobre el vector de medias usando R para n grande",
+                                                             style="color:black;text-align:center")),
+                                                        style="background-color:lavender;border-radius: 10px")),
+                                       br(),
+                                       verbatimTextOutput("Res_sigma0r_ng"),
+                                       br()
+                                       
+                              ), # Fin del tabPanel de: Sigma=Sigma_0, Usando-R
+                              
+                              
+                              tabPanel("Teoría",
+                                       br(),
+                                       withMathJax(),
+                                       fluidRow(column(width=8,
+                                                       tags$a("Ver la documentación teórica acá:",
+                                                              href="https://fhernanb.github.io/stests/reference/one_covar_matrix_test.html")
+                                       ))
+                                       
+                              )
+                              
+                            )  ####  Fin del tabsetPanel: Sigma=Sigma0
+                          )    ### fin mainPanle
+                          
+                        )     # fin del sidebarLayout
+                        
+               )  ### tabPanel: SIgma=igma0
+               
+             )  ### Fin del tabsetPanel-De una Población
+             
+             
+             ################################################
+             ################################################
+             ######### FIN DEL PANEL DE UNA POBLACIÓN  ######
+             ################################################
+             ################################################
+             
+    ),    ### Fin del tabPanel-De una Población
+    
+    #####################################
+    #####################################
+    #### INICIO DOS POBLACIONES #########
+    #####################################
+    #####################################
+    
+    tabPanel(h4("PH para dos poblaciones",style={'color:#e905f5;'}),
+             
+             tabsetPanel(
+               
+               tabPanel("Datos:",
+                        div(
+                          sidebarPanel(
+                            conditionalPanel(condition = "input.tabs2 == 'Datos:'",
+                                             
+                                             radioButtons("dataInputa","Elegir los datos a usar:",
+                                                          list("Usar datos de muestra" = 1,"Cargar sus Datos" = 2),selected = 1 ),
+                                             
+                                             conditionalPanel(condition = "input.dataInputa=='2'",
+                                                              hr(),
+                                                              
+                                                              fileInput("uploada","Descargue su arhivo delimitado (10MB_max):",multiple = FALSE,
+                                                                        accept = c(
+                                                                          "text/csv",
+                                                                          "text/comma-separated-values,text/plain",
+                                                                          "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                                                                          ".csv",
+                                                                          ".xlsx"),
+                                                                        buttonLabel = "Cargar"),
+                                                              
+                                                              radioButtons("fileSepDFa","Delimiter:",
+                                                                           list("Comma" = 1,"Tab" = 2,"Semicolon" = 3,"Space" = 4),selected = 1),
+                                                              
+                                                              checkboxInput("myHeada","Nombres de vars. en la primera fila",value = TRUE),
+                                                              
+                                                              conditionalPanel(condition = "input.fileSepDFa!='1'",
+                                                                               
+                                                                               checkboxInput("decimal","Usar la coma como decimal",value = FALSE))
+                                                              
+                                             ),  # Fin de conditional(...input.dataInputa=='2'), ie. Datos2
+                                             
+                                             selectizeInput("variables1a","Variables a utilizar Grupo-1",choices = NULL,selected = NULL,multiple = TRUE),
+                                             
+                                             selectizeInput("variables2a","Variables a utilizar Grupo-2",choices = NULL,selected = NULL,multiple = TRUE),
+                                             generateInfo()
+                                             
+                            )  # Find de condition = "input.tabs2 == 'Datos:', ie. Datos
+                            
+                          ) # fin de sidebarPanel( width = 4)
+                          
+                        ),  # fin Barra opciones de datos ie. el Div
+                        
+                        ########################################################
+                        ## Inicio Panel Principal De Datos Dos Poblaciones
+                        ########################################################
+                        
+                        mainPanel(
+                          fluidRow(column(width=8,
+                                          tags$h3(
+                                            # tagList(
+                                            tags$li(
+                                              actionLink("sobre_datos_2Pob","  ",icon("info")),
+                                              class="dropdown",
+                                              tags$code("Conjunto de datos completo")
+                                            )
+                                            #)
+                                          )
+                          )),
+                          hr(),
+                          dataTableOutput('tabla1a'),
+                          hr(),
+                          h3(p(code("Muestra de la Población-1"))),
+                          hr(),
+                          dataTableOutput('tabla2a'),
+                          hr(),
+                          h3(p(code("Muestra de la Población-2"))),
+                          hr(),
+                          dataTableOutput('tabla3a')
+                        )  ### Find Panel-Principal de Datos2
+               ),   ### Fin de tabPanel: "Datos:"
+               
+               
+               #########################################################
+               #########################################################
+               ######### INICIO PANEL DE PH: Mu1=Mu2
+               #########################################################
+               #########################################################
+               
+               tabPanel("\\( H_0:  \\underline{\\mu}_1=\\underline{\\mu}_2 \\)",
+                        
+                        sidebarLayout(
+                          sidebarPanel(
+                            
+                            textInput('mu0a',
+                                      HTML('Entre el vector
+                 \\( \\underline{\\delta}_0 \\)  para realizar la PH:
+                 \\( H_0 \\)  :  \\( \\underline{\\mu}_1 - \\underline{\\mu}_2
+                 = \\underline{\\delta}_0  \\) Ejemplo Input: 0,0,0 Dependiendo de la cantidad de variables')),
+                            numericInput("alfaa",p("Entre el valor de \\( \\alpha \\)"),value = 0.05),
+                            selectInput("PruebaAnaliticaa", p("Prueba a usar n pequeña:",
+                                                              style="text-align:center"),
+                                        choices=c("T2.test"=1,"HotellingsT2"=2),
+                                        selected = 1),
+                            selectInput("PruebaAnalitica_nga",p("Prueba a usar n grande:",
+                                                                style="text-align:center"),
+                                        choices=c("HotellingsT2"=1),
+                                        selected = 1),
+                            generateInfo()
+                          ),  ### FIn de sidebarPanel(width = 4,....
+                          
+                          #######################################################
+                          #######################################################
+                          ## Inicio Panel Principal de Derecha para PH: Mu1=Mu2
+                          #######################################################
+                          #######################################################
+                          
+                          mainPanel(
+                            
+                            ####################################
+                            ####################################
+                            ##### Inicio Panel de PH Mu1=Mu2
+                            ####################################
+                            ####################################
+                            
+                            tabsetPanel(
+                              type = "pills",
+                              
+                              ####################################
+                              ## Inicio Panel de PH Mu1=Mu2, FU
+                              ####################################
+                              
+                              tabPanel(withMathJax("Función-Usuario"),
+                                       br(),
+                                       fluidRow(column(width=8,
+                                                       h4(p("PH sobre igualdad de vectores de medias
+                usando una FU, para n pequeña, para \\( \\Sigma_1=\\Sigma_2 \\)",
+                                                            style="color:black;text-align:center")),
+                                                       style="background-color:lavender;border-radius: 10px")),
+                                       br(),
+                                       withMathJax(),
+                                       fluidRow(column(width=8,
+                                                       p('$$\\begin{cases}
+                  H_0: \\ \\ \\underline{\\mu}_1 - \\underline{\\mu}_2  =
+                  \\underline{\\delta}_0 \\\\
+                  H_a: \\ \\ \\underline{\\mu}_1 - \\underline{\\mu}_2  \\neq
+                  \\underline{\\delta}_0
+                  \\end{cases}$$',
+                                                         style="color:black;border:1px solid black; background-color:white"
+                                                       ))),
+                                       br(),
+                                       tableOutput('PH_mu1_mu2_FU'),
+                                       br(),
+                                       withMathJax(),
+                                       fluidRow(column(width=8,
+                                                       p(tags$em("Puedes consultar algo sobre la teoría
+                            utilizada para este tipo de pruebas en:  "),
+                                                         tags$a("Dar click acá:", href="parte3mu0.pdf")
+                                                       )
+                                       )),
+                                       br(),
+                                       fluidRow(column(width=8,
+                                                       p(em("No se rechaza \\(  H_0 \\) si valor p de la prueba
+                  es mayor o igual que \\( \\alpha \\) para un nivel
+                  de significancia del \\( (1-\\alpha)100\\% \\),  en
+                  caso contrario se rechaza."),
+                                                         style="background-color:#a9f1a86b"
+                                                       ))),
+                                       br(),
+                                       tableOutput('conclus2a'),
+                                       br(),
+                                       
+                                       fluidRow(column(width=8,
+                                                       h4(p("PH sobre igualdad de vectores de medias
+                 usando una FU, para n pequeña para \\( \\Sigma_1\\neq \\Sigma_2\\) Nel and Van
+                 Der Merwe-1986",
+                                                            style="color:black;text-align:center")),
+                                                       style="background-color:lavender;border-radius: 10px")),
+                                       br(),
+                                       tableOutput('PH_mu1_mu2_FU_sigmas_dif'),
+                                       br(),
+                                       tableOutput('conclus4a'),
+                                       hr(),
+                                       
+                                       ### FU-n-Grande
+                                       br(),
+                                       
+                                       fluidRow(column( width=8,
+                                                        h4(p("PH sobre igualdad de vectores de medias para n grande,
+                    usando una FU",
+                                                             style="color:black;text-align:center")),
+                                                        style="background-color:lavender;border-radius: 10px")),
+                                       br(),
+                                       tableOutput('PH_mu1_mu2_FU_NG'),
+                                       br(),
+                                       tableOutput('conclus3a'),
+                                       br()
+                                       
+                              ), #### Fin de Mu1=Mu2, FU
+                              
+                              
+                              ##############################################
+                              ## Inicio Panel de PH Mu1=Mu2, USANDO-R
+                              ##############################################
+                              
+                              tabPanel("Usando-R",
+                                       br(),
+                                       fluidRow(column(width=8,
+                                                       h4(p("PH sobre igualdad de vectores de medias usando R",
+                                                            style="color:black;text-align:center")),
+                                                       style="background-color:lavender;border-radius: 10px")),
+                                       br(),
+                                       verbatimTextOutput("Res_mu1_mu2_R"),
+                                       br(),
+                                       withMathJax(),
+                                       br(),
+                                       fluidRow(column(width=8,
+                                                       p(tags$em("Puedes consultar las ayudas de las funciones del R
+                          usadas para estas pruebas en:",
+                                                                 tags$a("rrcov::T2.test()",
+                                                                        href="https://rdrr.io/cran/rrcov/man/T2.test.html"
+                                                                 ),
+                                                                 tags$a(",  icsnp::HotellingsT2()",
+                                                                        href="https://rdrr.io/cran/ICSNP/man/HotellingsT.html"
+                                                                 )
+                                                                 
+                                                       ),".")
+                                       )),
+                                       br(),
+                                       fluidRow(column(width=8,
+                                                       p(em("No se rechaza \\(  H_0 \\) si valor p de la prueba
+                  es mayor o igual que \\( \\alpha \\) para un nivel
+                  de significancia del \\( (1-\\alpha)100\\% \\),  en
+                  caso contrario se rechaza."),
+                                                         style="background-color:#a9f1a86b"
+                                                       ))),
+                                       br(),
+                                       
+                                       ### Usando-R N-Grande
+                                       hr(),
+                                       fluidRow(column( width=8,
+                                                        h4(p("Resultados de PH sobre igualdad de vectores de medias
+                usando R Para n-grande",
+                                                             style="color:black;text-align:center")),
+                                                        style="background-color:lavender;border-radius: 10px")),
+                                       br(),
+                                       verbatimTextOutput("Res_mu1_mu2_R_NG"),
+                                       br()
+                                       
+                              ), # Fin Panel: Mu1=Mu2, USANDO-R
+                              
+                              ##############################################
+                              ## Inicio Panel de Teoría
+                              ##############################################
+                              
+                              tabPanel("Teoría", "1234"
+                                       
+                                       
+                              )
+                              
+                            )   ### Fin de tabsetPanel(type = "pills",
+                          )     ### Fin de mainPanel() Mu1=Mu2
+                        )     ### Fin de sidebarLayout()
+               ), ### FIN de PANEL mu1=mu2
+               
+               
+               #####################################################
+               #####################################################
+               ##### Inicio Panel de PH Mu1=Mu2, Muestras Pareadas
+               #####################################################
+               #####################################################
+               
+               tabPanel("\\( \\underline{\\mu}_1 = \\underline{\\mu}_2 \\)-Pareadas",
+                        
+                        sidebarLayout(
+                          
+                          sidebarPanel(
+                            numericInput("alfa1a", p("Valor de \\( \\alpha \\)"),
+                                         value = 0.05),
+                            br(),
+                            selectInput("Prueba_mp",p("Seleccione la prueba pareada a usar:"
+                                                      ,style="text-align:center"),
+                                        choices=c("approx.hotelling.diff.test"=1),
+                                        selected = 1),
+                            generateInfo()
+                          ),
+                          
+                          mainPanel(
+                            
+                            tabsetPanel(type = "pills",
+                                        
+                                        ##############################################################
+                                        ##########  INICIPO PANEL: Mu1=Mu2, MP, FU
+                                        ##############################################################
+                                        
+                                        tabPanel("Función de Usuario",
+                                                 br(),
+                                                 fluidRow(column( width=8,
+                                                                  h4(p("PH sobre igualdad de vectores de de medias
+              usando una FU para muestras pareadas",
+                                                                       style="color:black;text-align:center")),
+                                                                  style="background-color:lavender;border-radius: 10px")),
+                                                 br(),
+                                                 withMathJax(),
+                                                 fluidRow(column( width=8,
+                                                                  p('$$\\begin{cases}
+               H_0: \\ \\ \\underline{\\mu}_1 = \\underline{\\mu}_2 \\\\
+               H_a: \\ \\ \\underline{\\mu}_1 \\neq \\underline{\\mu}_2
+               \\end{cases}$$',
+                                                                    style="color:black;border:1px solid black;background-color:white"
+                                                                  ))),
+                                                 br(),
+                                                 tableOutput('PH_mu1_mu2_FU_MPareadas'),
+                                                 br(),
+                                                 withMathJax(),
+                                                 fluidRow(column(width=8,
+                                                                 p(tags$em("Puedes consultar algo sobre la teoría
+                            utilizada para este tipo de pruebas en:  "),
+                                                                   tags$a("Dar click acá:", href="parte4mu0.pdf")
+                                                                 )
+                                                 )),
+                                                 br(),
+                                                 fluidRow(column(width=8,
+                                                                 p(em("No se rechaza \\(  H_0 \\) si valor p de la prueba
+                es mayor o igual que \\( \\alpha \\) para un nivel
+                de significancia del \\( (1-\\alpha)100\\% \\),  en
+                caso contrario se rechaza."),
+                                                                   style="background-color:#a9f1a86b"
+                                                                 ))),
+                                                 br(),
+                                                 tableOutput('conclus6a'),
+                                                 br()
+                                                 
+                                        ), #### Fin de Panel: Mu1=Mu2, MUESTRAS-PAREADAS, FU
+                                        
+                                        ##############################################################
+                                        ##########  INICIPO PANEL: Mu1=Mu2, MP, USANDO-R
+                                        ##############################################################
+                                        
+                                        tabPanel("Usando R",
+                                                 br(),
+                                                 fluidRow(column( width=8,
+                                                                  h4(p("Resultados de PH sobre igualdad de vectores de medias
+                  usando R para muestras pareadas",
+                                                                       style="color:black;text-align:center")),
+                                                                  style="background-color:lavender;border-radius: 10px")),
+                                                 br(),
+                                                 verbatimTextOutput("Res_mu1_mu2_R_MPareadas"),
+                                                 br(),
+                                                 withMathJax(),
+                                                 br(),
+                                                 fluidRow(column(width=8,
+                                                                 p(tags$em("Puedes consultar las ayudas de las funciones del R
+                          usadas para estas pruebas en:",
+                                                                           tags$a("ergm::approx.hotelling.diff.test()",
+                                                                                  href="https://rdrr.io/cran/ergm/man/approx.hotelling.diff.test.html"
+                                                                           )
+                                                                 ),".")
+                                                 )),
+                                                 br(),
+                                                 fluidRow(column(width=8,
+                                                                 p(em("No se rechaza \\(  H_0 \\) si valor p de la prueba
+                es mayor o igual que \\( \\alpha \\) para un nivel
+                de significancia del \\( (1-\\alpha)100\\% \\),  en
+                caso contrario se rechaza."),
+                                                                   style="background-color:#a9f1a86b"
+                                                                 ))),
+                                                 br()
+                                                 
+                                        ), ### Fin Mu1=Mu2, Muestras Pareadas, usando-R
+                                        
+                                        ##############################################
+                                        ## Inicio Panel de Teoría
+                                        ##############################################
+                                        
+                                        tabPanel("Teoría", "1234"
+                                                 
+                                                 
+                                        )
+                                        
+                                        
+                            )   ### Fin de tabsetPanel(type = "pills",
+                          )     ### Fin de mainPanel() Mu1=Mu2, MUESTRAS_PAREADAS
+                        )     ### Fin de sidebarLayout()
+               ), ### FIN de PANEL mu1=mu2, MUESTRAS-PAREADAS
+               
+               
+               #####################################################
+               #####################################################
+               ##### Inicio Panel de PH sigma1=sigma2
+               #####################################################
+               #####################################################
+               
+               tabPanel("\\( H_0:  \\Sigma_1=\\Sigma_2 \\)",
+                        
+                        sidebarLayout(
+                          
+                          sidebarPanel(
+                            
+                            numericInput("alfa2a", label = p("Entre el valor de \\( \\alpha \\)"),value = 0.05),
+                            br(),
+                            selectInput("Prueba_box",p("Seleccione la PH de R a usar:",
+                                                       style="text-align:center"),
+                                        choices=c("boxM"=1),selected = 1),
+                            generateInfo()
+                          ),
+                          
+                          
+                          mainPanel(
+                            
+                            tabsetPanel(type = "pills",
+                                        
+                                        ##############################################################
+                                        ##########  INICIPO PANEL: Sigma1=Sigma2, FU
+                                        ##############################################################
+                                        
+                                        tabPanel("Funci��n de Usuario",
+                                                 br(),
+                                                 fluidRow(column( width=8,
+                                                                  h4(p("Resultados de PH sobre igualdad de matrices de Var-Cov
+                 usando una FU", style="color:black;text-align:center")),
+                                                                  style="background-color:lavender;border-radius: 10px")),
+                                                 br(),
+                                                 withMathJax(),
+                                                 fluidRow(column( width=8,
+                                                                  p('$$\\begin{cases}
+                  H_0: \\ \\ \\Sigma_1 = \\Sigma_2 \\\\
+                  H_a: \\ \\ \\Sigma_1 = \\Sigma_2
+                  \\end{cases} $$',
+                                                                    style="color:black;border:1px solid black; background-color:white"
+                                                                  ))),
+                                                 br(),
+                                                 tableOutput('PH_sigma1_sigma2_FU'),
+                                                 br(),
+                                                 withMathJax(),
+                                                 fluidRow(column(width=8,
+                                                                 p(tags$em("Puedes consultar algo sobre la teoría
+                            utilizada para este tipo de pruebas en:  "),
+                                                                   tags$a("Dar click acá:", href="parte2mu0.pdf")
+                                                                 )
+                                                 )),
+                                                 br(),
+                                                 fluidRow(column(width=8,
+                                                                 p(em("No se rechaza \\(  H_0 \\) si valor p de la prueba
+                 es mayor o igual que \\( \\alpha \\) para un nivel
+                 de significancia del \\( (1-\\alpha)100\\% \\),  en
+                 caso contrario se rechaza."),
+                                                                   style="background-color:#a9f1a86b"
+                                                                 ))),
+                                                 br(),
+                                                 tableOutput('conclus8a'),
+                                                 br()
+                                                 
+                                        ), ### Fin Panel Sigma1=SIgma2, FU
+                                        
+                                        
+                                        ##############################################################
+                                        ##########  INICIPO PANEL: Sigma1=Sigma2, USANDO-R
+                                        ##############################################################
+                                        
+                                        tabPanel("Usando R",
+                                                 br(),
+                                                 fluidRow(column( width=8,
+                                                                  h4(p("Resultados de PH sobre igualdad de matrices de Var-Cov usando R",
+                                                                       style="color:black;text-align:center")),
+                                                                  style="background-color:lavender;border-radius: 10px")),
+                                                 br(),
+                                                 verbatimTextOutput("Res_sigma1_sigma2_R"),
+                                                 br(),
+                                                 withMathJax(),
+                                                 br(),
+                                                 fluidRow(column(width=8,
+                                                                 p(tags$em("Puedes consultar las ayudas de las funciones del R
+                          usadas para estas pruebas en:",
+                                                                           tags$a("biotools::boxM()",
+                                                                                  href="https://rdrr.io/cran/biotools/man/boxM.html"
+                                                                           )
+                                                                 ),".")
+                                                 )),
+                                                 br(),
+                                                 fluidRow(column(width=8,
+                                                                 p(em("No se rechaza \\(  H_0 \\) si valor p de la prueba
+                 es mayor o igual que \\( \\alpha \\) para un nivel
+                 de significancia del \\( (1-\\alpha)100\\% \\),  en
+                 caso contrario se rechaza."),
+                                                                   style="background-color:#a9f1a86b"
+                                                                 ))),
+                                                 br()
+                                                 
+                                        ), ### Fin Panel: Sigma1=Sigma2, usando-R
+                                        
+                                        ##############################################
+                                        ## Inicio Panel de Teoría
+                                        ##############################################
+                                        
+                                        tabPanel("Teoría", "1234"
+                                                 
+                                                 
+                                        )
+                                        
+                            )   ### Fin de tabsetPanel(type = "pills",
+                          )     ### Fin de mainPanel() Sigma1=Sigma2
+                        )     ### Fin de sidebarLayout()
+               ), ### FIN de PANEL Sigma1=Sigma2
+               
+               id = "tabs2",
+               type = "pills"
+               
+             )    ### Fin del tabPanel   tabsetPanel (Antes de Datos:)
+             
+    ) ### Fin del tabPanel-De Dos Poblaciones
+    
+  )  ### Fin del tabsetPanel-Global, ie. De Una y Dos Poblaciones
+  
+)   # Fin de ui
+
+
+