Forum de mathématiques - Bibm@th.net

stormin

Membre

Inscription : 03-12-2009

Messages : 124

[Python]Remplacement d'éléments de matrice tant que somme <>0

Bonjour,

J'ai obtenu une matrice classé par ordre décroissant.

Je voudrais faire la somme des éléments de la matrice,si la somme est >0,je remplace le max par 0,et si la somme est <0,je remplace le min par 0,
Jusqu'à avoir une somme égale à zéro.

Merci

yoshi

Modo Ferox

Inscription : 20-11-2005

Messages : 16 991

Re : [Python]Remplacement d'éléments de matrice tant que somme <>0

Re,

Voilà un premier jet.
J'ai configuré la matrice comme une liste de listes, nombres dans le désordre : marche donc aussi pour une matrice triée...
Si tu as des questions, n'hésite pas

#!/usr/bin/env python
# -*- coding: Latin-1 -*-

# Donnée de la matrice
L=[[-5,2,3,-7],[6,2,8,1],[3,4,0,-9],[1,-55,4,3]]

# Dimension de la matrice : nb de lignes, nb de colonnes
m,n=4,4
# Initialistion de la somme (n'importe quelle valeur autre que zéro convient)
somme=1
# Initialisation des coordonnées du mini et du maxi (dans cet ordre)
pos=[(m+1,n+1),(m+1,n+1)]

# Affichage matrice d'origine
print "Matrice de départ"
for i in range(m):
    for j in range(n):
        print "%3i" % L[i][j],
    print
print
print "Sommes successives :"

while somme !=0:
# Initialisation mini, maxi
    mini,maxi=10**12,-10**12

# Calcul de la somme
    somme=sum(L[0])  
    for i in range(1,m):
        somme+=sum(L[i])
    print somme,
    if somme > 0:
        for lign in range(m):
            for col in range(n):
                a=L[lign][col]
                if a > maxi:
                    maxi=a
                    pos[1]=(lign,col)
        (a,b)=pos[1]
        L[a][b]=0
    elif somme<0:
        for lign in range(m):
            for col in range(n):
                a=L[lign][col]
                if a < mini:
                    mini=a
                    pos[0]=(lign,col)
        (a,b)=pos[0]
        L[a][b]=0

print
print
print "Matrice finale"        
for i in range(m):
    for j in range(n):
        print "%3i" % L[i][j],
    print

Affichage :

Matrice de départ
-5   2   3  -7
  6   2   8   1
  3   4   0  -9
  1 -55   4   3

Sommes successives :
-39 16 8 2 -2 7 3 0

Matrice finale
-5   2   0  -7
  0   2   0   1
  3   0   0   0
  1   0   0   3

Code valable jusqu'à Python v 2.7.
Pour Python 3.x, remplacer :
* print seul par print()
* print suivi d'instructions, mettre les instructions entre parenthèses.
   Exemple : print "%3i" % L[i][j],  devient print("%3i" % L[i][j]),
print est devenu une fonction dans les versions 3.x.

Au fait qu'appelles-tu : "une matrice classé par ordre décroissant" ? Exemple s'il te plaît. Merci.
J'attends tes remarques pour modifier éventuellement le code.

@+

[EDIT]
Pour une fois que je réagis au quart de tour, me v'là mal récompensé..
Stormin, t'es toujours vivant ???

Dernière modification par yoshi (11-05-2011 18:12:33)

---

Arx Tarpeia Capitoli proxima...

stormin

Membre

Inscription : 03-12-2009

Messages : 124

Re : [Python]Remplacement d'éléments de matrice tant que somme <>0

Bonsoir,

Vraiment ,je suis désolé.

J'ai constaté que le fait de manipuler les matrices avec autre que Matlab,conduit à utiliser énormément de boucles,mais quand même j'ai bénéficié de ton raisonnement pour employer l'idée sous matlab.

Merci infiniment,et je présente encore une fois mes sincères excuses.

yoshi

Modo Ferox

Inscription : 20-11-2005

Messages : 16 991

Re : [Python]Remplacement d'éléments de matrice tant que somme <>0

Salut,

Si tu trouves qu'il y a trop de boucles (et je ne vois pas en quoi ça te gène), je peux écrire ça autrement...
Ce sera peut-être moins clair pour un non familier de Python mais bien plus court.
Donc voilà :

#!/usr/bin/env python
# -*- coding: Latin-1 -*-
# v. 2.0

# Donnée de la matrice
L=[-5,2,3,-7,6,2,8,1,3,4,0,-9,1,-55,4,3]

# Dimension de la matrice : nb de lignes, nb de colonnes
m,n=4,4
dim=m*n
# Initialistion de la somme (n'importe quelle valeur autre que zéro convient)
somme=1

# Affichage matrice d'origine
print "Matrice initiale :"
for j in range(dim):
    if j%n==0 and j>0:
        print
    print "%3i" % L[j],
print
print

print "Sommes successives :"
while somme !=0:
# Calcul de la somme
    somme=sum(L)  
    print somme,
# test de valeur et relevé de la position du mini ou du maxi
    if somme > 0:
        pos=L.index(max(L))
    elif somme<0:
        pos=L.index(min(L))
# mise à zéro du nombre en position pos relevée
    L[pos]=0
print
print

print "Matrice modifiée :"
for j in range(dim):
    if j%n==0 and j>0:
        print
    print "%3i" % L[j],
print

Résultat :

Matrice initiale :
-5   2   3  -7
  6   2   8   1
  3   4   0  -9
  1 -55   4   3

Sommes successives :
-39 16 8 2 -2 7 3 0

Matrice modifiée :
-5   2   0  -7
  0   2   0   1
  3   0   0   0
  1   0   0   3

Commentaires :
1. Au lieu d'écrire la matrice sous forme d'une liste de listes de ligne, je l'ai écrite tout à la suite...
2. Dans ce cas les fonctions min() et max() marchent.
3. J'ai utilisé la méthode de liste index qui me renvoie la position de n'importe quel nombre dans la liste :
    L.index(-55) donne 13.
4. Donc, je recherche la position du mini et du maxi de la liste par pos = L.index(max(L)) et
pos = L.index(min(L)) et je mets les valeurs aux positions correspondantes à 0 L[pos]=0
5. Les boucles for du début et de la fin ne sont pas indispensables elle ne servent que pour l'affichage avant/après.

As-tu en Matlab une fonction qui te donne la position du mini ou du maxi dans une liste (ou un tableau si tu préfères), l'équivalent de index en Python ?

Peut-être que cette version sera plus facilement adaptable : je te conseille de voir si tu peux déjà faire fonctionner ça en matlab. Si oui, tu n'auras plus qu'à introduire tes transformées de Fourier...
Essaie et reviens.

Au fait dans ton prog ici http://www.bibmath.net/forums/viewtopic.php?id=4635, à quoi sert chacune de ces lignes :

Auto_Cor1=Auto_Cor1.*MASQUE;
    G1=abs(Auto_Cor1).^2;

    Auto_Cor2=Auto_Cor2.*MASQUE;
    G2=abs(Auto_Cor2).^2;

    Auto_Cor3=Auto_Cor3.*MASQUE;
    G3=abs(Auto_Cor3).^2;

    XCor1=XCor1.*MASQUE;
    G4=abs(XCor1).^2;

    XCor2=XCor2.*MASQUE;
    G5=abs(XCor2).^2;

    XCor3=XCor3.*MASQUE;
    G6=abs(XCor3).^2;

    [A1 ID1] = max(Auto_Cor1(:));
    [A2 ID2] = max(Auto_Cor2(:));
    [A3 ID3] = max(Auto_Cor3(:));

    [M1 id1] = max(XCor1(:));
    [M2 id2] = max(XCor2(:));
    [M3 id3] = max(XCor3(:));

    M123=[M1 M2 M3];
    A123=[A1 A2 A3];

    MAXC=max(M123)
    MINA=min(A123)

    if     MAXC==M1
        trans_four_C=TF7;
    elseif MAXC==M2
        trans_four_C=TF8;
    else
        trans_four_C=TF9;
    end

    if     MINA==A1
        trans_four_A=TF1;
    elseif MINA==A2
        trans_four_A=TF2;
    else
        trans_four_A=TF3;
    end

Sachant cela, je pourrai peut-être avancer.
@+

---

Arx Tarpeia Capitoli proxima...

stormin

Membre

Inscription : 03-12-2009

Messages : 124

Re : [Python]Remplacement d'éléments de matrice tant que somme <>0

Bonjour,

As-tu en Matlab une fonction qui te donne la position du mini ou du maxi dans une liste (ou un tableau si tu préfères), l'équivalent de index en Python ?.

Max:

[M1 id1] = max(XCor1(:));
[X1 Y1] = ind2sub(size(XCor1),id1);

Min:

[M1 id1] = min(XCor1(:));
[X1 Y1] = ind2sub(size(XCor1),id1);

Auto_Cor1=Auto_Cor1.*MASQUE;%%ici j'applique le masque pour voir si le pic min reste min puisque,je bloque une fréquence
    G1=abs(Auto_Cor1).^2;%%je calcule l'amplitude au carrée,car je cherche le min dans un tableau des intensités

    Auto_Cor2=Auto_Cor2.*MASQUE;
    G2=abs(Auto_Cor2).^2;

    Auto_Cor3=Auto_Cor3.*MASQUE;
    G3=abs(Auto_Cor3).^2;

    XCor1=XCor1.*MASQUE;%%Je multiplie par le masque qui contient des zeros,et je teste si le max est encore max.
    G4=abs(XCor1).^2;

    XCor2=XCor2.*MASQUE;
    G5=abs(XCor2).^2;

    XCor3=XCor3.*MASQUE;
    G6=abs(XCor3).^2;

    [A1 ID1] = max(Auto_Cor1(:));%%je détermine le max
    [A2 ID2] = max(Auto_Cor2(:));
    [A3 ID3] = max(Auto_Cor3(:));

    [M1 id1] = max(XCor1(:));
    [M2 id2] = max(XCor2(:));
    [M3 id3] = max(XCor3(:));

    M123=[M1 M2 M3];
    A123=[A1 A2 A3];

    MAXC=max(M123)%%entre les trois max de XCor,je précise le max
    MINA=min(A123)%%entre les trois max de Auto_Cor,je précise le min

    if     MAXC==M1
        trans_four_C=TF7;%%tous ces tests pour travailler dans Matrice avec Transformée de Fourier de Max et Min,et ici ou il y a le problème ,car a chaque fois que je mets un zéro dans masque,je dois appliquer ce masque au 3 Auto_Cor et 3 XCor,et chercher à nouveau si le max et min ne changent pas,sinon il faut trouver le nouveau max et min,pour toujours ne utiliser que la transformée de Fourier de max et min.
    elseif MAXC==M2
        trans_four_C=TF8;
    else
        trans_four_C=TF9;
    end

    if     MINA==A1
        trans_four_A=TF1;
    elseif MINA==A2
        trans_four_A=TF2;
    else
        trans_four_A=TF3;
    end

yoshi

Modo Ferox

Inscription : 20-11-2005

Messages : 16 991

Re : [Python]Remplacement d'éléments de matrice tant que somme <>0

RE,

As-tu traduit mon programme et seulement lui en MatLab ?
Si oui, fonctionne-t-il ?
Il est indispensable que tu commences par là : ainsi tu disposeras d'une boucle opérationnelle que tu pourras enrichir avec tes transformées de Fourier.
J'insiste lourdement parce que l'expérience m'a suffisamment montré qu'une base de départ saine est la condition sine qua non de la réussite.
Ton silence tendrait à prouver que, non, tu ne l'as pas fait : tu as peur de perde du temps ?
J'ai toujours asséné à mes élèves cette vérité en forme de paradoxe : << Vous voulez gagner du temps ? Alors commencez par en perdre... à réfléchir ! >>
Pour toi ici, il s'agit à partir d'une matrice donnée d'avoir une boucle qui te permette de mettre à zéro, les minimums et maximums successifs tant que la somme des éléments de la matrice est différente de zéro.
Après, tu pourras la  modifier en fonction de tes besoins et sauvegarder ton travail pour tester, sous un autre nom.
Bon, j'attends une réponse positive de ta part...

Qu'est ce que représentent XCor, Auto_Cor1 2 et 3, Masque ?
Et là : [X1 Y1] = ind2sub(size(XCor1),id1); tu fais quoi ?
Par quelles variables sont désignées ton mini et ton maxi ? C'est ça : [M1 id1], ta "variable" ?
Pourquoi 3 Max ? Et alors pourquoi n'y a-t-il pas 3 min ?
Pourquoi prends-tu le min de 3 max ? Quel rapport avec ce que tu as demandé au départ  : mettre à zéro, les minimums et maximums successifs d'une matrice  tant que la somme des éléments de la matrice est différente de zéro ?

@+

Autre question sans rapport : mon pseudo est Yoshi.
Pourquoi t'obstines-tu à m'appeler James comme ça :

m'obligeant à rectifier à chaque fois ?

---

Arx Tarpeia Capitoli proxima...

stormin

Membre

Inscription : 03-12-2009

Messages : 124

Re : [Python]Remplacement d'éléments de matrice tant que somme <>0

Bonsoir,
Voila,j'ai traduit ton programme en Matlab:

epse=0.001;

Matrice=abs(TF4).*cos(angle(TF4) - angle(TF1))-epse*abs(TF1);
somme = sum(Matrice(:));
epsilon = 0.01;

while(abs(somme)>epsilon)
    if somme>0
        [maximum indice] = max(Matrice(:));
        Matrice(indice) = 0;
    else
        [minimum indice] = min(Matrice(:));
        Matrice(indice) = 0;
    end
    somme = sum(Matrice(:));
end

Le problème est résolu maintenant.

Merci

yoshi

Modo Ferox

Inscription : 20-11-2005

Messages : 16 991

Re : [Python]Remplacement d'éléments de matrice tant que somme <>0

Re,

Ok !
Donc, ça y est tu as réussi à faire tourner ton programme en MatLab ?
Tu as donc satisfaction ?
Je ne comprends pas par contre que tu n'aies pas eu de réponse sur le forum MatLab de developpez.net. Bizarre, quand même !

@+

---

Arx Tarpeia Capitoli proxima...

stormin

Membre

Inscription : 03-12-2009

Messages : 124

Re : [Python]Remplacement d'éléments de matrice tant que somme <>0

Salut,

Avec ce programme,

epse=0.0035;
MASQUE=ones(256,256);
Matrice=abs(TF4).*cos(angle(TF4) - angle(TF1))-epse*abs(TF1);
 
somme = sum(Matrice(:))

epsilon = 0.000023;

while(abs(somme)>epsilon)

    if somme>0
        [maximum indice] = max(Matrice(:));
        Matrice(indice) = 0;
        MASQUE(indice) = 0;
       
    else
        [minimum indice] = min(Matrice(:));
        Matrice(indice) = 0;
        MASQUE(indice) = 0;
       
    end
    somme = sum(Matrice(:));
   
end

J'ai obtenu le masque binaire qui bloques certains pixels,mais puisque je travaille avec des valeurs réelles,la sortie de la boucle n'est faite que lorsque je manipule avec un epsilon.
Le masque binaire sera optimale si je travaille avec 0.
ma question,est la suivante:

Comment améliorer cela,sachant que j'ai essayé plusieurs epsilon,mais le pic de corrélation croisée que je désire l'éliminer,sa taille est diminue,mais s'annule pas.

Merci

yoshi

Modo Ferox

Inscription : 20-11-2005

Messages : 16 991

Re : [Python]Remplacement d'éléments de matrice tant que somme <>0

Re,

la sortie de la boucle n'est faite que lorsque je manipule avec un epsilon

Qu'est-ce que tu veux dire par "manipuler avec un epsilon" ?
Donne un exemple de matrice qui ne s'annule pas, s'il te plaît
Les valeurs des éléments de ta matrice doivent être définis avec quelle précision ?[tex]10^{-4},\;10^{-5},\;10^{-6}[/tex]
Selon ta réponse, on interviendra là : Matrice=abs(TF4).*cos(angle(TF4) - angle(TF1))-epse*abs(TF1); en imposant des arrondis...
Il est clair que le programme ne peut donner des valeurs d'une précision absolue...
Les cosinus sont précis à combien près ?
Comment sont définis (calculés ?) TF4 et TF1 ?

@+

---

Arx Tarpeia Capitoli proxima...

stormin

Membre

Inscription : 03-12-2009

Messages : 124

Re : [Python]Remplacement d'éléments de matrice tant que somme <>0

Qu'est-ce que tu veux dire par "manipuler avec un epsilon" ?

C'est ici:

while(abs(somme)>epsilon)

J'ai essayé plusieurs valeurs de epsilon pour optimiser mon résultat.
Et que moi je souhaite faire :

while somme~=0

Mais lorsque,je fait cela,la boucle continue à tourner jusqu'à qu'elle met toutes les valeurs de la matrice à zéro.

Donne un exemple de matrice qui ne s'annule pas, s'il te plaît

abs(TF1),abs(TF4),Matrice :ce sont des matrice de taille:256*256,et  voila une partie de la matrice abs(TF1):

0.0275    0.0412    0.0512    0.0554    0.0533    0.0457    0.0341    0.0212    0.0113    0.0126    0.0186    0.0219
    0.0201    0.0236    0.0329    0.0409    0.0444    0.0424    0.0352    0.0242    0.0118    0.0066    0.0150    0.0217
    0.0250    0.0179    0.0095    0.0075    0.0136    0.0182    0.0191    0.0160    0.0099    0.0022    0.0062    0.0132
    0.0254    0.0315    0.0333    0.0310    0.0254    0.0177    0.0093    0.0017    0.0041    0.0069    0.0067    0.0044
    0.0156    0.0333    0.0474    0.0550    0.0552    0.0486    0.0369    0.0227    0.0093    0.0054    0.0109    0.0125
    0.0141    0.0199    0.0400    0.0558    0.0636    0.0625    0.0535    0.0389    0.0217    0.0052    0.0080    0.0159
    0.0285    0.0082    0.0156    0.0350    0.0486    0.0545    0.0524    0.0436    0.0304    0.0159    0.0056    0.0112
    0.0358    0.0266    0.0169    0.0154    0.0233    0.0311    0.0355    0.0356    0.0317    0.0251    0.0172    0.0102

Merci

Dernière modification par stormin (21-05-2011 15:04:33)

yoshi

Modo Ferox

Inscription : 20-11-2005

Messages : 16 991

Re : [Python]Remplacement d'éléments de matrice tant que somme <>0

Salut

Oui, je comprends, c'est bien ce que je pensais...
Et si tu arrondissais arbitrairement tout ce petit monde à 4 chiffres après la virgule...
En Python :
Matrice=round(abs(TF4).*cos(angle(TF4) - angle(TF1))-epse*abs(TF1),4);
Ainsi tu travaillerais sur des décimaux et plus sur des réels...
Je vais tester mon module avec des décimaux pour voir...

@+

[EDIt]
Ah.... Même souci !
Avec une matrice 4 x 4 et 1 chiffre après la virgule...
Finalement, ça ne me paraît pas illogique...
Je vais vérifier à la main.

[EDIT2]
Non, c'est correct le programme ne fait pas n'importe quoi...
Le problème vient de l'Informatique.
Il vient de la représentation des nombres à virgule par l'ordinateur.
Pour comprendre va voir là : http://fr.wikipedia.org/wiki/Syst%C3%A8me_binaire
Regarde ce que fait Python :

>>> x=0.9
>>> x
0.90000000000000002

Le hic, c'est que travaillant avec des décimaux, même si le programme obtient 0, il ne le "verra pas".
Avec mon test, j'ai un 0, mais l'ordinateur le voit ainsi : 4.4408920985e-16.
Alors j'ai refait mon test avec while abs(somme)>10**-10 et là, il s'arrête avant de n'avoir que des zéros...

Je vois une solution (enfin je pense).
1. Arrondir tous les éléments de ta matrice à 4 chiffres après la virgule,
2. Tous les multiplier par 10000, et vérifier si pour matlab, ils sont du type int ou float...
3. Le cas échéant les convertir en int,
4. Lancer le programme sur les éléments entiers,
5. A la fin rediviser les éléments non nuls par 10000...

Tiens une autre idée, moins lourde, je viens de tester...
J'ai remplacé somme=sum(L) par somme=round(sum(L),1)
L=[-15.2,20.5,3.1,-7.4,6.1,20.2,8.1,1.1,3.2,4.1,0.5,-9.2,1.1,-5.8,4.5,3.1]
Résultat avec round :

Matrice initiale :
-15  20   3  -7
  6  20   8   1
  3   4   0  -9
  1  -5   4   3

Sommes successives :
38.0 17.5 -2.7 12.5 4.4 -1.7 7.5 3.0 -1.1 6.3 3.1 0.0

Matrice modifiée :
    0     0     0     0
    0     0     0   1.1
    0     0   0.5     0
  1.1  -5.8     0   3.1

Toi
Avec tes 4 chiffres après la virgule, arrondis tes sommes à 4 chiffres après la virgule, pour éliminer les nombres parasites intempestifs comme dans 0.90000000000000002, au lieu de 0.9...
Essaie en laissant le test sur 0 et l'arrondi des sommes et reviens.

Cela dit en Python, il y a le module : decimal qui permet de gérer exactement les nombres décimaux y compris avec 20, 30, 40 chiffres après la virgule : il suffit de le préciser avant...
test avec

Dernière modification par yoshi (21-05-2011 15:42:58)

---

Arx Tarpeia Capitoli proxima...

stormin

Membre

Inscription : 03-12-2009

Messages : 124

Re : [Python]Remplacement d'éléments de matrice tant que somme <>0

Bonsoir,

Merci pour les explications,j'ai bien compris .

Après l'arrondissement ,la boucle marche très bien avec la condition de somme 0,mais toujours le masque binaire obtenu ne me permet pas d'avoir le bon résultat,je suis  vraiment coincé,et même dans developpez.net,pas de réponse.

Merci

yoshi

Modo Ferox

Inscription : 20-11-2005

Messages : 16 991

Re : [Python]Remplacement d'éléments de matrice tant que somme <>0

RE,

,mais toujours le masque binaire obtenu ne me permet pas d'avoir le bon résultat,

.
Tu veux dire par là, qu'à la sortie de la boucle la matrice est nulle ?
Es-tu sûr d'avoir des nombres négatifs dans ta matrice ?
Qu'est-ce que veux dire exactement "le bon masque" ?

L'idéal serait que je puisse disposer des 4096 valeurs d'une matrice.
Peux-tu les enregistrer dans un fichier texte et me le déposer ici :
http://www.cijoint.fr
et me communiquer le "code" d'accès qui te sera donné...

Parce que je pense contourner la difficulté :
1. Je veux tester par moi-même grandeur nature parce que je ne suis qu'à moitié surpris (en termes de probabilité) que ça ne fonctionne pas.
2. Au besoin, je fournirai le prog complet en Python, sur le forum Python de développez.net : là, je pense qu'on aurait une réponse

Au delà de ce programme, tu avais parlé de pixels, tu cherches à faire quoi ?

@+

---

Arx Tarpeia Capitoli proxima...

stormin

Membre

Inscription : 03-12-2009

Messages : 124

Re : [Python]Remplacement d'éléments de matrice tant que somme <>0

Tu veux dire par là, qu'à la sortie de la boucle la matrice est nulle ?

Non le contraire,avant l'arrondissement,la boucle sorte avec une matrice nulle,après l'arrondissement ,elle me donne une matrice non nulle.

Es-tu sûr d'avoir des nombres négatifs dans ta matrice ?

Oui.

Qu'est-ce que veux dire exactement "le bon masque" ?

J'ai deux images de taille 256*256,une scène contient deux lettres E et F,et une cible contient la lettre F,après une opération de corrélation,j'ai obtenu deux pics,l'un (F*F) et plus intense que l'autre(E*F),et mon objectif vise à faire diminuer le maximum l'intensité du pic E*F ,pour laisser seulement le pic F*F ,c'est à dire augmenter la capacité de discrimination:

Cela à travers la matrice:

Matrice=abs(TF4).*cos(angle(TF4) - angle(TF1))-0.1*abs(TF1);

Je veux faire le test jusqu'à avoir un équilibre entre la partie positive et négative,en remplacant par zéro le pixel qui ne remplie pas la condition (la somme égale à zéro).
Ce travail sur Matrice,c'est en quelque sorte la construction du masque binaire que je l'applique au résultat de corrélation pour bloquer certains pixels de façon à ne garder que le pic d’auto-corrélation et d'éliminer le pic de corrélation croisée.
J'ai diminuer le pic E*F,mais moi je cherche à l'éliminer à l'aide de masque de binaire .

Pour l'enregistrement dans http://www.cijoint.fr,il me signale un problème de email de confirmation.
Pseudo:stormin
Mot de passe:nomadstorm

Si vous avez besoin du programme en Matlab,et les images,je serai à votre disposition.

Voila la matrice:Matrice

http://www.cijoint.fr/cjlink.php?file=c … WGeBy6.txt

yoshi

Modo Ferox

Inscription : 20-11-2005

Messages : 16 991

Re : [Python]Remplacement d'éléments de matrice tant que somme <>0

Salut,

J'ai récupéré ta matrice.
Introduire ça dans Python va demander que j'enregistre tes 4096 nombres dans un fichier pour pouvoir le stocker sur disque (pour pouvoir faire plusieurs essais), puis le charger dans une matrice et faire des tests...
L'astuce de l'arrondi de la somme ne marchant pas, peux-tu essayer de travailler sur des entiers
- en multipliant chaque nombre par 10000,
- en forçant le type int (si cela a un sens en Matlab)
puis en déclenchant le programme...

Pour moi, ce n'est pas la programmation qui est en cause...
La preuve, voilà une matrice avec des entiers qui aboutit à la matrice nulle.
L=[1,2,3,-7,6,2,-8,1,-9,4,5,-13,10,11,-12,3]
Résultat :

Matrice initiale :
  1   2   3  -7
  6   2  -8   1
-9   4   5 -13
10  11 -12   3

Sommes successives :
-1 12 1 -9 3 -3 6 1 -3 5 2 -1 6 4 2 1 0

Matrice modifiée :
    0     0     0     0
    0     0     0     0
    0     0     0     0
    0     0     0     0

Voilà déjà un contre exemple montrant que ce que tu demandes n'est pas toujours possible.
Es-tu certain que tes matrices de départ sonneront cette possibilité ?

@+

---

Arx Tarpeia Capitoli proxima...

stormin

Membre

Inscription : 03-12-2009

Messages : 124

Re : [Python]Remplacement d'éléments de matrice tant que somme <>0

Oui,j'ai abouti à une matrice non nulle et l'arrondissement fait son travail.
Le problème ,c'est que le masque binaire obtenu,diminue le pic mais ,il n'annule pas.

Pouvez vous me donner si possible,ton Email,pour que je vous envois le programme en Matlab ainsi que les images,pour que tu vois de près le résultat.
Et si vous connaissez quelqu'un en Matlab pourra m'aider.

Merci

Dernière modification par stormin (22-05-2011 19:09:46)

yoshi

Modo Ferox

Inscription : 20-11-2005

Messages : 16 991

Re : [Python]Remplacement d'éléments de matrice tant que somme <>0

RE,

Oui,j'ai abouti à une matrice non nulle et l'arrondissement fait son travail.

Oui, répond à quelle question ?
As-tu
- essayé de travailler avec des nombres entiers tous égaux à 10000 fois le nombre correspondant initial,
- fait ensuite tourner le programme,
- redivisé par 10000 les nombres restants non nuls ?

Si oui à ces 3 questions, alors :

Le problème ,c'est que le masque binaire obtenu,diminue le pic mais ,il n'annule pas.

Ne serait-ce pas là un indice de ce que ta théorie ne fonctionne pas ?

Et si vous connaissez quelqu'un en Matlab pourra m'aider.

Non, désolé, les fous de la programmation ne courent déjà pas les rues, alors trouver quelqu'un qui s'intéresse à MatLab à part sur un forum spécialisé comme sur developpez.net, mais ils ne te répondent pas...
Autres forums :
Tu fais précéder ton sujet de la mention [MATLAB] : http://forum.pcinpact.com/forum/45-programmation/
Je ne sais pas s'ils répondent sur Matlab  : http://forum.zebulon.fr/programmation-f … filter=all
Eux, je connais http://www.siteduzero.com/forum-81-127- … oches.html

Si tu es à l'aise en anglais http://www.mathworks.fr/matlabcentral/n … global_nav

Quant à moi, je vais être occupé dans les deux semaines et je n'aurai pas le temps d'apprendre Matlab...
Donc, je vais essayer avec ce que j'ai récupéré...

@+

---

Arx Tarpeia Capitoli proxima...

stormin

Membre

Inscription : 03-12-2009

Messages : 124

Re : [Python]Remplacement d'éléments de matrice tant que somme <>0

As-tu
- essayé de travailler avec des nombres entiers tous égaux à 10000 fois le nombre correspondant initial,
- fait ensuite tourner le programme,
- redivisé par 10000 les nombres restants non nuls ?

Oui.