Apprendre Maple Index du Forum Apprendre Maple
Site dédié au logiciel de calcul formel Maple
 
  Page d'accueilPage d'accueil   FAQFAQ    RechercherRechercher    Liste des MembresListe des Membres    Groupes d'utilisateursGroupes d'utilisateurs 
S'enregistrerS'enregistrer    ProfilProfil   Se connecter pour vérifier ses messages privésSe connecter pour vérifier ses messages privés   ConnexionConnexion 

Sauvegarder une liste dans le noyau de Maple

 
Poster un nouveau sujet   Répondre au sujet    Apprendre Maple Index du Forum -> Séquences, listes, ensembles, tables ou tableaux...
Voir le sujet précédent :: Voir le sujet suivant  
Auteur Message
Guimzo



Inscrit le: 02 Juin 2012
Messages: 198

MessagePosté le: 09 Avr 2017 15:00    Sujet du message: Sauvegarder une liste dans le noyau de Maple Répondre en citant

Bonjour ALS : )
Que le temps passe : )
J'espère que ça va ; cela fait si longtemps : )
Je viens vous solliciter s'il vous plaît pour savoir comment serait-il possible de sauvegarder une Liste de nombre et de pouvoir utiliser cette Liste selon les besoins au cours d'une procédure ?

Exemple :
Si je calcule avec Maple une liste de puissance de 2 de 1 à 20 telle que
L:=seq(2**k,k=1..20);

Comment sauvegarder la Liste dans une sorte de "package" ou de "librairie", ce qui éviterait Maple de faire ce calcul si j'ai ultérieurement besoin d'inclure cette liste de nombres dans une séquence.

Je sais qu'une solution serait de sauvegarder sous forme de fichier texte dans word ou autre et de faire un copier/coller à chaque fois, mais n'y aurait-il pas une astuce dans Maple pour sauvegarder directement ladite liste ?

Ainsi au lieu de faire une séquence telle que :

(1)
restart;
Digits:=1000;
p:=(799);
L:=seq(2**k,k=1..20):
Res:=seq(i/p,i=L);

On ferait juste :

(2)
restart;
Digits:=1000;
p:=(799);
L:="Liste2":
Res:=seq(i/p,i=L);

Ainsi dans (1) Même si Maple n'affiche pas de résultats, il calcule L:=seq(2**k,k=1..20):
Alors que dans (2), Maple ne ferait plus le calcul de L:=seq(2**k,k=1..20): mais irait chercher cette liste déjà calculée et enregistrée.
Voilà voilà,
À bientôt Professeur : )
Revenir en haut de page
Voir le profil de l'utilisateur Envoyer un message privé
ALS



Inscrit le: 11 Sep 2006
Messages: 624

MessagePosté le: 10 Avr 2017 6:19    Sujet du message: Répondre en citant

Bonjour, j'espère que vous allez bien.
Je vous propose d'utiliser les fonctions d'enregistrement et de lecture de données writedata et readdata (j'ai spécifié le format "integer" pour des nbs entiers).
On est obligés de donner le chemin f du fichier (à modifier selon votre propre configuration).

Code:

>  # Enregistrement d'une liste d'entiers dans un fichier f :
> L:=[seq(2**k,k=1..20)]:
> f:="C:\\Documents and Settings\\Alain\\Mes documents\\Maple\\exemple.dat":
> writedata(f,L,integer);

>  # Lecture de la liste enregistrée et poursuite des calculs:
> restart:
> Digits:=1000;
> p:=(799);
> f:="C:\\Documents and Settings\\Alain\\Mes documents\\Maple\\exemple.dat":
> L:=readdata(f,integer);
> Res:=seq(i/p,i=L);

                            Digits := 1000


                               p := 799


  L := [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192,

        16384, 32768, 65536, 131072, 262144, 524288, 1048576]


                              16   32   64   128  256  512  1024
  Res := 2/799, 4/799, 8/799, ---, ---, ---, ---, ---, ---, ----,
                              799  799  799  799  799  799  799

        2048  4096  8192  16384  32768  65536  131072  262144  524288
        ----, ----, ----, -----, -----, -----, ------, ------, ------,
        799   799   799    799    799    799    799     799     799

        1048576
        -------
          799


J'espère que ça convient, c'est plus simple que de passer par les librairies.
Revenir en haut de page
Voir le profil de l'utilisateur Envoyer un message privé
Guimzo



Inscrit le: 02 Juin 2012
Messages: 198

MessagePosté le: 10 Avr 2017 20:45    Sujet du message: Sauvegarder une liste dans le noyau de Maple Répondre en citant

Bonjour ALS,
Comme d'habitude, vous n'avez que des solutions : )
Merci beaucoup, ça marche nickel : )
À bientôt, All the best ; )
Revenir en haut de page
Voir le profil de l'utilisateur Envoyer un message privé
Guimzo



Inscrit le: 02 Juin 2012
Messages: 198

MessagePosté le: 11 Avr 2017 21:16    Sujet du message: Sauvegarder une liste dans le noyau de Maple Répondre en citant

Bonsoir ALS,

Par tout hasard, en relation avec le post, connaitriez-vous un site où on pourrait trouver des bases de données pour Maple, ou des bases de données mathématiques tout simplement, par exemple une Liste g ainsi calculée :
======================================
restart;
Digits := 1000;
a := [seq(ithprime(k), k = 1 .. 10000)]:
Quantité := nops(a);
with(combinat):
d := choose(a, 3):
N := nops(d);
with(ListTools):
e := [seq(convert(d[i], `*`), i = 1 .. N)]:
h := convert(e, set):
Diviseurs := nops(h);
g:=convert(h,list);

====================================

Une base donnée qui donnerait la liste "g" ici ; c'est à dire ce genre de base de donnée ?
Vu que Binomial(10000,3) = 166616670000 ; "g" est impossible à calculer avec mon ordi...
Un fichier où cette Liste serait disponible et d'autres listes de ce genre ?
À bientôt
P.S.: J'ai regardé un peu sur google, mais que des liens vers des bibliothèques, et pas vraiment ce genre de listes...
Revenir en haut de page
Voir le profil de l'utilisateur Envoyer un message privé
ALS



Inscrit le: 11 Sep 2006
Messages: 624

MessagePosté le: 12 Avr 2017 7:34    Sujet du message: Répondre en citant

Bonjour Guimzo,

Je vous suggère une autre approche complètement différente que de passer par un tel site, s'il existe ?

Ce qui pose problème est la fonction choose qui sature la mémoire quand on prend un trop grand nombre d'entiers premiers dans a, 10000 en l'occurrence dans votre exemple.

Je propose de réécrire cette fonctionnalité de manière récursive en programmant 2 procédures.

La procédure ajout (e,L::list(list)) rend pour résultat la liste de listes obtenue en ajoutant l'élément e comme premier élément à chacune des listes composant L.

La procédure récursive comb (p::nonnegint,e::list) rend pour résultat la liste des parties à p éléments de l'ensemble e (combinaisons).

Je l'ai testée avec succès pour a := [seq(ithprime(k), k = 1 .. 100)]:
A vous d'être patient en la testant pour 1000 ou 10000.
J'ai bien peur hélàs que ça pourrait ne pas fonctionner (pb de mémoire?).

A bientôt.

ALS

Voici le code de ces 2 procédures :

Code:

restart:
> ajout:=proc(e,L::list(list))
>         local i,M;
>         M:=NULL;
>         for i in L do
>             M:=M,[e,op(i)]
>         end do;
>         [M]
>  end proc:

 
>  ajout(a,[[b,c,d],[alpha,beta],[],[1,2,3,4]]);

        [[a, b, c, d], [a, alpha, beta], [a], [a, 1, 2, 3, 4]]

> comb:=proc(p::nonnegint,e::list)
>         local x,f;
>         if p>nops(e) then []
>         else
>             if p=0 then [[]]
>             else
>                 x:=e[1]; f:=subsop(1=NULL,e);
>                 [op(ajout(x,procname(p-1,f))),op(procname(p,f))]
>             end if;
>         end if;
> end proc:

 
> comb(3,[a,b,c,d,e,f]);

  [[a, b, c], [a, b, d], [a, b, e], [a, b, f], [a, c, d], [a, c, e],

        [a, c, f], [a, d, e], [a, d, f], [a, e, f], [b, c, d],

        [b, c, e], [b, c, f], [b, d, e], [b, d, f], [b, e, f],

        [c, d, e], [c, d, f], [c, e, f], [d, e, f]]

> a := [seq(ithprime(k), k = 1 .. 100)]:

> d := comb(3, a);

Revenir en haut de page
Voir le profil de l'utilisateur Envoyer un message privé
Guimzo



Inscrit le: 02 Juin 2012
Messages: 198

MessagePosté le: 12 Avr 2017 22:06    Sujet du message: Sauvegarder une liste dans le noyau de Maple Répondre en citant

Bonsoir ALS,
Merci pour les procédures, faut que j'essaie, je reviens vers vous demain, plus amplement,
Portez-vous bien Professeur : )
Revenir en haut de page
Voir le profil de l'utilisateur Envoyer un message privé
Guimzo



Inscrit le: 02 Juin 2012
Messages: 198

MessagePosté le: 13 Avr 2017 21:49    Sujet du message: Sauvegarder une liste dans le noyau de Maple Répondre en citant

Bonsoir ALS,
Je n'ai pas du tout compris les procédures, mais elles fonctionnent à merveille : )
Il n'y avait que vous pour concevoir un truc pareil : )
Je suis en train d'essayer avec 1000, pour l'instant 311,48 Mo de mémoire utilisée et 15568 secondes... ça tourne toujours...

P.S.1: Pour l'instant j'utilise un Dell T3500 avec 12 Go de mémoire ECC ( plus fiable que la mémoire classique, mais plus lente, dû au temps de correction des erreurs...) couplé avec un Processeur Xéon W3565 à 4 coeurs...Des que je pourrais je prendrais un appareil que j'ai repéré sur Ebay avec 2 processeurs Xéons de 8 coeurs chacun, et capable de monter jusqu'à 192 Go de Ram... un HP Z820 ou un Dell T7600...

P.S.2: ALS, si vous partez en camping cet été, tenez moi au courant s'il vous plaît, on pourrait peut-être s'y croiser, si cela vous dit, histoire de faire une belotte le soir, à la belle étoile : )

P.S.3: Merci pour tout et à bientôt Professeur : )
Revenir en haut de page
Voir le profil de l'utilisateur Envoyer un message privé
ALS



Inscrit le: 11 Sep 2006
Messages: 624

MessagePosté le: 14 Avr 2017 6:15    Sujet du message: Répondre en citant

Bonjour,

Explication sur la procédure ajout : elle reçoit une variable e de n'importe quel type et une liste de listes L, comme paramètres formels. La procédure, grâce à la boucle for i in L, passe en revue chaque élément i (liste) constituant L et y rajoute l'élément e. Le résultat [e,op(i)] de cet ajout est alors rajouté à la séquence M, initialement vide, par le code : M:=M,[e,op(i)]. Une fois la boucle exécutée, on sort avec la liste de listes [M] pour résultat.

Exemple, si e=a et L=[[b,c,d],[alpha,beta],[],[1,2,3,4]], on aura pour résultat [M] = [[a, b, c, d], [a, alpha, beta], [a], [a, 1, 2, 3, 4]].

Explication sur la procédure comb : elle reçoit un entier p>=0 et une liste e comme paramètres formels. Elle est récursive, car on va se servir de la procédure au rang p-1 pour construire la procédure au rang p.
Pour les cas particuliers où p>nops(e) où p=0, le résultat sera respectivement [] et [[]], sinon on récupère le premier élément x:=e[1] de e, et on enlève le premier élément de e grâce au code : f:=subsop(1=NULL,e);

La ligne suivante très difficile à comprendre, je le conçois, est le coeur de la procédure. Tout d'abord, elle contient 2 fois le mot réservé procname, qui est l'équivalent du nom de la procédure courante, c'est à dire comb en l'occurrence.
Il y a donc récursivité à deux niveaux : pour construire comb(p,e), on va utiliser à la fois comb(p-1,f) et comb(p,f).
On ajoute x à comb(p-1,f), on transforme la liste obtenue en séquence par op(ajout(x,procname(p-1,f))). On ajoute à cette séquence la séquence op(procname(p,f)).
La pile du calculateur va ainsi être utilisée à plein régime, puisqu'on va descendre ainsi plusieurs niveaux en empilant les arguments aux niveaux p, p-1, p-2, p-3, etc... jusqu'à p=0, valeur qui va délencher un résultat [[]] et la phase de dépilement, c'est à dire de remontée aux niveaux 1,2, etc... jusqu'à p.

Observons ce qui se passe en traçant la procédure comb et en exécutant
comb(3,[a,b,c,d,e,f]);

Code:


> trace(comb); comb(3,[a,b,c,d,e,f]);
                                 comb

{--> enter comb, args = 3, [a, b, c, d, e, f]

                                x := a


                         f := [b, c, d, e, f]

{--> enter comb, args = 2, [b, c, d, e, f]

                                x := b


                          f := [c, d, e, f]

{--> enter comb, args = 1, [c, d, e, f]

                                x := c


                            f := [d, e, f]

{--> enter comb, args = 0, [d, e, f]

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, [d, e, f]

                                x := d


                             f := [e, f]

{--> enter comb, args = 0, [e, f]

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, [e, f]

                                x := e


                               f := [f]

{--> enter comb, args = 0, [f]

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, [f]

                                x := f


                               f := []

{--> enter comb, args = 0, []

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, []

                                  []

<-- exit comb (now in comb) = []}

                                [[f]]

<-- exit comb (now in comb) = [[f]]}

                              [[e], [f]]

<-- exit comb (now in comb) = [[e], [f]]}

                           [[d], [e], [f]]

<-- exit comb (now in comb) = [[d], [e], [f]]}

                         [[c], [d], [e], [f]]

<-- exit comb (now in comb) = [[c], [d], [e], [f]]}
{--> enter comb, args = 2, [c, d, e, f]

                                x := c


                            f := [d, e, f]

{--> enter comb, args = 1, [d, e, f]

                                x := d


                             f := [e, f]

{--> enter comb, args = 0, [e, f]

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, [e, f]

                                x := e


                               f := [f]

{--> enter comb, args = 0, [f]

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, [f]

                                x := f


                               f := []

{--> enter comb, args = 0, []

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, []

                                  []

<-- exit comb (now in comb) = []}

                                [[f]]

<-- exit comb (now in comb) = [[f]]}

                              [[e], [f]]

<-- exit comb (now in comb) = [[e], [f]]}

                           [[d], [e], [f]]

<-- exit comb (now in comb) = [[d], [e], [f]]}
{--> enter comb, args = 2, [d, e, f]

                                x := d


                             f := [e, f]

{--> enter comb, args = 1, [e, f]

                                x := e


                               f := [f]

{--> enter comb, args = 0, [f]

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, [f]

                                x := f


                               f := []

{--> enter comb, args = 0, []

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, []

                                  []

<-- exit comb (now in comb) = []}

                                [[f]]

<-- exit comb (now in comb) = [[f]]}

                              [[e], [f]]

<-- exit comb (now in comb) = [[e], [f]]}
{--> enter comb, args = 2, [e, f]

                                x := e


                               f := [f]

{--> enter comb, args = 1, [f]

                                x := f


                               f := []

{--> enter comb, args = 0, []

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, []

                                  []

<-- exit comb (now in comb) = []}

                                [[f]]

<-- exit comb (now in comb) = [[f]]}
{--> enter comb, args = 2, [f]

                                  []

<-- exit comb (now in comb) = []}

                               [[e, f]]

<-- exit comb (now in comb) = [[e, f]]}

                       [[d, e], [d, f], [e, f]]

<-- exit comb (now in comb) = [[d, e], [d, f], [e, f]]}

           [[c, d], [c, e], [c, f], [d, e], [d, f], [e, f]]

<-- exit comb (now in comb) = [[c, d], [c, e], [c, f], [d, e], [d, f], [e, f]]}

  [[b, c], [b, d], [b, e], [b, f], [c, d], [c, e], [c, f], [d, e],

        [d, f], [e, f]]

<-- exit comb (now in comb) = [[b, c], [b, d], [b, e], [b, f], [c, d], [c, e], [c, f], [d, e], [d, f], [e, f]]}
{--> enter comb, args = 3, [b, c, d, e, f]

                                x := b


                          f := [c, d, e, f]

{--> enter comb, args = 2, [c, d, e, f]

                                x := c


                            f := [d, e, f]

{--> enter comb, args = 1, [d, e, f]

                                x := d


                             f := [e, f]

{--> enter comb, args = 0, [e, f]

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, [e, f]

                                x := e


                               f := [f]

{--> enter comb, args = 0, [f]

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, [f]

                                x := f


                               f := []

{--> enter comb, args = 0, []

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, []

                                  []

<-- exit comb (now in comb) = []}

                                [[f]]

<-- exit comb (now in comb) = [[f]]}

                              [[e], [f]]

<-- exit comb (now in comb) = [[e], [f]]}

                           [[d], [e], [f]]

<-- exit comb (now in comb) = [[d], [e], [f]]}
{--> enter comb, args = 2, [d, e, f]

                                x := d


                             f := [e, f]

{--> enter comb, args = 1, [e, f]

                                x := e


                               f := [f]

{--> enter comb, args = 0, [f]

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, [f]

                                x := f


                               f := []

{--> enter comb, args = 0, []

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, []

                                  []

<-- exit comb (now in comb) = []}

                                [[f]]

<-- exit comb (now in comb) = [[f]]}

                              [[e], [f]]

<-- exit comb (now in comb) = [[e], [f]]}
{--> enter comb, args = 2, [e, f]

                                x := e


                               f := [f]

{--> enter comb, args = 1, [f]

                                x := f


                               f := []

{--> enter comb, args = 0, []

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, []

                                  []

<-- exit comb (now in comb) = []}

                                [[f]]

<-- exit comb (now in comb) = [[f]]}
{--> enter comb, args = 2, [f]

                                  []

<-- exit comb (now in comb) = []}

                               [[e, f]]

<-- exit comb (now in comb) = [[e, f]]}

                       [[d, e], [d, f], [e, f]]

<-- exit comb (now in comb) = [[d, e], [d, f], [e, f]]}

           [[c, d], [c, e], [c, f], [d, e], [d, f], [e, f]]

<-- exit comb (now in comb) = [[c, d], [c, e], [c, f], [d, e], [d, f], [e, f]]}
{--> enter comb, args = 3, [c, d, e, f]

                                x := c


                            f := [d, e, f]

{--> enter comb, args = 2, [d, e, f]

                                x := d


                             f := [e, f]

{--> enter comb, args = 1, [e, f]

                                x := e


                               f := [f]

{--> enter comb, args = 0, [f]

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, [f]

                                x := f


                               f := []

{--> enter comb, args = 0, []

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, []

                                  []

<-- exit comb (now in comb) = []}

                                [[f]]

<-- exit comb (now in comb) = [[f]]}

                              [[e], [f]]

<-- exit comb (now in comb) = [[e], [f]]}
{--> enter comb, args = 2, [e, f]

                                x := e


                               f := [f]

{--> enter comb, args = 1, [f]

                                x := f


                               f := []

{--> enter comb, args = 0, []

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, []

                                  []

<-- exit comb (now in comb) = []}

                                [[f]]

<-- exit comb (now in comb) = [[f]]}
{--> enter comb, args = 2, [f]

                                  []

<-- exit comb (now in comb) = []}

                               [[e, f]]

<-- exit comb (now in comb) = [[e, f]]}

                       [[d, e], [d, f], [e, f]]

<-- exit comb (now in comb) = [[d, e], [d, f], [e, f]]}
{--> enter comb, args = 3, [d, e, f]

                                x := d


                             f := [e, f]

{--> enter comb, args = 2, [e, f]

                                x := e


                               f := [f]

{--> enter comb, args = 1, [f]

                                x := f


                               f := []

{--> enter comb, args = 0, []

                                 [[]]

<-- exit comb (now in comb) = [[]]}
{--> enter comb, args = 1, []

                                  []

<-- exit comb (now in comb) = []}

                                [[f]]

<-- exit comb (now in comb) = [[f]]}
{--> enter comb, args = 2, [f]

                                  []

<-- exit comb (now in comb) = []}

                               [[e, f]]

<-- exit comb (now in comb) = [[e, f]]}
{--> enter comb, args = 3, [e, f]

                                  []

<-- exit comb (now in comb) = []}

                             [[d, e, f]]

<-- exit comb (now in comb) = [[d, e, f]]}

             [[c, d, e], [c, d, f], [c, e, f], [d, e, f]]

<-- exit comb (now in comb) = [[c, d, e], [c, d, f], [c, e, f], [d, e, f]]}

  [[b, c, d], [b, c, e], [b, c, f], [b, d, e], [b, d, f], [b, e, f],

        [c, d, e], [c, d, f], [c, e, f], [d, e, f]]

<-- exit comb (now in comb) = [[b, c, d], [b, c, e], [b, c, f], [b, d, e], [b, d, f], [b, e, f], [c, d, e], [c, d, f], [c, e, f], [d, e, f]]}

  [[a, b, c], [a, b, d], [a, b, e], [a, b, f], [a, c, d], [a, c, e],

        [a, c, f], [a, d, e], [a, d, f], [a, e, f], [b, c, d],

        [b, c, e], [b, c, f], [b, d, e], [b, d, f], [b, e, f],

        [c, d, e], [c, d, f], [c, e, f], [d, e, f]]

<-- exit comb (now at top level) = [[a, b, c], [a, b, d], [a, b, e], [a, b, f], [a, c, d], [a, c, e], [a, c, f], [a, d, e], [a, d, f], [a, e, f], [b, c, d], [b, c, e], [b, c, f], [b, d, e], [b, d, f], [b, e, f], [c, d, e], [c, d, f], [c, e, f], [d, e, f]]}

  [[a, b, c], [a, b, d], [a, b, e], [a, b, f], [a, c, d], [a, c, e],

        [a, c, f], [a, d, e], [a, d, f], [a, e, f], [b, c, d],

        [b, c, e], [b, c, f], [b, d, e], [b, d, f], [b, e, f],

        [c, d, e], [c, d, f], [c, e, f], [d, e, f]]



J'espère que tout ceci est plus clair maintenant.

A bientôt.

ALS, qui ne fait plus de camping depuis plus de 15 ans...
Revenir en haut de page
Voir le profil de l'utilisateur Envoyer un message privé
Guimzo



Inscrit le: 02 Juin 2012
Messages: 198

MessagePosté le: 16 Avr 2017 23:42    Sujet du message: Sauvegarder une liste dans le noyau de Maple Répondre en citant

Bonsoir ALS,
Merci pour votre patience et ces amples explications : )
J'ai essayé avec C(100,4) avec C(200,3) avec C(300,3) et même avec C(4000,2) et c'est Ok, mais pour ce qui est de C(1000,3) j'ai laissé l'ordi tourner 2 jours et 7 heures, les processeurs étaient à fond les ballons : ), mémoire utilisée par Maple, plus de 6000 Mo, du coup, ne sachant pas combien de temps qu'allait prendre le Calcul, j'ai arrêté la machine au bout de ces 2 jours...

Je me demande ( pour le futur ) si cela ne serait pas opportun d'intégrer systématiquement une ligne de commande en début de chaque programme, permettant de connaître le temps que mettra Maple pour Calculer le résultat final..??

Voilà, voilà, je vous remercie en tout cas encore, pour votre inestimable aide !

P.S.1: Prenez soin de vous Professeur : )
P.S.2: J'espère quand même avoir la joie de venir en Bretagne un jour : )
Revenir en haut de page
Voir le profil de l'utilisateur Envoyer un message privé
Montrer les messages depuis:   
Poster un nouveau sujet   Répondre au sujet    Apprendre Maple Index du Forum -> Séquences, listes, ensembles, tables ou tableaux... Toutes les heures sont au format GMT + 2 Heures
Page 1 sur 1

 
Sauter vers:  
Vous ne pouvez pas poster de nouveaux sujets dans ce forum
Vous ne pouvez pas répondre aux sujets dans ce forum
Vous ne pouvez pas éditer vos messages dans ce forum
Vous ne pouvez pas supprimer vos messages dans ce forum
Vous ne pouvez pas voter dans les sondages de ce forum


phpBB

Développé par phpBB © 2001, 2006 phpBB Group
Traduction par : phpBB-fr.com


Apprendre Maple - ©  - Alain Le Stang - Navigation optimisée pour une résolution 1024 x 768.