Estequiometria - ALC 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ffacf0a8-8c8b-48b6-ad6a-5c631deec1a1",
   "metadata": {},
   "source": [
    "# <strong>Aplicação de Sistemas Lineares na Estequiometria:</strong> Desenvolvimento de uma Ferramenta Computacional\n",
    "#### Autores: Gabriel Viégas Ribeiro, Glauber Nascimento de Oliveira, Lorena Ribeiro Nascimento, Maria Emily Nayla Gomes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f7f48ae-7927-45bd-9586-bee306c05997",
   "metadata": {},
   "source": [
    "O balanceamento de equações químicas é uma etapa fundamental na química, pois é essencial para garantir que a lei da conservação da massa seja respeitada, ou seja, a quantidade de átomos de cada elemento químico deve ser a mesma nos reagentes e nos produtos. Este trabalho apresenta o desenvolvimento de uma calculadora estequiométrica baseada em métodos computacionais, com foco na aplicação do Método Iterativo de Gauss-Seidel, além da Eliminação Gaussiana, para resolver sistemas de equações lineares que representam os coeficientes estequiométricos de uma reação química. A ferramenta foi projetada para receber como entrada uma string no formato convencional de reações químicas (por exemplo, \"Reagente1 + Reagente2 -> Produto1 + Produto2\"), identificar os componentes da reação e, a partir disso, calcular e fornecer a equação balanceada como saída.\n",
    "\n",
    "A escolha do Método Iterativo de Gauss-Seidel deve-se à sua capacidade de lidar com matrizes esparsas. Dessa forma, este trabalho busca não apenas criar uma solução computacional para o balanceamento químico, mas também destacar a importância dos métodos numéricos como ferramentas no contexto de problemas científicos."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4bbf903-21ca-414f-aed8-54dccfca706d",
   "metadata": {},
   "source": [
    " ### Importando as bibliotecas\n",
    "Com a biblioteca <code>numpy</code>, é possível realizar operações de array, com a <code>re</code>, lidou-se com o input e se organizou a matriz com o valor de cada átomo presente em cada molécula da reação. Além disso, a <code>fractions</code> facilitou a transformação de coeficientes decimais em inteiros.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "04bb2878-6da6-444e-8359-db735afbbdab",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import re\n",
    "from fractions import Fraction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c87b6e43-2360-4dfe-8869-bb20c3eab3c5",
   "metadata": {},
   "source": [
    "## Métodos de resolução"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24e2115b",
   "metadata": {},
   "source": [
    "### Método iterativo Gauss-Seidel\n",
    "Temos três funções nesse método: a primeira, vai verificar se a matriz segue os critérios definidos por nós; a segunda, realiza um pivoteamento caso não esteja convergindo, e a terceira é de fato o método iterativo.<br>\n",
    "Além dos critérios comuns de convergência (critério das linhas e não haver zeros não pivoteáveis na diagonal principal), acrescentou-se o critério da matriz ser no mínimo 3x3. Esse critério surge pela natureza das matrizes correspondentes a coeficientes estequiométricos: em geral, aparecem zeros na diagonal secundária que atrapalham a resolução por métodos numéricos. Assim, todas as matrizes 2x2 são resolvidas pelo método direto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7bc56ef2-ae2c-4118-ac99-ab8e0e1fc653",
   "metadata": {},
   "outputs": [],
   "source": [
    "def criterios(A,b, iterr=100):\n",
    "    \"\"\"\n",
    "    Função que verifica se o sistema cumpre os critérios para ser resolvido por método numérico\n",
    "\n",
    "    Args: \n",
    "        A (numpy.ndarray): Matriz com coeficientes. Deve ser numérica \n",
    "            (dtype float ou int).\n",
    "        b (numpy.ndarray): Vetor de termos independentes. Deve ser numérico \n",
    "            (dtype float ou int).\n",
    "        iterr (int, optional): Número máximo de iterações de pivoteamento. O padrão é 100.\n",
    "\n",
    "    Returns:\n",
    "        numpy.ndarray or bool: A matriz A e o vetor b (pivoteados ou não) se cumprirem todos os critérios, ou False se não.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    if A.shape[0] < 3:\n",
    "        return False # o método direto lida melhor com matrizes pequenas\n",
    "    \n",
    "    while (np.any(np.diag(A) == 0) == True):\n",
    "\n",
    "        for i in range(iterr):\n",
    "            A, b = pivoteamento(A,b)\n",
    "            \n",
    "        break\n",
    "    \n",
    "    if np.any(np.diag(A) == 0) == True:\n",
    "        return False\n",
    "    \n",
    "    def convergencia(A):\n",
    "        \"\"\"Verifica se a matriz A cumpre o critério das linhas para convergência de matrizes resolvidas pelo método numérico.\"\"\"\n",
    "\n",
    "        linhas, colunas = A.shape\n",
    "    \n",
    "        for i in range(linhas):\n",
    "        \n",
    "            soma = 0\n",
    "            for j in range(colunas):\n",
    "                if j == i:\n",
    "                    pass\n",
    "                else:\n",
    "                    soma = soma + A[i,j]\n",
    "            divisao = soma / A[i,i]\n",
    "\n",
    "            if divisao > 1:\n",
    "                return False\n",
    "        return True\n",
    "    \n",
    "    if convergencia(A) == False:\n",
    "        return False\n",
    "    \n",
    "    return A,b\n",
    "\n",
    "def pivoteamento(A,b):\n",
    "    \"\"\"\n",
    "    Função que realiza o método de pivoteamento para um sistema linear formado por uma matriz A e um vetor resposta b\n",
    "\n",
    "    Args: \n",
    "        A (numpy.ndarray): Matriz com coeficientes. Deve ser quadrada e numérica \n",
    "            (dtype float ou int).\n",
    "        b (numpy.ndarray): Vetor de termos independentes. Deve ser numérico \n",
    "            (dtype float ou int).\n",
    "\n",
    "    Returns:\n",
    "        tuple: Tupla contendo:\n",
    "            - A (numpy.ndarray): matriz A pivoteada\n",
    "            - b (numpy.ndarray): vetor b pivoteado\n",
    "            \n",
    "    \"\"\"\n",
    "\n",
    "    linhas = A.shape[0]\n",
    "    for j in range(linhas): # colunas\n",
    "        \n",
    "        # Achar o index do maior pivô\n",
    "        index_maior_a = np.argmax(np.abs(A[j:, j])) + j\n",
    "        A[[j, index_maior_a]] = A[[index_maior_a, j]]\n",
    "        b[[j, index_maior_a]] = b[[index_maior_a, j]]\n",
    "        \n",
    "    return A,b\n",
    "\n",
    "def gauss_seidel(A, b, chute=None, iterr=100, tol=0.05):\n",
    "    \"\"\"\n",
    "    Resolve sistemas lineares utilizando o método de Gauss-Seidel.\n",
    "\n",
    "    Args: \n",
    "        A (numpy.ndarray): Matriz com coeficientes. Deve ser numérica \n",
    "            (dtype float ou int).\n",
    "        b (numpy.ndarray): Vetor de termos independentes. Deve ser numérico \n",
    "            (dtype float ou int).\n",
    "        chute (numpy.ndarray, optional): Vetor de chute. Deve ser numérico\n",
    "            (dtype float ou int) ou None. O padrão é um vetor de uns.\n",
    "        iterr (int, optional): Número máximo de iterações de pivoteamento. O padrão é 100.\n",
    "        tol (float, optional): Diferença mínima entre o vetor solução anterior e o iterado. \n",
    "            Representa o critério de convergência. O padrão é 5%.\n",
    "\n",
    "    Returns:\n",
    "        numpy.ndarray: Solução aproximada do sistema em forma de vetor.\n",
    "\n",
    "    Raises:\n",
    "        ValueError: Se a matriz não aderir aos critérios de Gauss-Seidel.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    if chute==None:\n",
    "        chute = np.ones(b.shape)\n",
    "\n",
    "    if criterios(A,b, iterr) == False:\n",
    "        raise ValueError('A matriz não adere aos critérios de Gauss-Seidel.')\n",
    "    else:\n",
    "        A, b = criterios(A,b, iterr)\n",
    "    \n",
    "    for _ in range(iterr):\n",
    "\n",
    "        # iteração de chutes\n",
    "        chute_antes = chute\n",
    "        \n",
    "        for i in range(len(b)):\n",
    "            soma = sum(A[i, j] * chute[j] for j in range((len(b))) if j != i)\n",
    "            chute[i] = (b[i] - soma) / A[i, i] # chute atualizado a cada iteração\n",
    "        \n",
    "        # erro relativo\n",
    "        distancia = max(abs(chute-chute_antes))\n",
    "        error = distancia/(max(abs(chute)))\n",
    "\n",
    "        if error <= tol:\n",
    "            break\n",
    "\n",
    "    return chute"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42b9f66a-c235-4eef-8cbd-7e370f77da3d",
   "metadata": {},
   "source": [
    "### Método direto Eliminação Gaussiana\n",
    "Se a matriz não cumprir os critérios para a resolução por métodos numéricos, utilizaremos o método direto de eliminação gaussiana, que se utiliza da função de resolução triangular para retornar o resultado, como descrito abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "88c2e3a5-ca0f-4806-beaf-5dba6f99a11c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def resolucao_triangular(A, b):\n",
    "    \"\"\"\n",
    "    Resolve sistemas lineares em que a matriz A é triangular superior utilizando substituição direta.\n",
    "\n",
    "    Args: \n",
    "        A (numpy.ndarray): Matriz com coeficientes. Deve ser triangular e numérica \n",
    "            (dtype float ou int).\n",
    "        b (numpy.ndarray): Vetor de termos independentes. Deve ser numérico \n",
    "            (dtype float ou int).\n",
    "\n",
    "    Returns:\n",
    "        numpy.ndarray: Solução do sistema em forma de vetor.\n",
    "\n",
    "    Raises:\n",
    "        ValueError: Se a matriz A não for quadrada ou houver um zero na diagonal.\n",
    "\n",
    "    \"\"\" \n",
    "    \n",
    "    linhas, colunas = A.shape\n",
    "    resolucao = np.zeros(colunas)\n",
    "    \n",
    "    if linhas != colunas:\n",
    "        raise ValueError('Essa não é uma matriz quadrada :| Esse não é o melhor método!')\n",
    "\n",
    "    else:\n",
    "        # Começa de cima para baixo na matriz\n",
    "        for i in range(linhas - 1, -1, -1):\n",
    "            if A[i, i] == 0:\n",
    "                raise ValueError('Há um zero na diagonal! Não dá pra resolver :(')\n",
    "                return\n",
    "            else:\n",
    "                nova_linha = np.sum(A[i, i+1:] * resolucao[i+1:]) # faz as operações na linha, com os multiplicadores etc\n",
    "                resolucao[i] = (b[i] - nova_linha) / A[i, i]\n",
    "    \n",
    "    return resolucao\n",
    "\n",
    "def eliminacao_gauss_pivo(A,b):\n",
    "    \"\"\"\n",
    "    Resolve sistemas lineares pelo método de eliminação gaussiana com pivoteamento.\n",
    "\n",
    "    Args: \n",
    "        A (numpy.ndarray): Matriz com coeficientes. Deve ser triangular e numérica \n",
    "            (dtype float ou int).\n",
    "        b (numpy.ndarray): Vetor de termos independentes. Deve ser numérico \n",
    "            (dtype float ou int).\n",
    "\n",
    "    Returns:\n",
    "        numpy.ndarray: Solução do sistema em forma de vetor.\n",
    "    \n",
    "    Raises:\n",
    "        ValueError: Se a matriz A não for quadrada ou houver um zero na diagonal.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    # Verifica o número de linhas da matriz.\n",
    "    linhas = A.shape[0]\n",
    "    \n",
    "    for j in range(linhas): # colunas\n",
    "        \n",
    "        # Achar o index do maior pivô\n",
    "        index_maior_a = np.argmax(np.abs(A[j:, j])) + j\n",
    "        A[[j, index_maior_a]] = A[[index_maior_a, j]]\n",
    "        b[[j, index_maior_a]] = b[[index_maior_a, j]]\n",
    "        \n",
    "        for i in range(j+1, linhas): # linhas\n",
    "            \n",
    "            multiplicador = A[i,j] / A[j,j]\n",
    "            \n",
    "            for k in range(j, linhas):\n",
    "                A[i,k] -= multiplicador * A[j,k]\n",
    "                \n",
    "            b[i] -= multiplicador * b[j]\n",
    "\n",
    "    resposta = resolucao_triangular(A,b)\n",
    "        \n",
    "    return resposta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73998393-ffe8-4e65-af87-025626120d28",
   "metadata": {},
   "source": [
    "## Aplicação"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61017c28",
   "metadata": {},
   "source": [
    "### Código de tratamento e cálculo\n",
    "Teremos um DataFrame com os valores de A organizados de maneira que devemos passar os valores para um mesmo lado. O vetor resposta 'b' será sempre 0, uma vez que não há valores inteiros não acompanhados de variáveis no nosso caso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "df1ca345-ca2c-4f92-934b-965f5fd3bd84",
   "metadata": {},
   "outputs": [],
   "source": [
    "def tratamento(A,b):\n",
    "    \"\"\"\n",
    "    Tratamento da matriz com coeficientes e o vetor de termos independentes. Transforma matrizes retangulares em quadradas.\n",
    "\n",
    "    A função identifica a coluna de `A` com o maior número de zeros e a remove, ajustando o vetor `b` subtraindo a linha correspondente da coluna \n",
    "    removida. A resposta da coluna removida é igualada a 1.\n",
    "\n",
    "    Args: \n",
    "        A (numpy.ndarray): Matriz com coeficientes. Deve ser triangular e numérica \n",
    "            (dtype float ou int).\n",
    "        b (numpy.ndarray): Vetor de termos independentes. Deve ser numérico \n",
    "            (dtype float ou int).\n",
    "\n",
    "    Returns:\n",
    "        tuple: Tupla contendo:\n",
    "            - A (numpy.ndarray): matriz A tratada (quadrada)\n",
    "            - b (numpy.ndarray): vetor b tratado (conforme a coluna retirada)\n",
    "            - j (int): índice da coluna retirada \n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    transposta = A.T\n",
    "    qtd_zeros = []\n",
    "\n",
    "    for i in transposta:\n",
    "        qtd_zeros.append((i == 0).sum()) # descobre a coluna com mais zeros\n",
    "    \n",
    "    j = qtd_zeros.index(max(qtd_zeros)) #coluna que será igualada a 1 (e retirada)\n",
    "\n",
    "    A = (np.delete(transposta, j, axis=0)).T\n",
    "    b = b - transposta[j]\n",
    "\n",
    "    return A, b, j\n",
    "\n",
    "def calculo(A,b, formula):\n",
    "    \"\"\"\n",
    "    Realiza o cálculo da solução de um sistema linear utilizando o método de Gauss-Seidel ou, em caso de erro, o método de Eliminação de Gauss com pivoteamento.\n",
    "\n",
    "    A função verifica se a matriz `A` é quadrada. Se não for, a função `tratamento` é chamada para ajustar `A` e `b`. \n",
    "    Em seguida, o método de Gauss-Seidel é tentado para resolver o sistema. Caso a matriz não cumpra os critérios para ser resolvida por Gauss-Seidel,\n",
    "    a eliminação de Gauss com pivoteamento é utilizada como alternativa. Após calcular a solução, a função tenta tornar os resultados inteiros, \n",
    "    multiplicando por um denominador comum.\n",
    "\n",
    "    Args:\n",
    "        A (numpy.ndarray): Matriz com coeficientes. Deve ser numérica \n",
    "            (dtype float ou int).\n",
    "        b (numpy.ndarray): Vetor de termos independentes. Deve ser numérico \n",
    "            (dtype float ou int).\n",
    "\n",
    "    Returns:\n",
    "        numpy.ndarray: Vetor solução ajustado, com todos os valores convertidos para inteiros, e com o valor 1 inserido, se a matriz inicial não era quadrada.\n",
    "    \n",
    "    Notes:\n",
    "        - Se a matriz A não for quadrada, ela é ajustada pelo método tratamento, que pode remover uma coluna de A e ajustar b.\n",
    "        - A solução final é multiplicada por um denominador comum, se houver frações, para tornar os valores inteiros.\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    if A.shape[0] != A.shape[1]:\n",
    "        matriz_tratada, resposta_tratada, j = tratamento(A,b)\n",
    "    else:\n",
    "        matriz_tratada, resposta_tratada = A,b\n",
    "\n",
    "    try:\n",
    "        r = gauss_seidel(matriz_tratada, resposta_tratada)\n",
    "    except ValueError:\n",
    "        # print('não foi numérico')\n",
    "        r = eliminacao_gauss_pivo(matriz_tratada,resposta_tratada)\n",
    "    \n",
    "    if A.shape[0] != A.shape[1]:\n",
    "        r = np.insert(r, j, 1)\n",
    "\n",
    "    while np.any([not numero.is_integer() for numero in r]):\n",
    "        denominador = 1\n",
    "        for _, numero in enumerate(r):\n",
    "            fracao = Fraction(numero).limit_denominator()\n",
    "            \n",
    "            if fracao.denominator > denominador:\n",
    "                denominador = fracao.denominator\n",
    "\n",
    "        r = r * denominador\n",
    "\n",
    "    return expressando(r, formula)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "653f998c",
   "metadata": {},
   "source": [
    "### Funções para o input: Recebe as equações químicas\n",
    "\n",
    "As funções desta seção do notebook são responsáveis por obter a equação química balanceada. O objetivo é permitir que o usuário insira uma reação contendo os reagentes e produtos, no formato: $Al + Cl_2 \\rightarrow AlCl_3$. Esse formato deve ser rigorosamente respeitado para evitar erros no processamento. Será possível identificar o sinal de '+' como um separador de diferentes moléculas e usar o símbolo '->' como referência para separar reagentes de produtos. Além disso, cada molécula deve seguir a notação química padrão, utilizando letras maiúsculas e minúsculas para os símbolos dos elementos, seguidas de números opcionais para os índices estequiométricos. Caso não haja um número após o elemento, o programa interpretará que ele está presente apenas um desse átomo na molécula.<br>\n",
    "O código interpreta essa entrada e extrai informações essenciais, como os tipos de átomos envolvidos e suas respectivas quantidades em cada molécula. Essas informações são utilizadas posteriormente para montar sistemas de equações lineares. Ao serem resolvidos pelo método de Gauss-Seidel, esses sistemas permitem determinar os coeficientes que balanceiam a reação química."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1afebe3b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def encontra_atomos(moleculas):\n",
    "    \"\"\"\n",
    "    Função que identifica todos os átomos únicos presentes nas moléculas fornecidas.\n",
    "\n",
    "    Args:\n",
    "        moleculas (list of str): Lista contendo strings que representam as moléculas dos reagentes.\n",
    "\n",
    "    Returns:\n",
    "        list of str: Lista, em ordem de ocorrência, dos átomos únicos encontrados nas moléculas.\n",
    "    \"\"\"\n",
    "    atomos = []\n",
    "    \n",
    "    for molecula in moleculas:\n",
    "        atomos.extend(re.findall(r\"([A-Z][a-z]*)\", molecula))\n",
    "\n",
    "    for elemento, indice in zip(atomos[::-1], range(len(atomos)-1,0,-1)):\n",
    "        if atomos.count(elemento) > 1:\n",
    "            atomos.pop(indice)\n",
    "    \n",
    "    return atomos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1ff4556f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def eosparenteses(molecula):\n",
    "    \"\"\"\n",
    "    Função que lida com fórmulas químicas com parênteses, desse modo é possível considerar\n",
    "    os multiplicadores fora dos parênteses.\n",
    "\n",
    "    Args:\n",
    "        molecula (str): String representando uma fórmula química.\n",
    "\n",
    "    Returns:\n",
    "        list of list: Lista contendo sublistas, onde cada sublista é formada pelo nome do átomo (str)\n",
    "                      e sua quantidade que pode ser uma string (caso não tenha sido convertida) ou \n",
    "                      um número inteiro (int) se precisou achar o produto entre o coeficiente do átomo \n",
    "                      e o coeficiente do grupo.\n",
    "    \"\"\"\n",
    "    aqui, indice = [], 0\n",
    "\n",
    "    for i in range(len(molecula)):\n",
    "        if molecula[i] == \"(\":\n",
    "            indice = i\n",
    "            aqui.extend(re.findall(r\"([A-Z][a-z]*)(\\d*)\", molecula[:i]))\n",
    "        elif molecula[i] == \")\":\n",
    "            valor = molecula[i+1]\n",
    "            parenteses = re.findall(r\"([A-Z][a-z]*)(\\d*)\", molecula[indice:i])\n",
    "            parenteses = [list(match) for match in parenteses]\n",
    "            \n",
    "            for indice in range(len(parenteses)):\n",
    "                if parenteses[indice][1] == \"\":\n",
    "                    parenteses[indice][1] = molecula[i+1]\n",
    "                else:\n",
    "                    parenteses[indice][1] = int(parenteses[indice][1])*int(molecula[i+1])\n",
    "                    \n",
    "        \n",
    "            aqui.extend(parenteses)    \n",
    "            aqui.extend(re.findall(r\"([A-Z][a-z]*)(\\d*)\", molecula[i+2:]))\n",
    "\n",
    "    return aqui"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fb5d9cae",
   "metadata": {},
   "outputs": [],
   "source": [
    "def encontra_coef(atomos, moleculas, qtd_reagentes):\n",
    "    \"\"\"\n",
    "    Função que calcula a matriz de coeficientes para um sistema linear representando\n",
    "    o balanceamento de uma equação química em que as colunas representam as moléculas da\n",
    "    reação e as linhas - os átomos, que foram encontrados em ordem de ocorrência.\n",
    "\n",
    "    Args:\n",
    "        atomos (list of str): Lista de átomos únicos presentes na reação química.\n",
    "        moleculas (list of str): Lista de moléculas da equação química (reagentes e produtos).\n",
    "        qtd_reagentes (int): Quantidade de moléculas que pertencem aos reagentes. \n",
    "                             Utilizado para ajustar os sinais dos coeficientes dos produtos, \n",
    "                             pois para o método interativo de Gauss-Seide é necessário.\n",
    "\n",
    "    Returns:\n",
    "        numpy.ndarray: Matriz de coeficientes em que as linhas representam os átomos e as\n",
    "                       colunas - as molécula. Os valores indicam as quantidades de cada átomo\n",
    "                       presente em cada molécula. Para os produtos, os coeficientes são negativos.\n",
    "    \"\"\"\n",
    "    coef = np.array([[0]*len(moleculas)]*len(atomos))\n",
    "    \n",
    "    for _, coluna in zip(moleculas, range(len(moleculas))):\n",
    "        dados =  eosparenteses(moleculas[coluna])\n",
    "        if len(dados) == 0:\n",
    "            dados = re.findall(r\"([A-Z][a-z]*)(\\d*)\", moleculas[coluna])\n",
    "        \n",
    "        for atomo, linha in zip(atomos, range(len(atomos))):\n",
    "            for i in dados:\n",
    "                if i[0] == atomo:\n",
    "                    if i[1] == \"\": \n",
    "                        coef[linha][coluna] += 1\n",
    "                    else:\n",
    "                        coef[linha][coluna] += int(i[1])\n",
    "                \n",
    "            if coluna >= qtd_reagentes:\n",
    "                coef[linha][coluna] *= (-1)\n",
    "                    \n",
    "\n",
    "    return coef"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "44445376",
   "metadata": {},
   "outputs": [],
   "source": [
    "def balaceamento():\n",
    "    \"\"\"\n",
    "    Função que solicita uma equação química ao usuário e devolve a quantidade de \n",
    "    cada átomo de cada molécula, as moléculas e a matriz de coeficientes para balanceamento.\n",
    "\n",
    "    Args:\n",
    "        None\n",
    "\n",
    "    Returns:\n",
    "        tuple: Uma tupla contendo:\n",
    "            - atomos (list of str): Lista de átomos únicos presentes na equação em ordem de ocorrência.\n",
    "            - moleculas (list of str): Lista de moléculas (reagentes e produtos).\n",
    "            - numpy.ndarray: Matriz de coeficientes para balanceamento da equação química.\n",
    "    \"\"\"\n",
    "    \n",
    "    print(\"Digite a equação para ser balanceada:\")\n",
    "    print(\"Siga o exemplo: Al + Cl2 -> AlCl3\\n\")\n",
    "    formula = input(\"\")\n",
    "    formuladiv = formula.replace(\"+\", \"\").partition(\"->\")\n",
    "    \n",
    "    reagente = [i for i in formuladiv[0].split(\" \") if i != \"\"]\n",
    "    produto = [i for i in formuladiv[2].split(\" \") if i != \"\"]\n",
    "    atomos = encontra_atomos(reagente)\n",
    "\n",
    "    A = encontra_coef(atomos, reagente+produto, len(reagente))\n",
    "    b = np.zeros(A.shape[0])\n",
    "\n",
    "    return calculo(A, b, formula)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f6dfbb6-dccb-431b-a17a-8227d7b76e76",
   "metadata": {},
   "source": [
    "### Output: Expressando o balanceamento encontrado\n",
    "\n",
    "Essa é a última função a ser chamada e tem como objetivo apresentar os resultados. Para isso, é criada uma nova string que corresponde à equação fornecida no início do input, agora acompanhada dos coeficientes estequiométricos de cada molécula encontrados pelos métodos presentes nesse notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d5a48ed5-9ea4-4fd0-91d6-824431b6e6e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def expressando(coeficientes, equacao):\n",
    "    \"\"\"\n",
    "    Função que retorna a equação química balanceada como uma string, \n",
    "    combinando os coeficientes encontrados com o método numérico de Gauss-Seidel.\n",
    "\n",
    "    Args:\n",
    "        coeficientes (list or numpy.ndarray): Lista ou array contendo os coeficientes balanceados para as moléculas.\n",
    "        equacao (str): String contendo a equação química no formato \"reagente1 + reagente2 -> produto1 + produto2\".\n",
    "\n",
    "    Returns:\n",
    "        str: A equação química balanceada com os coeficientes incluídos.\n",
    "    \"\"\"\n",
    "    formuladiv = equacao.replace(\"+\", \"\").partition(\"->\")\n",
    "    \n",
    "    reagente = [i for i in formuladiv[0].split(\" \") if i != \"\"]\n",
    "    produto = [i for i in formuladiv[2].split(\" \") if i != \"\"]\n",
    "    moleculas = reagente + produto\n",
    "    \n",
    "    resultado = \"\"\n",
    "    \n",
    "    for i in range(len(reagente)):\n",
    "        resultado += str(int(coeficientes[i])) + reagente[i] \n",
    "        if i != len(reagente) -1:\n",
    "            resultado += \" + \"\n",
    "    \n",
    "    resultado += \" -> \"\n",
    "\n",
    "    for j in range(len(produto)):\n",
    "        resultado += str(int(coeficientes[j + len(reagente)])) + produto[j]\n",
    "        if j != len(produto) -1:\n",
    "            resultado += \" + \"\n",
    "\n",
    "    return resultado"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9db359c6-1fef-4e22-86a5-8bc8ef654e95",
   "metadata": {},
   "source": [
    "### Validação do Código\n",
    "\n",
    "<p style=\"text-align:justify;\">  Durante o processo de validação, é necessário testar tanto casos mais simples quanto aqueles que apresentam maior complexidade, como moléculas com átomos repetidos (por exemplo, NH₄NO₂) ou moléculas que utilizam parênteses e multiplicadores. O sucesso do código depende de sua capacidade de interpretar corretamente fórmulas químicas, identificar átomos únicos, processar moléculas com estruturas mais elaboradas e gerar uma matriz de coeficientes coerente. Com todas essas informações, o código é capaz de encontrar os coeficientes necessários para balancear a equação de maneira eficaz. Para validar o código de balanceamento de equações químicas e assegurar que ele funcione de maneira precisa e confiável em diferentes cenários, seguem alguns exemplos de equações balanceadas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "507f8114-897a-4144-af4c-1e166c2d24dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite a equação para ser balanceada:\n",
      "Siga o exemplo: Al + Cl2 -> AlCl3\n",
      "\n",
      "\n",
      "A equação balanceada: 2Al + 3Cl2 -> 2AlCl3\n"
     ]
    }
   ],
   "source": [
    "#Al + Cl2 -> AlCl3\n",
    "equacao1 = balaceamento()\n",
    "print(\"\\nA equação balanceada:\", equacao1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e655305a-2764-4f26-a530-735ea8b6d56b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite a equação para ser balanceada:\n",
      "Siga o exemplo: Al + Cl2 -> AlCl3\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " NH4NO2 -> N2 + H2O\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "A equação balanceada 1NH4NO2 -> 1N2 + 2H2O\n"
     ]
    }
   ],
   "source": [
    "# NH4NO2 -> N2 + H2O\n",
    "equacao2 = balaceamento()\n",
    "print(\"\\nA equação balanceada\", equacao2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf624add-267a-47fd-a4ca-352b6c09cc89",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite a equação para ser balanceada:\n",
      "Siga o exemplo: Al + Cl2 -> AlCl3\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Al + H2SO4 -> Al2(SO4)3 + H2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "A equação balanceada 2Al + 3H2SO4 -> 1Al2(SO4)3 + 3H2\n"
     ]
    }
   ],
   "source": [
    "# Al + H2SO4 -> Al2(SO4)3 + H2\n",
    "equacao3 = balaceamento()\n",
    "print(\"\\nA equação balanceada\", equacao3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1b3cafb-de30-4939-98ca-acc86190086c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite a equação para ser balanceada:\n",
      "Siga o exemplo: Al + Cl2 -> AlCl3\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Na + Cl -> NaCl\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "A equação balanceada: 1Na + 1Cl -> 1NaCl\n"
     ]
    }
   ],
   "source": [
    "# Na + Cl -> NaCl\n",
    "equacao5 = balaceamento()\n",
    "print(\"\\nA equação balanceada:\", equacao5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d23cbc5b-32f8-46fc-9240-49418dd62c06",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite a equação para ser balanceada:\n",
      "Siga o exemplo: Al + Cl2 -> AlCl3\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " C2H6O -> C4H10O + H2O\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "A equação balanceada: 2C2H6O -> 1C4H10O + 1H2O\n"
     ]
    }
   ],
   "source": [
    "#C2H6O -> C4H10O + H2O\n",
    "equacao6 = balaceamento()\n",
    "print(\"\\nA equação balanceada:\", equacao6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee68c399-9097-4fb6-82db-f569f01a6ef9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Digite a equação para ser balanceada:\n",
      "Siga o exemplo: Al + Cl2 -> AlCl3\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " NOH + H2 -> N2 + H2O\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "A equação balanceada: 2NOH + 1H2 -> 1N2 + 2H2O\n"
     ]
    }
   ],
   "source": [
    "# NOH + H2 -> N2 + H2O\n",
    "equacao4 = balaceamento()\n",
    "print(\"\\nA equação balanceada:\", equacao4)"
   ]
  }
 ],
 "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}