Teknik Makale

FormCalc Round, Mod ve Null, Delphi Round ve mod Değildir

Bir fatura formu ek ücreti Round(Subtotal * 0.025, 2) ile hesaplar ve toplamlarını yeniden kontrol eden bir Delphi servisi, yarım kuruşluk satırlarda düzleştirilmiş PDF ile anlaşamaz. FormCalc yarıları sıfırdan uzağa yuvarlar ve bir Double döndürür; System.Round ise çifte yuvarlar. Güvenilir kontrol, HotPDF'in XFA formu düzleştirmesine ve FormCalc scriptlerini çalıştırmasına izin vermektir

Sıfırdan uzağa yarım, ve sonuç Double olarak kalır

Delphi'nin System.Round'u FPU yuvarlama modunu izler ve varsayılan mod yarıları çifteye yuvarlar: Round(2.5) 2'dir, Round(3.5) 4'tür ve Round(-2.5) -2'dir. Banker's rounding istatistiğe uyar. Hep 3 göstermiş bir form için ise kötü bir eşleşmedir. FormCalc'ın Round'u yarıları sıfırdan uzağa alır; 2.5, 3 olur ve -2.5, -3 olur. Dönüş tipi de farklıdır. System.Round bir Int64 döndürür; tanıdık Round(X * 100) / 100 deyimi bu yüzden X * 100, Int64 aralığını terk ettiğinde taşar; oysa FormCalc'ın Round(X, 2)'si bir Double alır ve bir Double geri verir

HotPDF ile Delphi XFA formları için yuvarlama matrisi: FormCalc Round 2.5'i sıfırdan uzağa 3'e götürürken System.Round 2 verir
FormCalc yarım eşitlikleri sıfırdan uzağa alır ve bir Double döndürür; 2.5, System.Round 2 derken 3 olur

Büyük değerler bir kural daha ister. Bir Double'ın 52 açık kesir biti vardır; dolayısıyla 252 (4.503.599.627.370.496) ve üzeri büyüklükteki bir değerin yuvarlanacak kesirli kısmı kalmamıştır. HotPDF mutlak değeri 10places ile ölçekler ve ölçeklenen değer 252'ye ulaştığında girdiyi olduğu gibi geri verir — daha fazla çarpmak yalnızca rakam uydurur veya taşar. İkili depolama diğer sınırı koyar ve o sınır Double tabanlı her değerlendiriciyi bağlar, FormCalc dahil. 2.675 literali 2.67499999999999982236431605997495353221893310546875 olarak depolanır. İki basamağa yuvarlandığında 2.67 verir. FormCalc'ın ondalık-duyarlı bir para tipi yoktur; bir form ile bir port yalnızca ikisinin de tuttuğu ikili değer üzerinde anlaşabilir

uses
  Math;

// Bir Delphi portu için FormCalc tarzı Round: yarılar sıfırdan uzağa,
// basamak sayısı sıfıra doğru kesilir ve 0..12'de tutulur, sonuç Double kalır
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);                         // yuvarlanacak kesir basamağı kalmadı
  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 basamak 2 sayılır)
// FormCalcRound(1234.5, -2)     = 1235     (negatif sayı 0 basamak demektir)
// FormCalcRound(1E18, 2)        = 1E18     (Round(1E18 * 100) Int64 taşar)

FormCalc Round kaç ondalık basamak kabul eder?

0'dan 12'ye tam basamaklar. HotPDF ikinci argümanı sıfıra doğru keser ve sonra o aralığa sıkıştırır; böylece Round(X, 2.7) iki basamağa yuvarlar, Round(X, 15) on ikiye, hem Round(X, -2) hem Round(X, -0.5) ise tam sayıya. Kural, HotPDF'in FormCalc'ı değerlendirdiği her yerde aynıdır; dolayısıyla düzleştirme sırasında hesaplanan toplam ile form doldurulurken hesaplanan toplam özdeş çıkar. Tabloların (spreadsheet) alışkanlıkları tersi yönde çeker. Excel'in ROUND(1234.5, -2)'si 1200 verir, çünkü Excel negatif sayıyı ondalık noktanın solundaki basamaklar olarak okur; FormCalc 1235 verir. Delphi'nin yardımcıları kuralı bir kez daha çevirir: Math.RoundTo ve SimpleRoundTo on'un kuvvetini alır; dolayısıyla RoundTo(X, -2) iki ondalık demektir ve RoundTo(1234.567, 2) 1200'dür. Script'in ikinci argümanını doğrudan RoundTo'ya kopyalayan bir port, formun kuruş gösterdiği yerde yüzü basar. Basamak sayısını FormCalc'ın tanımladığı biçimde tutun ve FormCalcRound gibi tie kuralını da doğru tutan bir yardımcıdan geçirin

a - b * Int(a / b) neden yanlış kalanı döndürür?

Çünkü bölüm (quotient), bölünenden çok önce kesin olmaktan çıkar. Mod(1E20, 7)'yi alın. Bölünen hatasız temsil edilebilir — 1020, 220 × 520'dir ve 520 53 bite sığar — ve gerçek kalan 2'dir. Bölüm ise, yaklaşık 1.43 × 1019, değildir: o aralıktaki Double'lar 2.048 arayla oturur, dolayısıyla çarpma daha başlamadan Int(a / b) yanlıştır ve a - b * q, yuvarlama hatalarının geride bıraktığını döndürür. Delphi'nin mod operatörü yalnızca tamsayılarda çalışır ve Trunc, Int64 aralığının ötesindeki bir bölümü tutamaz. Burada dayanmadan önce System.Math.FMod'u kontrol edin. Kalanı bölümden türeyen bir uygulama aynı hatayı miras alır; FMod(1E20, 7)'yi beklenen 2 ile karşılaştırmak soruyu tek satırda çözümler

İkili uzun bölme bölümü hiç kurmaz. Böleni bölünenin yarısını geçene dek ikiye katlar, sonra aşağı geri iner ve ölçeklenen bölenin sığdığı her yerde çıkarır. Her ölçeklenen bölen orijinalin ikinin bir kuvvetiyle çarpımıdır, dolayısıyla yuvarlama hatası taşımaz. Her çıkarma, o anki kalanın yarısı ile tamamı arasinda bir sayı götürür — Sterbenz lemma'sının gereği, IEEE 754 çıkarmasında bu durumda yuvarlama yoktur. Sonuç kesindir. FormCalc'ın işaret kuralı sonra devreye girer: kalan, bölünenin işaretini alır; Mod(-7, 3) -1'dir ve Mod(7, -3) 1'dir. Bölünen, büyüklükçe böleninden küçükse olduğu gibi geri gelir ve sıfır bölen hiçbir sayı vermez

HotPDF ile Delphi'de FormCalc Mod: bölüm formülü 1E20'de başarısız olurken ikili uzun bölme böleni ikiye katlar ve kesin çıkarır
1.43E19 civarındaki bölüm zaten kaba bir Double ızgarasına oturur; ikili uzun bölme ise bölüm kurmadan kesin kalana ulaşır
// Kesin kayan nokta kalanı, bölünenin işareti, bölüme gerek yok
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;                   // en büyük ikinin kuvveti katı
  while Step > Divisor do
  begin
    if Result >= Step then
      Result := Result - Step;          // kesin: 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 indeksini keser, HasValue boşlukları yok sayar

Choose(n, item1, item2, …) ilk argümanını bir sayıya çevirir ve keser; dolayısıyla Choose(2.7, "a", "b", "c") "b" döndürür ve tip hatası kaldırmaz. 1'in altında ya da son ögenin ötesinde bir indeks boş dize döndürür ve null bir indeks null döndürür. HasValue, yazarların opsiyonel alanları test etmek için kullandığı fonksiyon hâlindedir: null için ve yalnızca Unicode boşluklarından oluşan metin için 0 cevap verir. 0 sayısı hâlâ sayılır. 0 tutan bir adet alanı doldurulmuştur; üç boşluk tutan bir yorum kutusu doldurulmamıştır, XFA boşluk metin değerleri o boşlukları bir kaydetmeden sağlam geçirse bile. İki fonksiyon birlikte opsiyonel satır kalemeleri için alışılmış korumayı verir: if (HasValue(Qty)) then Round(Qty * Price, 2) else null endif; bu, doldurulmamış satırı boş bırakır ve sütun toplamını girilenle sınırlar. Boş adedi 0 sayan bir Delphi portu, form hiçbir şey basmazken 0.00 satır toplamı basar

FormCalc boş bir alan için ne döndürür?

Null — ve null, bir calculate script'in çağırdığı fonksiyonların çoğunu hayatta geçer. FormCalc'ta boş dize gerçek bir değerdir ve null onun yokluğudur; dize fonksiyonları ikisini ayrı tutar:

  • Len, Upper, Lower, Ltrim, Rtrim, Trim ve Space, argümanları null olduğunda null döndürür
  • Left, Right, At ve Replace ilk iki argümanlarını kontrol eder, Stuff ilk üçünü, Substr ise verilen her argümanı
  • Hepsine geçilen boş dize metin olarak işlenir: Upper("") null değil ""dir
  • Scriptler null'u açıkça null literaliyle veya Null() ile üretebilir

Delphi dizelerinin null'u yoktur ve el yazımı portlar en çok orada sapar. Concat listenin dışındadır: null argümanları atlar; dolayısıyla doldurulmamış bir prefiks üzerinde Concat(Prefix, Code), bir portun '''den kurduğu metnin aynısını verir. Len vermez. Len(Prefix) nulldur ve ona bağlı sayısal alan boş kalır; Length('') ise oraya 0 koyar. Aggregate'ler atlama kuralını izler: Sum, Avg, Count, Min ve Max boş girdileri yok sayar; 10, boş bir satır ve 20 üzerinden Avg 15'tir ve Count 2'dir. Boş satırı 0 okuyan bir port ortalama 10 raporlar. Hiçbir şey girilmemiş bir sütun Sum'a hiç değer vermez, bu da genel toplam alanını boş tutar

HotPDF ile Delphi'de FormCalc için null yayılım haritası: dize fonksiyonları null döndürür, aggregate'ler boş girdileri atlar ve HasValue boşluk metnini doldurulmamış sayar
null, Len ve aggregate'ler üzerinden yürümeye devam ederken Concat ve Sum onu atlar; bir port alanları Variant olarak modellemelidir, null'u boş dizeye indirmemelidir
uses
  Variants;

// FormCalc tarzı Avg: boş girdiler atlanır, sıfır sayılmaz
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     boş girdiyi 0 okumak 10 verir
// FormCalcAvg([Null, Null])   = Null   ortalama alanı boş kalır

Portta alanları Variant olarak modelleyin ve Null'u '''den ayrı tutun. Bir dataset'ten çekilen değerler aynı özeni ister: TField.Value bir NULL sütun için Null döndürür; TField.AsString ise onu boş dizeye çevirir ve farkı, port onu hiç görmeden siler

Formun kendi scriptlerini çalıştırmasına izin verin

En güvenli port, çoğu zaman hiç portlamamaktır. THotPDF.FlattenLoadedXFA, formu dizerken her alanın calculate script'ini değerlendirir ve alanları AcroForm alanları olarak yeniden kurar; yukarıdaki yuvarlama, kalan ve null kurallarını uygular. Aynı çağrı, XFA'dan AcroForm'a düzleştirmenin kalanını da halleder, düzenden widget eşlemesine dek. Değerlendirilemeyen bir formül — çözülmemiş bir referans, sıfırla bölme, ayrıştırma hatası — bütün olarak başarısız olur. Yarım hesaplanmış hiçbir şey alana ulaşmaz. Düzleştirilmiş dosyayı yeniden yüklemek ve alan değerlerini portun çıktısıyla karşılaştırmak, belirsiz bir anlaşmazlığı alan adları listesine çevirir:

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;      // '' ile '0.00' gerçek bir uyuşmazlıktır
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 = alanlar salt okunur olur
    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;

Herhangi bir toplama güvenmeden önce uyarıları okuyun; liste, dönüştürmenin haritalayamadığı her ögeyi adlandırır, o yüzden hesaplanan bir alanı adlandıran girdileri arayın. Sonra porta yukarıdaki kurallar için kurulmuş bir örnek verin: ikinci ondalıkta .5'e düşen satır tutarları, Mod'dan geçirilen 20 haneli bir hesap numarası, kesirli basamak sayılı bir Round ve boş bırakılmış bir opsiyonel satır. Prosedürün bastığı her satır, portun yanlış aldığı bir kuraldır. AcroForm format ve calculate scriptleriyle hesap yapan formlar JavaScript sayı kurallarını izler — orada Math.round(-2.5) -2'dir, aynı sorunun üçüncü cevabı

Servisinizin gerektiği sayı formun zaten bastığı bir sayıysa, onu formdan alın: HotPDF Delphi PDF component ile düzleştirin, sonucu yeniden yükleyin ve alanı okuyun. Yukarıdaki yardımcı fonksiyonlar, yalnızca formun hiç hesaplamadığı sayılar için değerlerini kanıtlar