eigener Datentyp oder "wie rechnet man das"???

Hallo,

hier mal eine kleine Dummy Frage von mir.

Ich hab heut mal ein paar Algorithmen zusammengebastelt. Darunter Fakultät, Fibonacci usw.

Hier ärgert mich der max. Wertebereich der Zahlen. (Ich weiss double reicht für ALLE Fälle) aber mir gehts mehr um die Theorie. Wie kann man denn "unendlich" weit rechnen lassen. z.B. für PI. da läuft man doch sicher schnell aus dem wertebereich hinaus.
Wie müsste man sowas anfagen? Ich hab mir schon was ausgedacht, wollt aber mal wissen ob das der richtige Weg ist:

Man nehme einen char*, den kann man ja mit einer beliebig langen Zahl füllen. Sagen wir mal 1000 Stellen. Nun will ich ja damit rechnen.
Multiplikation mit 2^n wäre ja eine einfache Bitweise Verschiebung nach links. Division ist Verschiebung nach rechts.
Wie hier Aber Multiplikation mit 3? oder 5? oder 6?

Ein Addition könnt ich mir noch vorstellen (muss ja alles binär erfolgen, oder?) bei einer Stelle. Für mehrere müsste man sich auch schon wieder ne Funktion bauen, die Binär den Übertrag verrechnet?

Hat jemand mein Problem verstanden? Und eine Idee dafür?

Danke
MfG Torsten

Descartes

Hierfür gibt es Toolkits zur Bearbeitung numerischer Probleme:

GNU MP -- Arithmetic without limitations

http://www.swox.com/gmp/
GMP is a free library for arbitrary precision arithmetic, operating on signed integers, rational numbers, and floating point numbers. There is no limit to the precision except the ones implied by the available memory in the machine GMP runs on. GMP has a rich set of functions, and the functions have a regular interface.
    GMP is designed to be as fast as possible, both for small operands and for huge operands. The speed is achieved by using fullwords as the basic arithmetic type, by using fast algorithms, with carefully optimized assembly code for the most common inner loops for a lot of CPUs, and by a general emphasis on speed (instead of simplicity or elegance).
    GMP is believed to be faster than any other similar library. The advantage for GMP increases with the operand sizes for certain operations, since GMP in many cases has asymptotically faster algorithms.
    GMP is distributed under the GNU Lesser General Public License. For more information about the GNU project, please see the official GNU web site.

HFLOAT -- The HUGE-FLOAT package

http://www.jjj.de/hfloat/
hfloat (for huge floats) is a library package for doing
calculations with floating point numbers of extreme precision. It is optimised for computations with 1000...several million digits. The computations can be done in (almost) arbitrary radix.

Blitz++

http://www.oonumerics.org/blitz/
Template Library für Matrizen und Vektoren. Schnell. Hohe Anforderungen an den Compiler.

Descartes

TorstenM schrieb:

Hallo,
Wie kann man denn "unendlich" weit rechnen lassen. z.B. für PI. da läuft man doch sicher schnell aus dem wertebereich hinaus.

Bei der Berechnung von PI kann man durch geeignete mathematische Algorithmen darauf verzichten, bereits bekannte Nachkommastellen erneut berechnen zu müssen. Wenn ein Wissenschaftler sich also hinsetzt, um mit seinem Supercomputer die 42-milliardste Nachkommastelle von PI zu berechnen, dann muss sein Rechner "lediglich" diese Stelle berechnen aber nicht alle anderen Stellen davor. Das ist schon mal ein immenser Zeitgewinn.
Das Ganze bringt dir aber nur dann etwas, wenn du wirklich nur diese ein Nachkommastelle bestimmen möchtest. Möchtest du allerdings alle Nachkommastellen bis hin zu dieser Nachkommastelle berechnen, so muss dein Computer eben jede einzelne Nachkommastelle einzeln ermitteln -- und das kann je nach vorhandener Hardware schon ein paar Monate dauern.

TriPhoenix

TorstenM schrieb:

Ein Addition könnt ich mir noch vorstellen (muss ja alles binär erfolgen, oder?) bei einer Stelle. Für mehrere müsste man sich auch schon wieder ne Funktion bauen, die Binär den Übertrag verrechnet?

Hat jemand mein Problem verstanden? Und eine Idee dafür?

Wenn dich die Theorie dahinter interessiert (also das wie, nicht nur die Tatsachem dass mans benutzen kann): "Kryptographie in C und C++" von Welschenbach.

Descartes

Beispiel:
GMP computation of PI, unlimited precision

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<gmp.h>

int main()
{
  mpf_t index,eight,c1,c2,root8,denom,threeninesix,tmp,sum,factorial;
  mpf_t factorial4,denom2,ONE;
  int n,m;

  mpf_init2(index,2048);
  mpf_init2(eight,2048);
  mpf_init2(c1,2048);
  mpf_init2(c2,2048);
  mpf_init2(root8,2048);
  mpf_init2(denom,2048);
  mpf_init2(denom2,2048);
  mpf_init2(threeninesix,2048);
  mpf_init2(tmp,2048);
  mpf_init2(sum,2048);
  mpf_init2(factorial,2048);
  mpf_init2(factorial4,2048);
  mpf_init2(ONE,2048);
  mpf_set_ui(eight,8);       /* set constant factors */
  mpf_set_ui(c1,1103);
  mpf_set_ui(c2,26390);
  mpf_set_ui(threeninesix,396);
  mpf_set_ui(denom,9801);
  mpf_mul(threeninesix,threeninesix,threeninesix); /* square */
  mpf_mul(threeninesix,threeninesix,threeninesix); /* (396)^4*/
  mpf_sqrt(eight,eight); /* compute sqrt(8) */
  mpf_set(denom2,threeninesix);
  mpf_set_ui(ONE,1);

  /* start adding up terms */
  mpf_set(sum,c1);

  /* loop, build the factorials */
  for(n=1;n<19;n++)
    {
      mpf_set_ui(factorial, 1);
      mpf_set_ui(factorial4, 1); /* inefficient, but so what? */
      mpf_set_ui(index,n);
      for(m=1;m<=n;m++)
	{
	  mpf_set_ui(tmp,m);
	  mpf_mul(factorial, factorial,tmp);
	}
      mpf_out_str(stdout,10,20,factorial);
      printf("\t");
      mpf_mul(factorial,factorial,factorial); /*square */
      mpf_mul(factorial,factorial,factorial); /* (n!)^4 */
      for(m=1;m<=4*n;m++)
	{
	  mpf_set_ui(tmp,m);
	  mpf_mul(factorial4, factorial4,tmp);
	}
      mpf_out_str(stdout,10,20,factorial4);
      printf("\n");
      mpf_mul(tmp,c2,index);  /* 26390 n */
      mpf_add(tmp,tmp,c1);      /* 1103 + 26390 n */
      mpf_mul(tmp,tmp,factorial4);
      mpf_div(tmp,tmp,factorial);
      mpf_div(tmp,tmp,denom2);
      mpf_add(sum,sum,tmp);
      mpf_mul(denom2,denom2,threeninesix); /* make (396)^4n */

    } /* finish the sum */
  mpf_mul(sum,sum,eight);
  mpf_div(sum,sum,denom);
  mpf_div(sum,ONE,sum);
  mpf_out_str(stdout,10,100,sum);
  printf("\n");
  return 0;
}

weitere Beispiele:
http://rustam.uwp.edu/499/files/files.html

Na das is es doch! Dieses GMP muss ich mir mal anschauen. ich glaub das spart viel Arbeit.

Danke ersteinmal!!!

MfG Torsten

eigener Datentyp oder &quot;wie rechnet man das&quot;???

eigener Datentyp oder "wie rechnet man das"???