## Importando uma função


```python
import numpy as np
```

## Usando uma função/como gerar um array


```python
a = np.array([1, 2, 3])
print(a)
```

    [1 2 3]



```python
a = np.array([[1, 2, 3], 
              [4, 5, 6],
              [1, 1, 1]])
print(a)
```

    [[1 2 3]
     [4 5 6]
     [1 1 1]]


## Como inverter matriz


```python
i = np.linalg.inv(a)
print(i)
```

    [[-1.2009599e+16  1.2009599e+16 -3.6028797e+16]
     [ 2.4019198e+16 -2.4019198e+16  7.2057594e+16]
     [-1.2009599e+16  1.2009599e+16 -3.6028797e+16]]


## Arrendondando matriz


```python
b = np.arange(1, 10.1, 1.332)
print(b)
b = np.around(b, 2)
print(b)
```

    [1.    2.332 3.664 4.996 6.328 7.66  8.992]
    [1.   2.33 3.66 5.   6.33 7.66 8.99]


## Arange vs Linspace


```python
# Voçê decide o passo e a função escolhe o tamanho
x = np.arange(step=2, stop=4, start=0)
print(x)
```

    [0 2]



```python
# Voçê decide o tamanho e a função escolhe o passo
y = np.linspace(0, 155, 7)
print(y)
```

    [  0.          25.83333333  51.66666667  77.5        103.33333333
     129.16666667 155.        ]


## Plotando grafico


```python
import matplotlib.pyplot as plt
```


```python
x = np.arange(10)
y = 2*x
z = 3*x
plt.plot(x, y, label='2x')
plt.plot(x, z, label='3x')
plt.xlabel('x')
plt.legend()
plt.show()
#show() plota o grafico com tds os comandos plt acima dele até chegar num outro show()
plt.plot(x, y, label='2x')
plt.plot(x, z, label='3x')
plt.xlabel('x')
plt.legend()
plt.show()
```


```python
a = np.array([1, 2, 3, 4, 5, 6])
print(f'{a[0]}\n{a[-1]}\n{a[2:5]}')
```

    1
    6
    [3 4 5]



```python
a = a.reshape([2, 3])
print(a)
```

    [[1 2 3]
     [4 5 6]]



```python
a = np.eye(3)
print(a)
```

    [[1. 0. 0.]
     [0. 1. 0.]
     [0. 0. 1.]]



```python
from scipy.linalg import toeplitz
e = toeplitz([1, 0, -1, -2], [1, 2, 3, 4])    #Escreve uma matriz([d, d-1, d-2, ...], [d(n), d+1, d+2, ...])
print(e)
```

    [[ 1  2  3  4]
     [ 0  1  2  3]
     [-1  0  1  2]
     [-2 -1  0  1]]



```python
a = np.array([[1, 2, 3],
              [2, 1, 2],
              [3, 2, 1]])
a = np.linalg.inv(a)
print(a)
```

    [[-0.375  0.5    0.125]
     [ 0.5   -1.     0.5  ]
     [ 0.125  0.5   -0.375]]



```python
a = np.array([[1, 1, 1],
                  [2, 2, 2],
                  [3, 3, 3]])
b = np.transpose(a)
print(a)
print(b)
```

    [[1 1 1]
     [2 2 2]
     [3 3 3]]
    [[1 2 3]
     [1 2 3]
     [1 2 3]]



```python
a = np.array([[1, 2, 3],
              [2, 1, 2],
              [3, 2, 1]])
b = np.array([[1, 1, 1],
              [2, 2, 2],
              [3, 3, 3]])
c = np.dot(a, b)
print(c)
```

    [[14 14 14]
     [10 10 10]
     [10 10 10]]



```python
a = np.array([[2, 1],
              [3, 4]])
p = np.array([[10],
              [20]])
from scipy.linalg import solve

s = solve(a, p)
print(s)
```

    [[4.]
     [2.]]



```python
from scipy.linalg import lu_factor, lu_solve
lu, piv  = lu_factor(a)
s = lu_solve((lu, piv), p)
print(s)
```

    [[4.]
     [2.]]



```python
from sympy import *
```


```python
f = lambda x: 1/x
x = symbols ('x')
```


```python
l = limit(f(x), x, 0)
print(l)
```

    oo



```python
print(l + 1)
```

    oo



```python
from scipy.misc import derivative
d = derivative(f, 1, dx=1e-10, n=1)
print(d)
```

    -1.000000082740371



```python

print(f'{d:.2f}')
```

    -1.00



```python
y = lambda x: x**2
v = symbols('v')
i = integrate(y(v), (v , 1, 2))
print(i)
print(type(i))
a = float(i)
print(a)
print(type(a))
```

    7/3
    <class 'sympy.core.numbers.Rational'>
    2.3333333333333335
    <class 'float'>



```python
i = float(integrate(f(v), (v , 1, 2)))
print(i)
```

    0.6931471805599453



```python
print(type(i))
```

    <class 'float'>



```python
import matplotlib.pyplot as plt
D = lambda x: 12 - 2*x
S = lambda x: 20*x
x = [i for i in range(0, 1000)]
dx = [D(i) for i in range(0, 1000)]
sx = [S(i) for i in range(1000, 0, -1)]
plt.plot(dx, x)
plt.plot(sx, x)
plt.show()
```


```python
import matplotlib.pyplot as plt
import numpy as np
    
def f(x):
    return x

def g(x):
    return x**2

def h(x):
    return 2*x

x = np.arange(-5, 6, 1)
y = [f(i) for i in x]
z = [g(i) for i in x]
w = [h(i) for i in x]
#cria uma lista com os valores de y para cada valor de x
    
plt.plot(x, y, label='y = x')
plt.plot(x, z, 'r--', label='y = x**2')
plt.plot(x, w, 'g-o', label='y = 2x')
plt.title('Titulo desejado')
plt.xlabel('Eixo X')
plt.ylabel('Eixo Y')
plt.legend(loc='best')
plt.tight_layout()
plt.style.use('ggplot')
plt.grid()
plt.show()
```


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

preco = np.array([8, 7, 6, 5, 4, 3, 2, 1, 0])
quant = np.array([0, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000])

plt.plot(quant, preco)
plt.ylabel('Preço(R$)')
plt.xlabel('Quantidade comprada')
plt.title('Quantidade x Preço')
plt.tight_layout()
plt.style.use('ggplot')
plt.show()
```


```python
pontos = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']

```


```python
def elasticidade(P, PN, Q, QN):
    Num = abs((Q - QN)/((Q + QN)/2))
    Dem = abs((P - PN)/((P + PN)/2))
    return Num/Dem
```


```python
for i in range(len(pontos)-1):
    r = elasticidade(preco[i], preco[i+1], quant[i], quant[i+1])
    print(f'Entre os pontos {pontos[i]} e {pontos[i+1]} a elasticidade vale {r:.2f}')
```

    Entre os pontos A e B a elasticidade vale 15.00
    Entre os pontos B e C a elasticidade vale 4.33
    Entre os pontos C e D a elasticidade vale 2.20
    Entre os pontos D e E a elasticidade vale 1.29
    Entre os pontos E e F a elasticidade vale 0.78
    Entre os pontos F e G a elasticidade vale 0.45
    Entre os pontos G e H a elasticidade vale 0.23
    Entre os pontos H e I a elasticidade vale 0.07



```python

```

6b8117b1d8305f16f525f9d27d8b098ce0c5a214
ipynb
Jupyter Notebook
Monitoria 1.ipynb
ViniciusRCortez/Monitoria-de-metodos-numericos-com-python
85678fe8907752533d0dc97dc83550411ba079f0
MIT
Monitoria 1.ipynb
ViniciusRCortez/Monitoria-de-metodos-numericos-com-python
85678fe8907752533d0dc97dc83550411ba079f0
MIT
Monitoria 1.ipynb
ViniciusRCortez/Monitoria-de-metodos-numericos-com-python
85678fe8907752533d0dc97dc83550411ba079f0
MIT
Qwen/Qwen-72B
1. YES
2. YES