Affiche en toutes lettres un nombre avec ou sans virgule, avec son unité (monétaire, mesure, etc...).
Bien qu'il existe d'autres sources sur le sujet, il m'a paru intéressant de publier la mienne pour plusieurs raisons :
- elle gère bien les règles grammaticales concernant les adjectifs numéraux cardinaux tels que définies par le Bescherelle,
- elle prend en compte le singulier et le pluriel,
- la grandeur des nombres n'est limitée que par l'étendue du type utilisé pour les définir,
- elle me semble suffisemment robuste et capable de rendre un réel service, bien qu'elle puisse être grandement améliorée.
- c'est moi "que je" l'ai faite...
Vous trouverez en prime une fonction perso qui trouve ici son utilité :
function StrToFloatDef(S: string; Def: Extended): Extended;
Une impression de déjà vu quelque part ???
C'est normal.
Cette fonction qui s'applique à un nombre réel, est semblable à la fonction StrToIntDef pour les nombre entiers.
Bien que je me réserve d'améliorer tout ça, il me semble que ça peut rendre service en l'état.
Source / Exemple :
unit Num2Let;
interface
uses Math, SysUtils;
function NumericToLetters(Num: Int64): string; overload;
function NumericToLetters(Num: Extended; const Sep: string = 'virgule'): string; overload;
implementation
function NumericToLetters(Num: Int64): string;
const
N0_19: array[0..19] of string =
('zéro','un','deux','trois','quatre','cinq','six','sept','huit','neuf', 'dix',
'onze','douze','treize','quatorze','quinze','seize','dix-sept','dix-huit','dix-neuf');
N20_60: array[2..6] of string =
('vingt','trente','quarante','cinquante','soixante');
Separator: array[Boolean] of string = ('-', ' et ');
Pluriel: array[Boolean] of string = ('', 's');
DIX : Int64 = 10;
CENT : Int64 = 100;
MILLE : Int64 = 1000;
MILLION : Int64 = 1000000;
MILLIARD : Int64 = 1000000000;
var
NDizaines, NCentaines, NMilliers, NMillions, NMilliards: Int64;
begin
if Num > 999999999 then
begin
NMilliards := Num div MILLIARD;
if Num mod MILLIARD = 0 then
Result := NumericToLetters(NMilliards)
+ ' milliard'
+ Pluriel[NMilliards > 1]
else
Result := NumericToLetters(NMilliards)
+ ' milliard' + Pluriel[NMilliards > 1] + ' '
+ NumericToLetters(Num - (NMilliards) * MILLIARD);
end
else
case Num of
0..19: Result := N0_19[Num];
20..69:
begin
NDizaines := Num div DIX;
if Num mod DIX = 0 then // if (Num in [20,30,40,50,60]) then
Result := N20_60[NDizaines]
else
Result := N20_60[NDizaines]
+ Separator[Num mod DIX = 1]
+ N0_19[Num - NDizaines * DIX];
end;
70..79: Result := 'soixante' + Separator[Num mod DIX = 1] + N0_19[Num - 60];
80: Result := 'quatre-vingts';
81..99: Result := 'quatre-vingt-' + N0_19[Num - 80];
100: Result := 'cent';
101..199: Result := 'cent ' + NumericToLetters(Num - CENT);
200..999:
begin
NCentaines := Num div CENT;
if Num mod CENT = 0 then
Result := N0_19[NCentaines] + ' cents'
else
Result := N0_19[NCentaines] + ' cent ' + NumericToLetters(Num - NCentaines * CENT);
end;
1000: Result := 'mille';
1001..1999: Result := 'mille ' + NumericToLetters(Num - MILLE);
2000..999999:
begin
NMilliers := Num div MILLE;
if Num mod MILLE = 0 then
Result := NumericToLetters(NMilliers) + ' mille'
else
Result := NumericToLetters(NMilliers) + ' mille '
+ NumericToLetters(Num - NMilliers * MILLE);
end;
1000000..999999999:
begin
NMillions := Num div MILLION;
if Num mod MILLION = 0 then
Result := NumericToLetters(NMillions)
+ ' million' + Pluriel[NMillions > 1]
else
Result := NumericToLetters(NMillions)
+ ' million' + Pluriel[NMillions > 1] + ' '
+ NumericToLetters(Num - NMillions * MILLION);
end;
end;
end;
{ ni la plus élégante ni la plus rapide des solutions, mais efficace }
procedure SeparateIntDec(Value: Extended; var IntPart, DecPart: Int64;
const N: Byte = 2);
var
S, sIntPart, sDecPart: string;
P: Byte;
begin
S := FloatToStr(Value); // uses SysUtils
P := Pos(DecimalSeparator, S);
if P = 0 then
begin
IntPart := Int64(Trunc(Value));
DecPart := 0;
end
else
begin
sIntPart := Copy(S, 1, Pos(DecimalSeparator, S) - 1);
sDecPart := Copy(S, Pos(DecimalSeparator, S) + 1, 2);
IntPart := StrToIntDef(sIntPart, 0);
if Length(sDecPart) = 2 then
DecPart := StrToInt64Def(sDecPart, 0)
else
DecPart := StrToInt64Def(sDecPart + '0', 0);
end;
end;
{ fonction très simplifiée, suffisante pour cet usage }
function PluralOf(const S: string; const Value: Extended): string;
const
P: array[False..True] of string = ('', 's');
NotAllowed = ['s', 'x', 'z'];
var
Plural: Boolean;
begin
Plural := (Abs(Value) >= 2) and (S <> 'virgule') and not(S[Length(S)] in NotAllowed);
Result := Format('%s%s', [S, P[Plural]]);
end;
function NumericToLetters(Num: Extended; const Sep: string = 'virgule'): string;
var
IntPart, DecPart: Int64;
Separator: string;
begin
SeparateIntDec(Num, IntPart, DecPart);
Separator := Format(' %s ', [PluralOf(Sep, Num)]);
Result := NumericToLetters(IntPart) + Separator + NumericToLetters(DecPart);
end;
end.
-------------------------------------------------------------------------------
function StrToFloatDef(S: string; Def: Extended): Extended;
var
Code: Integer;
begin
if DecimalSeparator <> '.' then // uses SysUtils
S := StringReplace(S, DecimalSeparator, '.', []);
Val(S, Result, Code);
if Code <> 0 then
Result := Def;
end;
Conclusion :
Compilable à partir de D4.
N'hésitez pas à me signaler les vilains bugs.
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.