Squeak-dev September 2011

squeak-dev@lists.squeakfoundation.org

64 participants
208 discussions

New programming fonts
by I3 Project 26 Sep '11

26 Sep '11

Although Smalltalk environments traditionally use variable width fonts, people are sometimes motivated to switch to a monospaced font. When I look at the reasons, I think it is mostly because the variable width fonts we have were not specifically designed for showing code. As an experiment, I made a set of proportional fonts that incorporate the design features we expect in a programming font. There are both bitmap and vector fonts. Note especially that the spacing is adjusted so you don't have to use tabs for indentation. This means you can write code that looks good with either a monospaced or proportional font. All the fonts are release to the public domain (via the Unlicense) and can be found at http://code.google.com/p/i3project/wiki/Fonts.

2 1

The Inbox: Kernel-nice.631.mcz
by commits＠source.squeak.org 26 Sep '11

26 Sep '11

A new version of Kernel was added to project The Inbox: http://source.squeak.org/inbox/Kernel-nice.631.mcz ==================== Summary ==================== Name: Kernel-nice.631 Author: nice Time: 26 September 2011, 11:16:10.34 pm UUID: 54730a61-b8b5-4e3f-9066-d90e018f15a6 Ancestors: Kernel-nice.630 Sorry, previous asFloat was not the fastest in COG. COG seems to perform some primitives like bitShift: slowly, while it is much faster with some others like digitAt: So let's use digitAt:. =============== Diff against Kernel-nice.630 =============== Item was changed: ----- Method: LargePositiveInteger>>asFloat (in category 'converting') ----- asFloat "Answer a Float that best approximates the value of the receiver. This algorithm is optimized to process only the significant digits of a LargeInteger. And it does honour IEEE 754 round to nearest even mode in case of excess precision (see details below)." "How numbers are rounded in IEEE 754 default rounding mode: A shift is applied so that the highest 53 bits are placed before the floating point to form a mantissa. The trailing bits form the fraction part placed after the floating point. This fractional number must be rounded to the nearest integer. If fraction part is 2r0.1, exactly between two consecutive integers, there is a tie. The nearest even integer is chosen in this case. Examples (First 52bits of mantissa are omitted for brevity): 2r0.00001 is rounded downward to 2r0 2r1.00001 is rounded downward to 2r1 2r0.1 is a tie and rounded to 2r0 (nearest even) 2r1.1 is a tie and rounded to 2r10 (nearest even) 2r0.10001 is rounded upward to 2r1 2r1.10001 is rounded upward to 2r10 Thus, if the next bit after floating point is 0, the mantissa is left unchanged. If next bit after floating point is 1, an odd mantissa is always rounded upper. An even mantissa is rounded upper only if the fraction part is not a tie." "Algorihm details: + The floating point hardware can perform the rounding correctly with several excess bits as long as there is a single inexact operation. + This can be obtained by splitting the mantissa plus excess bits in two part with less bits than Float precision. + Note 1: the inexact flag in floating point hardware must not be trusted because in some cases the operations would be exact but would not take into account some bits that were truncated before the Floating point operations. - Floating point hardware will correctly handle the rounding by itself if there is a single inexact operation. - Except in the last case when extra bits are present after an even mantissa, we must round upper by ourselves. - Note 1: the inexact flag in floating point hardware must not be trusted because it won't take into account the bits we truncated by ourselves. Note 2: the floating point hardware is presumed configured in default rounding mode." + | mantissa shift excess high low | - | mantissa shift excess | "Check how many bits excess the maximum precision of a Float mantissa." excess := self highBitOfMagnitude - Float precision. excess > 7 ifTrue: + ["Remove the excess bits but seven." - ["Remove the excess bits but seven. - Float precision + 7 = 60 bits = 2 * length of positive small integer" mantissa := self bitShiftMagnitude: 7 - excess. shift := excess - 7. + "An even mantissa with a single excess bit immediately following would be truncated. + But this would not be correct if above shift has truncated some extra bits. + Check this case, and round excess bits upper manually." - "Handle the case of extra bits truncated after an even mantissa." ((mantissa digitAt: 1) = 2r01000000 and: [self anyBitOfMagnitudeFrom: 1 to: shift]) ifTrue: [mantissa := mantissa + 1]] ifFalse: [mantissa := self. shift := 0]. + "Combine two Floats with a single inexact round off" + low := (mantissa digitAt: 1) asFloat timesTwoPower: shift. + 2 to: 4 do: [:i |. + low := low + ((mantissa digitAt: i) asFloat timesTwoPower: (shift := shift + 8))]. + high := (mantissa digitAt: 5) asFloat timesTwoPower: (shift := shift + 8). + 6 to: mantissa digitLength do: [:i | + high := high + ((mantissa digitAt: i) asFloat timesTwoPower: (shift := shift + 8)).]. + ^high + low! - "Combine two small integers (SmallInteger maxVale highBit = 30 bits) asFloat with a single inexact round off" - ^(((mantissa bitShiftMagnitude: -30) asFloat timesTwoPower: 30) - + (mantissa bitAnd: 16r3FFFFFFF "SmallInteger maxVal")) - timesTwoPower: shift!

1 0

The Inbox: Kernel-nice.630.mcz
by commits＠source.squeak.org 26 Sep '11

26 Sep '11

A new version of Kernel was added to project The Inbox: http://source.squeak.org/inbox/Kernel-nice.630.mcz ==================== Summary ==================== Name: Kernel-nice.630 Author: nice Time: 26 September 2011, 10:20:03.656 pm UUID: 741a02d5-c9f3-4549-8013-a77ffe1305b1 Ancestors: Kernel-nice.629 With the help of Andres remarks, and a bit of magic (7 and 30), here is an ever faster LargeInteger>>asFloat. Non portable to other precision than double, but cute. =============== Diff against Kernel-nice.629 =============== Item was changed: ----- Method: LargePositiveInteger>>asFloat (in category 'converting') ----- asFloat "Answer a Float that best approximates the value of the receiver. This algorithm is optimized to process only the significant digits of a LargeInteger. And it does honour IEEE 754 round to nearest even mode in case of excess precision (see details below)." "How numbers are rounded in IEEE 754 default rounding mode: A shift is applied so that the highest 53 bits are placed before the floating point to form a mantissa. The trailing bits form the fraction part placed after the floating point. This fractional number must be rounded to the nearest integer. If fraction part is 2r0.1, exactly between two consecutive integers, there is a tie. The nearest even integer is chosen in this case. Examples (First 52bits of mantissa are omitted for brevity): 2r0.00001 is rounded downward to 2r0 2r1.00001 is rounded downward to 2r1 2r0.1 is a tie and rounded to 2r0 (nearest even) 2r1.1 is a tie and rounded to 2r10 (nearest even) 2r0.10001 is rounded upward to 2r1 2r1.10001 is rounded upward to 2r10 Thus, if the next bit after floating point is 0, the mantissa is left unchanged. If next bit after floating point is 1, an odd mantissa is always rounded upper. An even mantissa is rounded upper only if the fraction part is not a tie." "Algorihm details: + Floating point hardware will correctly handle the rounding by itself if there is a single inexact operation. - Floating point hardware will correctly handle the rounding by itself with a single inexact operation if mantissa has one excess bit of precision. Except in the last case when extra bits are present after an even mantissa, we must round upper by ourselves. Note 1: the inexact flag in floating point hardware must not be trusted because it won't take into account the bits we truncated by ourselves. Note 2: the floating point hardware is presumed configured in default rounding mode." + | mantissa shift excess | - | mantissa shift sum excess | "Check how many bits excess the maximum precision of a Float mantissa." excess := self highBitOfMagnitude - Float precision. + excess > 7 - excess > 1 ifTrue: + ["Remove the excess bits but seven. + Float precision + 7 = 60 bits = 2 * length of positive small integer" + mantissa := self bitShiftMagnitude: 7 - excess. + shift := excess - 7. - ["Remove the excess bits but one." - mantissa := self bitShift: 1 - excess. - shift := excess - 1. "Handle the case of extra bits truncated after an even mantissa." + ((mantissa digitAt: 1) = 2r01000000 and: [self anyBitOfMagnitudeFrom: 1 to: shift]) - ((mantissa bitAnd: 2r11) = 2r01 and: [self anyBitOfMagnitudeFrom: 1 to: shift]) ifTrue: [mantissa := mantissa + 1]] ifFalse: [mantissa := self. shift := 0]. + "Combine two small integers (SmallInteger maxVale highBit = 30 bits) asFloat with a single inexact round off" + ^(((mantissa bitShiftMagnitude: -30) asFloat timesTwoPower: 30) + + (mantissa bitAnd: 16r3FFFFFFF "SmallInteger maxVal")) + timesTwoPower: shift! - "Now that mantissa has at most 1 excess bit of precision, let floating point operations perform the final rounding." - sum := 0.0. - 1 to: mantissa digitLength do: - [:byteIndex | - sum := sum + ((mantissa digitAt: byteIndex) asFloat timesTwoPower: shift). - shift := shift + 8]. - ^sum!

1 0

The Trunk: Kernel-nice.629.mcz
by commits＠source.squeak.org 26 Sep '11

26 Sep '11

Nicolas Cellier uploaded a new version of Kernel to project The Trunk: http://source.squeak.org/trunk/Kernel-nice.629.mcz ==================== Summary ==================== Name: Kernel-nice.629 Author: nice Time: 26 September 2011, 9:26:30.229 pm UUID: efcd1a80-4b32-4ccf-bdb7-8548ec1f040b Ancestors: Kernel-nice.628 Define and use #highBitOfByte when we know we operate on byte boundary. And, oups, remove ===> which crept in trunk (was solely for testing speed). =============== Diff against Kernel-nice.628 =============== Item was removed: - ----- Method: Boolean>>===> (in category 'logical operations') ----- - ===> aBlock - "this is material implication, a ==> b, also known as: - b if a - a implies b - if a then b - b is a consequence of a - a therefore b (but note: 'it is raining therefore it is cloudy' is implication; 'it is autumn therefore the leaves are falling' is equivalence). - - Here is the truth table for material implication (view in a monospaced font): - - p | q | p ==> q - -------|-------|------------- - T | T | T - T | F | F - F | T | T - F | F | T - " - - ^self not or: [aBlock value]! Item was changed: ----- Method: Integer>>digitDiv:neg: (in category 'private') ----- digitDiv: arg neg: ng "Answer with an array of (quotient, remainder)." | quo rem ql d div dh dnh dl qhi qlo j l hi lo r3 a t | <primitive: 'primDigitDivNegative' module:'LargeIntegers'> arg = 0 ifTrue: [^ (ZeroDivide dividend: self) signal]. "TFEI added this line" l := self digitLength - arg digitLength + 1. l <= 0 ifTrue: [^ Array with: 0 with: self]. "shortcut against #highBit" + d := 8 - arg lastDigit highBitOfByte. - d := 8 - arg lastDigit highBitOfPositiveReceiver. div := arg digitLshift: d. div := div growto: div digitLength + 1. "shifts so high order word is >=128" rem := self digitLshift: d. rem digitLength = self digitLength ifTrue: [rem := rem growto: self digitLength + 1]. "makes a copy and shifts" quo := Integer new: l neg: ng. dl := div digitLength - 1. "Last actual byte of data" ql := l. dh := div digitAt: dl. dnh := dl = 1 ifTrue: [0] ifFalse: [div digitAt: dl - 1]. 1 to: ql do: [:k | "maintain quo*arg+rem=self" "Estimate rem/div by dividing the leading to bytes of rem by dh." "The estimate is q = qhi*16+qlo, where qhi and qlo are nibbles." j := rem digitLength + 1 - k. "r1 := rem digitAt: j." (rem digitAt: j) = dh ifTrue: [qhi := qlo := 15 "i.e. q=255"] ifFalse: ["Compute q = (r1,r2)//dh, t = (r1,r2)\\dh. Note that r1,r2 are bytes, not nibbles. Be careful not to generate intermediate results exceeding 13 bits." "r2 := (rem digitAt: j - 1)." t := ((rem digitAt: j) bitShift: 4) + ((rem digitAt: j - 1) bitShift: -4). qhi := t // dh. t := (t \\ dh bitShift: 4) + ((rem digitAt: j - 1) bitAnd: 15). qlo := t // dh. t := t \\ dh. "Next compute (hi,lo) := q*dnh" hi := qhi * dnh. lo := qlo * dnh + ((hi bitAnd: 15) bitShift: 4). hi := (hi bitShift: -4) + (lo bitShift: -8). lo := lo bitAnd: 255. "Correct overestimate of q. Max of 2 iterations through loop -- see Knuth vol. 2" r3 := j < 3 ifTrue: [0] ifFalse: [rem digitAt: j - 2]. [(t < hi or: [t = hi and: [r3 < lo]]) and: ["i.e. (t,r3) < (hi,lo)" qlo := qlo - 1. lo := lo - dnh. lo < 0 ifTrue: [hi := hi - 1. lo := lo + 256]. hi >= dh]] whileTrue: [hi := hi - dh]. qlo < 0 ifTrue: [qhi := qhi - 1. qlo := qlo + 16]]. "Subtract q*div from rem" l := j - dl. a := 0. 1 to: div digitLength do: [:i | hi := (div digitAt: i) * qhi. lo := a + (rem digitAt: l) - ((hi bitAnd: 15) bitShift: 4) - ((div digitAt: i) * qlo). rem digitAt: l put: lo - (lo // 256 * 256). "sign-tolerant form of (lo bitAnd: 255)" a := lo // 256 - (hi bitShift: -4). l := l + 1]. a < 0 ifTrue: ["Add div back into rem, decrease q by 1" qlo := qlo - 1. l := j - dl. a := 0. 1 to: div digitLength do: [:i | a := (a bitShift: -8) + (rem digitAt: l) + (div digitAt: i). rem digitAt: l put: (a bitAnd: 255). l := l + 1]]. quo digitAt: quo digitLength + 1 - k put: (qhi bitShift: 4) + qlo]. rem := rem digitRshift: d bytes: 0 lookfirst: dl. ^ Array with: quo with: rem! Item was changed: ----- Method: LargePositiveInteger>>highBitOfMagnitude (in category 'bit manipulation') ----- highBitOfMagnitude "Answer the index of the high order bit of the magnitude of the receiver, or zero if the receiver is zero. This method is used for LargeNegativeIntegers as well, since Squeak's LargeIntegers are sign/magnitude." | realLength lastDigit | realLength := self digitLength. [(lastDigit := self digitAt: realLength) = 0] whileTrue: [(realLength := realLength - 1) = 0 ifTrue: [^ 0]]. + ^ lastDigit highBitOfByte + (8 * (realLength - 1))! - ^ lastDigit highBitOfPositiveReceiver + (8 * (realLength - 1))! Item was added: + ----- Method: SmallInteger>>highBitOfByte (in category 'private') ----- + highBitOfByte + "The high bits table can be obtained with: + (1 to: 8) inject: #[0] into: [:highBits :rank | highBits , (highBits collect: [:e | rank])]." + ^ #[0 1 2 2 3 3 3 3 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8] at: self + 1! Item was changed: ----- Method: SmallInteger>>highBitOfPositiveReceiver (in category 'private') ----- highBitOfPositiveReceiver | shifted bitNo | "Answer the index of the high order bit of the receiver, or zero if the receiver is zero. Receiver has to be positive!!" shifted := self. bitNo := 0. [shifted < 65536] whileFalse: [shifted := shifted bitShift: -16. bitNo := bitNo + 16]. shifted < 256 ifFalse: [shifted := shifted bitShift: -8. bitNo := bitNo + 8]. + ^bitNo + shifted highBitOfByte! - - "The high bits table can be obtained with: - (1 to: 8) inject: #[0] into: [:highBits :rank | highBits , (highBits collect: [:e | rank])]." - ^bitNo + ( #[0 1 2 2 3 3 3 3 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8] at: shifted + 1)!

1 0

The Trunk: Kernel-nice.628.mcz
by commits＠source.squeak.org 26 Sep '11

26 Sep '11

Nicolas Cellier uploaded a new version of Kernel to project The Trunk: http://source.squeak.org/trunk/Kernel-nice.628.mcz ==================== Summary ==================== Name: Kernel-nice.628 Author: nice Time: 26 September 2011, 9:10:09.363 pm UUID: 9c77ee63-103f-4577-b987-5ee0f539d582 Ancestors: Kernel-nice.627 Boolean subclasses know better how to behave, so if we delegate ==> , we can implement a branch-less implication. Though I wonder if this is really an optimization in case of a JIT VM... { [true ==> [1 > 2]] bench. [false ==> [1 > 2]] bench. } #( '6,440,000 per second.' '6,690,000 per second.') "BEFORE" #( '6,410,000 per second.' '7,030,000 per second.') "AFTER" =============== Diff against Kernel-nice.627 =============== Item was added: + ----- Method: Boolean>>===> (in category 'logical operations') ----- + ===> aBlock + "this is material implication, a ==> b, also known as: + b if a + a implies b + if a then b + b is a consequence of a + a therefore b (but note: 'it is raining therefore it is cloudy' is implication; 'it is autumn therefore the leaves are falling' is equivalence). + + Here is the truth table for material implication (view in a monospaced font): + + p | q | p ==> q + -------|-------|------------- + T | T | T + T | F | F + F | T | T + F | F | T + " + + ^self not or: [aBlock value]! Item was changed: ----- Method: Boolean>>==> (in category 'logical operations') ----- ==> aBlock "this is material implication, a ==> b, also known as: b if a a implies b if a then b b is a consequence of a a therefore b (but note: 'it is raining therefore it is cloudy' is implication; 'it is autumn therefore the leaves are falling' is equivalence). Here is the truth table for material implication (view in a monospaced font): p | q | p ==> q -------|-------|------------- T | T | T T | F | F F | T | T F | F | T " + self subclassResponsibility! - ^self not or: [aBlock value]! Item was added: + ----- Method: False>>==> (in category 'logical operations') ----- + ==> aBlock + ^true! Item was added: + ----- Method: True>>==> (in category 'logical operations') ----- + ==> aBlock + ^aBlock value!

1 0

Daily Commit Log
by commits＠source.squeak.org 26 Sep '11

26 Sep '11

Changes to Trunk (http://source.squeak.org/trunk.html) in the last 24 hours: http://lists.squeakfoundation.org/pipermail/packages/2011-September/004991.… Name: Kernel-nice.627 Ancestors: Kernel-ul.626 Improve Fraction and Integer asFloat by: - removing unreachable branch - removing un-needed arithmetic - renaming temps - using Float precision explicitly rather than hardcoded magical numbers - clarifying comments The resulting code shall be clearer and a bit faster than previously. =============================================

1 0

Re: [squeak-dev] The Trunk: Kernel-nice.627.mcz
by Frank Shearar 25 Sep '11

25 Sep '11

With the proviso that I'm nowhere near an expert on numerics, the code looks a lot cleaner, and the removal of magic numbers improves readability. My sole nit is that you loose an arrow (or pack of hounds), but you lose bits. The exec summary of most of the changeset is making Integer >> asFloat be subclassResponsibility. The functionality moves to LargePositiveInteger >> asFloat. LargeNegativeInteger delegates to LargePositiveInteger, and SmallInteger uses primitive 40. frank On 25 September 2011 11:56, <commits(a)source.squeak.org> wrote: > Nicolas Cellier uploaded a new version of Kernel to project The Trunk: > http://source.squeak.org/trunk/Kernel-nice.627.mcz > > ==================== Summary ==================== > > Name: Kernel-nice.627 > Author: nice > Time: 25 September 2011, 12:55:51.623 pm > UUID: c09ead19-3aa6-482b-b2cc-f6549bc67eb6 > Ancestors: Kernel-ul.626 > > Improve Fraction and Integer asFloat by: > - removing unreachable branch > - removing un-needed arithmetic > - renaming temps > - using Float precision explicitly rather than hardcoded magical numbers > - clarifying comments > The resulting code shall be clearer and a bit faster than previously. > > =============== Diff against Kernel-ul.626 =============== > > Item was changed: > ----- Method: Fraction>>asFloat (in category 'converting') ----- > asFloat > "Answer a Float that closely approximates the value of the receiver. > + This implementation will answer the closest floating point number to the receiver. > + In case of a tie, it will use the IEEE 754 round to nearest even mode. > + In case of overflow, it will answer +/- Float infinity." > + > + | a b mantissa exponent hasTruncatedBits lostBit n ha hb hm | > - This implementation will answer the closest floating point number to > - the receiver. > - It uses the IEEE 754 round to nearest even mode > - (can happen in case denominator is a power of two)" > - > - | a b q r exponent floatExponent n ha hb hq q1 | > a := numerator abs. > + b := denominator. "denominator is always positive" > - b := denominator abs. > ha := a highBit. > hb := b highBit. > > + "Number of bits to keep in mantissa plus one to handle rounding." > + n := 1 + Float precision. > + > "If both numerator and denominator are represented exactly in floating point number, > + then fastest thing to do is to use hardwired float division." > + (ha < n and: [hb < n]) ifTrue: [^numerator asFloat / denominator asFloat]. > + > + "Shift the fraction by a power of two exponent so as to obtain a mantissa with n bits. > + First guess is rough, the mantissa might have n+1 bits." > + exponent := ha - hb - n. > + exponent >= 0 > - then fastest thing to do is to use hardwired float division" > - (ha < 54 and: [hb < 54]) ifTrue: [^numerator asFloat / denominator asFloat]. > - > - "Try and obtain a mantissa with 54 bits. > - First guess is rough, we might get one more bit or one less" > - exponent := ha - hb - 54. > - exponent > 0 > ifTrue: [b := b bitShift: exponent] > ifFalse: [a := a bitShift: exponent negated]. > + mantissa := a quo: b. > + hasTruncatedBits := a > (mantissa * b). > + hm := mantissa highBit. > - q := a quo: b. > - r := a - (q * b). > - hq := q highBit. > > + "Check for gradual underflow, in which case the mantissa will loose bits. > + Keep at least one bit to let underflow preserve the sign of zero." > + lostBit := Float emin - (exponent + hm - 1). > + lostBit > 0 ifTrue: [n := n - lostBit max: 1]. > + > + "Remove excess bits in the mantissa." > + hm > n > + ifTrue: > + [exponent := exponent + hm - n. > + hasTruncatedBits := hasTruncatedBits or: [mantissa anyBitOfMagnitudeFrom: 1 to: hm - n]. > + mantissa := mantissa bitShift: n - hm]. > + > + "Check if mantissa must be rounded upward. > + The case of tie (mantissa odd & hasTruncatedBits not) > + will be handled by Integer>>asFloat." > + (hasTruncatedBits and: [mantissa odd]) > + ifTrue: [mantissa := mantissa + 1]. > + > - "check for gradual underflow, in which case we should use less bits" > - floatExponent := exponent + hq - 1. > - n := floatExponent > -1023 > - ifTrue: [54] > - ifFalse: [54 + floatExponent + 1022]. > - > - hq > n > - ifTrue: [exponent := exponent + hq - n. > - r := (q bitAnd: (1 bitShift: hq - n) - 1) * b + r. > - q := q bitShift: n - hq]. > - hq < n > - ifTrue: [exponent := exponent + hq - n. > - q1 := (r bitShift: n - hq) quo: b. > - q := (q bitShift: n - hq) bitAnd: q1. > - r := (r bitShift: n - hq) - (q1 * b)]. > - > - "check if we should round upward. > - The case of exact half (q bitAnd: 1) isZero not & (r isZero) > - will be handled by Integer>>asFloat" > - ((q bitAnd: 1) isZero or: [r isZero]) > - ifFalse: [q := q + 1]. > - > ^ (self positive > + ifTrue: [mantissa asFloat] > + ifFalse: [mantissa asFloat negated]) > - ifTrue: [q asFloat] > - ifFalse: [q = 0 > - ifTrue: [Float negativeZero] > - ifFalse: [q asFloat negated]]) > timesTwoPower: exponent! > > Item was changed: > ----- Method: Integer>>asFloat (in category 'converting') ----- > asFloat > + "Answer a Float that best approximates the value of the receiver." > - "Answer a Float that represents the value of the receiver. > - Optimized to process only the significant digits of a LargeInteger. > - SqR: 11/30/1998 21:1 > > + self subclassResponsibility! > - This algorithm does honour IEEE 754 round to nearest even mode. > - Numbers are first rounded on nearest integer on 53 bits. > - In case of exact half difference between two consecutive integers (2r0.1), > - there are two possible choices (two integers are as near, 0 and 1) > - In this case, the nearest even integer is chosen. > - examples (with less than 53bits for clarity) > - 2r0.00001 is rounded to 2r0 > - 2r1.00001 is rounded to 2.1 > - 2r0.1 is rounded to 2r0 (nearest event) > - 2r1.1 is rounded to 2.10 (neraest even) > - 2r0.10001 is rounded to 2r1 > - 2r1.10001 is rounded to 2.10" > - > - | abs shift sum delta mask trailingBits carry | > - self isZero > - ifTrue: [^ 0.0]. > - abs := self abs. > - > - "Assume Float is a double precision IEEE 754 number with 53bits mantissa. > - We should better use some Float class message for that (Float precision)..." > - delta := abs highBit - 53. > - delta > 0 > - ifTrue: [mask := (1 bitShift: delta) - 1. > - trailingBits := abs bitAnd: mask. > - "inexact := trailingBits isZero not." > - carry := trailingBits bitShift: 1 - delta. > - abs := abs bitShift: delta negated. > - shift := delta. > - (carry isZero > - or: [(trailingBits bitAnd: (mask bitShift: -1)) isZero > - and: [abs even]]) > - ifFalse: [abs := abs + 1]] > - ifFalse: [shift := 0]. > - > - "now, abs has no more than 53 bits, we can do exact floating point arithmetic" > - sum := 0.0. > - 1 to: abs size do: > - [:byteIndex | > - sum := ((abs digitAt: byteIndex) asFloat timesTwoPower: shift) + sum. > - shift := shift + 8]. > - ^ self positive > - ifTrue: [sum] > - ifFalse: [sum negated]! > > Item was added: > + ----- Method: LargeNegativeInteger>>asFloat (in category 'converting') ----- > + asFloat > + ^self negated asFloat negated! > > Item was added: > + ----- Method: LargePositiveInteger>>asFloat (in category 'converting') ----- > + asFloat > + "Answer a Float that best approximates the value of the receiver. > + This algorithm is optimized to process only the significant digits of a LargeInteger. > + And it does honour IEEE 754 round to nearest even mode in case of excess precision (see details below)." > + > + "How numbers are rounded in IEEE 754 default rounding mode: > + A shift is applied so that the highest 53 bits are placed before the floating point to form a mantissa. > + The trailing bits form the fraction part placed after the floating point. > + This fractional number must be rounded to the nearest integer. > + If fraction part is 2r0.1, exactly between two consecutive integers, there is a tie. > + The nearest even integer is chosen in this case. > + Examples (First 52bits of mantissa are omitted for brevity): > + 2r0.00001 is rounded downward to 2r0 > + 2r1.00001 is rounded downward to 2r1 > + 2r0.1 is a tie and rounded to 2r0 (nearest even) > + 2r1.1 is a tie and rounded to 2r10 (nearest even) > + 2r0.10001 is rounded upward to 2r1 > + 2r1.10001 is rounded upward to 2r10 > + Thus, if the next bit after floating point is 0, the mantissa is left unchanged. > + If next bit after floating point is 1, an odd mantissa is always rounded upper. > + An even mantissa is rounded upper only if the fraction part is not a tie." > + > + "Algorihm details: > + Floating point hardware will correctly handle the rounding by itself with a single inexact operation if mantissa has one excess bit of precision. > + Except in the last case when extra bits are present after an even mantissa, we must round upper by ourselves. > + Note 1: the inexact flag in floating point hardware must not be trusted because it won't take into account the bits we truncated by ourselves. > + Note 2: the floating point hardware is presumed configured in default rounding mode." > + > + | mantissa shift sum excess | > + > + "Check how many bits excess the maximum precision of a Float mantissa." > + excess := self highBitOfMagnitude - Float precision. > + excess > 1 > + ifTrue: > + ["Remove the excess bits but one." > + mantissa := self bitShift: 1 - excess. > + shift := excess - 1. > + "Handle the case of extra bits truncated after an even mantissa." > + ((mantissa bitAnd: 2r11) = 2r01 and: [self anyBitOfMagnitudeFrom: 1 to: shift]) > + ifTrue: [mantissa := mantissa + 1]] > + ifFalse: > + [mantissa := self. > + shift := 0]. > + > + "Now that mantissa has at most 1 excess bit of precision, let floating point operations perform the final rounding." > + sum := 0.0. > + 1 to: mantissa digitLength do: > + [:byteIndex | > + sum := sum + ((mantissa digitAt: byteIndex) asFloat timesTwoPower: shift). > + shift := shift + 8]. > + ^sum! > > >

1 0

The Trunk: Kernel-nice.627.mcz
by commits＠source.squeak.org 25 Sep '11

25 Sep '11

Nicolas Cellier uploaded a new version of Kernel to project The Trunk: http://source.squeak.org/trunk/Kernel-nice.627.mcz ==================== Summary ==================== Name: Kernel-nice.627 Author: nice Time: 25 September 2011, 12:55:51.623 pm UUID: c09ead19-3aa6-482b-b2cc-f6549bc67eb6 Ancestors: Kernel-ul.626 Improve Fraction and Integer asFloat by: - removing unreachable branch - removing un-needed arithmetic - renaming temps - using Float precision explicitly rather than hardcoded magical numbers - clarifying comments The resulting code shall be clearer and a bit faster than previously. =============== Diff against Kernel-ul.626 =============== Item was changed: ----- Method: Fraction>>asFloat (in category 'converting') ----- asFloat "Answer a Float that closely approximates the value of the receiver. + This implementation will answer the closest floating point number to the receiver. + In case of a tie, it will use the IEEE 754 round to nearest even mode. + In case of overflow, it will answer +/- Float infinity." + + | a b mantissa exponent hasTruncatedBits lostBit n ha hb hm | - This implementation will answer the closest floating point number to - the receiver. - It uses the IEEE 754 round to nearest even mode - (can happen in case denominator is a power of two)" - - | a b q r exponent floatExponent n ha hb hq q1 | a := numerator abs. + b := denominator. "denominator is always positive" - b := denominator abs. ha := a highBit. hb := b highBit. + "Number of bits to keep in mantissa plus one to handle rounding." + n := 1 + Float precision. + "If both numerator and denominator are represented exactly in floating point number, + then fastest thing to do is to use hardwired float division." + (ha < n and: [hb < n]) ifTrue: [^numerator asFloat / denominator asFloat]. + + "Shift the fraction by a power of two exponent so as to obtain a mantissa with n bits. + First guess is rough, the mantissa might have n+1 bits." + exponent := ha - hb - n. + exponent >= 0 - then fastest thing to do is to use hardwired float division" - (ha < 54 and: [hb < 54]) ifTrue: [^numerator asFloat / denominator asFloat]. - - "Try and obtain a mantissa with 54 bits. - First guess is rough, we might get one more bit or one less" - exponent := ha - hb - 54. - exponent > 0 ifTrue: [b := b bitShift: exponent] ifFalse: [a := a bitShift: exponent negated]. + mantissa := a quo: b. + hasTruncatedBits := a > (mantissa * b). + hm := mantissa highBit. - q := a quo: b. - r := a - (q * b). - hq := q highBit. + "Check for gradual underflow, in which case the mantissa will loose bits. + Keep at least one bit to let underflow preserve the sign of zero." + lostBit := Float emin - (exponent + hm - 1). + lostBit > 0 ifTrue: [n := n - lostBit max: 1]. + + "Remove excess bits in the mantissa." + hm > n + ifTrue: + [exponent := exponent + hm - n. + hasTruncatedBits := hasTruncatedBits or: [mantissa anyBitOfMagnitudeFrom: 1 to: hm - n]. + mantissa := mantissa bitShift: n - hm]. + + "Check if mantissa must be rounded upward. + The case of tie (mantissa odd & hasTruncatedBits not) + will be handled by Integer>>asFloat." + (hasTruncatedBits and: [mantissa odd]) + ifTrue: [mantissa := mantissa + 1]. + - "check for gradual underflow, in which case we should use less bits" - floatExponent := exponent + hq - 1. - n := floatExponent > -1023 - ifTrue: [54] - ifFalse: [54 + floatExponent + 1022]. - - hq > n - ifTrue: [exponent := exponent + hq - n. - r := (q bitAnd: (1 bitShift: hq - n) - 1) * b + r. - q := q bitShift: n - hq]. - hq < n - ifTrue: [exponent := exponent + hq - n. - q1 := (r bitShift: n - hq) quo: b. - q := (q bitShift: n - hq) bitAnd: q1. - r := (r bitShift: n - hq) - (q1 * b)]. - - "check if we should round upward. - The case of exact half (q bitAnd: 1) isZero not & (r isZero) - will be handled by Integer>>asFloat" - ((q bitAnd: 1) isZero or: [r isZero]) - ifFalse: [q := q + 1]. - ^ (self positive + ifTrue: [mantissa asFloat] + ifFalse: [mantissa asFloat negated]) - ifTrue: [q asFloat] - ifFalse: [q = 0 - ifTrue: [Float negativeZero] - ifFalse: [q asFloat negated]]) timesTwoPower: exponent! Item was changed: ----- Method: Integer>>asFloat (in category 'converting') ----- asFloat + "Answer a Float that best approximates the value of the receiver." - "Answer a Float that represents the value of the receiver. - Optimized to process only the significant digits of a LargeInteger. - SqR: 11/30/1998 21:1 + self subclassResponsibility! - This algorithm does honour IEEE 754 round to nearest even mode. - Numbers are first rounded on nearest integer on 53 bits. - In case of exact half difference between two consecutive integers (2r0.1), - there are two possible choices (two integers are as near, 0 and 1) - In this case, the nearest even integer is chosen. - examples (with less than 53bits for clarity) - 2r0.00001 is rounded to 2r0 - 2r1.00001 is rounded to 2.1 - 2r0.1 is rounded to 2r0 (nearest event) - 2r1.1 is rounded to 2.10 (neraest even) - 2r0.10001 is rounded to 2r1 - 2r1.10001 is rounded to 2.10" - - | abs shift sum delta mask trailingBits carry | - self isZero - ifTrue: [^ 0.0]. - abs := self abs. - - "Assume Float is a double precision IEEE 754 number with 53bits mantissa. - We should better use some Float class message for that (Float precision)..." - delta := abs highBit - 53. - delta > 0 - ifTrue: [mask := (1 bitShift: delta) - 1. - trailingBits := abs bitAnd: mask. - "inexact := trailingBits isZero not." - carry := trailingBits bitShift: 1 - delta. - abs := abs bitShift: delta negated. - shift := delta. - (carry isZero - or: [(trailingBits bitAnd: (mask bitShift: -1)) isZero - and: [abs even]]) - ifFalse: [abs := abs + 1]] - ifFalse: [shift := 0]. - - "now, abs has no more than 53 bits, we can do exact floating point arithmetic" - sum := 0.0. - 1 to: abs size do: - [:byteIndex | - sum := ((abs digitAt: byteIndex) asFloat timesTwoPower: shift) + sum. - shift := shift + 8]. - ^ self positive - ifTrue: [sum] - ifFalse: [sum negated]! Item was added: + ----- Method: LargeNegativeInteger>>asFloat (in category 'converting') ----- + asFloat + ^self negated asFloat negated! Item was added: + ----- Method: LargePositiveInteger>>asFloat (in category 'converting') ----- + asFloat + "Answer a Float that best approximates the value of the receiver. + This algorithm is optimized to process only the significant digits of a LargeInteger. + And it does honour IEEE 754 round to nearest even mode in case of excess precision (see details below)." + + "How numbers are rounded in IEEE 754 default rounding mode: + A shift is applied so that the highest 53 bits are placed before the floating point to form a mantissa. + The trailing bits form the fraction part placed after the floating point. + This fractional number must be rounded to the nearest integer. + If fraction part is 2r0.1, exactly between two consecutive integers, there is a tie. + The nearest even integer is chosen in this case. + Examples (First 52bits of mantissa are omitted for brevity): + 2r0.00001 is rounded downward to 2r0 + 2r1.00001 is rounded downward to 2r1 + 2r0.1 is a tie and rounded to 2r0 (nearest even) + 2r1.1 is a tie and rounded to 2r10 (nearest even) + 2r0.10001 is rounded upward to 2r1 + 2r1.10001 is rounded upward to 2r10 + Thus, if the next bit after floating point is 0, the mantissa is left unchanged. + If next bit after floating point is 1, an odd mantissa is always rounded upper. + An even mantissa is rounded upper only if the fraction part is not a tie." + + "Algorihm details: + Floating point hardware will correctly handle the rounding by itself with a single inexact operation if mantissa has one excess bit of precision. + Except in the last case when extra bits are present after an even mantissa, we must round upper by ourselves. + Note 1: the inexact flag in floating point hardware must not be trusted because it won't take into account the bits we truncated by ourselves. + Note 2: the floating point hardware is presumed configured in default rounding mode." + + | mantissa shift sum excess | + + "Check how many bits excess the maximum precision of a Float mantissa." + excess := self highBitOfMagnitude - Float precision. + excess > 1 + ifTrue: + ["Remove the excess bits but one." + mantissa := self bitShift: 1 - excess. + shift := excess - 1. + "Handle the case of extra bits truncated after an even mantissa." + ((mantissa bitAnd: 2r11) = 2r01 and: [self anyBitOfMagnitudeFrom: 1 to: shift]) + ifTrue: [mantissa := mantissa + 1]] + ifFalse: + [mantissa := self. + shift := 0]. + + "Now that mantissa has at most 1 excess bit of precision, let floating point operations perform the final rounding." + sum := 0.0. + 1 to: mantissa digitLength do: + [:byteIndex | + sum := sum + ((mantissa digitAt: byteIndex) asFloat timesTwoPower: shift). + shift := shift + 8]. + ^sum!

1 0

Fraction>>asFloat needs review
by Nicolas Cellier 25 Sep '11

25 Sep '11

After Integer>>asFloat, Fraction>>asFloat needs a review too. It is not broken. But it has unreachable code, performs more arithmetic than necessary and we could put some light on obscure comments and reduce implicit knowledge. So if we can leave a better example of coding in the image, let's do it. It's better to write this in a Blog http://smallissimo.blogspot.com/2011/09/reviewing-fraction-asfloat.html because it would be too long for a single commit comment. Nicolas

1 0

Fixing the "what to show" button on browsers (was: Inbox: ToolBuilder-Kernel-dtl.50.mcz)
by David T. Lewis 24 Sep '11

24 Sep '11

On Sat, Sep 24, 2011 at 07:51:51PM +0000, commits(a)source.squeak.org wrote: > > Provide updating button for "what to show" button on CodeHolder, similar > to Squeak 3.8 behavior. This button activates a menu, and displays the > resulting menu selection. For the default look, normal buttons are rounded > and the menu activation button is square (vice versa if the "Rounded > Button Corners" preference is disabled). When menu selection is changed, > the button label displays the selected mode ('source', 'decompile', > 'bytecodes' etc). I uploaded three packages to the inbox for review. These add a couple of hooks to ToolBuilder to teach an action button to react to "changed: #contents" notifications from a browser, and to allow showing a visual cue that distinguishes a menu activation button from an action button. As implemented here, the look and behavior is similar to pre-toolbuilder Squeak (although a nice graphical icon in the button would be a nicer visual cue than the old square versus rounded corners cue, help welcome here). Comments and review appeciated, and if no objections I'll move this to trunk a few days from now. Dave

1 0

← Newer
1
...
4
5
6
7
8
9
10
...
21
Older →

Jump to page: