In AlinneVeiga/EstComp1_2021_1:

library(learnr)

knitr::opts_chunk$set(echo = TRUE)
tutorial_options(exercise.eval = FALSE)

Loops: `if {...}else{...}`

Como podemos determinar se uma matriz é inversível? Vamos criar um if:

(matriz.inv <- matrix(c(seq(2,8,2), rep(3,4), seq(20,5,-4), 35:32), nrow=4))
det(matriz.inv)

#Digite cada linha e rode apenas quando terminar todas as linhas
if (dim(matriz.inv)[1]!= dim(matriz.inv)[2]){
  "A matriz não é quadrada"
  } else {
  if(det(matriz.inv)==0)
    {
   "A matriz é quadrada mas não inversível"
    } else {
    print("A inversa da matriz é") #aqui precisa do print!
    print(( solve(matriz.inv)))
    }
 }

Modifique os códigos para a matriz.inv para testar outras matrizes.

Loops: `if` e `for`

Vamos juntar if() com for() - digite:

for( i in 1:10) {
 if (i%%2 ==0) {
  print(c(i," é par"))
  } else {
    print(c( i,  "é impar"))
  }
}

O que foi feito acima? Modifique os códigos para verificar outros resultados.

De outra forma:

for( i in 1:10) {
 print(c(i,ifelse(i%%2==0, " é par", "é impar")))
  }

Note como foi criado o print no for.

Rode os comandos abixo e verifique o resultado:

vetor <- seq(1,30,2)
class(vetor)
is.vector(vetor)

#valores iniciais
soma <- 0 ; produto <- 1 
minimo <- 1 ; maximo <- 1

#Para achar o máximo e o mínimo do vetor
for( i in 1:length(vetor)){
#soma
soma <- soma + vetor[i]
#produto
produto <- produto *vetor[i]
#máximo
if (maximo < vetor[i])  maximo <- vetor[i]
#mínimo
if (minimo > vetor[i])  minimo <- vetor[i]
}
maximo; minimo; soma; produto

Modifique os códigos para o vetor e veja as mudanças nos resultados.

Loops: `for` e `while`

Vimos o seguinte exemplo em aula: queremos estabilizar o valor de i sabendo que

$$i = \frac{(1 + ( 1 + i)^{-20})}{19}$$.

Vimos isso feito com for()e com while() também. Com o for() fazíamos (rode o código):

#Valor inicial
i <- 0.006

#For...
for (j in 1:500) {
  i <- (1 - (1 + i)^(-20)) / 19
}

i # O valor de i estabilizado
j # O valor de j final

Obviamente, o valor de j final é igual a 500. Com o while() poderíamos fazer:

#Valor inicial
i <- 0.006
j <- 0

i_anterior <- 0.007

#While...
while (i_anterior - i > 0.000000001) {
  i_anterior <- i
  j <- j + 1
  i <- (1 - (1 + i)^(-20)) / 19
}
i# O valor de i estabilizado 
j# O valor de j final

A partir do while() verificamos que o i se estabiliza na iteração 207, logo, não havia necessidade de repertir esse processo 500 vezes.

Modifique os códigos acima para observar mudanças.

Exercícios

Exercício 1

Escreva os comandos necessários para realizar $\sum_{j=1}^{n}r^j$ supondo que $r=1.08$. Escreva usando comandos de repetição e looping e supondo diferentes valores para : $n = 10,20,30, 100$. Supondo $n=10$ o resultado é:

r <- 1.08
n<- 10
soma <-0
for (j in 1:n) {
  soma <- r^j + soma

}
soma

for (j in 1:n) {
  }

r <- 1.08
n <- 10
soma <-0
for (j in 1:n) {
  soma <- r^j + soma

}
soma

Exercício 2

Calcule os seguintes somatórios - escreva os comandos para tal:

a. $\sum_{j=1}^{n} j$ para $n = 10,20,30, 100$

soma <-0

n <-10
soma <-0
for (j in 1:n) {
  soma <- soma + j
}
soma

b. $\sum_{j=1}^{n} j^2$ para $n = 10,20,30, 100$

j^2

n <-10
soma2 <- 0
for (j in 1:n) {
  soma2 <- soma2 + j^2 
}
soma2

c. $\sum_{j=1}^{n} 1/j$ para $n = 10,20,30, 100$

(1/j)

n <-10
soma3 <- 0
for (j in 1:n) {
  soma3 <- soma3 + (1/j)
}
soma3

Exercício 3

Com o uso de while(), forneça o valor da iteração e do i estabilizado para cada caso a seguir -- Repare que as diferenças nesse caso nem sempre são positivas:

a. $i = e^{e^{-i}}$ , supondo o valor inicial igual a 2.

while (abs(i_antigo - i) > 0.000000001) {

}

i <- 2
itera <- 0
i_antigo <- 2.1

while (abs(i_antigo - i) > 0.000000001) {

  i_antigo <- i

  itera <- itera + 1

  i<- exp(exp(-i))

}

i 

itera

b. $i = i + e^{-i}$ com valor inicial igual a 2.

exp(-i)

i <- 2
itera <- 0
i_antigo <- 2.1

while (abs(i_antigo - i) > 0.000001) {

  i_antigo <- i

  itera <- itera + 1

  (i <- i + exp(-i))

}

i 

itera

c. $i = 1/i + e^{-i} + i^{1/2}$ com valor inicial igual a 2.

i <- 2
itera <- 0
i_antigo <- 2.1

while (abs(i_antigo - i) > 0.000000001) {

  i_antigo <- i

  itera <- itera + 1
  i <- (1/i) + exp(-i) +  i^(1/2)
}
i 
itera