server.R

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()
  })





}