diff --git a/shiny/deliQuadLat/server.R b/shiny/deliQuadLat/server.R
new file mode 100644
index 0000000000000000000000000000000000000000..3ad9bc26326246fdd307fc3737cb9991b01fa658
--- /dev/null
+++ b/shiny/deliQuadLat/server.R
@@ -0,0 +1,95 @@
+##-------------------------------------------
+## 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")
+ }
+ )
+ })
diff --git a/shiny/deliQuadLat/ui.R b/shiny/deliQuadLat/ui.R
new file mode 100644
index 0000000000000000000000000000000000000000..1166e25e0d3980bdbe9df60fdd4898d1297731f2
--- /dev/null
+++ b/shiny/deliQuadLat/ui.R
@@ -0,0 +1,27 @@
+##-------------------------------------------
+## 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")
+ )
+ )
+ )
+)
diff --git a/shiny/distProb/server.R b/shiny/distProb/server.R
new file mode 100644
index 0000000000000000000000000000000000000000..27e24c2d348d0e0b240be493bc2a97f3e5f65955
--- /dev/null
+++ b/shiny/distProb/server.R
@@ -0,0 +1,105 @@
+##-------------------------------------------
+## 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)
+ )
+ }
+ )
+ })
+ })
diff --git a/shiny/distProb/ui.R b/shiny/distProb/ui.R
new file mode 100644
index 0000000000000000000000000000000000000000..fcdabb6f3141404cb478be7975e1bd38bb88cc40
--- /dev/null
+++ b/shiny/distProb/ui.R
@@ -0,0 +1,28 @@
+##-------------------------------------------
+## 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
diff --git a/shiny/fastCalc/server.R b/shiny/fastCalc/server.R
new file mode 100644
index 0000000000000000000000000000000000000000..7a4178c9f8f8994fb76d3d59ac85097b882348db
--- /dev/null
+++ b/shiny/fastCalc/server.R
@@ -0,0 +1,123 @@
+##-------------------------------------------
+## 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, "%"))
+ }
+ })
+ })
diff --git a/shiny/fastCalc/ui.R b/shiny/fastCalc/ui.R
new file mode 100644
index 0000000000000000000000000000000000000000..a9a464757ec2d64d49b3d85fa1f809d63ac875a3
--- /dev/null
+++ b/shiny/fastCalc/ui.R
@@ -0,0 +1,27 @@
+##-------------------------------------------
+## 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")
+ )
+ )
+ )
+)
diff --git a/shiny/regex/server.R b/shiny/regex/server.R
new file mode 100644
index 0000000000000000000000000000000000000000..aa46a0597aa78e6967635f0d1434f8e9d04c410b
--- /dev/null
+++ b/shiny/regex/server.R
@@ -0,0 +1,45 @@
+##-------------------------------------------
+## 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:")
+ )
+ }
+ )
+ })
+ })
diff --git a/shiny/regex/ui.R b/shiny/regex/ui.R
new file mode 100644
index 0000000000000000000000000000000000000000..bd1e8d4f198033d033e7af04cfa8e63c466eec79
--- /dev/null
+++ b/shiny/regex/ui.R
@@ -0,0 +1,25 @@
+##-------------------------------------------
+## 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
diff --git a/shiny/teoLimCentral/server.R b/shiny/teoLimCentral/server.R
new file mode 100644
index 0000000000000000000000000000000000000000..25fa43e720051344bfed7c733effcb263176d693
--- /dev/null
+++ b/shiny/teoLimCentral/server.R
@@ -0,0 +1,96 @@
+##-------------------------------------------
+## 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))
+ })
+ })
diff --git a/shiny/teoLimCentral/ui.R b/shiny/teoLimCentral/ui.R
new file mode 100644
index 0000000000000000000000000000000000000000..c008fa185606bc35c73f283cadea8a7f80cbbf58
--- /dev/null
+++ b/shiny/teoLimCentral/ui.R
@@ -0,0 +1,34 @@
+##-------------------------------------------
+## 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)
+ )
+ ))
diff --git a/shiny/testHipFlipCoin/server.R b/shiny/testHipFlipCoin/server.R
new file mode 100644
index 0000000000000000000000000000000000000000..bbf142a8b74a4aaa77d0042d403a026c08017357
--- /dev/null
+++ b/shiny/testHipFlipCoin/server.R
@@ -0,0 +1,114 @@
+##-------------------------------------------
+## 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))
+ })
+ })
+ })
diff --git a/shiny/testHipFlipCoin/ui.R b/shiny/testHipFlipCoin/ui.R
new file mode 100644
index 0000000000000000000000000000000000000000..be8f9903b8c77fd55dc5ed2e4cdebb8384d4714e
--- /dev/null
+++ b/shiny/testHipFlipCoin/ui.R
@@ -0,0 +1,34 @@
+##-------------------------------------------
+## 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)
+ )
+ ))