Formeln in DECMath für mehr genauigkeit

[nastytrouble]

Hi leute,

ich hab mal ne frage:
wie kann man solche formeln in decmath umformen???

Delphi-Quellcode:

swap1:=((bquad+cquad-aquad)/(2*bnormal1*cnormal1));
alpha1:=arccos(swap1)*180/Pi;
WinkelAlpha.Text:=FloatToStr(Alpha1);
Gamma1:= arcsin(aquad/bquad/sin(beta1))*180/pi;
WinkelGamma.text:=FloatToStr(Gamma1);
Beta1:=180-(Alpha1+Gamma1);
WinkelBeta.text:=FloatToStr(Beta1);

hier geht es um berechnungen im dreieck hab ich selbst geschrieben bloß leider sind die zahlen die dort rauskommen ziemlich ungenau also habe ich gedacht nutzt du DECMath soll ja rein theoretisch genauer sein(mehr nachkommastellen mit NRats). swap1 habe ich benutzt um da mehr ordnung rein zu bringen und ich rechne damit nachher noch weiter.

ich hoffe ihr könnt mir da helfen =)

gruß Nasty

[negaH]

Hm, das geht nicht auf anhieb.

In deiner Formel kommen Funktionen vor wie "Arccos", "Arcsin", "Sin" und "Pi". Für diese Funktionen gibts in den IRational's vom DECMath noch keine Funktionen, du müsstest diese also selber programmieren. Es gibt aber in der Unit NInt_1.pas schon einige dieser Funktionen die auf IInteger Basis arbeiten, die kann man als Ausgangsbasis für die IRational's umschreiben. Das ist auch ziemlich einfach, Beipsiel

procedure NSin(var R: IInteger; const U,V: IInteger); Schau dir mal den Source dazu an, du findest dann dort ein Code wie

Delphi-Quellcode:

    NBinarySplitting(P, Q, Round(L), @DoSIN);  // P / Q = Sin(U / V)
    NMul(R, P);
    NDiv(R, Q);

Die letzten beiden Operationen -> NMul(R, P) und NDiv(R, Q) stellen eine Umwandlung einer Rationalen/Gebrochenen Zahl in P/Q in eine Ganzzahl R dar. Dieser Schritt wäre in deinem Falle überflüßig da du ja mit IRational arbeiten möchtest. Stattdessen also

Delphi-Quellcode:

  NMul(R.N, P);
  NMul(R.D, Q);

Du multiplizierst also den Zähler und Nenner deines IRationals und bekommst so

Delphi-Quellcode:

procedure NSin(var R: IRational);
// R = sin(R)
var
  sU,sV: IInteger;

  procedure DoSIN(N: Integer; var D: TIIntegerSplitData); register;
  begin
    if N > 0 then
    begin
      D.P := sU;                         // -U^2
      NSet(D.Q, Int64(N * (N + N +1)));  // 2V^2 * (2n^2 +n)             n(2n +1)
      NMul(D.Q, sV);
    end else
    begin
      NSet(D.P, U);                    // (-1)^n * x^(2n + 1) / (2n + 1)!
      NSet(D.Q, V);
    end;
  end;

resourcestring
  sNSin = 'NSin(), requiere R.N <> 0 and R.D <> 0';
var
  P,Q: IInteger;
  C,D,L: Extended;
begin
  if (NSgn(R.N) = 0) or (NSgn(R.D) = 0) then NRaise(@sNSin);

  NSqr(sU, R.N);
  NSqr(sV, R.D);
  NMul(sV, 2);
  // compute series length
  D := NLn(R);
  C := NLn(sU) - NLn(sV);
  L := 1;
  while D > 0 do
  begin
    D := D + C - Ln(L * (L + L +1));
    L := L + 1;
  end;
  NNeg(sU);
  NBinarySplitting(P, Q, Round(L), @DoSIN);  // P / Q = Sin(R.N / R.D)
  NSet(R, P, Q);
end;

Vorsicht ich habe das jetzt nicht getestet, sollte aber so funktionieren.
Essentiell also die Funktionen aus NInt_1.pas so umschreiben das sie von zb.

I := I * Sin(U / V); der IInteger Version in

R := Sin(R.N / R.D); der IRational Funktion

umgebaut werden.

In NInt_1.pas sind enthalten

Delphi-Quellcode:

procedure NLn2(var R: IInteger);
procedure NLn10(var R: IInteger);
procedure NArcTan(var R: IInteger; const U,V: IInteger); overload;
procedure NArcTan(var R: IInteger; V: Integer); overload;
procedure NArcTanh(var R: IInteger; const V: IInteger);
procedure NSin(var R: IInteger; const U,V: IInteger);
procedure NSinh(var R: IInteger; const U,V: IInteger);
procedure NCos(var R: IInteger; const U,V: IInteger);
procedure NCosh(var R: IInteger; const U,V: IInteger);
procedure NTan(var R: IInteger; const U,V: IInteger);
procedure NTanh(var R: IInteger; const U,V: IInteger);
procedure NExp(var A: IInteger; U: Integer = 1; V: Integer = 1); overload;
procedure NExp(var A: IInteger; const U,V: IInteger); overload;
function  NPi(var A: IInteger; Decimals: Cardinal; Method: TIIntegerPIMethod = piFastChudnovsky): Cardinal;

Gruß Hagen

[nastytrouble]

sry aber ich glaube ich verstehe da nur bahnhof xD geht das sonst noch einfacher? zB mit NInts oder so? ich hätte mir das jetz einfacher vorgestellt...

[negaH]

Um zb. den Sinus in einem IInteger zu berechnen mit zb. 1024 Bit Genauigkeit kannst du so arbeiten

Delphi-Quellcode:

var
  I: IInteger;
begin
  NBit(I, 1024, True);  // I := 2^1024
  NSin(I, NInt(4), NInt(5));  // I := I * Sin(4 / 5);
end;

Dies berechnet also den Sinus aus der gebrochenen Zahl 4 / 5 und multipliziert das mit 2^1024, das steht dann in I.
Das ist im Grunde eine ganz normale Skalierung der Berechnungen. Statt also mit Nachkommastellen zu rechnen verschiebt man per Skalierung alle Berechnungen in den Ganzzahl Bereich.

Angenommen du möchtest 1/5 = 0.2 berechnen hast aber keine Fließkommazahlen oder die Genauigkeit reicht nicht aus. Dann kann man auch skalieren zb. mit 1000. Man rechnet also 4 * 1000 / 5 und bekommt 200 raus. Das finale Ergebnis wird dann einfach mit / 1000 runterskaliert -> 200 / 1000 = 0.2. Die IRational Datentypen gehen im Grunde exakt so vor, nur das sie eben intern den Nenner und Zähler abspeichern und erst in der Funktion NStr() diese Skalierungen durchführen, also bei der Ausgabe der Zahl.

Gruß Hagen

[nastytrouble]

das klingt schon einfacher =) ich werde mich heute abend mal daran versuchen^^ wirst du eigentlich irgentwann noch fließkommazahlen hinzufügen?

[negaH]

So wie es aussieht nicht ;( zZ. habe ich am DECMath seit 2-3 Jahren nicht mehr intensiv gearbeitet, es gibt andere Projekte auf die ich mich konzentriere
Eventuell könnte man die IRational noch erweitern, um obige transzendente Funktionen, sie sind ja im Grunde schon fast fertig. IRational würde dann sogar eine höhere Genauigkeit bieten als ein Fließkomma Datentyp bei vergleichbarer Performance, dh. IRational wären schneller bei gleicher Genauigkeit verglichen mit einem Fließkommadatentyp (vorrausgesetzt die Berechnungen sind alle im gleichen Zahlenbereich gewichtet)

Gruß Hagen

[nastytrouble]

das wäre cool wenn du das machen würdest =) ich habs noch nich ganz eingebaut, muss mir das glaube ich erstmal selbst verständlich machen