Tri dans TableMatrix

Version imprimable

Bonjour,

J'ai récemment beaucoup utilisé TableMatrix, qui est très pratique pour l'affichage de tableau.
Le problème principal pour moi, c'est le format de données nécessaire, que je trouve maladroit à utiliser, notamment pour les tris.
TableMatrix prend en entrée une référence de hash
Code:

1 2 3 4 5 my $tableau; $tableau->{"1,1"} = 11; $tableau->{"1,2"} = 12; $tableau->{"1,3"} = 13; $tableau->{"2,1"} = 21;
Jusqu'à présent, je triai en passant par un tableau temporaire et réécriture complète de $tableau
Code:

1 2 3 4 5 6 7 8 9 10 11 12 my @t; for (my $i=0; $i<$nb1; $i++){ for (my $j=0; $j<$nb2; $j++){ $t[$i][$j] = $tableau->{"$i,$j"}; } } sort @t; for (my $i=0; $i<$nb1; $i++){ for (my $j=0; $j<$nb2; $j++){ $tableau->{"$i,$j"} = $t[$i][$j]; } }
c'est lourd et peu efficace.
J'ai pensé à essayer de trier le hash dont $tableau est la référence
Code:

1 2 3 4 5 6 7 my %h; $h{"1,1"}=11; $h{"1,2"} = 12; $h{"1,3"} = 13; $h{"2,1"} = 21; $tableau = \%h; sort %h;
Cela ne marche pas, puisque chaque case du hash est une clé différente.
Alors je me demandais s'il était possible de faire pointer le hash vers un tableau à la place. Quelque chose du style
Code:

1 2 my @data; $h{"$i,$j"} = \$data[$i][$j];
Je ne sais pas comment faire. Je pense que la difficulté viens de [0][15] vers {"0,15"}, c'est à dire convertir des indices en une clé. Mais je ne suis pas sûre.
Quelqu'un aurait-il une piste?

17/03/2015, 19h28
Lolo78
Pas bien compris. Tu veux trier les clefs ("1,1, "1,2") d'après les valeurs (11, 12, 13, 21)? Si c'est cela, il y a beaucoup plus simple.

Je ne peux pas tester maintenant sur ma tablette mobile, mais quelque chose comme cela devrait fonctionner, je pense:
Code:

1 2 my @sorted_keys = sort { $tableau->{$a} <=> $tableau->{$b} } keys %$tableau;
Tu ne devrais pas appeler "tableau" un hash ref, c'est vraiment trompeur.
18/03/2015, 09h59
clmin
J'ai déjà essayé quelque chose comme ça, mais deux problèmes:
1) Il me faut un résultat sous la forme $t->{"i,j"}
2) Je veux faire un tri par colonne, pas trier l'ensemble des valeurs de $t. En plus, c'est $t->{"1,2"} pas $t->{1,2}
Idéalement, quelque chose comme
Code:

1 2 3 4 $t = sort $t->{"$i,$j"} key $j; #ou bien $t = \%h; %h = sort $h{"$i,$j"} key $j;
Je ne pense pas que cela soit possible cependant, d'où l'idée de faire pointer le hash vers un tableau.
J'aurais ainsi $t pointant vers %h pointant vers @d.
Càd $t->{"$i,$j"} pointe vers $h{"$i,$j"} pointe vers $d[$i][$j]
Et je peux donc trier @d en fonction du deuxième indice $j.
Mais à la fois l'entrée et la sortie doivent être de forme $t->{"$i,$j"}
18/03/2015, 15h13
Lolo78

Un hachage n'est pas définition pas trié, tu ne peux lui donner un ordre. Ce que je proposais permettait de mettre dans un tableau l'ordre des clefs du hachage (triées selon les valeurs), ce qui permet ensuite de visiter le hachage dans l'ordre de ces clefs.

Citation:

2) Je veux faire un tri par colonne, pas trier l'ensemble des valeurs de $t. En plus, c'est $t->{"1,2"} pas $t->{1,2}

Je ne comprends pas ce que tu veux dire.

Peux-tu donner un exemple parlant de tes données en entrée et du résultat que tu veux obtenir?

Disons un tableau listant les noms et âges, que l'on voudrai trier par âge:

Citation:

toto 10
tata 8
tonton 12

deviendrai:

tata 8
toto 10
tonton 12

Pour cela, on a:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 my $t; $t->{'0,0'} = 'toto'; $t->{'1,0'} = 'tata'; $t->{'2,0'} = 'tonton'; $t->{'0,1'} = 10; $t->{'1,1'} = 8; $t->{'2,1'} = 12; $t = mon_tri($t, 1); #Tri de $t par la colonne 1 print $t->{'0,0'}."\t".$t->{'0,1'}."\n"; print $t->{'1,0'}."\t".$t->{'1,1'}."\n"; print $t->{'2,0'}."\t".$t->{'2,1'}."\n";

18/03/2015, 19h30
djibril
Ton problème correspond à trier une matrice de données en suivant une règle précise.

Tu souhaites passer d'une matrice de type :
Code:

1 2 3 toto 10 tata 8 tonton 12
à
Code:

1 2 3 tata 8 toto 10 tonton 12
Je pense que pour ce faire, on est obligé de construire un nouveau tableau qui contiendra toutes les données, le trier pour recontruire le hash dédié à TableMatrix.

Il faut donc trouver un bon algorithm pour cela.
Il serait intéressant de faire plusieurs cas :
- trier par rapport à une colonne x ;
- trier par rapport à une colonne x sans toucher à la première (ou deux prmières, trois premières...) ligne(s) si cette dernière est une entête.
Et pour les deux cas ci-dessous, de pouvoir préciser s'il s'agit de colonne de données numériques ou lexicographique.

Je ne sais pas si un tel module existe déjà sur le CPAN. Si non, ce serait peut-être occasion d'en créer un.

Vous en pensez quoi ?

Voici un exemple de tri de tes âges:

Code:

1
2
3
4
5
6
7
8
9
10
 
use strict;
use warnings;
use Data::Dumper;
 
my @ages = ( [qw /toto 10/], [qw / tata 8/], [qw/ tonton 12/]);
print "Non trié: \n", Dumper \@ages;
 
@ages = sort { $a->[1] <=> $b->[1] } @ages;
print "Trié: \n", Dumper \@ages;

Ce qui affiche:

Code:

Pour ton second cas:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
use strict;
use warnings;
 
my $t;
$t->{'2,0'} = 'tonton'; 
$t->{'0,0'} = 'toto';
$t->{'1,0'} = 'tata';
 
 
$t->{'1,1'} = 8;
$t->{'2,1'} = 12;
$t->{'0,1'} = 10;
 
print join "\n", 
	map {$t->{$_->[1]}} 
	sort { $a->[0] <=> $b->[0] } 
	map { my $c = $1 if /(\d),/; [$c, $_]} 
	keys %$t;

Ce qui affiche:

Code:

1
2
3
4
5
6
7
8
 
$ perl sort_val.pl
toto
10
tata
8
tonton
12

Je te laisse peaufiner l'affichage si besoin. Mais n'hésite pas à demander si tu n'y arrives pas.

18/03/2015, 20h06
djibril

Je viens de voir ce module Sort::Fields, il semble bien fonctionner.
Il date un peu (1998), mais il fait le job.
18/03/2015, 22h23
Lolo78
Je ne connais pas du tout TableMatrix, mais je me demande si la structure de données suivante ne serait pas meilleure:
Code:

1 2 3 4 $t->{0]{0} = 'toto'; $t->{1}{0} = 'tata'; # etc.
18/03/2015, 22h57
djibril

Ce ne sera pas possible :aie:. Le module fonctionne avec les indices de type x,y.

Voici un code qui permet de trier un hash type Tablematrix. Tu peux le trier en fonction de n'importe quelle colonne (de plusieurs colonnes), en mode numérique ou non, trie inverse.
Tu peux même spécifier que tu ne souhaites pas toucher à la première ligne.

Code:

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
#!/usr/bin/perl
use strict;
use warnings;
use Sort::Fields;
use Data::Dumper;
 
# Construction data matrix
my @data = <DATA>;
my $t;
my $id_ligne = 0;
foreach my $ligne (@data) {
	my $id_colonne = 0;
	foreach my $cellule ( split( /\s+/, $ligne ) ) {
		$t->{"$id_ligne,$id_colonne"} = $cellule;
		$id_colonne++;
	}
	$id_ligne++;
}
 
# Pour le choix de ['2n'], lire documentation de Sort::Fields
print Dumper $t;
trier_data_matrix( $t, ['2n'], 0, 0 );
print Dumper $t;
 
sub trier_data_matrix {
	my ( $ref_data, $ref_type_trie, $indice_row_origin, $indice_col_origin ) = @_;
 
	# Construction tableau temporaire à trier
	my @temp_data;
 
	my $separateur        = '--sep--';
	my $nb_data           = scalar keys %{$ref_data};
	my $i                 = 0;
  ROW:
	for my $irow ( $indice_row_origin .. $nb_data ) {
	  COL:
		for my $icol ( $indice_col_origin .. $nb_data ) {
			if ( not exists $ref_data->{"$irow,$icol"} ) {
				$i++;
				next ROW;
			}
 
			push @{ $temp_data[$i] }, $ref_data->{"$irow,$icol"};
		}
	}
	foreach my $ligne (@temp_data) {
		$ligne = join $separateur, @{$ligne};
	}
 
	# trie
	my @sorted = fieldsort $separateur, $ref_type_trie, @temp_data;
	@temp_data = undef;
	#print Dumper @sorted;
 
	# Reconstruction tableau matrix
	my ( $il, $ic ) = ( $indice_row_origin, $indice_col_origin );
	foreach my $ligne (@sorted) {
		$ic = $indice_col_origin;
		foreach my $cellule ( split( $separateur, $ligne ) ) {
			$ref_data->{"$il,$ic"} = $cellule;
			$ic++;
		}
		$il++;
	}
	@sorted = undef;
	return $ref_data;
}
 
__DATA__
toto	10
tata	8
tonton	12

Tu dois jouer avec les arguments de la procédure trier_data_matrix. Pour le choix des colonnes, lit la documentation du module Sort::Fields, c'est très très simple.

Pour faire des tests très facilement, tu peux mettre des jeux de données en fin de programme et le script te créera le hash.
Je te laisse t'amuser avec le code.

N.B. Je me suis amusé à faire un programme Tk et cela fonctionne. Y a surement moyen de l'optimiser et de gérer des cas particuliers, mais ce n'était pas mon but premier.

Merci djibril. La fonction est à peu près la fonction de tri qui manquait à TableMatrix. C'est dommage de toujours passer par un tableau temporaire, mais c'est tout de même plus efficace que ce que j'utilisai jusqu'à présent. Et c'est aussi très paramétrable, ce qui est toujours un plus. Si quelqu'un viens sur ce sujet pour une fonction de tri prête à l'emploi, je pense qu'elle peut être utilisée telle quelle. Et si ils ne veulent pas lire la doc:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Fonction de tri pour TableMatrix : trier_data_matrix( $ref_data, $ref_type_trie, $row_titre, $col_titre ) Fonction dans le post de djibril plus haut $ref_data : tableau utilisé dans TableMatrix, format $ref_data->{"$ligne,$col"} $ref_type_trie : par quelle(s) colonne(s) effectuer le tri: [$col] : tri alphabétique de la colonne $col [-$col] : tri alphabétique déscendant de la colonne $col [$col."n"] : tri numérique de la colonne $col ["-".$col."n"] : tri numérique déscendant de la colonne $col [$tri1, tri2] : effectuer plusieurs tris à la suite $row_titre : nombre de lignes de titre dans le tableau $col_titre : nombre de colonnes de titre dans le tableau
Par contre, je ne comprend pas ce que fait la fonction de Lolo78. Pour la tester, j'ai fais:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 use strict; use warnings; use Data::Dumper; my $t; $t->{'2,0'} = 'tonton'; $t->{'0,0'} = 'toto'; $t->{'1,0'} = 'tata'; $t->{'1,1'} = 8; $t->{'2,1'} = 12; $t->{'0,1'} = 10; print Dumper $t; $t = join "\n", map {$t->{$_->[1]}} sort { $a->[0] <=> $b->[0] } map { my $c = $1 if /(\d),/; [$c, $_]} keys %$t; print Dumper $t;
Ce qui m'affiche
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 $VAR1 = { '1,0' => 'tata', '2,1' => 12, '0,1' => 10, '0,0' => 'toto', '2,0' => 'tonton', '1,1' => 8 }; $VAR1 = '10 toto tata 8 12 tonton';
Le format de mon tableau est donc totalement modifié... Ce qui est dommage, car a priori cela semblait intéressant. Il serait possible de récuperer les données dans le bon format, mais je ne pense pas que ce serai forcément moins long que de passer par un tableau temporaire.

19/03/2015, 15h51
djibril
Attention, ce commentaire n'est pas juste :
Code:

1 2 3 $row_titre : nombre de lignes de titre dans le tableau $col_titre : nombre de colonnes de titre dans le tableau
Dans mon exemple, ces variables correspondent aux indices d'origine.

Exemple, j'ai un tableau avec une entête :
Code:

1 2 3 4 Nom Prénom Age Dupond Jean 45 Merre Josette 65 Pioc Leo 17
Je souhaite effectuer un tri sans que la première ligne ne soit affectée, là tu diras que ton indice d'origine est 1 ($row_titre).
19/03/2015, 15h57
clmin

Ben, oui. Mais Puisque la première ligne du tableau a pour indice 0, cela revient au même.

Une ligne de titre (non affectée par le tri) -> trier_data_matrix( $ref_data, $ref_type_trie, 1 , $col_titre )
4 lignes de titres non affectées par le tri -> trier_data_matrix( $ref_data, $ref_type_trie, 4, $col_titre )

En gros, l'indice d'origine et égale au nombre de lignes non affectées du tableau, càd titre.
Mais c'est vrai que je n'était pas très précises dans mon explication.

Citation:
Envoyé par clmin
Par contre, je ne comprend pas ce que fait la fonction de Lolo78. Pour la tester, j'ai fais:
Code:

1 2 (...)
Le format de mon tableau est donc totalement modifié... Ce qui est dommage, car a priori cela semblait intéressant. Il serait possible de récuperer les données dans le bon format, mais je ne pense pas que ce serai forcément moins long que de passer par un tableau temporaire.
Hum, tu n'as manifestement pas compris ce que faisait mon code, mais comme je ne suis pas non plus sûr d'avoir compris ce que tu voulais, nous sommes peut-être à égalité. :(

D'abord, la partie "join "\n", ..." servait uniquement à l'affichage à l'écran des données résultantes par le print. A ne pas garder pour alimenter une structure de données.

Deuxièmement, l'idée n'était pas de remplacer $t, mais d'afficher la struture de données triée selon tes critères.

Si tu veux tester le code proposé, essaie plutôt quelque chose cela:
Code:

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 use strict; use warnings; use Data::Dumper; my $t; $t->{'2,0'} = 'tonton'; $t->{'0,0'} = 'toto'; $t->{'1,0'} = 'tata'; $t->{'1,1'} = 8; $t->{'2,1'} = 12; $t->{'0,1'} = 10; my @result = map {$t->{$_->[1]}} sort { $a->[0] <=> $b->[0] } map { my $c = $1 if /(\d),/; [$c, $_]} keys %$t; print Dumper \@result; print "\n\n"; while (@result) { print shift @result, "\t", shift @result, "\n"; }
Ce qui affiche:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 $ perl sort_val.pl $VAR1 = [ 'toto', 10, 'tata', 8, 'tonton', 12 ]; toto 10 tata 8 tonton 12
ce qui me paraît correspondre à ce que tu demandais dans ton post #5: les données sont triées selon la première colonne.