solve_serie.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "from sympy import *\n",
    "from fractions import Fraction\n",
    "import re\n",
    "init_printing()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def cleanup(formule):\n",
    "    cleanup = {'−': '-',' ':'','\\u200b':'','un':'n','×':'*'}\n",
    "    formule = re.sub('(?P<t>\\d)\\(','\\g<t>*(',formule)\n",
    "    formule = re.sub('(?P<t>\\d)n','\\g<t>*n',formule)\n",
    "    formule = re.sub('\\w\\(\\w','f(n',formule)\n",
    "    for key, val in cleanup.items(): formule = formule.replace(key,val)\n",
    "    return(formule)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def raison(serie):\n",
    "    # 1,2,3,4 or 1+2+3+...+234\n",
    "    if(serie[2]==serie[1]*2-serie[0]): # suite arithmétique\n",
    "        print(\"suite arithmétique\")\n",
    "        r = serie[1]-serie[0]\n",
    "    else: # suite géométrique\n",
    "        print(\"suite géométrique\")\n",
    "        r = serie[1]/serie[0]\n",
    "    return(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def convert_formula(formule):\n",
    "        t = S(\"{0}*(n-1)+{2}\".format(raison,serie[0]),evaluate=false)\n",
    "        t = S(\"{0}*{1}**(n-1)\".format(suite[0],raison))\n",
    "        formule = Eq(f(n),t,evaluate=False)\n",
    "        forme_recurrente = Eq(f(n+1),S(\"f(n){0}{1}\".format(signe,raison)))\n",
    "        forme_explicite = formule.rhs.doit()\n",
    "        print(formule)\n",
    "        print(forme_recurrente)\n",
    "        print(forme_explicite)\n",
    "        nfirst = int(solve(Eq(suite[0],forme_explicite))[0])\n",
    "        nlast = int(solve(Eq(suite[-1],forme_explicite))[0])+10\n",
    "        done = True\n",
    "    except Exception as e:\n",
    "        print(e)\n",
    "    \n",
    "    if not done:\n",
    "        #try:\n",
    "        formule = formule.replace(',','.').split('=')\n",
    "        if re.search('n\\+1',formule[0]): # f(n+1)=f(n)+9; f(1) # forme de recurrence\n",
    "            print(\"forme récurrente\")\n",
    "            forme_recurrente = Eq(f(n+1),S(formule[1]))\n",
    "            formule = forme_recurrente.doit()\n",
    "            forme_explicite = forme_recurrente.rhs.doit()\n",
    "        else: # forme explicite\n",
    "            print(\"forme explicite\")\n",
    "            formule = Eq(f(n),S(formule[1]))\n",
    "            raison = formule.subs(n,2).rhs - formule.subs(n,1).rhs\n",
    "            forme_recurrente = Eq(f(n+1),f(n)+raison,evaluate=False)\n",
    "            forme_explicite = formule.rhs.doit()\n",
    "            print(forme_explicite)\n",
    "        #except Exception as e:\n",
    "        #    print(e)\n",
    "    \n",
    "    try:\n",
    "        if (forme_explicite.has(f)):\n",
    "            suite = S([input(\"Entrez les premiers termes: \")])\n",
    "            forme_explicite = rsolve(formule, f(n), suite)\n",
    "            print(forme_explicite)\n",
    "            nfirst = int(solve(Eq(suite[0],forme_explicite))[0])\n",
    "            nlast = int(solve(Eq(suite[-1],forme_explicite))[0])\n",
    "        if not nfirst: nfirst = 0\n",
    "        if not nlast: int(input(\"Entrez le nombre de termes: \"))\n",
    "        results_20 = list(map(S,[forme_explicite.subs(n,i) for i in range(nfirst,nlast+1)]))\n",
    "    except AttributeError as e:\n",
    "        print(e)\n",
    "        return (None)\n",
    "    else:\n",
    "        result = {\n",
    "            'formule': formule,\n",
    "            'forme_recurrente': forme_recurrente,\n",
    "            'forme_explicite': forme_explicite,\n",
    "            'results_20': results_20,\n",
    "            'nfirst': repr(nfirst),\n",
    "            'nlast': repr(nlast),\n",
    "            'step': repr(raison)}\n",
    "        return(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "# égalité une formule\n",
    "def mysolve(entree=None):\n",
    "    entree = cleanup(entree)\n",
    "    entree = re.sub(',','.',entree)\n",
    "    entree = re.split('[=|+|-]',entree)\n",
    "    print(entree)\n",
    "    print(solve(Eq(entree[0],entree[1])))\n",
    "\n",
    "mysolve(input())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def PGCD(a, b):\n",
    "    while(b!=0):\n",
    "        c=a%b\n",
    "        a=b\n",
    "        b=c\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "# égalité deux formules\n",
    "x = Symbol('x')\n",
    "y = Symbol('y')\n",
    "a=-5*x+2*y-9\n",
    "b=7*x-y\n",
    "solve((a,b),x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "# factorisation\n",
    "factor(16*x**2-49*y**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "# inégalité\n",
    "solve(3+2*n>=13)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "# comparaison suite arithmétique et suite géométrique\n",
    "n=Symbol('n')\n",
    "\n",
    "t=S(21+5*n)\n",
    "u=S(5*2**n)\n",
    "\n",
    "def test(t,u): \n",
    "    i=1\n",
    "    while (t.subs(n,i) > u.subs(n,i)): i+=1\n",
    "    return(i+1)\n",
    "\n",
    "r = test(t,u)\n",
    "print('-- ' +repr(r)+ ' --')\n",
    "\n",
    "for i in range(r-2,r+2):\n",
    "    print(i+1)\n",
    "    print(t.subs(n,i))\n",
    "    print(u.subs(n,i))\n",
    "    print('***')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3,5,9\n",
      "[3, 5, 9]\n",
      "suite géométrique\n",
      "raison: 5/3\n"
     ]
    }
   ],
   "source": [
    "# type suite\n",
    "suite = cleanup(input())\n",
    "suite = list(map(S,suite.split(',')))\n",
    "print(suite)\n",
    "r = raison(suite)\n",
    "print('raison: ' + repr(r))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "# somme suite arithmétique\n",
    "n = Symbol('n')\n",
    "f = Function('f')\n",
    "fonction = suite[0] + r*(n-1)\n",
    "nlast = solve(Eq(suite[-1],fonction),n)[0]\n",
    "print(fonction)\n",
    "print('nlast: ' + repr(nlast))\n",
    "serie = list(fonction.subs(n,i) for i in range(1,nlast+1))\n",
    "print(serie)\n",
    "print('total: ' + repr(sum(serie)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "# somme suite géométrique\n",
    "n = Symbol('n')\n",
    "f = Function('f')\n",
    "fonction = suite[0] * r**n\n",
    "nlast = 25\n",
    "print(fonction)\n",
    "serie = list(fonction.subs(n,i) for i in range(0,nlast+1))\n",
    "print(serie)\n",
    "print('total: ' + repr(sum(serie)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "θ = Symbol('θ')\n",
    "r = 1+2*sin(θ)\n",
    "pprint(r)\n",
    "tan(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "a = cos(θ).subs(θ,pi/4)\n",
    "p1, p2 = Point(0, 0), Point(pi/4, a)\n",
    "l1 = Line(p1, p2)\n",
    "l1.slope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "Fraction(4,1)*Fraction(1,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "# Convertir les nombres fractionnaires\n",
    "from time import sleep\n",
    "a=c=3/4\n",
    "b=5/6\n",
    "while (a%b != 0):\n",
    "    a=a-1\n",
    "    print(a)\n",
    "    \n",
    "print('{0} {1}/{2}'.format(int(a/b),c-a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "(Fraction(1)+Fraction(1,12)) - Fraction(7/4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "Fraction(Fraction(1,3),9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "(2+Fraction(3,12))<Fraction(7,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "PGCD(22517998136852481,36028797018963968)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}