Un formulaire de facture calcule une majoration avec Round(Subtotal * 0.025, 2), et un service Delphi qui revérifie les totaux est en désaccord avec le PDF aplati sur les lignes à un demi-centime. FormCalc arrondit les moitiés au loin de zéro et renvoie un Double, tandis que System.Round arrondit au pair, si bien que le contrôle fiable consiste à laisser HotPDF aplatir le formulaire XFA et exécuter ses scripts FormCalc
Moitiés au loin de zéro, et le résultat reste un Double
Le System.Round de Delphi suit le mode d'arrondi de la FPU, et le mode par défaut arrondit les moitiés au pair : Round(2.5) donne 2, Round(3.5) donne 4 et Round(-2.5) donne -2. L'arrondi du banquier convient aux statistiques. Il colle mal à un formulaire qui a toujours affiché 3. Le Round de FormCalc emporte les moitiés au loin de zéro, si bien que 2.5 devient 3 et -2.5 devient -3. Le type de retour diffère aussi. System.Round renvoie un Int64, voilà pourquoi l'idiome bien connu Round(X * 100) / 100 déborde dès que X * 100 quitte l'intervalle Int64, alors que Round(X, 2) de FormCalc prend un Double et en rend un
Les grandes valeurs réclament une règle de plus. Un Double dispose de 52 bits explicites de fraction, si bien qu'une magnitude de 252 (4 503 599 627 370 496) ou plus n'a plus aucune partie fractionnaire à arrondir. HotPDF met la valeur absolue à l'échelle par 10places, et quand la valeur mise à l'échelle atteint 252 il rend l'entrée telle quelle — multiplier davantage ne ferait qu'inventer des chiffres ou déborder. Le stockage binaire fixe l'autre limite, et celle-là vaut pour tout évaluateur fondé sur le Double, FormCalc compris. Le littéral 2.675 est stocké comme 2.67499999999999982236431605997495353221893310546875. Arrondi à deux décimales, il donne 2.67. FormCalc n'a aucun type monétaire à précision décimale exacte, si bien qu'un formulaire et un port ne peuvent s'accorder que sur la valeur binaire que tous deux détiennent
uses
Math;
// Round façon FormCalc pour un port Delphi : moitiés au loin de zéro,
// nombre de décimales tronqué vers zéro et borné à 0..12, le résultat reste un Double
function FormCalcRound(Value: Double; Places: Double = 0): Double;
const
NoFractionBits = 4503599627370496.0; // 2^52
var
Digits: Integer;
Scale, Scaled, Whole: Double;
begin
if IsNan(Value) or IsNan(Places) then
Exit(NaN);
if IsInfinite(Value) or (Value = 0) then
Exit(Value);
Digits := Trunc(EnsureRange(Places, 0.0, 12.0));
Scale := IntPower(10, Digits);
if Abs(Value) >= NoFractionBits / Scale then
Exit(Value); // plus aucun chiffre fractionnaire à arrondir
Scaled := Abs(Value) * Scale;
Whole := Int(Scaled);
if Scaled - Whole >= 0.5 then
Whole := Whole + 1;
Result := Whole / Scale;
if Value < 0 then
Result := -Result;
end;
// FormCalcRound(2.5) = 3 System.Round(2.5) = 2
// FormCalcRound(-2.5) = -3 System.Round(-2.5) = -2
// FormCalcRound(1234.567, 2.7) = 1234.57 (2.7 décimales comptent pour 2)
// FormCalcRound(1234.5, -2) = 1235 (un compte négatif vaut 0 décimale)
// FormCalcRound(1E18, 2) = 1E18 (Round(1E18 * 100) déborde Int64)
Combien de décimales le Round de FormCalc accepte-t-il ?
Des décimales entières de 0 à 12. HotPDF tronque le second argument vers zéro puis le borne à cet intervalle, si bien que Round(X, 2.7) arrondit à deux décimales, Round(X, 15) à douze, et Round(X, -2) comme Round(X, -0.5) à un entier. La règle est la même partout où HotPDF évalue du FormCalc, si bien qu'un total calculé pendant l'aplatissement et un calculé pendant le remplissage du formulaire sortent identiques. Les habitudes tableur tirent dans l'autre sens. Le ROUND(1234.5, -2) d'Excel donne 1200 parce qu'Excel lit un compte négatif comme des chiffres à gauche de la virgule ; FormCalc donne 1235. Les utilitaires de Delphi renversent encore une fois la convention : Math.RoundTo et SimpleRoundTo prennent une puissance de dix, si bien que RoundTo(X, -2) signifie deux décimales et que RoundTo(1234.567, 2) donne 1200. Un port qui recopie tel quel le second argument du script dans RoundTo imprime des centaines là où le formulaire affiche des centimes. Conservez le compte de décimales tel que FormCalc le définit et routez-le vers un utilitaire comme FormCalcRound, qui garde aussi la règle des égalités dans le bon
Pourquoi a - b * Int(a / b) renvoie-t-il le mauvais reste ?
Parce que le quotient cesse d'être exact bien avant le dividende. Prenons Mod(1E20, 7). Le dividende est représentable sans erreur — 1020 vaut 220 × 520, et 520 tient en 53 bits — et le vrai reste est 2. Le quotient, environ 1.43 × 1019, ne l'est pas : les Doubles de cette plage sont espacés de 2 048, si bien que Int(a / b) est faux avant même que la multiplication ne commence, et a - b * q renvoie ce que les erreurs d'arrondi laissent derrière eux. L'opérateur mod de Delphi ne travaille que sur des entiers, et Trunc ne peut pas porter un quotient au-delà de l'intervalle Int64. Vérifiez System.Math.FMod avant de vous appuyer sur lui ici. Une implémentation qui dérive le reste du quotient hérite de la même erreur, et comparer FMod(1E20, 7) au 2 attendu tranche la question en une ligne
La division longue binaire ne forme jamais le quotient. Doublez le diviseur jusqu'à dépasser la moitié du dividende, puis redescendez, en retranchant le diviseur mis à l'échelle partout où il tient. Chaque diviseur mis à l'échelle est l'original fois une puissance de deux, donc il ne transporte aucune erreur d'arrondi. Chaque soustraction retire un nombre entre la moitié et la totalité du reste courant — le cas où, par le lemme de Sterbenz, la soustraction IEEE 754 n'implique aucun arrondi. Le résultat est exact. La règle de signe de FormCalc s'applique alors : le reste prend le signe du dividende, si bien que Mod(-7, 3) donne -1 et Mod(7, -3) donne 1. Un dividende de magnitude inférieure au diviseur revient inchangé, et un diviseur nul ne produit aucun nombre du tout
// Reste flottant exact, signe du dividende, aucun quotient requis
function FormCalcMod(Dividend, Divisor: Double): Double;
var
Step, Half: Double;
begin
if IsNan(Dividend) or IsNan(Divisor) or IsInfinite(Dividend) or (Divisor = 0) then
Exit(NaN);
if IsInfinite(Divisor) or (Abs(Dividend) < Abs(Divisor)) then
Exit(Dividend);
Divisor := Abs(Divisor);
Result := Abs(Dividend);
Half := Result * 0.5;
Step := Divisor;
while Step <= Half do
Step := Step * 2; // plus grand multiple puissance de deux
while Step > Divisor do
begin
if Result >= Step then
Result := Result - Step; // exact : Step <= Result < 2 * Step
Step := Step * 0.5;
end;
if Result >= Divisor then
Result := Result - Divisor;
if Dividend < 0 then
Result := -Result;
end;
// FormCalcMod(1E20, 7) = 2 FormCalcMod(-7, 3) = -1
// FormCalcMod(7, -3) = 1 FormCalcMod(7.5, 2) = 1.5
// FormCalcMod(1, 0) = NaN
Choose tronque son index, HasValue ignore les blancs
Choose(n, item1, item2, …) convertit son premier argument en nombre et le tronque, si bien que Choose(2.7, "a", "b", "c") renvoie "b" sans lever d'erreur de type. Un index sous 1 ou au-delà du dernier élément renvoie une chaîne vide, et un index null renvoie null. HasValue est la forme fonctionnelle que les auteurs emploient pour tester les champs optionnels : elle répond 0 pour null et pour du texte fait uniquement d'espacements Unicode. Le nombre 0 compte toujours. Un champ quantité contenant 0 a été rempli ; une zone de commentaires contenant trois espaces ne l'a pas, même si les valeurs textuelles d'espacement XFA gardent ces espaces intacts à travers une sauvegarde. Les deux fonctions donnent ensemble le garde habituel des lignes optionnelles, if (HasValue(Qty)) then Round(Qty * Price, 2) else null endif, qui laisse vide une ligne non remplie et limite le total de colonne à ce qui a été saisi. Un port Delphi qui traite une quantité vide comme 0 imprime un total de ligne 0.00 là où le formulaire n'imprime rien
Que renvoie FormCalc pour un champ vide ?
Null — et null survit à la plupart des fonctions qu'un script de calcul appelle. En FormCalc, une chaîne vide est une vraie valeur et null est son absence, et les fonctions de chaîne maintiennent la distinction :
Len,Upper,Lower,Ltrim,Rtrim,TrimetSpacerenvoient null quand leur argument est nullLeft,Right,AtetReplacecontrôlent leurs deux premiers arguments,Stuffses trois premiers, etSubstrchaque argument fourni- Une chaîne vide passée à l'une d'elles est traitée comme du texte :
Upper("")donne "", pas null - Les scripts peuvent produire null explicitement avec le littéral
nullouNull()
Les chaînes Delphi n'ont pas de null, et c'est là que les ports écrits à la main dérivent le plus. Concat siège hors de la liste : il saute les arguments null, si bien que Concat(Prefix, Code) sur un préfixe non rempli produit le même texte qu'un port construit depuis ''. Len, non. Len(Prefix) est null et un champ numérique lié à lui reste blanc, tandis que Length('') y met 0. Les agrégats suivent la règle du saut : Sum, Avg, Count, Min et Max ignorent les entrées vides, si bien que Avg sur 10, une ligne vide et 20 donne 15 et Count donne 2. Un port qui lit la ligne vide comme 0 rapporte une moyenne de 10. Une colonne sans aucune saisie ne donne à Sum aucune valeur du tout, ce qui laisse le champ de total général vide
uses
Variants;
// Avg façon FormCalc : les entrées vides sont sautées, pas comptées comme zéro
function FormCalcAvg(const Values: array of Variant): Variant;
var
I, Count: Integer;
Total: Double;
begin
Result := Null;
Total := 0;
Count := 0;
for I := Low(Values) to High(Values) do
if not VarIsNull(Values[I]) then
begin
Total := Total + Values[I];
Inc(Count);
end;
if Count > 0 then
Result := Total / Count;
end;
// FormCalcAvg([10, Null, 20]) = 15 lire l'entrée vide comme 0 donne 10
// FormCalcAvg([Null, Null]) = Null le champ de moyenne reste blanc
Modélisez les champs en Variant dans le port et gardez Null à part de ''. Les valeurs tirées d'un dataset réclament le même soin : TField.Value renvoie Null pour une colonne NULL, tandis que TField.AsString la transforme en chaîne vide et efface la différence avant même que le port ne la voie
Laissez le formulaire exécuter ses propres scripts
Le port le plus sûr est souvent aucun port du tout. THotPDF.FlattenLoadedXFA évalue le script de calcul de chaque champ pendant qu'il dispose le formulaire et reconstruit les champs en champs AcroForm, en appliquant les règles d'arrondi, de reste et de null ci-dessus. Le même appel traite le reste de l'aplatissement XFA vers AcroForm, de la mise en page au mappage des widgets. Une formule qui ne peut pas être évaluée — une référence non résolue, une division par zéro, une erreur d'analyse — échoue en bloc. Rien de partiellement calculé n'atteint le champ. Recharger le fichier aplati et comparer ses valeurs de champs à la sortie du port transforme un désaccord vague en liste de noms de champs :
uses
SysUtils, Classes, HPDFDoc;
function SameFieldValue(const FormText, PortText: string): Boolean;
var
FS: TFormatSettings;
A, B: Double;
begin
FS := TFormatSettings.Create;
FS.DecimalSeparator := '.';
if TryStrToFloat(FormText, A, FS) and TryStrToFloat(PortText, B, FS) then
Result := A = B
else
Result := FormText = PortText; // '' contre '0.00' est un vrai désaccord
end;
procedure CheckPortAgainstForm(const XfaFile, FlatFile: string; Port: TStrings);
var
Pdf: THotPDF;
Pairs: TStringList;
I: Integer;
FieldName: string;
begin
Pdf := THotPDF.Create(nil);
try
if Pdf.LoadFromFile(XfaFile) <= 0 then
raise Exception.Create('Cannot open the XFA form');
Pdf.FlattenLoadedXFA(False); // False = les champs deviennent en lecture seule
for I := 0 to Pdf.XFAFlattenWarnings.Count - 1 do
Writeln('XFA: ', Pdf.XFAFlattenWarnings[I]);
Pdf.SaveLoadedDocument(FlatFile);
finally
Pdf.Free;
end;
Pdf := THotPDF.Create(nil);
Pairs := TStringList.Create;
try
if Pdf.LoadFromFile(FlatFile) <= 0 then
raise Exception.Create('Cannot open the flattened PDF');
Pdf.GetLoadedFormFieldNameValuePairs(Pairs);
for I := 0 to Pairs.Count - 1 do
begin
FieldName := Pairs.Names[I];
if (Port.IndexOfName(FieldName) >= 0) and
not SameFieldValue(Pairs.ValueFromIndex[I], Port.Values[FieldName]) then
Writeln(Format('%s: form "%s", port "%s"',
[FieldName, Pairs.ValueFromIndex[I], Port.Values[FieldName]]));
end;
finally
Pairs.Free;
Pdf.Free;
end;
end;
Lisez les avertissements avant de faire confiance à un total ; la liste nomme chaque élément que la conversion n'a pas su mapper, donc cherchez les entrées qui nomment un champ calculé. Puis donnez au port un échantillon construit pour les règles ci-dessus : des montants de ligne qui tombent sur .5 à la deuxième décimale, un numéro de compte à 20 chiffres passé au Mod, un Round avec un compte de décimales fractionnaire, et une ligne optionnelle laissée vide. Chaque ligne que la procédure imprime est une règle sur laquelle le port se trompe. Les formulaires qui calculent avec les scripts de format et de calcul AcroForm suivent les règles numériques JavaScript — Math.round(-2.5) donne -2 là-bas, une troisième réponse à la même question
Si le chiffre que votre service réclame en est un que le formulaire imprime déjà, prenez-le au formulaire : aplatissez-le avec le composant PDF HotPDF pour Delphi, rechargez le résultat et lisez le champ. Les fonctions utilitaires ci-dessus ne valent leur salaire que pour les nombres que le formulaire ne calcule jamais