#!/usr/bin/env python
# coding: utf-8

# # Problemas de Mínimos Quadráticos
# #### Até agora, preocupamo-nos essencialmente com sistemas de equações lineares compatíveis. Então, vamos considerar sistemas envolvendo mais equações do que incógnitas. Tais sistemas são, muitas vezes, incompatíveis.

# ##### Leon, Steven J., 1943 - Álgebra Linear com Aplicações/ Steven J. Leon; tradução Valéria de Magalhães Iório - [reimpr]. Rio de Janeiro: LTC, 2008.

# ### Aplicação 1: Lei de Hooke

# A **_Lei de Hooke_** diz que a força aplicada a uma mola é proporcional ao comprimento de seu alongamento. Então, se **F** é a força aplicada e **x** é o alongamento da mola, então **F = kx**. A constante de proporcionalidade **k** é a _constante da mola_.

# Na disciplina de Física Experimental I, alguns alunos de Engenharia Elétrica da UFCG querem determinar a _constante da mola_ **k** para uma determinada mola. Eles aplicam forças de **13**, **22** e **36** _newtons_, que alongam a mola em **10**, **18** e **28** centímetros, respectivamente. Usando a **_Lei de Hooke_**, eles obtêm o seguinte sistema de equações:

# |**Sistema de Equações:**|
# |:----------------------:|
# |**0.10k = 13**          |
# |**0.18k = 22**          |
# |**0.28k = 36**          |

# Definindo a **Matriz Ampliada** para esse sistema, poderemos escrevê-lo da seguinte forma:

# $$\begin{bmatrix}
#           0.10 \\
#           0.18 \\
#           0.28 \\
#           \end{bmatrix} \begin{bmatrix}
#                                 k \\
#                                 \end{bmatrix} = \begin{bmatrix}
#                                                         13 \\
#                                                         22 \\
#                                                         36 \\
#                                                         \end{bmatrix}$$

# Graficamente, vamos observar as coordenadas **(x,F)** e analisar o seu comportamento. Se o valor de **k**, dada as três equações, estiver convergindo para um único valor, teremos a construção de uma reta.

# In[231]:


# importando a biblioteca numpy do Python
import numpy as np
# importando a biblioteca de funções do Python matplotlib
import matplotlib 
import matplotlib.pyplot as plt
get_ipython().run_line_magic('matplotlib', 'inline')


# In[232]:


# Valores de F e x para a primeira equação do sistema
x1, f1 = 0.10, 13
# Valores de F e x para a segunda equação do sistema
x2, f2 = 0.18, 22
# Valores de F e x para a terceira equação do sistema
x3, f3 = 0.28, 36
# uma lista com todos os valores de x do sistema de equações
x = [x1, x2, x3]
# uma lista com todos os valores de F do sistema de equações
f = [f1, f2, f3]
# definindo o tamanho do gráfico
plt.figure(figsize = (10, 5))
# plotandos os pontos definidos da primeira equação
plt.scatter(x1, f1, color = "red", label = "Coordenadas (x,F) Obtidas no Experimento")
# plotandos os pontos definidos da segunda equação
plt.scatter(x2, f2, color = "red")
# plotandos os pontos definidos da terceira equação
plt.scatter(x3, f3, color = "red")
# plotando o traço entre todos os pontos dos gráficos definidos
plt.plot(x, f, label = "Gráfico que Liga Todos os Pontos (x,F)")
# colocando uma grade no gráfico
plt.grid(True)
# remove a moldura do gráfico
plt.box(False)
# adiciona a etiqueta definida no gráfico plotado
plt.legend()
# adicionando o título do gráfico plotado
plt.title("Valores Obtidos por Cada Aluno na Experiência")


# Esse sistema é claramente **incompatível**. Já que cada uma das equações corresponde a um valor diferente de **k**. Além disso, se você estudou o progama sobre _"Estudo de Sistema de Equações"_, você pode observar que o gráfico que liga todos os pontos dos valores obtidos pelos alunos na experiência, não formam uma reta. Então, por mais próximo que seja o valor de **k**, eles não convergem a uma solução única. Em vez de usar um desses valores, os alunos decidem calcular a solução de mínimos quadráticos para o sistema.

# ### Mínimos Quadráticos

# Até agora, preocupamo-nos essencialmente com sistemas de equações lineares compatíveis. Então, vamos considerar sistemas envolvendo mais equações do que incógnitas. Tais sistemas são, muitas vezes, incompatíveis. Então, dado um sistema $m_{x}n$ **Ax = b** com **m > n**, não podemos esperar, em geral, encontrar um vetor **x** ∈ $R^{n}$ para o qual **Ax** seja igual a **b**. Em vez disso, vamos procurar um vetor **x** para o qual **Ax** está "o mais próximo possível" de **b**.

# Temos um sistema **Ax = b**.

# que pode ser colocado da seguinte forma com a **Matriz Ampliada**:

# $$\begin{bmatrix}
#           a_{11} & a_{12} & ... & a_{1n} \\
#           a_{21} & a_{22} & ... & a_{2n} \\
#           :      & :      & ... & : \\
#           a_{m1} & a_{m2} & ... & a_{mn} \\
#           \end{bmatrix} \begin{bmatrix}
#                                 x_{1} \\
#                                 x_{2} \\
#                                 :     \\
#                                 x_{n} \\
#                                 \end{bmatrix} = \begin{bmatrix}
#                                                         b_{1} \\
#                                                         b_{2} \\
#                                                         :     \\
#                                                         b_{n} \\
#                                                         \end{bmatrix}$$

# Quando o sistema de equações é incompátivel, podemos encontrar valores aproximados para $x_{n}$ utilizando a seguinte fórmula:

# $$A^{T}Ax = A^{T}b$$

# que também pode ser simplificada, para facilitar aplicações computacionais, da seguinte forma:

# $$x = (A^{T}A)^{-1}A^{T}b$$

# ### Aplicação 1: Lei de Hooke

# Voltando ao exemplo anterior, vamos aplicar a fórmula acima e tentar estimar um valor para **k**, dada o sistema de equações abaixo:

# |**Sistema de Equações:**|
# |:----------------------:|
# |**0.10k = 13**          |
# |**0.18k = 22**          |
# |**0.28k = 36**          |

# Vamos definir a **matriz ampliada** **A** e a matriz **b**:

# In[233]:


# definindo a matriz ampliada A
A = np.array([[x1], [x2], [x3]])
# definindo a matriz b
b = np.array([[f1], [f2], [f3]])


# In[234]:


# imprimindo a matriz ampliada A
print("A matriz ampliada A é:\n\n", A)


# In[235]:


# imprimindo a matriz b
print("A matriz b é:\n\n", b)


# E com essas matrizes, vamos usá-las na fórmula:

# - $$A^{T}Ax = A^{T}b$$
# que se resume em:
# - $$x = (A^{T}A)^{-1}A^{T}b$$

# In[236]:


# definindo a matriz k
k = np.dot(np.dot(np.linalg.pinv(np.dot(A.transpose(), A)), A.transpose()), b)


# In[237]:


# imprimindo o valor de x
print("O valor de k, obtido usando a técnica de mínimos quadráticos é: k = {:.3f}".
      format(k[0][0]))


# Observe agora qual seria os valores de **x** e **F**, da fórmula **F = kx**, nas coordenadas do gráfico (ponto verde), após ser utilizado o método dos **mínimos quadráticos**.

# In[238]:


print("Usando o método de mínimos quadráticos, Teremos a Lei de Hooke: {:.4f}k = {:.2f}".
      format((np.dot(A.transpose(), A))[0][0], (np.dot(A.transpose(), b))[0][0]))


# In[239]:


# Valores de F e x para a primeira equação do sistema
x1, f1 = 0.10, 13
# Valores de F e x para a segunda equação do sistema
x2, f2 = 0.18, 22
# Valores de F e x para a terceira equação do sistema
x3, f3 = 0.28, 36
# uma lista com todos os valores de x do sistema de equações
x = [x1, x2, x3]
# uma lista com todos os valores de F do sistema de equações
f = [f1, f2, f3]
# definindo o tamanho do gráfico
plt.figure(figsize = (10, 5))
# plotandos os pontos definidos da primeira equação
plt.scatter(x1, f1, color = "red", label = "Coordenadas (x,F) Obtidas no Experimento")
# plotandos os pontos definidos da segunda equação
plt.scatter(x2, f2, color = "red")
# plotandos os pontos definidos da terceira equação
plt.scatter(x3, f3, color = "red")
# plotando o ponto obtido pelo método de mínimos quadráticos
#plt.scatter(np.dot(A.transpose(), A), np.dot(A.transpose(), b), color = "green", 
 #           label = "Coordenada (x,F) Obtida pelo Método de Mínimos Quadráticos")
# plotando o traço entre todos os pontos dos gráficos definidos
plt.plot(x, f, label = "Gráfico que Liga Todos os Pontos (x,F)")
# definindo valores para x entre 0.100 até 0.280
valoresX = np.linspace(0.100, 0.280)
# plotando o gráfico obtido pelo método de mínimos quadráticos
plt.plot(valoresX, k[0][0] * valoresX, color = "Green", 
         label = "Gráfico Obtido Pelo Método de Mínimos Quadráticos")
# colocando uma grade no gráfico
plt.grid(True)
# remove a moldura do gráfico
plt.box(False)
# adiciona a etiqueta definida no gráfico plotado
plt.legend()
# adicionando o título do gráfico plotado
plt.title("Valores Obtidos por Cada Aluno na Experiência")


# ### Aplicação 2: Melhor Reta

# Vamos agora encontrar a melhor reta que aproxima os pontos **(-1,0)**, **(0,1)**, **(1,2)** e **(2,1)**. 

# Lembrando que a equação da reta é 
# - **y = ax + b**

# A partir dessas coordenadas, vamos ter: 

# |**Sistema de Equações:**|
# |:----------------------:|
# |**-a + b = 0**          |
# |**b = 1**               |
# |**a + b = 2**           |
# |**2a + b = 1**          |

# E teremos também os pontos no gráfico

# In[240]:


# definindo o ponto (x,y) da primeira equação
x1, y1 = -1, 0
# definindo o ponto (x,y) da segunda equação
x2, y2 = 0, 1
# definindo o ponto (x,y) da terceira equação
x3, y3 = 1, 2
# definindo o ponto (x,y) da quarta equação
x4, y4 = 2, 1
# definindo uma lista com todas as coordenadas de x
x = [x1, x2, x3, x4]
# definindo uma lista com todas as coordenadas de y
y = [y1, y2, y3, y4]
# definindo o tamanho do gráfico
plt.figure(figsize = (10, 5))
# plotando o ponto definido na primeira equação
plt.scatter(x1, y1, color = "red", label = "Pontos (x,y) Obtidos para o Sistema de Equações")
# plotando o ponto definido na segunda equação
plt.scatter(x2, y2, color = "red")
# plotando o ponto definido na terceira equação
plt.scatter(x3, y3, color = "red")
# plotando o ponto definido na quarta equação
plt.scatter(x4, y4, color = "red")
# plotando o gráfico que liga todos os pontos definidos
plt.plot(x, y, label = "Gráfico que Liga Todos os Pontos da Reta")
# definindo uma grade para o gráfico
plt.grid(True)
# removendo a moldura do gráfico
plt.box(False)
# colocando a legenda no gráfico
plt.legend()
# colocando um título no gráfico
plt.title("Interpolando uma Reta Sobre os Pontos Informados")


# Dessa forma, assim como a primeira aplicação, os valores **x** e **y** não convergem a um valor único levando em consideração o sistema informado, logo temos novamente um sistema incompatível e será conveniente usar o método de **mínimos quadráticos** novamente.

# - $$A^{T}Ax = A^{T}b$$
# que se resume em:
# - $$x = (A^{T}A)^{-1}A^{T}b$$

# Podemos reescrever o sistema, usando **Matrizes Ampliadas**, da seguinte forma:

# $$\begin{bmatrix}
#           -1 & 1 \\
#           0  & 1 \\
#           1  & 1 \\
#           2  & 1 \\
#           \end{bmatrix} \begin{bmatrix}
#                                 a \\
#                                 b \\
#                                 \end{bmatrix} = \begin{bmatrix}
#                                                         0 \\
#                                                         1 \\
#                                                         2 \\
#                                                         1 \\
#                                                         \end{bmatrix}$$

# Vamos definir a **matriz ampliada** **A** e a matriz **b**:

# In[241]:


# definindo a matriz ampliada A
A = np.array([[-1, 1], [0, 1], [1, 1], [2, 1]])
# definindo a matriz b
b = np.array([[0], [1], [2], [1]])


# In[242]:


# imprimindo a matriz ampliada A
print("A matriz A é:\n\n", A)


# In[243]:


# imprimindo a matriz b
print("A matriz b é:\n\n", b)


# Vamos aplicar o método de **mínimos quadráticos**, para descobrir um valor aproximado para **a** e **b**:

# In[244]:


# usando o método de mínimos quadráticos para descobrir a e b
(a, b) = np.dot(np.dot(np.linalg.pinv(np.dot(A.transpose(), A)), A.transpose()), b)


# In[245]:


# imprimindo o valor de a e b
print("Usando o método de mínimos quadráticos, teremos: (a = {:.1f}, b = {:.1f})".
      format(float(a), float(b)))


# E assim, teremos o gráfico abaixo:

# In[246]:


# definindo o ponto (x,y) da primeira equação
x1, y1 = -1, 0
# definindo o ponto (x,y) da segunda equação
x2, y2 = 0, 1
# definindo o ponto (x,y) da terceira equação
x3, y3 = 1, 2
# definindo o ponto (x,y) da quarta equação
x4, y4 = 2, 1
# definindo uma lista com todos os valores de x informados
x = [x1, x2, x3, x4]
# definindo uma lista com todos os valores de y informados
y = [y1, y2, y3, y4]
# definindo o tamanho do gráfico
plt.figure(figsize = (10, 5))
# plotando o ponto (x,y) da primeira equação
plt.scatter(x1, y1, color = "red", label = "Pontos (x,y) Obtidos para o Sistema de Equações")
# plotando o ponto (x,y) da segunda equação
plt.scatter(x2, y2, color = "red")
# plotando o ponto (x,y) da terceira equação
plt.scatter(x3, y3, color = "red")
# plotando o ponto (x,y) da quarta equação
plt.scatter(x4, y4, color = "red")
# definindo uma lista de valores de x para serem usados em cada ponto da reta, entre -1 e 2
valoresX = np.linspace(-1,2)
# plotando o gráfico que liga todos os pontos informados
plt.plot(x, y, label = "Gráfico que Liga Todos os Pontos da Reta")
# plotando o gráfico da equação da reta y = ax + b
plt.plot(valoresX, a * valoresX + b, 
         label = "Reta com os Valores de (a,b) Obtidos pelo Método de Mínimos Quadráticos")
# adicionando uma grade no gráfico
plt.grid(True)
# removendo a moldura do gráfico
plt.box(False)
# adicionando a legenda ao gráfico
plt.legend()
# adicionando um título ao gráfico
plt.title("Gráfico que Liga Todos os Pontos Informados (x,y)")


# ### Aplicação 3: Polinômio Quadrático

# Encontre o Polinômio Quadrático utilizando o método de **Mínimos Quadráticos**. Leve em consideração os pontos: **(2,0)**, **(3,-10)**, **(5,-48)** e **(6,-76)**.

# Use $y = ax^{2} + bx + c$

# Vamos plotar o gráfico com todos os pontos disponíveis:

# In[247]:


# coordenada (x,y) da primeira equação
x1, y1 = 2, 0
# coordenada (x,y) da segunda equação
x2, y2 = 3, -10
# coordenada (x,y) da terceira equação
x3, y3 = 5, -48
# coordenada (x,y) da quarta equação
x4, y4 = 6, -76
# lista com todos os valores de x
x = [x1, x2, x3, x4]
# lista com todos os valores de y
y = [y1, y2, y3, y4]
# determinando o tamanho da figura
plt.figure(figsize = (10,5))
# plotando o primeiro ponto (x,y) da primeira equação
plt.scatter(x1, y1, color = "red", label = "Pontos (x,y) Informados")
# plotando o segundo ponto (x,y) da segunda equação
plt.scatter(x2, y2, color = "red")
# plotando o terceiro ponto (x,y) da terceira equação
plt.scatter(x3, y3, color = "red")
# plotando o quarto ponto (x,y) da quarta equação
plt.scatter(x4, y4, color = "red")
# plotando o gráfico que liga todos os pontos informados
plt.plot(x, y, color = "blue", label = "Gráfico que Liga Todos os Pontos (x,y) Informados")
# definindo a legenda no gráfico
plt.legend()
# colocando a grade no gráfico
plt.grid(True)
# removendo a moldura do gráfico
plt.box(False)
# colocando o título no gráfico
plt.title("Tentando Encontrar um Polinômio Quadrático por Mínimos Quadráticos")


# Vamos definir a **matriz ampliada A** e a matriz **b**:

# In[248]:


# definindo a matriz ampliada A
A = np.array([[x1 ** 2, x1, 1],
              [x2 ** 2, x2, 1],
              [x3 ** 2, x3, 1],
              [x4 ** 2, x4, 1]])
# definindo a matriz b
b = np.array([[y1],
              [y2],
              [y3],
              [y4]])


# In[249]:


# imprimindo a matriz ampliada A
print("A matriz ampliada A é:\n\n", A)


# In[250]:


# imprimindo a matriz b
print("A matriz b é:\n\n", b)


# Novamente, vamos utilizar a fórmula para montar a equação geral que interpole todos os pontos dados nas equações do sistema linear:

# $$x = (A^{T}A)^{-1}A^{T}b$$

# In[251]:


# definindo a matriz x
x = np.dot(np.dot(np.linalg.pinv(np.dot(A.transpose(), A)), A.transpose()), b)


# In[252]:


# definindo as variáveis que serão utilizadas na fórmula geral, que são justamente os elementos de x
(a, b, c) = x[0][0], x[1][0], x[2][0]


# In[253]:


# pontos (x,y) da primeira equação
x1, y1 = 2, 0
# pontos (x,y) da segunda equação
x2, y2 = 3, -10
# pontos (x,y) da terceira equação
x3, y3 = 5, -48
# pontos (x,y) da quarta equação
x4, y4 = 6, -76
# lista com todos os valores de x
x = [x1, x2, x3, x4]
# lista com todos os valores de y
y = [y1, y2, y3, y4]
# dimensão da figura
plt.figure(figsize = (10,5))
# plotando os primeiros pontos (x,y) da primeira equação
plt.scatter(x1, y1, color = "red", label = "Pontos (x,y) Informados")
# plotando os segundos pontos (x,y) da segunda equação
plt.scatter(x2, y2, color = "red")
# plotando os terceiros pontos (x,y) da terceira equação
plt.scatter(x3, y3, color = "red")
# plotando os quartos pontos (x,y) da quarta equação
plt.scatter(x4, y4, color = "red")
# plotando o gráfico que liga todos os pontos informados
plt.plot(x, y, color = "blue", label = "Gráfico que Liga Todos os Pontos (x,y) Informados")
# definindo valores para x de 2 até 6
valoresX = np.linspace(2,6)
# plotando o gráfico obtido pelo método de mínimos quadráticos
plt.plot(valoresX, (a * (valoresX ** 2)) + (b * valoresX) + c, color = "Green", 
         label = "Polinômio Quadrático")
# ativando a legenda no gráfico
plt.legend()
# colocando uma grade no gráfico
plt.grid(True)
# removendo a moldura do gráfico
plt.box(False)
# colocando um título no gráfico
plt.title("Tentando Encontrar um Polinômio Quadrático por Mínimos Quadráticos")


# ### Aplicação 4: Polinômio de Grau 7

# Vamos agora operar com gráficos que vão além de retas, observe que o problema de mínimos quadráticos é útil para diversas situações além das mais simples.

# Vamos usar a seguinte equação para o gráfico:

# $$y = ax^{7} + bx^{6} + cx^{5} + dx^{4} + ex^{3} + fx^{2} + gx + h$$

# E também teremos as seguintes coordenadas:

# |**X**|**Y**|
# |:---:|:---:|
# |-8   |10   |
# |-6   |1    |
# |-5   |-4   |
# |-3   |-3   |
# |-2   |0    |
# |0    |5    |
# |1    |0    |
# |3    |-4   |
# |9    |0    |
# |12   |8    |

# Cada coordenada nos dará um sistema de equações da forma informada acima. Não nos interessa visualizá-la agora, já que as únicas ferramentas que precisaremos são as **coordenadas**, a **matriz ampliada** e a **matriz b**.

# Vamos analisar os pontos informados no gráfico abaixo:

# In[254]:


# coordenada (x,y) da primeira equação
x1, y1 = -8, 10
# coordenada (x,y) da segunda equação
x2, y2 = -6, 1
# coordenada (x,y) da terceira equação
x3, y3 = -5, -4
# coordenada (x,y) da quarta equação
x4, y4 = -3, -3
# coordenada (x,y) da quinta equação
x5, y5 = -2, 0
# coordenada (x,y) da sexta equação
x6, y6 = 0, 5
# coordenada (x,y) da sétima equação
x7, y7 = 1, 0
# coordenada (x,y) da oitava equação
x8, y8 = 3, -4
# coordenada (x,y) da nona equação
x9, y9 = 9,0
# coordenada (x,y) da décima equação
x10, y10 = 12, 8
# lista com todos os valores da coordenada x, para plotar o gráfico que une todos os pontos acima
x = [x1, x2, x3, x4, x5, x6, x7, x8, x9, x10]
# lista com todos os valores da coordenada y, para plotar o gráfico que une todos os pontos acima
y = [y1, y2, y3, y4, y5, y6, y7, y8, y9, y10]
# dimensões da figura
plt.figure(figsize = (10,5))
# imprime o primeiro ponto (x,y) informado
plt.scatter(x1, y1, color = "red", label = "Coordenadas (x,y) Informadas")
# imprime o segundo ponto (x,y) informado
plt.scatter(x2, y2, color = "red")
# imprime o terceiro ponto (x,y) informado
plt.scatter(x3, y3, color = "red")
# imprime o quarto ponto (x,y) informado
plt.scatter(x4, y4, color = "red")
# imprime o quinto ponto (x,y) informado
plt.scatter(x5, y5, color = "red")
# imprime o sexto ponto (x,y) informado
plt.scatter(x6, y6, color = "red")
# imprime o sétimo ponto (x,y) informado
plt.scatter(x7, y7, color = "red")
# imprime o oitavo ponto (x,y) informado
plt.scatter(x8, y8, color = "red")
# imprime o nono ponto (x,y) informado
plt.scatter(x9, y9, color = "red")
# imprime o décimo ponto (x,y) informado
plt.scatter(x10, y10, color = "red")
# plota o gráfico que une todos os pontos informados
plt.plot(x, y, color = "blue", label = "Gráfico que Liga Todos os Pontos (x,y) Informados")
# adiciona a legenda ao gráfico
plt.legend()
# adiciona a grade ao gráfico
plt.grid(True)
# reomvendo a moldura do gráfico
plt.box(False)
# adiciona um título ao gráfico
plt.title("Usando Mínimos Quadráticos para Encontrar um Gráfico que Interpola Todos os Pontos Informados")


# Vamos agora definir a **matriz ampliada A** e a matriz **b**:

# In[255]:


# definindo a matriz ampliada A
A = np.array([[x1 ** 7, x1 ** 6, x1 ** 5, x1 ** 4, x1 ** 3, x1 ** 2, x1, 1],
              [x2 ** 7, x2 ** 6, x2 ** 5, x2 ** 4, x2 ** 3, x2 ** 2, x2, 1],
              [x3 ** 7, x3 ** 6, x3 ** 5, x3 ** 4, x3 ** 3, x3 ** 2, x3, 1],
              [x4 ** 7, x4 ** 6, x4 ** 5, x4 ** 4, x4 ** 3, x4 ** 2, x4, 1],
              [x5 ** 7, x5 ** 6, x5 ** 5, x5 ** 4, x5 ** 3, x5 ** 2, x5, 1],
              [x6 ** 7, x6 ** 6, x6 ** 5, x6 ** 4, x6 ** 3, x6 ** 2, x6, 1],
              [x7 ** 7, x7 ** 6, x7 ** 5, x7 ** 4, x7 ** 3, x7 ** 2, x7, 1],
              [x8 ** 7, x8 ** 6, x8 ** 5, x8 ** 4, x8 ** 3, x8 ** 2, x8, 1],
              [x9 ** 7, x9 ** 6, x9 ** 5, x9 ** 4, x9 ** 3, x9 ** 2, x9, 1],
              [x10 ** 7, x10 ** 6, x10 ** 5, x10 ** 4, x10 ** 3, x10 ** 2, x10, 1]])
# definindo a matriz B
b = np.array([[10],
              [1],
              [-4],
              [-3],
              [0],
              [5],
              [0],
              [-4],
              [0],
              [8]])


# In[256]:


# imprimindo a matriz ampliada A
print("A matriz ampliada A é:\n\n", A)


# In[257]:


# imprimindo a matriz b
print("A matriz b é:\n\n", b)


# Vamos, novamente, usar a fórmula abaixo para descobrir o vetor x:

# - $$A^{T}Ax = A^{T}b$$
# que se resume em:
# - $$x = (A^{T}A)^{-1}A^{T}b$$

# In[258]:


# definindo o vetor x
x = np.dot(np.dot(np.linalg.pinv(np.dot(A.transpose(), A)), A.transpose()), b)


# In[259]:


# imprimindo o vetor x
print("O vetor x é:\n\n", x)


# Desse modo, podemos construir o gráfico abaixo:

# In[260]:


# definindo as variáveis da equação geral
(a, b, c, d, e, f, g, h) = x[0][0], x[1][0], x[2][0], x[3][0], x[4][0], x[5][0], x[6][0], x[7][0]


# In[261]:


# coordenada (x,y) da primeira equação
x1, y1 = -8, 10
# coordenada (x,y) da segunda equação
x2, y2 = -6, 1
# coordenada (x,y) da terceira equação
x3, y3 = -5, -4
# coordenada (x,y) da quarta equação
x4, y4 = -3, -3
# coordenada (x,y) da quinta equação
x5, y5 = -2, 0
# coordenada (x,y) da sexta equação
x6, y6 = 0, 5
# coordenada (x,y) da sétima equação
x7, y7 = 1, 0
# coordenada (x,y) da oitava equação
x8, y8 = 3, -4
# coordenada (x,y) da nona equação
x9, y9 = 9,0
# coordenada (x,y) da décima equação
x10, y10 = 12, 8
# lista com todos os valores da coordenada x, para plotar o gráfico que une todos os pontos acima
x = [x1, x2, x3, x4, x5, x6, x7, x8, x9, x10]
# lista com todos os valores da coordenada y, para plotar o gráfico que une todos os pontos acima
y = [y1, y2, y3, y4, y5, y6, y7, y8, y9, y10]
# dimensões da figura
plt.figure(figsize = (10,5))
# imprime o primeiro ponto (x,y) informado
plt.scatter(x1, y1, color = "red", label = "Coordenada (x,y) Informadas")
# imprime o segundo ponto (x,y) informado
plt.scatter(x2, y2, color = "red")
# imprime o terceiro ponto (x,y) informado
plt.scatter(x3, y3, color = "red")
# imprime o quarto ponto (x,y) informado
plt.scatter(x4, y4, color = "red")
# imprime o quinto ponto (x,y) informado
plt.scatter(x5, y5, color = "red")
# imprime o sexto ponto (x,y) informado
plt.scatter(x6, y6, color = "red")
# imprime o sétimo ponto (x,y) informado
plt.scatter(x7, y7, color = "red")
# imprime o oitavo ponto (x,y) informado
plt.scatter(x8, y8, color = "red")
# imprime o nono ponto (x,y) informado
plt.scatter(x9, y9, color = "red")
# imprime o décimo ponto (x,y) informado
plt.scatter(x10, y10, color = "red")
# plota o gráfico que une todos os pontos informados
plt.plot(x, y, color = "blue", label = "Gráfico que Liga Todos os Pontos (x,y) Informados")
# definindo valores para x entre -8 e 13, para ser usada no gráfico
valoresX = np.linspace(-8,12)
# plotando o gráfico construido a partir dos métodos de mínimo quadrático
plt.plot(valoresX, (a * (valoresX ** 7)) + (b * (valoresX ** 6)) + (c * (valoresX ** 5)) + 
         (d * (valoresX ** 4)) + (e * (valoresX ** 3)) + (f * (valoresX ** 2)) + (g * valoresX) + h, 
         color = "brown", label = "Gráfico que Interpola os Pontos (x,y) Informados")
# adiciona a legenda ao gráfico
plt.legend()
# adiciona a grade ao gráfico
plt.grid(True)
# removendo a moldura do gráfico
plt.box(False)
# adiciona um título ao gráfico
plt.title("Usando Mínimos Quadráticos para Encontrar um Gráfico que Interpola Todos os Pontos Informados")


# ### Aplicação 5: Polinômio Cúbico

# Encontre o polinômio cúbico utilizando o método de **mínimos quadráticos**, use os pontos **(-1,-14)**, **(0,-5)**, **(1,-4)**, **(2,1)** e **(3,22)**.

# Use $y = ax^{3} + bx^{2} + cx + d$

# Vamos plotar todos os pontos informados:

# In[262]:


# coordenada (x,y) da primeira equação
x1, y1 = -1, -14
# coordenada (x,y) da segunda equação
x2, y2 = 0, -5
# coordenada (x,y) da terceira equação
x3, y3 = 1, -4
# coordenada (x,y) da quarta equação
x4, y4 = 2, 1
# coordenada (x,y) da quinta equação
x5, y5 = 3, 22
# lista com todos os valores de x
x = [x1, x2, x3, x4, x5]
# lista com todos os valores de y
y = [y1, y2, y3, y4, y5]
# definindo a dimensão da figura
plt.figure(figsize = (10, 5))
# plotando o primeiro ponto (x,y) da primeira equação
plt.scatter(x1, y1, color = "red", label = "Pontos (x,y) Informados")
# plotando o segundo ponto (x,y) da segunda equação
plt.scatter(x2, y2, color = "red")
# plotando o terceiro ponto (x,y) da terceira equação
plt.scatter(x3, y3, color = "red")
# plotando o quarto ponto (x,y) da quarta equação
plt.scatter(x4, y4, color = "red")
# plotando o quinto ponto (x,y) da quinta equação
plt.scatter(x5, y5, color = "red")
# plotando o gráfico que liga todos os pontos informados
plt.plot(x, y, color = "blue", label = "Gráfico que Liga Todos os Pontos (x, y)")
# colocando uma grade ao gráfico
plt.grid(True)
# removendo a moldura do gráfico
plt.box(False)
# colocando a legenda no gráfico
plt.legend()
# removendo o título do gráfico
plt.title("Tentando Encontrar um Polinômio Cúbico por Mínimos Quadráticos")


# Vamos definir a **matriz ampliada A** e a matriz **b**.

# In[263]:


# definindo a matriz ampliada A
A = np.array([[x1 ** 3, x1 ** 2, x1, 1],
              [x2 ** 3, x2 ** 2, x2, 1],
              [x3 ** 3, x3 ** 2, x3, 1],
              [x4 ** 3, x4 ** 2, x4, 1],
              [x5 ** 3, x5 ** 2, x5, 1]])
# definindo a matriz b
b = np.array([[y1],
              [y2],
              [y3],
              [y4],
              [y5]])


# In[264]:


# imprimindo a matriz ampliada A
print("A matriz ampliada A é:\n\n", A)


# In[265]:


# imprimindo a matriz b
print("A matriz b é:\n\n", b)


# Como é de praxe, usaremos a fórmula $x = (A^{T}A)^{-1}A^{T}b$ para encontrar as variáveis que compõem a equação geral com base em todas as equações do sistema linear.

# In[266]:


# definindo o vetor x
x = np.dot(np.dot(np.linalg.pinv(np.dot(A.transpose(), A)), A.transpose()), b)


# In[267]:


# imprimindo o vetor x
print("O vetor x é:\n\n", x)


# In[268]:


# pegando os elementos de x, que são as coordenadas da equação geral
(a, b, c, d) = x[0][0], x[1][0], x[2][0], x[3][0]


# In[269]:


# imprimindo a equação geral
print("A equação geral é: y = {}x³ {}x² + {}x {}".format(int(a), int(b), int(c), int(d)))


# Por fim, teremos o gráfico:

# In[270]:


# coordenada (x,y) da primeira equação
x1, y1 = -1, -14
# coordenada (x,y) da segunda equação
x2, y2 = 0, -5
# coordenada (x,y) da terceira equação
x3, y3 = 1, -4
# coordenada (x,y) da quarta equação
x4, y4 = 2, 1
# coordenada (x,y) da quinta equação
x5, y5 = 3, 22
# lista com todos os valores de x
x = [x1, x2, x3, x4, x5]
# lista com todos os valores de y
y = [y1, y2, y3, y4, y5]
# definindo a dimensão da figura
plt.figure(figsize = (10, 5))
# plotando o primeiro ponto (x,y) da primeira equação
plt.scatter(x1, y1, color = "red", label = "Pontos (x,y) Informados")
# plotando o segundo ponto (x,y) da segunda equação
plt.scatter(x2, y2, color = "red")
# plotando o terceiro ponto (x,y) da terceira equação
plt.scatter(x3, y3, color = "red")
# plotando o quarta ponto (x,y) da quarta equação
plt.scatter(x4, y4, color = "red")
# plotando o quinto ponto (x,y) da quinta equação
plt.scatter(x5, y5, color = "red")
# plotando o gráfico que liga todos os pontos informados
plt.plot(x, y, color = "blue", label = "Gráfico que Liga Todos os Pontos (x, y)")
# definindo valores de x entre -1 e 3
valoresX = np.linspace(-1, 3)
# plotando a equação geral obtida pelo método de mínimos quadráticos
plt.plot(valoresX, (a * (valoresX ** 3)) + (b * (valoresX ** 2)) + (c * valoresX) + d)
# adicionando uma grade ao gráfico
plt.grid(True)
# removendo a moldura do gráfico
plt.box(False)
# adicionando uma legenda ao gráfico
plt.legend()
# adicionando um título ao gráfico
plt.title("Tentando Encontrar um Polinômio Cúbico por Mínimos Quadráticos")


# ### O que a inteligência artificial tem haver com isso?

# > Pensando computacionalmente, a ideia desses algoritmos é encontrar um modelo matemático que mais se aproxime dos dados disponíveis. Desse modo, esses modelos podem ser usados em algoritmos de Machine Learning (um ramo da inteligência artificial) para fazer predições por regressão. Vale a pena a pesquisa sobre o tema!

# ### Alguma Dúvida? Entre em Contato Comigo:

# - [Me envie um e-mail](mailto:alysson.barbosa@ee.ufcg.edu.br);