"

 COPYRIGHT (c) 1989 by Claus Gittinger

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libbasic' }"

Number subclass:#Fraction

	instanceVariableNames:'numerator denominator'

	classVariableNames:'FractionOne FractionZero PrintWholeNumbers'

	poolDictionaries:''

	category:'Magnitude-Numbers'

!

!Fraction class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1989 by Claus Gittinger

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    Instances of Fraction represent fractional numbers consisting of

    a numerator and denominator. Both are themselfes arbitrary precision

    integers. 

    Fractions are usually created by dividing Integers using / (for exact division).

    Notice, that all operations on fractions reduce their result; this means, that

    the result of a fraction-operation may return an integer.

    Aka:

        (1 / 7) * 7   ->  1  (not 0.99999999...)

    Mixed mode arithmetic:

        fraction op fraction    -> fraction/integer

        fraction op fix         -> fix; scale is fix's scale

        fraction op integer     -> fraction/integer

        fraction op float       -> float

    [classVariables:]

        PrintWholeNumbers       Booolean        experimental: 

                                                controls how fractions which are greater than 1 are printed.

                                                if true, print them as a sum of an integral and the fractional part. 

                                                (Large ones are easier to read this way)

                                                     (17/3) printString  -> '(5+(2/3))'  

                                                for now, the default is false, for backward compatibility

    [author:]

        Claus Gittinger

    [see also:]

        Number

        FixedPoint Float ShortFloat LongFloat Integer Complex

"

! !

!Fraction class methodsFor:'instance creation'!

new

    "create and return a new fraction with value 0"

    ^ self numerator:0 denominator:1

!

numerator:num denominator:den

    "create and return a new fraction with numerator num and denominator den"

    |newFraction|

%{  /* NOCONTEXT */

    /* this check allows subclassing .. */

    if (self == Fraction) {

        if (__bothSmallInteger(num, den)) {

            if (__CanDoQuickAlignedNew(sizeof(struct __Fraction))) {    /* OBJECT ALLOCATION */

                OBJ newFraction;

                int spc;

                INT iDen;

                __qCheckedAlignedNew(newFraction, sizeof(struct __Fraction));

                __InstPtr(newFraction)->o_class = self;

                __qSTORE(newFraction, self);

                iDen = __intVal(den);

                if (iDen != 0) {

                    if (iDen < 0) {

                        __FractionInstPtr(newFraction)->f_numerator = __MKSMALLINT(- __intVal(num));

                        __FractionInstPtr(newFraction)->f_denominator = __MKSMALLINT(- iDen);

                    } else {

                        __FractionInstPtr(newFraction)->f_numerator = num;

                        __FractionInstPtr(newFraction)->f_denominator = den;

                    }

                    if (num == __MKSMALLINT(1)) {

                        /* no need to reduce */

                        RETURN ( newFraction );

                    }

                }

            }

        }

    }

%}.

    den == 0 ifTrue:[

        ^ ZeroDivide raiseRequestWith:thisContext.

    ].

    newFraction isNil ifTrue:[

        newFraction := self basicNew setNumerator:num denominator:den.

    ].

    ^ newFraction reduced

    "

     Fraction numerator:1 denominator:3

     Fraction numerator:2 denominator:6

     Fraction numerator:1 denominator:0

     Fraction numerator:2 denominator:0

    "

! !

!Fraction class methodsFor:'class initialization'!

initialize

    FractionZero isNil ifTrue:[

        FractionZero := self numerator:0 denominator:1.

        FractionOne := self numerator:1 denominator:1

    ]

! !

!Fraction class methodsFor:'constants'!

pi

    "return the constant pi as Fraction"

    ^ self 

        numerator:  314159265358979323846264343

        denominator:100000000000000000000000000

"/    ^ self 

"/        numerator:  314159265358979323846264338327950288419716939937510582097494459

"/        denominator:100000000000000000000000000000000000000000000000000000000000000

    "

     Fraction pi         

     Fraction pi asFloat

     Float pi            

    "

    "Modified: 5.11.1996 / 11:11:44 / cg"

!

unity

    "return the neutral element for multiplication (1 / 1)"

    ^ FractionOne

    "Modified: 18.7.1996 / 12:26:06 / cg"

!

zero

    "return the neutral element for addition (0 / 1)"

    ^ FractionZero

    "Modified: 18.7.1996 / 12:26:12 / cg"

! !

!Fraction class methodsFor:'queries'!

isBuiltInClass

    "return true if this class is known by the run-time-system.

     Here, true is returned for myself, false for subclasses."

    ^ self == Fraction

    "Modified: 23.4.1996 / 15:59:10 / cg"

! !

!Fraction methodsFor:'accessing'!

denominator

    "return the denominator"

    ^ denominator

!

numerator

    "return the numerator"

    ^ numerator

! !

!Fraction methodsFor:'arithmetic'!

* aNumber

    "return the product of the receiver and the argument, aNumber"

    "/ notice:

    "/ the following code handles some common cases,

    "/ and exists as an optimization, to speed up those cases.

    "/ also notice, that checks for those cases must be inlinable without

    "/ a message send; otherwise double-dispatch is just as fast.

    "/

    "/ Conceptionally, (and for most other argument types),

    "/ mixed arithmetic is implemented by double dispatching

    "/ (see the message send at the bottom)

    (aNumber isMemberOf:SmallInteger) ifTrue:[

        ^ self class 

                numerator:(numerator * aNumber)

                denominator:denominator

    ].

    (aNumber isMemberOf:Float) ifTrue:[

        ^ (numerator * aNumber) / denominator

    ].

    ^ aNumber productFromFraction:self

    "Modified: 28.7.1997 / 19:09:23 / cg"

!

+ aNumber

    "return the sum of the receiver and the argument, aNumber"

    "/ notice:

    "/ the following code handles some common cases,

    "/ and exists as an optimization, to speed up those cases.

    "/ also notice, that checks for those cases must be inlinable without

    "/ a message send; otherwise double-dispatch is just as fast.

    "/

    "/ Conceptionally, (and for most other argument types),

    "/ mixed arithmetic is implemented by double dispatching

    "/ (see the message send at the bottom)

    (aNumber isMemberOf:SmallInteger) ifTrue:[

        ^ self class 

            numerator:(numerator + (denominator * aNumber))

            denominator:denominator

    ].

    (aNumber isMemberOf:Float) ifTrue:[

        ^ (numerator asFloat / denominator asFloat) + aNumber

    ].

    ^ aNumber sumFromFraction:self

    "Modified: 28.7.1997 / 19:09:16 / cg"

!

- aNumber

    "return the difference of the receiver and the argument, aNumber"

    "/ notice:

    "/ the following code handles some common cases,

    "/ and exists as an optimization, to speed up those cases.

    "/ also notice, that checks for those cases must be inlinable without

    "/ a message send; otherwise double-dispatch is just as fast.

    "/

    "/ Conceptionally, (and for most other argument types),

    "/ mixed arithmetic is implemented by double dispatching

    "/ (see the message send at the bottom)

    (aNumber isMemberOf:SmallInteger) ifTrue:[

        ^ self class 

                numerator:(numerator - (denominator * aNumber))

                denominator:denominator

    ].

    (aNumber isMemberOf:Float) ifTrue:[

        ^ (numerator asFloat / denominator asFloat) - aNumber

    ].

    ^ aNumber differenceFromFraction:self

    "

     (1/3) - (1/9)      

     (1/9) - (1/3)      

     (999/1000) - (1/1000)      

     (999/1000) - (1/1000000)      

     (999000/1000000) - (1/1000000)      

    "

    "Modified: 28.7.1997 / 19:09:11 / cg"

!

/ aNumber

    "return the quotient of the receiver and the argument, aNumber"

    "/ notice:

    "/ the following code handles some common cases,

    "/ and exists as an optimization, to speed up those cases.

    "/ also notice, that checks for those cases must be inlinable without

    "/ a message send; otherwise double-dispatch is just as fast.

    "/

    "/ Conceptionally, (and for most other argument types),

    "/ mixed arithmetic is implemented by double dispatching

    "/ (see the message send at the bottom)

    (aNumber isMemberOf:SmallInteger) ifTrue:[

        ^ self class 

                numerator:numerator

                denominator:(denominator * aNumber)

    ].

    (aNumber isMemberOf:Float) ifTrue:[

        ^ numerator / (denominator * aNumber)

    ].

    ^ aNumber quotientFromFraction:self

    "Modified: 28.7.1997 / 19:09:06 / cg"

!

// aNumber

    "return the integer quotient of dividing the receiver by aNumber with

     truncation towards negative infinity."

    ^ (numerator * aNumber denominator) // (denominator * aNumber numerator)

    "

     0.5 // 1

     -0.5 // 1

     (1/2) // 1  = 0 ifFalse:[self halt].

     (-1/2) // 1 = -1 ifFalse:[self halt].

    "

    "Modified: / 5.11.1996 / 11:47:14 / cg"

    "Modified: / 13.2.1998 / 09:15:35 / stefan"

!

negated

    "optional - could use inherited method ..."

    ^ self class 

        numerator:(numerator negated)

        denominator:denominator

    "Modified: 5.11.1996 / 10:29:11 / cg"

!

reciprocal

    "optional - could use inherited method ..."

    numerator == 1 ifTrue:[^ denominator].

    ^ self class 

        numerator:denominator

        denominator:numerator

    "Modified: 5.11.1996 / 10:29:22 / cg"

! !

!Fraction methodsFor:'coercing & converting'!

asFixedPoint

    "return the receiver as fixedPoint number.

     Q: what should the scale be here ?"

    ^ FixedPoint numerator:numerator denominator:denominator scale:2

    "

     (1/2) asFixedPoint

    "

    "Created: 5.11.1996 / 15:15:54 / cg"

!

asFixedPoint:scale

    "return the receiver as fixedPoint number, with the given number

     of post-decimal-point digits."

    ^ FixedPoint numerator:numerator denominator:denominator scale:scale

    "

     (1/2) asFixedPoint:2 

     (1/3) asFixedPoint:2 

     (1/3) asFixedPoint:5 

     (2/3) asFixedPoint:2 

     (2/3) asFixedPoint:5 

    "

    "Created: 5.11.1996 / 15:15:54 / cg"

    "Modified: 10.1.1997 / 19:54:50 / cg"

!

asFloat

    "return a float with (approximately) my value"

    |num den numShift denShift bits rslt|

    (numerator class == SmallInteger and:[denominator class == SmallInteger]) ifTrue:[

        ^ (numerator asFloat) / (denominator asFloat)

    ].

    "Do it the hard way: reduce magnitude and undo reduction on the quotient"

    bits := Float precision * 2.    "number of bits to preserve (conservative)"

    num := numerator abs.

    numShift := bits - num highBit. "(num highBit - bits) negated"

    numShift < 0 ifTrue:[num := num bitShift:numShift] ifFalse:[numShift := 0].

    den :=  denominator.

    denShift := bits - den highBit. "(den highBit - bits) negated"

    denShift < 0 ifTrue:[den := den bitShift:denShift] ifFalse:[denShift := 0].

    rslt := (num asFloat / den asFloat) * (2 raisedToInteger:denShift-numShift).

    numerator negative ifTrue:[ ^ rslt negated ].

    ^ rslt.

    " 

      (5/9) asFloat

      (-5/9) asFloat

      (500000000000/900000000000) asFloat

      (-500000000000/900000000000) asFloat

      (500000000000/9) asFloat

      (5/900000000000) asFloat

      89012345678901234567 asFloat / 123456789123456789 asFloat

      (89012345678901234567 / 123456789123456789) asFloat

      (

       180338700661043257034670206806167960222709397862806840937993331366591676308781197477183367018067356365812757479444845320188679437752013593674158587947149815441890236037219685250845721864713487208757788709113534916165172927384095182655935222723385253851776639985379367854545495930551624041981995105743408203125

        /

       180331613628627651967947866455016278082980736719853750685591387625058011528928110602436691256100991596843001549483950600930062886280582766771424470965440873615557144641435276844465734361353086032476712374317224249252177316815544331763696909434844464464323192083930469387098582956241443753242492675781250

      ) asFloat

      180338700661043257034670206806167960222709397862806840937993331366591676308781197477183367018067356365812757479444845320188679437752013593674158587947149815441890236037219685250845721864713487208757788709113534916165172927384095182655935222723385253851776639985379367854545495930551624041981995105743408203125

         asFloat /

      180331613628627651967947866455016278082980736719853750685591387625058011528928110602436691256100991596843001549483950600930062886280582766771424470965440873615557144641435276844465734361353086032476712374317224249252177316815544331763696909434844464464323192083930469387098582956241443753242492675781250

         asFloat

    "

!

asFraction

    "return the receiver as fraction - thats itself"

    ^ self

!

asInteger

    "return an integer with my value - will usually truncate"

    ^ numerator // denominator

!

asLargeFloat

    "return a large float with (approximately) my value"

    ^ (numerator asLargeFloat) / (denominator asLargeFloat)

    "

      (5/9) asLargeFloat

      (500000000000/900000000000) asLargeFloat

      (500000000000/9) asLargeFloat

    "

!

asLargeInteger

    "return an integer with my value - will usually truncate"

    ^ self asInteger asLargeInteger

!

asLongFloat

    "return a long float with (approximately) my value"

    |num den numShift denShift numBits rslt|

    (numerator class == SmallInteger and:[denominator class == SmallInteger]) ifTrue:[

        ^ (numerator asLongFloat) / (denominator asLongFloat)

    ].

    "Do it the hard way: reduce magnitude and undo reduction on the quotient"

    numBits := LongFloat precision * 2.    "number of bits to preserve (conservative)"

    num := numerator abs.

    numShift := numBits - num highBit. "(num highBit - bits) negated"

    numShift < 0 ifTrue:[

        num := num bitShift:numShift

    ] ifFalse:[

        numShift := 0