{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Nympy (Numeric Python)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 - Básico de arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Listas de listas como matriz\n",
    "a = [[1,2,3], [4,5,6], [7,8,9], [10,11,12]]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Transformar a lista num array de Numpy\n",
    "A = np.array(a)\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Acessar uma entrada do array. Se fosse acessar pela lista tem que usar a[0][1].\n",
    "print(A[0, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Propriedades básicas de arrays\n",
    "print(A.shape)\n",
    "print(A.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Função arange\n",
    "a = np.arange(1, 13)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Função reshape\n",
    "A = np.reshape(a, (4,3))\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Função linspace\n",
    "np.linspace(0, 1, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Arrays especiais\n",
    "Z = np.zeros((4,3))\n",
    "print('Z = ',)\n",
    "print(Z)\n",
    "print()\n",
    "\n",
    "print('O = ',)\n",
    "O = np.ones((4,3))\n",
    "print(O)\n",
    "print()\n",
    "\n",
    "print('I = ',)\n",
    "I = np.identity(4)\n",
    "print(I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 - Operações com arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Operações entre arrays e escalares\n",
    "print('2 + A =')\n",
    "print(2 + A)\n",
    "print()\n",
    "\n",
    "print('2 * A =')\n",
    "print(2 * A)\n",
    "print()\n",
    "\n",
    "print('A / 2 =')\n",
    "print(A / 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adição \n",
    "print(A + O)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Subtração\n",
    "print(A - O)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiplicação ponto a ponto (ou produto de Hadamard)\n",
    "print(A*O)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiplicação matricial clássica\n",
    "# Vai dar erro porque o número de colunas de A não é igual ao número de linha de O\n",
    "print(np.dot(A, O))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiplicação matricial clássica sem erros\n",
    "O = np.ones((3,3))\n",
    "print(np.dot(A, O))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Divisão matricial ponto a ponto\n",
    "print(A/A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 - Transformação de arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Transposição\n",
    "At = np.transpose(A)\n",
    "print(At)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Transposição - versão 2\n",
    "At = A.T\n",
    "print(At)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# seno, cosseno, tangente, potência\n",
    "sin_A = np.sin(A)\n",
    "print('sin(A) = ')\n",
    "print(sin_A)\n",
    "print()\n",
    "\n",
    "cos_A = np.cos(A)\n",
    "print('cos(A) = ')\n",
    "print(cos_A)\n",
    "print()\n",
    "\n",
    "tan_A = np.tan(A)\n",
    "print('tan(A) = ')\n",
    "print(tan_A)\n",
    "print()\n",
    "\n",
    "pow2_A = A**2 # repare que A**2 = A*A, o que é diferente de np.dot(A, A)\n",
    "print('A**2 = ')\n",
    "print(pow2_A)\n",
    "print()\n",
    "\n",
    "powA_2 = 2**A\n",
    "print('2**A =')\n",
    "print(powA_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Confira que np.tan(A) = np.sin(A)/np.cos(A)\n",
    "print('sin(A)/cos(A) = ')\n",
    "print(np.sin(A)/np.cos(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 - Constantes especiais"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('pi =', np.pi)\n",
    "print()\n",
    "\n",
    "print('e =', np.e)\n",
    "print()\n",
    "\n",
    "print('infinity =', np.inf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercícios\n",
    "\n",
    "**1)** O número $e = 2.718281828459045 \\ldots$ é dado exatamente pela fórmula\n",
    "$$e = \\lim_{n \\to +\\infty} \\left( 1 + \\frac{1}{n} \\right)^n.$$\n",
    "\n",
    "Supondo que a constante $e$ do Numpy é exata, compute a aproximação com o limite acima para $n = 1, 10, 100, 1000, 10000$ e printe na tela erro entre a aproximação e o valor exato para cada $n$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2)** Todos sabemos que $sen(x)^2 + cos(x)^2 = 1$ para qualquer número $x$. Vamos ver que isso também, vale para matrizes. Crie uma matriz qualquer, compute `np.sin(A)**2 + np.cos(A)**2` e observe o resultado. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3)** Uma matriz quadrada $A$ é chamada de *nilpotente* se $A^k = 0$ para algum $k \\in \\mathbb{N}$. O menor $k$ satisfazendo esta igualdade se chama o *índice de $A$*. Dada a matriz\n",
    "\n",
    "$$A = \\left[\n",
    "\\begin{array}{cc}\n",
    "    2 & 2 & -2\\\\\n",
    "    5 & 1 & -3\\\\\n",
    "    1 & 5 & -3\n",
    "\\end{array}\n",
    "\\right]$$\n",
    "\n",
    "verifique que $A$ é nilpotente com índice $k = 3$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 - Gráfico de funções"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# gera imagens estáticas (ao invés de interativas) no notebook\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Gera arrays com valores do domínio e imagem \n",
    "x = np.linspace(0, 10, 100)\n",
    "sinx = np.sin(x)\n",
    "cosx = np.cos(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plota as funções seno e cosseno no intervalo [0, 10]\n",
    "plt.plot(x, sinx)\n",
    "plt.plot(x, cosx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 - Opções extras "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Legenda\n",
    "plt.plot(x, sinx, label='sin x')\n",
    "plt.plot(x, cosx, label='cos x')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Título, grid, cor e estilo dos pontos (outras possíveis opções são +, -, --, o, :, ., s, |, _, etc)\n",
    "plt.plot(x, sinx, '^', label='sin x', color='black')\n",
    "plt.plot(x, cosx, '*', label='cos x', color='red')\n",
    "plt.title('Grafico de seno e cosseno')\n",
    "plt.grid()\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercícios\n",
    "\n",
    "**4)** Considere a função quadrática $f(x) = x^2 - 1$. Como $x^2 - 1 = (x+1)(x-1)$, pode-se concluir que os zeros de $f$ são $x = 1$ e $x = -1$. Faça o gráfico desta função no intervalo $[-2, 2]$ e verifique visualmente que os zeros são esses mesmo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5)** Calcule (na mão) o ponto de interseção entre as retas $f(x) = 2x + 1$ e $g(x) = x - 3$. Feito isso, plote os gráficos de $f$ e $g$ (com legendas), e plote também o ponto de interseção. Use o intervalo $[-8, -3]$ para os valores do domínio."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Soluções dos exercícios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solução - exercício 1\n",
    "e = np.e\n",
    "\n",
    "for n in [1, 10, 100, 1000, 10000]:\n",
    "    e_aprox = (1 + 1/n)**n \n",
    "    print(e - e_aprox)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solução - exercício 2\n",
    "A = np.arange(1,13).reshape(4,3)\n",
    "print('A =')\n",
    "print(A)\n",
    "print()\n",
    "\n",
    "print('np.sin(A)**2 + np.cos(A)**2 =')\n",
    "print(np.sin(A)**2 + np.cos(A)**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solução - exercício 3\n",
    "A = np.array([[2, 2, -2], [5, 1, -3], [1, 5, -3]])\n",
    "A2 = np.dot(A, A)\n",
    "A3 = np.dot(A2, A)\n",
    "print('A^3 =')\n",
    "print(A3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solução - exercício 4\n",
    "x = np.linspace(-2, 2, 100)\n",
    "f = x**2 - 1\n",
    "\n",
    "plt.plot(x, f)\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solução - exercício 5\n",
    "x = np.linspace(-8, -3, 100)\n",
    "f = 2*x+1\n",
    "g = x - 3\n",
    "p = np.array([-4, -7])\n",
    "\n",
    "plt.plot(x, f, label='f')\n",
    "plt.plot(x, g, label='g')\n",
    "plt.plot(p[0], p[1], 'o', color='red')\n",
    "plt.grid()\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Desafio \n",
    "\n",
    "Considere a matriz\n",
    "$$A = \\left[\n",
    "\\begin{array}{cc}\n",
    "    -1 & 1\\\\\n",
    "    t & 2\n",
    "\\end{array}\n",
    "\\right].$$\n",
    "\n",
    "A partir de $A$ podemos definir a função $f(t) = det\\left( A  \\right)$, em que $det$ é o determinante da matriz. Plote o gráfico de $f$ no intervalo $t \\in [-10, 10]$. Use o comando `np.linalg.det(A)` para obter o determinante de $A$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solução - desafio \n",
    "\n",
    "t_range = np.linspace(-10, 10, 100)\n",
    "f = []\n",
    "\n",
    "for t in t_range:\n",
    "    A = np.array([[-1, 1], [t, 2]])\n",
    "    det_A = np.linalg.det(A)\n",
    "    f.append(det_A)\n",
    "    \n",
    "plt.plot(t_range, f, '.')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}