"

 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' }"

"{ NameSpace: Smalltalk }"

Number subclass:#Fraction

	instanceVariableNames:'numerator denominator'

	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       Boolean        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.

     Notice: stc inlines this message if sent to the global named Fraction."

    |newFraction|

%{  /* NOCONTEXT */

#ifdef __SCHTEAM__

    if (self == Fraction.Class) {

	return context._RETURN(new STFraction(num, den));

    }

#else

    /* this check allows subclassing .. */

    if (self == Fraction) {

	if (__bothSmallInteger(num, den)) {

	    if (den != __mkSmallInteger(0)) {

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

		    OBJ newFraction;

		    INT iDen;

		    INT iNum;

		    __qCheckedNew(newFraction, sizeof(struct __Fraction));

		    __InstPtr(newFraction)->o_class = self;

		    __qSTORE(newFraction, self);

		    iDen = __intVal(den);

		    iNum = __intVal(num);

		    if (iDen < 0) {

			iNum = -iNum;

			iDen = -iDen;

		    }

		    while ( (((iNum | iDen) & 1) == 0) && ( iNum != 0) && ( iDen != 0)) {

			/* both even and non-zero */

			iNum = iNum >> 1;

			iDen = iDen >> 1;

		    }

		    if (iNum >= _MAX_INT) {

			__FractionInstPtr(newFraction)->f_numerator = __MKINT(iNum);

		    } else {

			__FractionInstPtr(newFraction)->f_numerator = __MKSMALLINT(iNum);

		    }

		    if (iDen >= _MAX_INT) {

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

		    } else {

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

		    }

		    if (iNum == 1) {

			/* no need to reduce */

			RETURN ( newFraction );

		    }

		}

	    }

	}

    }

#endif /* not __SCHTEAM__ */

%}.

    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:3

     Fraction numerator:2 denominator:6

     Fraction numerator:1 denominator:0  -> error

     Fraction numerator:2 denominator:0  -> error

     Fraction numerator:5 denominator:10

     Fraction numerator:50 denominator:100

     Fraction numerator:8 denominator:16

    "

    "Modified: / 27-02-2016 / 00:25:47 / cg"

!

readDecimalFractionFrom:aStringOrStream onError:exceptionBlock

    "Read an arbitrary number (>0) of digits representing a decimal fraction."

    |anyDigit factor fraction s ch|

    s := aStringOrStream isStream ifTrue:[aStringOrStream] ifFalse:[aStringOrStream readStream].

    factor := (1 / 10).

    fraction := 0.

    anyDigit := false.

    [

	ch := s peekOrNil.

	ch notNil and:[ch isDigit].

    ] whileTrue: [

	s next.

	anyDigit := true.

	fraction := (ch digitValue) * factor + fraction.

	factor := (factor / 10).

    ].

    anyDigit ifFalse: [^ exceptionBlock valueWithOptionalArgument: 'Missing digits in fraction'].

    ^ fraction

    "

     Fraction readDecimalFractionFrom:'1'   onError:[nil]     -> 0.1

     Fraction readDecimalFractionFrom:'123' onError:[nil]     -> 0.123

     Fraction readDecimalFractionFrom:'5'   onError:[nil]     -> 0.5

     Fraction readDecimalFractionFrom:'005' onError:[nil]     -> 0.005

     Fraction readDecimalFractionFrom:''    onError:[nil]     -> nil

     Fraction readDecimalFractionFrom:'aa'  onError:[nil]     -> nil

    "

!

readFrom:aStringOrStream onError:exceptionBlock

    |s numerator denominator|

    "/ sigh - care for subclasses...

    self == Fraction ifFalse:[

	^ super readFrom:aStringOrStream onError:exceptionBlock

    ].

    s := aStringOrStream readStream.

    s skipSeparators.

    s peekOrNil == $( ifTrue:[

	s next.

    ].

    numerator := super readFrom:s onError:[^ exceptionBlock value].

    numerator isInteger ifTrue:[

	s skipSeparators.

	(s peekOrNil == $/) ifTrue:[

	    s next.

	    denominator := Integer readFrom:s onError:[^ exceptionBlock value].

	    ^ self numerator:numerator denominator:denominator

	].

	^ numerator

    ].

    ^ numerator asFraction

    "

     Fraction readFrom:'1'

     Fraction readFrom:'2'

     Fraction readFrom:'1.5'

     Fraction readFrom:'1/5'

    "

! !

!Fraction class methodsFor:'class initialization'!

initialize

    FractionZero isNil ifTrue:[

	FractionZero := self numerator:0 denominator:1.

	FractionOne := self numerator:1 denominator:1

    ]

! !

!Fraction class methodsFor:'coercing & converting'!

coerce:aNumber

    "convert the argument aNumber into an instance of the receiver's class and return it."

    ^ aNumber asFraction

! !

!Fraction class methodsFor:'constants'!

pi

    "return an approximation of the constant pi as Fraction.

     The approx. returned here has an error smaller than representable by float instances"

    "

     Fraction pi

     Fraction pi asFloat - Float pi

     Fraction pi asLongFloat - LongFloat pi

     Float pi

    "

!

pi1000

    "return an approximation of the constant pi as Fraction (1024 decimal digits)."

    ].

    "

     Fraction pi1000

     Fraction pi1000 asLongFloat - LongFloat pi

     LongFloat pi

    "

!

pi_approximation

    "return an approximation of the constant pi as Fraction.

     The approx. returned is good for 6 valid digits and has an error of less than -2.67-07.

     The value might be useful to avoid floating point numbers in graphic rendering code,

     where 6 digits of precision are usually good enough."

    ^ self

    "

     Fraction pi

     Fraction pi asFloat

    "

!

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."

    "/ 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].