Fehlerabschätzung / signifikante Stellen

22/02/2010 - 16:13 von Markus Wichmann | Report spam
Hi all,

allgemeine Frage: Wie schàtzt man bei einer Floating Point-Operation den
potentiellen Fehler ab? Mantissenbreite und Exponentengröße sind
gegeben. Und in diesem Fall darf die Mantisse auch eine Zahl zwischen 0
und 2 sein.

spezielle Frage: Gegeben sei eine IEEE-754-80-bit Floating-Point-Zahl
mit 64 Bit Mantisse und 15 Bit Exponent. Ich habe ein Programm
geschrieben, dass jeder beliebigen Zahl den Anfang ihres Kettenbruches
zuordnet. Wie viele Stellen sollte dieser Kettenbruch haben? Kann man
mit Tricks die Pràzision erhöhen?

Hier der Quelltext:

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <ctype.h>
#include <math.h>

#define EPSILON 1e-13

size_t kettenbruch(long* ar, size_t s, long double x)
{
long double r;
for (size_t i = 0; i < s; i++)
{
ar[i] = x;
if (fabsl(ar[i] + 1 - x) < EPSILON) ar[i]++;
r = x - ar[i];
if (fabsl(r) < EPSILON)
return i;
x = 1/r;
}
return s;
}

#define LENGTH 16
int main(int argc, char** argv)
{
long double x = 43.L/30.L;
static long c[LENGTH];
size_t rv;
bool overlength;
long zaehler = 1, nenner = 0;
if (argc >= 2)
{
char* endptr;
x = strtold(argv[1], &endptr);
if (endptr == argv[1])
{
x = 43.L/30.L;
fputs("first argument should be a double number", stderr);
}
}
rv = kettenbruch(c, LENGTH, x);
putchar('[');
overlength = (rv == LENGTH);
if (overlength) rv--;
for (int i = 0; i <= rv; i++)
{
if (i > 0)
putchar(',');

printf("%ld", c[i]);
}
if (overlength)
{
fputs(",...", stdout);
}

puts("]");

fputs("Nàchster Bruch: ", stdout);

for (int i = rv; i >= 0; i--)
{
long tmp;
tmp = zaehler;
zaehler = nenner;
nenner = tmp;
zaehler += c[i] * nenner;
}

printf("%ld/%ld", zaehler, nenner);
return 0;
}

Tschö,
Markus
Progress (n.): Process through which USENET evolved from smart people in
front of dumb terminals to dumb people in front of smart
terminals.

news://freenews.netfront.net/ - complaints: news@netfront.net
 

Lesen sie die antworten

#1 Christopher Creutzig
22/02/2010 - 21:59 | Warnen spam
On 2/22/10 4:13 PM, Markus Wichmann wrote:

allgemeine Frage: Wie schàtzt man bei einer Floating Point-Operation den
potentiellen Fehler ab? Mantissenbreite und Exponentengröße sind
gegeben. Und in diesem Fall darf die Mantisse auch eine Zahl zwischen 0
und 2 sein.



Das hàngt von der Operation ab, davon, was man über die Eingabedaten
weiß und davon, welche Sorte von Fehlerabschàtzung (relativ oder
absolut) man sucht. Außerdem gibt es mehrere Sorten von Fehlern:
Rundungsfehler, systematische Fehler und Fehlerfortpflanzung, die bspw.
Rundungsfehler der Eingabe der einzelnen Operation massiv verstàrken können.

spezielle Frage: Gegeben sei eine IEEE-754-80-bit Floating-Point-Zahl
mit 64 Bit Mantisse und 15 Bit Exponent. Ich habe ein Programm
geschrieben, dass jeder beliebigen Zahl den Anfang ihres Kettenbruches
zuordnet. Wie viele Stellen sollte dieser Kettenbruch haben? Kann man



Leider hàngt das davon ab, was für eine Zahl hereinkommt.
Beispielsweise kannst Du trivialerweise für eine Zahl wie sqrt(5) einen
wesentlich làngeren signifikanten Kettenbruch angeben als für
10^123+sqrt(5/6).

Du könntest wàhrend des Zusammenbauens des Kettenbruchs mit etwas wie
dem Algorithmus von Wallis den rationalen Wert des bislang gebildeten
Kettenbruchs als Paar von Integers mitschleifen (wofür man vier
Integer-Variablen braucht). Ein Vergleich mit dem Eingabewert liefert
Dir vermutlich ein ziemlich brauchbares Abbruchkriterium.

Du musst in einer Sekte sein.


Nö. Ich bin bloss bizarr.
[Ulrich Diez antwortet einem Anonymling]

Ähnliche fragen