704_gleichungeLoesen.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gleichungen lösen mit Sympy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die verwendeten Variablen müssen als *symbols* deklariert werden. Das Gleichheitszeichen wird durch die *Eq*-Funktion ersetzt. Für quadratische Gleichungen und Betragsgleichungen nehmen wir die Funktion *solve*, für lineare Gleichungssysteme nehmen wir *linsolve*. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Import und Symbole setzen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import symbols, Eq, solve, Rational\n",
    "x = symbols(\"x\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Einfache Gleichungen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Löse die Gleichung $\\frac{3}{4}x + 2 = 0.75x$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.615384615384615]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e = Eq(3/4*x + 2, 4*x)\n",
    "solve(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wenn wir die Brüche beibehalten wollen, müssen wir mit **Rational**-Objekten arbeiten. Verschiedene Möglichkeiten, Rational-Objekte zu erzeugen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3/4 3/4 3/4\n"
     ]
    }
   ],
   "source": [
    "a = Rational(3,4)\n",
    "b = Rational(3/4)\n",
    "c = Rational('3/4')\n",
    "print(a,b,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8/13]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e = Eq(Rational(3,4)*x + 2, 4*x)\n",
    "solve(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ist eine Gleichung immer richtig ist, wertet sie sich zu True aus. Auch die Funktion solve liefert dann True.\n",
    "Ist eine Gleichung immer falsch, wertet sie sich zu False aus.  Auch die Funktion solve liefert dann False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True True True\n",
      "False False\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(True, False, True, Eq(x, 2))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(Eq(1,1), Eq(x,x), Eq(0*x,0))\n",
    "print(Eq(1,2), Eq(0*x,4))\n",
    "\n",
    "solve(Eq(1,1)), solve(Eq(0*x,4)), Eq(1,1), Eq(x,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Quadratische Gleichungen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zwei Lösungen:\n",
      "[-sqrt(7)/7, sqrt(7)/7]\n",
      "\n",
      "Eine Lösung:\n",
      "[0]\n",
      "\n",
      "Keine Lösung:\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print('Zwei Lösungen:')\n",
    "z = solve(Eq(14*x*x + 7 ,9))\n",
    "print(z)\n",
    "\n",
    "print('\\nEine Lösung:')\n",
    "z = solve(Eq(x*x + 7 ,7))\n",
    "print(z)\n",
    "\n",
    "print(('\\nKeine Lösung:'))\n",
    "z = solve(Eq(x*x + 7 ,0))\n",
    "print(z)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Betragsgleichungen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zwei Lösungen:\n",
      "[-1, 5]\n",
      "\n",
      "Eine Lösung:\n",
      "[2]\n",
      "\n",
      "Keine Lösung:\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print('Zwei Lösungen:')\n",
    "z = solve(Eq(abs(x-2) ,3))\n",
    "print(z)\n",
    "\n",
    "print('\\nEine Lösung:')\n",
    "z = solve(Eq(abs(x-2) ,0))\n",
    "print(z)\n",
    "\n",
    "print(('\\nKeine Lösung:'))\n",
    "z = solve(Eq(abs(x-2) ,-1))\n",
    "print(z)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lineare Gleichungssystem\n",
    "*linsolve* gibt eine Menge zurück. In unserem Fällen enthält diese Menge immer nur ein Tupel. Dies können wir durch *sequence unpacking* direkt\n",
    "in eine Variable speichern: *erg, = ...*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Eine Lösung:\n",
      "(-2, 1, 5)\n",
      "\n",
      "EmptySet()\n",
      "Keine Lösung\n",
      "\n",
      "Unendlich viele Lösungen\n",
      "(5*z/2 + 6, z + 6, z)\n"
     ]
    }
   ],
   "source": [
    "print('\\nEine Lösung:')\n",
    "equations = [\n",
    "    Eq(2*x,-4),\n",
    "    Eq(3*x+y,-5),\n",
    "    Eq(-y+z,4)\n",
    "]\n",
    "erg, = linsolve(equations,x,y,z)   # sequence unpacking\n",
    "print(erg)\n",
    "\n",
    "equations = [\n",
    "    Eq(x+3*y-2*z,0),\n",
    "    Eq(2*x-4*y+z,-3),\n",
    "    Eq(4*x-8*y+2*z,-5)\n",
    "]\n",
    "\n",
    "print()\n",
    "erg = linsolve(equations,x,y,z)    # hier führt das sequence unpacking zu einem Fehler, da erg leer\n",
    "print(erg)\n",
    "if not erg:\n",
    "    print('Keine Lösung')\n",
    "\n",
    "print(\"\\nUnendlich viele Lösungen\")\n",
    "equations = [\n",
    "    Eq(-2*x+y+4*z,-6),\n",
    "    Eq(2*x-2*y-3*z,0),\n",
    "    Eq(-4*x+3*y+7*z,-6)\n",
    "]\n",
    "erg, = linsolve(equations,x,y,z)    # hier führt das sequence unpacking zu einem Fehler, da erg leer\n",
    "print(erg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Achtung**: wenn eine der drei Gleichungen sich selbst schon zu True oder False auswertet, weil sie entweder immer wahr oder nicht erfüllbar sind, bekommt man bei dem Ansatz oben einen Fehler. Diesen Fall muss man ggf. vorher abfangen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# erzeugt Fehler \n",
    "equations = [\n",
    "    Eq(x,x),\n",
    "    Eq(y,1),\n",
    "    Eq(z,2)\n",
    "]\n",
    "erg = linsolve(equations,x,y,z)\n",
    "print(erg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# erzeugt Fehler \n",
    "equations = [\n",
    "    Eq(0*x,1),\n",
    "    Eq(y,1),\n",
    "    Eq(z,2)\n",
    "]\n",
    "erg = linsolve(equations,x,y,z)\n",
    "print(erg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funktionen für die Vektorgeometrie"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Parallelität und Orthogonalität zweier Vektoren"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 4)\n",
      "(0, 'nicht parallel')\n",
      "(1, 2)\n"
     ]
    }
   ],
   "source": [
    "def parallel(x1,x2,x3,y1,y2,y3):\n",
    "    '''\n",
    "    returns Tupel (f,k)\n",
    "    f = 0: nicht parallel\n",
    "    f = 1: parallel mit x * k = y\n",
    "    '''\n",
    "    equations = [\n",
    "        Eq(x1 * k, y1),\n",
    "        Eq(x2 * k, y2),\n",
    "        Eq(x3 * k, y3)\n",
    "    ]\n",
    "    \n",
    "    if not linsolve(equations,k) :\n",
    "        return (0,'nicht parallel')\n",
    "    else:\n",
    "        erg, = linsolve(equations,k) \n",
    "        return (1,erg[0])\n",
    "\n",
    "def orthogonal(x1,x2,x3,y1,y2,y3):\n",
    "    return math.isclose(x1*y1+x2*y2+x3*y3,0)\n",
    "    \n",
    "print(parallel(2,3,1,8,12,4))    \n",
    "print(parallel(1,4,3,2,3,-1))\n",
    "print(parallel(1,4,3,2,8,6))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Liegt Punkt auf Gerade?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 3)\n",
      "(0, 'nicht auf Gerade')\n"
     ]
    }
   ],
   "source": [
    "def punktAufGerade(s1,s2,s3,r1,r2,r3,p1,p2,p3):\n",
    "    '''\n",
    "    s - Stützvektor, r - Richtungsvektor, p - Punkt\n",
    "    returns: (0,.) wenn p nicht auf Gerade\n",
    "             (1,k) wenn p = s + k * r\n",
    "    '''\n",
    "    equations = [\n",
    "        Eq(s1 + r1 * k, p1),\n",
    "        Eq(s2 + r2 * k, p2),\n",
    "        Eq(s3 + r3 * k, p3),\n",
    "    ]\n",
    "    if not linsolve(equations,k) :\n",
    "        return (0,'nicht auf Gerade')\n",
    "    else:\n",
    "        erg, = linsolve(equations,k) \n",
    "        return (1,erg[0])\n",
    "    \n",
    "print(punktAufGerade(1,0,1,1,2,-2,4,6,-5))    \n",
    "print(punktAufGerade(1,0,1,1,2,-2,4,6,-6))  \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lage zweier Geraden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, (0, 6, 5))\n",
      "(0, 'windschief')\n",
      "(2, 'parallel')\n",
      "(3, 'identisch')\n"
     ]
    }
   ],
   "source": [
    "def lageZweierGeraden(s1,s2,s3,r1,r2,r3,s4,s5,s6,r4,r5,r6):\n",
    "    '''\n",
    "    g1 = s + k * r,   g2 = s' + k * r'\n",
    "    returns:\n",
    "       (0,.) wenn windschief\n",
    "       (1,(p1,p2,p3)), wenn Schnittpunkt p\n",
    "       (2,.) wenn parallel\n",
    "       (3,.) wenn identisch\n",
    "    '''\n",
    "    \n",
    "    if parallel(r1,r2,r3,r4,r5,r6)[0] == 1:\n",
    "        if punktAufGerade(s1,s2,s3,r1,r2,r3,s4,s5,s6)[0] == 1:\n",
    "            return (3,'identisch')     \n",
    "        else: return (2,'parallel')   \n",
    "    else:\n",
    "        equations = [\n",
    "            Eq(s1 + r1 * k, s4 + r4 * t),\n",
    "            Eq(s2 + r2 * k, s5 + r5 * t),\n",
    "            Eq(s3 + r3 * k, s6 + r6 * t),\n",
    "        ]\n",
    "        if not linsolve(equations,k,t) :\n",
    "            return (0,\"windschief\")     \n",
    "        else:\n",
    "            erg, = linsolve(equations,k,t) \n",
    "            n = erg[0]\n",
    "            \n",
    "            return (1,(s1 + r1 * n, s2 + r2 * n, s3 + r3 * n))\n",
    "        \n",
    "        \n",
    "print(lageZweierGeraden(-1,2,2,1,4,3,0,6,5,2,3,-1))   \n",
    "print(lageZweierGeraden(-1,2,2,1,4,3,1,2,5,2,3,-1))\n",
    "print(lageZweierGeraden(-1,2,2,1,4,3,-1,6,5,2,8,6))\n",
    "print(lageZweierGeraden(-1,2,2,1,4,3,0,6,5,2,8,6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lage Ebene und Gerade"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'Gerade parallel zur Ebene')\n",
      "(2, 'Gerade in Ebene')\n",
      "(1, (1, 1, 1))\n"
     ]
    }
   ],
   "source": [
    "def lageEbeneGerade(a,b,c,d,s1,s2,s3,r1,r2,r3):\n",
    "    '''\n",
    "    E in Koordinatenform mit Koeffizienten a,b,c,d\n",
    "    g = s + k* r\n",
    "    returns:\n",
    "        (0,.)  wenn g parallel zu E\n",
    "        (1,(p1,p2,p3))  wenn p Schnittpunkt\n",
    "        (2,.)  wenn g in E\n",
    "    '''\n",
    "    if orthogonal(a,b,c,r1,r2,r3):\n",
    "        if math.isclose(a*s1+b*s2+c*s3,d):\n",
    "            return (2,'Gerade in Ebene')\n",
    "        else:\n",
    "            return (0,'Gerade parallel zur Ebene')\n",
    "    else:\n",
    "        equations = [Eq(a*(s1 + k * r1) + b*(s2 + k * r2) + c*(s3 + k * r3),d)]\n",
    "        erg, = linsolve(equations,k) \n",
    "        n = erg[0]\n",
    "        p = (s1+n*r1,s2+n*r2,s3+n*r3)\n",
    "        return (1,p)\n",
    "        \n",
    "print(lageEbeneGerade(2,3,-1,4,3,2,1,1,-1,-1))\n",
    "print(lageEbeneGerade(2,3,-1,4,1,1,1,1,-1,-1))\n",
    "print(lageEbeneGerade(2,3,-1,4,3,2,1,2,1,0))\n",
    "\n",
    "def gibEinenPunkt(a,b,c,d):\n",
    "    a = [spurpunkt1(a,b,c,d),spurpunkt2(a,b,c,d),spurpunkt3(a,b,c,d)]\n",
    "    for x in a:\n",
    "        if (x[0]==1): return x[1]\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Spurpunkte"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, (3, 0, 0))\n",
      "(1, (0, 2, 0))\n",
      "(1, (0, 0, 1))\n",
      "(2, 'x1-Achse liegt in Ebene')\n"
     ]
    }
   ],
   "source": [
    "def spurpunkt1(a,b,c,d):\n",
    "    '''\n",
    "    E Ebene in Koordinatenform mit Koeffizienten a,b,c,d\n",
    "    returns:\n",
    "        (0,.)  wenn kein Spurpunkt mit x1-Achse\n",
    "        (1,(p1,p2,p3))  wenn p Spurpunkt auf x1-Achse\n",
    "        (2,.)  wenn x1-Achse in Ebene\n",
    "    '''\n",
    "    e = Eq(a*k,d)\n",
    "    if e == False:\n",
    "        return (0,\"kein Spurpunkt auf x1-Achse\")   \n",
    "    elif e == True:\n",
    "        return (2,\"x1-Achse liegt in Ebene\")\n",
    "    else: \n",
    "        equations = [e]\n",
    "        erg, = linsolve(equations,k) \n",
    "        return (1,(erg[0],0,0))\n",
    "    \n",
    "def spurpunkt2(a,b,c,d):\n",
    "    e = Eq(b*k,d)\n",
    "    if e == False:\n",
    "        return (0,\"kein Spurpunkt auf x2-Achse\")   \n",
    "    elif e == True:\n",
    "        return (2,\"x2-Achse liegt in Ebene\")\n",
    "    else: \n",
    "        equations = [e]\n",
    "        erg, = linsolve(equations,k) \n",
    "        return (1,(0,erg[0],0))\n",
    "    \n",
    "def spurpunkt3(a,b,c,d):\n",
    "    e = Eq(c*k,d)\n",
    "    if e == False:\n",
    "        return (0,\"kein Spurpunkt auf x3-Achse\")   \n",
    "    elif e == True:\n",
    "        return (2,\"x3-Achse liegt in Ebene\")\n",
    "    else: \n",
    "        equations = [e]\n",
    "        erg, = linsolve(equations,k) \n",
    "        return (1,(0,0,erg[0]))\n",
    "\n",
    "print(spurpunkt1(2,3,6,6))\n",
    "print(spurpunkt2(2,3,6,6))\n",
    "print(spurpunkt3(2,3,6,6))\n",
    "print(spurpunkt1(0,0,5,0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Einen Punkt auf einer Ebene"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gibEinenPunkt(a,b,c,d):\n",
    "    '''\n",
    "    E Ebene in Koordinatenform mit Koeffizienten a,b,c,d\n",
    "    returns: den ersten vorhandenen Spurpunkt\n",
    "    '''\n",
    "    a = [spurpunkt1(a,b,c,d),spurpunkt2(a,b,c,d),spurpunkt3(a,b,c,d)]\n",
    "    for x in a:\n",
    "        if (x[0]==1): return x[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lage zweier Ebenen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'Ebenen sind parallel')\n",
      "(2, 'Ebenen sind identisch')\n",
      "(1, (1, 1, 0), (1/5, 1/5, 1))\n",
      "(1, (3, 2, 0), (-1, 1/3, 1))\n"
     ]
    }
   ],
   "source": [
    "def lageZweierEbenen(a1,b1,c1,d1,a2,b2,c2,d2):\n",
    "    '''\n",
    "    E1, E2 Ebenen\n",
    "    returns:\n",
    "       (0,.) falls Ebenen parallel\n",
    "       (1,stuetz,richtung) falls Schnittgerade g: stuetz + k * richtung \n",
    "       (2,.) falls Ebenen identisch\n",
    "    \n",
    "    '''\n",
    "    if parallel(a1,b1,c1,a2,b2,c2)[0] == 1:\n",
    "        p1,p2,p3 = gibEinenPunkt(a1,b1,c1,d1)\n",
    "        if math.isclose(a2*p1 + b2*p2 + c2*p3,d2):\n",
    "            return (2,'Ebenen sind identisch')\n",
    "        else:\n",
    "            return (0,'Ebenen sind parallel')\n",
    "    else:\n",
    "        equations = [\n",
    "            Eq(a1*x+b1*y+c1*z,d1),\n",
    "            Eq(a2*x+b2*y+c2*z,d2),\n",
    "        ]\n",
    "        erg, = linsolve(equations,x,y,z)\n",
    "        stuetz = erg.subs(z,0).subs(x,0).subs(y,0)\n",
    "        s1,s2,s3 = stuetz\n",
    "        r1,r2,r3 = erg.subs(z,1).subs(x,1).subs(y,1) \n",
    "        return (1,stuetz,((r1-s1),(r2-s2),(r3-s3)))\n",
    "        \n",
    "print(lageZweierEbenen(2,3,-1,5,4,6,-2,3))\n",
    "print(lageZweierEbenen(2,3,-1,5,4,6,-2,10))\n",
    "print(lageZweierEbenen(2,3,-1,5,-5,10,-1,5))\n",
    "\n",
    "print(lageZweierEbenen(3,-3,4,3,6,3,5,24))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}