CONVERSION LITTÉRALE D'UN NOMBRE ENTIER OU FLOTTANT

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;

Télécharger le zip

04 février 2007 13:30:13 :

Suppression d'une variable superflue.

05 février 2007 20:27:05 :

Correction d'un bug se produisant quand le paramétrage système du séparateur décimal est le point (merci à Lucien pour me l'avoir fait remarquer). Utilisation de StrToInt64Def() dans la procedure SeparateIntDec() afin de rester cohérent avec la valeur à traiter sur 64 bits (merci à WhiteHippo pour le conseil).

05 février 2007 20:51:08 :

Retouche mineure dans le blabla de présentation.