Developpez.com

Une très vaste base de connaissances en informatique avec
plus de 100 FAQ et 10 000 réponses à vos questions

FAQ DelphiConsultez toutes les FAQ

Nombre d'auteurs : 119, nombre de questions : 909, dernière mise à jour : 22 décembre 2016  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums Delphi et Delphi et bases de données de www.developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose soient correctes. Les auteurs font le maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous souhaitez y apporter des corrections ou la compléter, contactez un responsable (lien au bas de cette page).

Nous espérons que cette FAQ saura répondre à vos attentes. Nous vous en souhaitons une bonne lecture.

L'équipe Delphi de Developpez.com.

Commentez


SommaireLangageTypes de donnéesNombres (9)
précédent sommaire suivant
 

Pour convertir un réel en entier, il faut utiliser les fonctions suivantes :

Function Trunc (X : Extended) : Integer

Trunc ajuste à l'entier le plus petit.
Exemples :

  • Trunc(1.2) donne 1 ;
  • Trunc(1.9) donne 1 ;
  • Trunc(-1.4) donne -1.

Function Round (X : Extended) : Integer

Round arrondit à l'entier le plus proche ; dans le cas où la valeur est juste entre deux entiers, c'est l'entier pair qui est choisi.
Exemples :
  • Round(1.2) donne 1 ;
  • Round(1.9) donne 2 ;
  • Round(1.5) donne 2 ;
  • Round(2.5) donne 2 ;
  • Round(2.500001) donne 3 ;
  • Round(-1.4) donne -1 ;
  • Round(-1.5) donne -2.

Function Ceil (X : Extended) : Integer (unité Maths)

Ceil arrondit à l'entier supérieur.
Exemples :
  • Ceil(1.2) donne 2 ;
  • Ceil(1.9) donne 2 ;
  • Ceil(-1.5) donne -1.

Function Floor (X : Extended) : Integer (unité Maths)

Floor arrondit à l'entier inférieur.
Exemples :
  • Floor(1.2) donne 1 ;
  • Floor(1.9) donne 1 ;
  • Floor(-1.5) donne -2.

Mis à jour le 18 octobre 2013 Nono40

Pour transformer un réel en chaîne sans formatage particulier, il faut utiliser la fonction FloatToStr (Value : Extended) : String.
Mais dans la plupart des cas, il est utile de formater le nombre de décimales. Pour ce faire il y a différentes fonctions dans Delphi : FloatToStrF(), FormatFloat() ou Format().

Par exemple, pour afficher une valeur avec deux chiffres après la virgule :

Code delphi : Sélectionner tout
1
2
3
4
5
6
Var f:Real; 
begin 
  f:=12345.6789; 
  ShowMessage(FloatToStrf(f,ffFixed,8,2)); 
  ShowMessage(FormatFloat('0.00',f)); 
  ShowMessage(Format('%8.2f',[f]));end;
Voir l'aide en ligne pour l'utilisation de ces fonctions.

Mis à jour le 18 octobre 2013 Nono40

En fonction des ordinateurs et de la configuration des options régionales, le caractère décimal par défaut n'est pas toujours le même. Si votre application est sensible à ce caractère, il est conseillé de le fixer à l'initialisation de l'application. Par exemple dans la section Initialization de la fiche principale :

Code delphi : Sélectionner tout
1
2
3
4
... 
Initialization 
  DecimalSeparator:='.'; 
end.

Ainsi, le caractère sera toujours le même. Il faut aussi penser à gérer la saisie de ce caractère dans les TEdit devant contenir des nombres réels :
Code delphi : Sélectionner tout
1
2
3
4
5
procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char); 
begin 
  If (Key=',') Or (Key='.') Then 
    Key:=DecimalSeparator; 
end;

Mis à jour le 18 octobre 2013 Nono40

La procédure donnée dans le code source ci-dessous permet de transformer un nombre en lettres, c'est-à-dire transformer 123 en « cent vingt trois ».
La déclaration de la fonction est la suivante :

Code delphi : Sélectionner tout
function NombreEnLettres(n : integer ; France : Boolean = True ) : string;
n est le nombre à transformer en lettres, France détermine le langage à utiliser. Si France est à True, 70 sera écrit « soixante dix », sinon 70 sera écrit « septante ». Par défaut, France est True s'il n'est pas précisé.

Cette fonction tient compte des cas particuliers du Français :
  • 31 : trente et un ;
  • 80 : quatre-vingts ;
  • 81 : quatre-vingt un (sans « s » et sans « et ») ;
  • 200 : deux cents ;
  • 202 : deux cent deux (sans « s »).


La première version de cette fonction a été écrite en Basic sur CBM 4032, pour un ami qui voulait afficher un "chèque" en fin d'un jeu de black-jack, avec le défi de n'utiliser que le minimum de mots en "data". Elle a ensuite été reprise comme sujet d'exercice lors de stages de programmation en Basic qu''animait son auteur en 1983 pour la LFEEP.
Elle a finalement été transcrite en Pascal suite à plusieurs demandes.

Mis à jour le 18 octobre 2013 Pascal Peyremorte

Pour arrondir un réel, utiliser la fonction SimpleRoundTo de l'unité Math.

Exemple :

Code delphi : Sélectionner tout
1
2
showMessage(floatToStr(SimpleRoundTo(1.235,-2))); 
  // Affiche 1.24
Si cette fonction n'est pas disponible dans votre version de Delphi, vous pouvez utiliser la fonction suivante :
Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
uses 
  Math; 
  
function Arrondir(nombre : extended ; nbDecim : integer) : extended; 
var 
  p10 : extended; 
begin 
  { 2 étant le cas le plus fréquent, on le traite directement } 
  if (nbDecim = 2) then 
    result := round(nombre * 100) / 100 
  else 
  begin 
    p10 := Power(10,nbDecim); 
    result := round(nombre * p10) / p10; 
  end; 
end;
Exemples :
Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
9
memo1.Lines.Add(floatToStr(arrondir(12,2))); 
memo1.Lines.Add(floatToStr(arrondir(13.59,1))); 
memo1.Lines.Add(floatToStr(arrondir(0.1,5))); 
memo1.Lines.Add(floatToStr(arrondir(0.14444444,3))); 
memo1.Lines.Add(floatToStr(arrondir(1.5,0))); 
memo1.Lines.Add(floatToStr(arrondir(1.54345678,1))); 
memo1.Lines.Add(floatToStr(arrondir(1.54345678,2))); 
memo1.Lines.Add(floatToStr(arrondir(1.54345678,3))); 
memo1.Lines.Add(floatToStr(arrondir(1.54345678,4)));
On obtient :
Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
12 
13,6 
0,1 
0,144 
2 
1,5 
1,54 
1,543 
1,5435

Mis à jour le 19 janvier 2014 Bloon

La fonction à utiliser est StrToInt en ajoutant un '$' devant la chaîne qui contient le nombre hexa :

Code delphi : Sélectionner tout
1
2
3
4
5
6
7
function hexaToInt(s : string) : integer; 
begin 
  if (s <> '') and (s[1] <> '$') then 
    result := StrToInt('$' + s) 
  else 
    result := StrToInt(s); 
end;
Exemples :
Code delphi : Sélectionner tout
1
2
3
showMessage(intToStr(hexaToInt('10'))); // 16 
showMessage(intToStr(hexaToInt('$10'))); // 16 
showMessage(intToStr(hexaToInt('ABCD'))); // 43981
Rappel : la fonction inverse est intToHex, qui renvoie la représentation hexadécimale d'un entier.

Mis à jour le 19 janvier 2014 Bloon

Cette fonctionnalité est proposée par la fonction Power, déclarée dans l'unité Math.

Syntaxe Delphi :

Code delphi : Sélectionner tout
function Power(const Base, Exponent: Extended): Extended;
Description
Power élève Base à n'importe quelle puissance. Pour les exposants fractionnels ou supérieurs à MaxInt, le paramètre Base doit être supérieur à 0.

Ainsi, pour récupérer 2.5^6, effectuez :
Code delphi : Sélectionner tout
1
2
3
uses Math; 
... 
Value := Power(2.5, 6);
Astuce : pour calculer la racine cubique d'un réel, utilisez :
Code delphi : Sélectionner tout
1
2
3
uses Math; 
... 
Value := Power(Value, 1/3);

Mis à jour le 19 janvier 2014 sjrd

Lorsque l'on compare 2 nombres à virgule flottante avec l'opérateur =, on a parfois des surprises : 2 nombres à priori égaux ne le sont pas. Ceci est dû à la représentation en virgule flottante qui est une approximation du nombre et non une représentation exacte (voir ci-dessous pour des explications plus poussées). Par exemple :

Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
9
var 
  a : double; 
begin 
  a := 11 + 1.11; 
  if (a = 12.11) then 
    showMessage('égal') 
  else 
    showMessage('pas égal') // <-- affiche ce message 
end;
Heureusement, à partir de Delphi 6, Borland nous fournit 3 fonctions dans l'unité Math qui sont :
Code delphi : Sélectionner tout
1
2
// Indique si deux valeurs en virgule flottante sont (approximativement) égales. 
function SameValue(const A, B: Single; Epsilon: Single = 0): Boolean; overload;
Les deux fonctions suivantes utilisent SameValue :
Code delphi : Sélectionner tout
1
2
// Indique si une variable ou une expression en virgule flottante est évaluée à zéro ou à une valeur très proche de zéro. 
function IsZero(const A: Single; Epsilon: Single = 0): Boolean; overload;
Code delphi : Sélectionner tout
1
2
// Renvoie la relation existant entre deux valeurs numériques. 
function CompareValue(const A, B: Single; Epsilon: Single = 0): TValueRelationship; overload;
Ces trois fonctions sont définies pour des Single, Double et Extended. CompareValue est également définie pour Integer et Int64. Le code ci-dessus qui ne fonctionnait pas devient alors :
Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
uses Math; 
var 
  a : double; 
begin 
  a := 11 + 1.11; 
  if sameValue(a,12.11) then 
    showMessage('égal')      // <-- affiche ce message 
  else 
    showMessage('pas égal'); 
end;
L'aide de Delphi nous apprend qu'Epsilon est la quantité maximale dont A et B peuvent s'éloigner tout en étant considérées comme égales. Par défaut cette valeur est 0 mais en regardant le code, on constate que si epsilon est à 0 (ce qui n'aurait pas de sens), cette valeur est corrigée.

Si vous avez une version antérieure à Delphi 6

Il faut écrire une fonction qui se charge du travail. La valeur de Epsilon dépend de la précision des types réels comparés :
Code delphi : Sélectionner tout
1
2
3
4
function EgaliteReels(n1,n2 : extended) : boolean; 
begin 
  result := Abs(n1 - n2) < Min(abs(n1),abs(n2)) * 1E-16; 
end;
Code delphi : Sélectionner tout
1
2
3
4
function EgaliteReels(n1,n2 : double) : boolean; 
begin 
  result := Abs(n1 - n2) < Min(abs(n1),abs(n2)) * 1E-12; 
end;
Code delphi : Sélectionner tout
1
2
3
4
function EgaliteReels(n1,n2 : single) : boolean; 
begin 
  result := Abs(n1 - n2) < Min(abs(n1),abs(n2)) * 1E-4; 
end;
Quelques précisions sur le calcul flottant

Pour aborder le calcul flottant je vous invite à vous reporter à la Norme IEEE 754 que vous pouvez consulter à cet endroit.

Les arrondis corrects de la nome IEEE 754, font qu'il est pratiquement impossible de comparer deux extended par le simple test suivant :
Code delphi : Sélectionner tout
1
2
x,y: extended; 
if x = y then //pas bien
Pour résoudre ce problème de façon simple plusieurs méthodes sont à notre disposition.
  • La première consiste à calculer la différence entre nos deux extended x et y puis de vérifier que cette différence est inférieure à epsilon (1 > epsilon > 0) que nous aurons fixé.
    Cela donne :
    Code delphi : Sélectionner tout
    | x - y | < epsilon
    Rappelons que x et y sont des flottants normalisés, on peut alors écrire
    Code delphi : Sélectionner tout
    x = m1 10exp(a) et y = m2 10exp(b)
    donc,
    Code delphi : Sélectionner tout
    |m1 10exp(a) - m2 10exp(b)| < epsilon
    Puisque x et y sont des nombres très proche dans le meilleur des cas nous aurons a = b, donc
    Code delphi : Sélectionner tout
    |(m1-m2) 10exp(a)| < epsilon
  • La seconde méthode pour comparer les nombres x et y peut partir de la constatation que si x et y sont très proches alors le quotient de ces deux nombres est proche de 1. On peut alors écrire :
    Code delphi : Sélectionner tout
    1
    2
    1-epsilon < |x/y| < 1 + epsilon 
    -epsilon < |x/y| - 1 < epsilon
    soit encore
    Code delphi : Sélectionner tout
    |1-|x/y|| < epsilon (*en ayant multiplié chacun des membres par -1*)
    En remplaçant x et y par leur représentation flottante normalisée, nous obtenons
    Code delphi : Sélectionner tout
    |1-|(m1 10exp(a))/(m2 10exp(b))|| < epsilon
    Comme plus haut, a = b dans le meilleur des cas, donc
    Code delphi : Sélectionner tout
    |1-|m1/m2|| < epsilon
    Ce qui est plus simple que dans la première méthode. En effet ici le calcul ne prendra en compte que les mantisses des flottants.

Mis à jour le 19 janvier 2014 Bloon

Pour formater un nombre entier en utilisant les séparateurs de milliers, on doit utiliser l'astuce de convertir notre entier en nombre flottant et n'afficher que la partie entière. La fonction format permet de réaliser cela très facilement.

Il existe deux formes d'utilisation de la fonction format.

Il est possible d'utiliser une variable locale pour spécifier le séparateur de milliers ou le séparateur décimal.

Voici un exemple :

Code Delphi : Sélectionner tout
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
  
procedure AfficheEntierFormate; 
var 
i:integer; 
setting:Tformatsettings; 
begin 
i:=10000000; 
  
//première forme de l'utilisation de la fonction format 
//L'astuce consiste à diviser l'entier par 1 pour obtenir un nombre flottant 
//et utiliser le caractère de type de conversion n au lieu de d. 
//On fixe le nombre de décimale à zéro avec le spécificateur facultatif de précision .0 
//On affiche donc une nombre flottant sans afficher les décimales 
//La fonction format utilisera les paramètres locaux pour formater le nombre 
showmessage(format('le nombre est %.0n ',[i/1])); 
//Si le séparateur de millier est l'espace notre valeur sera 10 000 000 
//mais rien nous garantie que le séparateur de millier est celui que nous voulons 
  
//Si on désire contrôler les paramètres de formatage, il faut déclarer une variable 
//de type Tformatsetting et utiliser la deuxième forme de la fonction format 
//On initialise notre variable avec les paramètres régionaux fixés par l'usager 
GetLocaleFormatSettings(SysLocale.DefaultLCID, setting); 
//On modifie la valeur ou les valeurs qui nous intéressent 
setting.ThousandSeparator:=','; 
showmessage(format('le nombre est %.0n ',[i/1], setting)); 
//Notre valeur sera affichée à coup sur selon notre désir 10,000,000 
  
end;
De cette façon, on ne modifie pas les variables globales et on ne risque pas d'effet de bord dans les traitements subséquents.

Mis à jour le 10 avril 2014 BeTuLa

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2017 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsables bénévoles de la rubrique Delphi : Gilles Vasseur - Alcatîz -