Discussion :

[linpro.lalaland]

Bonjour à tous,

J'ai une matrice M composée de 3 colonnes et de x lignes.
Je créé des sous-matrice m composée des lignes a à b de M, avec toutes les colonnes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
m = M(a:b , :)

Dans mon travail, j'aimerais renommer ma matrice sachant qu'elle est dans une boucle avec une variable n qui prend des valeurs différentes. Je veux ajouter cette valeur au nom de la matrice ...

1) Comment faire pour rennomer un "sous-matrice" en fonction d'une variable n ?
2) Je m'apperçoit que ma variable n garde toujours sa valeur "1" ... comment faire pour que n=n+1 fonctionne dans mon 1er "if" : if SumZ(lig) >= n*Ztot ?

Voici un exemple de mon script ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

M = horzcat (X, Y, Z) % Je concatènne mes colonne X, Y et Z en une matrice M 

Dlig=length(X)  
Ztot=sum(X)/3      % Comme je veux séparer Z en 3 classes ayant une somme des Z identique, donc je calcul la somme totale de mes Z divisée par 3 pour connaître la valeur que doit approcher chaque classe ...
Deb = 1     % 1ère ligne à prendre en compte pour définir chaque classe

SumZ(1)=Z(1)      % J'initialise ma variable.
n=1    % j'initialise la variable n

    for lig = 2:Dlig 
       SumZ(lig)= SumZ(lig-1)+Z(lig) 
        
       if SumZ(lig) >= n*Ztot 
       
           if SumZ(lig)-(n*Ztot) > (n*Ztot)- SumZ(lig-1) % si l'écart entre cette valeur théorique et Sum.Z(lig) est supérieur à l'écart entre la valeur théorique et Sum.Z(lig-1), alors
               m = M(Deb:lig-1 , :)           
               Deb=lig % 1ère ligne à prendre en compte pour la prochaine classe.

           else % Sinon, c'est-à-dire, si l'écart entre la valeur théorique et Sum.Z(lig) est inférieure à l'écart entre la valeur théorique et Sum.Z(lig-1), alors
               m = M(Deb:lig , :)
               Deb=lig % 1ère ligne à prendre en compte pour la prochaine classe.
           end
           

%% Ma tentative pour renommer mes matrice : Ne marche pas (Message d'erreur : 
Undefined function or variable 'm1'
)
           if n == 1
               m1 = m
           elseif n == 2
               m2 = m
            else
               m3 = m
           end
       

           n = n+1

   
       end
           
    end

Voici le code qui "tourn" avec le fichier en pj ... ExempleScatterBox.txt

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
%% ********************************************************************* %%
%%                          CHOIX DES DONNEES                            %%
%% ********************************************************************* %%
 
% Choix du fichier de débit à utiliser  :
FichierHoule = 'ExempleScatterBox.txt'
 
 
%% ********************************************************************* %%
%%                   ETAPE 1 : Importation des données                   %%              
%% ********************************************************************* %%
 
% Ouverture du fichier texte dans lequel il y a les houles.
fid=fopen(FichierHoule,'r'); % 'r' = open file for reading
 
% Lecture d'un texte formaté. 
m=textscan(fid,'%f %f %f','delimiter');
    % fid : identification du fichier
    % '%f %f %f %f' : Il y a 4 champs numériques
    % 'delimiter' : Champs délimité par un espace.
 
% Fermeture du fichier après lecture.
fclose(fid);
 
X=m{2}; % La colonne 1 de ma matrice m contient les valeurs X.
Y=m{1}; % La colonne 2 de ma matrice m contient les valeurs Y.
Z=m{3}; % La colonne 3 de ma matrice m contient les valeurs Z.
 
 
%% ********************************************************************* %%
%%                     ETAPE 2 : Création du graphe                      %%              
%% ********************************************************************* %%
 
scatter(X,Y,'.k')
 
%% ********************************************************************* %%
%%                     ETAPE 3 : Calcul des cases                        %%              
%% ********************************************************************* %%
 
% Trier les lignes en fonction de X, pour que les valeurs soient rangées
% dans l'ordre croissant.
 
mbis = horzcat (X, Y, Z); % Je concatènne mes colonne X, Y et Z en une matrice 
Tri = sortrows (mbis); % Je tri ma matrice en fonction de ma première colonne
                      % J'aurais pu écrire : Tri = sortrows (mbis, 1)
 
Xbis=Tri(:,1); % La colonne 1 de ma matrice m contient les valeurs X.
Ybis=Tri(:,2); % La colonne 2 de ma matrice m contient les valeurs Y.
Zbis=Tri(:,3); % La colonne 3 de ma matrice m contient les valeurs Z.
 
Dlig=length(X); % Il y a length(X) lignes dans ma matrice. Dlig est le numéro de ma dernière ligne.
Ztot=sum(X)/10; % Comme je veux 10 classes avec une somme des Z identique, je calcul la somme totale de mes Z
Deb = 1 % 1ère ligne à prendre en compte
SumZ=Z(1) % J'initialise ma variable.
n=1 % j'initialise la variable n
 
    for lig = 2:Dlig % Pour chacune des lignes, à partir de la deuxième ...
       SumZ= SumZ + Z(lig) % La somme des Z = La somme déjà calculée + Z(lig)
 
       if SumZ >= n*Ztot % Si ma somme dépasse n*Ztot (la valeur de Z théorique de chacune des 10 cases que je veux dessiner)
 
           if SumZ-(n*Ztot) > (n*Ztot)-(SumZ-Z(lig-1)) % Et si l'écart entre cette valeur théorique et SumZ est supérieur à l'écart entre la valeur théorique et SumZ-Z(lig-1), alors
               C = mbis(Deb:lig-1 , :)         
               Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.
 
           else % Sinon, c'est-à-dire, si l'écart entre la valeur théorique et Sum.Z(lig) est inférieure à l'écart entre la valeur théorique et Sum.Z(lig-1), alors
               C = mbis(Deb:lig , :)
               Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.
           end
 
           if n == 1
               C1 = C
           elseif n == 2
               C2 = C
           elseif n == 3
               C3 = C
           elseif n == 4
               C4 = C
           elseif n == 5
               C5 = C
           elseif n == 6
               C6 = C
           elseif n == 7
               C7 = C
           elseif n == 8
               C8 = C
           elseif n == 9
               C9 = C
           else
               C10 = C
           end
         n = n+1
       end
 
    end

[shaiHulud]

Bonjour,

1/ Il est déconseillé d'avoir des noms de variables indexé par ton n. Il vaut mieux créer un cell array vide, et insérer à l'emplacement n la matrice qui tintéresse

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
all_matrices={};
for n=1:10; all_matrices{n} = eye(n);end

2/ Ce n'est pas possible dans une boucle for (ceci est spécifique à Matlab), car la variable n que tu as modifiée dans l'itération de la boucle sera écrasée par la nouvelle valeur de l'instruction for. Il faut passer par une boucle while.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
for k=1:10; disp(k); k=0;end % oublie la valeur assignée
k=1; while k< 10; disp(k); k=k+1;end % ok

[linpro.lalaland]

Merci VV33D pour ta réponse.


Dans ta première explication, tu me donne ce code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
all_matrices={};
for n=1:10; all_matrices{n} = eye(n);end

Si je comprends bien "all_matrices={}" me permet de créer une matrice vide.
La deuxième partie m'intrigue : Elle permet de créer 10 matrices dans l'array all_matrices de dimension n x n ?

->> Aide MatLab :

%EYE Identity matrix.
% EYE(N) is the N-by-N identity matrix

[shaiHulud]

Si je comprends bien "all_matrices={}" me permet de créer une matrice vide.

non, cela crée un cell-array vide (une matrice vide s'écrirait []). c'est un conteneur de type hétérogène. Tu peux mettre ce que tu veux dans chaque case, des matrices, des strings (alors qu'une matrice ne contient que du numérique). Par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
x= {0, ones(2,2),'bonjour'};

la seconde ligne remplit les 10 premières cases de ce cell array avec des matrices de tailles différentes.

[linpro.lalaland]

J'ai essayé d'appliquer tes conseils. Mais j'ai encore un problème dans ma boucle WHILE. Les calculs s'arrêtent à lig=12 alors qu'on devrait aller jusqu'à lig=601.
Le calcul s'arrête à cause de :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
       if SumZ >= sum(Zbis)
       break
       end

Que j'ai rajouté car sinon Matlab calculait indifiniement (rectification : c'est long si j'oubli de mettre ";" après SumZ= SumZ + Zbis(lig)...). Sans doute à cause d'une erreur que je n'arrive pas à situer. J'ai juste remarqué que :

sum(Zbis) = 2.7127e+03
Normalement, à lig=12, SumZ= 31.9000
mais quand je lance le calcul à lig=12, SumZ = 2.7154e+03
et si je laisse aller jusqu'au bout SumZ = 1.6276e+05

Je vous joins la troisième partie de mon code que j'ai modifiée. Le reste est plus haut avec le fichier texte ... Si quelqu'un sait me dire où je me suis trompée, ça serait génial !!!

Merci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
%% ********************************************************************* %%
%%                     ETAPE 3 : Calcul des cases                        %%              
%% ********************************************************************* %%
 
% Trier les lignes en fonction de X, pour que les valeurs soient rangées
% dans l'ordre croissant.
 
Matrice = horzcat (X, Y, Z); % Je concatènne mes colonne X, Y et Z en une matrice 
Tri = sortrows (Matrice); % Je tri ma matrice en fonction de ma première colonne
                      % J'aurais pu écrire : Tri = sortrows (matrice, 1)
 
Xbis=Tri(:,1); % La colonne 1 de ma matrice m contient les valeurs X.
Ybis=Tri(:,2); % La colonne 2 de ma matrice m contient les valeurs Y.
Zbis=Tri(:,3); % La colonne 3 de ma matrice m contient les valeurs Z.
 
Dlig=length(Xbis); % Il y a length(X) lignes dans ma matrice. Dlig est le numéro de ma dernière ligne.
Ztot=sum(Zbis)/10; % Comme je veux 10 classes avec une somme des Z identique, je calcule la somme totale de mes Z
Deb = 1 % 1ère ligne à prendre en compte
SumZ=Zbis(1) % J'initialise ma variable.
 
% Je crée un cell-array vide. c'est un conteneur de type hétérogène. Je peux mettre ce que 
% je veux dans chaque case, des matrices, des strings (alors qu'une matrice ne contient que du numérique)
all_matrices={};
for n=1:10; 
all_matrices{n} = eye(n);
end
 
    n=1 % j'initialise la variable n
    lig=2
    while lig < Dlig+1 % Pour chacune des lignes, à partir de la deuxième ...
       SumZ= SumZ + Zbis(lig); % La somme des Z = La somme déjà calculée + Z(lig)
 
       if SumZ >= n*Ztot % Si ma somme dépasse n*Ztot (la valeur de Z théorique de chacune des 10 cases que je veux dessiner)
 
           if SumZ-(n*Ztot) > (n*Ztot)-(SumZ-Zbis(lig-1)) % Et si l'écart entre cette valeur théorique et SumZ est supérieur à l'écart entre la valeur théorique et SumZ-Z(lig-1), alors
               % C = Matrice(Deb:lig-1 , :) 
               all_matrices{n} = Matrice(Deb:lig-1 , :);
               Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.
 
           else % Sinon, c'est-à-dire, si l'écart entre la valeur théorique et Sum.Z(lig) est inférieure à l'écart entre la valeur théorique et Sum.Z(lig-1), alors
               % C = Matrice(Deb:lig , :)
               all_matrices{n} = Matrice(Deb:lig , :);
               Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.
           end
 
         n = n+1
         lig = lig+1
       end
 
       if SumZ >= sum(Zbis)
       break
       end
 
    end

[shaiHulud]

Il ne faut pas faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
for n=1:10; 
all_matrices{n} = eye(n);
end

Ce n’était qu'un exemple d'utilisation. Tu dois juste faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

all_matrices={};

Puis à chaque fois que tu voulais définir sous_matrice_n, utilises all_matrices{n} la place.
C'est juste un moyen de référencer plusieurs sous-matrices dont le nom dépendrait de n !

[linpro.lalaland]

J'ai oublié de l'enlevé
(Comment paraître plus tête en l'air qu'on ne l'est déjà !!)

J'ai trouvé d'où vient le problème ... Et je l'ai réglé (J'ai modifié le message précédent pendant que tu me répondais).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
         n = n+1
         lig = lig+1

Ces deux lignes sont toujours dans une boucle : IF
Jusque là, rien de bien grave. Sauf que 'lig = lig+1' doit être calculé pour chaque itération de WHILE et non pas uniquement lorsque la condition 'if SumZ >= n*Ztot' est vérifiée ...

Pour ceux que ça peut aider, je mets le script qui est ok :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
%% ********************************************************************* %%
%%                     ETAPE 3 : Calcul des cases                        %%              
%% ********************************************************************* %%
 
% Trier les lignes en fonction de X, pour que les valeurs soient rangées
% dans l'ordre croissant.
 
Matrice = horzcat (X, Y, Z); % Je concatènne mes colonne X, Y et Z en une matrice 
Tri = sortrows (Matrice); % Je tri ma matrice en fonction de ma première colonne
                      % J'aurais pu écrire : Tri = sortrows (matrice, 1)
 
Xbis=Tri(:,1); % La colonne 1 de ma matrice m contient les valeurs X.
Ybis=Tri(:,2); % La colonne 2 de ma matrice m contient les valeurs Y.
Zbis=Tri(:,3); % La colonne 3 de ma matrice m contient les valeurs Z.
 
Dlig=length(Xbis); % Il y a length(X) lignes dans ma matrice. Dlig est le numéro de ma dernière ligne.
Ztot=sum(Zbis)/10; % Comme je veux 10 classes avec une somme des Z identique, je calcule la somme totale de mes Z
Deb = 1 % 1ère ligne à prendre en compte
SumZ=Zbis(1) % J'initialise ma variable.
 
% Je crée un cell-array vide. c'est un conteneur de type hétérogène. Je peux mettre ce que 
% je veux dans chaque case, des matrices, des strings (alors qu'une matrice ne contient que du numérique)
all_matrices={};
 
    n=1 % j'initialise la variable n
    lig=2
    while lig < Dlig+1 % Pour chacune des lignes, à partir de la deuxième ...
       SumZ= SumZ + Zbis(lig); % La somme des Z = La somme déjà calculée + Z(lig)
 
       if SumZ >= n*Ztot % Si ma somme dépasse n*Ztot (la valeur de Z théorique de chacune des 10 cases que je veux dessiner)
 
           if SumZ-(n*Ztot) > (n*Ztot)-(SumZ-Zbis(lig-1)) % Et si l'écart entre cette valeur théorique et SumZ est supérieur à l'écart entre la valeur théorique et SumZ-Z(lig-1), alors
               % C = Matrice(Deb:lig-1 , :) 
               all_matrices{n} = Matrice(Deb:lig-1 , :);
               Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.
 
           else % Sinon, c'est-à-dire, si l'écart entre la valeur théorique et Sum.Z(lig) est inférieure à l'écart entre la valeur théorique et Sum.Z(lig-1), alors
               % C = Matrice(Deb:lig , :)
               all_matrices{n} = Matrice(Deb:lig , :);
               Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.
           end
 
         n = n+1
       end
 
%        if SumZ >= sum(Zbis)
%        break
%        end
      lig = lig+1   
    end

Encore merci VV33D, une fois de plus tu m'auras bien aidée !!


A+

[linpro.lalaland]

J'ai encore une petite question.

Comment je peux faire pour attribuer un nom à chacune des 3 colonnes de mes 10 matrices ? Ou comment puis-je faire appel à elles ...

>> J'ai un tableau de 3 colonnes (X, Y, Z) et 601 lignes.
>> J'ai réorganisé trié les lignes de ce tableau en fonction de la colonne X
>> J'ai découpé ce tableau en 10 sous-tableaux qui ont une sum(Z) identique.

Maintenant, je veux pour chacun de ces sous-tableaux :
>> Trier les lignes en fonction de la colonne Y (et non plus X)
>> Découper de la même façon que précédemment ces sous-tableaux en 10 sous-sous tableaux qui ont une sum(Z) identique (et après j’arrête !!).

Du coup j'ai besoin de pouvoir travailler avec chacune des colonnes, et l'écriture NomMatrice={} me perturbe ...
est-ce que je dois écrire, en prenant l'exemple su tri :

Tri = sortrows (all_matrices{n},2); ??


Merci d'avance ...
Il y a de l'aide ici : http://matlab.developpez.com/faq/?page=cellarray
Mais je n'ai toujours pas trouver ma réponse

[linpro.lalaland]

A priori ça marche.

Pour les curieux, voici la 4ème partie de mon script ... je crois ne pas avoir d'erreur ... Je suis en train de vérifier

.... Ca ne marche pas ... il y a encore un problème .... c ne s'arrête pas à 10 .... à suivre !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
%% ********************************************************************* %%
%%             ETAPE 4 : Calcul des classes en focntion de Y             %%              
%% ********************************************************************* %%
clear Deb Tri Dlig Ztot Deb  SumZ n lig
 
% Trier les lignes en fonction de X, pour que les valeurs soient rangées
% dans l'ordre croissant, POUR CHAQUE all_matrices{n}
 
for n = 1 : 10
 
    Tri = sortrows (all_matrices{n},2); % Je tri ma matrice en fonction de ma deuxième colonne.
 
    Xter=Tri(:,1); % La colonne 1 de ma matrice Tri contient les valeurs X.
    Yter=Tri(:,2); % La colonne 2 de ma matrice Tri contient les valeurs Y.
    Zter=Tri(:,3); % La colonne 3 de ma matrice Tri contient les valeurs Z.
 
    Dlig=length(Yter); % Il y a length(X) lignes dans ma matrice. Dlig est le numéro de ma dernière ligne.
    Ztot=sum(Zter)/10; % Je veux 10 classes pour chacune des 10 matrices qui 
      % contiennent déjà 1/10ème du Z total. Donc ici Ztot correspond à 1/10 du Ztot de l'etape 3..
    Deb = 1 % 1ère ligne à prendre en compte
 
    SumZ=Zter(1) % J'initialise ma variable. ...DANS QUELLE SOUS-MATRICE  ?
 
    % Je crée un cell-array vide. c'est un conteneur de type hétérogène. Je peux mettre ce que 
    % je veux dans chaque case, des matrices, des strings (alors qu'une matrice ne contient que du numérique)
    all_matrices2={};
 
        c=1 % j'initialise la variable n qui représente les colonnes de all_matrices{c,n}
        lig=2
        while lig < Dlig+1 % Pour chacune des lignes, à partir de la deuxième ...
           SumZ= SumZ + Zter(lig); % La somme des Z = La somme déjà calculée + Z(lig)
 
           if SumZ >= n*Ztot % Si ma somme dépasse n*Ztot (la valeur de Z théorique de chacune des 10 cases que je veux dessiner)
 
               if SumZ-(n*Ztot) > (n*Ztot)-(SumZ-Zter(lig-1)) % Et si l'écart entre cette valeur théorique et SumZ est supérieur à l'écart entre la valeur théorique et SumZ-Z(lig-1), alors
                   % C = Matrice(Deb:lig-1 , :) 
                   all_matrices2{c} = Matrice(Deb:lig-1 , :);
                   Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.
 
               else % Sinon, c'est-à-dire, si l'écart entre la valeur théorique et Sum.Z(lig) est inférieure à l'écart entre la valeur théorique et Sum.Z(lig-1), alors
                   % C = Matrice(Deb:lig , :)
                   all_matrices2{c} = Matrice(Deb:lig , :);
                   Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.
               end
 
             c = c+1
           end
 
    %        if SumZ >= sum(Zbis)
    %        break
    %        end
          lig = lig+1   
        end
 
end

[shaiHulud]

pas sur d'avoir tout compris. Quelques éléments:
* Pour trier une matrice m suivant la colonne 2:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
[~,i]= sort(m(:,2));
ms= m(i,:); % matrice ordonnées

Tri = sortrows (all_matrices{n},2); ??

Oui, ca me semble bien.

l'écriture NomMatrice={} me perturbe ...

Fais une boucle sur n=1:length(NomMatrice), et a chaque fois traite NomMatrice{n}, par exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
all_matrice_sort= {};
for n=1:length(all_matrice)
[~,i]= sort(all_matrice{n}(:,2));
all_matrice_sort = all_matrice{n}(i,:);
end

Tu peux aussi apprendre à utiliser cellfun

[linpro.lalaland]

.... Ca ne marche pas ... il y a encore un problème .... c ne s'arrête pas à 10 .... à suivre !

Pour préciser :
>> j'ai fait la somme de la colonne Zter pour chaque all_matrices{n} (avec n qui va de 1 à 10).
>> J'ai divisé cette somme par 10 pour connaître la somme optimale de Zter que doit contenir chacunes des all_matrices2{n,c}
>> J'ai donc 10 matrices all_matrices{n} que je dois re-découper en 10 all_matrices2{n,c} ... J'aurai donc 100 all_matrices2{n,c} !
>> pour cela je devrais avoir c qui varie de 1 à 10 ...
>> En fait il varie de 1 à 10 puis repart c=1 ..... c=2 ... et stop ... :/

J'ai beau regarder dans tous les sens, je ne trouve pas d'où peut venir l'erreur.
Ztot=sum(Zbis)/10 pour l'étape 3
Ztot2=sum(Zter)/10 pour l'étape 4 ne montrent que les Ztot théorique que je devrais avoir dans mes matrices all_matrices{n} d'une part et all_matrices2{n,c} d'autre part.

Le nombre de valeurs placées dans les matrices all_matrices2{n,c} est donc variable, et la somme des Ztot2 aussi ...
J'ai donc recalculé le nombre de lignes (Dlig=length(Yter)), Ztot2 (Ztot2=sum(Zter)/10).

Mais je ne comprends pas pourquoi, je n'arrive pas à garder c entre 1 et 10 sans répétition.

je remets tout le script et le fichier texte.
J'espère que quelqu'un pourra m'aider.
ExempleScatterBox.txt

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
%% ********************************************************************* %%
%%                          CHOIX DES DONNEES                            %%
%% ********************************************************************* %%
 
% Choix du fichier de débit à utiliser  :
FichierHoule = 'ExempleScatterBox.txt'
 
 
%% ********************************************************************* %%
%%                   ETAPE 1 : Importation des données                   %%              
%% ********************************************************************* %%
 
% Ouverture du fichier texte dans lequel il y a les houles.
fid=fopen(FichierHoule,'r'); % 'r' = open file for reading
 
% Lecture d'un texte formaté. 
m=textscan(fid,'%f %f %f','delimiter');
    % fid : identification du fichier
    % '%f %f %f %f' : Il y a 4 champs numériques
    % 'delimiter' : Champs délimité par un espace.
 
% Fermeture du fichier après lecture.
fclose(fid);
 
X=m{2}; % La colonne 1 de ma matrice m contient les valeurs X.
Y=m{1}; % La colonne 2 de ma matrice m contient les valeurs Y.
Z=m{3}; % La colonne 3 de ma matrice m contient les valeurs Z.
 
 
%% ********************************************************************* %%
%%                     ETAPE 2 : Création du graphe                      %%              
%% ********************************************************************* %%
 
%%%%%%%%%    scatter(X,Y,'.k')
 
%% ********************************************************************* %%
%%             ETAPE 3 : Calcul des classes en focntion de X             %%              
%% ********************************************************************* %%
 
% Trier les lignes en fonction de X, pour que les valeurs soient rangées
% dans l'ordre croissant.
 
Matrice = horzcat (X, Y, Z); % Je concatènne mes colonne X, Y et Z en une matrice 
Tri = sortrows (Matrice); % Je tri ma matrice en fonction de ma première colonne
                      % J'aurais pu écrire : Tri = sortrows (matrice, 1)
 
Xter=Tri(:,1); % La colonne 1 de ma matrice Tri contient les valeurs X.
Yter=Tri(:,2); % La colonne 2 de ma matrice Tri contient les valeurs Y.
Zter=Tri(:,3); % La colonne 3 de ma matrice Tri contient les valeurs Z.
 
Dlig=length(Xter); % Il y a length(X) lignes dans ma matrice. Dlig est le numéro de ma dernière ligne.
Ztot=sum(Zter)/10; % Comme je veux 10 classes avec une somme des Z identique, je calcule la somme totale de mes Z
Deb = 1 % 1ère ligne à prendre en compte
SumZbis=Zter(1) % J'initialise ma variable.
 
% Je crée un cell-array vide. c'est un conteneur de type hétérogène. Je peux mettre ce que 
% je veux dans chaque case, des matrices, des strings (alors qu'une matrice ne contient que du numérique)
all_matrices={};
 
    n=1 % j'initialise la variable n qui représente les colonnes de all_matrices{c,n}
    lig=2
    while lig < Dlig+1 % Pour chacune des lignes, à partir de la deuxième ...
       SumZbis= SumZbis + Zter(lig); % La somme des Z = La somme déjà calculée + Z(lig)
 
       if SumZbis >= n*Ztot % Si ma somme dépasse n*Ztot (la valeur de Z théorique de chacune des 10 cases que je veux dessiner)
 
           if SumZbis-(n*Ztot) > (n*Ztot)-(SumZbis-Zter(lig-1)) % Et si l'écart entre cette valeur théorique et SumZ est supérieur à l'écart entre la valeur théorique et SumZ-Z(lig-1), alors
               all_matrices{n} = Matrice(Deb:lig-1 , :);
               Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.
 
           else % Sinon, c'est-à-dire, si l'écart entre la valeur théorique et Sum.Z(lig) est inférieure à l'écart entre la valeur théorique et Sum.Z(lig-1), alors
               all_matrices{n} = Matrice(Deb:lig , :);
               Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.
           end
 
         n = n+1
       end
 
%        if SumZ >= sum(Zbis)
%        break
%        end
      lig = lig+1   
    end
 
%% ********************************************************************* %%
%%             ETAPE 4 : Calcul des classes en focntion de Y             %%              
%% ********************************************************************* %%
clear Deb Tri Dlig n lig
 
% Trier les lignes en fonction de X, pour que les valeurs soient rangées
% dans l'ordre croissant, POUR CHAQUE all_matrices{n}
 
for n = 1 : 10  
 
    Tri = sortrows (all_matrices{n},2); % Je tri ma matrice en fonction de ma deuxième colonne.
 
    Xter=Tri(:,1); % La colonne 1 de ma matrice Tri contient les valeurs X.
    Yter=Tri(:,2); % La colonne 2 de ma matrice Tri contient les valeurs Y.
    Zter=Tri(:,3); % La colonne 3 de ma matrice Tri contient les valeurs Z.
 
    Dlig=length(Yter); % Il y a length(X) lignes dans ma matrice. Dlig est le numéro de ma dernière ligne.
    Ztot2=sum(Zter)/10; % Je veux 10 classes pour chacune des 10 matrices qui 
      % contiennent déjà 1/10ème du Z total. Donc ici Ztot correspond à 1/10 du Ztot de l'etape 3..
    Deb = 1 % 1ère ligne à prendre en compte
 
    SumZter=Zter(1) % J'initialise ma variable. ...DANS QUELLE SOUS-MATRICE  ? 
 
    % Je crée un cell-array vide. c'est un conteneur de type hétérogène. Je peux mettre ce que 
    % je veux dans chaque case, des matrices, des strings (alors qu'une matrice ne contient que du numérique)
    all_matrices2={};
 
        c=1 % j'initialise la variable n qui représente les colonnes de all_matrices{c,n}
        lig=2
        while lig < Dlig+1 % Pour chacune des lignes, à partir de la deuxième ...
           SumZter= SumZter + Zter(lig); % La somme des Z = La somme déjà calculée + Z(lig)
 
           if SumZter >= n*Ztot2 % Si ma somme dépasse n*Ztot (la valeur de Z théorique de chacune des 10 cases que je veux dessiner)
 
               if SumZter-(n*Ztot2) > (n*Ztot2)-(SumZter-Zter(lig-1)) % Et si l'écart entre cette valeur théorique et SumZ est supérieur à l'écart entre la valeur théorique et SumZ-Z(lig-1), alors
                   all_matrices2{n,c} = Matrice(Deb:lig-1 , :);
                   Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.
 
               else % Sinon, c'est-à-dire, si l'écart entre la valeur théorique et Sum.Z(lig) est inférieure à l'écart entre la valeur théorique et Sum.Z(lig-1), alors
                   all_matrices2{n,c} = Matrice(Deb:lig , :);
                   Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.
               end
 
             c = c+1
           end
 
    %        if SumZ >= sum(Zbis)
    %        break
    %        end
          lig = lig+1   
        end
 
end

[linpro.lalaland]

Quand je fais tourner :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
for n=1:10
Tri = sortrows (all_matrices{n},2); % Je tri ma matrice en fonction de ma deuxième colonne.
Dlig=length(Yter); 
end

Et que je somme les 10 valeurs Dlig, je trouve 606 au lieu de 602 :/

Peut-être que j'ain une erreur qui vient de l'étape 3 en fait ...

[linpro.lalaland]

J'ai trouvé !!

j'avais bien une erreur d'étourderie dans la partie "etape 3" ... J'avais oublié un "+1" ... donc j'avais des lignes comptées 2 fois ...
J'ai réctifié cet étourderie dans les 2 parties concernées !!

Merci pour ta forte participation VV33D

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
n=1 % j'initialise la variable n qui représente les colonnes de all_matrices{c,n}
    lig=2
    while lig < Dlig+1 % Pour chacune des lignes, à partir de la deuxième ...
       SumZbis= SumZbis + Zter(lig); % La somme des Z = La somme déjà calculée + Z(lig)
        
       if SumZbis >= n*Ztot % Si ma somme dépasse n*Ztot (la valeur de Z théorique de chacune des 10 cases que je veux dessiner)
   
           if SumZbis-(n*Ztot) > (n*Ztot)-(SumZbis-Zter(lig-1)) % Et si l'écart entre cette valeur théorique et SumZ est supérieur à l'écart entre la valeur théorique et SumZ-Z(lig-1), alors
               all_matrices{n} = Matrice(Deb:lig-1 , :);
               Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.

           else % Sinon, c'est-à-dire, si l'écart entre la valeur théorique et Sum.Z(lig) est inférieure à l'écart entre la valeur théorique et Sum.Z(lig-1), alors
               all_matrices{n} = Matrice(Deb:lig , :);
               Deb=lig+1 % 1ère ligne à prendre en compte pour la prochaine case.
           end

         n = n+1
       end
       
%        if SumZ >= sum(Zbis)
%        break
%        end
      lig = lig+1   
    end

[linpro.lalaland]

Faux espoir ...

En voulant continuer mon travail (autre post ...), je me suis aperçue que mes matrices all_matrices2{n,c} sont vides ... en fait elles n'existent pas je crois :

>> all_matrices2{n,c}
Index exceeds matrix dimensions.

J'ai le même message si je remplace n et c par des chiffres ...


Les matrices all_matrices{n} de mon Etape 3 sont ok. j'ai donc encore un soucis avec mon Etape 4 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
%% ********************************************************************* %%
%%             ETAPE 4 : Calcul des classes en focntion de Y             %%              
%% ********************************************************************* %%
clear Deb Tri Dlig n lig
 
% Trier les lignes en fonction de X, pour que les valeurs soient rangées
% dans l'ordre croissant, POUR CHAQUE all_matrices{n}
 Nbligtot = 0
for n = 1 : 10  
 
        Tri = sortrows (all_matrices{n},2); % Je tri ma matrice en fonction de ma deuxième colonne.
 
        Xter=Tri(:,1); % La colonne 1 de ma matrice Tri contient les valeurs X.
        Yter=Tri(:,2); % La colonne 2 de ma matrice Tri contient les valeurs Y.
        Zter=Tri(:,3); % La colonne 3 de ma matrice Tri contient les valeurs Z.
 
        Dlig=length(Yter); % Il y a length(X) lignes dans ma matrice. Dlig est le numéro de ma dernière ligne.
        Ztot2=sum(Zter)/10; % Je veux 10 classes pour chacune des 10 matrices qui 
          % contiennent déjà 1/10ème du Z total. Donc ici Ztot correspond à 1/10 du Ztot de l'etape 3..
        Deb = 1; % 1ère ligne à prendre en compte
 
        SumZter=Zter(1); % J'initialise ma variable. ...DANS QUELLE SOUS-MATRICE  ? 
 
        % Je crée un cell-array vide. c'est un conteneur de type hétérogène. Je peux mettre ce que 
        % je veux dans chaque case, des matrices, des strings (alors qu'une matrice ne contient que du numérique)
        all_matrices2={};
 
            nblig=1;
            c=1; % j'initialise la variable n qui représente les colonnes de all_matrices{c,n}
            lig=2;
            while lig < Dlig+1 % Pour chacune des lignes, à partir de la deuxième ...
               SumZter= SumZter + Zter(lig) % La somme des Z = La somme déjà calculée + Z(lig)
 
               if SumZter >= n*Ztot2 % Si ma somme dépasse n*Ztot (la valeur de Z théorique de chacune des 10 cases que je veux dessiner)
 
                   if SumZter-(n*Ztot2) > (n*Ztot2)-(SumZter-Zter(lig-1)) % Et si l'écart entre cette valeur théorique et SumZ est supérieur à l'écart entre la valeur théorique et SumZ-Z(lig-1), alors
                       all_matrices2{n,c} = Matrice(Deb:lig-1 , :);
                       Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.
 
                   else % Sinon, c'est-à-dire, si l'écart entre la valeur théorique et Sum.Z(lig) est inférieure à l'écart entre la valeur théorique et Sum.Z(lig-1), alors
                       all_matrices2{n,c} = Matrice(Deb:lig , :);
                       Deb=lig+1 % 1ère ligne à prendre en compte pour la prochaine case.
                   end
 
                 c = c+1
               end
 
    %            if c > 10
    %            break
    %            end
              lig = lig+1
              nblig=nblig+1;
              c
            end
        Nbligtot = Nbligtot + nblig
 
end

L'indice n est fixé par la boucle FOR et l'indice c par la condition IF.
Peut-être existe-t'il un problème de compatibilité ?
L'indice c change bien de valeur pendant le calcul, mais il dépasse 10 ... ce qui n'est pas normal ... je suis en train de voir ce problème là.

Quelqu'un saurait me dire pourquoi mes matrices all_matrices2{n,c} ne semblent pas exister ?




Script complet :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
%% ********************************************************************* %%
%%                          CHOIX DES DONNEES                            %%
%% ********************************************************************* %%
 
% Choix du fichier de débit à utiliser  :
FichierHoule = 'ExempleScatterBox.txt'
 
 
%% ********************************************************************* %%
%%                   ETAPE 1 : Importation des données                   %%              
%% ********************************************************************* %%
 
% Ouverture du fichier texte dans lequel il y a les houles.
fid=fopen(FichierHoule,'r'); % 'r' = open file for reading
 
% Lecture d'un texte formaté. 
m=textscan(fid,'%f %f %f','delimiter');
    % fid : identification du fichier
    % '%f %f %f %f' : Il y a 4 champs numériques
    % 'delimiter' : Champs délimité par un espace.
 
% Fermeture du fichier après lecture.
fclose(fid);
 
X=m{2}; % La colonne 1 de ma matrice m contient les valeurs X.
Y=m{1}; % La colonne 2 de ma matrice m contient les valeurs Y.
Z=m{3}; % La colonne 3 de ma matrice m contient les valeurs Z.
 
 
%% ********************************************************************* %%
%%                     ETAPE 2 : Création du graphe                      %%              
%% ********************************************************************* %%
 
scatter(X,Y,'.k')
drawnow
 
%% ********************************************************************* %%
%%             ETAPE 3 : Calcul des classes en focntion de X             %%              
%% ********************************************************************* %%
 
% Trier les lignes en fonction de X, pour que les valeurs soient rangées
% dans l'ordre croissant.
 
Matrice = horzcat (X, Y, Z); % Je concatènne mes colonne X, Y et Z en une matrice 
Tri = sortrows (Matrice); % Je tri ma matrice en fonction de ma première colonne
                      % J'aurais pu écrire : Tri = sortrows (matrice, 1)
 
Xter=Tri(:,1); % La colonne 1 de ma matrice Tri contient les valeurs X.
Yter=Tri(:,2); % La colonne 2 de ma matrice Tri contient les valeurs Y.
Zter=Tri(:,3); % La colonne 3 de ma matrice Tri contient les valeurs Z.
 
Dlig=length(Xter); % Il y a length(X) lignes dans ma matrice. Dlig est le numéro de ma dernière ligne.
Ztot=sum(Zter)/10; % Comme je veux 10 classes avec une somme des Z identique, je calcule la somme totale de mes Z
Deb = 1 % 1ère ligne à prendre en compte
SumZbis=Zter(1) % J'initialise ma variable.
 
% Je crée un cell-array vide. c'est un conteneur de type hétérogène. Je peux mettre ce que 
% je veux dans chaque case, des matrices, des strings (alors qu'une matrice ne contient que du numérique)
all_matrices={};
 
    n=1 % j'initialise la variable n qui représente les colonnes de all_matrices{c,n}
    lig=2
    while lig < Dlig+1 % Pour chacune des lignes, à partir de la deuxième ...
       SumZbis= SumZbis + Zter(lig); % La somme des Z = La somme déjà calculée + Z(lig)
 
       if SumZbis >= n*Ztot % Si ma somme dépasse n*Ztot (la valeur de Z théorique de chacune des 10 cases que je veux dessiner)
 
           if SumZbis-(n*Ztot) > (n*Ztot)-(SumZbis-Zter(lig-1)) % Et si l'écart entre cette valeur théorique et SumZ est supérieur à l'écart entre la valeur théorique et SumZ-Z(lig-1), alors
               all_matrices{n} = Matrice(Deb:lig-1 , :);
               Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.
 
           else % Sinon, c'est-à-dire, si l'écart entre la valeur théorique et Sum.Z(lig) est inférieure à l'écart entre la valeur théorique et Sum.Z(lig-1), alors
               all_matrices{n} = Matrice(Deb:lig , :);
               Deb=lig+1 % 1ère ligne à prendre en compte pour la prochaine case.
           end
 
         n = n+1
       end
 
%        if SumZ >= sum(Zbis)
%        break
%        end
      lig = lig+1   
    end
 
%% ********************************************************************* %%
%%             ETAPE 4 : Calcul des classes en focntion de Y             %%              
%% ********************************************************************* %%
clear Deb Tri Dlig n lig
 
% Trier les lignes en fonction de X, pour que les valeurs soient rangées
% dans l'ordre croissant, POUR CHAQUE all_matrices{n}
 Nbligtot = 0
for n = 1 : 10  
 
        Tri = sortrows (all_matrices{n},2); % Je tri ma matrice en fonction de ma deuxième colonne.
 
        Xter=Tri(:,1); % La colonne 1 de ma matrice Tri contient les valeurs X.
        Yter=Tri(:,2); % La colonne 2 de ma matrice Tri contient les valeurs Y.
        Zter=Tri(:,3); % La colonne 3 de ma matrice Tri contient les valeurs Z.
 
        Dlig=length(Yter); % Il y a length(X) lignes dans ma matrice. Dlig est le numéro de ma dernière ligne.
        Ztot2=sum(Zter)/10; % Je veux 10 classes pour chacune des 10 matrices qui 
          % contiennent déjà 1/10ème du Z total. Donc ici Ztot correspond à 1/10 du Ztot de l'etape 3..
        Deb = 1; % 1ère ligne à prendre en compte
 
        SumZter=Zter(1); % J'initialise ma variable. ...DANS QUELLE SOUS-MATRICE  ? 
 
        % Je crée un cell-array vide. c'est un conteneur de type hétérogène. Je peux mettre ce que 
        % je veux dans chaque case, des matrices, des strings (alors qu'une matrice ne contient que du numérique)
        all_matrices2={};
 
            nblig=1;
            c=1; % j'initialise la variable n qui représente les colonnes de all_matrices{c,n}
            lig=2;
            while lig < Dlig+1 % Pour chacune des lignes, à partir de la deuxième ...
               SumZter= SumZter + Zter(lig) % La somme des Z = La somme déjà calculée + Z(lig)
 
               if SumZter >= n*Ztot2 % Si ma somme dépasse n*Ztot (la valeur de Z théorique de chacune des 10 cases que je veux dessiner)
 
                   if SumZter-(n*Ztot2) > (n*Ztot2)-(SumZter-Zter(lig-1)) % Et si l'écart entre cette valeur théorique et SumZ est supérieur à l'écart entre la valeur théorique et SumZ-Z(lig-1), alors
                       all_matrices2{n,c} = Matrice(Deb:lig-1 , :);
                       Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.
 
                   else % Sinon, c'est-à-dire, si l'écart entre la valeur théorique et Sum.Z(lig) est inférieure à l'écart entre la valeur théorique et Sum.Z(lig-1), alors
                       all_matrices2{n,c} = Matrice(Deb:lig , :);
                       Deb=lig+1 % 1ère ligne à prendre en compte pour la prochaine case.
                   end
 
                 c = c+1
               end
 
    %            if c > 10
    %            break
    %            end
              lig = lig+1
              nblig=nblig+1;
              c
            end
        Nbligtot = Nbligtot + nblig
 
end

[linpro.lalaland]

Je viens de régler une petite partie du problème ...
all_matrices2={}; était dans la boucle FOR et il était donc réinitialisé à chaque fois ...
l'array all_matrices2{n,c} n'est plus vide. Mais toutes les cases ne sont pas remplies.

Je crois que c'est lié au fait que c ne prend pas que des valeurs de 1 à 10 ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
%% ********************************************************************* %%
%%             ETAPE 4 : Calcul des classes en focntion de Y             %%              
%% ********************************************************************* %%
clear Deb Tri Dlig n lig


% Je crée un cell-array vide. c'est un conteneur de type hétérogène. Je peux mettre ce que 
% je veux dans chaque case, des matrices, des strings (alors qu'une matrice ne contient que du numérique)
all_matrices2={};

% Trier les lignes en fonction de X, pour que les valeurs soient rangées
% dans l'ordre croissant, POUR CHAQUE all_matrices{n}
 Nbligtot = 0
for n = 1 : 10  
    
        Tri = sortrows (all_matrices{n},2); % Je tri ma matrice en fonction de ma deuxième colonne.

        Xter=Tri(:,1); % La colonne 1 de ma matrice Tri contient les valeurs X.
        Yter=Tri(:,2); % La colonne 2 de ma matrice Tri contient les valeurs Y.
        Zter=Tri(:,3); % La colonne 3 de ma matrice Tri contient les valeurs Z.

        Dlig=length(Yter); % Il y a length(X) lignes dans ma matrice. Dlig est le numéro de ma dernière ligne.
        Ztot2=sum(Zter)/10; % Je veux 10 classes pour chacune des 10 matrices qui 
          % contiennent déjà 1/10ème du Z total. Donc ici Ztot correspond à 1/10 du Ztot de l'etape 3..
        Deb = 1; % 1ère ligne à prendre en compte

        SumZter=Zter(1); % J'initialise ma variable. ...DANS QUELLE SOUS-MATRICE  ? 

            nblig=1;
            c=1; % j'initialise la variable n qui représente les colonnes de all_matrices{c,n}
            lig=2;
            while lig < Dlig+1 % Pour chacune des lignes, à partir de la deuxième ...
               SumZter= SumZter + Zter(lig) % La somme des Z = La somme déjà calculée + Z(lig)

               if SumZter >= n*Ztot2 % Si ma somme dépasse n*Ztot (la valeur de Z théorique de chacune des 10 cases que je veux dessiner)

                   if SumZter-(n*Ztot2) > (n*Ztot2)-(SumZter-Zter(lig-1)) % Et si l'écart entre cette valeur théorique et SumZ est supérieur à l'écart entre la valeur théorique et SumZ-Z(lig-1), alors
                       all_matrices2{n,c} = Matrice(Deb:lig-1 , :);
                       Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.

                   else % Sinon, c'est-à-dire, si l'écart entre la valeur théorique et Sum.Z(lig) est inférieure à l'écart entre la valeur théorique et Sum.Z(lig-1), alors
                       all_matrices2{n,c} = Matrice(Deb:lig , :);
                       Deb=lig+1 % 1ère ligne à prendre en compte pour la prochaine case.
                   end

                 c = c+1
               end

    %            if c > 10
    %            break
    %            end
              lig = lig+1
              nblig=nblig+1;
              c
            end
        Nbligtot = Nbligtot + nblig
   
end

[linpro.lalaland]

C'est réglé.

Petite erreur d'indice dans l'Etape 4. J'ai remplacé n par c.

Voici le script corrigé pour les curieux

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
%% ********************************************************************* %%
%%             ETAPE 4 : Calcul des classes en focntion de Y             %%              
%% ********************************************************************* %%
clear Deb Tri Dlig n lig


% Je crée un cell-array vide. c'est un conteneur de type hétérogène. Je peux mettre ce que 
% je veux dans chaque case, des matrices, des strings (alors qu'une matrice ne contient que du numérique)
all_matrices2={};

% Trier les lignes en fonction de X, pour que les valeurs soient rangées
% dans l'ordre croissant, POUR CHAQUE all_matrices{n}
 Nbligtot = 0
for n = 1 : 10  
    
        Tri = sortrows (all_matrices{n},2); % Je tri ma matrice en fonction de ma deuxième colonne.

        Xter=Tri(:,1); % La colonne 1 de ma matrice Tri contient les valeurs X.
        Yter=Tri(:,2); % La colonne 2 de ma matrice Tri contient les valeurs Y.
        Zter=Tri(:,3); % La colonne 3 de ma matrice Tri contient les valeurs Z.

        Dlig=length(Yter); % Il y a length(X) lignes dans ma matrice. Dlig est le numéro de ma dernière ligne.
        Ztot2=sum(Zter)/10; % Je veux 10 classes pour chacune des 10 matrices qui 
          % contiennent déjà 1/10ème du Z total. Donc ici Ztot correspond à 1/10 du Ztot de l'etape 3..
        Deb = 1; % 1ère ligne à prendre en compte

        SumZter=Zter(1); % J'initialise ma variable. ...DANS QUELLE SOUS-MATRICE  ? 

            nblig=1;
            c=1; % j'initialise la variable n qui représente les colonnes de all_matrices{c,n}
            lig=2;
            while lig < Dlig+1 % Pour chacune des lignes, à partir de la deuxième ...
               SumZter= SumZter + Zter(lig) % La somme des Z = La somme déjà calculée + Z(lig)

               if SumZter >= c*Ztot2 % Si ma somme dépasse n*Ztot (la valeur de Z théorique de chacune des 10 cases que je veux dessiner)

                   if SumZter-(c*Ztot2) > (c*Ztot2)-(SumZter-Zter(lig-1)) % Et si l'écart entre cette valeur théorique et SumZ est supérieur à l'écart entre la valeur théorique et SumZ-Z(lig-1), alors
                       all_matrices2{n,c} = Matrice(Deb:lig-1 , :);
                       Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.

                   else % Sinon, c'est-à-dire, si l'écart entre la valeur théorique et Sum.Z(lig) est inférieure à l'écart entre la valeur théorique et Sum.Z(lig-1), alors
                       all_matrices2{n,c} = Matrice(Deb:lig , :);
                       Deb=lig+1 % 1ère ligne à prendre en compte pour la prochaine case.
                   end

                 c = c+1
               end

    %            if c > 10
    %            break
    %            end
              lig = lig+1
              nblig=nblig+1;
              c
            end
        Nbligtot = Nbligtot + nblig
   
end