<jupyter_start><jupyter_text>Exercício de Programação 1**Prazo de submissão: 23:55 do dia 04.01.2021** 2020.2 Álgebra Linear Computacional - DCC - UFMGErickson - FabricioInstruções:* Antes de submeter suas soluções, certifique-se de que tudo roda como esperado. Primeiro, **reinicie o kernel** no menu, selecione Kernel$\rightarrow$Restart e então execute **todas as células** (no menu, Cell$\rightarrow$Run All)* Apenas o arquivo .ipynb deve ser submetido. Ele não deve ser compactado.* Não deixe de preencher seu nome e número de matrícula na célula a seguir **Nome do aluno:** <NAME>**Matricula:** 2020054293  Questão 1Dadas as matrizes $A$, $B$ e o vetor $C$:$$A = \begin{bmatrix} 2 & 1 & 3\\ 3 & 1 & 4\\ 5 & 7 & 12\end{bmatrix}_{3\times 3}\qquadB = \begin{bmatrix} 1 & 0 & 0\\ 0 & 1 & 0\\ 0 & 0 & 1\end{bmatrix}_{3\times 3}\qquadC = \begin{bmatrix} 3 \\ 1 \\ 2\end{bmatrix}_{3\times 1}$$Gere as matrizes D, E e o vetor F tal que:$$D = A B \\E = A^\top + B\\F = A  C$$*Dicas:** *Imprima ```A.shape, B.shape, C.shape``` e confira se as dimensões de suas matrizes batem com a descrição do enunciado.** As operações de produto e transposição estão definidas na documentação da biblioteca ```numpy```.<jupyter_code># Código para Exercício 1
import numpy as np
A = np.array([[2,1,3], [3,1,4], [5,7,12]])
B = np.eye(3, dtype=int)
C = np.array([[3],[1],[2]])
D = np.matmul(A, B)
E = np.transpose(A) + B
F = np.matmul(A, C)
print(D)
print(E)
print(F)<jupyter_output>[[ 2  1  3]
 [ 3  1  4]
 [ 5  7 12]]
[[ 3  3  5]
 [ 1  2  7]
 [ 3  4 13]]
[[13]
 [18]
 [46]]<jupyter_text>Questão 2  Questão 2.1Uma forma de representar um vetor no espaço é através de um ponto localizado na extremidade da "seta" do vetor. Essa representação é especialmente útil quando queremos vizualizar uma grande quantidade de vetores. Crie um array chamado `dados`, de tamanho $n \times 2$, em que cada linha represente um dos seguintes vetores de tamanho 2:- $(\ 0.7,\ 0.7\ )$- $(\ 0.0,\ 1.0\ )$- $(\ -0.7,\ 0.7\ )$- $(\ -1.0,\ 0.0\ )$- $(\ -0.7,\ -0.7\ )$- $(\ 0.0,\ -1.0\ )$- $(\ 0.7,\ -0.7\ )$- $(\ 1.0,\ 0.0\ )$Você pode achar a documentação do [`np.array`](https://numpy.org/doc/stable/reference/generated/numpy.array.html) útil.<jupyter_code># Código para Exercício 2.1
dados = np.array([
    [0.7, 0.7],
    [0, 1],
    [-0.7, 0.7],
    [-1, 0],
    [-0.7, -0.7],
    [0, -1],
    [0.7, -0.7],
    [1, 0]]
)
print(dados)<jupyter_output>[[ 0.7  0.7]
 [ 0.   1. ]
 [-0.7  0.7]
 [-1.   0. ]
 [-0.7 -0.7]
 [ 0.  -1. ]
 [ 0.7 -0.7]
 [ 1.   0. ]]<jupyter_text>Questão 2.2Vamos agora visualizar esses pontos no espaço 2D. Para isso, podemos usar a biblioteca [`matplotlib`](https://matplotlib.org/). Agora, com as coordenadas $x$ e $y$ dos pontos do exercício anterior, crie um gráfico de dispersão que mostre cada ponto no plano. Voce pode achar a documentação de [`plt.scatter`](https://matplotlib.org/3.1.0/api/_as_gen/matplotlib.pyplot.scatter.html) útil, além da dica que para escolher a coluna $i$ de um array bi-dimensional usamos `x[:, i]` (consulte essa página sobre [indexing](https://numpy.org/doc/stable/reference/arrays.indexing.html) em `numpy.arrays` para mais detalhes).<jupyter_code># Código para Exercício 2.2
import matplotlib.pyplot as plt
for dado in dados:
    plt.scatter(dado[0], dado[1])
plt.show()<jupyter_output><empty_output><jupyter_text>Questão 2.3Agora que temos como visualizar os vetores no plano, vamos fazer operação de adição de vetores. Crie um array que represente um vetor $\textbf{a}=(\ 6,\ 9\ )$ e adicione-o a todos os vetores no nosso array, criando um novo array chamado `novos_dados`.**Dica**: Quando estamos tratando de matrizes, não podemos simplesmente adicionar uma matriz de tamanho $n \times 2$ por um vetor de tamanho $2$, ou $1 \times 2$. Porém, o `numpy` tem uma funcionalidade que é muito útil quando queremos fazer operações entre arrays que não possuem o mesmo tamanho, como é o nosso caso (podemos ver isso usando: `print(dados.shape, a.shape)`). Essa funcionalidade é o [broadcasting](https://numpy.org/doc/stable/user/basics.broadcasting.html), e ela nos ajuda a fazer operações entre arrays que não possuem o mesmo tamanho, mas algumas dimensões são compatíveis.<jupyter_code># Código para Exercício 2.3
a = np.array([6, 9])
novos_dados = dados + a
print(novos_dados)<jupyter_output>[[ 6.7  9.7]
 [ 6.  10. ]
 [ 5.3  9.7]
 [ 5.   9. ]
 [ 5.3  8.3]
 [ 6.   8. ]
 [ 6.7  8.3]
 [ 7.   9. ]]<jupyter_text>Questão 2.4Note que para somar arrays de dimensões diferentes (nesse caso, dados é 2D e a é 1D), o broadcasting primeiro adiciona dimensões de tamanho 1 ao início do array com menos dimensões. Só depois ele expande as dimensões de tamanho 1 para que casem com os tamanhos das dimensões do outro array.Portanto, devemos pensar no array ```a``` como um vetor coluna ou como um vetor linha? **Resposta:** como um vetor linha, pois assim o tamanho das colunas será igual e o broadcasting será responsável por criar novas linhas iguais à primeira.  Questão 2.5Agora podemos ver no espaço 2D nossos vetores originais e os vetores resultantes da soma. Para isso, podemos usar a mesma função que usamos para criar o gráfico de dispersão na **Questão 2.2**, porém agora queremos mostrar os pontos de 2 arrays, e não de apenas 1.<jupyter_code># Código para Exercício 2.5
for dado in dados:
    plt.scatter(dado[0], dado[1])
for novo_dado in novos_dados:
    plt.scatter(novo_dado[0], novo_dado[1])
plt.show()<jupyter_output><empty_output><jupyter_text>Questão 3Como visto em aula, a multiplicação de uma matriz $G$ por um vetor $\mathbb{x}$ pode ser vista como uma combinação linear das colunas de $G$.  Questão 3.1Dado a matriz $G$ e o vetor $\mathbb{x}$:$$G = \begin{bmatrix} 3 & 6 & 9\\ 5 & 10 & 15\end{bmatrix}_{2\times 3}\qquad\mathbb{x} = \begin{bmatrix} 2 \\ 1 \\ 1\end{bmatrix}_{3\times 1}$$Gere o vetor $\mathbb{y}$ tal que:$$\mathbb{y} = G \mathbb{x} \\$$<jupyter_code># Código para Exercício 3.1
G = np.array([[3,6,9], [5,10,15]])
x = np.array([[2], [1], [1]])
y = np.matmul(G, x)
print(y)<jupyter_output>[[21]
 [35]]<jupyter_text>Questão 3.2O espaço de colunas de uma matriz pode ser interpretado como o espaço formado por todas as combinações lineares das colunas da matriz. Então, vamos simular a representação do espaço de colunas da matriz $G$ criada anteriormente fazendo várias combinações lineares de suas colunas. Para isso, podemos criar vários vetores-coluna $x$ aleatórios, calcular a operação $y = Gx$ para cada um deles, e mostrar onde cada vetor $y$ está localizado no espaço. Portanto, faça os seguintes passos:1. Crie um vetor-coluna $x \in \mathbb{R}^{3 \times 1}$ com valores aleatórios entre $-10$ e $10$.1. Calcule $y = Gx$. Esse passo pode ser feito da mesma forma que a **Questão 3.1**.1. Plote no plano 2D um ponto com as coordenadas do $y$ resultante.Repita esses passos 10 vezes. **Dica:** para a criação dos valores $x$ aleatórios, voce pode escolher os números você mesmo ou usar a função [`np.random.randint`](https://numpy.org/doc/stable/reference/random/generated/numpy.random.randint.html). Para a  visualização, utilize a biblioteca [`matplotlib`](https://matplotlib.org/), e deixe para usar `plt.show()` apenas depois de ter plotado todos os vetores $y$, para que todos apareçam no mesmo gráfico.<jupyter_code># Código para Exercício 3.2
for i in range(10):
    x = np.random.randint(-10, 11, (3,1))
    y = np.matmul(G, x)
    plt.scatter(y[0], y[1])
plt.show()<jupyter_output><empty_output><jupyter_text>Questão 3.3No item anterior, você deve ter obtido uma reta ao visualizar o gráfico resultante. Por que isso acontece no caso dessa matriz $G$ em específico? **Resposta:** porque as linhas da matriz G são linearmente dependentes, ou seja, é possível escrever uma das linhas como combinação linear da outra. Portanto, como há apenas um vetor linearmente independente, o espaço coluna da matriz gera uma reta.  Questão 3.4Agora que sabemos que o espaço coluna da matriz $G$ é uma reta, encontre dois pontos no espaço coluna $C(G)$ e use o comando ```plt.plot()``` para traçá-la.<jupyter_code># Código para Exercício 3.4
x1 = np.random.randint(-10, 11, (3,1))
y1 = np.matmul(G, x1)
x2 = np.random.randint(-10, 11, (3,1))
y2 = np.matmul(G, x2)
plt.plot(y1, y2)
plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.13570391872278664, 'fraction_numerical': 0.04112239961296565, 'mean_word_length': 3.999395405078597, 'pattern_counts': {'":': 0, '<': 30, '<?xml version=': 0, '>': 30, 'https://': 7, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '8', 'dir': 'jupyter-structured-clean-dedup', 'id': '259244', 'license': 'MIT', 'n_tokens_mistral': 3414, 'n_tokens_neox': 3210, 'n_words': 1102, 'path': 'src/eps/exercicios/EP1.ipynb', 'repo_name': 'stemDaniel/linear-algebra', 'size': '8288'}