Discussion :

[linpro.lalaland]

NB : j'ai avancé dans mon travail ... peu, mais peut-être suffisamment pour que quelqu'un puisse m'aider sur les petites questions ponctuelles que je pose dans mon dernier post sans avoir à comprendre l'ensemble du problème ...


Bonjour à tous,

Contexte :
J'ai réalisé un nuage de point avec en abscisse, des valeurs X et en ordonnées, des valeurs Y.
A chaque point de ce nuage est associé une troisième valeur "Z" (vous pouvez imaginer que cette valeur est un prix qui diffère ou non d'un point à l'autre).

J'aimerais tracer sur mon graphe des cases qui regroupent mes points avec les conditions suivantes :
1) Chaque case doit contenir une somme de Z identique, peu importe le nombre de valeurs inclues dedans. (Vous pouvez imaginer que chaque case est un boîte dans laquelle on range des objets ou des fruits .... et chaque boîte doit avoir le même prix).
2) L'axe des X est découpé en 10.
3) Puis l'axe des Y est découpé en 10 à son tour.

On devrait ainsi obtenir une figure qui ressemble à :


Avez-vous une idée de comment procéder ? Surtout pour tracer les cases. J'avance mon travail au fur et à mesure. Mais ne sachant pas qu'elles sont les données dont j'ai besoin pour tracer mon graphe, je ne sais pas si je travaille "dans le bon sens" ou si ce que je fais est inutile.
Je suis preneuse de toute idée, conseil, script (?) ... tout ce qui pourrait m'aider à avancer sur ce nouveau problème ...
Précision : Je ne sais absoluement pas comment tracer les cases ! Alors encore moins tracer des cases en fonction de la somme de valeurs Z qu'elle contient ou pourrait contenir ...



Je vous mets mon scropt (ci-dessous) et un fichier simplifié en exemple avec mon nuage de point allégé ... 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
 
%% ********************************************************************* %%
%%                          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 %f %f %f %f','delimiter','\t');
    % 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')

Merci d'avance à tous

[linpro.lalaland]

J'ai réfléchi à la question.

Voilà peut-être comment procéder :

1) Découper les X en 10 colonnes contenant des sommes de Z identiques.
2) Découper les Y en fonction du premier découpage fait en 1) pour former mes cases contenant des sommes de Z identiques.

Je pense qu'il y indispensable de passer par la création de matrices. Voici une ébauche de ce que j'ai fait cet après-midi : (suite de mon premier post)

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
%% ********************************************************************* %%
%%                     ETAPE 3 : Calcul des cases                        %%              
%% ********************************************************************* %%

% Trier les lignes en fonction de X, pour que les valeurs soient rangées
% dans l'ordre croissant.

      % (Je n'ai pas encore regardé comment faire).

 
N.Case=10 % Je veux séparer X en dix colonnes (N.Case = nombre de colonne ... logique !)
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
Sum.Z(1)=Z(1) % J'initialise ma variable.

For n = 1:N.Case  % Pour chacune des 10 colonnes ...

    for lig = 2:Dlig % Pour chacune des lignes, à partir de la deuxième ...
       Sum.Z(lig)= Sum.Z(lig-1)+Z(lig) % La somme des Z = La somme déjà calculée + Z(lig)
       
        
       IF Sum.Z(lig) > n*Ztot/10 % Si ma somme dépasse n*Ztot (la valeur de Z théorique de chacune des 10 cases que je veux dessiner)
       
       ELSEIF Sum.Z(lig)-(n*Ztot) > (n*Ztot)- Sum.Z(lig-1) % Et 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
         Case(n) = X(Deb) à Z(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
         Case(n) = X(Deb) à Y(lig)
         Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.
       END
    end 
 end

Bien évidemment, je n'ai pas su tout faire.

Comment puis-je faire pour créer une matrice Case(n) (avec n=1:10) qui contienne les valeurs X(Deb) à Z(lig) ? (ligne 30 du script) Je sais que c'est une question de base, qu'il y a 20 tuto dessus, mais je n'y arrive pas. Je cherche encore ... et je vous tiens au courant.

N'hésitez pas à me demander plus d'explication sur ce que je veux faire ... Si ça peut m'aider à avoir un petit coup de pouce, j'expliquerai volontiers de 50 façons différentes !!

[linpro.lalaland]

J'ai amélioré et complété mon précédent script :
1) J'ai récupéré 3 colonnes : X, Y et Z dans un fichier texte.
2) Je concatène ces 3 colonnes dans une matrice "mbis".
3) J'identifie les colonnes Xbis, Ybis et Zbis (pour ne pas faire répétition)... C'est bof mais je ferai mieux plus tard
4) Je tri les lignes de ma matrice mbis en fonction de ma première colonne Xbis de telle sorte que ses valeurs progressent dans l'ordre croissant.
5) J'essaye de découper ma colonne X en 10 classes, de telle sorte que la somme des Z associée à chacune des 10 classes soit la même (autant que possible).

Parmi toutes les erreurs que je vais bien pouvoir rencontrer ... Je bloque sur :
Case(n) = [X(Deb) : Z(lig-1)] --> Comment créer une matrice Case(n) composé des lignes de mbis allant de la ligne "deb" à la ligne "lig" ?


Merci d'avance ...

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
 
%% ********************************************************************* %%
%%                     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.
 
 
NCase=10 % Je veux séparer X en dix colonnes (NCase = nombre de colonne ... logique !)
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(1)=Z(1) % J'initialise ma variable.
 
for n = 1:NCase  % Pour chacune des 10 colonnes ...
    for lig = 2:Dlig % Pour chacune des lignes, à partir de la deuxième ...
       SumZ(lig)= SumZ(lig-1)+Z(lig) % La somme des Z = La somme déjà calculée + Z(lig)
 
 
       if SumZ(lig) >= n*Ztot % Si ma somme dépasse n*Ztot (la valeur de Z théorique de chacune des 10 cases que je veux dessiner)
 
       elseif SumZ(lig)-(n*Ztot) > (n*Ztot)- SumZ(lig-1) % Et 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
         Case(n) = [X(Deb) : Z(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
         Case(n) = [X(Deb) : Y(lig)]
         Deb=lig % 1ère ligne à prendre en compte pour la prochaine case.
       end
    end 
 end