Conversion littérale d'un nombre entier ou flottant

Télécharger le projet
Commenter

Description

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.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

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.

Du même auteur (japee)