SELFHTML/Aides à la navigation CGI/Perl Fonctions Perl| SELFHTML/Aides à la navigation CGI/Perl Fonctions Perl |
 |
Fonctions pour les calculs |
|
|
 | |
Perl lui même ne propose que peu de fonctions mathématiques étant donné qu'il est davantage conçu comme langage pour le traitement des chaînes de caractères et des fichiers. Il existe pourtant des modules mathématiques puissants qui font aussi de Perl un langage mathématique puissant. Tenez compte aussi pour cette raison, outre les fonctions décrites ici des 
modules standard, qui peuvent être incorporés sans problème et qui proposent beaucoup d'autres fonctions intéressantes pour les calculs mathématiques, scientifiques et commerciaux.
|
Attend comme paramètre:
1. un nombre quelconque permis.
Renvoie la valeur positive d'un nombre, au cas où il est négatif.. Si le nombre est positif, il est renvoyé inchangé.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @nombres = (1463.45,2038.02,-12348.12,5671.12,-4939.48,-1124.09);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test</title></head><body>\n";
print "<table border=\"1\">\n";
print "<tr><th>nombres noirs</th><th style=\"color:red\">nombres rouges</th></tr>\n";
foreach my $nombre (@nombres) {
if($nombre >= 0) {
print "<tr><td>$nombre</td><td style=\"color:red\"> </td></tr>\n";
}
else {
my $nombre_absolu = abs($nombre);
print "<tr><td> </td><td style=\"color:red\">$nombre_absolu</td></tr>\n";
}
}
print "</table>\n";
print "</body></html>\n";
|
L'exemple définit une liste @nombres. Quelques uns des nombres sont positifs d'autres sont négatifs. Ensuite, du code HTML est envoyé au navigateur. Ici un tableau avec deux colonnes est créé. À gauche figurent les nombres positifs (noirs), à droite les nombres négatifs (rouges). Les nombres rouges doivent cependant être représentés sans signe moins mais à la place l'être en rouge. C'est pourquoi la fonction abs est appliquée sur le nombre au cas où il est négatif. Le résultat est sauvegardé dans la scalaire $nombre_absolu, puis il est sorti.
|
|
Attend comme paramètre:
1. un nombre quelconque permis x,
2. un nombre quelconque permis y.
Renvoie l'arc tangente de y par x.
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); print "Content-type: text/html\n\n"; print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n"; print "<html><head><title>Test</title></head><body>\n"; my $valeur = atan2(1.394,5.01); print "L'arc tangente de 5.01 par 1.394 est $valeur\n"; print "</body></html>\n"; |
L'exemple transmet à la fonction atan2 les deux nombres à virgule flottante 1.394 et 5.01. La fonction renvoie l'arc tangente de 5.01/1.394. Pour le contrôle, du code HTML est envoyé au navigateur et sort le résultat.
|
|
Attend comme paramètre:
1. un nombre quelconque permis.
Renvoie le cosinus du nombre.
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); print "Content-type: text/html\n\n"; print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n"; print "<html><head><title>Test</title></head><body>\n"; my $un = cos(0); print "1 reste $un, comme prévu\n"; print "</body></html>\n"; |
L'exemple crée le nombre 1 à partir de 0 (dont le résultat est 1). Pour le contrôle, du code HTML est sorti au navigateur et sort le nombre dans un dicton laconique.
|
|
Attend comme paramètre:
1. un nombre quelconque permis.
Renvoie la valeur exponentielle du nombre.
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); print "Content-type: text/html\n\n"; print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n"; print "<html><head><title>Test</title></head><body>\n"; my $x = exp(1); print "x = $x\n"; print "</body></html>\n"; |
L'exemple envoie du code HTML au navigateur. Ici, la valeur exponentielle de 1 est recherchée et sauvegardée dans la scalaire $x. Le résultat est sorti.
|
|
Convertit une valeur hexadécimale disponible sous forme de chaîne de caractères en valeur décimale correspondante.
Attend comme paramètre:
1. une chaîne de caractères qui représente une valeur hexadécimale valable, donc par exemple "0xB56A" ou bien "B56A".
Renvoie la valeur décimale correspondante comme valeur numérique.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $couleur = $ENV{'QUERY_STRING'};
my $valeur_rouge_Hex = substr($couleur,0,2);
my $valeur_vert_Hex = substr($couleur,2,2);
my $valeur_bleu_Hex = substr($couleur,4,2);
my $valeur_rouge_Dec = hex($valeur_rouge_Hex);
my $valeur_vert_Dec = hex($valeur_vert_Hex);
my $valeur_bleu_Dec = hex($valeur_bleu_Hex);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test</title></head><body>\n";
print "La couleur #$couleur se répartit dans les composantes RGB suivantes:<br>\n";
print "Valeur rouge: $valeur_rouge_Dec<br>\n";
print "Valeur vert: $valeur_vert_Dec<br>\n";
print "Valeur bleu: $valeur_bleu_Dec<br>\n";
print "</body></html>\n";
|
Le script CGI en exemple attend la transmission d'un paramètre noté derrière un point d'interrogation lors de l'appel par une URI. Le paramètre transmis est composé d'une mention de couleur typique en HTML excepté le signe dièse d'introduction #. Exemple:
http://localhost/cgi-bin/test.pl?FF9933.
Le script en exemple recherche le paramètre transmis dans la variable d'environnement CGI QUERY_STRING et sauvegarde la valeur dans la scalaire $couleur. À l'aide de la fonction substr Les composantes pour le rouge, le vert et le bleu sont extraites de la mention hexadécimale. Si le nombre transmis est par exemple FF9933, la valeur "FF" est sauvegardée dans $valeur_rouge_Hex, la valeur "99" dans $valeur_vert_Hex et la valeur "33" dans $valeur_bleu_Hex. À partir de ces mentions hexadécimales, on obtient en appliquant la fonction hex les valeurs décimales des composantes de la couleur correspondantes. L'exemple envoie du code HTML au navigateur et sort les composantes de la couleur ainsi trouvées.
|
|
La fonction sert d'une part à séparer dans un nombre avec décimales la partie avant la virgule des décimales. D'autre part elle peut néanmoins être appliquée à des chaînes de caractères jusqu'à ce qu'elle rencontre un signe qui ne peut plus être interprété comme signe numérique.
Attend comme paramètre:
1. un nombre ou une chaîne de caractères.
Donne la partie pouvant être interprétée comme nombre entier des données transmises.
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); my $chaine_caracteres = "161cm"; my $nombre_entier = 23; my $nombre_virgule = 3.1415; my $nombre_negatif = -3.999; my $chaine_caracteres_int = int($chaine_caracteres); my $nombre_entier_int = int($nombre_entier); my $nombre_virgule_int = int($nombre_virgule); my $nombre_negatif_int = int($nombre_negatif); print "Content-type: text/html\n\n"; print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n"; print "<html><head><title>Sortie du test</title></head><body>\n"; print "$chaine_caracteres après l'application de int: $chaine_caracteres_int<br>\n"; print "$nombre_entier après l'application de int: $nombre_entier_int<br>\n"; print "$nombre_virgule après l'application de int: $nombre_virgule_int<br>\n"; print "$nombre_negatif après l'application de int: $nombre_negatif_int\n"; print "</body></html>\n"; |
L'exemple définit différentes scalaires: une chaîne de caractères, un nombre entier normal, un nombre avec décimales et un nombre négatif lui aussi avec décimales. Après cela, la fonction int est appliquée aux différentes scalaires. Les valeurs renvoyées sont sauvegardées dans des nouvelles scalaires distinctes. Pour le contrôle, le script en exemple envoie du code HTML au navigateur et sort les valeurs avant et après l'application de la fonction int.
|
|
Attend comme paramètre:
1. un nombre quelconque permis.
Renvoie le logarithme naturel d'un nombre.
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); my $un = log(exp(1)); print "Content-type: text/html\n\n"; print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n"; print "<html><head><title>Sortie du test</title></head><body>\n"; print "$un"; print "</body></html>\n"; |
Dans l'exemple, une scalaire $un est définie. À cette scalaire est affecté le résultat de la fonction log. Le nombre, qui est transmis à cette fonction est dans l'exemple la valeur renvoyée par la fonction exp, appliquée sur le nombre 1. Étant donné que exp est la fonction inverse de log, le résultat de l'appel imbriqué des deux fonctions donne le valeur 1. Pour le contrôle, du code HTML est envoyé au navigateur et sort le résultat.
|
|
Convertit une valeur octale disponible sous forme de chaîne de caractères en valeur décimale correspondante.
Attend comme paramètre:
1. une chaîne de caractères qui représente une valeur octale valide donc par exemple "755" ou bien "0755".
Renvoie la valeur décimale correspondante comme valeur numérique.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $droits_unix_oct = $ENV{'QUERY_STRING'};
my $droits_decimal = oct($droits_unix_oct);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
print "La représentation décimale des droits en Unix $droits_unix_oct donne $droits_decimal\n";
print "</body></html>\n";
|
Un cas typique d'application pour les valeurs en octal est la mention d'attribution des droits pour l'utilisateur, le groupe d'utilisateurs et les autres (User, Group et Other) dans le système de fichiers Unix. L'exemple de script CGI attend une telle mention de droits typique en octal et y recherche la valeur décimale correspondante. Pour cela, le script attend la transmission d'un paramètre noté derrière un point d'interrogation lors de l'appel par une URI. Le paramètre transmis est composé d'une valeur en octal. Exemple:
http://localhost/cgi-bin/test.pl?0755.
Le script en exemple recherche le paramètre transmis dans la variable d'environnement CGI QUERY_STRING et sauvegarde la valeur dans la scalaire $droits_unix_oct. Cette scalaire est transmise à son tour à la fonction oct, qui la transforme en nombre décimal, qui est sauvegardé dans $droits_decimal. Pour le contrôle, le script sort les deux valeurs.
|
|
Recherche un nombre aléatoire entre 0 et 1, si aucun paramètre n'est transmis, ou un nombre aléatoire entre 0 compris et le nombre n non compris, si n est transmis comme paramètre. Le résultat est un nombre à virgule flottante.
Attend comme paramètre:
1. (facultatif) un nombre. S'il est mentionné, un nombre aléatoire entre 0 et ce nombre est recherché, sinon entre 0 et 1.
Renvoie le nombre aléatoire trouvé.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @nombres;
for(my $i = 0; $i < 7; $i++) {
$nombres[$i] = int(rand(49) + 1);
}
my @chiffres_lotto = sort(tri_nombres @nombres);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
print "Le tuyau de Perl pour le lotto et:<br>\n";
print "$chiffres_lotto[0], $chiffres_lotto[1], $chiffres_lotto[2], $chiffres_lotto[3], $chiffres_lotto[4], $chiffres_lotto[5]<br>\n";
print "Le numéro complémentaire est le: $chiffres_lotto[6]\n";
print "</body></html>\n";
sub tri_nombres {
if($a < $b)
{ return -1; }
elsif($a == $b)
{ return 0; }
else
{ return 1; }
}
|
Le script vous évite d'imaginer les numéros du lotto. Il recherche 7 nombres (6 plus le numéro complémentaire) entre 1 et 49. Les nombres sont recherchés dans une boucle for . Afin que ce soit réellement des nombres entiers compris entre 0 et 49 qui soient trouvés, le nombre 49 est transmis comme paramètre à l'appel de la fonction rand. Ainsi cependant, ne seront trouvés que des nombres entre 0.0x et 48.9x. En y ajoutant 1, ce sont des nombres compris entre 1.0x et 49.9x. En appliquant encore à toute l'opération la fonction int , on obtient des nombres entiers compris entre 1 et 49.
Pour sortir les nombres bien triés est encore appliquée la fonction sort. Comme il s'agit d'un tri numérique, le script utilise la fonction utilitaire pour le tri numérique.
Le script envoie du code HTML au navigateur et sort les numéros du loto trouvés.
Avec cette façon de générer des nombres aléatoires, il ne s'agit pas de "véritables" nombres aléatoires mais de pseudo chiffres aléatoires, qui sont créés à l'aide d'un algorithme sur la base d'une valeur de départ. Vous pouvez aussi préciser vous-même cette valeur de départ. C'est à cela que sert la fonction srand.
|
|
Attend comme paramètre:
1. un nombre quelconque permis.
Renvoie le sinus du nombre.
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); my $x = 2; my $Fx = sin($x) + sin(2*$x) - sin(3*$x) + sin(4*$x) - sin(5*$x) + 0.3*sin(25*$x); print "Content-type: text/html\n\n"; print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n"; print "<html><head><title>Sortie du test</title></head><body>\n"; print "$Fx\n"; print "</body></html>\n"; |
L'exemple montre une application répétée de la fonction sin dans une opération. Le script envoie du code HTML au navigateur et sort le résultat de l'opération.
|
|
Attend comme paramètre:
1. un nombre quelconque plus grand que 0.
Renvoie la racine carrée du nombre.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title></head><body>\n";
for(my $i = 1; $i <= 1000; $i++) {
my $racine = sqrt($i);
if($racine == int($racine)) {
print "La racine carrée de $racine est $i<br>\n";
}
}
print "</body></html>\n";
|
Le script en exemple envoie du code HTML au navigateur. Ici, la racine carrée est recherchée pour les nombres de 1 à 1000 dans une boucle for avec sqrt et sauvegardée dans une scalaire $racine. Ensuite il est demandé si la valeur qui y est sauvegardée est identique au nombre entier de cette valeur. À cet effet la fonction int est appliquée.
Si $racine et int($racine) sont identiques, il s'agit, dans la boucle actuelle de $i d'un nombre au carré. Si c'est le cas dans l'exemple, une ligne correspondante est sortie. De cette manière, le script sort tous les nombres au carré entre 1 et 1000.
|
|
Quand vous créez des nombres aléatoires avec rand, Perl a besoin en interne d'une valeur d'initialisation. Si vous ne mentionnez aucune valeur vous même, Perl en recherche automatiquement une. Vous pouvez cependant aussi mentionner la valeur vous même.
Attend comme paramètre:
1. un nombre entier quelconque permis ou un nombre, duquel la partie avant la virgule sera utilisée.
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); srand(42); my $hasard_1 = rand(); my $hasard_2 = rand(); srand(42); my $hasard_3 = rand(); my $hasard_4 = rand(); print "Content-type: text/html\n\n"; print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n"; print "<html><head><title>Sortie du test</title></head><body>\n"; print "hasard 1: $hasard_1<br>\n"; print "hasard 2: $hasard_2<br>\n"; print "hasard 3: $hasard_3<br>\n"; print "hasard 4: $hasard_4\n"; print "</body></html>\n"; |
L'exemple illustre la façon d'agir de srand et des appels qui suivent de rand. Elle est initialisée deux fois avec la même valeur, à savoir avec le nombre 42. Ensuite la fonction rand est appelée respectivement deux fois et les valeurs aléatoires trouvées sont sauvegardées à chaque fois dans des scalaires distinctes. L'exemple envoie du code HTML au navigateur et sort les quatre scalaires. Les valeurs de $hasard_1 et $hasard_3 sont ici les mêmes comme les valeurs de $hasard_2 et $hasard_4. Et ce n'est pas un hasard mais la conséquence du fait que chaque initialisation déterminée de srand génère la même série de nombres aléatoires à chaque appel de rand qui suit.
|
| |
 |
Fonctions pour le contrôle du script en cours
|
 |
Fonctions pour les listes et les hashes
|
| SELFHTML/Aides à la navigation CGI/Perl Fonctions Perl |
© 2001 Stefan Münz / © 2003 Traduction 
Serge François, 13405@free.fr selfhtml@fr.selfhtml.org