Conversion littérale d'un nombre entier ou flottant

Soyez le premier à donner votre avis sur cette source.

Vue 16 526 fois - Téléchargée 1 100 fois

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.

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

cs_Jean-Pierre
Messages postés
88
Date d'inscription
jeudi 25 septembre 2003
Statut
Membre
Dernière intervention
20 avril 2010
-
Bonjour,

Ce petit mot d'encouragement, car je trouve absolument dég******** la note de 3 apportée à ce source.

Un code comme ça mérite au moins le triple, voilà qui est dit !

Un 10 et bravo Japee !
japee
Messages postés
1708
Date d'inscription
vendredi 27 décembre 2002
Statut
Modérateur
Dernière intervention
5 octobre 2019
1 -
Salut Mauricio,

Je prends note de tes suggestions pour une évolution future de mon code. Merci pour tes commentaires qui sont constructifs et utiles, comme d'habitude.
Je suis allé faire un tour du côté de la source que tu as publiée sur le sujet, mais n'ai pas eu le temps de la tester. Je le ferai dès que possible.
Quand à la limace visqueuse qui m'a collé un 3 sans laisser la moindre explication, je ne lui dirai pas ce que je pense de ce genre de comportement : il ne comprendrait sans doute pas plus qu'il ne comprend quelque chose à la programmation.
cs_lucien
Messages postés
82
Date d'inscription
vendredi 27 décembre 2002
Statut
Membre
Dernière intervention
3 juin 2007
-
Pour Japi,
Je vois que tu viens de déposer une mise à jour que je vais découvrir...J'aurais aimé qu'elle contienne (peut-être est-ce le cas ?) une option pour choisir le nombre de décimales...Il est parfois utile d'en avoir plus de deux...
Merci,
Lucien
bongenie
Messages postés
15
Date d'inscription
samedi 8 janvier 2005
Statut
Membre
Dernière intervention
28 octobre 2010
-
Personnellement, je préfère gérer le problème de la virgule de façon autoritaire dès l'appui de la touche, à savoir :
procedure TForm1.edFloatOnKeyPress(Sender: TObject; var Key: Char);
begin
if key=',' then key:='.';
end;

Les problèmes compliqués ont souvent des réponses simples ;-) (bien sûr si on veut vraiment voir la vrai virgule c'est un autre problème)
cs_MAURICIO
Messages postés
2233
Date d'inscription
mardi 10 décembre 2002
Statut
Modérateur
Dernière intervention
15 décembre 2014
5 -
J' ai oublié de préciser que ma fonction renvoit le résultat en portugais et non pas en français!
Mais ceux qui me connaissent avaient compris :)
A+

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.