Discussion :

[arwen76]

Bonjour,
Je cherche à passer proprement un tableau comme argument d'une fonction, c'est-à-dire sous la forme d'une référence. Le code qui suit fonctionne très bien mais comme vous le constaterez, c'est bien un tableau que je passe en argument de la fonction mystd() pas une référence...

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
 
 
#!/usr/bin/perl
use strict;
 
my %hashx;
my %hashy;
my $std;
my $cor;
 
%hashx=(
'103904950' => 6.1,
'103905269' => 5.5,
'103905308' => 5.5,
'103905458' => 5.8,
'103905264' => 5.8,
'103905270' => 5.6);
 
%hashy=(
'103904950' => -6.1,
'103905269' => -6.3,
'103905308' => -5.7,
'103905458' => -6.6,
'103905264' => -6.8,
'103905270' => -6.6);
 
$std=mystd(values %hashx);
$cor=mycor(\%hashx, \%hashy);
 
print "STD= $std\nCC= $cor\n";
 
sub mysum
{
  my ($refvaluelist)=@_;
  my @valuelist=@{$refvaluelist};
  my $sum=0;
  foreach my $value (@valuelist)
  {$sum+=$value;}
  return $sum;
}
 
sub mymean
{
  my @valuelist=@_;
  my $mean=0;
  $mean=mysum(\@valuelist)/@valuelist;
  return $mean;
}
 
 
sub myvar
{
  my @values=@_;
  my $var=0;
  my $mean=mymean(@values);
  foreach my $v (@values)
  {$var+=($v-$mean)*($v-$mean);}
  $var=$var/@values;
  return $var;
}
 
 
sub mystd
{
  #my ($refvalues)=@_;
  my @values=@_; #@{$refvalues};
  my $std=myvar(@values);
  $std=sqrt($std);
  return $std;
}
 
sub mycov
{
  my ($refx, $refy)=@_;
  my %xvalues=%$refx;
  my %yvalues=%$refy;
  my $nb=(values %xvalues);
  my $meanx=mymean(values %xvalues);
  my $meany=mymean(values %yvalues);
  my $cov=0;
  foreach my $x (keys %xvalues)
  {$cov+=($xvalues{$x}-$meanx)*($yvalues{$x}-$meany);}
  $cov=$cov/$nb;
  return $cov;
 
}
 
sub mycor
{
  my ($refx, $refy)=@_;
  my %xvalues=%$refx;
  my %yvalues=%$refy;
  my $cor=0;
  my $stdx=mystd(\values %xvalues);
  my $stdy=mystd(\values %yvalues);
  if ($stdx!=0 && $stdy!=0)
  {$cor=mycov(\%xvalues, \%yvalues)/($stdx*$stdy);}
  else
  {$cor="";}
  return $cor;
}

Dès que j'essaye de passer une référence, telle que:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
 
$std=mystd(\values %hashx);
 
sub mystd
{
  my ($refvalues)=@_;
  my @values=@{$refvalues};
  my $std=myvar(@values);
  $std=sqrt($std);
  return $std;
}

La console me dit:
Not an ARRAY reference at ./moyennepka_LPE_forum.pl line (celle de "my @values=@{$refvalues};")
Alors que ça fonctionne pour mysum()...
Je n'y comprends rien :'( Le pire c'est que ça fonctionne pour mysum()...
Quelqu'un peut-il m'aider SVP?

[djibril]

Bonjour,

Lorsque vous programmez, apprenez à :

1. respecter l'écriture du langage ;
2. lire la documentation ;
3. commenter son code ;
4. indenter son code ;
5. ...

Voici votre code corrigé. Je ne sais pas si le résultat en sortie est bon, j'ai juste effectué quelques corrections. À vous de les comprendre :

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
#!/usr/bin/perl
use warnings;
use strict;
 
my %hashx = (
	'103904950' => 6.1,
	'103905269' => 5.5,
	'103905308' => 5.5,
	'103905458' => 5.8,
	'103905264' => 5.8,
	'103905270' => 5.6
);
 
my %hashy = (
	'103904950' => -6.1,
	'103905269' => -6.3,
	'103905308' => -5.7,
	'103905458' => -6.6,
	'103905264' => -6.8,
	'103905270' => -6.6
);
 
my $std = mystd( \%hashx );
my $cor = mycor( \%hashx, \%hashy );
 
print "STD= $std\nCC= $cor\n";
 
sub mysum {
	my ($refvaluelist) = @_;
	my @valuelist      = @{$refvaluelist};
	my $sum            = 0;
	foreach my $value (@valuelist) {
		$sum += $value;
	}
	return $sum;
}
 
sub mymean {
	my @valuelist = @_;
	my $mean      = 0;
	$mean = mysum( \@valuelist ) / @valuelist;
	return $mean;
}
 
sub myvar {
	my $ref_values = shift;
	my $var        = 0;
	my $mean       = mymean($ref_values);
	foreach my $v ( @{$ref_values} ) {
		$var += ( $v - $mean ) * ( $v - $mean );
	}
	$var = $var / scalar( @{$ref_values} );
	return $var;
}
 
sub mystd {
	my $refvalues = shift;
	my @values    = values %{$refvalues};
	my $std       = myvar( \@values );
	$std = sqrt $std;
	return $std;
}
 
sub mycov {
	my ( $refx, $refy ) = @_;
	my %xvalues = %$refx;
	my %yvalues = %$refy;
	my $nb      = ( values %xvalues );
	my $meanx   = mymean( values %xvalues );
	my $meany   = mymean( values %yvalues );
	my $cov     = 0;
	foreach my $x ( keys %xvalues ) {
		$cov += ( $xvalues{$x} - $meanx ) * ( $yvalues{$x} - $meany );
	}
	$cov = $cov / $nb;
	return $cov;
 
}
 
sub mycor {
	my ( $refx, $refy ) = @_;
	my %xvalues = %$refx;
	my %yvalues = %$refy;
	my $cor     = 0;
	my $stdx    = mystd( \%xvalues );
	my $stdy    = mystd( \%yvalues );
	if ( $stdx != 0 && $stdy != 0 ) {
		$cor = mycov( \%xvalues, \%yvalues ) / ( $stdx * $stdy );
	}
	else {
		$cor = "";
	}
	return $cor;
}

[arwen76]

Bonjour,
Je vous remercie beaucoup pour vos conseils.
Utilisant "use strict", j'avoue être très étonnée par celui de "respecter l'écriture du langage". En effet, parmi la nombreuse documentation que j'ai lue, je n'ai trouvé nul par le règlement du programmeur perlien, lequel m'aurait très certainement beaucoup aidé car, sachant qu'il existe beaucoup de façons différentes d'écrire une même instruction, en particulier dans ce langage, il est difficile de ne pas en perdre la tête parfois. Votre conseil de "commenter son code" est excellent. Je n'ai cessé de le clamer à mes étudiants! Il est vrai que je n'en ai pas pris la peine ici, pensant que le nom de mes fonctions (mysum(), mymean(), etc.) étaient suffisamment explicite. Je m'en excuse donc. Par contre, mon code est indenté. Là non plus, je n'ai trouvé aucun texte déclarant l'unique et incontournable façon d'indenter son code. J'en ai d'ailleurs vu de toutes les couleurs quelque soit le langage! Le 5ème point est obscur pour moi...

Je vous remercie beaucoup pour vos corrections. Tel quel, le code ne fonctionne pas.
La fonction mymean() est appelée une fois avec comme argument une référence, 2 autres fois avec un tableau. Il manquait aussi les "()" à la "réception" de l'argument dans la fonction mymean(). Avec les fonctions mymean() et mycor() corrigées comme suit, cela fonctionne:

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
sub mymean {
	my ($refvaluelist)= @_;
	my @valuelist = @{$refvaluelist};
	my $mean      = 0;
	$mean = mysum( \@valuelist ) / @valuelist;
	return $mean;
}

sub mycov {
	my ( $refx, $refy ) = @_;
	my %xvalues = %$refx;
	my %yvalues = %$refy;
	my $nb      = ( values %xvalues );
	my @xvalues = values %xvalues;
	my @yvalues = values %yvalues;
	my $meanx   = mymean( \@xvalues );
	my $meany   = mymean( \@yvalues );
	my $cov     = 0;
	foreach my $x ( keys %xvalues ) {
		$cov += ( $xvalues{$x} - $meanx ) * ( $yvalues{$x} - $meany );
	}
	$cov = $cov / $nb;
	return $cov;
 
}

Il y a certainement une plus jolie façon d'écrire ce code, mais je ne suis qu'une débutante.
En tous les cas, merci encore pour cette correction qui m'a bien dépannée. J'ai au moins compris qu'on ne pouvait pas référencer de cette façon "\values @tab" et appris que l'on déférençait un tableau comme cela "@{$reftab}" (et non pas "@$reftab" comme lu dans la documentation...) bien que cela fonctionne pour les hash (comme vous écrivez "my %xvalues = %$refx;"), il y a de quoi être perdue...

[Lolo78]

J'ai au moins compris qu'on ne pouvait pas référencer de cette façon "\values @tab" et appris que l'on déférençait un tableau comme cela "@{$reftab}" (et non pas "@$reftab" comme lu dans la documentation...) bien que cela fonctionne pour les hash (comme vous écrivez "my %xvalues = %$refx;"), il y a de quoi être perdue...

Dans le premier cas, values est une fonction interne de Perl, on ne peut pas vraiment prendre une référence sur cette fonction, ça n'aurait pas de sens. Mais on peut construire une référence sur le résultat produit par cette fonction:

Code :

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

1
2
 
my $stdx=mystd( [values %xvalues] );

est sémantiquement équivalent à:

Code :

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

1
2
3
 
my @temp_val = values %xvalues;
my $stdx=mystd(\@temp_val);

Sinon, on peut tout-à-fait déréférencer une référence de tableau avec la syntaxe @$reftab, l'ajout des accolades peut être considéré comme un peu plus clair. Dans le cas de structures de données imbriquées (du genre tableaux de hachages de tableaux), les accolades sont parfois nécessaires pour que le compilateur s'y retrouve sur l'intention du développeur.

[arwen76]

Merci Lolo78, c'est plus clair.

[Philou67430]

Bonjour,
Je vous remercie beaucoup pour vos conseils.
Utilisant "use strict", j'avoue être très étonnée par celui de "respecter l'écriture du langage". En effet, parmi la nombreuse documentation que j'ai lue, je n'ai trouvé nul par le règlement du programmeur perlien, lequel m'aurait très certainement beaucoup aidé car, sachant qu'il existe beaucoup de façons différentes d'écrire une même instruction, en particulier dans ce langage, il est difficile de ne pas en perdre la tête parfois.

Quelques éléments de réponses à ce que j'ai surligné en gras :
- perldoc strict
- perldoc perlstyle
- perldoc Perl::Critic
- Perl Best Practicies (D. Conway)

[arwen76]

Merci Philou pour ces références.
J'étais quelque peu ironique car perl est un langage très (trop à mon goût) souple mais je sais bien qu'il existe des "bonnes pratiques" et pourtant personne ne vous tapera sur les doigts si vous n'en faites qu'à votre tête...

[Philou67430]

La souplesse du langage, c'est aussi la liberté qu'il offre.
Et comme toute liberté, elle nécessite de ces utilisateurs, une certaine responsabilité.

D'autres langages sont des dictatures où la liberté d'expression est limitée, où les schémas de pensée sont préformatés.

C'est ça le bonheur dans l'informatique : on a le choix de savoir à quelle sauce on va être mangé