The Trunk: Kernel-nice.1168.mcz

Nicolas Cellier uploaded a new version of Kernel to project The Trunk:
http://source.squeak.org/trunk/Kernel-nice.1168.mcz

==================== Summary ====================

Name: Kernel-nice.1168
Author: nice
Time: 26 April 2018, 11:40:17.923908 am
UUID: fa008d75-249a-b243-8b1e-068eeb72a45d
Ancestors: Kernel-nice.1167

Change asApproximateFraction to allow prescribing a relative decimal precision

Example:
        (FloatArray with: 1/3) first
                asApproximateFractionRelativeDecimalPlaces: 6.
        0.6667 asApproximateFractionRelativeDecimalPlaces: 3.
        0.6667 asApproximateFractionRelativeDecimalPlaces: 5.

=============== Diff against Kernel-nice.1167 ===============

Item was changed:
  ----- Method: Float>>asApproximateFraction (in category 'converting') -----
  asApproximateFraction
  "Answer a Fraction approximating the receiver. This conversion uses the
  continued fraction method to approximate a floating point number."
 
+ ^ self asApproximateFractionRelativeDecimalPlaces: 10!
- ^ self asApproximateFractionAtOrder: 0!

Item was changed:
  ----- Method: Float>>asApproximateFractionAtOrder: (in category 'converting') -----
  asApproximateFractionAtOrder: maxOrder
  "Answer a Fraction approximating the receiver. This conversion uses the
  continued fraction method to approximate a floating point number. If maxOrder
  is zero, use maximum order"
 
+ ^self
+ asApproximateFractionAtOrder: maxOrder
+ precision: self ulp / 2!
- | num1 denom1 num2 denom2 int frac newD temp order |
- num1 := self asInteger. "The first of two alternating numerators"
- denom1 := 1. "The first of two alternating denominators"
- num2 := 1. "The second numerator"
- denom2 := 0. "The second denominator--will update"
- int := num1. "The integer part of self"
- frac := self fractionPart. "The fractional part of self"
- order := maxOrder = 0 ifTrue: [-1] ifFalse: [maxOrder].
- [frac = 0 or: [order = 0] ]
- whileFalse:
- ["repeat while the fractional part is not zero and max order is not reached"
- order := order - 1.
- newD := 1.0 / frac. "Take reciprocal of the fractional part"
- int := newD asInteger. "get the integer part of this"
- frac := newD fractionPart. "and save the fractional part for next time"
- temp := num2. "Get old numerator and save it"
- num2 := num1. "Set second numerator to first"
- num1 := num1 * int + temp. "Update first numerator"
- temp := denom2. "Get old denominator and save it"
- denom2 := denom1. "Set second denominator to first"
- denom1 := int * denom1 + temp. "Update first denominator"
- 10000000000.0 < denom1
- ifTrue:
- ["Is ratio past float precision?  If so, pick which
- of the two ratios to use"
- num2 = 0.0
- ifTrue: ["Is second denominator 0?"
- ^ Fraction numerator: num1 denominator: denom1].
- ^ Fraction numerator: num2 denominator: denom2]].
- "If fractional part is zero, return the first ratio"
- denom1 = 1
- ifTrue: ["Am I really an Integer?"
- ^ num1 "Yes, return Integer result"]
- ifFalse: ["Otherwise return Fraction result"
- ^ Fraction numerator: num1 denominator: denom1]!

Item was added:
+ ----- Method: Float>>asApproximateFractionAtOrder:precision: (in category 'converting') -----
+ asApproximateFractionAtOrder: maxOrder precision: limit
+ "Answer a Rational number--Integer or Fraction--representing the receiver.
+ This conversion uses the continued fraction method to approximate a floating point number.
+ The iteration stops when precision has reached the prescribed limit,
+ or when the maximum number of iterations has been reached.
+ If maxOrder is zero, then the number of iterations is not limited."
+
+ | num1 denom1 num2 denom2 int frac newD order |
+ newD := self asFraction. "use exact arithmetic to avoid both overflow and accumulation of rounding errors"
+ num1 := denom2 := 1. "Initialize alternating numerators"
+ num2 := denom1 := 0. "and denominators"
+ order := maxOrder = 0 ifTrue: [-1] ifFalse: [maxOrder].
+ [int := newD integerPart. "get the integer part of this"
+ frac := newD fractionPart. "and save the fractional part for next time"
+ num1 := num2 + ((num2 := num1) * int). "Update numerators"
+ denom1 := denom2 + ((denom2 := denom1) * int). "and denominators"
+ frac = 0
+ or: [order = 0
+ or: [((Fraction numerator: num1 denominator: denom1) - self) abs <= limit]]]
+ whileFalse:
+ [newD := frac reciprocal "Take reciprocal of the fractional part".
+ order := order - 1].
+ ^denom1 = 1
+ ifTrue: ["Am i really an Integer?"
+ num1"Yes, return Integer result"]
+ ifFalse: ["Otherwise return Fraction result"
+ Fraction numerator: num1 denominator: denom1]!

Item was added:
+ ----- Method: Float>>asApproximateFractionRelativeDecimalPlaces: (in category 'converting') -----
+ asApproximateFractionRelativeDecimalPlaces: decimalPlaces
+ "Answer a Fraction approximating the receiver. This conversion uses the
+ continued fraction method to approximate a floating point number.
+ Stop the recursion when precision has reached prescribed number of relative decimalPlaces."
+
+ ^ self
+ asApproximateFractionAtOrder: 0
+ precision: (1.0 timesTwoPower: self exponent - (decimalPlaces * Ln10 / Ln2) rounded)!