quelqu´un pourrait-il m´expliquer pourquoi mon logiciel de calcul formel (Maple V4) met beaucoup plus de temps pour effectuer un calcul qu´un programme similaire écrit en pascal ? La boucle que j´ai programmée est pourtant identique. C´est normal (la différence est vraiment conséquente) ?

la raison est simple : maple est très mauvais (et ça ne va qu´en empirant avec les versions plus récente)...

Plus sérieusement, maple va interpréter la fonction que tu lu donne, ce qui est déjà bien plus lent que ton programme pascal qui lui va d´abord la compiler et ensuite l´exécuter nativement. D´autre part si tu n´a pas truffer ton code maple de evalf, alors la plupart des calculs seront fait symboliquement et ça, c´est des milliers de fois plus long que de faire des calculs approché.
En fait maple est "doué" (et encore) pour le calcul formel, mais pas du tout pour faire des bêtes calculs numérique.

Pour ce genre de chose, utilise plutot SciLab, qui en plus d´être gratuit, est performant (ou alors, continu à utiliser du pascal, c´est très bien aussi).

Moralité, pour de la vitesse pure il faut faire du C ou du pascal, pour faire des calculs en haute précisions SciLab (ou l´un des langages précédent avec une bibliothèque spécialisé), et pour faire du calcul formel maple peut aller (mais mupad est beaucoup moins chère, et là aussi, il existe des bibliothèque prévues pour).

a oui j´avais plus pensé à la valeur approchée...

merci pour les infos.

Hum ! Moi personnellement, j´adore Maple Il m´a dépanné des milliers de fois, pour faire du calcul formel !

Mais comme dit Dnob, il faut utiliser le bon outil pour ce que tu veux faire !

Si tu veux juste faire du numérique, Maple sort le gros burrin pour le faire, et donc est tres lent.

Mais si tu veux résoudre une équation complexe, dériver, etc... Maple tue tout

Evidemment, Maple n´est pas réputé pour sa vitesse, ça...

ok.

en fait je m´étais juste poser la question sans trop réfléchir, car j´avais dû attendre très très longtemps en Maple, et le même programme en Pascal donnait un résultat en moins de 3s.

puisque j´ai créé un topic j´en profite pour poser une autre question : Lors de mes calculs, Pascal me renvoit parfois des nombres négatifs lors d´une multiplication de deux entiers positifs... Plutôt génant. J´ai lu que le problème venait de la taille du nombre renvoyé, qui ne tient pas sur le format (longint en l´occurence) défini.
Ce que je ne comprends pas, c´est qu´il me le fait lorsque je calcule x*x mod m (avec x et m plutôt grands), mais pas quand je calcule (par exemple) 1004578*x mod m avec x qui prendra pourtant une valeur élévée à un moment ou à un autre....
C´est un simple hasard ou une incompréhension de ma part ?
On peut y remédier ? Je pensais que ce problème n´interviendrait pas du fait des modulo...

plutot que de faire x*x mod m, essaye (x mod m)*(x mod m) mod m. Si m n´est pas trop grand (pas plus que la racine carré du plus grand entier qui peut être stoké dans un longint (je ne sais pas quelle est la taille de cette structure de donnée)) alors ça ira, ça restera positif.

Mais sinon, si x*x est trop grand, le résultat est stocké sous forme de nombre négatif et le résultat du modulo l´est aussi (c´est juste une convention du compilo), de toute manière, ça ne change rien, le résultat sera faux.

Peut-être existe-t-il en pascal comme en C,des type non signé du genre unsigned longint, qui permettent de stocker des nombre un tout petit peu plus grand (deux fois plus grand en fait).
Mais là, fait attention, tu n´aura pas de moyen simple de savoir si le résultat que tu obtient est juste ou si c´est n´importe à cause d´un débordement de capacité du type utilisé.

Sinon, si ça ne te suffit pas il te faudra utiliser une bibliothèque spécialisé pour ça.

La vache, ça fait un bail que je n´ai pas programmé en Pascal, y´a encore des restes, mais y´a des choses que j´avaient complètement oubliées !

Les types entiers sont :
- integer (-2147483648 -> 2147483647)
- cardinal (0 -> 4294967295)
- shortint (-128 -> 127)
- smallint (-32768 -> 32767)
- longint (-2147483648 -> 2147483647)
- int64 (-2^63 -> 2^63-1)
- byte (0 -> 255)
- word (0 -> 65535)
- longword (0 -> 4294967295)

Les types réels sont :
- real (5.0 x 10^-324 -> 1.7 x 10^308)
- real48 (2.9 x 10^-39 -> 1.7 x 10^38)
- single (1.5 x 10^-45 -> 3.4 x 10^38)
- double (5.0 x 10^-324 -> 1.7 x 10^308)
- extended (3.6 x 10^-4951 -> 1.1 x 10^4932)
- comp (-2^63+1 -> 2^63-1)
- currency (-922337203685477.5808 -> 922337203685477.5807)

Personnellement, j´utilisait les réels pour faire mes calculs et si j´avais besoin d´un entier, je faisais un arrondi.

à toi de voir

(réf. : Le programmeur - Delphi7 - CampusPress Editions)

Le problème des réels est qu´ils ne sont pas exact., certes tu poeux compter jusqu´a 10^308, mais tu ne peux pas coder:
100000000000000001 différement de 100000000000000000.

Ca ne convient donc probablement pas a quelqu´un qui cherche a faire du calcul exact dans Z/mZ.

Pour la question de base, regarde du coté de la lib BLAS. Je penses qu´elle fait du calcul sci a précision arbitraire.

les calculs sont plus précis avec des entiers

Pour la question de base, regarde du coté de la lib BLAS. Je penses qu´elle fait du calcul sci a précision arbitraire.

-> c´est à dire ?
(je peux trouver ca où, pour faire quoi concrètement ?)

"Les calculs sont plus précis avec des entiers"
les calcul sur réel sont ne sont pas précis. Ils sont précis a 12 chiffres (de mémoire, on peu confirmer en lisant la norme IEEE s´y rapportant.)

Mea culpa poyur BLAS, ca ne fait pas de calcul sur grand entiers. regarde du coté de la lib bigint:
http://www.lifl.fr/~marquet/ens/cu/bigint.html

les calcul sur des int64 sont plus précis qu´avec des réel. Sinon, ça doit être kifkif (sauf à utiliser de vrai double double)

oups, l´url que j´ai donné est un TP de construction d´une lib big int (ce qui n´est pas tout a fait ce que tu cherches).
regardes le paquet debian libcnumx0-dev, de Big_int(
http://valyala.narod.ru/big_int/), et de GMP (
http://www.swox.se/gmp/)