|
Apprendre Maple Site dédié au logiciel de calcul formel Maple
|
Voir le sujet précédent :: Voir le sujet suivant |
Auteur |
Message |
Guimzo
Inscrit le: 02 Juin 2012 Messages: 209
|
Posté le: 09 Avr 2017 15:00 Sujet du message: Sauvegarder une liste dans le noyau de Maple |
|
|
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 |
|
|
ALS
Inscrit le: 11 Sep 2006 Messages: 647
|
Posté le: 10 Avr 2017 6:19 Sujet du message: |
|
|
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 |
|
|
Guimzo
Inscrit le: 02 Juin 2012 Messages: 209
|
Posté le: 10 Avr 2017 20:45 Sujet du message: Sauvegarder une liste dans le noyau de Maple |
|
|
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 |
|
|
Guimzo
Inscrit le: 02 Juin 2012 Messages: 209
|
Posté le: 11 Avr 2017 21:16 Sujet du message: Sauvegarder une liste dans le noyau de Maple |
|
|
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 |
|
|
ALS
Inscrit le: 11 Sep 2006 Messages: 647
|
Posté le: 12 Avr 2017 7:34 Sujet du message: |
|
|
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 |
|
|
Guimzo
Inscrit le: 02 Juin 2012 Messages: 209
|
Posté le: 12 Avr 2017 22:06 Sujet du message: Sauvegarder une liste dans le noyau de Maple |
|
|
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 |
|
|
Guimzo
Inscrit le: 02 Juin 2012 Messages: 209
|
Posté le: 13 Avr 2017 21:49 Sujet du message: Sauvegarder une liste dans le noyau de Maple |
|
|
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 |
|
|
ALS
Inscrit le: 11 Sep 2006 Messages: 647
|
Posté le: 14 Avr 2017 6:15 Sujet du message: |
|
|
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 |
|
|
Guimzo
Inscrit le: 02 Juin 2012 Messages: 209
|
Posté le: 16 Avr 2017 23:42 Sujet du message: Sauvegarder une liste dans le noyau de Maple |
|
|
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 |
|
|
|
|
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
|
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.
|