This is an automated email from the ASF dual-hosted git repository.
mseidel pushed a commit to branch Pilot-Pirx-patch-1
in repository https://gitbox.apache.org/repos/asf/openoffice.git
The following commit(s) were added to refs/heads/Pilot-Pirx-patch-1 by this
push:
new e3c47441a9 Additional files
e3c47441a9 is described below
commit e3c47441a9a58c125bae01cb7f6e0d84f3e59baf
Author: mseidel <[email protected]>
AuthorDate: Fri Oct 17 15:35:35 2025 +0200
Additional files
---
main/tools/source/generic/fract.cxx | 802 ++++++++++++++++++------------------
1 file changed, 401 insertions(+), 401 deletions(-)
diff --git a/main/tools/source/generic/fract.cxx
b/main/tools/source/generic/fract.cxx
index b57b52a657..86ce98857d 100644
--- a/main/tools/source/generic/fract.cxx
+++ b/main/tools/source/generic/fract.cxx
@@ -19,8 +19,6 @@
*
*************************************************************/
-
-
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_tools.hxx"
@@ -37,88 +35,88 @@
|*
|* GetGGT()
|*
-|* Beschreibung Berechnet den groessten gemeinsamen Teiler von
+|* Beschreibung Berechnet den gr��ten gemeinsamen Teiler von
|* nVal1 und nVal2
|* Parameter long nVal1, long nVal2
|* Ersterstellung DV 20.09.90
-|* Letzte Aenderung DV 21.12.92
+|* Letzte �nderung DV 21.12.92
|*
*************************************************************************/
-// Die Funktion GetGGT berechnet den groessten gemeinsamen Teiler der
-// beiden als Parameter uebergebenen Werte nVal1 und nVal2 nach dem
+// Die Funktion GetGGT berechnet den gr��ten gemeinsamen Teiler der
+// beiden als Parameter �bergebenen Werte nVal1 und nVal2 nach dem
// Algorithmus von Euklid. Hat einer der beiden Parameter den Wert 0 oder
-// 1, so wird als Ergebnis der Wert 1 zur�ckgegeben. Da der Algorithmus
+// 1, so wird als Ergebnis der Wert 1 zur�ckgegeben. Da der Algorithmus
// nur mit positiven Zahlen arbeitet, werden die beiden Parameter
// entsprechend umgewandelt.
-// Zum Algorithmus: die beiden Parameter werden solange ducheinander
+// Zum Algorithmus: die beiden Parameter werden solange durcheinander
// geteilt, bis sie beide gleich sind oder bis bei der Division
// kein Rest bleibt. Der kleinere der beiden Werte ist dann der
// GGT.
static long GetGGT( long nVal1, long nVal2 )
{
- nVal1 = Abs( nVal1 );
- nVal2 = Abs( nVal2 );
-
- if ( nVal1 <= 1 || nVal2 <= 1 )
- return 1;
-
- while ( nVal1 != nVal2 )
- {
- if ( nVal1 > nVal2 )
- {
- nVal1 %= nVal2;
- if ( nVal1 == 0 )
- return nVal2;
- }
- else
- {
- nVal2 %= nVal1;
- if ( nVal2 == 0 )
- return nVal1;
- }
- }
-
- return nVal1;
+ nVal1 = Abs( nVal1 );
+ nVal2 = Abs( nVal2 );
+
+ if ( nVal1 <= 1 || nVal2 <= 1 )
+ return 1;
+
+ while ( nVal1 != nVal2 )
+ {
+ if ( nVal1 > nVal2 )
+ {
+ nVal1 %= nVal2;
+ if ( nVal1 == 0 )
+ return nVal2;
+ }
+ else
+ {
+ nVal2 %= nVal1;
+ if ( nVal2 == 0 )
+ return nVal1;
+ }
+ }
+
+ return nVal1;
}
static void Reduce( BigInt &rVal1, BigInt &rVal2 )
{
- BigInt nA( rVal1 );
- BigInt nB( rVal2 );
- nA.Abs();
- nB.Abs();
-
- if ( nA.IsOne() || nB.IsOne() || nA.IsZero() || nB.IsZero() )
- return;
-
- while ( nA != nB )
- {
- if ( nA > nB )
- {
- nA %= nB;
- if ( nA.IsZero() )
+ BigInt nA( rVal1 );
+ BigInt nB( rVal2 );
+ nA.Abs();
+ nB.Abs();
+
+ if ( nA.IsOne() || nB.IsOne() || nA.IsZero() || nB.IsZero() )
+ return;
+
+ while ( nA != nB )
+ {
+ if ( nA > nB )
+ {
+ nA %= nB;
+ if ( nA.IsZero() )
{
- rVal1 /= nB;
- rVal2 /= nB;
+ rVal1 /= nB;
+ rVal2 /= nB;
return;
}
- }
- else
- {
- nB %= nA;
- if ( nB.IsZero() )
+ }
+ else
+ {
+ nB %= nA;
+ if ( nB.IsZero() )
{
- rVal1 /= nA;
- rVal2 /= nA;
+ rVal1 /= nA;
+ rVal2 /= nA;
return;
}
- }
- }
+ }
+ }
- rVal1 /= nA;
- rVal2 /= nB;
+ rVal1 /= nA;
+ rVal2 /= nB;
}
/*************************************************************************
@@ -127,7 +125,7 @@ static void Reduce( BigInt &rVal1, BigInt &rVal2 )
|*
|* Beschreibung FRACT.SDW
|* Ersterstellung WP 07.03.97
-|* Letzte Aenderung
+|* Letzte �nderung
|*
*************************************************************************/
@@ -141,19 +139,19 @@ Fraction::Fraction( long nN1, long nN2, long nD1, long
nD2 )
if( nD1 < 0 ) { i = -i; nD1 = -nD1; }
if( nD2 < 0 ) { i = -i; nD2 = -nD2; }
- n = GetGGT( nN1, nD1 ); if( n > 1 ) { nN1 /= n; nD1 /= n; }
- n = GetGGT( nN1, nD2 ); if( n > 1 ) { nN1 /= n; nD2 /= n; }
- n = GetGGT( nN2, nD1 ); if( n > 1 ) { nN2 /= n; nD1 /= n; }
- n = GetGGT( nN2, nD2 ); if( n > 1 ) { nN2 /= n; nD2 /= n; }
+ n = GetGGT( nN1, nD1 ); if( n > 1 ) { nN1 /= n; nD1 /= n; }
+ n = GetGGT( nN1, nD2 ); if( n > 1 ) { nN1 /= n; nD2 /= n; }
+ n = GetGGT( nN2, nD1 ); if( n > 1 ) { nN2 /= n; nD1 /= n; }
+ n = GetGGT( nN2, nD2 ); if( n > 1 ) { nN2 /= n; nD2 /= n; }
- BigInt nN( nN1 );
- nN *= BigInt( nN2 );
+ BigInt nN( nN1 );
+ nN *= BigInt( nN2 );
- BigInt nD( nD1 );
- nD *= BigInt( nD2 );
+ BigInt nD( nD1 );
+ nD *= BigInt( nD2 );
- while ( nN.bIsBig || nD.bIsBig )
- {
+ while ( nN.bIsBig || nD.bIsBig )
+ {
BigInt n1 = 1;
BigInt n2 = 2;
@@ -162,12 +160,12 @@ Fraction::Fraction( long nN1, long nN2, long nD1, long
nD2 )
nD += n1;
nD /= n2;
- // Kuerzen ueber Groesste Gemeinsame Teiler
- Reduce( nN, nD );
- }
+ // K�rzen �ber Gr��te Gemeinsame Teiler
+ Reduce( nN, nD );
+ }
- nNumerator = i * (long)nN;
- nDenominator = (long)nD;
+ nNumerator = i * (long)nN;
+ nDenominator = (long)nD;
}
/*************************************************************************
@@ -176,30 +174,30 @@ Fraction::Fraction( long nN1, long nN2, long nD1, long
nD2 )
|*
|* Beschreibung FRACT.SDW
|* Ersterstellung DV 20.09.90
-|* Letzte Aenderung DV 21.12.92
+|* Letzte �nderung DV 21.12.92
|*
*************************************************************************/
-// Zur Initialisierung eines Bruches wird nNum dem Zaehler und nDen dem
+// Zur Initialisierung eines Bruches wird nNum dem Z�hler und nDen dem
// Nenner zugewiesen. Da negative Werte des Nenners einen Bruch als
-// ungueltig kennzeichnen, wird bei der Eingabe eines negativen Nenners
-// sowohl das Vorzeichen des Nenners und des Zaehlers invertiert um wieder
-// einen gueltigen Wert fuer den Bruch zu erhalten.
+// ung�ltig kennzeichnen, wird bei der Eingabe eines negativen Nenners
+// sowohl das Vorzeichen des Nenners und des Z�hlers invertiert um wieder
+// einen g�ltigen Wert f�r den Bruch zu erhalten.
Fraction::Fraction( long nNum, long nDen )
{
- nNumerator = nNum;
- nDenominator = nDen;
- if ( nDenominator < 0 )
- {
- nDenominator = -nDenominator;
- nNumerator = -nNumerator;
- }
-
- // Kuerzen ueber Groesste Gemeinsame Teiler
- long n = GetGGT( nNumerator, nDenominator );
- nNumerator /= n;
- nDenominator /= n;
+ nNumerator = nNum;
+ nDenominator = nDen;
+ if ( nDenominator < 0 )
+ {
+ nDenominator = -nDenominator;
+ nNumerator = -nNumerator;
+ }
+
+ // K�rzen �ber Gr��te Gemeinsame Teiler
+ long n = GetGGT( nNumerator, nDenominator );
+ nNumerator /= n;
+ nDenominator /= n;
}
/*************************************************************************
@@ -208,40 +206,40 @@ Fraction::Fraction( long nNum, long nDen )
|*
|* Beschreibung FRACT.SDW
|* Ersterstellung DV 20.09.90
-|* Letzte Aenderung DV 21.12.92
+|* Letzte �nderung DV 21.12.92
|*
*************************************************************************/
-// Wenn der Wert von dVal groesser ist als LONG_MAX, dann wird der Bruch
-// auf den Wert ungueltig gesetzt, ansonsten werden dVal und der Nenner
-// solange mit 10 multipliziert, bis entweder der Zaehler oder der Nenner
-// groesser als LONG_MAX / 10 ist. Zum Schluss wird der so entstandene Bruch
-// gekuerzt.
+// Wenn der Wert von dVal gr��er ist als LONG_MAX, dann wird der Bruch
+// auf den Wert ung�ltig gesetzt, ansonsten werden dVal und der Nenner
+// solange mit 10 multipliziert, bis entweder der Z�hler oder der Nenner
+// gr��er als LONG_MAX / 10 ist. Zum Schluss wird der so entstandene Bruch
+// gek�rzt.
Fraction::Fraction( double dVal )
{
- long nDen = 1;
- long nMAX = LONG_MAX / 10;
-
- if ( dVal > LONG_MAX || dVal < LONG_MIN )
- {
- nNumerator = 0;
- nDenominator = -1;
- return;
- }
-
- while ( Abs( (long)dVal ) < nMAX && nDen < nMAX )
- {
- dVal *= 10;
- nDen *= 10;
- }
- nNumerator = (long)dVal;
- nDenominator = nDen;
-
- // Kuerzen ueber Groesste Gemeinsame Teiler
- long n = GetGGT( nNumerator, nDenominator );
- nNumerator /= n;
- nDenominator /= n;
+ long nDen = 1;
+ long nMAX = LONG_MAX / 10;
+
+ if ( dVal > LONG_MAX || dVal < LONG_MIN )
+ {
+ nNumerator = 0;
+ nDenominator = -1;
+ return;
+ }
+
+ while ( Abs( (long)dVal ) < nMAX && nDen < nMAX )
+ {
+ dVal *= 10;
+ nDen *= 10;
+ }
+ nNumerator = (long)dVal;
+ nDenominator = nDen;
+
+ // K�rzen �ber Gr��te Gemeinsame Teiler
+ long n = GetGGT( nNumerator, nDenominator );
+ nNumerator /= n;
+ nDenominator /= n;
}
/*************************************************************************
@@ -250,16 +248,16 @@ Fraction::Fraction( double dVal )
|*
|* Beschreibung FRACT.SDW
|* Ersterstellung DV 20.09.90
-|* Letzte Aenderung DV 14.05.91
+|* Letzte �nderung DV 14.05.91
|*
*************************************************************************/
Fraction::operator double() const
{
- if ( nDenominator > 0 )
- return (double)nNumerator / (double)nDenominator;
- else
- return (double)0;
+ if ( nDenominator > 0 )
+ return (double)nNumerator / (double)nDenominator;
+ else
+ return (double)0;
}
/*************************************************************************
@@ -268,54 +266,54 @@ Fraction::operator double() const
|*
|* Beschreibung FRACT.SDW
|* Ersterstellung DV 20.09.90
-|* Letzte Aenderung DV 21.12.92
+|* Letzte �nderung DV 21.12.92
|*
*************************************************************************/
-// Zunaechst werden die beiden Parameter auf ihre Gueltigkeit ueberprueft.
-// Ist einer der Parameter ungueltig, dann ist auch des Ergebnis
-// ungueltig. Zur Addition werden die beiden Brueche erst durch
+// Zun�chst werden die beiden Parameter auf ihre G�ltigkeit �berpr�ft.
+// Ist einer der Parameter ung�ltig, dann ist auch des Ergebnis
+// ung�ltig. Zur Addition werden die beiden Br�che erst durch
// Erweiterung mit den Nenner des jeweils anderen Bruches auf einen
-// gemeinsamen Nenner gebracht. Anschliessend werden die beiden Zaehler
-// addiert und das Ergebnis gekuerzt (durch Division von Zaehler und
+// gemeinsamen Nenner gebracht. Anschlie�end werden die beiden Z�hler
+// addiert und das Ergebnis gek�rzt (durch Division von Z�hler und
// Nenner mit nGGT). Innerhalb der Funktion wird mit dem Datentyp SLong
-// gerechnet, um einen Moeglichen Ueberlauf erkennen zu koennen. Bei
-// einem Ueberlauf wird das Ergebnis auf den Wert ungueltig gesetzt.
+// gerechnet, um einen m�glichen �berlauf erkennen zu k�nnen. Bei
+// einem �berlauf wird das Ergebnis auf den Wert ung�ltig gesetzt.
Fraction& Fraction::operator += ( const Fraction& rVal )
{
- if ( !rVal.IsValid() )
- {
- nNumerator = 0;
- nDenominator = -1;
- }
- if ( !IsValid() )
- return *this;
-
- // (a/b) + (c/d) = ( (a*d) + (c*b) ) / (b*d)
- BigInt nN( nNumerator );
- nN *= BigInt( rVal.nDenominator );
- BigInt nW1Temp( nDenominator );
- nW1Temp *= BigInt( rVal.nNumerator );
- nN += nW1Temp;
-
- BigInt nD( nDenominator );
- nD *= BigInt( rVal.nDenominator );
-
- Reduce( nN, nD );
-
- if ( nN.bIsBig || nD.bIsBig )
- {
- nNumerator = 0;
- nDenominator = -1;
- }
- else
- {
- nNumerator = (long)nN,
- nDenominator = (long)nD;
- }
-
- return *this;
+ if ( !rVal.IsValid() )
+ {
+ nNumerator = 0;
+ nDenominator = -1;
+ }
+ if ( !IsValid() )
+ return *this;
+
+ // (a/b) + (c/d) = ( (a*d) + (c*b) ) / (b*d)
+ BigInt nN( nNumerator );
+ nN *= BigInt( rVal.nDenominator );
+ BigInt nW1Temp( nDenominator );
+ nW1Temp *= BigInt( rVal.nNumerator );
+ nN += nW1Temp;
+
+ BigInt nD( nDenominator );
+ nD *= BigInt( rVal.nDenominator );
+
+ Reduce( nN, nD );
+
+ if ( nN.bIsBig || nD.bIsBig )
+ {
+ nNumerator = 0;
+ nDenominator = -1;
+ }
+ else
+ {
+ nNumerator = (long)nN,
+ nDenominator = (long)nD;
+ }
+
+ return *this;
}
/*************************************************************************
@@ -324,54 +322,54 @@ Fraction& Fraction::operator += ( const Fraction& rVal )
|*
|* Beschreibung FRACT.SDW
|* Ersterstellung DV 20.09.90
-|* Letzte Aenderung DV 21.12.92
+|* Letzte �nderung DV 21.12.92
|*
*************************************************************************/
-// Zunaechst werden die beiden Parameter auf ihre Gueltigkeit ueberprueft.
-// Ist einer der Parameter ungueltig, dann ist auch des Ergebnis
-// ungueltig. Zur Subtraktion werden die beiden Brueche erst durch
+// Zun�chst werden die beiden Parameter auf ihre G�ltigkeit �berpr�ft.
+// Ist einer der Parameter ung�ltig, dann ist auch des Ergebnis
+// ung�ltig. Zur Subtraktion werden die beiden Br�che erst durch
// Erweiterung mit den Nenner des jeweils anderen Bruches auf einen
-// gemeinsamen Nenner gebracht. Anschliessend werden die beiden Zaehler
-// subtrahiert und das Ergebnis gekuerzt (durch Division von Zaehler und
+// gemeinsamen Nenner gebracht. Anschlie�end werden die beiden Z�hler
+// subtrahiert und das Ergebnis gek�rzt (durch Division von Z�hler und
// Nenner mit nGGT). Innerhalb der Funktion wird mit dem Datentyp BigInt
-// gerechnet, um einen Moeglichen Ueberlauf erkennen zu koennen. Bei
-// einem Ueberlauf wird das Ergebnis auf den Wert ungueltig gesetzt.
+// gerechnet, um einen m�glichen �berlauf erkennen zu k�nnen. Bei
+// einem �berlauf wird das Ergebnis auf den Wert ung�ltig gesetzt.
Fraction& Fraction::operator -= ( const Fraction& rVal )
{
- if ( !rVal.IsValid() )
- {
- nNumerator = 0;
- nDenominator = -1;
- }
- if ( !IsValid() )
- return *this;
-
- // (a/b) - (c/d) = ( (a*d) - (c*b) ) / (b*d)
- BigInt nN( nNumerator );
- nN *= BigInt( rVal.nDenominator );
- BigInt nW1Temp( nDenominator );
- nW1Temp *= BigInt( rVal.nNumerator );
- nN -= nW1Temp;
-
- BigInt nD( nDenominator );
- nD *= BigInt( rVal.nDenominator );
-
- Reduce( nN, nD );
-
- if ( nN.bIsBig || nD.bIsBig )
- {
- nNumerator = 0;
- nDenominator = -1;
- }
- else
- {
- nNumerator = (long)nN,
- nDenominator = (long)nD;
- }
-
- return *this;
+ if ( !rVal.IsValid() )
+ {
+ nNumerator = 0;
+ nDenominator = -1;
+ }
+ if ( !IsValid() )
+ return *this;
+
+ // (a/b) - (c/d) = ( (a*d) - (c*b) ) / (b*d)
+ BigInt nN( nNumerator );
+ nN *= BigInt( rVal.nDenominator );
+ BigInt nW1Temp( nDenominator );
+ nW1Temp *= BigInt( rVal.nNumerator );
+ nN -= nW1Temp;
+
+ BigInt nD( nDenominator );
+ nD *= BigInt( rVal.nDenominator );
+
+ Reduce( nN, nD );
+
+ if ( nN.bIsBig || nD.bIsBig )
+ {
+ nNumerator = 0;
+ nDenominator = -1;
+ }
+ else
+ {
+ nNumerator = (long)nN,
+ nDenominator = (long)nD;
+ }
+
+ return *this;
}
/*************************************************************************
@@ -380,50 +378,50 @@ Fraction& Fraction::operator -= ( const Fraction& rVal )
|*
|* Beschreibung FRACT.SDW
|* Ersterstellung DV 20.09.90
-|* Letzte Aenderung TH 19.08.92
+|* Letzte �nderung TH 19.08.92
|*
*************************************************************************/
-// Zunaechst werden die beiden Parameter auf ihre Gueltigkeit ueberprueft.
-// Ist einer der Parameter ungueltig, dann ist auch des Ergebnis
-// ungueltig. Zur Multiplikation werden jeweils die beiden Zaehler und
-// Nenner miteinander multipliziert. Um Ueberlaufe zu vermeiden, werden
-// vorher jeweils der GGT zwischen dem Zaehler des einen und dem Nenner
-// des anderen Bruches bestimmt und bei der Multiplikation Zaehler und
+// Zun�chst werden die beiden Parameter auf ihre G�ltigkeit �berpr�ft.
+// Ist einer der Parameter ung�ltig, dann ist auch des Ergebnis
+// ung�ltig. Zur Multiplikation werden jeweils die beiden Z�hler und
+// Nenner miteinander multipliziert. Um �berl�ufe zu vermeiden, werden
+// vorher jeweils der GGT zwischen dem Z�hler des einen und dem Nenner
+// des anderen Bruches bestimmt und bei der Multiplikation Z�hler und
// Nenner durch die entsprechenden Werte geteilt.
// Innerhalb der Funktion wird mit dem Datentyp BigInt gerechnet, um
-// einen Moeglichen Ueberlauf erkennen zu koennen. Bei einem Ueberlauf
-// wird das Ergebnis auf den Wert ungueltig gesetzt.
+// einen m�glichen �berlauf erkennen zu k�nnen. Bei einem �berlauf
+// wird das Ergebnis auf den Wert ung�ltig gesetzt.
Fraction& Fraction::operator *= ( const Fraction& rVal )
{
- if ( !rVal.IsValid() )
- {
- nNumerator = 0;
- nDenominator = -1;
- }
- if ( !IsValid() )
- return *this;
-
- long nGGT1 = GetGGT( nNumerator, rVal.nDenominator );
- long nGGT2 = GetGGT( rVal.nNumerator, nDenominator );
- BigInt nN( nNumerator / nGGT1 );
- nN *= BigInt( rVal.nNumerator / nGGT2 );
- BigInt nD( nDenominator / nGGT2 );
- nD *= BigInt( rVal.nDenominator / nGGT1 );
-
- if ( nN.bIsBig || nD.bIsBig )
- {
- nNumerator = 0;
- nDenominator = -1;
- }
- else
- {
- nNumerator = (long)nN,
- nDenominator = (long)nD;
- }
-
- return *this;
+ if ( !rVal.IsValid() )
+ {
+ nNumerator = 0;
+ nDenominator = -1;
+ }
+ if ( !IsValid() )
+ return *this;
+
+ long nGGT1 = GetGGT( nNumerator, rVal.nDenominator );
+ long nGGT2 = GetGGT( rVal.nNumerator, nDenominator );
+ BigInt nN( nNumerator / nGGT1 );
+ nN *= BigInt( rVal.nNumerator / nGGT2 );
+ BigInt nD( nDenominator / nGGT2 );
+ nD *= BigInt( rVal.nDenominator / nGGT1 );
+
+ if ( nN.bIsBig || nD.bIsBig )
+ {
+ nNumerator = 0;
+ nDenominator = -1;
+ }
+ else
+ {
+ nNumerator = (long)nN,
+ nDenominator = (long)nD;
+ }
+
+ return *this;
}
/*************************************************************************
@@ -432,58 +430,58 @@ Fraction& Fraction::operator *= ( const Fraction& rVal )
|*
|* Beschreibung FRACT.SDW
|* Ersterstellung DV 20.09.90
-|* Letzte Aenderung DV 21.12.92
+|* Letzte �nderung DV 21.12.92
|*
*************************************************************************/
-// Zunaechst werden die beiden Parameter auf ihre Gueltigkeit ueberprueft.
-// Ist einer der Parameter ungueltig, dann ist auch des Ergebnis
-// ungueltig.
+// Zun�chst werden die beiden Parameter auf ihre G�ltigkeit �berpr�ft.
+// Ist einer der Parameter ung�ltig, dann ist auch des Ergebnis
+// ung�ltig.
// Um den Bruch a durch b zu teilen, wird a mit dem Kehrwert von b
-// multipliziert. Analog zu Multiplikation wird jezt jeweils der Zaehler
+// multipliziert. Analog zu Multiplikation wird jetzt jeweils der Z�hler
// des einen Bruches mit dem Nenner des anderen multipliziert.
-// Um Ueberlaufe zu vermeiden, werden vorher jeweils der GGT zwischen den
-// beiden Zaehlern und den beiden Nennern bestimmt und bei der
-// Multiplikation Zaehler und Nenner durch die entsprechenden Werte
+// Um �berl�ufe zu vermeiden, werden vorher jeweils der GGT zwischen den
+// beiden Z�hlern und den beiden Nennern bestimmt und bei der
+// Multiplikation Z�hler und Nenner durch die entsprechenden Werte
// geteilt.
// Innerhalb der Funktion wird mit dem Datentyp BigInt gerechnet, um
-// einen Moeglichen Ueberlauf erkennen zu koennen. Bei einem Ueberlauf
-// wird das Ergebnis auf den Wert ungueltig gesetzt.
+// einen m�glichen �berlauf erkennen zu k�nnen. Bei einem �berlauf
+// wird das Ergebnis auf den Wert ung�ltig gesetzt.
Fraction& Fraction::operator /= ( const Fraction& rVal )
{
- if ( !rVal.IsValid() )
- {
- nNumerator = 0;
- nDenominator = -1;
- }
- if ( !IsValid() )
- return *this;
-
- long nGGT1 = GetGGT( nNumerator, rVal.nNumerator );
- long nGGT2 = GetGGT( rVal.nDenominator, nDenominator );
- BigInt nN( nNumerator / nGGT1 );
- nN *= BigInt( rVal.nDenominator / nGGT2 );
- BigInt nD( nDenominator / nGGT2 );
- nD *= BigInt( rVal.nNumerator / nGGT1 );
-
- if ( nN.bIsBig || nD.bIsBig )
- {
- nNumerator = 0;
- nDenominator = -1;
- }
- else
- {
- nNumerator = (long)nN,
- nDenominator = (long)nD;
- if ( nDenominator < 0 )
- {
- nDenominator = -nDenominator;
- nNumerator = -nNumerator;
- }
- }
-
- return *this;
+ if ( !rVal.IsValid() )
+ {
+ nNumerator = 0;
+ nDenominator = -1;
+ }
+ if ( !IsValid() )
+ return *this;
+
+ long nGGT1 = GetGGT( nNumerator, rVal.nNumerator );
+ long nGGT2 = GetGGT( rVal.nDenominator, nDenominator );
+ BigInt nN( nNumerator / nGGT1 );
+ nN *= BigInt( rVal.nDenominator / nGGT2 );
+ BigInt nD( nDenominator / nGGT2 );
+ nD *= BigInt( rVal.nNumerator / nGGT1 );
+
+ if ( nN.bIsBig || nD.bIsBig )
+ {
+ nNumerator = 0;
+ nDenominator = -1;
+ }
+ else
+ {
+ nNumerator = (long)nN,
+ nDenominator = (long)nD;
+ if ( nDenominator < 0 )
+ {
+ nDenominator = -nDenominator;
+ nNumerator = -nNumerator;
+ }
+ }
+
+ return *this;
}
/*************************************************************************
@@ -492,7 +490,7 @@ Fraction& Fraction::operator /= ( const Fraction& rVal )
|*
|* Beschreibung FRACT.SDW
|* Ersterstellung JOE 17.09.95
-|* Letzte Aenderung kendy 2007-06-13
+|* Letzte �nderung kendy 2007-06-13
|*
*************************************************************************/
@@ -500,65 +498,65 @@ Fraction& Fraction::operator /= ( const Fraction& rVal )
// Similar to clz_table that can be googled
const char nbits_table[32] =
{
- 32, 1, 23, 2, 29, 24, 14, 3,
- 30, 27, 25, 18, 20, 15, 10, 4,
- 31, 22, 28, 13, 26, 17, 19, 9,
- 21, 12, 16, 8, 11, 7, 6, 5
+ 32, 1, 23, 2, 29, 24, 14, 3,
+ 30, 27, 25, 18, 20, 15, 10, 4,
+ 31, 22, 28, 13, 26, 17, 19, 9,
+ 21, 12, 16, 8, 11, 7, 6, 5
};
static int impl_NumberOfBits( unsigned long nNum )
{
- // http://en.wikipedia.org/wiki/De_Bruijn_sequence
- //
- // background paper: Using de Bruijn Sequences to Index a 1 in a
- // Computer Word (1998) Charles E. Leiserson,
- // Harald Prokop, Keith H. Randall
- // (e.g. http://citeseer.ist.psu.edu/leiserson98using.html)
- const sal_uInt32 nDeBruijn = 0x7DCD629;
-
- if ( nNum == 0 )
- return 0;
-
- // Get it to form like 0000001111111111b
- nNum |= ( nNum >> 1 );
- nNum |= ( nNum >> 2 );
- nNum |= ( nNum >> 4 );
- nNum |= ( nNum >> 8 );
- nNum |= ( nNum >> 16 );
-
- sal_uInt32 nNumber;
- int nBonus = 0;
+ // https://en.wikipedia.org/wiki/De_Bruijn_sequence
+ //
+ // background paper: Using de Bruijn Sequences to Index a 1 in a
+ // Computer Word (1998) Charles E. Leiserson,
+ // Harald Prokop, Keith H. Randall
+ // (e.g. http://citeseer.ist.psu.edu/leiserson98using.html)
+ const sal_uInt32 nDeBruijn = 0x7DCD629;
+
+ if ( nNum == 0 )
+ return 0;
+
+ // Get it to form like 0000001111111111b
+ nNum |= ( nNum >> 1 );
+ nNum |= ( nNum >> 2 );
+ nNum |= ( nNum >> 4 );
+ nNum |= ( nNum >> 8 );
+ nNum |= ( nNum >> 16 );
+
+ sal_uInt32 nNumber;
+ int nBonus = 0;
#if SAL_TYPES_SIZEOFLONG == 4
- nNumber = nNum;
+ nNumber = nNum;
#elif SAL_TYPES_SIZEOFLONG == 8
- nNum |= ( nNum >> 32 );
-
- if ( nNum & 0x80000000 )
- {
- nNumber = sal_uInt32( nNum >> 32 );
- nBonus = 32;
-
- if ( nNumber == 0 )
- return 32;
- }
- else
- nNumber = sal_uInt32( nNum & 0xFFFFFFFF );
+ nNum |= ( nNum >> 32 );
+
+ if ( nNum & 0x80000000 )
+ {
+ nNumber = sal_uInt32( nNum >> 32 );
+ nBonus = 32;
+
+ if ( nNumber == 0 )
+ return 32;
+ }
+ else
+ nNumber = sal_uInt32( nNum & 0xFFFFFFFF );
#else
#error "Unknown size of long!"
#endif
- // De facto shift left of nDeBruijn using multiplication (nNumber
- // is all ones from topmost bit, thus nDeBruijn + (nDeBruijn *
- // nNumber) => nDeBruijn * (nNumber+1) clears all those bits to
- // zero, sets the next bit to one, and thus effectively shift-left
- // nDeBruijn by lg2(nNumber+1). This generates a distinct 5bit
- // sequence in the msb for each distinct position of the last
- // leading 0 bit - that's the property of a de Bruijn number.
- nNumber = nDeBruijn + ( nDeBruijn * nNumber );
-
- // 5-bit window indexes the result
- return ( nbits_table[nNumber >> 27] ) + nBonus;
+ // De facto shift left of nDeBruijn using multiplication (nNumber
+ // is all ones from topmost bit, thus nDeBruijn + (nDeBruijn *
+ // nNumber) => nDeBruijn * (nNumber+1) clears all those bits to
+ // zero, sets the next bit to one, and thus effectively shift-left
+ // nDeBruijn by lg2(nNumber+1). This generates a distinct 5bit
+ // sequence in the msb for each distinct position of the last
+ // leading 0 bit - that's the property of a de Bruijn number.
+ nNumber = nDeBruijn + ( nDeBruijn * nNumber );
+
+ // 5-bit window indexes the result
+ return ( nbits_table[nNumber >> 27] ) + nBonus;
}
/** Inaccurate cancellation for a fraction.
@@ -581,43 +579,43 @@ static int impl_NumberOfBits( unsigned long nNum )
*/
void Fraction::ReduceInaccurate( unsigned nSignificantBits )
{
- if ( !nNumerator || !nDenominator )
- return;
-
- // Count with unsigned longs only
- const bool bNeg = ( nNumerator < 0 );
- unsigned long nMul = (unsigned long)( bNeg? -nNumerator: nNumerator );
- unsigned long nDiv = (unsigned long)( nDenominator );
-
- DBG_ASSERT(nSignificantBits<65, "More than 64 bit of significance is
overkill!");
-
- // How much bits can we lose?
- const int nMulBitsToLose = Max( ( impl_NumberOfBits( nMul ) - int(
nSignificantBits ) ), 0 );
- const int nDivBitsToLose = Max( ( impl_NumberOfBits( nDiv ) - int(
nSignificantBits ) ), 0 );
-
- const int nToLose = Min( nMulBitsToLose, nDivBitsToLose );
-
- // Remove the bits
- nMul >>= nToLose;
- nDiv >>= nToLose;
-
- if ( !nMul || !nDiv )
- {
- // Return without reduction
- DBG_ERROR( "Oops, we reduced too much..." );
- return;
- }
-
- // Reduce
- long n1 = GetGGT( nMul, nDiv );
- if ( n1 != 1 )
- {
- nMul /= n1;
- nDiv /= n1;
- }
-
- nNumerator = bNeg? -long( nMul ): long( nMul );
- nDenominator = nDiv;
+ if ( !nNumerator || !nDenominator )
+ return;
+
+ // Count with unsigned longs only
+ const bool bNeg = ( nNumerator < 0 );
+ unsigned long nMul = (unsigned long)( bNeg? -nNumerator: nNumerator );
+ unsigned long nDiv = (unsigned long)( nDenominator );
+
+ DBG_ASSERT(nSignificantBits<65, "More than 64 bit of significance is
overkill!");
+
+ // How much bits can we lose?
+ const int nMulBitsToLose = Max( ( impl_NumberOfBits( nMul ) - int(
nSignificantBits ) ), 0 );
+ const int nDivBitsToLose = Max( ( impl_NumberOfBits( nDiv ) - int(
nSignificantBits ) ), 0 );
+
+ const int nToLose = Min( nMulBitsToLose, nDivBitsToLose );
+
+ // Remove the bits
+ nMul >>= nToLose;
+ nDiv >>= nToLose;
+
+ if ( !nMul || !nDiv )
+ {
+ // Return without reduction
+ DBG_ERROR( "Oops, we reduced too much..." );
+ return;
+ }
+
+ // Reduce
+ long n1 = GetGGT( nMul, nDiv );
+ if ( n1 != 1 )
+ {
+ nMul /= n1;
+ nDiv /= n1;
+ }
+
+ nNumerator = bNeg? -long( nMul ): long( nMul );
+ nDenominator = nDiv;
}
/*************************************************************************
@@ -626,17 +624,17 @@ void Fraction::ReduceInaccurate( unsigned
nSignificantBits )
|*
|* Beschreibung FRACT.SDW
|* Ersterstellung DV 20.09.90
-|* Letzte Aenderung TH 19.08.92
+|* Letzte �nderung TH 19.08.92
|*
*************************************************************************/
sal_Bool operator == ( const Fraction& rVal1, const Fraction& rVal2 )
{
- if ( !rVal1.IsValid() || !rVal2.IsValid() )
- return sal_False;
+ if ( !rVal1.IsValid() || !rVal2.IsValid() )
+ return sal_False;
- return rVal1.nNumerator == rVal2.nNumerator
- && rVal1.nDenominator == rVal2.nDenominator;
+ return rVal1.nNumerator == rVal2.nNumerator
+ && rVal1.nDenominator == rVal2.nDenominator;
}
/*************************************************************************
@@ -645,28 +643,28 @@ sal_Bool operator == ( const Fraction& rVal1, const
Fraction& rVal2 )
|*
|* Beschreibung FRACT.SDW
|* Ersterstellung DV 20.09.90
-|* Letzte Aenderung DV 21.12.92
+|* Letzte �nderung DV 21.12.92
|*
*************************************************************************/
-// Beide Operanden werden zunaechst auf ihre Gueltigkeit ueberprueft und
-// anschliessend zur Sicherheit noch einmal gekuerzt. Um die Brueche
-// (a/b) und (c/d) zu vergleichen, werden sie zunaechst auf einen
-// gemeinsamen Nenner gebracht (b*d), um dann die beiden Zaehler (a*d)
+// Beide Operanden werden zun�chst auf ihre G�ltigkeit �berpr�ft und
+// anschlie�end zur Sicherheit noch einmal gek�rzt. Um die Br�che
+// (a/b) und (c/d) zu vergleichen, werden sie zun�chst auf einen
+// gemeinsamen Nenner gebracht (b*d), um dann die beiden Z�hler (a*d)
// und (c*b) zu vergleichen. Das Ergebnis dieses Vergleichs wird
-// zurueckgegeben.
+// zur�ckgegeben.
sal_Bool operator < ( const Fraction& rVal1, const Fraction& rVal2 )
{
- if ( !rVal1.IsValid() || !rVal2.IsValid() )
- return sal_False;
+ if ( !rVal1.IsValid() || !rVal2.IsValid() )
+ return sal_False;
- BigInt nN( rVal1.nNumerator );
- nN *= BigInt( rVal2.nDenominator );
- BigInt nD( rVal1.nDenominator );
- nD *= BigInt( rVal2.nNumerator );
+ BigInt nN( rVal1.nNumerator );
+ nN *= BigInt( rVal2.nDenominator );
+ BigInt nD( rVal1.nDenominator );
+ nD *= BigInt( rVal2.nNumerator );
- return nN < nD;
+ return nN < nD;
}
/*************************************************************************
@@ -675,28 +673,28 @@ sal_Bool operator < ( const Fraction& rVal1, const
Fraction& rVal2 )
|*
|* Beschreibung FRACT.SDW
|* Ersterstellung DV 20.09.90
-|* Letzte Aenderung TH 19.08.92
+|* Letzte �nderung TH 19.08.92
|*
*************************************************************************/
-// Beide Operanden werden zunaechst auf ihre Gueltigkeit ueberprueft und
-// anschliessend zur Sicherheit noch einmal gekuerzt. Um die Brueche
-// (a/b) und (c/d) zu vergleichen, werden sie zunaechst auf einen
-// gemeinsamen Nenner gebracht (b*d), um dann die beiden Zaehler (a*d)
+// Beide Operanden werden zun�chst auf ihre G�ltigkeit �berpr�ft und
+// anschlie�end zur Sicherheit noch einmal gek�rzt. Um die Br�che
+// (a/b) und (c/d) zu vergleichen, werden sie zun�chst auf einen
+// gemeinsamen Nenner gebracht (b*d), um dann die beiden Z�hler (a*d)
// und (c*b) zu vergleichen. Das Ergebnis dieses Vergleichs wird
-// zurueckgegeben.
+// zur�ckgegeben.
sal_Bool operator > ( const Fraction& rVal1, const Fraction& rVal2 )
{
- if ( !rVal1.IsValid() || !rVal2.IsValid() )
- return sal_False;
+ if ( !rVal1.IsValid() || !rVal2.IsValid() )
+ return sal_False;
- BigInt nN( rVal1.nNumerator );
- nN *= BigInt( rVal2.nDenominator );
- BigInt nD( rVal1.nDenominator);
- nD *= BigInt( rVal2.nNumerator );
+ BigInt nN( rVal1.nNumerator );
+ nN *= BigInt( rVal2.nDenominator );
+ BigInt nD( rVal1.nDenominator);
+ nD *= BigInt( rVal2.nNumerator );
- return nN > nD;
+ return nN > nD;
}
/*************************************************************************
@@ -705,7 +703,7 @@ sal_Bool operator > ( const Fraction& rVal1, const
Fraction& rVal2 )
|*
|* Beschreibung FRACT.SDW
|* Ersterstellung MM 08.01.96
-|* Letzte Aenderung MM 08.01.96
+|* Letzte �nderung MM 08.01.96
|*
*************************************************************************/
SvStream& operator >> ( SvStream& rIStream, Fraction& rFract )
@@ -721,7 +719,7 @@ SvStream& operator >> ( SvStream& rIStream, Fraction&
rFract )
|*
|* Beschreibung FRACT.SDW
|* Ersterstellung MM 08.01.96
-|* Letzte Aenderung MM 08.01.96
+|* Letzte �nderung MM 08.01.96
|*
*************************************************************************/
SvStream& operator << ( SvStream& rOStream, const Fraction& rFract )
@@ -730,3 +728,5 @@ SvStream& operator << ( SvStream& rOStream, const Fraction&
rFract )
rOStream << rFract.nDenominator;
return rOStream;
}
+
+/* vim: set noet sw=4 ts=4: */
