# ÁLGEBRA LINEAR COMPUTACIONAL

## SEGUNDA AVALIAÇÃO - 2020.2 - PROFESSOR ERITO MARQUES   

---
### GRUPO:
**Ícaro Santos Barcelos Pereira - _2017780187_**\
**Leandro Bataglia Pereira - _2018780199_**\
**Pedro Henrique Farolfi Camelo - _2018780326_**

---

Repositório dos algoritmos solicitados na segunda prova da disciplina de Álgebra Linear Computacional.
##### Instruções:
As respostas devem ser enviadas no formato jupyter notebook.\
Os trabalhos devem ser feitos em grupo. Não é permitida troca de informações entre os grupos.\
Fixada a data de entrega, não serão aceitos trabalhos entregues fora dessa data.


```python
import numpy as np
import pandas as pd
import normas
from cholesky import decomposicao_cholesky
from gauss import eliminacao_gauss
from fatoracaoLU import fatoracaoLU
from sympy import Matrix, init_printing
init_printing()
#BIBLIOTECA QUE NÃO ESTOU USANDO MAS PODE SER ÚTIL PARA EXIBIR AS MATRIZES/VETORES = display(Matrix(*variavel que representa o dado*)
```


```python
# Coverti isso aqui em um procedimento, a parada é que vc pode mandar isso 
# ocorrer no início de qualquer célula e pode alterar o excel em tempo de execução :)

# CONVERSÃO DOS DADOS EM ARRAYS DA NUMPY COM TYPE 'float64'
def ler():
    df_matriz = pd.read_excel(r"dados/matriz_A.xlsx", header=None) # Le o arquivo do excel que contém a matriz A sem cabeçalho
    df_vetor = pd.read_excel(r"dados/vetor_b.xlsx", header=None) # Le o arquivo do excel que contém o vetor b sem cabeçalho
    matriz = np.array(df_matriz, dtype='f8') # Converte a matriz A em um array da numpy
    vetor = np.ravel(np.array(df_vetor, dtype='f8')) # Converte o vetor b em um array da numpy
    return matriz, vetor
```

### 1) Implemente um algoritmo que leia uma matriz A e um vetor b (de uma planilha excel) e avalie:
**a)** se A é tridiagonal;


```python
def verifica_tridiagonal(matriz_A):
    linhas, colunas = np.shape(matriz_A)

    for i in range(linhas):
        for j in range(colunas):
            if np.abs(i-j) <= 1 and matriz_A[i,j] == 0:
                return False
            if np.abs(i-j) >= 2 and matriz_A[i,j] != 0:
                return False
    return True
```


```python
matriz, vetor = ler()
verifica_tridiagonal(matriz)
```




    False



**b)** se A é triangular superior;


```python
def verifica_tri_superior(matriz_A):
    linhas = len(matriz_A)

    for i in range(linhas):
        for j in range(i):
            if matriz_A[i,j] != 0:
                return False
    return True
```


```python
matriz, vetor = ler()
verifica_tri_superior(matriz)
```




    False



**c)** se A é triangular inferior;


```python
def verifica_tri_inferior(matriz_A):
    colunas = len(matriz_A[0])

    for j in range(colunas):
        for i in range(j):
            if matriz_A[i,j] != 0:
                return False
    return True
```


```python
matriz, vetor = ler()
verifica_tri_inferior(matriz)
```




    False



**d)** se Traço de A é maior que 4.


```python
def traco(matriz_A):
    linhas, colunas = np.shape(matriz_A)
    n, traco = min((linhas, colunas)), 0

    for i in range(n):
        traco += matriz_A[i,i]
    if traco > 4:
        print("O traço da matriz é maior que 4")
        return True
    print("O traço da matriz não é maior que 4")
    return False
```


```python
matriz, vetor = ler()
traco(matriz)
```

    O traço da matriz é maior que 4





    True



---
### 2) Implemente um algoritmo que leia uma matriz A (triangular) e um vetor b (de uma planilha excel) e resolva o sistema Ax = b por substituição para frente ou para trás conforme o caso.


```python
# TESTE DO ALGORITMO DE DECOMPOSIÇÃO DE CHOLESKY E NORMA RESIDUAL (cholesky.py, normas.py) '''
matriz, vetor = ler()
delta_x = decomposicao_cholesky(matriz, vetor)

if delta_x != None:
    print("Vetor x resultado da Decomposição de Cholesky:\n",delta_x,"\n")
    normas.residual(matriz, vetor, delta_x)
```


```python
# TESTE DO ALGORITMO DE ELIMINAÇÃO DE GAUSS E NORMA RESIDUAL (gauss.py, normas.py) '''
delta_x = eliminacao_gauss(matriz, vetor)

if delta_x != None:
    print("Vetor x resultado da Eliminação de Gauss:\n",delta_x,"\n")
    normas.residual(matriz, vetor, delta_x)
    print("\n")
```


```python
# TESTE DO ALGORITMO DE FATORAÇÃO LU E NORMA RESIDUAL (fatoracaoLU.py, normas.py)'''
delta_x = fatoracaoLU(matriz,vetor)

if delta_x != None:
    print("Vetor x resultado da Fatoração LU:\n",delta_x,"\n")
    normas.residual(matriz, vetorÍcaro, delta_x)
```


```python

```

7525ce44ac01c3e0254d850450185f6e0e9ae454
ipynb
Jupyter Notebook
.ipynb_checkpoints/run-checkpoint.ipynb
eRRe-i/algebra-linear-computacional
f2caffdb33aed0fad9d811b20f6505ad6513d824
MIT
.ipynb_checkpoints/run-checkpoint.ipynb
eRRe-i/algebra-linear-computacional
f2caffdb33aed0fad9d811b20f6505ad6513d824
MIT
.ipynb_checkpoints/run-checkpoint.ipynb
eRRe-i/algebra-linear-computacional
f2caffdb33aed0fad9d811b20f6505ad6513d824
MIT
2021-07-23T02:07:55.000Z
2021-07-23T02:07:55.000Z
Qwen/Qwen-72B
1. YES
2. YES