<a href="https://colab.research.google.com/github/gabrielvieiraf/ProjetosPython/blob/master/GoogleColab/Calculo/Matematica01.ipynb" target="_parent"></a>

# Matemática: Funções e Seus Usos

## Equação de segundo Grau com Python


```
from math import sqrt
from sympy import *
import math
init_printing()

a = 1
b = 8
c = 6
```


```
# Resolvendo equação de segundo grau
def raizes(a, b, c):
    x = Symbol('x')
    # ax² + bx + c
    return solve( a*x**2 + b*x + c , x)

# Plotando equação de segundo grau
def grafico_2grau(x1,x2):
  eixo_x = []
  eixo_y = []
  zero = []

  variacao = abs(x1 - x2)

  if variacao < 3:
      variacao = 3

  for x in np.arange(x1 - variacao, x2 + variacao, variacao / 100):
      y = a * (x ** 2 ) + b * (x) + c
      eixo_x.append(x)
      eixo_y.append(y)
      zero.append(0.0)

  # Desenha linha
  plt.plot(eixo_x,eixo_y,color="blue")

  # Desenha pontos
  plt.plot((x1,x2),(0,0), marker='o',color='red')
  plt.plot(c, marker='o',color='red')

  # Desenha eixos
  plt.plot(eixo_x,zero,color="black")
  plt.plot(zero,eixo_y,color='black')

  plt.show()

r = raizes(a,b,c)
```


```
import matplotlib.pyplot as plt
import numpy as np

try:
  x1 = float(r[0])
  x2 = float(r[1])
  grafico_2grau(x1,x2)
  print('x1 = %0.3f' % x1, 'x2= %0.3f' % x2)
except:
  try:
    x1 = complex(r[0])
    x2 = complex(r[1])
    print('O resultado das raízes é um número complexo')
    print('x1 =', x1, '\nx2 =', x2)
  except:
    print('O valor de a é 0, resultado indefinido.')
```

## Utilização do sympy para criar variáveis simbólicas


```
# define x, y e z como variáveis simbólicas
var('x y z')
```

# Funções

## Exemplo 01: Custo de operação de uma máquina


*   A empresa deseja saber o custo de energia elátrica de uma máquina.
*   A potência da máquina é de 500 kW
*   O custo de cada kW*h é de R$ 0,10

Qual a função matemática que descreve o consumo da máquina em função da hora?





```
# Custo da máquina por hora
def f(x): return 500*0.1*x
x = 24 * 30
print('O custo é de:', f(x), 'por %2.0f hora(s)' % x)

# Custo da máquina por dia
def C(x): return (500*0.1*x)*24
x = 30
print('O custo é de:', C(x), 'por %2.0f dia(s)' % x)
```

    O custo é de: 36000.0 por 720 hora(s)
    O custo é de: 36000.0 por 30 dia(s)


### Plotando Gráficos


```
# Calculando horas em um mês
dias = 30
horas = dias*24

lista_preco = list()
for hora in range(0,horas):
  lista_preco.append(f(hora))

# Gráfico

fig, ax = plt.subplots()

# Título do gráfico
plt.title('Preço kW*h em um mês')

# Eixos 
ax.set_xlabel('horas')
ax.set_ylabel('Preço em (R$)')

plt.plot(lista_preco)
```


```
# Podemos redefinir o preço em função dos dias

dias = 30

lista_preco2 = list()

for dia in range(0,dias):
  lista_preco2.append(C(dia))

# Gráfico 

fig, ax = plt.subplots()

# Título do gráfico
plt.title('Preço kW*dia em um mês')

# Eixos 
ax.set_xlabel('dias')
ax.set_ylabel('Preço em (R$)')

plt.plot(lista_preco2)
```

## Exemplo 02: Realizando Previsões com funções


*   A situação problema da empresa é: temos a função custo C(x):

<center><h4> C(x) =  0.02x² + 80/x </h4></center>

*   Qual a dimensão x da caixa, a partir da qual o custo é maior ou igual a R$ 22,00?



### Definindo Funções para o exemplo


```
def C(x): return (0.02*(x**2)) + (80/x)

def c(x): return round(C(x) - 22,2)

def find_raizes(y,x1,x2,p=0.005):
  lista_raizes = list()
  lista_index = list()
  raizes_= list()

  for i in np.arange(x1,x2,step=0.001):
    if (C(i)<= y and C(i)>= y-p):
      # Preço
      lista_raizes.append(round(C(i),4))
      # m²
      lista_index.append(round(i,2))

  return lista_index, lista_raizes
```

### Plotando Gráficos


```
resultado = find_raizes(22,3,5)

import itertools

for i, j in itertools.product(resultado[0], resultado[1]):
  valor_x = float(i)
  valor_y = float(j)

print('O valor de x é:', valor_x)
print('O valor de y é:', valor_y)

resultado2 = find_raizes(22,30,35)

print()

for i, j in itertools.product(resultado2[0], resultado2[1]):
  valor_x2 = float(i)
  valor_y2 = float(j)

print('O valor de x2 é:', valor_x2)
print('O valor de y2 é:', valor_y2)

```

    O valor de x é: 3.68
    O valor de y é: 21.9985
    
    O valor de x2 é: 31.17
    O valor de y2 é: 21.9991



```
lista_ex02 = list()

x = 35

zero_ex02 = []
eixo_x_ex02 = []
raiz = []

for i in np.arange(0.5,x, step=0.01):
  lista_ex02.append(C(i))
  zero_ex02.append(22)
  eixo_x_ex02.append(i)

# Gráfico
fig, ax = plt.subplots()

# Título do gráfico
plt.title('Custo de produção da caixa')

# Eixos 
ax.set_xlabel('cm')
ax.set_ylabel('Preço em (R$)')

plt.plot(eixo_x_ex02,lista_ex02)

plt.plot(eixo_x_ex02,zero_ex02,color='red')

plt.plot(valor_x,valor_y, marker='o',color='black')
plt.plot(valor_x2,valor_y2, marker='o',color='black')

print('Logo, para tamanhos menores que: %0.2fcm e maiores que %0.2fcm, o custo de R$22,00 é inviável.' % (valor_x,valor_x2))
```

## Variação Media de Função: Parte 1

A variação média de uma função f(x), dentro do intervalo [a,b] é definida por:

$
\dfrac{\Delta f(x)}{\Delta x} = \dfrac{f(b)-f(a)}{b-a}
$


```
var ('a b')

def f(a): return 2*a**2-1
f(a)

eixo_x_exvm = []
eixo_y_exvm = []
raiz = []

for i in np.arange(0,5,step=0.1):
  eixo_y_exvm .append(f(i))
  eixo_x_exvm.append(i)

# Gráfico
fig, ax = plt.subplots()

# Título do gráfico
plt.title('Gráfico da Função')

plt.plot(eixo_x_exvm,eixo_y_exvm)
```


```
def variacao(a,b): return (f(b)-f(a))/(b-a)

# Alguns exemplos de variação média da função
print(variacao(4,2))
print(variacao(5,2))
print(variacao(1,2))
print(variacao(3,5))
```

    12.0
    14.0
    6.0
    16.0


## Variação Media de Função: Parte 2

Uma descrição mais flexível para variação média de uma função é: 

A variação média da função f(x), no intevalo delta(x) é dada por:

$
\dfrac{\Delta f(x)}{\Delta x} = \dfrac{(f(x) + \Delta x) - f(x)}{\Delta x}
$


```
var ('x delta_x p')
def C(p): return 0.02*p**2+80/p
print(C(p))
def h(x,delta_x): return (C(x + delta_x) - C(x) )/ delta_x

# A função h() pode ser usada para calcular a variação da média 
print(h(10,0.5))
```

    0.02*p**2 + 80/p
    -0.3519047619047626


## Dominio e Imagem de uma Função

O domínio da função f(x) corresponde ao conjunto de todos os valores x onde f(x) pode ser calculada.

A imagem da função f(x) corresponde ao conjunto de todos os valores que a função assume.


```
var ('x')
def f(x): return sqrt(x-1)

eixo_y_ex_dominio = list()
eixo_x_ex_dominio = list()

for i in np.arange(3,5, step=0.01):
  eixo_y_ex_dominio.append(f(i))
  eixo_x_ex_dominio.append(i)

plt.plot(eixo_x_ex_dominio,eixo_y_ex_dominio)

```

## Inversa de uma Função

### Função Injetora
 Uma função é injetora, se e somente se, para quaisquer x1 e x2 pertencentes ao domínio, temos que:
 
 $
 x_1 \neq x_2 \rightarrow f(x_1) \neq f(x_2)
 $  

**Exemplo :** Note que: $ f: \mathbb{R} \rightarrow \mathbb{R}  $ **tal que:** $ f(x) = 5 $ é uma função, mas não é injetora!


```
var ('x')
def f(x): return 5

eixo_x = list()
eixo_y = list()

for i in range(-5,6):
  eixo_x.append(i)
  eixo_y.append(f(i))

plt.plot(eixo_x, eixo_y)
```

**Exemplo02 :** Note que: $ f: \mathbb{R} \rightarrow \mathbb{R}  $ **tal que:** $ f(x) = 5 * x $ é uma função injetora!


```
var ('x')
def f(x): return 5*x

eixo_x = list()
eixo_y = list()

for i in range(-5,6):
  eixo_x.append(i)
  eixo_y.append(f(i))

plt.plot(eixo_x, eixo_y)
```

### Função Sobrejetora
Uma função $ f: A \rightarrow B $  é sobrejetora, se cada elemento do conjunto imagem de B é imagem de pelo menos um elemento de A. 

Em outras palavras, a imagem B de f é a totalidade do conjunto B.
 
$ f: \mathbb{R} \rightarrow \mathbb{R} | f(x) = 3*x  $ 


```
var ('x')
def f(x): return 3*x

eixo_x = list()
eixo_y = list()

for i in range(-5,6):
  eixo_x.append(i)
  eixo_y.append(f(i))

plt.plot(eixo_x, eixo_y)
```

### Função Bijetora

Definição: Uma função que é injetora e subjetora.

$ f(x) $ bijetora é reversível $ f^{-1}(x)$

$ f^{-1}(f(x)) = x$

$ f^{-1}(x) = \sqrt{x} $

## Polinômios e raizes

Uma função polinomia de grau n, é toda função que pode ser escrita da seguinte forma:
$ f(x) = a_0 + a_1x^1 + a_2x^2 + ... + a_nx^n  $ 

**exemplo:** $ f(x) = -2x + 5x^3 + 3  $ é uma função de grau 3.

### Exemplo
Vamos mostrar alguns exemplos de como modelamos alguns problemas reais, usando funções. Dessa vez, vamos descrever a queda livre de um objeto, o modelo matemático parte da segunda lei de Newton:

A queda livre de um objeto é solução do seguinte problema:



1.   Solta-se um objeto, de uma altura $ h0 $, deixando-o cair em direção ao solo.
2.   Considera-se desprezível a resistência do ar, durante o movimento da queda.
3.   A única força que age sobre o objeto é o peso do mesmo ( que descreve a atração do planeta sobre esse corpo)
4.   Usa-se a segunda lei de Newton: 

      $   \overrightarrow{P} = m\overrightarrow{g}=m\overrightarrow{a}_(t)$

A função que descreve o modelo do objeto em queda, é solução da lei de Newton e é dada pela função polinomial de segundo grau:

$h(t) = h_0 + v_{0}t - \dfrac {g}{2}t^2 $


```
var ('t h0 v0 g')
# A aceleração da gravidade na Terra ao nível do mar e à latitude de 45°,
# possui o valor aproximado de 9,80665 m/s²
def h(t,h0=h0,v0=v0,g=9.80665): return h0 + (v0 * t) - ((g/2)*t**2)
h(t,h0,v0,g)
```

### Problema

Podemos realizar um gráfico para o seguinte exemplo de queda livre: 
Um objeto é solto de uma altura inicial $ h_0 = 200m, v_0 = 0ms^{-1}.$

Pede-se o gráfico da altura $ h(t) $ para $ t > 0 $ e quanto tempo esse objeto leva para alcançar o solo.


```
h(t,200,0)

eixo_x = list()
eixo_y = list()

zero = list()

for i in np.arange(-20,20,step=0.1):
  eixo_y.append(h(i,200,0))
  eixo_x.append(i)
  zero.append(0)

plt.plot(eixo_x,eixo_y)

# Desenha eixos
plt.plot(eixo_x,zero,color="black")
plt.plot(zero,eixo_y,color='black')

# Raíz do polinômio é quando f(x) = 0
round(h(6.382,200,0))
```



## Juros 

Os juros são divididos entre simples ou compostos. 

### Juros Simples

$ J(C,i,n) = Cin$

**Valor futuro de uma aplicação financeira:**

$ C + J(C,i,n) = C(1+in)  $

**Onde:**

*   C --> Capital inicial
*   i --> Taxa de Juros
*   n --> Período

Capital inicial também é conhecido como Valor presente:

$ VF = VP(1+in)  $


**Exemplo:** Considere um capital inicial $ C= 10000,00$ capitalizado  com uma taxa de juros $ i = 0,01 $ ao mês.

*   Qual é o valor montante VF depois de 10 meses?
*   Faça um gráfico de VF pelo tempo.


```
var ('i n vp')
def vf(i,n,vp): return vp*(1+i*n)

VF = vf(0.01,10,10000)
print('O montante final foi de: R$', VF)
```

    O montante final foi de: R$ 11000.0



```
eixo_x = list()
eixo_y = list()

for t in np.arange(0,10, step=0.1):
  eixo_x.append(t)
  eixo_y.append(vf(0.01,t,10000))

plt.plot(eixo_x,eixo_y)
```

### Juros Compostos

Fórmula dos juros compostos e uma comparação:

**Juros compostos:**

$ VF(VP,i,n,) = VP(1+i)^2  $

**Juros simples:**

$ VF = C + J(C,i,n) = C(1+in)  $



```
# Definindo função de juros compostos
def vf_c(i,n,vp): return vp*(1+i)**n
```


```
eixo_x = list()
eixo_y = list()

eixo_y2 = list()

for t in np.arange(0,30, step=0.1):
  eixo_x.append(t)
  eixo_y.append(vf(0.03,t,100))

  eixo_x2.append(t)
  eixo_y2.append(vf_c(0.03,t,100))

plt.plot(eixo_x,eixo_y)
plt.plot(eixo_x,eixo_y2)
```

## Função exponencial

**Definição:**
É uma função contínua da variável “x” que depende de um parâmetro “C”, que é chamado de base.

 Esse “C” é um número real/positivo e todo esse “C” está elevado a uma função contínua e bem-comportada da variável “x”. E “g(x)” pode ter sinal positivo ou negativo.

 $ f(x) = C ^{g(x)}$

**Usos mais comuns:** 

$ C=2, C=10, C=e = 2,71828183... $

Estimativas numéricas para o $ e $:

$ e = \lim_{x \to oo} ( 1 + \dfrac{1}{x})^{x}$

**Usos mais comuns:** 

$ f(x) = e^{x}$

$h(x) = e^{-x}$

**Exemplo:**  Em uma reportagem de março de 2020 do Jornal Nacional, foi mostrado o dado de que, a cada pessoa que contrai o virus coronavirus, ela passa para duas pessoas.

 Pensando em estimar o contágio na população, crie uma função que represente esse dado de contaminação.


```
var('k')
def N(k): return 2**k
N(10)
```

# Limites

Podemos usar o SymPy para calcular o limite de uma função quando  x  tende a um ponto.

## Exemplo 03: Calculando Limites


```
# define x e y como variáveis simbólicas
var('x y')

# Definindo função
f = Lambda(x, (x**2 -1))

# Limite da função f(x) quando x tende a 2
r1 = limit(f(x),x,2)

# Limite da função f(x) quando x tende a -1
r2 = limit(f(x),x,-1)

# Limite da função f(x) quando x tende a 5
r3 = limit(f(x),x,5)

print(r1,r2,r3)
```

    3 0 24


### Gráfico da Função


```
def f(x): return (x**2 -1)

lista_ex03 = list()

x = 5

eixo_x_ex03 = []
raiz = []

for i in np.arange(-1,x,step=0.1):
  lista_ex03.append(f(i))
  eixo_x_ex03.append(i)

# Gráfico
fig, ax = plt.subplots()

# Título do gráfico
plt.title('Gráfico da Função')

plt.plot(eixo_x_ex03,lista_ex03)

# Limites
plt.plot(2,r1, marker='o',color='black')
plt.plot(-1,r2, marker='o',color='black')
plt.plot(5,r3, marker='o',color='black')
```

## Calculando Limites Laterais

Como padrão, a função ```limit()```
calcula o limite lateral pela direita.




```
limit(1/y, y, 0)
```

para calcularmos o limite lateral pela esquerda, basta digitar:


```
limit(1/y, y, 0, '-')
```

### Exemplo 04

Devido aos limites laterais não coincidirem, o limite da função não existe.


```
lista_ex04 = list()
eixo_x_ex04 = list()

for x in np.arange(0,6, step=0.1):
  if (x<3):
    lista_ex04.append(1+x**2)
  else:
    lista_ex04.append(20)
  eixo_x_ex04.append(x)

plt.plot(eixo_x_ex04,lista_ex04)
```


```
# Limite de x quando x tende a 3
limite01 = limit(1+x**2, x, 3, '-')

# Limite de x quando x tende a 3
limite02 = limit(20, x, 3)

print('O limite pela direita é de:', limite01 )
print('enquanto o limite pela esquerda é de:' , limite02 )
```

    O limite pela direita é de: 35.8100000000000
    enquanto o limite pela esquerda é de: 20


**Conclusão:** Os limites laterais refletem o fato de que podemos nos aproximar de um dado valor, quer seja pela esquerda ou pela direita.

Em alguns casos, o valor resultante do limite pode ser igual pela equerda e pela direita, mas em outros pode não ser.

## Propriedades Limites: Parte 1

1 - O limite da soma de duas funções quando x se aproxima de x0, é igual à soma dos limites das funções.

$
\lim_{x \to x0} (f(x) + g(x))= \lim_{x \to x0} f(x) + \lim_{x \to x0} g(x)
$


2 - Propriedade da multiplicação por escalar do Limite:

$
\lim_{x \to x0} C( f(x))= C \lim_{x \to x0} f(x)
$

### Soma de **Funções**


```
def f(z): return z + 1
def g(z): return z

soma_funcoes = f(z) + g(z)
print('O limite da soma das funções é:',limit(soma_funcoes,z, 1))

soma_limites = limit(g(z),z,1) + limit(f(z),z,1)

print('A soma dos limites das funções é:',soma_limites)

```

    O limite da soma das funções é: 3
    A soma dos limites das funções é: 3


### Constante vezes função


```
soma_funcoes = 4 * (f(z) + g(z))
print('O limite da soma das funções é:',limit(soma_funcoes,z, 1))

soma_limites = 4 * (limit(g(z),z,1) + limit(f(z),z,1))

print('A soma dos limites das funções é:',soma_limites)
```

    O limite da soma das funções é: 12
    A soma dos limites das funções é: 12


## Propriedades Limites: Parte 2

1 - O limite do produto das funções é equivalente ao produto dos limites.

$
\lim_{x \to x_0} f(x)  *g(x) = \lim_{x \to x_0} f(x) * \lim_{x \to x_0} g(x)
$

2 - O limite da divisão das funções é equivalente à divisão dos limites.

$
\lim_{x \to x_0} \dfrac{f(x)}{g(x)} =  \dfrac{\lim_{x \to x_0}f(x)}{\lim_{x \to x_0} g(x)}
$


**Desde que:**

$
\lim_{x \to x_0} g(x) \neq 0
$


```
# Reutilizando as funções já criadas na parte 01
print(f(z),g(z),'\n')

produto_funcoes = f(z) * g(z)
print('O limite do produto das funções é:',limit(produto_funcoes, z, 2))

produto_limites = limit(f(z),z, 2) * limit(g(z), z, 2)
print('O limite do produto dos limites é:',limit(produto_limites, z, 2))

print()
try: 
  divisao_funcoes = f(z) / g(z)
  print('O limite da divisão das funções é:',limit(divisao_funcoes, z, 2))

  divisao_limites = limit(f(z),z, 2) / limit(g(z), z, 2)
  print('O limite da divisão dos limites é:',limit(divisao_limites, z, 2))
except:
  print('g(x) == 0')
```

    z + 1 z 
    
    O limite do produto das funções é: 6
    O limite do produto dos limites é: 6
    
    O limite da divisão das funções é: 3/2
    O limite da divisão dos limites é: 3/2


## Existência do Limite


```
var('x')
def f(x): return 2*x**2

eixo_x_ex05 = list()
eixo_y_ex05 = list()

for i in np.arange(0,5, step= 0.1):
  eixo_x_ex05.append(i)
  eixo_y_ex05.append(f(i))

plt.plot(eixo_x_ex05,eixo_y_ex05)
```


```
print('Limite Lateral pela Direita:',limit(f(x),x,2))
print('Limite Lateral pela Esquerda:',limit(f(x),x,2,'-'))
```

    Limite Lateral pela Direita: 8
    Limite Lateral pela Esquerda: 8


8f843b6dba52366a3a39469f1bfd50bb0344f0f2
ipynb
Jupyter Notebook
GoogleColab/Calculo/Funcoes.ipynb
gabrielvieiraf/ProjetosPython
d8cf8eb28ebe1d0bf8319cb5500028c1d2a71ef9
MIT
2021-06-23T23:48:39.000Z
2021-06-23T23:48:39.000Z
GoogleColab/Calculo/Funcoes.ipynb
gabrielvieiraf/ProjetosPython
d8cf8eb28ebe1d0bf8319cb5500028c1d2a71ef9
MIT
GoogleColab/Calculo/Funcoes.ipynb
gabrielvieiraf/ProjetosPython
d8cf8eb28ebe1d0bf8319cb5500028c1d2a71ef9
MIT
2021-06-23T21:59:10.000Z
2021-06-23T23:49:00.000Z
Qwen/Qwen-72B
1. YES
2. YES