Adiciona as aplicações intermediárias elaboradas no iguiR/Rbras

shiny/deliQuadLat/server.R

+##-------------------------------------------
+## server.R
+
+## FUNCIONA LOCALMENTE MAS NÃO DÁ CERTO QUANDO MANDA PARA SERVIDORA. ALGO ESQUISITO.
+
+require(shiny)
+## Carrega template das aplicações elaboradas pelo projeto iguiR2
+source("../template.R")
+require(lattice)
+require(RColorBrewer)
+
+## Função para aleatorizar experimento em quadrado latino.
+
+qldesign <- function(dim){
+    ## dim: escalar inteiro que é a dimensão do QL. 
+    M <- matrix(1:dim, dim, dim)
+    N <- M+(t(M))
+    O <- (N%%dim)+1
+    lin <- sample(1:dim)
+    col <- sample(1:dim)
+    M <- O[lin,col]
+    D <- expand.grid(lin=gl(dim,1), col=gl(dim,1))
+    D$trat <- c(M)
+    return(list(M=M, D=D))
+}
+
+# da <- qldesign(5)
+# 
+# # display.brewer.all()
+# colr <- brewer.pal(9, "Set1")
+# colr <- colorRampPalette(colr, space="rgb")
+# 
+# levelplot(trat~lin+col, data=da$D, aspect=1,
+#           colorkey=FALSE,
+#           col.regions=colr,
+#           panel=function(x, y, z, ...){
+#               panel.levelplot(x=x, y=y, z=z, ...)
+#               panel.text(x=x, y=y, labels=LETTERS[z])
+#               })
+
+shinyServer(
+    function(input, output, clientData, session){
+        ## Cabeçalho IGUIR2
+        output$header <- renderPrint({
+            template("TEMA")
+        })
+        output$ui <- renderUI({
+            if(input$set){
+                textInput(inputId="seed",
+                          label="Semente:",
+                          value=1234)
+            } else {
+                return()
+                }
+            })
+        
+        do <- reactive({
+            if(input$set){
+                seed <- input$seed
+                set.seed(seed)
+            } else {
+                seed <- sample(100:999, size=1)
+                set.seed(seed)
+            }
+            da <- qldesign(input$size)
+            da$seed <- seed
+            return(da=da)
+        })
+        
+        output$plotRes <- renderPlot({
+            da <- do()
+            colr <- brewer.pal(9, "Set1")
+            colr <- colorRampPalette(colr, space="rgb")
+            
+            levelplot(trat~lin+col, data=da$D, aspect=1,
+                      colorkey=FALSE,
+                      xlab="Linha", ylab="Coluna",
+                      col.regions=colr,
+                      panel=function(x, y, z, ...){
+                          panel.levelplot(x=x, y=y, z=z, ...)
+                          panel.text(x=x, y=y, labels=LETTERS[z])
+                      })
+            })
+        
+        output$downloadData <- downloadHandler(
+            filename=function(){ 
+                paste("dql", input$size, "-", do()$seed,".txt", sep="") 
+            },
+            content=function(file) {
+                write.table(x=do()$D, file=file,
+                            quote=FALSE, row.names=FALSE,
+                            sep="\t")
+            }
+        )
+    })

shiny/deliQuadLat/ui.R

+##-------------------------------------------
+## ui.R
+
+library(shiny)
+
+shinyUI(
+    fluidPage(
+        ## Cabeçalho IGUIR2
+        htmlOutput("header"),
+
+        titlePanel("Delineamento Quadrado Latino"),
+        sidebarLayout(
+            sidebarPanel(
+                numericInput(inputId="size",
+                             label="Tamanho do Quadrado Latino:",
+                             min=4, max=20,
+                             step=1, value=5),
+                checkboxInput(inputId="set", label="Fixar semente."),
+                uiOutput("ui"),
+                downloadButton("downloadData", "Download")
+            ),
+            mainPanel(
+                plotOutput("plotRes")
+            )
+        )
+    )
+)

shiny/distProb/server.R

+##-------------------------------------------
+## server.R
+
+require(shiny)
+## Carrega template das aplicações elaboradas pelo projeto iguiR2
+source("../template.R")
+
+shinyServer(
+    function(input, output){
+        ## Cabeçalho IGUIR2
+        output$header <- renderPrint({
+            template("TEMA")
+        })
+        output$ui <- renderUI({
+            if(is.null(input$dist)){
+                return()}
+            switch(input$dist,
+                   "poisson"={
+                       output$plot <- renderPlot({
+                           x <- 0:30
+                           px <- dpois(x, lambda=input$poissonLambda)
+                           plot(x, px, type="h", xlab="x", ylab="Pr(x)")
+                       })
+                       wellPanel(
+                           sliderInput(inputId="poissonLambda",
+                                       label="Média da Poisson",
+                                       min=0.1, max=20, value=10)
+                           )
+                   },
+                   
+                   "binomial"={
+                       output$plot <- renderPlot({
+                           x <- 0:input$binomialSize
+                           px <- dbinom(x, size=input$binomialSize,
+                                        prob=input$binomialProb)
+                           plot(x, px, type="h", xlab="x", ylab="Pr(x)")
+                       })
+                       wellPanel(
+                           sliderInput(inputId="binomialSize",
+                                       "Número de ensaios",
+                                       min=0, max=30, value=10, step=1),
+                           sliderInput(inputId="binomialProb",
+                                       label="Probabilidade de sucesso",
+                                       min=0.02, max=0.98,
+                                       value=0.5, step=0.02)
+                           
+                       )
+                   },
+
+                   "beta"={
+                       output$plot <- renderPlot({
+                           curve(dbeta(x,
+                                       shape1=input$betaShape1,
+                                       shape2=input$betaShape2),
+                                 from=0, to=1,
+                                 xlab="x", ylab="f(x)")
+                       })
+                       wellPanel(
+                           sliderInput(inputId="betaShape1",
+                                       label="Parâmetro de forma 1",
+                                       min=0.01, max=7, value=1, step=0.1),
+                           sliderInput(inputId="betaShape2",
+                                       label="Parâmetro de forma 2",
+                                       min=0.01, max=7, value=1, step=0.1)
+                       )
+                   },
+                   
+                   "gamma"={
+                       output$plot <- renderPlot({
+                           curve(dgamma(x,
+                                       shape=input$gammaShape,
+                                       rate=input$gammaRate),
+                                 from=0, to=20,
+                                 xlab="x", ylab="f(x)")
+                       })
+                       wellPanel(
+                           sliderInput(inputId="gammaShape",
+                                       label="Parâmetro de forma",
+                                       min=0.01, max=7, value=1, step=0.1),
+                           sliderInput(inputId="gammaRate",
+                                       label="Parâmetro de taxa",
+                                       min=0.01, max=7, value=1, step=0.1)
+                       )
+                   },
+                   
+                   "normal"={
+                       output$plot <- renderPlot({
+                           curve(dnorm(x,
+                                       mean=input$normalMean,
+                                       sd=input$normalSd),
+                                 from=-3, to=3,
+                                 xlab="x", ylab="f(x)")
+                       })
+                       wellPanel(
+                           sliderInput(inputId="normalMean",
+                                       label="Média da normal",
+                                       min=-3, max=3, value=0, step=0.05),
+                           sliderInput(inputId="normalSd",
+                                       label="Desvio-padrão da normal",
+                                       min=0.1, max=3, value=1, step=0.05)
+                           )
+                   }
+            )
+        })
+    })

shiny/distProb/ui.R

+##-------------------------------------------
+## ui.R
+
+require(shiny)
+
+choi <- c("Poisson"="poisson",
+          "Binomial"="binomial",
+          "Beta"="beta",
+          "Gamma"="gamma",
+          "Normal"="normal")
+
+shinyUI(
+    fluidPage(
+        ## Cabeçalho IGUIR2
+        htmlOutput("header"),
+
+        titlePanel("Distribuições de probabilidade"),
+        sidebarPanel(
+            selectInput(inputId="dist",
+                        label="Distribuição",
+                        choices=choi),
+            uiOutput("ui")
+        ),
+        mainPanel(
+            plotOutput("plot")
+        )
+    )
+)
\ No newline at end of file

shiny/fastCalc/server.R

+##-------------------------------------------
+## server.R
+
+## FUNCIONA LOCALMENTE MAS NÃO DÁ CERTO QUANDO MANDA PARA SERVIDORA. ALGO ESQUISITO.
+
+require(shiny)
+## Carrega template das aplicações elaboradas pelo projeto iguiR2
+source("../template.R")
+
+## Número de alternativas.
+nalter <- 4
+
+## Hora do acesso.
+tm0 <- Sys.time()
+tm <- tm0
+
+## Remove arquivo de log para criar um novo.
+file.remove("log")
+cat("expr; timeDes; correctAnswer; userAnswer", sep="\n", file="log")
+
+shinyServer(
+    function(input, output, clientData, session){
+        ## Cabeçalho IGUIR2
+        output$header <- renderPrint({
+            template("TEMA")
+        })
+        
+        ## Responde a estímulos no `input$goButton`.
+        do <- reactive({
+            input$goButton
+            smpl <- sample(0:9, size=2)
+            expr <- paste0(smpl[1], " + ", smpl[2], " = ")
+            erros <- sample(c(-1,1), size=nalter-1, replace=TRUE)*sample(1:5, size=nalter-1)
+            answers <- sum(smpl)+c(0, erros)
+            ran <- sample(1:nalter)
+            return(list(expr=expr, choi=answers[ran], correct=answers[1])
+            )
+        })
+        
+        ## Apresenta a expressão.
+        output$expr <- renderText(do()$expr)
+        
+        ## Gera o `radioInput()`. Estímulo do `input$goButton` pelo `do()$choi`.
+        output$uiRadio <- renderUI({
+            return(
+                radioButtons(inputId="radio", 
+                             label="",
+                             choices=do()$choi,
+                             selected=NA,
+                             inline=FALSE)
+            )
+        })
+        
+        ## Executado toda vez que clica no `input$radio`. 
+        ## Não responde ao `input$goButton` porque se usou isolate(do()$...).
+        results <- reactive({
+            tm <<- c(Sys.time(), tm) ## Informação do instante.
+            ## Diferença de tempo só deve aparecer depois de escolher resposta.
+            d <- 0
+            if(!is.null(input$radio)){
+                d <- as.numeric(diff(tm[2:1])) ## Diferença entre ações.
+            }
+            iscerto <- isolate(do()$correct)==as.integer(isolate(input$radio))
+            td <- sprintf("Tempo de decisão: %0.3f", d)
+            rc <- paste("Resposta correta: ", ifelse(iscerto, "SIM", "NÃO"))
+            return(list(td=td,
+                        rc=rc,
+                        d=d,
+                        expr=isolate(do()$expr),
+                        corAns=isolate(do()$correct),
+                        userAns=input$radio
+                        )
+            )
+        })
+        
+        ## Vínculado ao `input$radio`.
+        output$result <- renderPrint({
+            ## Print para usuário.
+            cat(results()$td, "\n", results()$rc, sep="")
+            ## cat(results()$rc)
+        })
+        
+        ## Executado toda vez que clica no botão `input$goButton`.
+        ## Não depende do `input$radio` por causa do isolate(results()$...).
+        observe({
+            input$goButton
+            cat(paste(
+                isolate(results()$expr),    ## Expressão.
+                isolate(results()$d),       ## Tempo para decisão.
+                isolate(results()$corAns),  ## Resposta correta.
+                isolate(results()$userAns), ## Resposta marcada.
+                sep="; "),
+                sep="\n",
+                file="log",
+                append=TRUE)
+        })
+        
+        ## Sensível ao `input$goResults` apenas.
+        output$plotRes <- renderPlot({
+            input$goResults
+            da <- read.table(file="log", sep=";", header=TRUE)
+            if(nrow(da)>1){
+                da <- na.omit(da)
+                n <- nrow(da)
+                y <- as.integer(da$userAnswer==da$correctAnswer)
+                x <- da$time
+                plot(density(x),
+                     xlab="Tempo para decisão (s)",
+                     ylab="Densidade",
+                     main=NA,
+                     sub=NA)
+                yr <- 0.05*diff(range(par()$usr[3:4]))
+                points(x, y*yr, col=y+1)
+                m <- mean(x, na.rm=TRUE)
+                p <- sum(y)/nrow(da)
+                abline(v=m, lty=2)
+                mtext(side=3, line=2,
+                      text=sprintf("Tempo médio de decisão: %0.3f segundos", m))
+                mtext(side=3, line=1,
+                      text=sprintf("Proporção de acertos: %0.2f%s", 100*p, "%"))
+            }
+        })
+    })

shiny/fastCalc/ui.R

+##-------------------------------------------
+## ui.R
+
+library(shiny)
+
+shinyUI(
+    fluidPage(
+        ## Cabeçalho IGUIR2
+        htmlOutput("header"),
+
+        titlePanel("Seja rápido!"),
+        sidebarLayout(
+            sidebarPanel(
+                h5("Qual o resultado da soma?"),
+                textOutput("expr"),
+                uiOutput("uiRadio"),
+                actionButton(inputId="goButton", label="Novo!"),
+                hr(),
+                actionButton(inputId="goResults", label="Resultados!")
+            ),
+            mainPanel(
+                verbatimTextOutput("result"),
+                plotOutput("plotRes")
+            )
+        )
+    )
+)

shiny/regex/server.R

+##-------------------------------------------
+## server.R
+
+require(shiny)
+## Carrega template das aplicações elaboradas pelo projeto iguiR2
+source("../template.R")
+
+shinyServer(
+    function(input, output){
+        ## Cabeçalho IGUIR2
+        output$header <- renderPrint({
+            template("TEMA")
+        })
+        output$ui <- renderUI({
+            switch(input$regexjob,
+                   "grepl"={
+                       output$text <- renderText({
+                           grepl(x=as.character(input$string),
+                                 pattern=as.character(input$pattern))
+                       })
+                       wellPanel(
+                           textInput(inputId="string",
+                                     label="Termo:"),
+                           textInput(inputId="pattern",
+                                     label="Padrão REGEX:")
+                       )
+                   },
+                   "gsub"={
+                       output$text <- renderText({
+                           gsub(x=as.character(input$string),
+                                pattern=as.character(input$pattern),
+                                replacement=as.character(input$replacement))
+                       })
+                       wellPanel(
+                           textInput(inputId="string",
+                                     label="Termo:"),
+                           textInput(inputId="pattern",
+                                     label="Padrão REGEX de busca:"),
+                           textInput(inputId="replacement",
+                                     label="Padrão REGEX de substituição:")
+                       )
+                   }
+            )
+        })
+    })

shiny/regex/ui.R

+##-------------------------------------------
+## ui.R
+
+library(shiny)
+
+choi <- c("Construção e ajuste"="grepl",
+          "Procura e substituição"="gsub")
+
+shinyUI(
+    fluidPage(
+        ## Cabeçalho IGUIR2
+        htmlOutput("header"),
+
+        titlePanel("Construidor de expressões regulares"),
+        sidebarPanel(
+            radioButtons(inputId="regexjob",
+                        label="Uso de expressão regular",
+                        choices=choi),
+            uiOutput("ui")
+        ),
+        mainPanel(
+            textOutput("text")
+        )
+    )
+)
\ No newline at end of file

shiny/teoLimCentral/server.R

+##-------------------------------------------
+## server.R
+
+require(shiny)
+## Carrega template das aplicações elaboradas pelo projeto iguiR2
+source("../template.R")
+require(latticeExtra)
+
+rm(list=ls())
+
+N <- 500
+n <- c(1,2,3,5,10,20)
+da <- data.frame(tam=rep(n, each=N))
+
+panel.dens <- function(x, ...){
+    panel.densityplot(x, ...)
+    m <- mean(x)
+    s <- sd(x)
+    panel.mathdensity(dmath=dnorm, col="blue",
+                      args=list(mean=m, sd=s)) 
+}
+
+panel.fa <- function(x, ...){
+    panel.ecdfplot(x, ...)
+    m <- mean(x)
+    s <- sd(x)
+    xx <- seq(min(x), max(x), length.out=20)
+    panel.lines(xx, pnorm(xx, m, s), col="blue")
+}
+
+# y <- runif(1000)
+# ecdfplot(~y,
+#          data=da, as.table=TRUE,
+#          xlab=expression(bar(X)),
+#          ylab="Frequêcia acumulada",
+#          panel=panel.fa)
+
+shinyServer(
+    function(input, output){
+        ## Cabeçalho IGUIR2
+        output$header <- renderPrint({
+            template("TEMA")
+        })
+        output$distBarX <- renderPlot({
+            ## Define a distribuiação de probabilidade de X.
+            barX <- switch(input$distX,
+                          UD5=function(ni){
+                              mean(sample(1:5, size=ni, replace=TRUE))
+                          },
+                          U01=function(ni){
+                              mean(runif(ni, min=0, max=1))
+                          },
+                          N01=function(ni){
+                              mean(rnorm(ni, mean=0, sd=1))
+                          },
+                          E1=function(ni){
+                              mean(rexp(ni, rate=1))
+                          },
+                          Poi5=function(ni){
+                              mean(rpois(ni, lambda=5))
+                          },
+                          BetaA=function(ni){
+                              mean(rbeta(ni, shape1=0.5, shape2=0.5))
+                          }
+            )
+            ## Obtém a distribuição de bar(X).
+            da$barx <- 
+                do.call(c, lapply(as.list(n),
+                                  function(ni){
+                                      replicate(N, {
+                                          barX(ni)
+                                      })
+                                  }))
+            ## Define parâmetros gráficos.
+            trellis.par.set(list(
+                grid.pars=list(fontfamily="palatino"),
+                strip.background=list(col="gray70"),
+                plot.line=list(col=1),
+                plot.symbol=list(col=1))
+            )
+            ## Representa a distribuição de probabilidades.
+            p <- switch(input$plotType,
+                        dens=densityplot(~barx|factor(tam),
+                                         data=da, as.table=TRUE,
+                                         xlab=expression(bar(X)),
+                                         ylab="Densidade",
+                                         panel=panel.dens),
+                        ecdf=ecdfplot(~barx|factor(tam),
+                                      data=da, as.table=TRUE,
+                                      xlab=expression(bar(X)),
+                                      ylab="Frequêcia acumulada",
+                                      panel=panel.fa)
+            )
+            return(print(p))
+        })
+    })

shiny/teoLimCentral/ui.R

+##-------------------------------------------
+## ui.R
+
+require(shiny)
+
+distX <- c("Uniforme discreta (5)"="UD5",
+           "Uniforme Contínua (0,1)"="U01",
+           "Exponencial (1)"="E1",
+           "Poisson (5)"="Poi5",
+           "Normal (0,1)"="N01",
+           "Beta (0.5, 0.5)"="BetaA")
+plotType <- c("Densidade empírica"="dens",
+              "Frequência acumulada"="ecdf")
+
+shinyUI(
+    fluidPage(
+        ## Cabeçalho IGUIR2
+        htmlOutput("header"),
+
+        headerPanel("Distribuição amostral da média"),
+        h4("Explore a convergência da distribuição amostral da média com as opções abaixo."),
+        hr(),
+        sidebarPanel(
+            radioButtons(inputId="distX",
+                         label="Distribuição de X:",
+                         choices=distX),
+            radioButtons(inputId="plotType",
+                         label="Representação da distribuição amostral:",
+                         choices=plotType)
+        ),
+        mainPanel(
+            plotOutput("distBarX", width=500, height=400)
+        )
+    ))

shiny/testHipFlipCoin/server.R

+##-------------------------------------------
+## server.R
+
+require(shiny)
+## Carrega template das aplicações elaboradas pelo projeto iguiR2
+source("../template.R")
+
+rm(list=ls())
+
+## Simula o número de trocas ao lançar n vezes uma moeda equilibrada.
+moeda <- function(n){
+    sum(abs(diff(rbinom(n, 1, 0.5))))
+}
+
+## Vetor vazio.
+x <- integer()
+N <- 1000
+
+shinyServer(
+    function(input, output){
+        ## Cabeçalho IGUIR2
+        output$header <- renderPrint({
+            template("TEMA")
+        })
+        #         cara <- eventReactive(input$goCara, {
+        #             x <<- c(x, 1L)
+        #         })
+        #         coro <- eventReactive(input$goCoro, {
+        #             x <<- c(x, 0L)
+        #         })
+        #         output$nlanc <- renderText({
+        #             coro(); cara()
+        #             return(length(x))
+        #         })
+        cara <- reactive({
+            input$goCara
+            x <<- c(x, 1L)
+        })
+        coro <- reactive({
+            input$goCoro
+            x <<- c(x, 0L)
+        })
+        ## x começa com dois elementos. Descontá-los.
+        output$nlanc <- renderText({
+            coro(); cara()
+            return(length(x)-2)
+        })
+        process <- eventReactive(input$goProcess, {
+            x <- x[-c(1:2)]
+            ## Número de lançamentos.
+            n <- length(x)
+            ## Número de caras.
+            k <- sum(x)
+            ## Número de trocas de face.
+            o <- sum(abs(diff(x)))
+            ## Faz várias execuções do experimento aleatório.
+            r <- replicate(N, moeda(n))
+            ## P-valor bilateral empírico.
+            p <- min(c(2*min(c(sum(r<=o), sum(r>=o)))/N, 1))
+            ## Lista com todos os elementos.
+            return(list(n=n, k=k, o=o, r=r, p=p, x=x))
+        })
+        output$seqx <- renderText({
+            s <- paste0(process()$x, collapse="")
+            return(s)
+        })
+        output$hist <- renderPlot({
+            with(process(),{
+                if(n<=9){
+                    stop("Pro favor, lance no mínimo 30 vezes.")
+                }
+                par(mar=c(5,4,3,2), family="Palatino")
+                layout(matrix(c(1,2,1,3), 2, 2))
+                bks <- seq(min(c(r,o)), max(c(r,o))+1, by=1)-0.5
+                ht <- hist(r, breaks=bks, plot=FALSE)
+                plot(ht$mids, ht$density, type="h", lwd=2,
+                     ylim=c(0, 1.05*max(ht$density)),
+                     xlab=sprintf("Número de trocas em %i lançamentos", n),
+                     ylab="Probabilidade",
+                     sub=sprintf("%i simulações", N))
+                if(input$teorico){
+                    px <- dbinom(x=ht$mids, size=n-1, prob=0.5)
+                    points(ht$mids+0.1, px, type="h", col="blue")
+                    pb <- 2*pbinom(q=min(c(o, n-o-1)), size=n-1, p=0.5)
+                    mtext(side=3, line=0, col="blue",
+                          text=sprintf("P-valor bilateral teórico: %0.4f", pb))
+                }
+                abline(v=o, col=2)
+                text(x=o, y=par()$usr[4],
+                     label="Estatística observada",
+                     srt=90, adj=c(1.25,-0.25))
+                mtext(side=3, line=1,
+                      text=sprintf("P-valor bilateral empírico: %0.4f", p))
+                mtext(side=3, line=2,
+                      text=sprintf(
+                          "Trocas observadas: %i\t Número de caras: %i",
+                          o, k))
+                plot(cumsum(x)/seq_along(x), type="l", ylim=c(0,1),
+                     ylab="Frequência de face cara",
+                     xlab="Número do lançamento")
+                abline(h=0.5, lty=2)
+                plot(ecdf(r), verticals=TRUE, cex=NA,
+                     main=NULL, xlim=range(bks),
+                     xlab=sprintf("Número de trocas em %i lançamentos", n),
+                     ylab="Probabilidade acumulada",
+                     sub=sprintf("%i simulações", N))
+                abline(h=seq(0.05, 0.95, by=0.05), lty=2, col="gray50")
+                abline(v=o, col=2)
+                text(x=o, y=par()$usr[4],
+                     label="Estatística observada",
+                     srt=90, adj=c(1.25,-0.25))
+            })
+        })
+    })

shiny/testHipFlipCoin/ui.R

+##-------------------------------------------
+## ui.R
+
+require(shiny)
+
+txt <- 
+"Você consegue criar uma sequência de caras e coroas tão aleatória e com as
+mesmas características propabilísticas de uma moeda equilibrada? Que tal
+testarmos essa hipótese?"
+
+shinyUI(
+    fluidPage(
+        ## Cabeçalho IGUIR2
+        htmlOutput("header"),
+
+        headerPanel("Introdução aos testes de hipótese"),
+        h4("Você consegue imitar uma moeda?"),
+        p(txt),
+        hr(),
+        sidebarPanel(
+            helpText("Clique nos botões para declarar cara ou coroa."),
+            actionButton("goCara", "Cara"),
+            actionButton("goCoro", "Coroa"),
+            h6("Número de lançamentos feitos:"),
+            verbatimTextOutput("nlanc"),
+            actionButton("goProcess", "Aplicar teste de hipótese!"),
+            h6("Sequência das faces observadas (1=cara, 0=coroa):"),
+            verbatimTextOutput("seqx"),
+            checkboxInput("teorico", "Valores teóricos: Binomial(n-1, p=0.5)")
+        ),
+        mainPanel(
+            plotOutput("hist", width=500, height=500)
+        )
+    ))