 |
Apprendre Maple
Site dédié au logiciel de calcul formel Maple
|
| Voir le sujet précédent :: Voir le sujet suivant |
| Auteur |
Message |
boirac
Inscrit le: 12 Sep 2006
Messages: 10
Localisation: Londres, Royaume Uni
|
 Posté le: 13 Sep 2006 20:16 Sujet du message: Question et réponse partielle transformer listes en matrices |
 |
|
Bonjour à tous,
je posais il y a une semaine une question qui plus tard fût malheureusement vandalisée.
Merci à celui qui avait répondu et désolé de ne pas avoir pu la lire. J'ai trouvé une solution partielle... mais ce n'est pas encore au point. Merci bien si vous me relisez. La question était à peu près la suivante:
On nous donne un paramètre k.
On déclare une liste "nested" ayant la forme suivante:
| Code: | | L[n[1],n[2],...n[k],m[1],m[2],.... m[k] ], |
avec tout les indices n et m parcourant l'intervale:
| Code: | n[1],n[2],n[3].. =0,1,.. ,d-1
m[1],m[2],m[3].. =0,1,.. ,d-1 |
QUESTION: comment traduire cette liste à une matrice carée de dimension Matrix(d^k) ayant deux indexes:
M(i,j) qui parcourent l'intervale i,j = 0,1,2...., d^(k-1). ?
l'expression qui relie ces deux indexes est:
| Code: | i := sum(d^(i)*n[i], i = 0 ..(k-1))
j:= sum(d^(i)*m[i], i = 0 .. (k-1)) |
Ou encore:
| Code: | i = n[0] + n[1]*d+...+n[k-1]*d^(k-1)
j = m[0] + m[1]*d+...+m[k-1]*d^(k-1) |
Dans ce cas, si je fais une division entière de l'indice "j"
j := floor ( j / d )
j'observe que le premier terme de la somme sera éliminé:
| Code: | floor ( j / d ) = floor (m[0]/d + m[1]*d/d+...+m[k-1]*d^(k-1)/d)
=m[1]+...+m[k-1]*d^(k-2) |
et ainsi on peut écrire la transformation:
| Code: |
for i from 0 to (d^k -1) do
for i from 0 to (d^k -1) do
Indx:=i ;
Jindx:=j ;
for s from 0 to (k-1) do
n[s]:= Indx mod d:
Indx:= floor (Indx/d) ;
n[s]:= Jindx mod d :
Jindx:= floor (Jindx/d) ;
end do;
M(i,j):= L(n[0],n[1],...,n[k-1],m[1],m[2],...,m[k-1]) ;
end do;
end do;
|
Qui fait l'affaire sans faire 2k boucles récursives.
Cepandant... lorsque je fais la traduction des indexes:
| Code: |
for i from 0 to (d^k -1) do
for i from 0 to (d^k -1) do
Indx:=i ;
Jindx:=j ;
for s from 0 to (k-1) do
n[s]:= Indx mod d:
Indx:= floor (Indx/d) ;
n[s]:= Jindx mod d :
Jindx:= floor (Jindx/d) ;
end do;
end do;
end do;
|
J'obtiens l'erreur: | Citation: | | Error, illegal use of an object as a name |
.
Et je ne sais bien comment déclarer, une fois donné K l'objet
L(n[0],n[1],...,n[k-1],m[1],m[2],...,m[k-1]) ;
ou encore le mettre dans la boucle definie plus en haut.
Je ne suis pas sur si une expression du genre:
L[cat(n, 1 .. K-1), cat(m, 1 .. K-1)]:
fonctionne, car elle déclare des indexes du genre:
n1,n2,n3.... au lieu de n[1],n[2],n[3] ...
et je ne saurrais les inclure plus tard dans la boucle.
Merci beaucoup de lire et si il y a des réponses,
à plus tard,
Alvaro.
[/quote] |
|
| Revenir en haut de page |
|
 |
zozo
Inscrit le: 03 Jan 2013
Messages: 125
|
| Posté le: 14 Sep 2006 13:20 Sujet du message: |
|
|
C'est moi qui avais répondu, mais en disant que ce n'était pas du tout clair ta question. Cette reformulation ne m'éclaire pas davantage...
Sorry... |
|
| Revenir en haut de page |
|
|
boirac
Inscrit le: 12 Sep 2006
Messages: 10
Localisation: Londres, Royaume Uni
|
| Posté le: 14 Sep 2006 17:12 Sujet du message: |
|
|
Salut Zozo,
merci de ta réponse. Je vais essayer d'être plus clair. Il se peut aussi que mon français ne soit pas tout à fait au point, c'est ma troisième langue et je ne le parle plus depuis 6 ans, je m'excuse donc s'il y a des incorrections.
Il y a deux questions differentes.
QUESTION n°1:
Si tu me donnes K,d
Comment est-ce que je déclare une liste ayant K indices qui vont de 1 a d?
prenons l'exemple suivant:
K:=4:
d:=2:
Disons que les éléments de cette liste sont les suivants:
| Code: |
L[n1,n2,n3,n4]=n1+n2+n3-n4
|
(la fonction dans le terme droit de l'equation est sans importance, il s'agit seulement d'un exemple)
Si je fais ça un par un cela equivaut a faire:
| Code: |
L[1,1,1,1]= 1+1+1-1:
L[2,1,1,1]= 2+1+1-1:
L[1,2,1,1]= 1+2+1-1:
L[2,2,1,1]= 2+2+1-1:
L[1,1,2,1]= 1+1+2-1:
...
L[2,2,2,2]:=2+2+2-2:
|
si je fais cela avec une structure de "loop" cela equivaut a faire:
| Code: |
d:= 2;
for i from 1 to d do
for j from 1 to d do
for k from 1 to d do
for l from 1 to d do
L[i,j,k,l]= i+j+k-l:
end do:
end do:
end do:
end do:
|
Or disons que j'ai K:=35 !!
Je ne veux pas écrire 35 indices dans les boucles:
| Code: |
or n1 from 1 to d do
for n2 from 1 to d do
for n3 from 1 to d do
for n4 from 1 to d do
....
for n35 from 1 to d do
..
|
ni encore avoir a écrire 35 indices dans ma liste:
L[n1,n2,n3,n4,....,n35]= f(n1,n2,n3,....,n35).
SOLUTION PARTIELLE A LA QUESTION n° 1:
| Code: |
K:=35:
L[cat(n, 1 .. K)];
|
semble déclarer l'objet dont j'ai besoin, donc une liste qui a K indexes.
or comment déclarer ses éléments sans écrire K boucles ?
QUESTION n°2:
Une fois touts les éléments de L[n1,n2,n3,n4,....,n35] déclarés, comment traduire cette liste à une matrice carré de dimension d^K?
SOLUTION PARTIELLE A LA QUESTION n° 2:
Pour cela j'ai écrit le code suivant:
| Code: |
for i from 0 to (d^k -1) do
for i from 0 to (d^k -1) do
Indx:=i ;
Jindx:=j ;
for s from 0 to (k-1) do
n[s]:= Indx mod d:
Indx:= floor (Indx/d) ;
n[s]:= Jindx mod d :
Jindx:= floor (Jindx/d) ;
end do;
M(i,j):= L(n[0],n[1],...,n[k-1],m[1],m[2],...,m[k-1]) ;
end do;
end do;
|
Il faut remarquer qu'au lieux d'employer des indexes du type
n0,n1,n2...
j'ai employé des indexes du type
n[0],n[1],n[2]...
Il faut aussi remarquer que pour faciliter la traduction Liste-Matrice j'ai une liste
qui a 2K indexes n[0] -> n[K] et m[0] -> m[K].
On peut voir que cette manière de traduire Liste -> Matrice fonctionne en exécutant l'exemple suivant:
| Code: |
restart;
d := 2;
for n[1] from 0 to d-1 do
for n[2] from 0 to d-1 do f
or m[1] from 0 to d-1 do
for m[2] from 0 to d-1 do
L[n[1], n[2], m[1], m[2]] := cat(n[1], n[2], m[1], m[2])
end do end do end do end do;
with(LinearAlgebra);
K := 2;
rho := Matrix(d^K);
for i from 0 to d^K-1 do
for j from 0 to d^K-1 do
Indx := i; Jndx := j;
for s from 0 to K-1 do
n[s] := `mod`(Indx, d);
Indx := floor(Indx/d);
m[s] := `mod`(Jndx, d);
Jndx := floor(Jndx/d) end do;
rho[1+i, 1+j] := L[n[0], n[1], m[0], m[1]]
end do end do;
n[0], m[1], n[0], n[1];
"rho" = rho
|
LES QUESTIONS n°1 et n°2 sont reliées!!!
Je voudrais pouvoir déclarer la liste et aussi la traduire en matrice.
Voici quelques points clé et quelques idées:
1. Si je comprends bien l'emploi de "cat", je sais construire une liste de K indexes:
L[cat(n, 1 .. K)];
2. Je ne sais pas déclarer les éléments de cette liste:
des tentatives comme,
| Code: |
restart;
d := 2;
for n1 from 0 to d-1 do
for n2 from 0 to d-1 do
for m1 from 0 to d-1 do
for m2 from 0 to d-1 do
L[cat(n, 1 .. 2), cat(m, 1 .. 2)] := n1+n2+m1-m2 :
end do: end do: end do: end do:
|
ne donnent pas le résultat désiré
3. Si j'étais capable de déclarer une liste ayant la forme
L[n[0], n[1],n[2],...,n[K], m[0], m[1],m[2],...,m[K]]
avec tout ses éléments alors je pourrais la traduire en Matrice. Mais,
est-ce que je pourrais accéder à ses éléments ? par exemple qu'est ce que je vais obtenir si une fois définie et déclarée je fais:
L[1,1,1,....,1]
?
J'espère que cela a clarifié la question qui finalement est, donnés K et d, comment déclarer:
L[n[0], n[1],n[2],...,n[K], m[0], m[1],m[2],...,m[K]]
sans écrire 2K boucles.
Merci bien de vôtre temps,
Alvaro. |
|
| Revenir en haut de page |
|
|
ALS
Inscrit le: 11 Sep 2006
Messages: 647
|
| Posté le: 14 Sep 2006 18:41 Sujet du message: |
|
|
Bonsoir Alvaro,
Votre français est quasi-parfait, pas de souci de ce côté là.
Pour ce qui est du problème posé que j'ai rapidement lu, j'avais une idée tout à fait différente pour construire votre matrice: celle d'utiliser la numération en base d dont les nombres s'écrivent 0,1,..., d-1.
0000 correspond à 0, 0001 à 1, etc...
| Code: |
> d:=3: K:=4:
> for i from 0 to d^K-1 do
> print(`i `=i, convert(i,base,d))
> od;
#Conversion de la liste en numérique:
#Par exemple:
> x:=[2, 1, 0, 2];
> L:=NULL: for k to nops(x) do L:=cat(L,x[k]) od;
|
Et compléter par des 0 si la taille n'est pas la bonne |
|
| Revenir en haut de page |
|
|
boirac
Inscrit le: 12 Sep 2006
Messages: 10
Localisation: Londres, Royaume Uni
|
| Posté le: 15 Sep 2006 15:24 Sujet du message: Merci |
|
|
Bonjour ALS, merci de vôtre conseil pour la conversion numérique.
convert(i,base,d)
fait probablement dans sa définition la même opération que:
| Code: |
d:=3: K:=4:
> for i from 0 to d^K-1 do
> Indx := i:
> for s from 0 to (K-1) do
> n[s]:= Indx mod d;
> Indx:= floor (Indx/d) :
> end do;
> print("i"=i,[seq(n[s],s=0..(K-1))]);
> end do:
|
Cela équivaut à un changement de base numérique puisque un nombre en base d peut s'exprimer comme:
i:= sum(d^(i)*m[i], i = 0 .. (k-1))
ce nombre étant décomposé en chiffres m[1]m[2]m.. etc,
et à chaque boucle je divise par d, prends la partie entière et puis évalue le reste de la division.
Ma connaissance des commandes de cat, parse, nop, et des matrices est encore faible... et déclarer la liste est, je crois, mon problème principal.
Sauriez vous comment déclarer une liste de K indexes sans écrire K boucles? La question n°1 plus haut?
Merci encore une fois,
Alvaro.  |
|
| Revenir en haut de page |
|
|
ALS
Inscrit le: 11 Sep 2006
Messages: 647
|
| Posté le: 15 Sep 2006 15:59 Sujet du message: |
|
|
Bonjour, j'ai pensé à une méthode aléatoire pour générer la liste, mais cela risque d'être long si d est grand. What do you think about this?
| Code: |
> d:=3: K:=4:
> randomize(): h:=rand(d):
> L:=[]:
> while nops(L)<d^K do
> S:=NULL:
> for i to K do
> S:=S,h()
> end do:
> S:=[S]:
> if not member(S,L) then L:=[op(L),S] end if:
> end do:
> L;
[[2, 2, 0, 1], [1, 2, 2, 2], [1, 1, 0, 0], [0, 2, 2, 2],
[2, 2, 1, 2], [0, 0, 1, 1], [2, 0, 1, 0], [1, 1, 2, 1],
[1, 0, 1, 0], [2, 1, 2, 0], [0, 0, 0, 0], [2, 2, 0, 0],
[0, 2, 0, 2], [0, 2, 0, 0], [2, 0, 0, 2], [2, 0, 2, 1],
[0, 1, 0, 0], [1, 0, 1, 1], [1, 2, 1, 2], [0, 2, 1, 1],
[2, 0, 2, 0], [1, 2, 0, 1], [1, 0, 0, 1], [0, 0, 0, 2],
[0, 0, 0, 1], [2, 2, 2, 0], [0, 1, 2, 2], [2, 2, 1, 1],
[2, 1, 0, 1], [1, 1, 2, 2], [0, 1, 2, 0], [1, 0, 2, 0],
[2, 0, 0, 1], [1, 1, 0, 1], [2, 2, 2, 1], [0, 1, 0, 2],
[1, 0, 0, 0], [0, 1, 2, 1], [0, 2, 2, 0], [0, 2, 0, 1],
[1, 1, 2, 0], [1, 1, 0, 2], [1, 2, 0, 2], [2, 1, 1, 0],
[0, 1, 1, 1], [1, 1, 1, 1], [2, 0, 1, 1], [2, 2, 2, 2],
[0, 0, 2, 0], [2, 2, 0, 2], [0, 0, 2, 1], [2, 2, 1, 0],
[2, 1, 2, 1], [1, 0, 0, 2], [1, 2, 2, 1], [2, 1, 0, 0],
[2, 0, 0, 0], [2, 1, 1, 2], [1, 2, 2, 0], [0, 0, 1, 2],
[1, 2, 1, 0], [1, 2, 0, 0], [0, 0, 1, 0], [1, 0, 2, 1],
[0, 1, 1, 0], [0, 1, 1, 2], [1, 1, 1, 0], [1, 1, 1, 2],
[2, 0, 2, 2], [0, 1, 0, 1], [1, 0, 1, 2], [2, 1, 2, 2],
[0, 2, 1, 2], [2, 1, 0, 2], [1, 2, 1, 1], [0, 2, 2, 1],
[0, 0, 2, 2], [2, 0, 1, 2], [1, 0, 2, 2], [2, 1, 1, 1],
[0, 2, 1, 0]]
|
|
|
| Revenir en haut de page |
|
|
boirac
Inscrit le: 12 Sep 2006
Messages: 10
Localisation: Londres, Royaume Uni
|
| Posté le: 18 Sep 2006 17:25 Sujet du message: |
|
|
Merci ALS de vôtre réponse. déclarer les éléments de la matrice aléatoirement peut être utile plus tard donc je prend note!
Voici la solution que j'ai trouvé pour déclarer les éléments d'un objet qui a 2k indexes qui vont de 0 a d-1 sans avoir à écrire 2k boucles et le transformer en matrice.
Donc voici comment déclarer L[n1,n2,n3,..,nk,m1,m2,...,mk] = f(n1,n2,...,mk)
et comment transformer ses éléments en celuis d'une matrice d^k * d^k.
(pour voir si l'exemple fonctionne, j'ai choisi
f(n1,n2,...,mk)=cat(n1,n2,..,nk,m1,m2,..mk) et des petites valeurs pour d et K)
EN écrivant les boucles pour déclarer (peu utile pour K grand)
Déclarer la liste:
| Code: |
d := 2;
for n[1] from 0 to d-1 do
for n[2] from 0 to d-1 do
for m[1] from 0 to d-1 do
for m[2] from 0 to d-1 do
L[n[1], n[2], m[1], m[2]] := cat(n[1], n[2], m[1], m[2])
end do: end do: end do: end do;
|
Traduire en matrice:
| Code: |
with(LinearAlgebra):
K := 2;
rho := Matrix(d^K);
for i from 0 to d^K-1 do
for j from 0 to d^K-1 do
Indx := i;
Jndx := j;
for s from 0 to K-1 do
n[s] := `mod`(Indx, d);
Indx := floor(Indx/d);
m[s] := `mod`(Jndx, d);
Jndx := floor(Jndx/d)
end do;
rho[1+i, 1+j] := L[n[0], n[1], m[0], m[1]]
end do: end do;
"rho" = rho
|
Déclarer sans boucles mais en transformant la base numérique pour déclarer et pour traduire (utile pour tout K-s raisonablement grands).
| Code: |
#This loop is intended to avoid all the do-s in the declarations of the states
#this loop creates the indexes of the List that correspond to i from 0 to d^(K)-1
#this way for i=0 we will have [0,0,0] if it is a 3 mode state.
#similarly for i=1 we will have [1,0,0] if it is a 3 mode state, etc...
d := 2; K := 2;
for i from 0 to d^K-1 do
Indi := convert(i, base, d);
while nops(Indi) <> K do
Indi := [op(Indi), 0]
end do;
for j from 0 to d^K-1 do
Jndi := convert(j, base, d);
while nops(Jndi) <> K do
Jndi := [op(Jndi), 0]
end do;
MS[op(Indi), op(Jndi)] := cat(Indi[1], Indi[2], Jndi[1], Jndi[2])
end do: end do;
|
Traduire liste en matrice: (meme operation qu'avant)
| Code: |
rho2 := Matrix(d^K);
for i from 0 to d^K-1 do
for j from 0 to d^K-1 do
Indx := i; Jndx := j;
for s from 0 to K-1 do
n[s] := `mod`(Indx, d);
Indx := floor(Indx/d);
m[s] := `mod`(Jndx, d);
Jndx := floor(Jndx/d) end do;
rho2[1+i, 1+j] := MS[n[0], n[1], m[0], m[1]]
end do: end do;
"rho" = rho2;
|
Merci de vos conseils et j'espère que cela poura servir a d'autres,
Alvaro. |
|
| 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.
|
Page d'accueil
FAQ
Rechercher
Liste des Membres
Groupes d'utilisateurs
S'enregistrer
Profil
Se connecter pour vérifier ses messages privés
Connexion
