AGB  ·  Datenschutz  ·  Impressum  







Anmelden
Nützliche Links
Registrieren
Thema durchsuchen
Ansicht
Themen-Optionen

Interner Fehler C1537 - result Fehler???

Ein Thema von mr.warft · begonnen am 7. Mär 2008 · letzter Beitrag vom 9. Mär 2008
 
mr.warft

Registriert seit: 7. Mär 2008
6 Beiträge
 
#3

Re: Interner Fehler C1537 - result Fehler???

  Alt 7. Mär 2008, 23:42
Ja benutze ich ... der BigInteger ist eine Vorgabe von unseren Prof.

Hier der Code:
Delphi-Quellcode:

        { Objekttypdeklarationen (Bezeichner, Methoden) einer
          BigInteger-Zahl: }

        PBigInteger = ^TBigInteger; { Pointer auf eine BigInteger-Zahl }
        TBigInteger = OBJECT
                   PRIVATE
                     { Eine BigInteger-Zahl wird als Bin?rzahl beliebiger
                      L?nge dargestellt. Alle Bits werden als vorzeichen-
                      lose positive Zahl interpretiert. Das Vorzeichen
                       der Zahl wird separat gespeichert                   }

                     vz : Tvorzeichen;
                     { Vorzeichen der Zahl : vzminus bei negativer Zahl,
                                            vznull bei Wert 0,
                                             vzplus bei positiver Zahl         }

                     wert : Pwertfeld;
                     { Wert der Zahl (als nullterminierter Bytestring)
                      in Big-endian Speicherung: das h?chstwertige Bit
                      der Zahl steht in wert[0] und dort an der
                      kleinstm?glichen Bitposition. Das niedrigst-
                      wertige Bit der Zahl steht an Bitposition 0 in
                      wert[i-1], wenn die Zahl die Bytes
                      wert[0], ..., wert[i-1] belegt. Die restlichen
                      Bytes des zugewiesenen Speicherbereichs sind mit
                      dem Zeichen #0 aufgef?llt.
                       Der Wert 0 hat vorzeichen = 0 und wert[0] = 0.      }

                     bitanzahl : INTEGER;
                     { Anzahl der Bits der Zahl.
                       Der Wert 0 hat bitanzahl = 1.                       }

                     byteanzahl : INTEGER;
                     { Anzahl der von der Zahl belegten Bytes, d.h. die
                      Zahl belegt die Bytes
                      wert[0], ..., wert[byteanzahl-1].
                       Der Wert 0 hat byteanzahl = 1.                      }

                     hoechstesBit : ShortInt;
                     { h?chste verwendete Bitposition in wert[0].
                       Es ist 0 <= hoechstesBit <= 7.                      }

                     PROCEDURE Nullbytes_entfernen;
                     { stellt sicher, da? die BigInteger-Zahl in der oben
                      beschriebenen Weise in wert abgelegt ist, d.h. da?
                      die Zahl genau die Bytes
                      wert[0], ..., wert[byteanzahl-1]
                      (ohne f?hrende Nullbytes) belegt
                      und da? bei einem Wert <> 0 die Bedingung
                       wert[0] <> 0 erf?llt ist                            }

                     PROCEDURE powergeneral (a : TBigInteger;
                                             b : TBigInteger;
                                             c : TBigInteger;
                                             mit_mod : BOOLEAN);
                      { ersetzt wert durch den Wert der BigInteger-Zahl |a|
                                          hoch
                                          den Wert der BigInteger-Zahl |b|
                                          MOD (falls mit_mod = TRUE ist)
                                           den Wert der BigInteger-Zahl |c|}

                     FUNCTION OddB : BOOLEAN;
                      { liefert TRUE, wenn der Wert der Zahl ungerade ist,
                        sonst FALSE                                        }

                   PUBLIC
                     CONSTRUCTOR BigInteger (Strwert : ANSIString);
                      { erzeugt eine BigInteger-Zahl, deren Repr?sentation
                        als Zeichenkette im Parameter Strwert
                        ?bergeben wird                                     }


                     CONSTRUCTOR BigIntegerI (Intwert : INTEGER);
                      { erzeugt eine BigInteger-Zahl, deren Repr?sentation
                        als INTEGER-Zahl im Parameter Intwert
                        ?bergeben wird                                     }


                     CONSTRUCTOR BigIntegerB (Bigwert : TBigInteger;
                                              vorz : Tvorzeichen);
                      { erzeugt eine BigInteger-Zahl, deren Repr?sentation
                        als BigInteger-Zahl im Parameter Bigwert
                        ?bergeben wird, mit dem in vorz ?bergebenen
                        Vorzeichen;
                        bei vorz = vznull wird der Wert 0 erzeugt,
                        unabh?ngig vom Wert von Bigwert                    }


                     CONSTRUCTOR BigIntegerH (Ptrwert : Pwertfeld;
                                              Byteanz : INTEGER);
                      { erzeugt aus dem Wertfeld (Sedezimalwerte) in der
                        angegebenen L?nge, indiziert von 0 bis Byteanz - 1),
                        eine nichtnegative BigInteger-Zahl                 }


                     FUNCTION internerWert : Pwertfeld;
                       { liefert einen Pointer auf die interne
                         Repr?sentation (Komponente wert) der Zahl         }


                     FUNCTION vorzeichen : Tvorzeichen;
                      { liefert das Vorzeichen der Zahl                    }

                     FUNCTION BitLength : INTEGER;
                      { liefert die Bitanzahl der Zahl                     }

                     FUNCTION ByteLength : INTEGER;
                      { liefert die Byteanzahl der Zahl                    }

                     FUNCTION compare (bigzahl : TBigInteger) : Tcompare;
                      { vergleicht den eigenen Wert mit dem Wert der
                        BigInteger-Zahl bigzahl                            }


                     FUNCTION BigIntegerToStr : ANSIString;
                      { liefert den eigenen Wert als lange
                        Zeichenkette einschlie?lich des Vorzeichens        }


                     FUNCTION BigIntegerToHexstr : ANSIString;
                      { liefert den eigenen Wert als lange
                        Zeichenkette aus Sedezimalziffern einschlie?lich
                        des Vorzeichens                                    }


                     PROCEDURE SetI (i : BYTE);
                     { setzt die Zahl auf den Wert i                       }

                     PROCEDURE SetB (Bigwert : TBigInteger;
                                     vorz : Tvorzeichen);
                      { setzt wert auf den Wert von Bigwert mit dem
                        in vorz ?bergebenen Vorzeichen;
                        bei vorz = vznull wird der Wert 0 erzeugt,
                        unabh?ngig vom Wert von Bigwert                    }


                     PROCEDURE add (a : TBigInteger;
                                    b : TBigInteger);
                      { ersetzt wert durch den Wert der BigInteger-Zahl a
                                          plus
                                           den Wert der BigInteger-Zahl b  }


                     PROCEDURE sub (a : TBigInteger;
                                    b : TBigInteger);
                      { ersetzt wert durch den Wert der BigInteger-Zahl a
                                          minus
                                           den Wert der BigInteger-Zahl b  }


                     PROCEDURE mult (a : TBigInteger;
                                     b : TBigInteger);
                      { ersetzt wert durch den Wert der BigInteger-Zahl a
                                          multiliziert mit
                                           dem Wert der BigInteger-Zahl b  }


                     PROCEDURE divB (a : TBigInteger;
                                     b : TBigInteger);
                      { ersetzt wert durch den Wert der BigInteger-Zahl |a|
                                          DIV
                                          den Wert der BigInteger-Zahl |b|;
                        der Wert der BigInteger-Zahl b muss <> 0 sein      }


                     PROCEDURE modB (a : TBigInteger;
                                     b : TBigInteger);
                      { ersetzt wert durch den Wert der BigInteger-Zahl |a|
                                          MOD
                                           den Wert der BigInteger-Zahl |b|}


                     PROCEDURE power (a : TBigInteger;
                                      b : TBigInteger);
                      { ersetzt wert durch den Wert der BigInteger-Zahl |a|
                                          hoch
                                           den Wert der BigInteger-Zahl |b|}


                     PROCEDURE powermod (a : TBigInteger;
                                         b : TBigInteger;
                                         c : TBigInteger);
                      { ersetzt wert durch den Wert der BigInteger-Zahl |a|
                                          hoch
                                          den Wert der BigInteger-Zahl |b|
                                          MOD
                                           den Wert der BigInteger-Zahl |c|}


                     PROCEDURE shiftleft (i : INTEGER);
                       { schiebt bei i >= 0 wert um i Bitpositionen nach
                        links; f?hrende Bits entfallen dabei nicht;
                         von rechts werden 0-Bits nachgezogen              }


                     PROCEDURE IncB;
                        { erh?ht den Wert von wert um 1                    }

                     PROCEDURE DecB;
                        { vermindert den Wert von wert um 1                }

                     PROCEDURE ggT (a : TBigInteger;
                                    b : TBigInteger);
                     { bestimmt den gr??ten gemeinsamen Teiler von
                      |a| und |b| mit dem Euklidischen Algorithmus         }


                     PROCEDURE invers (a : TBigInteger;
                                        b : TBigInteger;
                                        VAR a_inv : TBigInteger;
                                        VAR b_inv : TBigInteger);

                    { bestimmt den gr??ten gemeinsamen Teiler von
                      |a| und |b| mit dem Euklidischen Algorithmus
                      und ganze Zahlen a_inv und b_inv mit
                      a*a_inv + b*b_inv = ggT(a, b)                        }


                    PROCEDURE zufallszahl (Dezimalstellen : INTEGER;
                                           ungerade : BOOLEAN);
                    { erzeugt eine Zufallszahl mit der angegebenen Anzahl
                      an Dezimalstellen                                    }


                    PROCEDURE generate_prim (Dezimalstellen : INTEGER);
                    { erzeugt eine Primzahl mit der angegebenen Anzahl
                      an Dezimalstellen                                    }


                    FUNCTION ist_prim (k : INTEGER) : BOOLEAN;
                    { ergibt TRUE, wenn der Wert der Zahl eine
                      Primzahl ist, sonst FALSE;
                      k gibt die Anzahl der Testiterationen an             }
Das ist ein bisschen mehr Code als verlangt aber das ist ja nicht schlimm.
  Mit Zitat antworten Zitat
 


Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Datenschutz · Nach oben
Alle Zeitangaben in WEZ +1. Es ist jetzt 00:26 Uhr.
Powered by vBulletin® Copyright ©2000 - 2025, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024-2025 by Thomas Breitkreuz