763 lines
22 KiB
PHP
763 lines
22 KiB
PHP
<?
|
|
|
|
class WChiffes {
|
|
|
|
private static $tabChiffresEnLEttres = array( 0=>'zéro',
|
|
1=>'un',
|
|
2=>'deux',
|
|
3=>'trois',
|
|
4=>'quatre',
|
|
5=>'cinq',
|
|
6=>'six',
|
|
7=>'sept',
|
|
8=>'huit',
|
|
9=>'neuf',
|
|
10=>'dix',
|
|
11=>'onze',
|
|
12=>'douze',
|
|
13=>'treize',
|
|
14=>'quatorze',
|
|
15=>'quinze',
|
|
16=>'seize',
|
|
17=>'dix sept',
|
|
18=>'dix huit',
|
|
19=>'dix neuf',
|
|
20=>'vingt',
|
|
21=>'vingt et un',
|
|
22=>'vingt deux',
|
|
23=>'vingt trois',
|
|
24=>'vingt quatre',
|
|
25=>'vingt cinq',
|
|
26=>'vingt six',
|
|
27=>'vingt sept',
|
|
28=>'vingt huit',
|
|
29=>'vingt neuf',
|
|
30=>'trente',
|
|
40=>'quarante',
|
|
50=>'cinquante',
|
|
60=>'soixante',
|
|
70=>'soixante dix',
|
|
80=>'quatre vingt',
|
|
90=>'quatre vingt dix');
|
|
|
|
public function ChiffresEnLettres($chiffre) {
|
|
return array_search($chiffre, self::$tabChiffresEnLEttres);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
define('NEL_SEPTANTE', 0x0001);
|
|
define('NEL_HUITANTE', 0x0002);
|
|
define('NEL_OCTANTE', 0x0004);
|
|
define('NEL_NONANTE', 0x0008);
|
|
define('NEL_BELGIQUE', NEL_SEPTANTE|NEL_NONANTE);
|
|
define('NEL_VVF', NEL_SEPTANTE|NEL_HUITANTE|NEL_NONANTE);
|
|
define('NEL_ARCHAIQUE', NEL_SEPTANTE|NEL_OCTANTE|NEL_NONANTE);
|
|
define('NEL_SANS_MILLIARD', 0x0010);
|
|
define('NEL_AVEC_ZILLIARD', 0x0020);
|
|
define('NEL_TOUS_ZILLIONS', 0x0040);
|
|
define('NEL_RECTIF_1990', 0x0100);
|
|
define('NEL_ORDINAL', 0x0200);
|
|
define('NEL_NIEME', 0x0400);
|
|
|
|
|
|
# Le tableau associatif $NEL contient toutes les variables utilisées
|
|
# de façon globale dans ce module. ATTENTION : ce nom est assez court,
|
|
# et cela pourrait poser des problèmes de collision avec une autre
|
|
# variable si plusieurs modules sont inclus dans le même programme.
|
|
|
|
$NEL = array(
|
|
'1-99' => array(
|
|
# 0-19
|
|
'', 'un', 'deux', 'trois', 'quatre', 'cinq', 'six', 'sept',
|
|
'huit', 'neuf', 'dix', 'onze', 'douze', 'treize', 'quatorze',
|
|
'quinze', 'seize', 'dix-sept', 'dix-huit', 'dix-neuf',
|
|
# 20-29
|
|
'vingt', 'vingt et un', 'vingt-deux', 'vingt-trois',
|
|
'vingt-quatre', 'vingt-cinq', 'vingt-six',
|
|
'vingt-sept', 'vingt-huit', 'vingt-neuf',
|
|
# 30-39
|
|
'trente', 'trente et un', 'trente-deux', 'trente-trois',
|
|
'trente-quatre', 'trente-cinq', 'trente-six',
|
|
'trente-sept', 'trente-huit', 'trente-neuf',
|
|
# 40-49
|
|
'quarante', 'quarante et un', 'quarante-deux', 'quarante-trois',
|
|
'quarante-quatre', 'quarante-cinq', 'quarante-six',
|
|
'quarante-sept', 'quarante-huit', 'quarante-neuf',
|
|
# 50-59
|
|
'cinquante', 'cinquante et un', 'cinquante-deux', 'cinquante-trois',
|
|
'cinquante-quatre', 'cinquante-cinq', 'cinquante-six',
|
|
'cinquante-sept', 'cinquante-huit', 'cinquante-neuf',
|
|
# 60-69
|
|
'soixante', 'soixante et un', 'soixante-deux', 'soixante-trois',
|
|
'soixante-quatre', 'soixante-cinq', 'soixante-six',
|
|
'soixante-sept', 'soixante-huit', 'soixante-neuf',
|
|
# 70-79
|
|
'septante', 'septante et un', 'septante-deux', 'septante-trois',
|
|
'septante-quatre', 'septante-cinq', 'septante-six',
|
|
'septante-sept', 'septante-huit', 'septante-neuf',
|
|
# 80-89
|
|
'huitante', 'huitante et un', 'huitante-deux', 'huitante-trois',
|
|
'huitante-quatre', 'huitante-cinq', 'huitante-six',
|
|
'huitante-sept', 'huitante-huit', 'huitante-neuf',
|
|
# 90-99
|
|
'nonante', 'nonante et un', 'nonante-deux', 'nonante-trois',
|
|
'nonante-quatre', 'nonante-cinq', 'nonante-six',
|
|
'nonante-sept', 'nonante-huit', 'nonante-neuf'
|
|
),
|
|
|
|
'illi' => array('', 'm', 'b', 'tr', 'quatr', 'quint', 'sext'),
|
|
'maxilli' => 0, # voir plus loin
|
|
'de_maxillions' => '', # voir plus loin
|
|
|
|
'septante' => false, # valeurs possibles : (false|true)
|
|
'huitante' => false, # valeurs possibles : (false|true|'octante')
|
|
'nonante' => false, # valeurs possibles : (false|true)
|
|
'zillions' => false, # valeurs possibles : (false|true)
|
|
'zilliard' => 1, # valeurs possibles : (0|1|2)
|
|
'rectif' => false, # valeurs possibles : (false|true)
|
|
'ordinal' => false, # valeurs possibles : (false|true|'nieme')
|
|
|
|
'separateur' => ' '
|
|
);
|
|
|
|
# Si le tableau $NEL['illi'] s'arrête à 'sext', alors les deux valeurs
|
|
# suivantes sont respectivement '6' et ' de sextillions'.
|
|
$NEL['maxilli'] = count($NEL['illi']) - 1;
|
|
$NEL['de_maxillions'] = " de {$NEL['illi'][$NEL['maxilli']]}illions";
|
|
|
|
function enlettres_options($options, $separateur=NULL)
|
|
{
|
|
global $NEL;
|
|
|
|
if ($options !== NULL) {
|
|
$NEL['septante'] = ($options & NEL_SEPTANTE) ? true : false;
|
|
$NEL['huitante'] =
|
|
($options & NEL_OCTANTE) ? 'octante' :
|
|
(($options & NEL_HUITANTE) ? true : false);
|
|
$NEL['nonante'] = ($options & NEL_NONANTE) ? true : false;
|
|
$NEL['zillions'] = ($options & NEL_TOUS_ZILLIONS) ? true : false;
|
|
$NEL['zilliard'] =
|
|
($options & NEL_AVEC_ZILLIARD) ? 2 :
|
|
(($options & NEL_SANS_MILLIARD) ? 0 : 1);
|
|
$NEL['rectif'] = ($options & NEL_RECTIF_1990) ? true : false;
|
|
$NEL['ordinal'] =
|
|
($options & NEL_NIEME) ? 'nieme' :
|
|
(($options & NEL_ORDINAL) ? true : false);
|
|
}
|
|
|
|
if ($separateur !== NULL) {
|
|
$NEL['separateur'] = $separateur;
|
|
}
|
|
}
|
|
|
|
function enlettres_par3($par3)
|
|
{
|
|
global $NEL;
|
|
|
|
if ($par3 == 0) return '';
|
|
|
|
$centaine = floor($par3 / 100);
|
|
$par2 = $par3 % 100;
|
|
$dizaine = floor($par2 / 10);
|
|
|
|
# On traite à part les particularités du français de référence
|
|
# 'soixante-dix', 'quatre-vingts' et 'quatre-vingt-dix'.
|
|
$nom_par2 = NULL;
|
|
switch ($dizaine) {
|
|
case 7:
|
|
if ($NEL['septante'] === false) {
|
|
if ($par2 == 71) $nom_par2 = 'soixante et onze';
|
|
else $nom_par2 = 'soixante-' . $NEL['1-99'][$par2 - 60];
|
|
}
|
|
break;
|
|
case 8:
|
|
if ($NEL['huitante'] === false) {
|
|
if ($par2 == 80) $nom_par2 = 'quatre-vingts';
|
|
else $nom_par2 = 'quatre-vingt-' . $NEL['1-99'][$par2 - 80];
|
|
}
|
|
break;
|
|
case 9:
|
|
if ($NEL['nonante'] === false) {
|
|
$nom_par2 = 'quatre-vingt-' . $NEL['1-99'][$par2 - 80];
|
|
}
|
|
break;
|
|
}
|
|
if ($nom_par2 === NULL) {
|
|
$nom_par2 = $NEL['1-99'][$par2];
|
|
if (($dizaine == 8) and ($NEL['huitante'] === 'octante')) {
|
|
$nom_par2 = str_replace('huitante', 'octante', $nom_par2);
|
|
}
|
|
}
|
|
|
|
# Après les dizaines et les unités, il reste à voir les centaines
|
|
switch ($centaine) {
|
|
case 0: return $nom_par2;
|
|
case 1: return rtrim("cent {$nom_par2}");
|
|
}
|
|
|
|
# Assertion : $centaine = 2 .. 9
|
|
$nom_centaine = $NEL['1-99'][$centaine];
|
|
if ($par2 == 0) return "{$nom_centaine} cents";
|
|
return "{$nom_centaine} cent {$nom_par2}";
|
|
}
|
|
|
|
function enlettres_zilli($idx)
|
|
{
|
|
# Noms des 0ème à 9ème zillions
|
|
static $petit = array(
|
|
'n', 'm', 'b', 'tr', 'quatr', 'quint', 'sext', 'sept', 'oct', 'non'
|
|
);
|
|
# Composantes des 10ème à 999ème zillions
|
|
static $unite = array(
|
|
'<', 'un<', 'duo<', 'tre<sé',
|
|
'quattuor<', 'quin<', 'se<xsé',
|
|
'septe<mné', 'octo<', 'nove<mné'
|
|
);
|
|
static $dizaine = array(
|
|
'', 'né>déci<', 'ms>viginti<', 'ns>triginta<',
|
|
'ns>quadraginta<', 'ns>quinquaginta<', 'né>sexaginta<',
|
|
'né>septuaginta<', 'mxs>octoginta<', 'é>nonaginta<'
|
|
);
|
|
static $centaine = array(
|
|
'>', 'nxs>cent', 'né>ducent', 'ns>trécent',
|
|
'ns>quadringent', 'ns>quingent', 'né>sescent',
|
|
'né>septingent', 'mxs>octingent', 'é>nongent'
|
|
);
|
|
|
|
# Règles d'assimilation aux préfixes latins, modifiées pour accentuer
|
|
# un éventuel 'é' de fin de préfixe.
|
|
# (1) Si on trouve une lettre deux fois entre < > on la garde.
|
|
# S'il y a plusieurs lettres dans ce cas, on garde la première.
|
|
# (2) Sinon on efface tout ce qui est entre < >.
|
|
# (3) On remplace "treé" par "tré", "seé" par "sé", "septeé" par "septé"
|
|
# et "noveé" par "nové".
|
|
# (4) En cas de dizaine sans centaine, on supprime la voyelle en trop.
|
|
# Par exemple "déciilli" devient "décilli" et "trigintailli" devient
|
|
# "trigintilli".
|
|
#
|
|
# Il est à noter que ces règles PERL (en particulier la première qui
|
|
# est la plus complexe) sont *très* fortement inspirées du programme
|
|
# de Nicolas Graner. On pourrait même parler de plagiat s'il n'avait
|
|
# pas été au courant que je reprenais son code.
|
|
# Voir <http://www.graner.net/nicolas/nombres/nom.php>
|
|
# et <http://www.graner.net/nicolas/nombres/nom-exp.php>
|
|
#
|
|
static $recherche = array(
|
|
'/<[a-zé]*?([a-zé])[a-zé]*\1[a-zé]*>/', # (1)
|
|
'/<[a-zé]*>/', # (2)
|
|
'/eé/', # (3)
|
|
'/[ai]illi/' # (4)
|
|
);
|
|
static $remplace = array(
|
|
'\\1', # (1)
|
|
'', # (2)
|
|
'é', # (3)
|
|
'illi' # (4)
|
|
);
|
|
|
|
$nom = '';
|
|
while ($idx > 0) {
|
|
$p = $idx % 1000;
|
|
$idx = floor($idx/1000);
|
|
|
|
if ($p < 10) {
|
|
$nom = $petit[$p] . 'illi' . $nom;
|
|
} else {
|
|
$nom = $unite[$p % 10] . $dizaine[floor($p/10) % 10]
|
|
. $centaine[floor($p/100)] . 'illi' . $nom;
|
|
}
|
|
}
|
|
return preg_replace($recherche, $remplace, $nom);
|
|
}
|
|
|
|
function enlettres_illions($idx)
|
|
{
|
|
global $NEL;
|
|
|
|
if ($idx == 0) {
|
|
return '';
|
|
}
|
|
|
|
if ($NEL['zillions']) {
|
|
return enlettres_zilli($idx) . 'ons';
|
|
}
|
|
|
|
$suffixe = '';
|
|
while ($idx > $NEL['maxilli']) {
|
|
$idx -= $NEL['maxilli'];
|
|
$suffixe .= $NEL['de_maxillions'];
|
|
}
|
|
return "{$NEL['illi'][$idx]}illions{$suffixe}";
|
|
}
|
|
|
|
function enlettres_avec_illiards($idx)
|
|
{
|
|
global $NEL;
|
|
|
|
if ($idx == 0) return false;
|
|
switch ($NEL['zilliard']) {
|
|
case 0: return false;
|
|
case 2: return true;
|
|
}
|
|
return ($idx == 1);
|
|
}
|
|
|
|
function enlettres($nombre, $options=NULL, $separateur=NULL)
|
|
{
|
|
global $NEL;
|
|
|
|
if ($options !== NULL or $separateur !== NULL) {
|
|
$NELsave = $NEL;
|
|
enlettres_options($options, $separateur);
|
|
$nom = enlettres($nombre);
|
|
$NEL = $NELsave;
|
|
return $nom;
|
|
}
|
|
|
|
# On ne garde que les chiffres, puis on supprime les 0 du début
|
|
$nombre = preg_replace('/[^0-9]/', '', $nombre);
|
|
$nombre = ltrim($nombre, '0');
|
|
|
|
if ($nombre == '') {
|
|
if ($NEL['ordinal'] === 'nieme') return 'zéroïème';
|
|
else return 'zéro';
|
|
}
|
|
|
|
$table_noms = array();
|
|
for ($idx = 0; $nombre != ''; $idx++) {
|
|
$par6 = (int)((strlen($nombre) < 6) ? $nombre : substr($nombre, -6));
|
|
$nombre = substr($nombre, 0, -6);
|
|
|
|
if ($par6 == 0) continue;
|
|
|
|
$nom_par3_sup = enlettres_par3(floor($par6 / 1000));
|
|
$nom_par3_inf = enlettres_par3($par6 % 1000);
|
|
|
|
$illions = enlettres_illions($idx);
|
|
if (enlettres_avec_illiards($idx)) {
|
|
if ($nom_par3_inf != '') {
|
|
$table_noms[$illions] = $nom_par3_inf;
|
|
}
|
|
if ($nom_par3_sup != '') {
|
|
$illiards = preg_replace('/illion/', 'illiard', $illions, 1);
|
|
$table_noms[$illiards] = $nom_par3_sup;
|
|
}
|
|
} else {
|
|
switch($nom_par3_sup) {
|
|
case '':
|
|
$nom_par6 = $nom_par3_inf;
|
|
break;
|
|
case 'un':
|
|
$nom_par6 = rtrim("mille {$nom_par3_inf}");
|
|
break;
|
|
default:
|
|
$nom_par3_sup = preg_replace('/(vingt|cent)s/', '\\1', $nom_par3_sup);
|
|
$nom_par6 = rtrim("{$nom_par3_sup} mille {$nom_par3_inf}");
|
|
break;
|
|
}
|
|
$table_noms[$illions] = $nom_par6;
|
|
}
|
|
}
|
|
|
|
$nom_enlettres = '';
|
|
foreach ($table_noms as $nom => $nombre) {
|
|
##
|
|
# $nombre est compris entre 'un' et
|
|
# 'neuf cent nonante-neuf mille neuf cent nonante-neuf'
|
|
# (ou variante avec 'quatre-vingt-dix-neuf')
|
|
##
|
|
# $nom peut valoir '', 'millions', 'milliards', 'billions', ...
|
|
# 'sextillions', 'sextilliards', 'millions de sextillions',
|
|
# 'millions de sextilliards', etc.
|
|
##
|
|
|
|
# Rectifications orthographiques de 1990
|
|
if ($NEL['rectif']) {
|
|
$nombre = str_replace(' ', '-', $nombre);
|
|
}
|
|
|
|
# Nom (éventuel) et accord (éventuel) des substantifs
|
|
$nom = rtrim("{$nombre} {$nom}");
|
|
if ($nombre == 'un') {
|
|
# Un seul million, milliard, etc., donc au singulier
|
|
# noter la limite de 1 remplacement, pour ne supprimer que le premier 's'
|
|
# dans 'billions de sextillions de sextillions'
|
|
$nom = preg_replace('/(illion|illiard)s/', '\\1', $nom, 1);
|
|
}
|
|
|
|
# Ajout d'un séparateur entre chaque partie
|
|
if ($nom_enlettres == '') {
|
|
$nom_enlettres = $nom;
|
|
} else {
|
|
$nom_enlettres = $nom . $NEL['separateur'] . $nom_enlettres;
|
|
}
|
|
}
|
|
|
|
if ($NEL['ordinal'] === false) {
|
|
# Nombre cardinal : le traitement est fini
|
|
return $nom_enlettres;
|
|
}
|
|
|
|
# Aucun pluriel dans les ordinaux
|
|
$nom_enlettres =
|
|
preg_replace('/(cent|vingt|illion|illiard)s/', '\\1', $nom_enlettres);
|
|
|
|
if ($NEL['ordinal'] !== 'nieme') {
|
|
# Nombre ordinal simple (sans '-ième')
|
|
return $nom_enlettres;
|
|
}
|
|
|
|
if ($nom_enlettres === 'un') {
|
|
# Le féminin n'est pas traité ici. On fait la supposition
|
|
# qu'il est plus facile de traiter ce cas à part plutôt
|
|
# que de rajouter une option rien que pour ça.
|
|
return 'premier';
|
|
}
|
|
|
|
switch (substr($nom_enlettres, -1)) {
|
|
case 'e':
|
|
# quatre, onze à seize, trente à nonante, mille
|
|
# exemple : quatre -> quatrième
|
|
return substr($nom_enlettres, 0, -1) . 'ième';
|
|
case 'f':
|
|
# neuf -> neuvième
|
|
return substr($nom_enlettres, 0, -1) . 'vième';
|
|
case 'q':
|
|
# cinq -> cinquième
|
|
return $nom_enlettres . 'uième';
|
|
}
|
|
|
|
# Tous les autres cas.
|
|
# Exemples: deuxième, troisième, vingtième, trente et unième,
|
|
# neuf centième, un millionième, quatre-vingt milliardième.
|
|
return $nom_enlettres . 'ième';
|
|
}
|
|
|
|
function enchiffres_petit($mot)
|
|
{
|
|
static $petit = array(
|
|
# 1-16
|
|
'un' => 1,
|
|
'deux' => 2,
|
|
'trois' => 3,
|
|
'quatre' => 4,
|
|
'cinq' => 5,
|
|
'six' => 6,
|
|
'sept' => 7,
|
|
'huit' => 8,
|
|
'neuf' => 9,
|
|
'dix' => 10,
|
|
'onze' => 11,
|
|
'douze' => 12,
|
|
'treize' => 13,
|
|
'quatorze' => 14,
|
|
'quinze' => 15,
|
|
'seize' => 16,
|
|
# 20-90
|
|
'vingt' => 20,
|
|
'vingts' => 20,
|
|
'trente' => 30,
|
|
'quarante' => 40,
|
|
'cinquante' => 50,
|
|
'soixante' => 60,
|
|
'septante' => 70,
|
|
'huitante' => 80,
|
|
'octante' => 80,
|
|
'nonante' => 90,
|
|
# 100, 1000
|
|
'cent' => 100,
|
|
'cents' => 100,
|
|
'mil' => 1000,
|
|
'mille' => 1000
|
|
);
|
|
|
|
if (! isset($petit[$mot]))
|
|
return false;
|
|
|
|
return $petit[$mot];
|
|
}
|
|
|
|
function enchiffres_zilli($mot)
|
|
{
|
|
# Noms des 0ème à 9ème zillions
|
|
static $petits = array(
|
|
'n', 'm', 'b', 'tr', 'quadr', 'quint', 'sext', 'sept', 'oct', 'non'
|
|
);
|
|
# Composantes des 10ème à 999ème zillions
|
|
static $unites = array(
|
|
'', 'un', 'duo', 'tre', 'quattuor', 'quin', 'se', 'septe', 'octo', 'nove'
|
|
);
|
|
static $dizaines = array(
|
|
'', 'dec', 'vigint', 'trigint', 'quadragint',
|
|
'quinquagint', 'sexagint', 'septuagint', 'octogint', 'nonagint'
|
|
);
|
|
static $centaines = array(
|
|
'', 'cent', 'ducent', 'trecent', 'quadringent',
|
|
'quingent', 'sescent', 'septingent', 'octingent', 'nongent'
|
|
);
|
|
# Expressions rationnelles pour extraire les composantes
|
|
static $um =
|
|
'(|un|duo|tre(?!c)|quattuor|quin|se(?!p)(?!sc)|septe|octo|nove)[mnsx]?';
|
|
static $dm =
|
|
'(|dec|(?:v|tr|quadr|quinqu|sex|septu|oct|non)[aio]gint)[ai]?';
|
|
static $cm =
|
|
'(|(?:|du|tre|ses)cent|(?:quadri|qui|septi|octi|no)ngent)';
|
|
|
|
$u = array_search($mot, $petits);
|
|
if ($u !== false) {
|
|
return '00' . $u;
|
|
}
|
|
|
|
if (preg_match('/^'.$um.$dm.$cm.'$/', $mot, $resultat) < 1) {
|
|
return false;
|
|
}
|
|
$u = array_search($resultat[1], $unites);
|
|
$d = array_search($resultat[2], $dizaines);
|
|
$c = array_search($resultat[3], $centaines);
|
|
if ($u === false or $d === false or $c === false) {
|
|
return false;
|
|
}
|
|
|
|
return $c.$d.$u;
|
|
}
|
|
|
|
function enchiffres_grand($mot)
|
|
{
|
|
# Quelques remplacements initiaux pour simplifier (les 'é' ont déjà
|
|
# été tous transformés en 'e').
|
|
# (1) Je supprime le 's' final de '-illions' ou '-illiards' pour ne
|
|
# tester que '-illion' ou '-illiard'.
|
|
# (2) Les deux orthographes étant possibles pour quadrillion ou
|
|
# quatrillion, je teste les deux. Noter que j'aurais pu changer
|
|
# 'quadr' en 'quatr' au lieu de l'inverse, mais alors cela aurait
|
|
# aussi changé 'quadragintillion' en 'quatragintillion', ce qui
|
|
# n'est pas franchement le but recherché.
|
|
# (3) En latin, on trouve parfois 'quatuor' au lieu de 'quattuor'. De même,
|
|
# avec google on trouve quelques 'quatuordecillions' au milieu des
|
|
# 'quattuordecillions' (environ 1 sur 10).
|
|
# (4) La règle de John Conway et Allan Wechsler préconisait le préfixe
|
|
# 'quinqua' au lieu de 'quin' que j'ai choisi. Pour accepter les deux,
|
|
# je remplace 'quinqua' par 'quin', sauf dans 'quinquaginta' (50)
|
|
# et dans 'quinquadraginta' (45).
|
|
static $recherche = array(
|
|
'/s$/', # (1)
|
|
'/quatr/', # (2)
|
|
'/quatuor/', # (3)
|
|
'/quinqua(?!(dra)?gint)/' # (4)
|
|
);
|
|
static $remplace = array(
|
|
'', # (1)
|
|
'quadr', # (2)
|
|
'quattuor', # (3)
|
|
'quin' # (4)
|
|
);
|
|
|
|
$mot = preg_replace($recherche, $remplace, $mot);
|
|
if ($mot == 'millier') return 1;
|
|
if ($mot == 'millinillion') return 2000;
|
|
|
|
$prefixes = explode('illi', $mot);
|
|
if (count($prefixes) < 2) {
|
|
# Il faut au moins un 'illi' dans le nom
|
|
return false;
|
|
}
|
|
switch (array_pop($prefixes)) {
|
|
case 'on':
|
|
# zillion : nombre pair de milliers
|
|
$ard = 0;
|
|
break;
|
|
case 'ard':
|
|
# zilliard : nombre impair de milliers
|
|
$ard = 1;
|
|
break;
|
|
default:
|
|
# Ce n'est ni un zillion, ni un zilliard
|
|
return false;
|
|
}
|
|
|
|
$nombre = '';
|
|
foreach ($prefixes as $prefixe) {
|
|
$par3 = enchiffres_zilli($prefixe);
|
|
if ($par3 === false) return false;
|
|
$nombre .= $par3;
|
|
}
|
|
if (strlen($nombre) > 3) {
|
|
# On n'accepte que les nombres inférieurs au millinillion
|
|
# pour limiter le temps de calcul
|
|
return 0;
|
|
}
|
|
return 2*$nombre + $ard;
|
|
}
|
|
|
|
class enchiffres_struct
|
|
{
|
|
var $valeur;
|
|
var $discr;
|
|
|
|
function enchiffres_struct($mul, $val)
|
|
{
|
|
$this->valeur = $this->discr = $val;
|
|
if ($mul != 0) {
|
|
$this->valeur *= $mul;
|
|
}
|
|
}
|
|
}
|
|
|
|
function enchiffres_ajouter_petit(&$table_petits, $petit)
|
|
{
|
|
$somme = 0;
|
|
while (($elem = array_pop($table_petits)) !== NULL) {
|
|
if ($elem->discr > $petit) {
|
|
array_push($table_petits, $elem);
|
|
break;
|
|
}
|
|
$somme += $elem->valeur;
|
|
}
|
|
$elem = new enchiffres_struct($somme, $petit);
|
|
array_push($table_petits, $elem);
|
|
}
|
|
|
|
function enchiffres_somme_petits($table_petits)
|
|
{
|
|
$somme = 0;
|
|
foreach ($table_petits as $elem) {
|
|
$somme += $elem->valeur;
|
|
}
|
|
return $somme;
|
|
}
|
|
|
|
function enchiffres_ajouter_grand(&$table_grands, $mantisse, $exposant)
|
|
{
|
|
while ($mantisse > 0) {
|
|
if (isset($table_grands[$exposant])) {
|
|
$mantisse += $table_grands[$exposant];
|
|
}
|
|
$table_grands[$exposant] = $mantisse % 1000;
|
|
$mantisse = floor($mantisse / 1000);
|
|
$exposant++;
|
|
}
|
|
}
|
|
|
|
function enchiffres($nom)
|
|
{
|
|
$nom = preg_replace('/[éèÉÈ]/', 'e', $nom);
|
|
$nom = strtolower($nom);
|
|
$table_mots = preg_split('/[^a-z]+/', $nom);
|
|
|
|
$table_petits = array();
|
|
$mantisse = $exposant = 0;
|
|
$table_grands = array();
|
|
|
|
foreach ($table_mots as $mot) {
|
|
$petit = enchiffres_petit($mot);
|
|
if ($petit !== false) {
|
|
if ($mantisse != 0) {
|
|
enchiffres_ajouter_grand($table_grands, $mantisse, $exposant);
|
|
$mantisse = $exposant = 0;
|
|
}
|
|
enchiffres_ajouter_petit($table_petits, $petit);
|
|
continue;
|
|
}
|
|
|
|
$grand = enchiffres_grand($mot);
|
|
if ($grand === false) {
|
|
# Ce n'est pas un nombre
|
|
continue;
|
|
}
|
|
|
|
if ($grand == 0) {
|
|
# Ce nombre était trop grand (millinillion et plus) : on annule le
|
|
# tout pour limiter le temps de calcul.
|
|
$mantisse = 0;
|
|
$exposant = 0;
|
|
$table_petits = array();
|
|
} else {
|
|
if (count($table_petits) > 0) {
|
|
$mantisse = enchiffres_somme_petits($table_petits);
|
|
$exposant = 0;
|
|
$table_petits = array();
|
|
}
|
|
if ($mantisse != 0) {
|
|
$exposant += $grand;
|
|
}
|
|
}
|
|
}
|
|
if (count($table_petits) > 0) {
|
|
$mantisse = enchiffres_somme_petits($table_petits);
|
|
$exposant = 0;
|
|
}
|
|
if ($mantisse != 0) {
|
|
enchiffres_ajouter_grand($table_grands, $mantisse, $exposant);
|
|
}
|
|
|
|
$nombre = "";
|
|
for ($exposant = 0; count($table_grands) > 0; $exposant++) {
|
|
if (isset($table_grands[$exposant])) {
|
|
$par3 = $table_grands[$exposant];
|
|
unset($table_grands[$exposant]);
|
|
} else {
|
|
$par3 = 0;
|
|
}
|
|
$nombre = sprintf("%03d", $par3) . $nombre;
|
|
}
|
|
$nombre = ltrim($nombre, '0');
|
|
if ($nombre === '') $nombre = '0';
|
|
return $nombre;
|
|
}
|
|
|
|
function enchiffres_aerer($nombre, $blanc=' ', $virgule=',', $tranche=3)
|
|
{
|
|
# Si c'est un nombre à virgule, on traite séparément les deux parties
|
|
if ($virgule !== NULL) {
|
|
$ent_dec = preg_split("/$virgule/", $nombre);
|
|
if (count($ent_dec) >= 2) {
|
|
$ent = enchiffres_aerer($ent_dec[0], $blanc, NULL, $tranche);
|
|
$dec = enchiffres_aerer($ent_dec[1], $blanc, NULL, -$tranche);
|
|
return $ent . $virgule . $dec;
|
|
}
|
|
}
|
|
|
|
# On ne garde que les chiffres
|
|
$nombre = preg_replace('/[^0-9]/', '', $nombre);
|
|
|
|
# Il est plus logique d'avoir un nombre positif pour les entiers,
|
|
# donc négatif pour la partie décimale, mais plus pratique de
|
|
# faire le contraire pour les substr().
|
|
$tranche = - (int)$tranche;
|
|
|
|
if ($tranche == 0) {
|
|
# on voulait juste supprimer les caractères en trop, pas en rajouter
|
|
return $nombre;
|
|
}
|
|
|
|
$nombre_aere = '';
|
|
if ($tranche < 0) {
|
|
# entier, ou partie entière d'un nombre décimal
|
|
while ($nombre != '') {
|
|
$par3 = substr($nombre, $tranche);
|
|
$nombre = substr($nombre, 0, $tranche);
|
|
if ($nombre_aere == '') {
|
|
$nombre_aere = $par3;
|
|
} else {
|
|
$nombre_aere = $par3 . $blanc . $nombre_aere;
|
|
}
|
|
}
|
|
} else {
|
|
# partie décimale
|
|
while ($nombre != '') {
|
|
$par3 = substr($nombre, 0, $tranche);
|
|
$nombre = substr($nombre, $tranche);
|
|
if ($nombre_aere == '') {
|
|
$nombre_aere = $par3;
|
|
} else {
|
|
$nombre_aere .= $blanc . $par3;
|
|
}
|
|
}
|
|
}
|
|
return $nombre_aere;
|
|
}
|
|
|
|
*/
|
|
?>
|