Term_AngleDièdre_chaudronnerie.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CT996wd1H4cP"
      },
      "source": [
        "# Geométrie vectorielle, algèbre de Clifford (ou Algèbre Géométrique) et Chaudronnerie:\n",
        "\n",
        "Au lycée professionnel, en co-intervention, il arrive que l'on ait besoin d'outils mathématiques qui ne sont pas dans la panoplie indiquée par le programme. Par exemple, comment faire pour déterminer un angle dièdre formeé par deux plaques de taule? Le recour à  geogebra (ou solidworks) permet au prix d'une construction geometrique, d'obtenir une mesure et la réponse.\n",
        "\n",
        "Il est néanmoins possible de répondre par le calcul. Différentes méthodes sont disponibles, s'appuyant sur le produit scalaire de deux vecteurs (qui est au programme de la terminale bac pro, selon les sections) et le produit vectoriel (qui n'est pas au programme).\n",
        "\n",
        "Tant qu'à être hors programme, on explorera, l'algèbre de Clifford (ou algèbre géométrique) qui nous fournira une réponse en introduisant de nouveaux objets géométriques."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uBNY0DiXDuuS",
        "jp-MarkdownHeadingCollapsed": true,
        "tags": []
      },
      "source": [
        "# Installation et importation de quelques modules utiles pour la suite\n",
        "Selon l'environnement d'exécution de ce notebook, quelques modules doivent être installés. Sur "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7ZH53-MBEcxz"
      },
      "source": [
        "## Installation\n",
        "\n",
        "Le module clifford n'est pas disponible dans google colaboratory, mais on peut l'installer. Sur une installation locale (son propre ordinateur), l'installation est définitive (par exemple dans edupython). Pour le moment (été 2022), le module n'est pas disponible dans la plateforme [Capytale](https://capytale2.ac-paris.fr/web/accueil)\n",
        "\n",
        "|Environnement|Installation|Définitive|\n",
        "|------|------|------|\n",
        "|google colab|oui|non|\n",
        "|Capytale|non|   x |\n",
        "|local|oui|oui|\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "wzfy4r-mtDFb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9dcd1fcf-907e-48bb-b9b0-a21b194affb8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting clifford\n",
            "  Downloading clifford-1.4.0-py3-none-any.whl (159 kB)\n",
            "\u001b[K     |████████████████████████████████| 159 kB 7.1 MB/s \n",
            "\u001b[?25hRequirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from clifford) (1.7.3)\n",
            "Requirement already satisfied: numba>0.46 in /usr/local/lib/python3.7/dist-packages (from clifford) (0.56.0)\n",
            "Collecting sparse\n",
            "  Downloading sparse-0.13.0-py2.py3-none-any.whl (77 kB)\n",
            "\u001b[K     |████████████████████████████████| 77 kB 7.7 MB/s \n",
            "\u001b[?25hRequirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.7/dist-packages (from clifford) (1.21.6)\n",
            "Requirement already satisfied: h5py in /usr/local/lib/python3.7/dist-packages (from clifford) (3.1.0)\n",
            "Requirement already satisfied: importlib-metadata in /usr/local/lib/python3.7/dist-packages (from numba>0.46->clifford) (4.12.0)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from numba>0.46->clifford) (57.4.0)\n",
            "Requirement already satisfied: llvmlite<0.40,>=0.39.0dev0 in /usr/local/lib/python3.7/dist-packages (from numba>0.46->clifford) (0.39.0)\n",
            "Requirement already satisfied: cached-property in /usr/local/lib/python3.7/dist-packages (from h5py->clifford) (1.5.2)\n",
            "Requirement already satisfied: typing-extensions>=3.6.4 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata->numba>0.46->clifford) (4.1.1)\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata->numba>0.46->clifford) (3.8.1)\n",
            "Installing collected packages: sparse, clifford\n",
            "Successfully installed clifford-1.4.0 sparse-0.13.0\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Requirement already satisfied: numba in /usr/local/lib/python3.7/dist-packages (0.56.0)\n",
            "Requirement already satisfied: numpy<1.23,>=1.18 in /usr/local/lib/python3.7/dist-packages (from numba) (1.21.6)\n",
            "Requirement already satisfied: llvmlite<0.40,>=0.39.0dev0 in /usr/local/lib/python3.7/dist-packages (from numba) (0.39.0)\n",
            "Requirement already satisfied: importlib-metadata in /usr/local/lib/python3.7/dist-packages (from numba) (4.12.0)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from numba) (57.4.0)\n",
            "Requirement already satisfied: typing-extensions>=3.6.4 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata->numba) (4.1.1)\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata->numba) (3.8.1)\n"
          ]
        }
      ],
      "source": [
        "#%pip install galgebra\n",
        "!pip install clifford\n",
        "!pip install numba -U"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "collapsed": true,
        "id": "pbhp1Aiaoyr6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 575
        },
        "outputId": "50ec780a-1ec0-47c5-a89b-3b33e0a69c23"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting mpl_toolkits.clifford\n",
            "  Downloading mpl_toolkits.clifford-0.0.3-py3-none-any.whl (6.8 kB)\n",
            "Collecting trimesh\n",
            "  Downloading trimesh-3.14.0-py3-none-any.whl (660 kB)\n",
            "\u001b[K     |████████████████████████████████| 660 kB 8.9 MB/s \n",
            "\u001b[?25hRequirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from mpl_toolkits.clifford) (3.2.2)\n",
            "Requirement already satisfied: clifford in /usr/local/lib/python3.7/dist-packages (from mpl_toolkits.clifford) (1.4.0)\n",
            "Requirement already satisfied: sparse in /usr/local/lib/python3.7/dist-packages (from clifford->mpl_toolkits.clifford) (0.13.0)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from clifford->mpl_toolkits.clifford) (1.7.3)\n",
            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.7/dist-packages (from clifford->mpl_toolkits.clifford) (1.21.6)\n",
            "Requirement already satisfied: numba>0.46 in /usr/local/lib/python3.7/dist-packages (from clifford->mpl_toolkits.clifford) (0.56.0)\n",
            "Requirement already satisfied: h5py in /usr/local/lib/python3.7/dist-packages (from clifford->mpl_toolkits.clifford) (3.1.0)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from numba>0.46->clifford->mpl_toolkits.clifford) (57.4.0)\n",
            "Requirement already satisfied: importlib-metadata in /usr/local/lib/python3.7/dist-packages (from numba>0.46->clifford->mpl_toolkits.clifford) (4.12.0)\n",
            "Requirement already satisfied: llvmlite<0.40,>=0.39.0dev0 in /usr/local/lib/python3.7/dist-packages (from numba>0.46->clifford->mpl_toolkits.clifford) (0.39.0)\n",
            "Requirement already satisfied: cached-property in /usr/local/lib/python3.7/dist-packages (from h5py->clifford->mpl_toolkits.clifford) (1.5.2)\n",
            "Requirement already satisfied: typing-extensions>=3.6.4 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata->numba>0.46->clifford->mpl_toolkits.clifford) (4.1.1)\n",
            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata->numba>0.46->clifford->mpl_toolkits.clifford) (3.8.1)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mpl_toolkits.clifford) (1.4.4)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mpl_toolkits.clifford) (3.0.9)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mpl_toolkits.clifford) (0.11.0)\n",
            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mpl_toolkits.clifford) (2.8.2)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib->mpl_toolkits.clifford) (1.15.0)\n",
            "Installing collected packages: trimesh, mpl-toolkits.clifford\n",
            "Successfully installed mpl-toolkits.clifford-0.0.3 trimesh-3.14.0\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.colab-display-data+json": {
              "pip_warning": {
                "packages": [
                  "mpl_toolkits"
                ]
              }
            }
          },
          "metadata": {}
        }
      ],
      "source": [
        "!pip install mpl_toolkits.clifford"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "49kLnhFglgEM"
      },
      "outputs": [],
      "source": [
        "#!pip install git+https://github.com/pygae/pyganja.git"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e1WDy7OyFrRb"
      },
      "source": [
        "## Importation des modules:\n",
        "Commençons par les modules:\n",
        "   * numpy\n",
        "   * matplotlib"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8hrI10cCD4Ma"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "from matplotlib import pyplot as plt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HqS2iToEtgcr"
      },
      "source": [
        "# Angle entre deux plans, angle dièdre:\n",
        "On dispose d'un repère orthonormé $\\mathcal{R}(O, \\vec{i}, \\vec{j}, \\vec{k})$. Les coordonnées des vecteurs sont:\n",
        "\n",
        "$$\\vec{i}=\n",
        "\\begin{pmatrix}\n",
        "    1 \\\\\n",
        "    0  \\\\\n",
        "    0\n",
        "\\end{pmatrix}  \n",
        "~~~~~~~\\vec{j}=\n",
        "\\begin{pmatrix}\n",
        "    0 \\\\\n",
        "    1  \\\\\n",
        "    0\n",
        "\\end{pmatrix}\n",
        "~~~~~~~\\vec{k}=\n",
        "\\begin{pmatrix}\n",
        "    0 \\\\\n",
        "    0  \\\\\n",
        "    1\n",
        "\\end{pmatrix}$$\n",
        "\n",
        "\n",
        "## Le plan $P_1$\n",
        "Définissons un premier plan $P_1$: par le point $O(0,0,0)$ et choisissons les vecteurs $\\vec{j}$ et $\\vec{k}$ comme vecteurs directeurs.\n",
        "\n",
        "**Qu'est-ce que cela signifie ?**\n",
        "\n",
        "Pour atteindre n'importe quel point ou \"endroit\" du plan, il suffit de prendre une proportion, ou une quantité, de chacun de ces deux vecteurs. On dit que l'on fait une combinaison linéaire des vecteurs:\n",
        "\n",
        "$$\\alpha \\vec{j}+\\beta \\vec{k}$$ où $\\alpha$ et $\\beta$ sont deux nombres.\n",
        "\n",
        "Par exemple pour $\\alpha=3$ et $\\beta=-2$, en \"partant\" du point $\\mathcal{O}$, on atteint un point du plan grâce au vecteur $\\vec{v}$:\n",
        "$$\\vec{v} = 3 \\vec{j}-2 \\vec{k}$$\n",
        "\n",
        "<div style=\"display: flex; gap:10px;\">\n",
        "  <img src=\"https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgBANVbdzX8NWpRK5qeru_7MLEiAntAnDAajFaFV4jR9fJD_2aaDahUc4QVEHcRPDsOsqkyXYWlvwrk0oerNi7l7ISSg-4qa5Tbge_DTqvBJ6NewHd6Z44RjHdX310H_UmD5T-CZXeqbTFHxK42FWPeH2rG3H-r4FybpdProI9WRPd9BG3j1uzPUSiPag/s760/Combinaison%20lin%C3%A9aire.png\" width=\"200\" height=\"200\" alt=\"img\"/ class=\"center\">\n",
        "  <p style=\"font-size: 10px;\">\n",
        "   Combinaison linéaire de deux vecteurs.\n",
        "  </p>\n",
        "</div>\n",
        "\n",
        "## Le plan $P_2$\n",
        "Définissons un deuxième plan $P_2$, passant par le point $\\mathcal{O}$ et de vecteurs directeurs $\\vec{k}$ et $\\vec{u}$ avec $\\vec{u}=\\vec{i}+\\vec{j}$:\n",
        "\n",
        "<div style=\"display: flex; gap:10px;\">\n",
        "  <img src=\"https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjxU6RS9E_YwcvNkzDNqPPNyMIlc6338Fiyk0K7UZGTy4Z6k3WZXVKcyGrsOu7hKJbZDu3bkYw7UJdmwU1vYJxllC3VjNz1U-L_pzkaKxCEUoNxh22eTIgmeHDZuMZHzz5gIPxmhF1LngG9V0jNvKc2GIwb0nE3A5_C_01FG4TKFQ0ned56A6ZOPQQqXA/s459/AngleDiedre-geogebra.png\" width=\"300\" height=\"300\" alt=\"img\"/ class=\"center\">\n",
        "  <p style=\"font-size: 10px;\">\n",
        "   Angle entre deux plans.\n",
        "  </p>\n",
        "</div>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Détermination de l'angle dièdre avec geogebra:\n",
        "Les deux plans sont sécants selon l'axe vertical. Avec *geogebra*, on détermine la mesure de l'angle entre les deux plans (entre les vecteurs $\\vec{u}$ et  $\\vec{j}$) égale à $45°$. Toujours avec geogebra, on peut vérifier que l'angle entre deux représentants des vecteurs normaux $vec{n_1}$ et $\\vec{n_2}$ des plans est bien égal à $45°$."
      ],
      "metadata": {
        "id": "Ow3vDy8gOAA-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Méthode utilisant le produit scalaire et le produit vectoriel:\n",
        "Les étapes pour obtenir la mesure de l'angle dièdre entre deux plans définis par un point et deux vecteurs directeurs seront:\n",
        "   1. Pour chaque plan défini par deux vecteurs directeurs, on calcule un vecteur normal avec le produit vectoriel des deux vecteurs directeurs. Ce vecteur normal est orthogonal aux deux vecteurs directeurs du plan.\n",
        "       * $P_1$ : déf par le point $\\mathcal{O}$ et les vecteurs directeurs $\\vec{j}$ et $\\vec{k}$.\n",
        "       * un vecteur normal de $P_1$ est le vecteur $\\vec{i}$, on peut le vérifier:$$\\vec{j} \\times \\vec{k} = \\vec{i}$$\n",
        "       * **remarque:** le produit vectoriel anticommute ! Le signe du produit change avec l'ordre des facteurs: $$\\vec{k} \\times \\vec{j} = -\\vec{i}$$\n",
        "       \n",
        "   2. on calcule le produit scalaire entre les deux vecteurs normaux\n",
        "   3. on calcul les normes de chacun des deux vecteurs normaux.\n",
        "   4. on en déduit le cosinus de l'angle des deux vecteurs normaux.\n",
        "   5. et enfin l'angle entre les deux vecteurs normaux, c'est à dire l'angle dièdre"
      ],
      "metadata": {
        "id": "PVEUKnYhOOZz"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bAsgAl2Ltd6_",
        "outputId": "7d70d927-dbae-40de-e2f7-7951f6b60bef"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "45.00000000000001"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "#--------------------CALCUL DE L'ANGLE DIEDRE ENTRE DEUX PLANS DE L'ESPACE ---------------------------------\n",
        "#On commence par définir les vecteurs  du repères orthonormal, par leur coordonnées.\n",
        "#\n",
        "# Les vecteurs j et k sont les vecteurs directeurs du plan P_1\n",
        "# les vecteurs U et k sont les vecteurs directeurs du plan P_2\n",
        "#\n",
        "i = np.array([1,0,0])\n",
        "j = np.array([0,1,0])\n",
        "k = np.array([0,0,1])\n",
        "u = i + j\n",
        "\n",
        "#\n",
        "# On calcule des vecteurs normaux de chacun des plans \n",
        "#\n",
        "n1 = np.cross(j, k)\n",
        "n2 = np.cross(u, k)\n",
        "\n",
        "# On calcule le produit scalaire, s,  entre n1 et n2.\n",
        "\n",
        "s = np.dot(n1,n2)\n",
        "\n",
        "# On calcule le cosinus, c, de l'angle =(n1,n2).\n",
        "# np.linalg.norm(n1) : permet de calculer la norme du vecteur n1\n",
        "\n",
        "c = s/(np.linalg.norm(n1) * np.linalg.norm(u))\n",
        "\n",
        "angle = np.arccos(c)\n",
        "angle = angle * 180/np.pi\n",
        "angle"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uo0TmD-hgBmV"
      },
      "source": [
        "## Algèbre Géométrique ou algèbre de Clifford:\n",
        "\n",
        "### Un peu d'histoire:\n",
        "Jusque il y a peu, en Mathématique, on réalisait des calculs avec des nombres (entiers, décimaux, \"fractions\", réels de manière générale comme tous les exemples précédents ou ceux-ci: $\\pi$ ou $\\sqrt{2} ...$).\n",
        "\n",
        "Dans le paragraphe précédent, on a fait des calculs avec des vecteurs, addition et même multiplication. On a découvert deux types de multiplication:\n",
        "   * le produit scalaire: on lui fait \"manger\" deux vecteurs et il donne un nombre. Les anglo-étusaniens, le nomment produit \"point\" ou *dot product*.\n",
        "   * le produit vectoriel: prend deux vecteurs et donne un troisième vecteurs orthogonal au deux autres vecteurs. Les anglo-étusaniens, le nomment produit \"croix\" ou *cross product*. **Ce produit n'a de sens que dans l'espace à trois dimensions**.\n",
        "   \n",
        "Au $XIX^e$  le mathématicien allemand [Herman Grassman](https://www.bibmath.net/bios/index.php?action=affiche&quoi=grassman) invente une nouvelle façon de multiplier deux vecteurs: Le produit exterieur, *wedge product* en anglais que pourrait traduire par produit \"coin\". En France, ce \"coin\" noté $\\wedge$ peut correspondre au produit vectoriel...Il faut juste s'entendre sur la notation. \n",
        "<div style=\"display: flex; gap:10px;\">\n",
        "  <img src=\"https://www.bibmath.net/bios/images/grassman.jpg\" width=\"100\" height=\"120\" alt=\"img\"/ class=\"center\">\n",
        "  <p style=\"font-size: 10px;\">\n",
        "  </p>\n",
        "</div>\n",
        "Pour multiplier deux vecteurs $\\vec{a}$ et $\\vec{b}$ avec ce produit, on écrit (en laissant les flèches de coté):\n",
        " $$ a \\wedge b$$\n",
        "Le produit ou résultat de cette muliplication, n'est ni un nombre ni un vecteur. Contrairement au produit vectoriel, cette multiplication peut se faire dans le plan, l'espace à trois dimension ou plus.\n",
        "\n",
        "Le mathématiciens anglais, [William Kingdon Clifford](https://fr.wikipedia.org/wiki/William_Kingdon_Clifford)\n",
        "<div style=\"display: flex; gap:10px;\">\n",
        "  <img src=\"https://mathshistory.st-andrews.ac.uk/Biographies/Clifford/Clifford_4.jpeg\" width=\"100\" height=\"120\" alt=\"img\"/ class=\"center\">\n",
        "  <p style=\"font-size: 10px;\">\n",
        "  </p>\n",
        "</div>\n",
        "s'appuyant sur les travaux de Grassman, invente le produit géométrique. Le produit géométrique des deux vecteurs de l'exemple précédent, se note sans symbole de multiplication: $$ab$$\n",
        "\n",
        "Les éléments de l'algèbre de Clifford (Ce que l'on peut obtenir comme résultat d'un produit) de l'espace à trois dimensions de notre quotidien, sont:\n",
        "   * des nombres\n",
        "   * des vecteurs\n",
        "   * des bivecteurs éléments de plan\n",
        "   * des trivecteurs, éléments d'espace.\n",
        "   \n",
        "On a une jolie représentation dans l'image ci-dessous:\n",
        "\n",
        "<div style=\"display: flex; gap:10px;\">\n",
        "  <img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/2/27/N_vector_positive.svg/800px-N_vector_positive.svg.png\" width=\"350\" height=\"350\" alt=\"img\"/ class=\"center\">\n",
        "  <p style=\"font-size: 10px;\">\n",
        "        éléments de l'algèbre de Clifford\n",
        "  </p>\n",
        "</div>\n",
        "\n",
        "Il y a des éléments de différents grades:\n",
        "\n",
        "|grade| objet|Correspondance Géométrique|\n",
        "|:------:|:------|:------|\n",
        "|0|nombre|point|\n",
        "|1| vecteur|droite|\n",
        "|2 |bivecteur|plan|\n",
        "|3 |trivecteur|espace|\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Le module python *clifford*\n",
        "Commençons par jouer avec ces éléments:\n",
        "\n",
        "Le module clifford nous fourni, des vecteurs unitaires formant une base (Comme les vecteurs $\\vec{i}$, $\\vec{j}$, $\\vec{k}$, du repère orthonormal). Ils sont nommés:\n",
        "$$e_1, e_2, e_3$$\n",
        "\n",
        "On peut multiplier ces vecteurs de différentes façons:\n",
        "   * par le produit scalaire, noté $\\cdot$, par exemple $e_1 \\cdot e_2$\n",
        "   * par le produit extérieur, noté $\\wedge$, par exemple $e_1 \\wedge e_2$\n",
        "   * par le produit géométrique, que l'on n'écrit pas, par exemple $e_1e_2$\n",
        "   \n",
        "Après avoir importé les modules *ad-hoc*:"
      ],
      "metadata": {
        "id": "tUa1aUIGOsXb"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "hkyIrY7QH4cl"
      },
      "outputs": [],
      "source": [
        "import mpl_toolkits.clifford\n",
        "from clifford.g3c import *\n",
        "from math import pi, acos\n",
        "from decimal import Decimal"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9JU7SF4QH4cm"
      },
      "source": [
        "On commence par créer deux vecteurs $a$ et $b$:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "l1ZPJmz5xo2N"
      },
      "outputs": [],
      "source": [
        "a = 3*e1 + e2 + 2*e3\n",
        "b = e1 - e2 + e3"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Aef9NO6CgGwQ",
        "tags": []
      },
      "source": [
        "### Une nouvelle multiplication: le produit géométrique:\n",
        "Calculons leur produit géométrique des vecteurs $a$ et $b$:\n",
        "\n",
        " $$ M=ab$$\n",
        "\n",
        "M est un multivecteur, une combinaison d'éléments de grade $0$ et de grade $2$:\n",
        "```Python\n",
        "M.grades()\n",
        "```\n",
        "Nous allons constater que ce multivecteur est un combinaison d'un nombre et de bivecteur. Comme quoi, on peut additionner les choux et les carottes."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OesNYNPZgNqF"
      },
      "outputs": [],
      "source": [
        "M = a*b\n",
        "print(M)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "feFg2_A4g5Dh"
      },
      "outputs": [],
      "source": [
        "M.grades()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_YjDUtmzH4co"
      },
      "source": [
        "la partie de grade $0$ de $m$ est un nombre:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JxqJ5TzUH4cp"
      },
      "outputs": [],
      "source": [
        "M(0)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wpl_i1hYH4cp"
      },
      "source": [
        "la partie de grade $2$ de $m$ est une combinaison de nouveaux objets mathématiques, des **bivecteurs**:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "i8ETm3ULH4cq"
      },
      "outputs": [],
      "source": [
        "M(2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2o3rKCLAiqU4"
      },
      "source": [
        "Le produits géométrique de deux vecteurs est la somme de leur produit scalaire (*dot* product) et de leur produit extérieur (*wedge* product)\n",
        "$$ab=a\\cdot b + a∧b$$\n",
        "En Python avec le module clifford, le produit scalaire se note $|$, le point étant déjà utilisé.\n",
        "Attention en python à la priorité des calculs:\n",
        "```Python\n",
        "a|b+a^b\n",
        "```\n",
        "ne donne pas la même chose que\n",
        "```Python\n",
        "(a|b)+(a^b)\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Ng6DqdNdy-10"
      },
      "outputs": [],
      "source": [
        "(a|b)+(a^b)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BXUgTbooihAG"
      },
      "source": [
        "Attention aux priorités de calculs:\n",
        "en Python $$a|b+a\\wedge b$$ revient à taper $$a|(b+ a \\wedge b)$$ donc il faut abuser des parenthèses."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RANTwmDcx2ib"
      },
      "outputs": [],
      "source": [
        "(a|b)+(a^b)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9n2dZtrXw_pp"
      },
      "source": [
        "### Angle entre deux plans: angle entre bivecteurs\n",
        "Essayons de déterminer l'angle entre les deux plans $P_1$ et $P_2$ mentionnés au début.\n",
        "\n",
        "Commençons par définir les bivecteurs $P_1 = e_2 \\wedge e_3$ et $P_2 = u \\wedge e_3$ avec $u = e_1 +e_2$ (remarque, on n'écrit plus les flèches au dessus des lettres, mais $e_1$, $e_2$, $e_3$ et  $u$ sont bien des vecteurs)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hHDR9nTbH4ct"
      },
      "outputs": [],
      "source": [
        "u = e1 + e2 \n",
        "P1 = e2 ^ e3\n",
        "P2 = u ^ e3 "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aCofbUoNH4cu"
      },
      "source": [
        "### Angle entre deux sous espaces A et B est:\n",
        "\n",
        "*Hitzer [arXiv:1306.1629v1]*\n",
        "\n",
        "$$\\cos \\theta _{A, B} = \\dfrac{\\langle A\\tilde B\\rangle_0}{|A||B|}$$\n",
        "\n",
        "Module d'un bivecteur\n",
        "\n",
        "$$|A|^2 = A \\tilde A$$\n",
        "\n",
        "Ici les deux sous espaces, seront les plans $P_1$ et $P_2$ définis ci-dessus. Donc:\n",
        "\n",
        "$$\\cos \\theta _{P_1, P_2} = \\dfrac{\\langle P_1\\tilde P_2\\rangle_0}{|P_1||P_2|}$$\n",
        "\n",
        "### Reverse d'un bivecteur $A$:\n",
        "\n",
        "Il se note: $$\\tilde A$$\n",
        "\n",
        "Demandons à Python de calculer $\\tilde P_2$:\n",
        "\n",
        "```Python \n",
        "~P2\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XiUC8iGQH4cu"
      },
      "outputs": [],
      "source": [
        "print(P2)\n",
        "print(~P2)\n",
        "~P2 == -P2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fUk6SBL2H4cv"
      },
      "outputs": [],
      "source": [
        "produit = P1 *(~P2)\n",
        "print(\"le produit de P1 et du reverse de P2 est:\", produit)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eX_r4TLMH4cv"
      },
      "source": [
        "Python va donner:\n",
        "```Python\n",
        "1 - (1^e12)\n",
        "```\n",
        "cela signifie $1-e_1 \\wedge e_2$ qui se note en raccourci $1-e_{12}$. Déterminons la partie de grade $0$ de $1-e_1 \\wedge e_2$ (on doit trouver $1$)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kg5e0pk4H4cw"
      },
      "outputs": [],
      "source": [
        "produit(0)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uNbaHl-0H4cx"
      },
      "source": [
        "Calculons le cosinus de l'angle entre les deux bivecteurs:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2J-2pUwNH4cx"
      },
      "outputs": [],
      "source": [
        "c = produit(0)/(abs(P1)*abs(P2))\n",
        "print(\"Le cosinus de l'angle est:\", c)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DzNHwkuhH4cx"
      },
      "source": [
        "Reste à calculer l'angle (qui sera donné en radian):"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FKdmksBwH4cx"
      },
      "outputs": [],
      "source": [
        "angle = acos(c)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xPTa5FH2H4cy"
      },
      "source": [
        "Puis à convertir cet angle en degré (si l'on souhaite), avec une petite règle de proportionalité:\n",
        "\n",
        "|radian| degré|\n",
        "|:------:|:------|\n",
        "|$\\pi$|180|\n",
        "|0.7| $0.7 \\dfrac{180}{\\pi}$|\n",
        "|    |                      |"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TAgDJok2H4cy"
      },
      "outputs": [],
      "source": [
        "angle = angle * 180/pi\n",
        "print(\"l'angle entre les deux bivecteurs représentant les plans P1 et P2 est:\", angle)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "09BVZ0XUH4cz"
      },
      "source": [
        "On retrouve bien le même résultat qu'avec la méthode vectorielle. En résumé, le code est:\n",
        "\n",
        "```Python\n",
        "from clifford.g3c import *\n",
        "from math import pi, acos\n",
        "\n",
        "u = e1 + e2 \n",
        "P1 = e2 ^ e3\n",
        "P2 = u ^ e3 \n",
        "\n",
        "produit = P1 *(~P2)\n",
        "c = produit(0)/(abs(P1)*abs(P2))\n",
        "angle = acos(c) * 180 / pi\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T-WRA9EJzDiu"
      },
      "source": [
        "**Et Voilà!**"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# En résumé\n",
        "L'algèbre géométrique de l'espace usuel à trois dimensions, manipule des  nombres, (élements de grade 0), des éléments orientés de ligne, les vecteurs (ou éléments de grade 1), des éléments orientés de plan (les bivecteurs de grade 2), des éléments orientés de volume (trivecteurs de grade 3):\n",
        "\n",
        "|grade| objet|Correspondance Géométrique|\n",
        "|:------:|:------|:------|\n",
        "|0|nombre|point|\n",
        "|1| vecteur|droite|\n",
        "|2 |bivecteur|plan|\n",
        "|3 |trivecteur|espace|\n",
        "\n",
        "Le produit géométrique *de deux vecteurs* $a$ et $b$ se décompose en produit scalaire et en produit extérieur. Dans le module **clifford**, ces trois produits s'écrivent avec les symboles suivants:\n",
        "\n",
        "|produit| notation mathématique|code Python|module python|\n",
        "|:------:|:------|:------|:------|\n",
        "|scalaire|$a \\cdot b$|$a | b$| clifford|\n",
        "|vectoriel| $a \\times b $|np.cross(a, b)| numpy (np)|\n",
        "|extérieur |$a \\wedge b $|a ^ b|clifford|\n",
        "|géométrique |$ab$|$a * b$|clifford|\n",
        "\n",
        "#Pour aller un peu plus loin:\n",
        "Le module python *clifford* ne fournit pas de produit vectoriel, ce n'est pas nécessaire. Tout ce que fait le produit vectoriel, le produit géométrique peut le faire. Si l'on souhaite absolument obtenir le vecteur normal d'un plan connaissant deux vecteurs directeurs. Construisons le nombre géométrique $I$:\n",
        "\n",
        "$$I = e_1 \\wedge e_2 \\wedge e_2 $$\n",
        "\n",
        "Dans le module clifford, on l'obtient directement avec:\n",
        "```Python\n",
        "e123\n",
        "```\n",
        "Ce nombre, comme les nombres \"habituels\" (que l'on dit réels), commute avec tous les éléments de l'algèbre, l'ordre de la multiplication ne change pas le signe du produit de la multiplication; pour cette raison, on l'apelle nombre *pseudo-scalaire*."
      ],
      "metadata": {
        "id": "1TBGw3z0xeIn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "I = e1^e2^e3"
      ],
      "metadata": {
        "id": "j4oJRNCa2PIR"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Que lui arrive-t-il lorsque on l'élève au carré?\n",
        "$$I^2$$\n",
        "Demandons à python de calculer $I^2$ pour nous:"
      ],
      "metadata": {
        "id": "sUaYat8iAZei"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "I**2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AvUPlo2z38gB",
        "outputId": "feb1975f-67ed-42f5-ebcc-18e57f4bd0a2"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-1"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "$I^2=-1$ , comme dans les nombres complexes, mais en trois dimensions!\n"
      ],
      "metadata": {
        "id": "ECm7k101A8Zu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Définissons un bivecteur et réalisons le produit géométrique avec le nombre pseudoscalaire $I$"
      ],
      "metadata": {
        "id": "1i9x93lUEOph"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Bivecteur = e1^e2"
      ],
      "metadata": {
        "id": "CClh8iGG3-56"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "I*Bivecteur"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "otyj911q4KTy",
        "outputId": "56f68492-229e-4bec-e715-341fcee9c073"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-(1^e3)"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "Bivecteur*I"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8N-ClH924vQ-",
        "outputId": "390a442d-4f2a-490d-f648-786217bad764"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-(1^e3)"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "On a vérifié précédemment que\n",
        "$$e_3= e_1 \\times e_2$$\n",
        "Si on calcule $$-Ie_1 \\wedge e_2$$\n",
        "On retrouve $e_3$, donc on vérifie que:\n",
        "$$e_1 \\times e_2 = -Ie_1 \\wedge e_2 = e_3$$\n",
        "\n",
        "$e_3$ est le dual du bivecteur $e_1 \\wedge e_2$. Multiplier géométriquement par $-I$ donne le dual."
      ],
      "metadata": {
        "id": "UVMMHBawEidi"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "-VhBhCUnGI-R"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [
        "e1WDy7OyFrRb",
        "PVEUKnYhOOZz",
        "Aef9NO6CgGwQ",
        "9n2dZtrXw_pp"
      ],
      "name": "Term_AngleDièdre-chaudronnerie.ipynb",
      "provenance": []
    },
    "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.8.6"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}