WXmaxima simplification d'une expression...

[curieuxdenature]

Bonjour,
Je cherche à simplifier le résultat pondu par WXmaxima sans succès.
Elle est pourtant toute simple :

..........(2^(5/2)*sqrt(%pi));

avec laquelle je m'attendais à afficher un truc un peu plus joli du genre sqrt(32 * %pi)

mais pas moyen, ratsimp(), fullratsimp(), combine(), et même des ordres au p'tit bonheur la chance.
Il m'est arrivé de trouver des soluces en parcourant scrupuleusement la doc pdf mais là j'ai pas eu de chance
J'ai même élevé les résultat au carré (ce qui fonctionne --> 32 * %pi) mais quand j'applique sqrt() rebelote, je retrouve mon fameux 2^(5/2)...
Si vous avez une idée, je suis preneur avec mon admiration
-----

[curieuxdenature]

je peux donner le source complet si ça interresse...

[umfred]

ça pourrait être bien de préciser au moins le langage. (mais bon on tombe sur https://wxmaxima-developers.github.i...xima/help.html avec une recherche
Mais ça donne la même chose non ? 2^(5/2) = sqrt(2^5)= sqrt(32)
Regarde peut-être les flags de simplification ratexpand ou ceux liés à sqrt, en particulier celui-ci https://maxima.sourceforge.io/docs/m...x-sqrtdispflag

[ThM55]

Pour commencer, le langage n'est pas wxmaxima. C'est Maxima. Wxmaxima est une interface graphique qui donne un rendu des expressions mathématiques, des graphes, etc.

Ensuite il faut s'entendre sur le concept de simplification. Quand considère-t-on qu'une expression est plus simple qu'une autre? Souvent c'est assez subjectif ou une affaire de goût. Et ce que vous considérez comme plus simple n'est pas forcément ce que les concepteurs du logiciel ont choisi.

Pour cela, il faut d'abord lire le manuel de Maxima. Ici la page sur la simplification: https://maxima.sourceforge.io/docs/m...Simplification

Par exemple la fonction ratsimp ne donnera aucun résultat ici puisque son but, expliqué dans le manuel, est de transformer autant que possible et de manière récursive une expression sous la forme d'un quotient de deux polynômes dont les variables peuvent être des fonctions non rationnelles (comme des sinus, logarithmes, etc). C'est juste un choix de forme des expressions qui est souvent considéré comme plus "simple" à comprendre. Dans le cas présent, cela n'a évidemment rien à voir avec le but d'obtenir une expression de cette forme.

La fonction radcan semble plus adaptée. Elle convertit les expressions comprenant des radicaux et des exposants à une "forme canonique". Canonique ici signifie ce que les programmeurs ont décidé, pas ce que vous avez décidé. Et manifestement la forme 2^(5/2)*sqrt(%^pi) est considérée comme canonique alors que sqrt(2^5*%pi) ne l'est pas.

Cela dit, radcan est soumis au contrôle de la variable radexpand, qui peut prendre les valeurs true, false et all. Par défaut elle vaut true. Si vous la positionnez à false (avec radexpand:false l'assignation de variable se fait avec deux points), et vous tapez sqrt(32*%pi), il imprimera . Mais radcan donne toujours la forme canonique , donc cette variable n'a pas un effet très fort dans ce cas.

Personnellement, concernant les simplifications, j'ai trouvé qu'il était souvent très utile d'apprendre et de mettre en pratique la fonction scsimp. Elle permet d'appliquer des transformations simplifiant des expressions en fonction de règles qu'on lui fournit (par exemple des identités qu'on désire appliquer). La commande examples (scsimp) permet de voir quelques exemples. La commande examples est utile en général quand on veut apprendre une fonction de Maxima.

Maxima est un bel outil pour son prix de zéro dollars, toutefois moins performant que les concurrents beaucoup plus chers. Mais il ne faut pas essayer des choses au hasard, il faut souvent chercher les solutions en ayant recours au manuel et aux exemples, et aussi noter ce qu'on a appris pour ne pas l'oublier.
Bonne chance!

[A voir en vidéo sur Futura]

[curieuxdenature]

Bonjour

Merci ThM55, Maxima est un excellent logiciel de calcul formel, j'ai vu qu'il permettait de contourner pas mal de cas spéciaux dans les résultats.
Aux niveau des applications numériques, pas de problème mais avec les expressions ça me parait un peu bizarre parfois.
Le cas 2^(5/2) me laisse perplexe car avec le même processus j'obtiens par exemple '8 sqrt(Pi)' au lieu de '2^(6/2) sqrt(Pi)', d'ailleurs pourquoi pas afficher 'sqrt(64 Pi)' ou encore '(64*Pi)^1/2', c'est tout de même plus joli dans une suite...
Je te laisse juge :

f100 = e^-r/sqrt(pi)
f200 = -(((r-2)*e^-(r/2))/(2^(5/2)*sqrt(pi)))
f210 = (e^-(r/2)*z)/(2^(5/2)*sqrt(pi))
f211 = (e^-(r/2)*x)/(8*sqrt(pi))
f300 = ((2*r^2-18*r+27)*e^-(r/3))/(3^(9/2)*sqrt(pi))

que j'ai corrigé à la main

f100 = Exp(-r) / sqr(Pi)
f200 = (2 - r) * Exp(-r / 2) / Sqr(32 * Pi)
f210 = z * Exp(-r / 2) / Sqr(32 * Pi)
f211 = x * Exp(-r / 2) / Sqr(64 * Pi)
f300 = (2 * r ^ 2 - 18 * r + 27) * Exp(-r / 3) / Sqr(19683 * Pi)

Mais bon, je continue à chercher, avec un peu de chance j'aurais une astuce de plus à noter.

[ThM55]

Si tu connais Lisp, c'est open source. Tu peux examiner les algorithmes et même les modifier si cela ne te fais pas peur. Une partie est d'ailleurs écrite dans le langage Maxima et on peut soi-même ajouter des fonctions dans ce langage. Voir le manuel.

[umfred]

Le cas 2^(5/2) me laisse perplexe car avec le même processus j'obtiens par exemple '8 sqrt(Pi)' au lieu de '2^(6/2) sqrt(Pi)', d'ailleurs pourquoi pas afficher 'sqrt(64 Pi)' ou encore '(64*Pi)^1/2', c'est tout de même plus joli dans une suite...

sûrement parce que sqrt(64) donne un entier (8) mais pas sqrt(32) qui donne 5.65685........ donc pourquoi s'embêter avec des puissances quand le résultat d'une opération donne un entier

[curieuxdenature]

Re

j'utilise les fonctions, par exemple :

/* substitution des formules pour simplification */
radsubstflag :true$                                                                          /* permet à ratsubst de remplacer x aussi dans sqrt(x), inutile ici */
f_1(as)   := radcan(realpart(trigexpand(demoivre(as)))) $
f_2(at)   := ratsubst(z, r * cos(theta)                   , f_1(at)) $            /* [z] remplacera les occurences de [r * cos(theta)]  contenus dans f_1(as)  */
f_3(au)  := ratsubst(x, r * sin(theta) * cos(phi), f_2(au)) $               /* correctement remplacé aussi */
f_4(av)  := ratsubst(y, r * sin(theta) * sin(phi), f_3(av)) $                /* ça merdouille celui-là, jamais affiché avec [for m : -k thru k do], trouve autre chose... */
f_5(aw) := ratsubst(RacineDePi, sqrt(%pi), f_4(aw)) $                    /* ça c'est OK... */   
f_6(ax)  := ratsubst(32, sqrt(2^5), f_5(ax)) $                                /* en revanche, ça et rien... je suppose que les nombres purs ne peuvent pas etre utilisés */
f_10(af) := ratsimp(radcan(  f_6 (f_5(f_4(f_3(f_2(f_1(af)))))))) $

résultat:

f100 = %e^-r/RacineDePi
f200 = -(((r-2)·%e^-(r/2))/(2^(5/2)·RacineDePi))
f210 = (%e^-(r/2)·z)/(2^(5/2)·RacineDePi)
f211 = (%e^-(r/2)·x)/(8·RacineDePi)
f300 = ((2·r^2-18·r+27)·%e^-(r/3))/(3^(9/2)·RacineDePi)

y a surement un truc intéressant à trouver.
Merci en tous cas.