{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "#**Química Computacional - Aula Prática 2**\n",
        "\n",
        "**Aplicações simples: vetores, matrizes e transformações unitárias (ortogonais)**\n",
        "\n",
        "\\\\\n",
        "\n",
        "---\n",
        "Bibliografia de Suporte:\n",
        "\n",
        "Attila Szabo and Neil S. Ostlund, Modern Quantum Chemistry: Introduction to Advanced Electronic Structure Theory, Dover Publications Inc., New York, 1996,  **Capítulo 1, Secção 1.1**\n",
        "\n",
        "https://medium.com/@zackbunch/matrices-with-numpy-and-scipy-a260a65551c6\n",
        "\n",
        "https://www.digitalocean.com/community/tutorials/numpy-matrix-multiplication\n",
        "\n",
        "---"
      ],
      "metadata": {
        "id": "FcI1UPSnW6aE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**1. Vectores**\n",
        "\n",
        "O produto interno de dois vectores é dado por:\n",
        "\n",
        "$\\vec{a} \\cdot \\vec{b} = a_{1}b_{1} + a_{2}b_{2} + ...a_{n}b_{n} = \\sum _{i=1}^{n}a_{i}b_{i}$ (Eq. 1)\n",
        "\n",
        "\\\\\n",
        "\n",
        "**Exercício 1**\n",
        "\n",
        "Calcule \"manualmente\" o produto interno dos vectores $\\vec{a} = (2 , 0, 5 )$ e $\\vec{b} = (1 , 0, 3 )$\n",
        "\n",
        "**Exercício 2**\n",
        "\n",
        "Com base na Eq. 1, escreva um programa em python que calcule o produto interno de dois vectores. Pode usar o código seguinte fazendo as modificações necessárias. Verifique que compreende todas as linhas do código. Faça o cálculo para $\\vec{a} \\cdot \\vec{b}$.\n",
        "\n",
        "\n",
        "```\n",
        "# Define os vectores a e b\n",
        "a = ([xxxx, xxxxx, xxxx])\n",
        "b = ([xxxx, xxxx, xxxx])\n",
        "\n",
        "# define o conteudo inicial de c; inicializa a variável\n",
        "c = 0\n",
        "\n",
        "# itera ao longo dos elementos do vector a\n",
        "for i in range(len(a)):\n",
        "      # adiciona os valores à variavel c\n",
        "      c += a[i]* b[i]\n",
        "\n",
        "# mostra o resultado\n",
        "print(c)\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "KqADZfYeHzHd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Coloque aqui o seu código e faça as modificações necessárias\n",
        "#\n",
        "#"
      ],
      "metadata": {
        "id": "YTFyvSUxK8nX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**2. Bibliotecas em Python**\n",
        "\n",
        "Na linguagem Python existem muitas bibliotecas cujas funções simplificam linhas de código mais complexas. Uma dessas bibliotecas chama-se **Numpy** (https://numpy.org/) e permite, entre outras funcionalidades, trabalhar com vectores e matrizes.\n",
        "\n",
        "A função `dot()` da biblioteca Numpy permite fazer a multiplicação (dot product) de vectores.\n",
        "\n",
        "A sintaxe é a seguinte: `numpy.dot(vector1, vector2, out=None)`\n",
        "\n",
        "**Exercício 4**\n",
        "\n",
        "Usando a biblioteca Numpy, escreva um programa que efectue o cálculo do produto interno dos vectores $\\vec{a} \\cdot \\vec{b}$.  \n",
        "\n",
        "Nota 1: para importar a biblioteca usa-se\n",
        "\n",
        "`import numpy as np`\n",
        "\n",
        "Nota 2: para usar uma determinada função de uma biblioteca que importámos com um determinado nome (e.g np), utiliza-se a seguinte sintaxe\n",
        "\n",
        "`np.dot(argumentos)`\n",
        "\n",
        "Nota 3: Um vector pode ser armazenado da seguinte forma usando a biblioteca Numpy\n",
        "\n",
        "`vector = np.array([xxx, xxxx, xxx])`"
      ],
      "metadata": {
        "id": "yzRZ8TXbnN1o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar a biblioteca\n",
        "import numpy as np\n",
        "\n",
        "# Coloque aqui o seu código e faça as modificações necessárias\n",
        "#\n",
        "#"
      ],
      "metadata": {
        "id": "VjeBeBM2rOIY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Exercício 5**\n",
        "\n",
        "Calcule \"manualmente\" o módulo ou norma dos vectores $\\vec{a}$ e $\\vec{b}$.\n",
        "\n",
        "**Exercício 6**\n",
        "\n",
        "Escreva um programa em python para fazer a tarefa. A função `np.sqrt` poderá ser útil."
      ],
      "metadata": {
        "id": "H8q_5BA2u9Zn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Coloque aqui o seu código e faça as modificações necessárias\n",
        "#\n",
        "#"
      ],
      "metadata": {
        "id": "a7MiK8FBwyK_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**3. Matrizes**\n",
        "\n",
        "A multiplicação de duas matrizes quadradas 2 x 2 pode ser representada da seguinte forma\n",
        "\n",
        "$\\begin{bmatrix}\n",
        "a_{11} & a_{12} \\\\\n",
        "a_{21} & a_{22}  \\\\\n",
        "\\end{bmatrix}\n",
        "\\begin{bmatrix}\n",
        "b_{11} & b_{12}  \\\\\n",
        "b_{21} & b_{22}  \\\\\n",
        "\\end{bmatrix} = \\begin{bmatrix}\n",
        "c_{11} & c_{12}  \\\\\n",
        "c_{21} & c_{22} \\\\\n",
        "\\end{bmatrix}$\n",
        "\n",
        "\\\n",
        "onde\n",
        "\n",
        "\n",
        "$c_{11} = a_{11}b_{11} + a_{12}b_{21}$\n",
        "$c_{12} = a_{11}b_{12} + a_{12}b_{22}$\n",
        "(...)\n",
        "\n",
        "ou escrito sob a forma de um somatório:\n",
        "\n",
        "$c_{ij}=a_{i1}b_{1j}+a_{i2}b_{2j}+\\cdots +a_{in}b_{nj}=\\sum _{k=1}^{n}a_{ik}b_{kj}$ (Eq. 1)\n",
        "\n",
        "\\\n",
        "**Exercício 7**\n",
        "\n",
        "Calcule \"manualmente\" o produto **C = AB** onde\n",
        "\n",
        "$\\boldsymbol{A} = \\begin{bmatrix}\n",
        "2 & 4 \\\\\n",
        "6 & 8  \\\\\n",
        "\\end{bmatrix}\n",
        "e\\space  \n",
        "\\boldsymbol{B} = \\begin{bmatrix}\n",
        "1 & 3 \\\\\n",
        "5 & 7  \\\\\n",
        "\\end{bmatrix}$\n",
        "\n",
        "\\\n",
        "**Exercício 8**\n",
        "\n",
        "O produto de matrizes, em geral, não é comutativo. Demonstre a veracidade a afirmação.\n",
        "\n",
        "\\\n",
        "**Exercício 9**\n",
        "\n",
        "Com base na Eq. 1, escreva um programa em python que efectue o cálculo do produto de matrizes. Pode usar o código seguinte fazendo as modificações necessárias. Faça o cálculo para o produto AB.\n",
        "\n",
        "```\n",
        "# Define as matrizes A e B\n",
        "\n",
        "A = ([xxx, xxx],\n",
        "     [xxx, xxx])\n",
        "\n",
        "B = ([xxx, xxx],\n",
        "     [xxx, xxx])\n",
        "\n",
        "# cria uma matriz C vazia para escrever o resultados\n",
        "C = ([0, 0],\n",
        "     [0, 0])\n",
        "\n",
        "# itera as linhas da matriz A\n",
        "# len(A) dá o número de colunas de A\n",
        "for i in range(len(A)):\n",
        "    # itera ao longo das colunas da matriz B\n",
        "    # len(B[0]) a dimensão da primeira linha, isto é, o número de colunas.\n",
        "    for j in range(len(B[0])):\n",
        "        # itera ao longo das linhas de B\n",
        "        # len(A) dá o número de colunas de B\n",
        "        for k in range(len(B)):\n",
        "            C[i][j] += A[i][k] * B[k][j]\n",
        "\n",
        "# mostra o resultado\n",
        "print(C)\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "ofoE6vzEhfPb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Coloque aqui o seu código e faça as modificações necessárias\n",
        "#\n",
        "#"
      ],
      "metadata": {
        "id": "T0JamKwa28Ji"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Exercício 10**\n",
        "\n",
        "Podemos demonstrar a utilidade da biblioteca Numpy também neste caso. A função `matmul()` dessa biblioteca permite fazer a multiplicação de matrizes. A sintaxe é a seguinte:\n",
        "\n",
        "`numpy.matmul(first_matrix, second_matrix, out=None)`\n",
        "\n",
        "Recorde que em python os índices começam em 0\n",
        "\n",
        "<figure>\n",
        "  <img src=\"https://journaldev.nyc3.cdn.digitaloceanspaces.com/2019/09/numpy-matrix-product.png\" width=\"400\">\n",
        "  <figcaption> Source: https://www.digitalocean.com/community/tutorials/numpy-matrix-multiplication</figcaption>\n",
        "</figure>\n",
        "\n",
        "Escreva um program em python que use esta função e faça o cálculo para o produto **AB**."
      ],
      "metadata": {
        "id": "44bVoQkQz-NT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Coloque aqui o seu código e faça as modificações necessárias\n",
        "#\n",
        "#"
      ],
      "metadata": {
        "id": "wBUYSdwsipRh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Exercício 11**\n",
        "Verifique quais das seguintes matrizes são Hermiteanas:\n",
        "\n",
        "$\\textbf{A1} =\\begin{bmatrix}\n",
        "i & 0 \\\\\n",
        "0 & i  \\\\\n",
        "\\end{bmatrix}\n",
        "\\textbf{A2} =\\begin{bmatrix}\n",
        "2 & 1-i \\\\\n",
        "1+i & 5  \\\\\n",
        "\\end{bmatrix}\n",
        "\\textbf{A3} =\\begin{bmatrix}\n",
        "1 & 3-i \\\\\n",
        "3+i & 2  \\\\\n",
        "\\end{bmatrix}\n",
        "$\n",
        "\n",
        "**Exercício 12**\n",
        "\n",
        "Conisdere 2 matrizes **A**(2X2) e **B**(2X2. Mostre se C=AB, então $C^†=B^†A^†$\n",
        "\n",
        "**4. Determinantes**\n",
        "\n",
        "O determinante de uma matriz é dado por\n",
        "\n",
        "$det(\\boldsymbol{A})\n",
        "= |\\boldsymbol{A}| = \\sum _{i=1}^{N!}(-1)^{p_{i}}P_{i}A_{11}A_{22}...A_{NN}$\n",
        "\n",
        "onde $P_{i}$ é o operador de permutação: permuta os índices de coluna de 1 a N. A soma é $N!$. O termo ${p_{i}}$ indica o número transposições necessárias para restaurar a ordem original 1,2,...,N. Só será importante verificar se o número é ímpar ou par.\n",
        "\n",
        "\\\n",
        "*** Exercício Avaliação (Casa)**\n",
        "\n",
        "a) Calcule \"manualmente\" o determinante de\n",
        "\n",
        "$\\boldsymbol{A} = \\begin{bmatrix}\n",
        "2 & 4 \\\\\n",
        "6 & 8  \\\\\n",
        "\\end{bmatrix}\n",
        "e\\space  \n",
        "\\boldsymbol{B} = \\begin{bmatrix}\n",
        "1 & 3 \\\\\n",
        "5 & 7  \\\\\n",
        "\\end{bmatrix}$\n",
        "\n",
        "\\\n",
        "\n",
        "b) Mais uma vez a biblioteca Numpy possuí uma função que permite calcular o determinante de uma matriz quadrada. Trata-se da função `numpy.linalg.det(matrix)`. Escreva um programa em python para calcular o determinante de $\\boldsymbol{A}$ e $\\boldsymbol{B}$"
      ],
      "metadata": {
        "id": "zUt6pxGmmEvI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Coloque aqui o seu código e faça as modificações necessárias\n",
        "#\n",
        "#"
      ],
      "metadata": {
        "id": "NBHmOlZHpym3"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}