| 1 |
% !TeX TXS-program:compile = txs:///arara |
| 2 |
% arara: lualatex: {shell: yes, synctex: no, interaction: batchmode} |
| 3 |
% arara: lualatex: {shell: yes, synctex: no, interaction: batchmode} if found('log', '(undefined references|Please rerun|Rerun to get)') |
| 4 |
|
| 5 |
\documentclass[french,a4paper,11pt]{article} |
| 6 |
\def\SCversion{0.1.1} |
| 7 |
\def\SCdate{8 mai 2023} |
| 8 |
\usepackage[executable=python.exe]{pyluatex} |
| 9 |
\usepackage[svgnames]{xcolor} |
| 10 |
\usepackage{siunitx} |
| 11 |
\sisetup{locale=FR,output-decimal-marker={,},group-minimum-digits=4} |
| 12 |
\usepackage{amsmath,amssymb} |
| 13 |
%\usepackage{mathtools} |
| 14 |
\usepackage[bold-style=ISO,math-style=french]{unicode-math} |
| 15 |
\setmainfont{TeX Gyre Schola} |
| 16 |
\setmathfont{TeX Gyre Schola Math} |
| 17 |
\usepackage{SympyCalc} |
| 18 |
\usepackage{awesomebox} |
| 19 |
\usepackage{fontawesome5} |
| 20 |
\usepackage{enumitem} |
| 21 |
\usepackage{tabularray} |
| 22 |
\usepackage{fancyvrb} |
| 23 |
\usepackage{fancyhdr} |
| 24 |
\fancyhf{} |
| 25 |
\renewcommand{\headrulewidth}{0pt} |
| 26 |
\lfoot{\sffamily\small [SympyCalc]} |
| 27 |
\cfoot{\sffamily\small - \thepage{} -} |
| 28 |
\rfoot{\hyperlink{matoc}{\small\faArrowAltCircleUp[regular]}} |
| 29 |
|
| 30 |
\usepackage{hologo} |
| 31 |
\providecommand\tikzlogo{Ti\textit{k}Z} |
| 32 |
\providecommand\TeXLive{\TeX{}Live\xspace} |
| 33 |
\providecommand\PSTricks{\textsf{PSTricks}\xspace} |
| 34 |
\let\pstricks\PSTricks |
| 35 |
\let\TikZ\tikzlogo |
| 36 |
\newcommand\TableauDocumentation{% |
| 37 |
\begin{tblr}{width=\linewidth,colspec={X[c]X[c]X[c]X[c]X[c]X[c]},cells={font=\sffamily}} |
| 38 |
{\LARGE \LaTeX} & & & & &\\ |
| 39 |
& {\LARGE \hologo{pdfLaTeX}} & & & & \\ |
| 40 |
& & {\LARGE \hologo{LuaLaTeX}} & & & \\ |
| 41 |
& & & {\LARGE \TikZ} & & \\ |
| 42 |
& & & & {\LARGE \TeXLive} & \\ |
| 43 |
& & & & & {\LARGE \hologo{MiKTeX}} \\ |
| 44 |
\end{tblr} |
| 45 |
} |
| 46 |
|
| 47 |
\usepackage{tikz} |
| 48 |
\usetikzlibrary{calc} |
| 49 |
\usepackage{hyperref} |
| 50 |
\urlstyle{same} |
| 51 |
\hypersetup{pdfborder=0 0 0} |
| 52 |
\usepackage[margin=1.5cm]{geometry} |
| 53 |
\setlength{\parindent}{0pt} |
| 54 |
\definecolor{LightGray}{gray}{0.9} |
| 55 |
|
| 56 |
\usepackage[most]{tcolorbox} |
| 57 |
\NewDocumentCommand\e{ }{\mathrm{e}} |
| 58 |
\RenewDocumentCommand\i{ }{\mathrm{i}} |
| 59 |
\newtcblisting{bloctext}[1][]{% |
| 60 |
enhanced,width=0.93\linewidth,flush right,% |
| 61 |
bicolor,size=title,% |
| 62 |
colback=cyan!5!white,% |
| 63 |
colbacklower=cyan!1!white,% |
| 64 |
colframe=cyan!75!black,% |
| 65 |
listing options={% |
| 66 |
style=tcblatex,basicstyle=\small\ttfamily,% |
| 67 |
tabsize=4,% |
| 68 |
commentstyle={\itshape\color{violet}}, |
| 69 |
keywordstyle={\bfseries\color{DodgerBlue}},% |
| 70 |
classoffset=0,% |
| 71 |
keywords={frac,dfrac,int,sqrt,mathcal},% |
| 72 |
keywordstyle={\bfseries\color{DodgerBlue}},% |
| 73 |
classoffset=1,% |
| 74 |
morekeywords={sympycalc,dsympycalc,sympydev,dsympydev,sympyfact,dsympyfact,sympyderiv,dsympyderiv,sympyprim,dsympyprim,sympyintegr,dsympyintegr,sympylim,dsympylim,sympyfexpo,dsympyfexpo,sympyresol,dsympyresol,sympyresolC,dsympyresolC,sympynbderiv,dsympynbderiv,sympyimage,dsympyimage,pythonq},% |
| 75 |
keywordstyle={\bfseries\color{purple}},% |
| 76 |
classoffset=2,% |
| 77 |
morekeywords={solve,radsimp,cancel},% |
| 78 |
keywordstyle={\bfseries\color{ForestGreen}},% |
| 79 |
classoffset=3,% |
| 80 |
morekeywords={NoSimplif,Simplif},% |
| 81 |
keywordstyle={\bfseries\color{OliveDrab}} |
| 82 |
},% |
| 83 |
overlay={\draw[cyan!75!black] ($(frame.north west)+(-0.035\linewidth,-0.025\linewidth)$) node[scale=1.66] {\faCode} ;},% |
| 84 |
#1 |
| 85 |
} |
| 86 |
|
| 87 |
\usepackage{babel} |
| 88 |
\usepackage{textualicomma} |
| 89 |
\DeclareMathSymbol{;}\mathbin{operators}{'73} % \mathpunct à l'origine |
| 90 |
|
| 91 |
\tcbset{vignettes/.style={% |
| 92 |
nobeforeafter,box align=base,boxsep=0pt,enhanced,sharp corners=all,rounded corners=southeast,% |
| 93 |
boxrule=0.75pt,left=7pt,right=1pt,top=0pt,bottom=0.25pt,% |
| 94 |
} |
| 95 |
} |
| 96 |
|
| 97 |
\tcbset{vignetteMaJ/.style={% |
| 98 |
fontupper={\vphantom{pf}\footnotesize\ttfamily}, |
| 99 |
vignettes,colframe=ForestGreen!50!black,coltitle=white,colback=ForestGreen!25,% |
| 100 |
overlay={\begin{tcbclipinterior}% |
| 101 |
\fill[fill=ForestGreen!75]($(interior.south west)$) rectangle node[rotate=90]{\tiny \sffamily{\textcolor{Black}{\scalebox{0.85}[0.75]{\textbf{MàJ}}}}} ($(interior.north west)+(5pt,0pt)$);% |
| 102 |
\end{tcbclipinterior}} |
| 103 |
} |
| 104 |
} |
| 105 |
|
| 106 |
\newcommand\Cle[1]{{\bfseries\sffamily\textlangle #1\textrangle}} |
| 107 |
\newcommand\cmaj[1]{\tcbox[vignetteMaJ]{#1}\xspace} |
| 108 |
|
| 109 |
\begin{document} |
| 110 |
|
| 111 |
\setlength{\aweboxleftmargin}{0.07\linewidth} |
| 112 |
\setlength{\aweboxcontentwidth}{0.93\linewidth} |
| 113 |
\setlength{\aweboxvskip}{8pt} |
| 114 |
|
| 115 |
\pagestyle{fancy} |
| 116 |
|
| 117 |
\thispagestyle{empty} |
| 118 |
|
| 119 |
\vspace{2cm} |
| 120 |
|
| 121 |
\begin{center} |
| 122 |
\begin{minipage}{0.75\linewidth} |
| 123 |
\begin{tcolorbox}[colframe=yellow,colback=yellow!15] |
| 124 |
\begin{center} |
| 125 |
\begin{tabular}{c} |
| 126 |
{\Huge \texttt{SympyCalc [fr]}}\\ |
| 127 |
\\ |
| 128 |
{\LARGE Des outils pour utiliser les} \\ |
| 129 |
\\ |
| 130 |
{\LARGE capacités de \textsf{sympy} de \faPython, } \\ |
| 131 |
\\ |
| 132 |
{\LARGE avec le package \textsf{pyluatex}.} \\ |
| 133 |
\end{tabular} |
| 134 |
|
| 135 |
\bigskip |
| 136 |
|
| 137 |
{\small \texttt{Version \SCversion{} -- \SCdate}} |
| 138 |
\end{center} |
| 139 |
\end{tcolorbox} |
| 140 |
\end{minipage} |
| 141 |
\end{center} |
| 142 |
|
| 143 |
\begin{center} |
| 144 |
\begin{tabular}{c} |
| 145 |
\texttt{Cédric Pierquet}\\ |
| 146 |
{\ttfamily c pierquet -- at -- outlook . fr}\\ |
| 147 |
\texttt{\url{https://github.com/cpierquet/SympyCalc}} |
| 148 |
\end{tabular} |
| 149 |
\end{center} |
| 150 |
|
| 151 |
\begin{center} |
| 152 |
\begin{minipage}{0.5\linewidth} |
| 153 |
\begin{tcolorbox}[colframe=DarkBlue!50,colback=DarkBlue!5] |
| 154 |
\begin{center} |
| 155 |
\textsf{SymPy} est un module \textsf{Python} qui permet de faire du calcul symbolique. |
| 156 |
|
| 157 |
\texttt{\url{https://www.sympy.org/}} |
| 158 |
\end{center} |
| 159 |
\end{tcolorbox} |
| 160 |
\end{minipage} |
| 161 |
\end{center} |
| 162 |
|
| 163 |
\vspace{0.25cm} |
| 164 |
|
| 165 |
{$\blacktriangleright$~~Compilation en \hologo{LuaLaTeX}, avec un accès \textsf{--shell-escape}, en \textit{partenariat} avec \textsf{pyluatex}.} |
| 166 |
|
| 167 |
\smallskip |
| 168 |
|
| 169 |
{$\blacktriangleright$~~Du calcul \textit{exact} avec des racines, de l'exponentielle, du logarithme, des complexes\ldots} |
| 170 |
|
| 171 |
\smallskip |
| 172 |
|
| 173 |
{$\blacktriangleright$~~Du calcul symbolique avec du développement, de la factorisation.} |
| 174 |
|
| 175 |
\smallskip |
| 176 |
|
| 177 |
{$\blacktriangleright$~~Des résolutions d'équations.} |
| 178 |
|
| 179 |
\smallskip |
| 180 |
|
| 181 |
{$\blacktriangleright$~~Du calcul différentiel, intégral.} |
| 182 |
|
| 183 |
\smallskip |
| 184 |
|
| 185 |
{$\blacktriangleright$~~Tout ce que \textsf{sympy} peut faire !} |
| 186 |
|
| 187 |
\vspace{1cm} |
| 188 |
|
| 189 |
\begin{center} |
| 190 |
\begin{tcolorbox}[enhanced,colframe=ForestGreen,colback=lightgray!5,center,width=0.95\linewidth,drop fuzzy shadow=lightgray] |
| 191 |
$1+\dfrac76 = \dsympycalc{1+7/6}$ et $\left(\e^5 +1 \right) \times \left(\e^5-1 \right) = \sympycalc{(exp(5)+1)*(exp(5)-1)}$ |
| 192 |
|
| 193 |
\medskip |
| 194 |
|
| 195 |
\hfill$3+\i\sqrt{3} = \dsympyfexpo{3+I*sqrt(3)}$\hfill~ |
| 196 |
|
| 197 |
\medskip |
| 198 |
|
| 199 |
\hfill$I=\displaystyle\int_0^{4} (x+3)\,\e^{2x}\,\text{d}x = \dsympyintegr{(x+3)*exp(2*x)}{0}{4}$ |
| 200 |
|
| 201 |
\medskip |
| 202 |
|
| 203 |
\hfill$\lim\limits_{x \to +\infty} \sqrt{\dfrac{2x^2+1}{x^2-5}} = \sympylim{sqrt((2*x**2+1)/(x**2-5))}{+oo}$\hfill~ |
| 204 |
|
| 205 |
\medskip |
| 206 |
|
| 207 |
$10\,\e^{4x+5}=2$ : $\mathcal{S}=\dsympyresol{10*exp(4*x+5)=2}$ |
| 208 |
|
| 209 |
\hfill$f(t)=(t+3)\,\e^{2t} \implies f'(t) = \sympyderiv{(t+3)*exp(2*t)}[t]$ |
| 210 |
\end{tcolorbox} |
| 211 |
\end{center} |
| 212 |
|
| 213 |
\vspace{0.5cm} |
| 214 |
|
| 215 |
%\hfill{}\textit{Merci à Denis Bitouzé et à Gilles Le Bourhis pour leurs retours et idées !} |
| 216 |
|
| 217 |
%\smallskip |
| 218 |
|
| 219 |
\vfill |
| 220 |
|
| 221 |
\hrule |
| 222 |
|
| 223 |
\medskip |
| 224 |
|
| 225 |
\TableauDocumentation |
| 226 |
|
| 227 |
\medskip |
| 228 |
|
| 229 |
\hrule |
| 230 |
|
| 231 |
\medskip |
| 232 |
|
| 233 |
\newpage |
| 234 |
|
| 235 |
\phantomsection |
| 236 |
\hypertarget{matoc}{} |
| 237 |
|
| 238 |
\tableofcontents |
| 239 |
|
| 240 |
\newpage |
| 241 |
|
| 242 |
\part{Introduction} |
| 243 |
|
| 244 |
\section{Le package SympyCalc} |
| 245 |
|
| 246 |
\subsection{Introduction et conventions} |
| 247 |
|
| 248 |
\begin{noteblock} |
| 249 |
Le package \textit{propose} des outils pour utiliser les capacités du module \textsf{sympy} de \textsf{python} et les \textit{formater} en \LaTeX{} : |
| 250 |
|
| 251 |
\begin{itemize} |
| 252 |
\item calcul exact (dans la mesure du possible) ; |
| 253 |
\item calcul symbolique (dans la mesure du possible) : |
| 254 |
\begin{itemize} |
| 255 |
\item factorisation, développement, simplification ; |
| 256 |
\item dérivation, intégration, limites ; |
| 257 |
\item résolution d'équations. |
| 258 |
\end{itemize} |
| 259 |
\end{itemize} |
| 260 |
\vspace*{-\baselineskip}\leavevmode |
| 261 |
\end{noteblock} |
| 262 |
|
| 263 |
\begin{importantblock} |
| 264 |
À noter que les calculs -- en interne -- sont : |
| 265 |
|
| 266 |
\begin{itemize} |
| 267 |
\item effectués par le module \textsf{sympy} ; |
| 268 |
\item formatés par la fonction \texttt{latex()} du module \textsf{sympy} ; |
| 269 |
\item sortis en \LaTeX{} avec quelques ajustements. |
| 270 |
\end{itemize} |
| 271 |
|
| 272 |
Les ajustements (qu'on pourrait qualifier de \textit{mini-patchs}) permettent : |
| 273 |
|
| 274 |
\begin{itemize} |
| 275 |
\item de forcer les résultats sous forme de fraction (grâce -- en interne -- au recours à \texttt{S.One}) ; |
| 276 |
\item d'utiliser la notation \texttt{ln} (\textsf{sympy} utilise \texttt{log} par défaut) ; |
| 277 |
\item d'utiliser l'écriture du \texttt{e} et du \texttt{i} en \textsf{romain} ; |
| 278 |
\item de forcer l'écriture du \og + \fg{} avant \og $\infty$ \fg. |
| 279 |
\end{itemize} |
| 280 |
|
| 281 |
Hormis le \textit{forçage} du \texttt{ln}, et du $\mathtt{+\infty}$, conventions sur \texttt{e} et \texttt{i} peuvent être \textit{désactivées}. |
| 282 |
\end{importantblock} |
| 283 |
|
| 284 |
\begin{tipblock} |
| 285 |
Le package propose également de quoi utiliser (et formater) toute commande exprimée en syntaxe \textsf{sympy}. |
| 286 |
|
| 287 |
\smallskip |
| 288 |
|
| 289 |
Le module \textsf{sympy} est chargé par le package, avec les variables symboliques \texttt{x}, \texttt{y}, \texttt{z} et \texttt{t}. |
| 290 |
\end{tipblock} |
| 291 |
|
| 292 |
\begin{warningblock} |
| 293 |
L'utilisation de \textsf{pyluatex} (en tant que passerelle entre \textsf{python} et \LaTeX) nécessite une compilation adaptée, à savoir en \hologo{LuaLaTeX} et en activant le mode \textsf{--shell-escape}. Le module \textsf{sympy} doit donc être installé pour que l'exécutable \textsf{python} qui sera paramétré le \textit{trouve} !. |
| 294 |
\end{warningblock} |
| 295 |
|
| 296 |
\subsection{Chargement du package} |
| 297 |
|
| 298 |
\begin{importantblock} |
| 299 |
Le package (qui ne charge \textit{que} \textsf{xstring}) se charge de manière classique, une fois \textsf{pyluatex} lui-même correctement chargé. |
| 300 |
|
| 301 |
\smallskip |
| 302 |
|
| 303 |
Compte-tenu de la spécificité de \textsf{pyluatex} et du paramétrage du chemin \textsf{python}, c'est à l'utilisateur de le charger en adéquation avec son installation ! |
| 304 |
|
| 305 |
\smallskip |
| 306 |
|
| 307 |
Les packages adaptés aux formules mathématiques sont également nécessaires, mais compte-tenu de leurs diversités, l'utilisateur choisira celui (ceux) qu'il jugera nécessaire(s). |
| 308 |
\end{importantblock} |
| 309 |
|
| 310 |
\begin{bloctext}[listing only] |
| 311 |
%compilation en lualatex + shell-escape !! |
| 312 |
\usepackage{mathtools} %package pour les maths |
| 313 |
\usepackage[executable=python.exe]{pyluatex} %à adapter ! |
| 314 |
\usepackage{SympyCalc} |
| 315 |
\end{bloctext} |
| 316 |
|
| 317 |
\newpage |
| 318 |
|
| 319 |
\section{Philosophie du package} |
| 320 |
|
| 321 |
\subsection{Fonctionnement global} |
| 322 |
|
| 323 |
\begin{noteblock} |
| 324 |
Le package propose des commandes génériques, qui permettent de \textit{traiter} tout commande \textsf{sympy}, ainsi que des commandes spécifiques qui sont en fait des \textit{raccourcis} de commandes usuelles en \textsf{sympy}. |
| 325 |
|
| 326 |
\smallskip |
| 327 |
|
| 328 |
Autant que peut se faire, les commandes sont assez explicites sur leur fonctionnement, et elles reposent sur le même principe : |
| 329 |
|
| 330 |
\begin{itemize} |
| 331 |
\item \texttt{\textbackslash \textcolor{purple}{sympy...}} : commande qui simplifie (par défaut), avec règles typographiques \texttt{[fr]} \textsf{romain} ; |
| 332 |
\item \texttt{\textbackslash \textcolor{purple}{dsympy...}} : commande qui simplifie (par défaut), avec règles typographiques \texttt{[fr]} \textsf{romain}, et affichage en \texttt{\textbackslash displaystyle} ; |
| 333 |
\item \texttt{\textbackslash \textcolor{purple}{sympy...*}} : commande qui simplifie (par défaut), avec règles typographiques \texttt{[fr]} \textsf{italique} ; |
| 334 |
\item \texttt{\textbackslash \textcolor{purple}{dsympy...*}} : commande qui simplifie (par défaut), avec règles typographiques \texttt{[fr]} \textsf{italique}, et affichage en \texttt{\textbackslash displaystyle}. |
| 335 |
\end{itemize} |
| 336 |
|
| 337 |
Dans certains cas la \textit{simplification} ne propose pas une sortie \textit{classique}, et il est possible d'empêcher la simplification grâce à l'argument optionnel \texttt{<\textcolor{OliveDrab}{NoSimplif}>}. |
| 338 |
|
| 339 |
\smallskip |
| 340 |
|
| 341 |
La variable est par défaut \texttt{x}, mais peut-être modifiée grâce à l'argument \texttt{[variable]}. |
| 342 |
\end{noteblock} |
| 343 |
|
| 344 |
\subsection{Commandes disponibles} |
| 345 |
|
| 346 |
\begin{bloctext}[listing only] |
| 347 |
%commandes génériques |
| 348 |
\sympycalc(*)<NoSimplif>{commande sympy} |
| 349 |
\dsympycalc(*)<NoSimplif>{commande sympy} |
| 350 |
|
| 351 |
%commandes spécifiques, sortie standard, détaillées plus loin |
| 352 |
\sympyimage(*)<NoSimplif>{fonction sympy}[variable]{point} |
| 353 |
\sympydev(*)<NoSimplif>{expr sympy}[variable] |
| 354 |
\sympyfact(*)<NoSimplif>{expr sympy} |
| 355 |
\sympyderiv(*)<NoSimplif>{expr sympy}[variable] |
| 356 |
\sympynbderiv(*)<NoSimplif>{expr sympy}[variable]{point}[côté] |
| 357 |
\sympyprim(*)<NoSimplif>{expr sympy}[variable] |
| 358 |
\sympyintegr(*)<NoSimplif>{expr sympy}[variable]{borne inf}{borne sup} |
| 359 |
\sympylim(*)<NoSimplif>{expr sympy}[variable]{point}[côté] |
| 360 |
\sympyfexpo(*)<NoSimplif>{complexe sympy} |
| 361 |
\sympyresol(*){equation sympy}[variable] |
| 362 |
\sympyresolC(*){equation sympy}[variable] |
| 363 |
|
| 364 |
%commandes spécifiques, sortie displaystyle, détaillées plus loin |
| 365 |
\dsympydev(*)<NoSimplif>{expr sympy}[variable] |
| 366 |
\dsympyimage(*)<NoSimplif>{fonction sympy}[variable]{point} |
| 367 |
\dsympyfact(*)<NoSimplif>{expr sympy} |
| 368 |
\dsympyderiv(*)<NoSimplif>{expr sympy}[variable] |
| 369 |
\dsympynbderiv(*)<NoSimplif>{expr sympy}[variable]{point}[côté] |
| 370 |
\dsympyprim(*)<NoSimplif>{expr sympy}[variable] |
| 371 |
\dsympyintegr(*)<NoSimplif>{expr sympy}[variable]{borne inf}{borne sup} |
| 372 |
\dsympylim(*)<NoSimplif>{expr sympy}[variable]{point}[côté] |
| 373 |
\dsympyfexpo(*)<NoSimplif>{complexe sympy} |
| 374 |
\dsympyresol(*){equation sympy}[variable] |
| 375 |
\dsympyresolC(*){equation sympy}[variable] |
| 376 |
\end{bloctext} |
| 377 |
|
| 378 |
\begin{importantblock} |
| 379 |
Dans certains cas, la sortie obtenue n'est pas celle attendue, que ce soit avec ou sans \texttt{<Simplif>}, et donc il s'agira de saisir les commandes \textsf{sympy} \textit{manuellement}. |
| 380 |
\end{importantblock} |
| 381 |
|
| 382 |
\begin{tipblock} |
| 383 |
L'\og infini \fg{} est disponible en \textsf{sympy}, grâce à \texttt{+oo} ou \texttt{-oo}. |
| 384 |
|
| 385 |
\smallskip |
| 386 |
|
| 387 |
Un petit \textit{guide} pour \textsf{sympy} est disponible à : \url{https://hashdork.com/fr/sympy-library-guide/}. |
| 388 |
\end{tipblock} |
| 389 |
|
| 390 |
\section{Limitations} |
| 391 |
|
| 392 |
\begin{warningblock} |
| 393 |
Pour le moment c'est le package \textsf{pyluatex} qui est privilégié, mais des tests sont en cours pour une compatibilité éventuelle avec d'autres packages pouvant travailler avec \textsf{python}. |
| 394 |
\end{warningblock} |
| 395 |
|
| 396 |
\begin{warningblock} |
| 397 |
Le formatage des flottants n'est pas géré par \texttt{\textbackslash num} de \textsf{sinuitx}, donc l'écriture des éventuelles valeurs approchées ne seront pas forcément cohérentes avec les autres formatages dans le document\ldots |
| 398 |
|
| 399 |
\smallskip |
| 400 |
|
| 401 |
Le remplacement éventuel du \texttt{e} en \textsf{romain} risque de ne pas fonctionner quand le résultat contient du \og e tout seul \fg\ldots |
| 402 |
|
| 403 |
\smallskip |
| 404 |
|
| 405 |
Des espacements \textit{non voulus} peuvent apparaître lors de la transcription en \LaTeX, donc le résultat formaté peut être légèrement différent de ce que peut attendre l'utilisateur\ldots |
| 406 |
|
| 407 |
\smallskip |
| 408 |
|
| 409 |
La transformation automatique du \texttt{oo} en \texttt{+oo} ne détecte pas si le calcul est effectué avec des complexes, donc prudence sur les limites notamment\ldots |
| 410 |
\end{warningblock} |
| 411 |
|
| 412 |
\newpage |
| 413 |
|
| 414 |
\part{Les commandes} |
| 415 |
|
| 416 |
\section{La commande générique} |
| 417 |
|
| 418 |
\subsection{Présentation} |
| 419 |
|
| 420 |
\begin{cautionblock} |
| 421 |
La commande générique pour formater une sortie \textsf{sympy} est \texttt{\textbackslash \textcolor{purple}{sympycalc}} ou \texttt{\textbackslash \textcolor{purple}{dsympycalc}}. |
| 422 |
|
| 423 |
\smallskip |
| 424 |
|
| 425 |
Elle permet de \textit{parser} du code \textsf{sympy} et de formater la sortie avec les règles typographiques usuelles. |
| 426 |
\end{cautionblock} |
| 427 |
|
| 428 |
\begin{bloctext}[listing only] |
| 429 |
%commandes génériques |
| 430 |
\sympycalc(*)<NoSimplif>{commande sympy} |
| 431 |
\dsympycalc(*)<NoSimplif>{commande sympy} |
| 432 |
\end{bloctext} |
| 433 |
|
| 434 |
\subsection{Arguments} |
| 435 |
|
| 436 |
\begin{tipblock} |
| 437 |
Concernant son fonctionnement : |
| 438 |
|
| 439 |
\begin{itemize} |
| 440 |
\item la version \Cle{*} permet de ne pas formater le \texttt{e} et le \texttt{i} en \textsf{romain} ; |
| 441 |
\item le premier argument, optionnel et pouvant valoir \texttt{<\textcolor{OliveDrab}{NoSimplif}>} permet d'\textit{annuler} la simplification (attention au comportement de la \textit{simplification} par \textsf{sympy}\ldots) |
| 442 |
\item le second argument, obligatoire et entre \texttt{\{...\}} est quant à lui la commande, en langage \textsf{sympy} à passer en \textsf{python}. |
| 443 |
\end{itemize} |
| 444 |
\vspace*{-\baselineskip}\leavevmode |
| 445 |
\end{tipblock} |
| 446 |
|
| 447 |
\subsection{Exemples} |
| 448 |
|
| 449 |
\begin{bloctext} |
| 450 |
On a $1+\frac76 = \sympycalc{1+7/6}$, ou $1+\dfrac76 = \dsympycalc{1+7/6}$ |
| 451 |
\end{bloctext} |
| 452 |
|
| 453 |
\begin{bloctext} |
| 454 |
$1+\frac14+\frac17 + \sqrt{45} + \frac{2}{\sqrt{12}} = |
| 455 |
\sympycalc{1+1/4+1/7+sqrt(45)+2/sqrt(12)}$ |
| 456 |
|
| 457 |
$1+\dfrac14+\dfrac17 + \sqrt{45} + \dfrac{2}{\sqrt{12}} = |
| 458 |
\dsympycalc{1+1/4+1/7+sqrt(45)+2/sqrt(12)}$ |
| 459 |
\end{bloctext} |
| 460 |
|
| 461 |
\begin{bloctext} |
| 462 |
On a $\left(\e^5 +1 \right) \times \left(\e^5-1 \right) = \sympycalc{(exp(5)+1)*(exp(5)-1)}$ |
| 463 |
\end{bloctext} |
| 464 |
|
| 465 |
\begin{bloctext} |
| 466 |
On a $\dfrac{x}{x+1} - \dfrac{x+2}{x-3} = \dsympycalc{radsimp(factor(x/(x+1) - (x+2)/(x-3)))}$ |
| 467 |
\end{bloctext} |
| 468 |
|
| 469 |
\begin{bloctext} |
| 470 |
Les solutions de $\dfrac13x^2+9x+4=0$ sont |
| 471 |
$x_1 = \dsympycalc{solve(1/3*x**2+9*x+4,x)[0]}$ et |
| 472 |
$x_2 = \dsympycalc{solve(1/3*x**2+9*x+4,x)[1]}$ |
| 473 |
\end{bloctext} |
| 474 |
|
| 475 |
\section{Quelques commandes spécifiques} |
| 476 |
|
| 477 |
\subsection{Images} |
| 478 |
|
| 479 |
\begin{cautionblock} |
| 480 |
\cmaj{0.1.1} La commande pour calculer une image via \textsf{sympy} est \texttt{\textbackslash \textcolor{purple}{sympyimage}} ou \texttt{\textbackslash \textcolor{purple}{dsympyimage}}. |
| 481 |
|
| 482 |
Il vaut mieux vérifier si le résultat formaté est conforme aux attentes, et sinon utiliser la commande générique. |
| 483 |
\end{cautionblock} |
| 484 |
|
| 485 |
\begin{bloctext}[listing only] |
| 486 |
%commandes pour cacluler une image |
| 487 |
\sympyimage(*)<NoSimplif>{fonction sympy}[variable]{point} |
| 488 |
\dsympyimage(*)<NoSimplif>{fonction sympy}[variable]{point} |
| 489 |
\end{bloctext} |
| 490 |
|
| 491 |
\begin{tipblock} |
| 492 |
Concernant son fonctionnement : |
| 493 |
|
| 494 |
\begin{itemize} |
| 495 |
\item la version \Cle{*} permet de ne pas formater le \texttt{e} et le \texttt{i} en \textsf{romain} ; |
| 496 |
\item le premier argument, optionnel et pouvant valoir \texttt{<\textcolor{OliveDrab}{NoSimplif}>} permet d'\textit{annuler} la simplification (attention au comportement de la \textit{simplification} par \textsf{sympy}\ldots) |
| 497 |
\item le deuxième argument, obligatoire et entre \texttt{\{...\}} est quant à lui la fonction, en langage \textsf{sympy} à passer en \textsf{python} ; |
| 498 |
\item les derniers arguments, optionnel entre \texttt{[...]} et obligatoire et entre \texttt{\{...\}} correspondent à la variable et le point. |
| 499 |
\end{itemize} |
| 500 |
\vspace*{-\baselineskip}\leavevmode |
| 501 |
\end{tipblock} |
| 502 |
|
| 503 |
\begin{bloctext} |
| 504 |
$f(x)=\dfrac{2+\e^x}{3+4\e^{2x}}$ avec $a=5$ : $f(5)=\dsympyimage{(2+exp(x))/(3+4*exp(2*x))}{5}$ |
| 505 |
\end{bloctext} |
| 506 |
|
| 507 |
\begin{bloctext} |
| 508 |
$g(t)=\sqrt{1+\ln(t)}$ avec $a=13$ : $g(13)=\sympyimage{sqrt(1+log(t))}[t]{13}$ |
| 509 |
\end{bloctext} |
| 510 |
|
| 511 |
\begin{bloctext} |
| 512 |
$h(x)=2x^2+2,5x+7$ en $a=\sqrt{2}$ : |
| 513 |
$h\left(\sqrt{2}\right)=\dsympyimage{2*x**2+5/2*x+7}{sqrt(2)}$ |
| 514 |
\end{bloctext} |
| 515 |
|
| 516 |
\subsection{Développement} |
| 517 |
|
| 518 |
\begin{cautionblock} |
| 519 |
La commande pour développer une sortie \textsf{sympy} est \texttt{\textbackslash \textcolor{purple}{sympydev}} ou \texttt{\textbackslash \textcolor{purple}{dsympydev}}. |
| 520 |
|
| 521 |
Il vaut mieux vérifier si le résultat formaté est conforme aux attentes, et sinon utiliser la commande générique. |
| 522 |
\end{cautionblock} |
| 523 |
|
| 524 |
\begin{bloctext}[listing only] |
| 525 |
%commandes pour développer |
| 526 |
\sympydev(*)<NoSimplif>{commande sympy}[variable] |
| 527 |
\dsympydev(*)<NoSimplif>{commande sympy}[variable] |
| 528 |
\end{bloctext} |
| 529 |
|
| 530 |
\begin{tipblock} |
| 531 |
Concernant son fonctionnement : |
| 532 |
|
| 533 |
\begin{itemize} |
| 534 |
\item la version \Cle{*} permet de ne pas formater le \texttt{e} et le \texttt{i} en \textsf{romain} ; |
| 535 |
\item le premier argument, optionnel et pouvant valoir \texttt{<\textcolor{OliveDrab}{NoSimplif}>} permet d'\textit{annuler} la simplification (attention au comportement de la \textit{simplification} par \textsf{sympy}\ldots) |
| 536 |
\item le deuxième argument, obligatoire et entre \texttt{\{...\}} est quant à lui la commande, en langage \textsf{sympy} à passer en \textsf{python} ; |
| 537 |
\item le dernier argument, optionnel et entre \texttt{[...]} est la variable éventuelle. |
| 538 |
\end{itemize} |
| 539 |
\vspace*{-\baselineskip}\leavevmode |
| 540 |
\end{tipblock} |
| 541 |
|
| 542 |
\begin{bloctext} |
| 543 |
$(1+\text{i})^5 = \sympydev{(1+I)**5}$ %typo [fr] |
| 544 |
|
| 545 |
$(1+i)^5 = \sympydev*{(1+I)**5}$ |
| 546 |
|
| 547 |
$\dfrac{1}{(1+\text{i})^5} = \dsympydev{1/(1+I)**5}$ |
| 548 |
\end{bloctext} |
| 549 |
|
| 550 |
\begin{bloctext} |
| 551 |
On a $(1+2x)^4 = \sympydev{(1+2*x)**4}$ |
| 552 |
|
| 553 |
On a $\left(2t+\dfrac13\right)^3 = \dsympydev{(2*t+1/3)**3}[t]$ |
| 554 |
\end{bloctext} |
| 555 |
|
| 556 |
\begin{bloctext} |
| 557 |
$\sin^2(x)+\cos^2(x) = \dsympydev{sin(x)**2+cos(x)**2}$ |
| 558 |
|
| 559 |
$\left(\cos(x)+\sin(x)\right)^2 = \dsympydev{(sin(x)+cos(x))**2}$ |
| 560 |
\end{bloctext} |
| 561 |
|
| 562 |
\subsection{Factorisation} |
| 563 |
|
| 564 |
\begin{cautionblock} |
| 565 |
La commande pour factoriser une sortie \textsf{sympy} est \texttt{\textbackslash \textcolor{purple}{sympyfact}} ou \texttt{\textbackslash \textcolor{purple}{dsympyfact}}. |
| 566 |
|
| 567 |
Il vaut mieux vérifier si le résultat formaté est conforme aux attentes, et sinon utiliser la commande générique. |
| 568 |
\end{cautionblock} |
| 569 |
|
| 570 |
\begin{bloctext}[listing only] |
| 571 |
%commandes pour factoriser |
| 572 |
\sympyfact(*)<NoSimplif>{commande sympy} |
| 573 |
\dsympyfact(*)<NoSimplif>{commande sympy} |
| 574 |
\end{bloctext} |
| 575 |
|
| 576 |
\begin{tipblock} |
| 577 |
Concernant son fonctionnement : |
| 578 |
|
| 579 |
\begin{itemize} |
| 580 |
\item la version \Cle{*} permet de ne pas formater le \texttt{e} et le \texttt{i} en \textsf{romain} ; |
| 581 |
\item le premier argument, optionnel et pouvant valoir \texttt{<\textcolor{OliveDrab}{NoSimplif}>} permet d'\textit{annuler} la simplification (attention au comportement de la \textit{simplification} par \textsf{sympy}\ldots) |
| 582 |
\item le dernier argument, obligatoire et entre \texttt{\{...\}} est quant à lui la commande, en langage \textsf{sympy} à passer en \textsf{python}. |
| 583 |
\end{itemize} |
| 584 |
\vspace*{-\baselineskip}\leavevmode |
| 585 |
\end{tipblock} |
| 586 |
|
| 587 |
\begin{bloctext} |
| 588 |
On a $x^3-x^2+x-1 = \sympyfact{x**3-x**2+x-1}$ |
| 589 |
|
| 590 |
On a $\e^x-3\e^{2x} = \sympyfact{exp(x)-3*exp(2*x)}$ %typo [fr] |
| 591 |
|
| 592 |
On a $e^t-3e^{2t} = \sympyfact*{exp(t)-3*exp(2*t)}$ |
| 593 |
\end{bloctext} |
| 594 |
|
| 595 |
\subsection{Résolution d'équations} |
| 596 |
|
| 597 |
\begin{cautionblock} |
| 598 |
La commande pour résoudre (dans les réels) une équation, grâce à \textsf{sympy} est \texttt{\textbackslash \textcolor{purple}{sympyresol}} ou \texttt{\textbackslash \textcolor{purple}{dsympyresol}}. |
| 599 |
|
| 600 |
La commande pour résoudre (dans les complexes) une équation, grâce à \textsf{sympy} est \texttt{\textbackslash \textcolor{purple}{sympyresolC}} ou \texttt{\textbackslash \textcolor{purple}{dsympyresolC}}. |
| 601 |
\end{cautionblock} |
| 602 |
|
| 603 |
\smallskip |
| 604 |
|
| 605 |
\begin{importantblock} |
| 606 |
Pour cette commande, la simplification en \textsf{sympy} n'est pas \textit{désactivable}. |
| 607 |
|
| 608 |
\smallskip |
| 609 |
|
| 610 |
Pour \textit{forcer} les résultats sous forme exact (fractions), il vaut mieux écrire les nombres sous forme fractionnaire. |
| 611 |
|
| 612 |
\smallskip |
| 613 |
|
| 614 |
Il vaut mieux vérifier si le résultat formaté est conforme aux attentes, et sinon utiliser la commande générique. |
| 615 |
\end{importantblock} |
| 616 |
|
| 617 |
\begin{bloctext}[listing only] |
| 618 |
%commandes pour résoudre dans R |
| 619 |
\sympyresol(*){equation sympy}[variable] |
| 620 |
\dsympyresol(*){equation sympy}[variable] |
| 621 |
|
| 622 |
%commandes pour résoudre dans C |
| 623 |
\sympyresolC(*){equation sympy}[variable] |
| 624 |
\dsympyresolC(*){equation sympy}[variable] |
| 625 |
\end{bloctext} |
| 626 |
|
| 627 |
\begin{tipblock} |
| 628 |
Concernant son fonctionnement : |
| 629 |
|
| 630 |
\begin{itemize} |
| 631 |
\item la version \Cle{*} permet de ne pas formater le \texttt{e} et le \texttt{i} en \textsf{romain} ; |
| 632 |
\item le premier argument, obligatoire et entre \texttt{\{...\}} est quant à lui l'équation, en langage \textsf{sympy} à passer en \textsf{python} (avec le signe \texttt{=}) ; |
| 633 |
\item le second argument, optionnel et entre \texttt{[...]} est la variable. |
| 634 |
\end{itemize} |
| 635 |
\vspace*{-\baselineskip}\leavevmode |
| 636 |
\end{tipblock} |
| 637 |
|
| 638 |
\begin{bloctext} |
| 639 |
Les solutions de $x^2-3=\num{0.5}$ sont $\mathcal{S}=\dsympyresol{x**2-3=0.5}$ |
| 640 |
|
| 641 |
%mieux vaut passer par les écritures en fraction ;-) |
| 642 |
Les solutions de $x^2-3=\num{0.5}$ sont $\mathcal{S}=\dsympyresol{x**2-3=1/2}$ |
| 643 |
\end{bloctext} |
| 644 |
|
| 645 |
\begin{bloctext} |
| 646 |
Les solutions réelles de $x^3-2,5x+16x=40$ sont $\mathcal{S}=\dsympyresol{x**3-5/2*x**2+16*x = 40}$ |
| 647 |
|
| 648 |
Les solutions de $x^3-2,5x+16x=40$ sont $\mathcal{S}=\dsympyresolC{x**3-5/2*x**2+16*x = 40}$ |
| 649 |
\end{bloctext} |
| 650 |
|
| 651 |
\begin{bloctext} |
| 652 |
Les solutions de $10\,\e^{4x+5}=2$ sont $\mathcal{S}=\dsympyresol{10*exp(4*x+5)=2}$ |
| 653 |
\end{bloctext} |
| 654 |
|
| 655 |
\subsection{Dérivation locale} |
| 656 |
|
| 657 |
\begin{cautionblock} |
| 658 |
\cmaj{0.1.1} La commande pour dériver localement, grâce à \textsf{sympy} est \texttt{\textbackslash \textcolor{purple}{sympynbderiv}} ou \texttt{\textbackslash \textcolor{purple}{dsympynbderiv}}. |
| 659 |
|
| 660 |
Il vaut mieux vérifier si le résultat formaté est conforme aux attentes, et sinon utiliser la commande générique. |
| 661 |
\end{cautionblock} |
| 662 |
|
| 663 |
\begin{bloctext}[listing only] |
| 664 |
%commandes pour dériver localement |
| 665 |
\sympynbderiv(*)<NoSimplif>{expression sympy}[variable]{point}[côté] |
| 666 |
\dsympynbderiv(*)<NoSimplif>{expression sympy}[variable]{point}[côté] |
| 667 |
\end{bloctext} |
| 668 |
|
| 669 |
\begin{tipblock} |
| 670 |
Concernant son fonctionnement : |
| 671 |
|
| 672 |
\begin{itemize} |
| 673 |
\item la version \Cle{*} permet de ne pas formater le \texttt{e} et le \texttt{i} en \textsf{romain} ; |
| 674 |
\item le premier argument, optionnel et pouvant valoir \texttt{<\textcolor{OliveDrab}{NoSimplif}>} permet d'\textit{annuler} la simplification (attention au comportement de la \textit{simplification} par \textsf{sympy}\ldots) |
| 675 |
\item le deuxième argument, obligatoire et entre \texttt{\{...\}} est quant à lui l'expression en langage \textsf{sympy} à passer en \textsf{python} ; |
| 676 |
\item le troisième argument, optionnel et entre \texttt{[...]} est la variable ; |
| 677 |
\item les derniers arguments, obligatoire et entre \texttt{\{...\}} et optionnel entre \texttt{[...]} correspondent à la valeur (et la position \texttt{[g]} ou \texttt{[d]}) en laquelle on souhaite travailler. |
| 678 |
\end{itemize} |
| 679 |
\vspace*{-\baselineskip}\leavevmode |
| 680 |
\end{tipblock} |
| 681 |
|
| 682 |
\begin{bloctext} |
| 683 |
Si $f(x)=(x+3)\,\e^{2x}$, alors on peut montrer que $f'(2) = \sympynbderiv{(x+3)*exp(2*x)}{2}$ |
| 684 |
\end{bloctext} |
| 685 |
|
| 686 |
\begin{bloctext} |
| 687 |
Le nombre dérivé de la fonction $x \mapsto \sqrt{x}$ en $a=2$ vaut |
| 688 |
$\lim\limits_{x \to 2} \frac{\sqrt{x}-\sqrt{2}}{x-2} = \sympynbderiv{sqrt(x)}{2}$. |
| 689 |
|
| 690 |
Le nombre dérivé de la fonction $x \mapsto \sqrt{x}$ en $a=2$ vaut |
| 691 |
$\lim\limits_{x \to 2} \dfrac{\sqrt{x}-\sqrt{2}}{x-2} = \dsympynbderiv{sqrt(x)}{2}$. |
| 692 |
\end{bloctext} |
| 693 |
|
| 694 |
\begin{bloctext} |
| 695 |
Le nombre dérivé de $\varphi(x) = 1+\dfrac{1}{(x+2)^2}$ en $a=-5$ vaut |
| 696 |
$\lim\limits_{x \to -3} \frac{\varphi(x)-\varphi(-5)}{x-(-5)} = \sympynbderiv{1+1/(x+2)**2}{-5}$. |
| 697 |
|
| 698 |
Le nombre dérivé de $\varphi(x) = 1+\dfrac{1}{(x+2)^2}$ en $a=-5$ vaut |
| 699 |
$\lim\limits_{x \to -3} \dfrac{\varphi(x)-\varphi(-5)}{x-(-5)} = \dsympynbderiv{1+1/(x+2)**2}{-5}$. |
| 700 |
\end{bloctext} |
| 701 |
|
| 702 |
\subsection{Dérivation globale} |
| 703 |
|
| 704 |
\begin{cautionblock} |
| 705 |
La commande pour dériver, grâce à \textsf{sympy} est \texttt{\textbackslash \textcolor{purple}{sympyderiv}} ou \texttt{\textbackslash \textcolor{purple}{dsympyderiv}}. |
| 706 |
|
| 707 |
Il vaut mieux vérifier si le résultat formaté est conforme aux attentes, et sinon utiliser la commande générique. |
| 708 |
\end{cautionblock} |
| 709 |
|
| 710 |
\begin{bloctext}[listing only] |
| 711 |
%commandes pour dériver |
| 712 |
\sympyderiv(*)<NoSimplif>{expression sympy}[variable] |
| 713 |
\dsympyderiv(*)<NoSimplif>{expression sympy}[variable] |
| 714 |
\end{bloctext} |
| 715 |
|
| 716 |
\begin{tipblock} |
| 717 |
Concernant son fonctionnement : |
| 718 |
|
| 719 |
\begin{itemize} |
| 720 |
\item la version \Cle{*} permet de ne pas formater le \texttt{e} et le \texttt{i} en \textsf{romain} ; |
| 721 |
\item le premier argument, optionnel et pouvant valoir \texttt{<\textcolor{OliveDrab}{NoSimplif}>} permet d'\textit{annuler} la simplification (attention au comportement de la \textit{simplification} par \textsf{sympy}\ldots) |
| 722 |
\item le deuxième argument, obligatoire et entre \texttt{\{...\}} est quant à lui l'expression en langage \textsf{sympy} à passer en \textsf{python} ; |
| 723 |
\item le troisième argument, optionnel et entre \texttt{[...]} est la variable. |
| 724 |
\end{itemize} |
| 725 |
\vspace*{-\baselineskip}\leavevmode |
| 726 |
\end{tipblock} |
| 727 |
|
| 728 |
\begin{bloctext} |
| 729 |
Si $f(x)=(x+3)\,\e^{2x}$, alors on peut montrer que $f'(x) = \sympyderiv{(x+3)*exp(2*x)}$ |
| 730 |
\end{bloctext} |
| 731 |
|
| 732 |
\begin{bloctext} |
| 733 |
La dérivée de $g(t)=\ln\left(\dfrac{1+x}{1-x}\right)$ sur |
| 734 |
$\left]-1;1\right[$ est $g'(t) = \dsympyderiv<NoSimplif>{ln((1+t)/(1-t))}[t] |
| 735 |
= \dsympyderiv{ln((1+t)/(1-t))}[t]$ |
| 736 |
\end{bloctext} |
| 737 |
|
| 738 |
\begin{bloctext} |
| 739 |
La dérivée de $f(t)=t^2-8\ln(t)$ est |
| 740 |
$f'(t)= \dsympyderiv{t**2-8*log(t)}[t] = \dsympycalc<NoSimplif>{cancel(2*t-8/t)}$ |
| 741 |
\end{bloctext} |
| 742 |
|
| 743 |
\subsection{Intégration} |
| 744 |
|
| 745 |
\begin{cautionblock} |
| 746 |
Les commandes pour déterminer une primitive, grâce à \textsf{sympy} sont \texttt{\textbackslash \textcolor{purple}{sympyprim}} ou \texttt{\textbackslash \textcolor{purple}{dsympyprim}}. |
| 747 |
|
| 748 |
\smallskip |
| 749 |
|
| 750 |
Les commandes pour calculer une intégrale, grâce à \textsf{sympy} sont \texttt{\textbackslash \textcolor{purple}{sympyintegr}} ou \texttt{\textbackslash \textcolor{purple}{dsympysympyintegr}}. |
| 751 |
|
| 752 |
\smallskip |
| 753 |
|
| 754 |
Il vaut mieux vérifier si le résultat formaté est conforme aux attentes, et sinon utiliser la commande générique. |
| 755 |
\end{cautionblock} |
| 756 |
|
| 757 |
\begin{bloctext}[listing only] |
| 758 |
%commandes pour primitiver |
| 759 |
\sympyprim(*)<NoSimplif>{expr sympy}[variable] |
| 760 |
\dsympyprim(*)<NoSimplif>{expr sympy}[variable] |
| 761 |
|
| 762 |
%commandes pour intégrer |
| 763 |
\sympyintegr(*)<NoSimplif>{expr sympy}[variable]{borne inf}{borne sup} |
| 764 |
\dsympyintegr(*)<NoSimplif>{expr sympy}[variable]{borne inf}{borne sup} |
| 765 |
\end{bloctext} |
| 766 |
|
| 767 |
\begin{tipblock} |
| 768 |
Concernant son fonctionnement : |
| 769 |
|
| 770 |
\begin{itemize} |
| 771 |
\item la version \Cle{*} permet de ne pas formater le \texttt{e} et le \texttt{i} en \textsf{romain} ; |
| 772 |
\item le premier argument, optionnel et pouvant valoir \texttt{<\textcolor{OliveDrab}{NoSimplif}>} permet d'\textit{annuler} la simplification (attention au comportement de la \textit{simplification} par \textsf{sympy}\ldots) |
| 773 |
\item le deuxième argument, obligatoire et entre \texttt{\{...\}} est quant à lui l'expression en langage \textsf{sympy} à passer en \textsf{python} ; |
| 774 |
\item le troisième argument, optionnel et entre \texttt{[...]} est la variable ; |
| 775 |
\item les derniers arguments, obligatoires et entre \texttt{\{...\}} correspondent aux bornes d'intégration (pour l'intégrale !). |
| 776 |
\end{itemize} |
| 777 |
\vspace*{-\baselineskip}\leavevmode |
| 778 |
\end{tipblock} |
| 779 |
|
| 780 |
\begin{bloctext} |
| 781 |
Une primitive de la fonction $f(x)=(1+x)^2$ est $F(x) = \dsympyprim{(1+x)**2}$ |
| 782 |
|
| 783 |
Une primitive de la fonction $f(x)=(1+x)^2$ est $F(x) = \dsympyprim<NoSimplif>{(1+x)**2}$ |
| 784 |
|
| 785 |
Une primitive de la fonction $f(x)=(1+t)^2$ est $F(t) = \dsympyprim<NoSimplif>{(1+t)**2}[t]$ |
| 786 |
\end{bloctext} |
| 787 |
|
| 788 |
\begin{bloctext} |
| 789 |
On a $\displaystyle\int_1^3 (1+x)^2\,\text{d}x = \dsympyintegr{(1+x)**2}{1}{3}$ |
| 790 |
|
| 791 |
$I=\displaystyle\int_0^{4} (t+3)\,\e^{2t}\,\text{d}t = \dsympyintegr{(t+3)*exp(2*t)}[t]{0}{4}$ |
| 792 |
\end{bloctext} |
| 793 |
|
| 794 |
\subsection{Limites} |
| 795 |
|
| 796 |
\begin{cautionblock} |
| 797 |
Les commandes pour déterminer une limite, grâce à \textsf{sympy} sont \texttt{\textbackslash \textcolor{purple}{sympylim}} ou \texttt{\textbackslash \textcolor{purple}{dsympylim}}. |
| 798 |
|
| 799 |
\end{cautionblock} |
| 800 |
|
| 801 |
\begin{bloctext}[listing only] |
| 802 |
%commandes pour détemriner une limite |
| 803 |
\sympylim(*)<NoSimplif>{expr sympy}[variable]{point}[côté] |
| 804 |
\dsympylim(*)<NoSimplif>{expr sympy}[variable]{point}[côté] |
| 805 |
\end{bloctext} |
| 806 |
|
| 807 |
\begin{tipblock} |
| 808 |
Concernant son fonctionnement : |
| 809 |
|
| 810 |
\begin{itemize} |
| 811 |
\item la version \Cle{*} permet de ne pas formater le \texttt{e} et le \texttt{i} en \textsf{romain} ; |
| 812 |
\item le premier argument, optionnel et pouvant valoir \texttt{<\textcolor{OliveDrab}{NoSimplif}>} permet d'\textit{annuler} la simplification (attention au comportement de la \textit{simplification} par \textsf{sympy}\ldots) |
| 813 |
\item le deuxième argument, obligatoire et entre \texttt{\{...\}} est quant à lui l'expression en langage \textsf{sympy} à passer en \textsf{python} ; |
| 814 |
\item le troisième argument, optionnel et entre \texttt{[...]} est la variable ; |
| 815 |
\item les derniers arguments, obligatoire et entre \texttt{\{...\}} et optionnel entre \texttt{[...]} correspondent à la valeur (et la position \texttt{[g]} ou \texttt{[d]}) en laquelle on souhaite travailler. |
| 816 |
\end{itemize} |
| 817 |
\vspace*{-\baselineskip}\leavevmode |
| 818 |
\end{tipblock} |
| 819 |
|
| 820 |
\begin{bloctext} |
| 821 |
On a $\lim\limits_{x \to +\infty} \dfrac{1+\e^x}{x^2+1} = \sympylim{(1+exp(x))/(x**2+1)}{+oo}$ |
| 822 |
\end{bloctext} |
| 823 |
|
| 824 |
\begin{bloctext} |
| 825 |
On a $\lim\limits_{x \to 1^+} \dfrac{x+2}{x^2-1} = \sympylim{(x+2)/(x**2-1)}{1}[d]$ |
| 826 |
|
| 827 |
On a $\lim\limits_{x \to 1^-} \dfrac{x+2}{x^2-1} = \sympylim{(x+2)/(x**2-1)}{1}[g]$ |
| 828 |
\end{bloctext} |
| 829 |
|
| 830 |
\begin{bloctext} |
| 831 |
On a $\lim\limits_{x \to +\infty} \sqrt{\dfrac{2x^2+1}{x^2-5}} = \sympylim{sqrt((2*x**2+1)/(x**2-5))}{+oo}$ |
| 832 |
\end{bloctext} |
| 833 |
|
| 834 |
\subsection{Forme exponentielle d'un complexe} |
| 835 |
|
| 836 |
\begin{cautionblock} |
| 837 |
La commande pour déterminer une forme exponentielle, grâce à \textsf{sympy} est \texttt{\textbackslash \textcolor{purple}{sympyfexpo}} ou \texttt{\textbackslash \textcolor{purple}{dsympyfexpo}}. |
| 838 |
|
| 839 |
Il vaut mieux vérifier si le résultat formaté est conforme aux attentes, et sinon utiliser la commande générique. |
| 840 |
\end{cautionblock} |
| 841 |
|
| 842 |
\begin{bloctext}[listing only] |
| 843 |
%commandes pour détemriner une forme exponentielle |
| 844 |
\sympyfexpo(*)<NoSimplif>{complexe sympy} |
| 845 |
\dsympyfexpo(*)<NoSimplif>{complexe sympy} |
| 846 |
\end{bloctext} |
| 847 |
|
| 848 |
\begin{tipblock} |
| 849 |
Concernant son fonctionnement : |
| 850 |
|
| 851 |
\begin{itemize} |
| 852 |
\item la version \Cle{*} permet de ne pas formater le \texttt{e} et le \texttt{i} en \textsf{romain} ; |
| 853 |
\item le premier argument, optionnel et pouvant valoir \texttt{<\textcolor{OliveDrab}{NoSimplif}>} permet d'\textit{annuler} la simplification (attention au comportement de la \textit{simplification} par \textsf{sympy}\ldots) |
| 854 |
\item le second argument, obligatoire et entre \texttt{\{...\}} est quant à lui le complexe en version \textsf{sympy} à passer en \textsf{python}. |
| 855 |
\end{itemize} |
| 856 |
\vspace*{-\baselineskip}\leavevmode |
| 857 |
\end{tipblock} |
| 858 |
|
| 859 |
\begin{bloctext} |
| 860 |
On a $1+\i = \dsympyfexpo{1+I}$ |
| 861 |
|
| 862 |
On a $3+\i\sqrt{3} = \dsympyfexpo{3+I*sqrt(3)}$ |
| 863 |
|
| 864 |
On a $\dfrac{-\sqrt{2}}{1+\i} = \dsympyfexpo{(-sqrt(2))/(1+I)}$ |
| 865 |
\end{bloctext} |
| 866 |
|
| 867 |
\newpage |
| 868 |
|
| 869 |
\part{Historique et évolutions} |
| 870 |
|
| 871 |
\section{Évolutions} |
| 872 |
|
| 873 |
\begin{tipblock} |
| 874 |
L'utilisateur du package pourra utiliser ses propres fonctions ou commandes \textsf{sympy}, qui pourront être déclarés grâce à l'environnement \texttt{pythonq}. |
| 875 |
\end{tipblock} |
| 876 |
|
| 877 |
\begin{bloctext}[listing only] |
| 878 |
\begin{pythonq} |
| 879 |
def tangente_exacte(expr,var,a) : |
| 880 |
fdea = expr.subs(var,a) |
| 881 |
fprimedea = limit((expr-fdea)/(var-a),var,a) |
| 882 |
tgte = expand(fprimedea*(x-a) + fdea) |
| 883 |
return tgte |
| 884 |
|
| 885 |
\end{pythonq} |
| 886 |
\end{bloctext} |
| 887 |
|
| 888 |
\begin{pythonq} |
| 889 |
def tangente_exacte(expr,var,a) : |
| 890 |
fdea = expr.subs(var,a) |
| 891 |
fprimedea = limit((expr-fdea)/(var-a),var,a) |
| 892 |
tgte = expand(fprimedea*(x-a) + fdea) |
| 893 |
return tgte |
| 894 |
|
| 895 |
\end{pythonq} |
| 896 |
|
| 897 |
\begin{bloctext} |
| 898 |
La tangente à la courbe de la fonction $f(x)=\e^{2x}+3$ en $a=1$ a pour équation :\\ |
| 899 |
$y = \sympycalc{tangente_exacte(exp(2*x)+3,x,1)}$. |
| 900 |
\end{bloctext} |
| 901 |
|
| 902 |
\begin{bloctext} |
| 903 |
La tangente à la courbe de la fonction $g(t)=\ln(x+3)$ en $a=4$ a pour équation :\\ |
| 904 |
$y = \dsympycalc{tangente_exacte(log(t+3),t,4)}$. |
| 905 |
\end{bloctext} |
| 906 |
|
| 907 |
\section{Historique} |
| 908 |
|
| 909 |
\verb|v0.1.1|~:~~~~Commandes pour les nombres dérivés + images. |
| 910 |
|
| 911 |
\verb|v0.1.0|~:~~~~Version initiale. |
| 912 |
|
| 913 |
|
| 914 |
|
| 915 |
|
| 916 |
|
| 917 |
\end{document} |