cat2.Rmd

---
title: "Catálogo de Modelos de Regressão Não Linear"
output:  
  flexdashboard::flex_dashboard:
    theme: yeti
    background: white
    orientation: rows
    vertical_layout: scroll
    social: [ "github", "facebook", "menu" ]
    links: ["https://meulink/about"]
    source_code: embed
    runtime: shiny
runtime: shiny
---

```{r setup, include=FALSE}
library(flexdashboard)
library(shiny) 
library(shinydashboard)
library(markdown)
library(knitr)
```


Introdução {data-orientation=columns}
=======================================================================
Column {data-height=950, data-width=650}
------------------------------------------------------------------------

### Autores: {data-commentary-width=400}

[Bruna Wundervald](https://gitlab.c3sl.ufpr.br/u/bdw13),
PET- Estatística UFPR  

[Walmes Zeviani](https://gitlab.c3sl.ufpr.br/u/walmes),
Professor Doutor do Departamento de Estatística da UFPR  




### Descrição do projeto

Este projeto tem como objetivo apresentar um catálogo interativo de modelos não 
lineares. A ideia principal do catálogo é possibilitar ao usu?rio escolher qual 
modelo melhor se aplica aos seus dados. Isso se dá facilmente pois ele apresenta
formas de manipulação e visualização destes modelos (gráficos), com a 
possibilidade de alteração interativa de seus parâmetros. Foram utilizados 
o software R, e o Shiny. Todo o conteúdo é disponibilizado *online*.  

O projeto está sendo desenvolvido no [GitLab do C3SL](https://gitlab.c3sl.ufpr.br/)
(Centro de Computação Científica e Software Livre), da Universidade Federal
do Paraná. Sugestões de implementação, comentários e contribuições são bem vindas. 

Sidebar {.sidebar data-width=350}
----------------------------------------------
### Lista de Modelos 
 - [Michaelis-Menten](#Michaelis-Menten)
 - [Michaelis-Menten Reparametrizado](#Michaelis-Menten-Reparametrizado) 
 - [Extensão do Michaelis-Menten](#Extensão-do-Michaelis-Menten) 
 - [Modificação do Modelo Anterior](#Modificação-do-Modelo-Anterior) 
 - [Outra Extensão do Michaelis-Menten](#Outra-Extensão-do-Michaelis-Menten) 
 - [Exponencial Assintótico](#Exponencial-Assintótico)
 - [Exponencial Assintótico Reparametrizado](#Exponencial-Assintótico-Reparametrizado) 
 - [Mitscherlich](#Mitscherlich)
 - [Mitscherlich Reparametrizado](#Mitscherlich-Reparametrizado) 
 - [Herschel-Bulkley](#Herschel-Bulkley)
 - [Herschel-Bulkley Reparametrizado](#Herschel-Bulkley-Reparametrizado) 
-  [Ratkowsky](#Ratkowsky)
 - [Modelo de Ratkowsky Reparametrizado](#Ratkowsky-Reparametrizado) 
 - [Linear-Platô](#Linear-Platô)
 - [Linear-Platô Reparametrizado](#Linear-Platô-Reparametrizado) 
 - [Bi-linear segmentado](#Bi-linear-segmentado)
 - [Bi-linear segmentado Reparametrizado](#Bi-linear-segmentado-Reparametrizado) 
 - [Polinômio de segundo grau](#Polinômio-de-segundo-grau)
 - [Polinômio de segundo grau Reparametrizado](#Polinômio-de-segundo-grau-Reparametrizado) 
 - [Quadrático-Platô](#Quadrático-Platô)
 - [Quadrático-Platô Reparametrizado](#Quadrático-Platô-Reparametrizado) 
 - [Bleasdale-Nelder](#Bleasdale-Nelder)
 - [Bleasdale-Nelder Reparametrizado](#Bleasdale-Nelder-Reparametrizado) 
 - [Gama Incompleto](#Gama-Incompleto)
 - [Gama Incompleto Reparametrizado](#Gama-Incompleto-Reparametrizado) 
 - [Logístico](#Logístico)
 - [Logístico Reparametrizado](#Logístico-Reparametrizado) 
 - [Gompertz](#Gompertz)
 - [Gompertz Reparametrizado](#Gompertz-Reparametrizado) 
 - [Van Genutchen](#Van-Genutchen)
 - [Van Genutchen Reparametrizado](#Van-Genutchen-Reparametrizado) 


Michaelis-Menten {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
# Model 1
                       sliderInput("thetaA_1",
                                   HTML("$$ \\theta_a $$"),
                                   min = -10,
                                   max = 10,
                                   value = 2)
                       sliderInput("thetaV_1",
                                   HTML("$$ \\theta_v $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
```


Row {.tabset, data-width=600}
-----------------------------------------------------------------------
### Gráfico

```{r, fig.align='center'}
## Model 1
  mForm1 <- as.formula("Y ~ (thetaA_1 * x)/(thetaV_1  + x)")
  mExpr1 <- mForm1[[3]] 
  
    output$Curve1 <- renderPlot({
    thetaA_1 <- input$thetaA_1
    thetaV_1 <- input$thetaV_1
    

    eval(call("curve", mExpr1, col = 2, ylab = "", main =
                expression(frac(theta[a]*x, theta[v] + x))))
  },  height = 465, width = 650)

 plotOutput("Curve1")

```

Row {data-height=85}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_a <- reactive({
  input$thetaA_1
}) 

t_v <- reactive({
  input$thetaV_1
}) 
```

  - $\theta_a=$ `r t_a`
  - $\theta_v=$ `r t_v`


Michaelis-Menten Reparametrizado {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
# Model 2
                       sliderInput("thetaA_2",
                                   HTML("$$ \\theta_a $$"),
                                   min = -10,
                                   max = 10,
                                   value = 2)
                       sliderInput("vthetaQ_2",
                                   HTML("$$ \\vartheta_q $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
                       sliderInput("q_2",
                                   HTML("$$ q $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico

```{r, fig.align='center'}
## Model 2
  mForm2 <- as.formula("Y ~ (thetaA_2 * x)/((vthetaQ_2 * ((1 - q_2)/q_2)) + x)")
  mExpr2 <- mForm2[[3]] 
    
    output$Curve2 <- renderPlot({
    thetaA_2 <- input$thetaA_2
    vthetaQ_2 <- input$vthetaQ_2
    q_2 <- input$q_2
    
    eval(call("curve", mExpr2, col = 2, ylab = "", main =
                expression(frac(theta[a]*x, vartheta[q]*(frac(1-q, q)) + x))))
  },  height = 465, width = 650)

 plotOutput("Curve2")

```

Row {data-height=110}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_a2 <- reactive({
  input$thetaA_2
}) 

t_q2 <- reactive({
  input$vthetaQ_2
}) 

q2 <- reactive({
  input$q_2
}) 
```
  - $\theta_a=$ `r t_a2`
  - $\vartheta_q=$ `r t_q2`
  - $q=$ `r q2`


Extensão do Michaelis-Menten {data-navmenu="Modelos"}
=======================================================================

Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 3
                       sliderInput("thetaA_3",
                                   HTML("$$ \\theta_a $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("vthetaQ_3",
                                   HTML("$$ \\vartheta_q $$"), 
                                   min = 1,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("q_3",
                                   HTML("$$ q $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
                       sliderInput("thetaC_3",
                                   HTML("$$ \\theta_c $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
```



Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
# Model 3
mForm3 <- as.formula("Y ~ thetaA_3/(1 + ((vthetaQ_3/x) * ((1 - q_3)/q_3)) ^ thetaC_3)")
mExpr3 <- mForm3[[3]]

output$Curve3 <- renderPlot({
  thetaA_3 <- input$thetaA_3
  vthetaQ_3 <- input$vthetaQ_3
  q_3 <- input$q_3
  thetaC_3 <- input$thetaC_3
  
  eval(call("curve", mExpr3, col = 2, ylab = "", main =
              expression(frac(theta[a], 1 + 
                                frac(1-q, q)*(frac(vartheta[q], x))^theta[c]))))
},  height = 400, width = 600)

plotOutput("Curve3")

```

Row {data-height=130}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_a3 <- reactive({
  input$thetaA_3
}) 

vt_q3 <- reactive({
  input$vthetaQ_3
}) 

q3 <- reactive({
  input$q_3
}) 

t_c3 <- reactive({
  input$thetaC_3
}) 
```

  - $\theta_a=$ `r t_a3`
  - $\vartheta_q=$ `r vt_q3`
  - $q=$ `r q3`
  - $\theta_c=$ `r t_c3`

Modificação do Modelo Anterior {data-navmenu="Modelos"}
=======================================================================

Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 4
                       sliderInput("thetaA_4",
                                   HTML("$$ \\theta_a $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("vthetaQ_4",
                                   HTML("$$ \\vartheta_q $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
                       sliderInput("q_4",
                                   HTML("$$ q $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
                       sliderInput("thetaC_4",
                                   HTML("$$ \\theta_c $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
```



Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
# Model 4
mForm4 <- as.formula("Y ~ thetaA_4/(1 + ((x/vthetaQ_4)*((1 - q_4)/q_4)) ^ thetaC_4)")
mExpr4 <- mForm4[[3]]

output$Curve4 <- renderPlot({
  thetaA_4 <- input$thetaA_4
  vthetaQ_4 <- input$vthetaQ_4
  q_4 <- input$q_4
  thetaC_4 <- input$thetaC_4
  
  eval(call("curve", mExpr4, col = 2, ylab = "", main =
              expression(frac(theta[a], 1 + 
                                frac(1-q, q)*(frac(x, vartheta[q]))^theta[c]))))
},  height = 400, width = 600)

plotOutput("Curve4")
```

Row {data-height=130}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_a4 <- reactive({
  input$thetaA_4
}) 

vt_q4 <- reactive({
  input$vthetaQ_4
}) 

q4 <- reactive({
  input$q_4
}) 

t_c4 <- reactive({
  input$thetaC_4
}) 
```

  - $\theta_a=$ `r t_a4`
  - $\vartheta_q=$ `r vt_q4`
  - $q=$ `r q4`
  - $\theta_c=$ `r t_c4`


Outra Extensão do Michaelis-Menten {data-navmenu="Modelos"}
=======================================================================

Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 5
                       sliderInput("thetaA_5",
                                   HTML("$$ \\theta_a $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("vthetaQ_5",
                                   HTML("$$ \\vartheta_q $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
                       sliderInput("q_5",
                                   HTML("$$ q $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
                       sliderInput("thetaC_5",
                                   HTML("$$ \\theta_c $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
```



Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
# Model 5
mForm5 <- as.formula("Y ~ (thetaA_5 * (x ^ thetaC_5))/(vthetaQ_5 * 
                ((1 - q_5)/q_5) + x ^ thetaC_5)")
mExpr5 <- mForm5[[3]]

output$Curve5 <- renderPlot({
  thetaA_5 <- input$thetaA_5
  vthetaQ_5 <- input$vthetaQ_5
  q_5 <- input$q_5
  thetaC_5 <- input$thetaC_5
  
  eval(call("curve", mExpr5, col = 2, ylab = "", main =
              expression(frac(theta[a]*x^theta[c],
                              vartheta[q]*(frac(1-q, q)) + x^theta[c]))))
},  height = 400, width = 600)

plotOutput("Curve5")
```


Row {data-height=90}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_a5 <- reactive({
  input$thetaA_5
}) 

vt_q5 <- reactive({
  input$vthetaQ_5
}) 

q5 <- reactive({
  input$q_5
}) 

t_c5 <- reactive({
  input$thetaC_5
}) 
```

  - $\theta_a=$ `r t_a5`
  - $\vartheta_q=$ `r vt_q5`
  - $q=$ `r q5`
  - $\theta_c=$ `r t_c5`



Exponencial Assintótico {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 6
                       sliderInput("thetaA_6",
                                   HTML("$$ \\theta_a $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("thetaC_6",
                                   HTML("$$ \\theta_0 $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
```



Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
# Model 6
mForm6 <- as.formula("Y ~ thetaA_6 * (1 - exp(-thetaC_6 *x))")
                     
mExpr6 <- mForm6[[3]]

output$Curve6 <- renderPlot({
  thetaC_6 <- input$thetaC_6
  thetaA_6 <- input$thetaA_6
  
eval(call("curve", mExpr6, from = 0, to = 10, col = 2, ylab = "", 
      main = expression(theta[a] * (1 - exp(-theta[c]*x))
                        )))
            
},  height = 400, width = 600)


plotOutput("Curve6")
```

Row {data-height=110}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_c_6 <- reactive({
  input$thetaC_6
}) 

t_a6 <- reactive({
  input$thetaA_6
}) 
```

  - $\theta_c=$ `r t_c_6`
  - $\theta_a=$ `r t_a6`


Exponencial Assintótico Reparametrizado {data-navmenu="Modelos"}
=======================================================================

Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 7
                       sliderInput("thetaA_7",
                                   HTML("$$ \\theta_a $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("vthetaQ_7",
                                   HTML("$$ \\vartheta_q $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
                       sliderInput("q_7",
                                   HTML("$$ q $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
# Model 7
mForm7 <- as.formula("Y ~ thetaA_7 * (1 - exp((x * log(1 - q_7))
                     /vthetaQ_7))")
                     
mExpr7 <- mForm7[[3]]

output$Curve7 <- renderPlot({
  thetaA_7 <- input$thetaA_7
  vthetaQ_7 <- input$vthetaQ_7
  q_7 <- input$q_7
  
  eval(call("curve", mExpr7, col = 2, ylab = "", main =
              expression(theta[a]*(1 - exp(frac(x*log(1-q), vartheta[q]))))
  ))
},  height = 400, width = 600)

plotOutput("Curve7")

```

Row {data-height=130}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
q7 <- reactive({
  input$q_7
}) 

vt_q7 <- reactive({
  input$vthetaQ_7
}) 

t_a7 <- reactive({
  input$thetaA_7
}) 
```

  - $\theta_a=$ `r t_a7`
  - $\vartheta_q=$ `r vt_q7`
  - $q=$ `r q7`
  

Mitscherlich {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 8
                       sliderInput("thetaA_8",
                                   HTML("$$ \\theta_a $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("theta1_8",
                                   HTML("$$ \\theta_1 $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
                       sliderInput("theta0_8",
                                   HTML("$$ \\theta_0 $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
# Model 8
output$Curve8 <- renderPlot({
  theta1_8 <- input$theta1_8
  theta0_8 <- input$theta0_8
  thetaA_8 <- input$thetaA_8
  
    fun_8 <- function(x) { 
    ifelse(test = x >= theta0_8, 
           yes = theta1_8 * (1 - exp(-theta1_8 * (x - 
                     theta0_8))),
           no = 0)}
  
      curve(expr = fun_8, from = 0, to = 10, col = 2, ylab = "", 
        main = expression(theta[1] * (1 - exp(-theta[0] * 
                                              (x - theta[0])))
                        ))
            
},  height = 400, width = 800)


plotOutput("Curve8")
```

Row {data-height=110}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_1_8 <- reactive({
  input$theta1_8
}) 

t_0_8 <- reactive({
  input$theta0_8
}) 

t_a8 <- reactive({
  input$thetaA_8
}) 
```

  - $\theta_1=$ `r t_1_8`
  - $\theta_0=$ `r t_0_8`
  - $\theta_a=$ `r t_a8`
  
  
Reparametrização do Mitscherlich {data-navmenu="Modelos"}
=======================================================================

Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 9
                       sliderInput("thetaA_9",
                                   HTML("$$ \\theta_a $$"),
                                   min = 1,
                                   max = 100,
                                   value = 1)
                       sliderInput("theta0_9",
                                   HTML("$$ \\theta_0 $$"),
                                   min = 1,
                                   max = 100,
                                   value = 1)
                       sliderInput("vthetaQ_9",
                                   HTML("$$ \\vartheta_q $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.05)
                       sliderInput("q_9",
                                   HTML("$$ q $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.05)
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
# Model 9
mForm9 <- as.formula("Y ~ thetaA_9 * (1 - exp((x * log(1 - q_9))*
                      (x-theta0_9)/(vthetaQ_9-theta0_9)))")
                     
mExpr9 <- mForm9[[3]]

output$Curve9 <- renderPlot({
  thetaA_9 <- input$thetaA_9
  theta0_9 <- input$theta0_9
  vthetaQ_9 <- input$vthetaQ_9
  q_9 <- input$q_9
  
  eval(call("curve", mExpr9, col = 2, ylab = "", main =
              expression(theta[a]*
                           (1 - exp(x*log(1-q), 
                                    frac(x-theta[0], 
                                         vartheta[q] - theta[0]))))
  ))
},  height = 400, width = 600)

plotOutput("Curve9")

```

Row {data-height=130}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
q9 <- reactive({
  input$q_9
}) 

vt_q9 <- reactive({
  input$vthetaQ_9
}) 

t_a9 <- reactive({
  input$thetaA_9
}) 

t_0_9 <- reactive({
  input$theta0_9
}) 
```

  - $\theta_a=$ `r t_a9`
  - $\theta_0=$ `r t_0_9`
  - $\vartheta_q=$ `r vt_q9`
  - $q=$ `r q9`
  
  

Herschel-Bulkley {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 10
                       sliderInput("theta0_10",
                                   HTML("$$ \\theta_0 $$"),
                                   min = 1,
                                   max = 100,
                                   value = 1)
                      sliderInput("theta1_10",
                                   HTML("$$ \\theta_1 $$"),
                                   min = 1,
                                   max = 100,
                                   value = 1)
                       sliderInput("theta2_10",
                                   HTML("$$ \\theta_1 $$"),
                                   min = 0,
                                   max = 4,
                                   value = 0.05)
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
mForm10 <- as.formula("Y ~ theta0_10 - theta1_10 * (x ^ theta2_10)")
mExpr10 <- mForm10[[3]]

output$Curve10 <- renderPlot({
  theta1_10 <- input$theta1_10
  theta2_10 <- input$theta2_10
  theta0_10 <- input$theta0_10

  eval(call("curve", mExpr10, col = 2, ylab = "", main =
              expression(theta[0] - theta[1]*(x^theta[2]))
  ))
},  height = 400, width = 600)

plotOutput("Curve10")

```

Row {data-height=130}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_0_10 <- reactive({
  input$theta0_10
})

t_1_10 <- reactive({
  input$theta1_10
}) 

t_2_10 <- reactive({
  input$theta2_10
})

```

  - $\theta_0=$ `r t_0_10`
  - $\theta_1=$ `r t_1_10`
  - $\theta_2=$ `r t_2_10`


Herschel-Bulkley Reparametrizado {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 11
                       sliderInput("theta0_11",
                                   HTML("$$ \\theta_0 $$"),
                                   min = 1,
                                   max = 100,
                                   value = 1)
                      sliderInput("theta1_11",
                                   HTML("$$ \\theta_1 $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.01)
                       sliderInput("q_11",
                                   HTML("$$ q $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.05)
                       sliderInput("vthetaQ_11",
                                   HTML("$$ \\vartheta_q $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.05)
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
mForm11 <- as.formula("Y ~ theta0_11 - theta1_11 * x ^ ((log(q_11) - 
                     log(theta1_11))/vthetaQ_11)")
mExpr11 <- mForm11[[3]]

output$Curve11 <- renderPlot({
  theta1_11 <- input$theta1_11
  theta0_11 <- input$theta0_11
  vthetaQ_11 <- input$vthetaQ_11
  q_11 <- input$q_11
  
  eval(call("curve", mExpr11, col = 2, ylab = "", main =
              expression(theta[0] - theta[1]*x^frac(log(q)-log(theta[1]),
                                                    log(vartheta[q])))
  ))
},  height = 400, width = 600)

plotOutput("Curve11")

```

Row {data-height=130}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_0_11 <- reactive({
  input$theta0_11
})

t_1_11 <- reactive({
  input$theta1_11
}) 

q11 <- reactive({
  input$q_11
})

vt_q11 <- reactive({
  input$vthetaQ_11
}) 
```

  - $\theta_0=$ `r t_0_11`
  - $\theta_1=$ `r t_1_11`
  - $\vartheta_q=$ `r vt_q11`
  - $q=$ `r q11`

Modelo de Ratkowsky {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 12
                       sliderInput("theta0_12",
                                   HTML("$$ \\theta_0 $$"),
                                   min = -5,
                                   max = 5,
                                   value = 0)
                      sliderInput("theta1_12",
                                   HTML("$$ \\theta_0 $$"),
                                   min = 1,
                                   max = 100,
                                   value = 1)
                      sliderInput("thetaC_12",
                                   HTML("$$ \\theta_c $$"),
                                   min = 0,
                                   max = 2,
                                   value = 0.01,
                                  step = 0.01)
                       
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
mForm12 <- as.formula("Y ~ theta0_12 + theta1_12 * (1 - thetaC_12^x)")
mExpr12 <- mForm12[[3]]

output$Curve12 <- renderPlot({
  theta0_12 <- input$theta0_12
  theta1_12 <- input$theta1_12
  thetaC_12 <- input$thetaC_12
  
  eval(call("curve", mExpr12, col = 2, ylab = "", main =
              expression(theta[0] - 
                           q*frac(1-theta[c]^x, 1-theta[c]^vartheta[q]))
            ))
},  height = 400, width = 600)

plotOutput("Curve12")

```
  

Row {data-height=120}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_0_12 <- reactive({
  input$theta0_12
})

t_1_12 <- reactive({
  input$theta1_12
}) 

t_q12 <- reactive({
  input$thetaQ_12
}) 
```

  - $\theta_0=$ `r t_0_12`
  - $\theta_1=$ `r t_1_12`
  - $\theta_q=$ `r t_q12`


Modelo de Ratkowsky Reparametrizado {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 13
                       sliderInput("theta0_13",
                                   HTML("$$ \\theta_0 $$"),
                                   min = 1,
                                   max = 100,
                                   value = 1)
                      sliderInput("thetaC_13",
                                   HTML("$$ \\theta_c $$"),
                                   min = 1,
                                   max = 10,
                                   value = 1,
                                  step = 0.02)
                       sliderInput("q_13",
                                   HTML("$$ q $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.01)
                       sliderInput("vthetaQ_13",
                                   HTML("$$ \\vartheta_q $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.01,
                                   step = 0.01)
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
mForm13 <- as.formula("Y ~ theta0_13 - q_13 * ((1 - thetaC_13 ^ x)/
                      (q_13 - thetaC_13 ^ vthetaQ_13))")
mExpr13 <- mForm13[[3]]

output$Curve13 <- renderPlot({
  theta0_13 <- input$theta0_13
  vthetaQ_13 <- input$vthetaQ_13
  q_13 <- input$q_13
  thetaC_13 <- input$thetaC_13
  
  eval(call("curve", mExpr13, col = 2, ylab = "", main =
              expression(theta[0] - 
                           q*frac(1-theta[c]^x, 1-theta[c]^vartheta[q]))
            ))
},  height = 400, width = 600)

plotOutput("Curve13")

```

Row {data-height=150}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_0_13 <- reactive({
  input$theta0_13
})

vt_q13 <- reactive({
  input$vthetaQ_13
}) 

q13 <- reactive({
  input$q_13
}) 

t_c13 <- reactive({
  input$thetaC_13
}) 
```

  - $\theta_0=$ `r t_0_13`
  - $\vartheta_q=$ `r vt_q13`
  - $q=$ `r q13`
  - $\theta_c=$ `r t_c13`
  
  
Linear-Platô {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 14
                      sliderInput("theta0_14",
                                   HTML("$$ \\theta_0 $$"),
                                   min = 0,
                                   max = 10,
                                   value = 1,
                                  step = 0.05)
                      sliderInput("theta1_14",
                                   HTML("$$ \\theta_1 $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                  step = 0.05)
                      sliderInput("thetaB_14",
                                   HTML("$$ \\theta_b $$"),
                                   min = 1,
                                   max = 15,
                                   value = 1)
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}

output$Curve14 <- renderPlot({
  theta0_14 <- input$theta0_14
  theta1_14 <- input$theta1_14
  thetaB_14 <- input$thetaB_14
  
  fun_14 <- function(x) { 
    ifelse(test = x <= thetaB_14, 
           yes = theta0_14 + (theta1_14 * x),
           no = theta0_14 + (theta1_14 * thetaB_14)) 
  }
  
  curve(expr = fun_14, from = 0, to = 10, col = 2, ylab = "", 
        main = expression(
          atop("f(x) ="~ theta[0] + (theta[1] * x)~"se"~x <= 0~", e",
               "f(x) ="~theta[0] + (theta[1] * theta[b])~"se"~x > 0
               )))
  
},  height = 400, width = 600)

plotOutput("Curve14")
```


Row {data-height=110}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_0_14 <- reactive({
  input$theta0_14
})

t_1_14 <- reactive({
  input$theta1_14
}) 

t_b14 <- reactive({
  input$thetaB_14
}) 
```

  - $\theta_0=$ `r t_0_14`
  - $\theta_1=$ `r t_1_14`
  - $\theta_b=$ `r t_b14`
  

Linear-Platô Reparametrizado {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 15
                      sliderInput("theta1_15",
                                   HTML("$$ \\theta_1 $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                  step = 0.5)
                      sliderInput("thetaB_15",
                                   HTML("$$ \\theta_b $$"),
                                   min = 1,
                                   max = 15,
                                   value = 1)
                       sliderInput("vthetaB_15",
                                   HTML("$$ \\vartheta_b $$"),
                                   min = -15,
                                   max = 15,
                                   value = 0.05)
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
output$Curve15 <- renderPlot({
  theta1_15 <- input$theta1_15
  vthetaB_15 <- input$vthetaB_15
  thetaB_15 <- input$thetaB_15
  
  fun_15 <- function(x) { 
      ifelse(test = x <= thetaB_15, 
             yes = vthetaB_15 + theta1_15 * (x - thetaB_15),
             no = vthetaB_15) 
  }
  
  curve(expr = fun_15, from = 0, to = 10, col = 2, ylab = "", 
      main = expression(atop("f(x) ="~vartheta[b] + theta[1]* 
                               (x - theta[b]) ~ "se"~ 
                               x <=vartheta[b]~", e", 
                          "f(x) ="~vartheta[b]~"se"~x > vartheta[b])))
},  height = 400, width = 600)

plotOutput("Curve15")
```

Row {data-height=110}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_1_15 <- reactive({
  input$theta1_15
}) 

t_b15 <- reactive({
  input$thetaB_15
})

vt_b15 <- reactive({
  input$vthetaB_15
})
```

  - $\theta_1=$ `r t_1_15`
  - $\theta_b=$ `r t_b15`
  - $\vartheta_b=$ `r vt_b15`


Bi-linear segmentado {data-navmenu="Modelos"}
=======================================================================
  
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 16
                       sliderInput("theta0_16",
                                   HTML("$$ \\theta_1 $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                      sliderInput("theta1_16",
                                   HTML("$$ \\theta_2 $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                  step = 0.05)
                      sliderInput("theta2_16",
                                   HTML("$$ \\theta_2 $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                  step = 0.05)
                      sliderInput("thetaB_16",
                                   HTML("$$ \\theta_b $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                  step = 0.05)
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
output$Curve16 <- renderPlot({
  theta0_16 <- input$theta0_16
  theta1_16 <- input$theta1_16
  theta2_16 <- input$theta2_16
  thetaB_16 <- input$thetaB_16

  
    fun_16 <- function(x) { 
      ifelse(test = x <= theta0_16, 
             yes = theta0_16 + (theta1_16 * x),
             no = theta0_16 + (theta1_16 * thetaB_16) +
               theta2_16 * (x - thetaB_16)) 
  }
  
    curve(expr = fun_16, from = 0, to = 10, col = 2, ylab = "", 
          main = expression(atop("f(x) ="~theta[0] + (theta[1] * x)~
                                   "se"~ x <=theta[b]~", e", 
                                 "f(x) ="~ theta[0] + theta[1] +
                                   theta[2] * (x - theta[b])~"se"~
                              x>theta[b])))

            
},  height = 400, width = 600)

plotOutput("Curve16")

```

Row {data-height=130}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_0_16 <- reactive({
  input$theta0_16
})

t_1_16 <- reactive({
  input$theta1_16
}) 

t_2_16 <- reactive({
  input$theta2_16
}) 

t_b16 <- reactive({
  input$thetaB_16
}) 
```

  - $\theta_0=$ `r t_0_16`
  - $\theta_1=$ `r t_1_16`
  - $\theta_2=$ `r t_2_16`
  - $\theta_b=$ `r t_b16`


Bi-linear segmentado Reparametrizado {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 17
                       sliderInput("theta1_17",
                                   HTML("$$ \\theta_1 $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
                      sliderInput("theta2_17",
                                   HTML("$$ \\theta_2 $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
                      sliderInput("thetaB_17",
                                   HTML("$$ \\theta_b $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                  step = 0.05)
                       sliderInput("vthetaB_17",
                                   HTML("$$ \\vartheta_b $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
output$Curve17 <- renderPlot({
  theta1_17 <- input$theta1_17
  theta2_17 <- input$theta2_17
  vthetaB_17 <- input$vthetaB_17
  thetaB_17 <- input$thetaB_17
  
    fun_17 <- function(x) { 
      ifelse(test = x <= vthetaB_17, 
             yes = vthetaB_17 + theta1_17 * (x - thetaB_17),
             no = vthetaB_17 + theta2_17 * (x - thetaB_17)) 
  }
  
  curve(expr = fun_17, from = 0, to = 10, col = 2, ylab = "", 
      main = expression(atop("f(x) ="~vartheta[b] + theta[1] * (x - theta[b])~
                                   "se"~x<=vartheta[b]~", e", 
                                 "f(x) ="~vartheta[b] + (theta[1] * (x - theta[b]))
                             ~"se"~x > vartheta[b])))
            
},  height = 400, width = 600)

plotOutput("Curve17")

```


Row {data-height=130}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_1_17 <- reactive({
  input$theta1_17
}) 

t_2_17 <- reactive({
  input$theta2_17
}) 


vt_b17 <- reactive({
  input$vthetaB_17
}) 

t_b17 <- reactive({
  input$thetaB_17
}) 
```

  - $\theta_1=$ `r t_1_17`
  - $\theta_2=$ `r t_2_17`
  - $\theta_b=$ `r t_b17`
  - $\vartheta_b=$ `r vt_b17`


Polinômio de segundo grau {data-navmenu="Modelos"}
=======================================================================

Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 18
                       sliderInput("theta0_18",
                                   HTML("$$ \\theta_1 $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("theta1_18",
                                   HTML("$$ \\theta_1 $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("theta2_18",
                                   HTML("$$ \\theta_2 $$"),
                                   min = 0,
                                   max = 100,
                                   value = 1,
                                   step = 0.05)
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
mForm18 <- as.formula("Y ~ theta0_18 + (theta1_18 * x)
                      + (theta2_18 * x^2)")
mExpr18 <- mForm18[[3]]

output$Curve18 <- renderPlot({
  theta0_18 <- input$theta0_18
  theta1_18 <- input$theta1_18
  theta2_18 <- input$theta2_18

  
  eval(call("curve", mExpr18, col = 2, ylab = "", main =
              expression(theta[0] + theta[1] * x + 
                           theta[2] * x^2)
            ))
},  height = 400, width = 600)

plotOutput("Curve18")
```

Row {data-height=110}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_0_18 <- reactive({
  input$theta0_18
}) 

t_1_18 <- reactive({
  input$theta1_18
}) 

t_2_18 <- reactive({
  input$theta2_18
}) 

```

  - $\theta_0=$ `r t_0_18`
  - $\theta_1=$ `r t_1_18`
  - $\theta_2=$ `r t_2_18`



Polinômio de segundo grau Reparametrizado {data-navmenu="Modelos"}
=======================================================================

Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 19
                       sliderInput("theta2_19",
                                   HTML("$$ \\theta_2 $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("vthetaX_19",
                                   HTML("$$ \\vartheta_x $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("vthetaY_19",
                                   HTML("$$ \\vartheta_y $$"),
                                   min = 1,
                                   max = 20,
                                   value = 2)
```



Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
mForm19 <- as.formula("Y ~ vthetaY_19 + theta2_19 * 
                      ((x - vthetaX_19)^2)")
mExpr19 <- mForm19[[3]]

output$Curve19 <- renderPlot({
  theta2_19 <- input$theta2_19
  vthetaX_19 <- input$vthetaX_19
  vthetaY_19 <- input$vthetaY_19
  
  eval(call("curve", mExpr19, col = 2, ylab = "", main =
              expression(vartheta[y] + theta[2] * (x - vartheta[x])^2)
            ))
},  height = 400, width = 600)

plotOutput("Curve19")
```


Row {data-height=110}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_2_19 <- reactive({
  input$theta2_19
}) 

vt_x19 <- reactive({
  input$vthetaX_19
}) 

vt_y19 <- reactive({
  input$vthetaY_19
}) 

```

  - $\theta_2=$ `r t_2_19`
  - $\theta_x=$ `r vt_x19`
  - $\theta_y=$ `r vt_y19`


Quadrático-Platô {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 20
                       sliderInput("theta0_20",
                                   HTML("$$ \\theta_0 $$"),
                                   min = -15,
                                   max = 5,
                                   value = 0,
                                   step = 0.05)
                       sliderInput("theta1_20",
                                   HTML("$$ \\theta_1 $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
                       sliderInput("theta2_20",
                                   HTML("$$ \\theta_2 $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)

```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}

output$Curve20 <- renderPlot({
  theta0_20 <- input$theta0_20
  theta1_20 <- input$theta1_20
  theta2_20 <- input$theta2_20

  
  fun_20 <- function(x) { 
      ifelse(test = x <= (-theta0_20)/(2*theta2_20), 
             yes = theta0_20 + (theta1_20 * x) +
               (theta2_20 * x^2),
             no = theta0_20 + (theta1_20 * 
                                 (-theta1_20/(2*theta2_20)) +
                                 (theta2_20 * (-theta1_20/(2*theta2_20))^2)
                               )) 
  }

  curve(expr = fun_20, from = 0, to = 10, col = 2, ylab = "", 
      main = expression(atop
                        ("f(x) ="~theta[0] + (theta[1] * x) +
                          (theta[2] * x^2)~"se"~ x <= frac(-theta[1], 2*theta[2])~", e", 
                                 "f(x) ="~theta[0] + 
                          (theta[1] * frac(-theta[1], 2*theta[2])) +
                          (theta[2] * frac(-theta[1], 2*theta[2]))^2~"se"~
                              x>frac(-theta[1], 2*theta[2]))
                        ))
      
  
},  height = 400, width = 600)

plotOutput("Curve20")

```


Row {data-height=110}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_0_20 <- reactive({
  input$theta0_20
}) 
t_1_20 <- reactive({
  input$theta1_20
}) 

t_2_20 <- reactive({
  input$theta2_20
}) 

```

  - $\theta_0=$ `r t_0_20`
  - $\theta_1=$ `r t_1_20`
  - $\theta_2=$ `r t_2_20`


Quadrático-Platô Reparametrizado {data-navmenu="Modelos"}
=======================================================================

Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 21

                       sliderInput("theta2_21",
                                   HTML("$$ \\theta_2 $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
                       sliderInput("vthetaX_21",
                                   HTML("$$ \\vartheta_x $$"),
                                   min = 0,
                                   max = 50,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("vthetaY_21",
                                   HTML("$$ \\vartheta_y $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
```



Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
output$Curve21 <- renderPlot({
  theta2_21 <- input$theta2_21
  vthetaX_21 <- input$vthetaX_21
  vthetaY_21 <- input$vthetaY_21
  
  fun_21 <- function(x) { 
      ifelse(test = x <= vthetaX_21, 
             yes = vthetaY_21 + theta2_21 * ((x - vthetaX_21)^2),
             no = vthetaY_21) 
  }
  
  curve(expr = fun_21, from = 0, to = 10, col = 2, ylab = "", 
      main = expression(atop
                        ("f(x) ="~vartheta[y] + theta[2] +
                          (x - vartheta[x]^2)~"se"~ x <= vartheta[x]~", e", 
                                 "f(x) ="~vartheta[y]~"se"~
                              x > vartheta[x]))
                        )
      
  
},  height = 400, width = 600)

plotOutput("Curve21")
```

Row {data-height=110}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_2_21 <- reactive({
  input$theta2_21
}) 

vt_x21 <- reactive({
  input$vthetaX_21
}) 

vt_y21 <- reactive({
  input$vthetaY_21
}) 

```

  - $\theta_2=$ `r t_2_21`
  - $\vartheta_x=$ `r vt_x21`
  - $\vartheta_y=$ `r vt_y21`



Bleasdale-Nelder {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 22
                       sliderInput("theta0_22",
                                   HTML("$$ \\theta_0 $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("theta1_22",
                                   HTML("$$ \\theta_1 $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("theta2_22",
                                   HTML("$$ \\theta_2 $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)                       
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
mForm22 <- as.formula("Y ~ x*(theta0_22 + (theta1_22 * x)^(-1/theta2_22))")
mExpr22 <- mForm22[[3]]

output$Curve22 <- renderPlot({
  theta0_22 <- input$theta0_22
  theta1_22 <- input$theta1_22
  theta2_22 <- input$theta2_22  

  eval(call("curve", mExpr22, col = 2, ylab = "", main =
              expression( x * (theta[0] + theta[1] * x)^
                            frac(-1, theta[2])
            )))
  
},  height = 400, width = 600)

plotOutput("Curve22")
```

Row {data-height=100}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_0_22 <- reactive({
  input$theta0_22
}) 

t_1_22 <- reactive({
  input$theta1_22
}) 

t_2_22 <- reactive({
  input$theta2_22
}) 

```

  - $\theta_0=$ `r t_0_22`
  - $\theta_1=$ `r t_1_22`
  - $\theta_2=$ `r t_2_22`


Bleasdale-Nelder Reparametrizado {data-navmenu="Modelos"}
=======================================================================

Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 23
                       
                       sliderInput("theta2_23",
                                   HTML("$$ \\theta_2 $$"),
                                   min = -1,
                                   max = 1,
                                   value = 0,
                                   step = 0.05)
                       sliderInput("vthetaX_23",
                                   HTML("$$ \\vartheta_x $$"),
                                   min = 0,
                                   max = 20,
                                   value = 2,
                                   step = 0.05)
                       sliderInput("vthetaY_23",
                                   HTML("$$ \\vartheta_y $$"),
                                   min = 0,
                                   max = 20,
                                   value = 2,
                                   step = 0.05)
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
mForm23 <- as.formula("Y ~ vthetaY_23 * (x/vthetaX_23) * 
                      ((1 - theta2_23 * (1 -x/vthetaX_23))^
                       (-1/theta2_23))")
mExpr23 <- mForm23[[3]]

output$Curve23 <- renderPlot({
  theta2_23 <- input$theta2_23
  vthetaX_23 <- input$vthetaX_23
  vthetaY_23 <- input$vthetaY_23
  
  eval(call("curve", mExpr23, col = 2, ylab = "", main =
              expression(vartheta[y] * frac(x, vartheta[x]) * 
                           (1 - theta[2] * 
                              (1 - frac(x, vartheta[x])))^
                                            frac(-1, theta[2])
            )))
  
},  height = 400, width = 600)

plotOutput("Curve23")
```


Row {data-height=110}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_2_23 <- reactive({
  input$theta2_23
}) 

vt_x23 <- reactive({
  input$vthetaX_23
}) 

vt_y23 <- reactive({
  input$vthetaY_23
}) 

```

  - $\theta_2=$ `r t_2_23`
  - $\vartheta_x=$ `r vt_x23`
  - $\vartheta_y=$ `r vt_y23`


Gama Incompleto {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 24
                       sliderInput("theta0_24",
                                   HTML("$$ \\theta_0 $$"),
                                   min = 0,
                                   max = 10,
                                   value = 5,
                                   step = 0.05)
                       sliderInput("theta1_24",
                                   HTML("$$ \\theta_1 $$"),
                                   min = 0,
                                   max = 10,
                                   value = 5, 
                                   step = 0.05)
                       sliderInput("theta2_24",
                                   HTML("$$ \\theta_2 $$"),
                                   min = 0,
                                   max = 10,
                                   value = 5, 
                                   step = 0.05)   
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
mForm24 <- as.formula("Y ~ theta0_24 * (x^theta1_24) *
                        exp(-theta2_24 * x)")
mExpr24 <- mForm24[[3]]

output$Curve24 <- renderPlot({
  theta0_24 <- input$theta0_24
  theta1_24 <- input$theta1_24  
  theta2_24 <- input$theta2_24
  
  eval(call("curve", mExpr24, col = 2, ylab = "", main =
              expression(theta[0] * x^theta[1] * exp(-theta[2] * x)
            )))
  
},  height = 400, width = 600)

plotOutput("Curve24")
```

Row {data-height=110}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_0_24 <- reactive({
  input$theta0_24
}) 

t_1_24 <- reactive({
  input$theta1_24
}) 

t_2_24 <- reactive({
  input$theta2_24
}) 

```

  - $\theta_0=$ `r t_0_24`
  - $\theta_1=$ `r t_1_24`
  - $\theta_2=$ `r t_2_24`


Gama Incompleto Reparametrizado {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 25
                       sliderInput("theta1_25",
                                   HTML("$$ \\dot \\theta_1 $$"),
                                   min = -5,
                                   max = 10,
                                   value = 5, 
                                   step = 0.05)
                       sliderInput("vthetaX_25",
                                   HTML("$$ \\vartheta_x $$"),
                                   min = 0,
                                   max = 15,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("vthetaY_25",
                                   HTML("$$ \\vartheta_y $$"),
                                   min = 0,
                                   max = 15,
                                   value = 1,
                                   step = 0.05)
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
mForm25 <- as.formula("Y ~ vthetaY_25 * ((x/vthetaX_25)^ 
                      theta1_25) * exp(theta1_25 * 
                      (1 - (x/vthetaX_25)))")
mExpr25 <- mForm25[[3]]

output$Curve25 <- renderPlot({
  theta1_25 <- input$theta1_25
  vthetaX_25 <- input$vthetaX_25
  vthetaY_25 <- input$vthetaY_25
  
  eval(call("curve", mExpr25, col = 2, ylab = "", main =
              expression(vartheta[y] * frac(x, vartheta[x])^
                           dot(theta[1]) * 
                           exp(dot(theta[1]) * 
                                 (1 - frac(x, vartheta[x])))
            )))
  
},  height = 400, width = 600)

plotOutput("Curve25")
```


Row {data-height=110}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_1_25 <- reactive({
  input$theta1_25
}) 

vt_x25 <- reactive({
  input$vthetaX_25
}) 

vt_y25 <- reactive({
  input$vthetaY_25
}) 

```

  - $\theta_1=$ `r t_1_25`
  - $\vartheta_x=$ `r vt_x25`
  - $\vartheta_y=$ `r vt_y25`



Logístico {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 26
                       sliderInput("theta0_26",
                                   HTML("$$ \\theta_0 $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("theta1_26",
                                   HTML("$$ \\theta_1 $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("thetaA_26",
                                   HTML("$$ \\theta_a $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)   
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
mForm26 <- as.formula("Y ~ thetaA_26/(1 + exp(theta0_26 +
                          theta1_26 * x))")
mExpr26 <- mForm26[[3]]

output$Curve26 <- renderPlot({
  theta0_26 <- input$theta0_26
  theta1_26 <- input$theta1_26
  thetaA_26 <- input$thetaA_26
  
  eval(call("curve", mExpr26, col = 2, ylab = "", main =
              expression(frac(theta[a], 1 + 
                                exp(theta[0] + 
                                      theta[1] * x)))
            ))
  
},  height = 400, width = 600)

plotOutput("Curve26")
```


Row {data-height=110}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_0_26 <- reactive({
  input$theta0_26
}) 

t_1_26 <- reactive({
  input$theta1_26
}) 

t_a26 <- reactive({
  input$thetaA_26
}) 

```

  - $\theta_0=$ `r t_0_26`
  - $\theta_1=$ `r t_1_26`
  - $\theta_a=$ `r t_a26`


Logístico Reparametrizado {data-navmenu="Modelos"}
=======================================================================

Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 27
                       sliderInput("thetaA_27",
                                   HTML("$$ \\theta_a $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("vthetaT_27",
                                   HTML("$$ \\vartheta_t $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
                       sliderInput("vthetaQ_27",
                                   HTML("$$ \\vartheta_q $$"),
                                   min = 1,
                                   max = 20,
                                   value = 5)
                      sliderInput("q_27",
                                   HTML("$$ q $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
mForm27 <- as.formula("Y ~ thetaA_27/(1 + ((1 - q_27)/q_27) * 
                      exp(-4 * vthetaT_27 * (x - vthetaQ_27)))")
mExpr27 <- mForm27[[3]]

output$Curve27 <- renderPlot({
  thetaA_27 <- input$thetaA_27
  vthetaT_27 <- input$vthetaT_27
  vthetaQ_27 <- input$vthetaQ_27
  q_27 <- input$q_27
  
  eval(call("curve", mExpr27, col = 2, ylab = "", main =
              expression(frac(theta[a], 1 + (frac(1-q, q)) * 
                                exp(-4 * vartheta[t] * 
                                      (x - vartheta[q]))))
            ))
  
},  height = 400, width = 600)

plotOutput("Curve27")
```


Row {data-height=130}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_a27 <- reactive({
  input$thetaA_27
}) 

vt_t27 <- reactive({
  input$vthetaT_27
}) 

vt_q27 <- reactive({
  input$vthetaQ_27
}) 

q27 <- reactive({
  input$q_27
}) 
```

  - $\theta_a=$ `r t_a27`
  - $\vartheta_t=$ `r vt_t27`
  - $\vartheta_q=$ `r vt_q27`
  - $q=$ `r q27`



Gompertz {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 28
                       sliderInput("theta0_28",
                                   HTML("$$ \\theta_0 $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("theta1_28",
                                   HTML("$$ \\theta_1 $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("thetaA_28",
                                   HTML("$$ \\theta_a $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)   
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
mForm28 <- as.formula("Y ~ thetaA_28 * (exp( -exp(theta0_28 +
                          theta1_28 * x)))")
mExpr28 <- mForm28[[3]]

output$Curve28 <- renderPlot({
  theta0_28 <- input$theta0_28
  theta1_28 <- input$theta1_28
  thetaA_28 <- input$thetaA_28
  
  eval(call("curve", mExpr28, col = 2, ylab = "", main =
              expression(theta[a] * (exp(-exp(theta[0] + 
                                      theta[1] * x))
            ))
            ))
  },  height = 400, width = 600)


plotOutput("Curve28")
```

Row {data-height=110}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_0_28 <- reactive({
  input$theta0_28
}) 

t_1_28 <- reactive({
  input$theta1_28
}) 

t_a28 <- reactive({
  input$thetaA_28
}) 

```

  - $\theta_0=$ `r t_0_28`
  - $\theta_1=$ `r t_1_28`
  - $\theta_a=$ `r t_a28`


Gompertz Reparametrizado {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 31

                       sliderInput("theta0_29",
                                   HTML("$$ \\theta_0 $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("thetaA_29",
                                   HTML("$$ \\theta_a $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)   
                       sliderInput("vthetaX_29",
                                   HTML("$$ \\vartheta_q $$"),
                                   min = 1,
                                   max = 20,
                                   value = 2)
                      sliderInput("q_29",
                                   HTML("$$ q $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                  step = 0.05)
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
mForm29 <- as.formula("Y ~ thetaA_29 * exp(log(q_29) * exp(theta0_29 *
                      (1 - x/vthetaX_29)))")
mExpr29 <- mForm29[[3]]

output$Curve29 <- renderPlot({
  thetaA_29 <- input$thetaA_29
  theta0_29 <- input$theta0_29
  vthetaX_29 <- input$vthetaX_29
  q_29 <- input$q_29
  
  eval(call("curve", mExpr29, col = 2, ylab = "", main =
              expression(theta[a] * exp(log(q) * exp(theta[0] *
                                    (1 - frac(x, vartheta[x])))
                                    ))
            ))
  
},  height = 400, width = 600)

plotOutput("Curve29")
```


Row {data-height=131}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_a29 <- reactive({
  input$thetaA_29
}) 

t_0_29 <- reactive({
  input$theta0_29
}) 

vt_x29 <- reactive({
  input$vthetaX_29
}) 

q29 <- reactive({
  input$q_29
}) 
```

  - $\theta_a=$ `r t_a29`
  - $\theta_0=$ `r t_0_29`
  - $\vartheta_x=$ `r vt_x29`
  - $q=$ `r q29`
  
  
Van Genutchen {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 30
                       sliderInput("thetaA_30",
                                   HTML("$$ \\theta_a $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)  
                       sliderInput("thetaS_30",
                                   HTML("$$ \\theta_s $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)  
                       sliderInput("thetaR_30",
                                   HTML("$$ \\theta_r $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("thetaN_30",
                                   HTML("$$ \\theta_n $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("thetaM_30",
                                   HTML("$$ \\theta_m $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)                       
 
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
mForm30 <- as.formula("Y ~ thetaR_30 + (thetaS_30 - thetaR_30)/
                        (1 + exp(thetaA_30 + x)^thetaN_30)^
                                                thetaM_30")
mExpr30 <- mForm30[[3]]

output$Curve30 <- renderPlot({
  thetaA_30 <- input$thetaA_30
  thetaS_30 <- input$thetaS_30
  thetaR_30 <- input$thetaR_30
  thetaN_30 <- input$thetaN_30
  thetaM_30 <- input$thetaM_30

  
  eval(call("curve", mExpr30, col = 2, ylab = "", main =
              expression(theta[r] + 
                           frac(theta[s] - theta[r],
                                (1 + exp(theta[a] + x)^
                                   theta[n])^theta[m]))
            ))
  
},  height = 400, width = 600)

plotOutput("Curve30")
```

Row {data-height=150}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_a30 <- reactive({
  input$thetaA_30
}) 

t_s30 <- reactive({
  input$thetaS_30
}) 

t_r30 <- reactive({
  input$thetaR_30
}) 

t_n30 <- reactive({
  input$thetaN_30
}) 

t_m30 <- reactive({
  input$thetaM_30
}) 
```

  - $\theta_a=$ `r t_a30`
  - $\theta_s=$ `r t_s30`
  - $\theta_r=$ `r t_r30`
  - $\theta_n=$ `r t_n30`
  - $\theta_m=$ `r t_m30`


Van Genutchen Reparametrizado {data-navmenu="Modelos"}
=======================================================================
Row {.sidebar}
-----------------------------------------------------------------------
```{r}
## Model 31
                       sliderInput("thetaR_31",
                                   HTML("$$ \\theta_r $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("thetaN_31",
                                   HTML("$$ \\theta_n $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
                       sliderInput("thetaM_31",
                                   HTML("$$ \\theta_m $$"),
                                   min = 0,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)                       
                       sliderInput("vthetaS_31",
                                   HTML("$$ \\vartheta_s $$"),
                                   min = 0,
                                   max = 1,
                                   value = 0.5,
                                   step = 0.05)
                       sliderInput("vthetaI_31",
                                   HTML("$$ \\vartheta_i $$"),
                                   min = -10,
                                   max = 10,
                                   value = 1,
                                   step = 0.05)
```


Row {.tabset}
-----------------------------------------------------------------------
### Gráfico
```{r}
mForm31 <- as.formula("Y ~ thetaR_31 - (vthetaS_31/thetaN_31) * 
                      ((1 + thetaM_31)^(thetaM_31 + 1)/
                      (1 + (exp(thetaN_31 * (x - vthetaI_31)))/
                      thetaM_31)^thetaM_31)")
mExpr31 <- mForm31[[3]]

output$Curve31 <- renderPlot({
  thetaR_31 <- input$thetaR_31
  thetaN_31 <- input$thetaN_31
  thetaM_31 <- input$thetaM_31
  vthetaS_31 <- input$vthetaS_31
  vthetaI_31 <- input$vthetaI_31
  
  eval(call("curve", mExpr31, col = 2,  ylab = "", main =
              expression(theta[r] - frac(vartheta[s], theta[n]) * 
                           frac((1 + theta[m])^(theta[m] + 1),
                           (1 + frac(exp(theta[n]*(x - vartheta[i])),
                                     theta[m]))^theta[m]))
            ))
  
},  height = 400, width = 600)

plotOutput("Curve31")
```


Row {data-height=150}
-------------------------------------
### Valores dos parâmetros
```{r, echo=FALSE}
t_r31 <- reactive({
  input$thetaR_31
}) 

t_n31 <- reactive({
  input$thetaN_31
}) 

t_m31 <- reactive({
  input$thetaM_31
})

vt_i31 <- reactive({
  input$vthetaI_31
}) 

vt_s31 <- reactive({
  input$vthetaS_31
}) 
```

  - $\theta_r=$ `r t_r31`
  - $\theta_n=$ `r t_n31`
  - $\theta_m=$ `r t_m31`
  - $\vartheta_i=$ `r vt_i31`
  - $\vartheta_s=$ `r vt_s31`

---
Seção de Documentação
---

Michaelis-Menten {data-navmenu="Documentação"}
=======================================================================
Row {data-height=850, data-width=800}
------------------------------------------------------------------------

Exponencial Assintótico {data-navmenu="Documentação"}
=======================================================================
Row {data-height=850, data-width=800}
------------------------------------------------------------------------

Mitscherlich {data-navmenu="Documentação"}
=======================================================================
Row {data-height=850, data-width=800}
------------------------------------------------------------------------

Herschel-Bulkley {data-navmenu="Documentação"}
=======================================================================
Row {data-height=850, data-width=800}
------------------------------------------------------------------------

Modelo de Ratkowsky {data-navmenu="Documentação"}
=======================================================================
Row {data-height=850, data-width=800}
------------------------------------------------------------------------

Linear-Platô {data-navmenu="Documentação"}
=======================================================================
Row {data-height=850, data-width=800}
------------------------------------------------------------------------

Bi-linear segmentado Reparametrizado {data-navmenu="Documentação"}
=======================================================================
Row {data-height=850, data-width=800}
------------------------------------------------------------------------

Quadrático-Platô {data-navmenu="Documentação"}
=======================================================================
Row {data-height=850, data-width=800}
------------------------------------------------------------------------

Bleasdale-Nelder {data-navmenu="Documentação"}
=======================================================================
Row {data-height=850, data-width=800}
------------------------------------------------------------------------

Gama Incompleto {data-navmenu="Documentação"}
=======================================================================
Row {data-height=850, data-width=800}
------------------------------------------------------------------------

Logístico {data-navmenu="Documentação"}
=======================================================================
Row {data-height=850, data-width=800}
------------------------------------------------------------------------

Gompertz {data-navmenu="Documentação"}
=======================================================================
Row {data-height=850, data-width=800}
------------------------------------------------------------------------

Van Genutchen {data-navmenu="Documentação"}
=======================================================================
Row {data-height=850, data-width=800}
------------------------------------------------------------------------