Skip to content

Instantly share code, notes, and snippets.

@jeanpat

jeanpat/TermBacPro_AngleDiedre_chaudronnerie_juplab.ipynb

Last active December 7, 2022 21:53
Show Gist options
  • Save jeanpat/3bac276c6c16e25ea819c4c8c1678e18 to your computer and use it in GitHub Desktop.
Save jeanpat/3bac276c6c16e25ea819c4c8c1678e18 to your computer and use it in GitHub Desktop.
Download ZIP
terminaleBccPro_AngleDiedre_Chaudronnerie_22Sept04.ipynb
Display the source blob
Display the rendered blob
Raw
TermBacPro_AngleDiedre_chaudronnerie_juplab.ipynb
{
"metadata": {
"colab": {
"collapsed_sections": [
"e1WDy7OyFrRb",
"PVEUKnYhOOZz",
"Aef9NO6CgGwQ",
"9n2dZtrXw_pp"
],
"provenance": [],
"include_colab_link": true
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3 (ipykernel)",
"language": "python"
},
"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_minor": 0,
"nbformat": 4,
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "view-in-github",
"colab_type": "text"
},
"source": [
"<a href=\"https://colab.research.google.com/gist/jeanpat/3bac276c6c16e25ea819c4c8c1678e18/term_angledie-dre_chaudronnerie_juplab.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
]
},
{
"cell_type": "markdown",
"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 formé 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."
],
"metadata": {
"id": "CT996wd1H4cP"
}
},
{
"cell_type": "markdown",
"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."
],
"metadata": {
"id": "uBNY0DiXDuuS",
"jp-MarkdownHeadingCollapsed": true,
"tags": []
}
},
{
"cell_type": "markdown",
"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). Dans l'ENT [monlyceeconnecte](https://jeunes.nouvelle-aquitaine.fr/formation/au-lycee/lycee-connecte-ent), l'application JupyterLab permet également d'installer des modules Python dont *clifford* et un module de visualisation *mpl_toolkit.clifford*.\n",
"\n",
"|Environnement|Installation|Définitive|\n",
"|------|------|------|\n",
"|google colab|oui|non|\n",
"|JupyterLab (ENT)|oui| x |\n",
"|Capytale|non| x |\n",
"|local|oui|oui|\n"
],
"metadata": {
"id": "7ZH53-MBEcxz"
}
},
{
"cell_type": "code",
"source": [
"#%pip install galgebra\n",
"!pip install clifford\n",
"!pip install numba -U"
],
"metadata": {
"id": "wzfy4r-mtDFb",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "9dcd1fcf-907e-48bb-b9b0-a21b194affb8",
"trusted": true
},
"execution_count": null,
"outputs": [
{
"name": "stdout",
"text": "Requirement already satisfied: clifford in /opt/conda/lib/python3.8/site-packages (1.4.0)\nRequirement already satisfied: h5py in /opt/conda/lib/python3.8/site-packages (from clifford) (3.7.0)\nRequirement already satisfied: numpy>=1.17 in /opt/conda/lib/python3.8/site-packages (from clifford) (1.23.1)\nRequirement already satisfied: scipy in /opt/conda/lib/python3.8/site-packages (from clifford) (1.9.0)\nRequirement already satisfied: numba>0.46 in /opt/conda/lib/python3.8/site-packages (from clifford) (0.56.2)\nRequirement already satisfied: sparse in /opt/conda/lib/python3.8/site-packages (from clifford) (0.13.0)\nRequirement already satisfied: importlib-metadata in /opt/conda/lib/python3.8/site-packages (from numba>0.46->clifford) (4.12.0)\nRequirement already satisfied: setuptools<60 in /opt/conda/lib/python3.8/site-packages (from numba>0.46->clifford) (49.6.0.post20201009)\nRequirement already satisfied: llvmlite<0.40,>=0.39.0dev0 in /opt/conda/lib/python3.8/site-packages (from numba>0.46->clifford) (0.39.1)\nRequirement already satisfied: zipp>=0.5 in /opt/conda/lib/python3.8/site-packages (from importlib-metadata->numba>0.46->clifford) (3.4.0)\nRequirement already satisfied: numba in /opt/conda/lib/python3.8/site-packages (0.56.2)\nRequirement already satisfied: setuptools<60 in /opt/conda/lib/python3.8/site-packages (from numba) (49.6.0.post20201009)\nRequirement already satisfied: importlib-metadata in /opt/conda/lib/python3.8/site-packages (from numba) (4.12.0)\nRequirement already satisfied: llvmlite<0.40,>=0.39.0dev0 in /opt/conda/lib/python3.8/site-packages (from numba) (0.39.1)\nRequirement already satisfied: numpy<1.24,>=1.18 in /opt/conda/lib/python3.8/site-packages (from numba) (1.23.1)\nRequirement already satisfied: zipp>=0.5 in /opt/conda/lib/python3.8/site-packages (from importlib-metadata->numba) (3.4.0)\n",
"output_type": "stream"
}
]
},
{
"cell_type": "markdown",
"source": [
"Dans l'application jupyterlab de l'ENT seule l'option **--user** permet d'installer le module *mpl_toolkits.clifford*:"
],
"metadata": {
"id": "RT5sBu9Ij2sl"
}
},
{
"cell_type": "code",
"source": [
"!pip install mpl_toolkits.clifford --user"
],
"metadata": {
"id": "pbhp1Aiaoyr6",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 575
},
"outputId": "50ec780a-1ec0-47c5-a89b-3b33e0a69c23",
"trusted": true
},
"execution_count": null,
"outputs": [
{
"name": "stdout",
"text": "Requirement already satisfied: mpl_toolkits.clifford in /home/jovyan/.local/lib/python3.8/site-packages (0.0.3)\nRequirement already satisfied: clifford in /opt/conda/lib/python3.8/site-packages (from mpl_toolkits.clifford) (1.4.0)\nRequirement already satisfied: trimesh in /opt/conda/lib/python3.8/site-packages (from mpl_toolkits.clifford) (3.14.1)\nRequirement already satisfied: matplotlib in /opt/conda/lib/python3.8/site-packages (from mpl_toolkits.clifford) (3.5.3)\nRequirement already satisfied: numba>0.46 in /opt/conda/lib/python3.8/site-packages (from clifford->mpl_toolkits.clifford) (0.56.2)\nRequirement already satisfied: scipy in /opt/conda/lib/python3.8/site-packages (from clifford->mpl_toolkits.clifford) (1.9.0)\nRequirement already satisfied: sparse in /opt/conda/lib/python3.8/site-packages (from clifford->mpl_toolkits.clifford) (0.13.0)\nRequirement already satisfied: numpy>=1.17 in /opt/conda/lib/python3.8/site-packages (from clifford->mpl_toolkits.clifford) (1.23.1)\nRequirement already satisfied: h5py in /opt/conda/lib/python3.8/site-packages (from clifford->mpl_toolkits.clifford) (3.7.0)\nRequirement already satisfied: cycler>=0.10 in /opt/conda/lib/python3.8/site-packages (from matplotlib->mpl_toolkits.clifford) (0.11.0)\nRequirement already satisfied: fonttools>=4.22.0 in /opt/conda/lib/python3.8/site-packages (from matplotlib->mpl_toolkits.clifford) (4.34.4)\nRequirement already satisfied: python-dateutil>=2.7 in /opt/conda/lib/python3.8/site-packages (from matplotlib->mpl_toolkits.clifford) (2.8.2)\nRequirement already satisfied: kiwisolver>=1.0.1 in /opt/conda/lib/python3.8/site-packages (from matplotlib->mpl_toolkits.clifford) (1.4.4)\nRequirement already satisfied: pyparsing>=2.2.1 in /opt/conda/lib/python3.8/site-packages (from matplotlib->mpl_toolkits.clifford) (2.4.7)\nRequirement already satisfied: packaging>=20.0 in /opt/conda/lib/python3.8/site-packages (from matplotlib->mpl_toolkits.clifford) (20.4)\nRequirement already satisfied: pillow>=6.2.0 in /opt/conda/lib/python3.8/site-packages (from matplotlib->mpl_toolkits.clifford) (9.2.0)\nRequirement already satisfied: setuptools<60 in /opt/conda/lib/python3.8/site-packages (from numba>0.46->clifford->mpl_toolkits.clifford) (49.6.0.post20201009)\nRequirement already satisfied: importlib-metadata in /opt/conda/lib/python3.8/site-packages (from numba>0.46->clifford->mpl_toolkits.clifford) (4.12.0)\nRequirement already satisfied: llvmlite<0.40,>=0.39.0dev0 in /opt/conda/lib/python3.8/site-packages (from numba>0.46->clifford->mpl_toolkits.clifford) (0.39.1)\nRequirement already satisfied: six in /opt/conda/lib/python3.8/site-packages (from packaging>=20.0->matplotlib->mpl_toolkits.clifford) (1.15.0)\nRequirement already satisfied: zipp>=0.5 in /opt/conda/lib/python3.8/site-packages (from importlib-metadata->numba>0.46->clifford->mpl_toolkits.clifford) (3.4.0)\n",
"output_type": "stream"
}
]
},
{
"cell_type": "markdown",
"source": [
"Sur jupyterlab (pas Capytale), ne pas oublier de changer de Kernel : aller dans le menu Kernel/change Kernel puis choisir le noyau correspondant au nom de ce notebook.\n",
"pyganja est un autre module de visualisation qui supporte les objet de l'algèbre de clifford:"
],
"metadata": {
"id": "308fX_GJigTr"
}
},
{
"cell_type": "code",
"source": [
"#!pip install git+https://github.com/pygae/pyganja.git --user"
],
"metadata": {
"id": "49kLnhFglgEM"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"## Importation des modules:\n",
"Commençons par les modules:\n",
" * numpy\n",
" * matplotlib"
],
"metadata": {
"id": "e1WDy7OyFrRb"
}
},
{
"cell_type": "code",
"source": [
"import numpy as np\n",
"from matplotlib import pyplot as plt"
],
"metadata": {
"id": "8hrI10cCD4Ma",
"trusted": true
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"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"
],
"metadata": {
"id": "HqS2iToEtgcr"
}
},
{
"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",
"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"
],
"metadata": {
"id": "bAsgAl2Ltd6_",
"outputId": "7d70d927-dbae-40de-e2f7-7951f6b60bef",
"trusted": true
},
"execution_count": null,
"outputs": [
{
"execution_count": 2,
"output_type": "execute_result",
"data": {
"text/plain": "45.00000000000001"
},
"metadata": {}
}
]
},
{
"cell_type": "markdown",
"source": [
"## Algèbre Géométrique ou algèbre de Clifford:\n",
"\n",
"### Un peu d'histoire:\n",
"Jusque il y a peu, en cours de mathématiques, 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 aux 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",
"\n",
"Dans l'algèbre géométrique, on peut additionner les choux et las carottes et plus. On peut additionner un nombre et un vecteur et même plus, par exemple:\n",
"\n",
"$$M = 1 + \\underbrace{e_1+e_2+e_3}_{vecteurs} + \\underbrace{e_{12}+e_{23}+e_{13}}_{bivecteurs}+\\underbrace{e_{123}}_{trivecteur}$$\n",
"\n",
"On a simplifié l'écriture:\n",
"\n",
" * $e_{12}$ représente un bivecteur qui se note également avec le produit géométrique $e_1e_2$\n",
" * $e_{123}$ représente le trivecteur de l'espace à trois dimensions, qui se note également avec le produit géométrique $e_1e_2e_3$. Ce nombre géométrique particulier est appelé le pseudo-scalaire, on l'écrit souvent ***I***:\n",
" $$I=e_{123}$$"
],
"metadata": {
"id": "uo0TmD-hgBmV"
}
},
{
"cell_type": "markdown",
"source": [
"### Le module python *clifford*\n",
"Commençons par jouer avec ses é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": "4JUMObwtigT5"
}
},
{
"cell_type": "code",
"source": [
"import mpl_toolkits.clifford\n",
"from clifford.g3c import *\n",
"from math import pi, acos\n",
"from decimal import Decimal"
],
"metadata": {
"id": "hkyIrY7QH4cl",
"trusted": true
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"On commence par créer deux vecteurs $a$ et $b$:"
],
"metadata": {
"id": "9JU7SF4QH4cm"
}
},
{
"cell_type": "code",
"source": [
"a = 3*e1 + e2 + 2*e3\n",
"b = e1 - e2 + e3"
],
"metadata": {
"id": "l1ZPJmz5xo2N",
"trusted": true
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"### Une nouvelle multiplication: le produit géométrique:\n",
"Calculons le 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."
],
"metadata": {
"id": "Aef9NO6CgGwQ",
"tags": []
}
},
{
"cell_type": "code",
"source": [
"M = a*b\n",
"print(M)"
],
"metadata": {
"id": "OesNYNPZgNqF",
"trusted": true,
"outputId": "7152762d-62f4-4781-eceb-f98254da1b25"
},
"execution_count": null,
"outputs": [
{
"name": "stdout",
"text": "4 - (4^e12) + (1^e13) + (3^e23)\n",
"output_type": "stream"
}
]
},
{
"cell_type": "code",
"source": [
"M.grades()"
],
"metadata": {
"id": "feFg2_A4g5Dh",
"trusted": true,
"outputId": "757049d7-2e28-4684-8655-127a55a0c579"
},
"execution_count": null,
"outputs": [
{
"execution_count": 6,
"output_type": "execute_result",
"data": {
"text/plain": "{0, 2}"
},
"metadata": {}
}
]
},
{
"cell_type": "markdown",
"source": [
"la partie de grade $0$ de $m$ est un nombre:"
],
"metadata": {
"id": "_YjDUtmzH4co"
}
},
{
"cell_type": "code",
"source": [
"M(0)"
],
"metadata": {
"id": "JxqJ5TzUH4cp",
"trusted": true,
"outputId": "47fe29d8-6e90-4fe3-d4fe-fe5c61638367"
},
"execution_count": null,
"outputs": [
{
"execution_count": 7,
"output_type": "execute_result",
"data": {
"text/plain": "4"
},
"metadata": {}
}
]
},
{
"cell_type": "markdown",
"source": [
"la partie de grade $2$ de $m$ est une combinaison de nouveaux objets mathématiques, des **bivecteurs**:"
],
"metadata": {
"id": "Wpl_i1hYH4cp"
}
},
{
"cell_type": "code",
"source": [
"M(2)"
],
"metadata": {
"id": "i8ETm3ULH4cq",
"trusted": true,
"outputId": "61303ab5-54a0-4d0e-8dd5-9ea414f35d9d"
},
"execution_count": null,
"outputs": [
{
"execution_count": 8,
"output_type": "execute_result",
"data": {
"text/plain": "-(4^e12) + (1^e13) + (3^e23)"
},
"metadata": {}
}
]
},
{
"cell_type": "markdown",
"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",
"```"
],
"metadata": {
"id": "2o3rKCLAiqU4"
}
},
{
"cell_type": "code",
"source": [
"print(\"sans parenthèse:\", a|b+a^b )\n",
"print(\"avec parenthèses:\", (a|b)+(a^b) ) "
],
"metadata": {
"id": "Ng6DqdNdy-10",
"trusted": true,
"outputId": "97e94d63-fb03-44c4-e8ae-b842effcd658"
},
"execution_count": null,
"outputs": [
{
"name": "stdout",
"text": "sans parenthèse: (2^e1) - (18^e2) + (6^e3)\navec parenthèses: 4 - (4^e12) + (1^e13) + (3^e23)\n",
"output_type": "stream"
}
]
},
{
"cell_type": "markdown",
"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."
],
"metadata": {
"id": "BXUgTbooihAG"
}
},
{
"cell_type": "markdown",
"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)."
],
"metadata": {
"id": "9n2dZtrXw_pp"
}
},
{
"cell_type": "code",
"source": [
"u = e1 + e2 \n",
"P1 = e2 ^ e3\n",
"P2 = u ^ e3 "
],
"metadata": {
"id": "hHDR9nTbH4ct",
"trusted": true
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"### Angle entre deux sous espaces A et B est:\n",
"\n",
"*Hitzer [arXiv:1306.1629v1](https://arxiv.org/abs/1306.1629)* donne une relation pour calculer l'angle entre deux sous espaces. Ici les deux plans sont des sous-espaces de l'esapce à trois dimensions. Pensons à une fourmi marchant sur une table, elle ne peut se déplacer que dans un espace à deux dimensions. Une mouche, quant à elle, est capable de se déplacer en marchant sur la table et dans l'espace à trois dimensions en s'envolant.\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",
"```"
],
"metadata": {
"id": "aCofbUoNH4cu"
}
},
{
"cell_type": "code",
"source": [
"print(P2)\n",
"print(~P2)\n",
"~P2 == -P2"
],
"metadata": {
"id": "XiUC8iGQH4cu"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"produit = P1 *(~P2)\n",
"print(\"le produit de P1 et du reverse de P2 est:\", produit)"
],
"metadata": {
"id": "fUk6SBL2H4cv"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"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$)."
],
"metadata": {
"id": "eX_r4TLMH4cv"
}
},
{
"cell_type": "code",
"source": [
"produit(0)"
],
"metadata": {
"id": "kg5e0pk4H4cw"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"Calculons le cosinus de l'angle entre les deux bivecteurs:"
],
"metadata": {
"id": "uNbaHl-0H4cx"
}
},
{
"cell_type": "code",
"source": [
"c = produit(0)/(abs(P1)*abs(P2))\n",
"print(\"Le cosinus de l'angle est:\", c)"
],
"metadata": {
"id": "2J-2pUwNH4cx"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"Reste à calculer l'angle (qui sera donné en radian):"
],
"metadata": {
"id": "DzNHwkuhH4cx"
}
},
{
"cell_type": "code",
"source": [
"angle = acos(c)"
],
"metadata": {
"id": "FKdmksBwH4cx"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"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",
"| | |"
],
"metadata": {
"id": "xPTa5FH2H4cy"
}
},
{
"cell_type": "code",
"source": [
"angle = angle * 180/pi\n",
"print(\"l'angle entre les deux bivecteurs représentant les plans P1 et P2 est:\", angle)"
],
"metadata": {
"id": "TAgDJok2H4cy"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"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",
"```"
],
"metadata": {
"id": "09BVZ0XUH4cz"
}
},
{
"cell_type": "markdown",
"source": [
"**Et Voilà!**"
],
"metadata": {
"id": "T-WRA9EJzDiu"
}
},
{
"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. Le module **numpy** fournit le produit vectoriel. Avec le module **clifford**, les produits, scalaire, extérieur et géométrique, 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|"
],
"metadata": {
"id": "1TBGw3z0xeIn"
}
},
{
"cell_type": "markdown",
"source": [
"# 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": "p3FkNYxkigUJ"
}
},
{
"cell_type": "code",
"source": [
"I = e1^e2^e3"
],
"metadata": {
"id": "j4oJRNCa2PIR"
},
"execution_count": null,
"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": null,
"outputs": [
{
"output_type": "execute_result",
"execution_count": 6,
"data": {
"text/plain": [
"-1"
]
},
"metadata": {}
}
]
},
{
"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": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"I*Bivecteur"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "otyj911q4KTy",
"outputId": "56f68492-229e-4bec-e715-341fcee9c073"
},
"execution_count": null,
"outputs": [
{
"output_type": "execute_result",
"execution_count": 22,
"data": {
"text/plain": [
"-(1^e3)"
]
},
"metadata": {}
}
]
},
{
"cell_type": "code",
"source": [
"Bivecteur*I"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "8N-ClH924vQ-",
"outputId": "390a442d-4f2a-490d-f648-786217bad764"
},
"execution_count": null,
"outputs": [
{
"output_type": "execute_result",
"execution_count": 21,
"data": {
"text/plain": [
"-(1^e3)"
]
},
"metadata": {}
}
]
},
{
"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": "markdown",
"source": [
"# Exercice\n",
"\n",
"On a quatre points $O(0,0,0)$, $A(2, 0, 0)$, $B(2, 1, 3)$ et $C(-1,3,4)$\n",
"\n",
"Compléter le code Python pour calculer les coordonnées des vecteurs:\n",
"\n",
" * $\\vec{u}= \\vec{OA}$\n",
" * $\\vec{v}= \\vec{OB}$\n",
" * $\\vec{w}= \\vec{OC}$"
],
"metadata": {
"id": "hHGgLFteigUP"
}
},
{
"cell_type": "code",
"source": [
"u = ( (2^e1) + (0^e2) + (0^e3) ) - ( (0^e1) + (0^e2) + (0^e3) )\n",
"\n",
"print(\"les coordonnées du vecteur u sont:\", u)\n"
],
"metadata": {
"trusted": true,
"id": "JG1dmUe8igUP",
"outputId": "f6f818ff-5061-4fff-854b-a6d39831bd50"
},
"execution_count": null,
"outputs": [
{
"name": "stdout",
"text": "les coordonnées du vecteur u sont: (2^e1)\n",
"output_type": "stream"
}
]
},
{
"cell_type": "code",
"source": [
"v = ( (2^e1) + (1^e2) + (3^e3) ) - ( (0^e1) + (0^e2) + (0^e3) )\n",
"v"
],
"metadata": {
"trusted": true,
"id": "JD7hh_UEigUP",
"outputId": "9b5c67cf-cd7a-415b-e1c0-dd1ded3fe5d2"
},
"execution_count": null,
"outputs": [
{
"execution_count": 15,
"output_type": "execute_result",
"data": {
"text/plain": "(2^e1) + (1^e2) + (3^e3)"
},
"metadata": {}
}
]
},
{
"cell_type": "code",
"source": [
"w = ( (-1^e1) + (3^e2) + (4^e3) ) - ( (0^e1) + (0^e2) + (0^e3) )\n",
"w"
],
"metadata": {
"trusted": true,
"id": "WsG7L64-igUQ",
"outputId": "7dcabfb0-c300-4dc4-e4fa-959cc2ef9b58"
},
"execution_count": null,
"outputs": [
{
"execution_count": 20,
"output_type": "execute_result",
"data": {
"text/plain": "-(1^e1) + (3^e2) + (4^e3)"
},
"metadata": {}
}
]
},
{
"cell_type": "markdown",
"source": [
"Ecrire le code Python pour calculer les bivecteurs suivants. Pour les enseignants les réponses sont proposées:\n",
"\n",
" * $B_1 = \\vec{u} \\wedge \\vec{v}$\n",
" * $B_2 = \\vec{u} \\wedge \\vec{w}$ "
],
"metadata": {
"id": "N6CfhgsligUQ"
}
},
{
"cell_type": "code",
"source": [
"B1 = (u) ^ (v)\n",
"B1"
],
"metadata": {
"trusted": true,
"id": "AbVoAB7higUS",
"outputId": "76b104d2-f00c-47e4-8dba-fa7ca52dd307"
},
"execution_count": null,
"outputs": [
{
"execution_count": 39,
"output_type": "execute_result",
"data": {
"text/plain": "(2^e12) + (6^e13)"
},
"metadata": {}
}
]
},
{
"cell_type": "code",
"source": [
"B2 = (u) ^ (w)\n",
"B2"
],
"metadata": {
"trusted": true,
"id": "pP3ICIu8igUS",
"outputId": "2f7cbeed-f408-4a1d-b5bf-62f975f86887"
},
"execution_count": null,
"outputs": [
{
"execution_count": 40,
"output_type": "execute_result",
"data": {
"text/plain": "(6^e12) + (8^e13)"
},
"metadata": {}
}
]
},
{
"cell_type": "markdown",
"source": [
"Nous allons calculer maintenant un vecteur normal pour chacun des deux bivecteurs $B_1$ et $B_2$ en utilisant "
],
"metadata": {
"id": "OWrevFHzigUT"
}
},
{
"cell_type": "code",
"source": [
"I = e123\n",
"n1 = -I*B1\n",
"n1/abs(n1)"
],
"metadata": {
"trusted": true,
"id": "PJiADGD8igUT",
"outputId": "be706389-e86c-44b9-e0fb-3b4d1c4c81d8"
},
"execution_count": null,
"outputs": [
{
"execution_count": 45,
"output_type": "execute_result",
"data": {
"text/plain": "-(0.94868^e2) + (0.31623^e3)"
},
"metadata": {}
}
]
},
{
"cell_type": "code",
"source": [
"n2 = -I * B2\n",
"n2/abs(n2)"
],
"metadata": {
"trusted": true,
"id": "_k2KfhtqigUT",
"outputId": "54caee2c-dc06-4373-fe28-801dbf618408"
},
"execution_count": null,
"outputs": [
{
"execution_count": 44,
"output_type": "execute_result",
"data": {
"text/plain": "-(0.8^e2) + (0.6^e3)"
},
"metadata": {}
}
]
},
{
"cell_type": "code",
"source": [
"ps = n1 | n2\n",
"print(\"Le produit scalaire\")\n",
"c = ps/(abs(n1) * abs(n2))"
],
"metadata": {
"trusted": true,
"id": "NeEcY6f8igUU"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"angle = (180/pi)*acos(c)\n",
"angle"
],
"metadata": {
"trusted": true,
"id": "3-ZsOWTtigUU",
"outputId": "22b2a776-7e1e-4a83-ce87-85f2a09cdd83"
},
"execution_count": null,
"outputs": [
{
"execution_count": 50,
"output_type": "execute_result",
"data": {
"text/plain": "18.434948822922017"
},
"metadata": {}
}
]
},
{
"cell_type": "markdown",
"source": [
"## Résumons: On utilise l'angle entre les vecteurs normaux, duals des bivecteurs:"
],
"metadata": {
"id": "qfGF9FlRigUW"
}
},
{
"cell_type": "code",
"source": [
"I = e123\n",
"\n",
"u = 2*e1\n",
"v = (2*e1) + (1*e2) + (3*e3)\n",
"w = -(1*e1) + (3*e2) + (4*e3)\n",
"\n",
"B1 = (u) ^ (v)\n",
"B2 = (u) ^ (w)\n",
"\n",
"#Dual du bivecteur à la place du produit vectoriel\n",
"n1 = -I * B1\n",
"n2 = -I * B2\n",
"\n",
"#produit scalaire entre les vecteur normaux\n",
"ps = n1 | n2\n",
"print(\"produit scalaire des normaux\", ps)\n",
"\n",
"c = ps/(abs(n1) * abs(n2))\n",
"angle = (180/pi)*acos(c)\n",
"angle"
],
"metadata": {
"trusted": true,
"id": "ghV2ngbTigUW",
"outputId": "9d168344-6315-44b9-8d32-0e4d1b0a700c"
},
"execution_count": null,
"outputs": [
{
"name": "stdout",
"text": "produit scalaire des normaux 135\n",
"output_type": "stream"
},
{
"execution_count": 64,
"output_type": "execute_result",
"data": {
"text/plain": "18.434948822922017"
},
"metadata": {}
}
]
},
{
"cell_type": "markdown",
"source": [
"## Revérifions avec une méthode utilisant seulement les bivecteurs et le produit géométrique:\n",
"\n",
"On remarquera que la partie de grade $0$ du produit géométrique $B_1 \\tilde{ B_2}$ est égale au produit scalaire des vecteurs normaux"
],
"metadata": {
"id": "G8bsobv3igUX"
}
},
{
"cell_type": "code",
"source": [
"u = 2*e1\n",
"v = (2*e1) + (1*e2) + (3*e3)\n",
"w = -(1*e1) + (3*e2) + (4*e3)\n",
"\n",
"B1 = u ^ v\n",
"B2 = u ^ w \n",
"\n",
"produit = B1 *(~B2)\n",
"print(\"produit géométrique de B1 et du reverse de B2:\", produit)\n",
"c = produit(0)/(abs(B1)*abs(B2))\n",
"angle = acos(c) * 180 / pi\n",
"print(\"angle entre les deux plans def par un bivecteur:\",angle )"
],
"metadata": {
"trusted": true,
"id": "ooM8vIkRigUX",
"outputId": "9225485a-b4a9-4479-8b37-1972519ec511"
},
"execution_count": null,
"outputs": [
{
"name": "stdout",
"text": "produit géométrique de B1 et du reverse de B2: 135 - (45^e23)\nangle entre les deux plans def par un bivecteur: 18.434948822922017\n",
"output_type": "stream"
}
]
},
{
"cell_type": "markdown",
"source": [
"## Vérifions avec une méthode purement vectorielle (pas de bivecteur)"
],
"metadata": {
"id": "wg7gKnWbigUX"
}
},
{
"cell_type": "code",
"source": [
"#--------------------CALCUL DE L'ANGLE DIEDRE ENTRE DEUX PLANS DE L'ESPACE ---------------------------------\n",
"#𝑂(0,0,0), 𝐴(2,0,0), 𝐵(2,1,3) et 𝐶(−1,3,4)\n",
"#\n",
"# Les vecteurs u et v sont les vecteurs directeurs du plan P_1\n",
"# les vecteurs u et w sont les vecteurs directeurs du plan P_2\n",
"#\n",
"u = np.array([2,0,0])-np.array([0,0,0])\n",
"v = np.array([2,1,3])-np.array([0,0,0])\n",
"w = np.array([-1,3,4])-np.array([0,0,0])\n",
"\n",
"\n",
"#\n",
"# On calcule des vecteurs normaux de chacun des plans \n",
"#\n",
"n1 = np.cross(u, v)\n",
"n2 = np.cross(u, w)\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(n2))\n",
"\n",
"angle = np.arccos(c)\n",
"angle = angle * 180/np.pi\n",
"angle"
],
"metadata": {
"outputId": "7d70d927-dbae-40de-e2f7-7951f6b60bef",
"trusted": true,
"id": "wUg5VfjaigUY"
},
"execution_count": null,
"outputs": [
{
"execution_count": 53,
"output_type": "execute_result",
"data": {
"text/plain": "18.434948822922017"
},
"metadata": {}
}
]
},
{
"cell_type": "code",
"source": [],
"metadata": {
"id": "0Ps3op-pigUZ"
},
"execution_count": null,
"outputs": []
}
]
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment