[squeak-dev] The Inbox: Kernel-ul.903.mczcommits at source.squeak.org commits at source.squeak.orgSun Feb 15 21:00:17 UTC 2015
Levente Uzonyi uploaded a new version of Kernel to project The Inbox: http://source.squeak.org/inbox/Kernel-ul.903.mcz ==================== Summary ==================== Name: Kernel-ul.903 Author: ul Time: 15 February 2015, 9:57:57.503 pm UUID: f1522d00-538e-45d7-a988-e541ea56db56 Ancestors: Kernel-nice.902 Introduced MTRandom, an implementation of the 32-bit Mersenne Twister PRNG. It includes a version optimized for Squeak, which is used by default. It's a possible replacement for Random. Removed LargePositiveInteger >> #atRandom:, since it's something that Random >> #nextInt: should do. Alternatively it can do something different later (eg send #nextLargeInt:). This is for review-only. If we decide to use this generator, then Random has to be replaced with this. After loading, the generator will only used by ThreadSafeRandom class >> #default. If you want to replace all existing generators in the image, then you can use the following snippet: | old new | old := Random allInstances. new := old collect: [ :each | MTRandom new ]. old elementsForwardIdentityTo: new =============== Diff against Kernel-nice.902 =============== Item was removed: - ----- Method: LargePositiveInteger>>atRandom: (in category 'truncation and round off') ----- - atRandom: aGenerator - "Answer a random integer from 1 to self picked from aGenerator." - - | chunkByteLength chunkBitLength chunkCount chunkMax bigRandomInteger | - chunkByteLength := 3. - chunkBitLength := chunkByteLength * 8. - chunkCount := - self highBitOfMagnitude + chunkBitLength - 1 // chunkBitLength "self would fit in that many chunks..." - + 2. "and two more chunks (48 bits) so as to have a pretty fair distribution" - chunkMax := 1<<chunkBitLength-1. - - "fill a big random integer by chunks of 3 bytes (24 bits)" - bigRandomInteger := self class new: chunkCount*chunkByteLength neg: false. - 0 to: chunkCount*chunkByteLength - 1 by: chunkByteLength do: [:byteOffset | - | chunk | - chunk := (aGenerator nextInt: chunkMax) - 1. - 1 to: chunkByteLength do: [:byteIndex | - bigRandomInteger digitAt: byteOffset + byteIndex put: (chunk digitAt: byteIndex)]]. - - ^self * bigRandomInteger >> (chunkCount * chunkBitLength) + 1! Item was added: + Object subclass: #MTRandom + instanceVariableNames: 'states index parameters' + classVariableNames: '' + poolDictionaries: '' + category: 'Kernel-Numbers'! + + !MTRandom commentStamp: 'ul 2/15/2015 15:02' prior: 0! + I implement the 32-bit version of the Mersenne Twister PRNG, based on http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/ARTICLES/mt.pdf . Alternatively the w parameter (number of bits per word) can be less than 32, but it should be at least 27. + + Instance Variables + index: <Integer> + parameters: <MTRandomParameters> + states: <Array> + + index + - the index of the state, which should be used to generate the next random integer value + + parameters + - an MTRandomParameters instance which defines the parameters to be used with this genetator. Must be set before the seed is defined. + + states + - a WordArray holding the internal state of the generator + ! Item was added: + ----- Method: MTRandom class>>new (in category 'instance creation') ----- + new + + | seed | + seed := Time primUTCMicrosecondClock. + seed = 0 ifTrue: [ seed := Time millisecondClockValue ]. + ^self seed: seed! Item was added: + ----- Method: MTRandom class>>parameters:seed: (in category 'instance creation') ----- + parameters: anMTRandomParameters seed: anInteger + + ^self basicNew + parameters: anMTRandomParameters seed: anInteger; + yourself! Item was added: + ----- Method: MTRandom class>>seed: (in category 'instance creation') ----- + seed: anInteger + + ^self + parameters: MTRandomParameters mt521b30 + seed: anInteger! Item was added: + ----- Method: MTRandom>>check: (in category 'compatibility - die rolling') ----- + check: nDice + "Roll some dice, WoD-style." + + ^ self check: nDice difficulty: 6! Item was added: + ----- Method: MTRandom>>check:against: (in category 'compatibility - die rolling') ----- + check: nAttack against: nDefend + "Roll some dice, WoD-style." + + ^ self check: nAttack against: nDefend difficulty: 6! Item was added: + ----- Method: MTRandom>>check:against:difficulty: (in category 'compatibility - die rolling') ----- + check: nAttack against: nDefend difficulty: diff + "Roll some dice, WoD-style." + + | attacks defends | + attacks := self check: nAttack difficulty: diff. + attacks < 0 ifTrue: [^ attacks]. + defends := self check: nDefend difficulty: diff. + ^ attacks - defends min: 0! Item was added: + ----- Method: MTRandom>>check:difficulty: (in category 'compatibility - die rolling') ----- + check: nDice difficulty: diff + "Roll some dice, WoD-style." + + | result | + result := 0. + nDice timesRepeat: + [ | die | + (die := self nextInt: 10) = 1 + ifTrue: [result := result - 1] + ifFalse: [die >= diff ifTrue: [result := result + 1]]]. + ^ result! Item was added: + ----- Method: MTRandom>>diceToken: (in category 'compatibility - die rolling') ----- + diceToken: stream + "Private. Mini scanner, see #roll:" + + stream atEnd ifTrue: [^ nil]. + stream peek isDigit ifTrue: [^ Number readFrom: stream]. + ^ stream next asLowercase! Item was added: + ----- Method: MTRandom>>generate (in category 'private') ----- + generate + "Generate untempered numbers into the states variable, and reset the index to 1." + + parameters generate: states. + index := 1! Item was added: + ----- Method: MTRandom>>next (in category 'accessing') ----- + next + "Answer a random 53-bit Float from the [0, 1) interval. The implementation assumes that the w parameter is between 27 and 53." + + | multiplier | + multiplier := parameters wFloatMultiplier. + ^self nextValue asFloat * multiplier + (self nextValue bitAnd: multiplier - 1) / 9.007199254740992e15 "(1 << 53) asFloat"! Item was added: + ----- Method: MTRandom>>next: (in category 'compatibility') ----- + next: anInteger + "To be exchangable with Random." + + ^self next: anInteger into: (Array new: anInteger)! Item was added: + ----- Method: MTRandom>>next:into: (in category 'compatibility') ----- + next: anInteger into: anArray + "To be exchangable with Random." + + 1 to: anInteger do: [ :index | anArray at: index put: self next ]. + ^anArray! Item was added: + ----- Method: MTRandom>>nextInt: (in category 'accessing') ----- + nextInt: anInteger + "Answer a random integer value from the interval [1, anInteger]" + + anInteger strictlyPositive ifFalse: [ self error: 'Range must be positive' ]. + anInteger isLarge ifTrue: [ ^self nextLargeInt: anInteger ]. + "Here we assume that the w parameter is at least 30. Using any less is a waste." + anInteger isPowerOfTwo ifTrue: [ ^(self nextValue bitAnd: anInteger - 1) + 1 ]. + ^(self next * anInteger) truncated + 1! Item was added: + ----- Method: MTRandom>>nextLargeInt: (in category 'private') ----- + nextLargeInt: anInteger + + | byteCount bigRandom remainder remainingBits i | + byteCount := anInteger digitLength + 4. + bigRandom := LargePositiveInteger new: byteCount. + remainder := remainingBits := 0. + i := 1. + [ i <= byteCount ] whileTrue: [ + remainingBits >= 8 + ifTrue: [ + bigRandom at: i put: (remainder bitAnd: 16rFF). + remainder := remainder bitShift: -8. + remainingBits := remainingBits - 8. + i := i + 1 ] + ifFalse: [ + remainingBits = 0 + ifTrue: [ remainder := self nextValue ] + ifFalse: [ + | newRandom | + newRandom := self nextValue. "Assume that at least 8 new bits are generated" + bigRandom at: i put: (remainder bitShift: 8 - remainingBits) + + (newRandom bitAnd: (1 bitShift: 8 - remainingBits) - 1). + i := i + 1. + remainder := newRandom bitShift: 0 - remainingBits ]. + remainingBits := parameters w - remainingBits ] ]. + ^(anInteger * bigRandom bitShift: -8 * byteCount) + 1 + ! Item was added: + ----- Method: MTRandom>>nextValue (in category 'private') ----- + nextValue + "Answer a random integer between 0 and wordMask, and increment the index." + + | result | + result := states at: index. + result isLarge + ifTrue: [ result := parameters temperLarge: result ] + ifFalse: [ result := parameters temperSmall: result ]. + (index := index + 1) > states size ifTrue: [ self generate ]. + ^result! Item was added: + ----- Method: MTRandom>>parameters:seed: (in category 'initialization') ----- + parameters: anMTRandomParameters seed: anInteger + "Initialize the generator for the given parameters, and seed." + + parameters := anMTRandomParameters. + self seed: anInteger! Item was added: + ----- Method: MTRandom>>roll: (in category 'compatibility - die rolling') ----- + roll: diceString + "Roll some dice, DnD-style, according to this mini-grammar: + dice := epxr {pm expr} + pm := '+' | '-' + expr := num | num dD | dD numP | num dD numP + dD := 'd' | 'D' + num := digit+ + numP := num | '%'" + + | stream op result | + stream := diceString readStream. + result := 0. + op := #+. + [ | res range dice token | + token := self diceToken: stream. + token isNumber + ifTrue: [dice := token. + token := self diceToken: stream] + ifFalse: [token == $d + ifTrue: [dice := 1] + ifFalse: [res := 0]]. + token == $d + ifTrue: [token := self diceToken: stream. + token isNumber + ifTrue: [range := token. + token := self diceToken: stream] + ifFalse: [token == $% + ifTrue: [range := 100. + token := self diceToken: stream] + ifFalse: [range := 6]]. + res := 0. + dice timesRepeat: [res := res + (self nextInt: range)]]. + result := result perform: op with: res. + token ifNil: [^ result]. + (token == $+ or: [token == $-]) + ifFalse: [self error: 'unknown token ' , token]. + op := token asSymbol] repeat! Item was added: + ----- Method: MTRandom>>seed: (in category 'initialization') ----- + seed: anInteger + "Initialize the generator for the given seed." + + states := parameters createStatesArrayForSeed: anInteger. + self generate! Item was added: + Object subclass: #MTRandomParameters + instanceVariableNames: 'p w a m b c uDiv sMul tMul lDiv upperMask lowerMask wordMask n l u s t bShifted cShifted r wFloatMultiplier' + classVariableNames: 'MT19937b32 MT521b30 MT521b31 MT521b32' + poolDictionaries: '' + category: 'Kernel-Numbers'! + + !MTRandomParameters commentStamp: 'ul 2/15/2015 03:13' prior: 0! + I provide the parameters for MTRandom instances. Once initialized, my values must not be changed, because they are shared among multiple MTRandom instances. + + Instance Variables + a: <Integer> + b: <Integer> + bShifted: <Integer> + c: <Integer> + cShifted: <Integer> + l: <Integer> + lDiv: <Integer> + lowerMask: <Integer> + m: <Integer> + n: <Integer> + p: <Integer> + r: <Integer> + s: <Integer> + sMul: <Integer> + t: <Integer> + tMul: <ObjeIntegerct> + u: <Integer> + uDiv: <Integer> + upperMask: <Integer> + w: <Integer> + wFloatMultiplier: <Integer> + wordMask: <Integer> + + a + - the last row of matrix A + + b + - tempering mask b + + bShifted + - tempering mask b shifted by s. This is a computed value. + + c + - tempering mask c + + cShifted + - tempering mask c shifted by t. This is a computed value. + + l + - the bits used for lower shifts. Its value must be negative. + + lDiv + - this number can be used to replace shifting by l with a division. This is a computed value. + + lowerMask + - the mask for the low r bits + + m + - the middle term + + n + - the number of words used in the state array. This is a computed value. + + p + - the exponent of the period of the generator. 2^p-1 must be a mersenne prime, therefore p must be a prime. + + r + - the number of set bits in the lowerMask. This is a computed value. + + s + - the shifts used after applying the tempering mask b + + sMul + - this number can be used to replace shifting by s with a multiplication. This is a computed value. + + t + - the shifts used after applying the tempering mask c + + tMul + - this number can be used to replace shifting by t with a multiplication. This is a computed value. + + u + - the bits used for upper shifts. Its value must be negative. + + uDiv + - this number can be used to replace shifting by u with a division. This is a computed value. + + upperMask + - a mask with w - r set bits in the upper region, and r zero bits in the lower region. This is a computed value. + + w + - the number of bits in a word + + wFloatMultiplier + - a multiplier which can create an 53 bit number from a word. This is a computed value. + + wordMask + - a mask with w bits + ! Item was added: + ----- Method: MTRandomParameters class>>initialize (in category 'class initialization') ----- + initialize + " self initialize " + + MT19937b32 := self new initializeForMT19937. + MT521b32 := self new initializeForMT521. + MT521b31 := self new initializeFor31BitsMT521. + MT521b30 := self new initializeFor30BitsMT521.! Item was added: + ----- Method: MTRandomParameters class>>mt19937b32 (in category 'accessing') ----- + mt19937b32 + + ^MT19937b32! Item was added: + ----- Method: MTRandomParameters class>>mt521b30 (in category 'accessing') ----- + mt521b30 + + ^MT521b30! Item was added: + ----- Method: MTRandomParameters class>>mt521b31 (in category 'accessing') ----- + mt521b31 + + ^MT521b31! Item was added: + ----- Method: MTRandomParameters class>>mt521b32 (in category 'accessing') ----- + mt521b32 + + ^MT521b32! Item was added: + ----- Method: MTRandomParameters>>a (in category 'accessing') ----- + a + + ^ a! Item was added: + ----- Method: MTRandomParameters>>b (in category 'accessing') ----- + b + + ^ b! Item was added: + ----- Method: MTRandomParameters>>bShifted (in category 'accessing') ----- + bShifted + + ^ bShifted! Item was added: + ----- Method: MTRandomParameters>>c (in category 'accessing') ----- + c + + ^ c! Item was added: + ----- Method: MTRandomParameters>>cShifted (in category 'accessing') ----- + cShifted + + ^ cShifted! Item was added: + ----- Method: MTRandomParameters>>calculateValues (in category 'private') ----- + calculateValues + " Calculate multipliers, divisors and masks used by the actual implementation. " + + self + assert: p isPrime; + assert: (w between: 27 and: 32); + assert: u < 0; + assert: l < 0. + n := (p / w) ceiling. "The size of the array." + r := n * w - p. "The number of bits in lowerMask" + lDiv := 1 bitShift: l negated. + uDiv := 1 bitShift: u negated. + sMul := 1 bitShift: s. + tMul := 1 bitShift: t. + bShifted := b bitShift: s negated. + cShifted := c bitShift: t negated. + wordMask := 1 bitShift: w - 1. + lowerMask := 1 bitShift: r - 1. + upperMask := wordMask - lowerMask. + wFloatMultiplier := 1 bitShift: (53 - w)! Item was added: + ----- Method: MTRandomParameters>>createStatesArrayForSeed: (in category 'generatring') ----- + createStatesArrayForSeed: anInteger + "Create an array for these parameters and the given seed. Hash the seed if it's not a 32-bit unsigned integer." + + | seed states | + seed := (anInteger between: 0 and: 16rFFFFFFFF) + ifTrue: [ anInteger ] + ifFalse: [ self hashSeed: anInteger ]. + states := Array new: n. + 1 to: n do: [ :i | + states at: i put: (wordMask bitAnd: seed). + seed := 16rFFFFFFFF bitAnd: (16r6C078965 * (seed bitXor: seed // 1073741824 "bitShift: -30") + i) ]. + ^states! Item was added: + ----- Method: MTRandomParameters>>generate: (in category 'generatring') ----- + generate: states + "Generate untempered numbers into the states variable. Choose the best method based on word size." + + wordMask isLarge ifTrue: [ ^self generateLarge: states ]. + ^self generateSmall: states! Item was added: + ----- Method: MTRandomParameters>>generateLarge: (in category 'generatring') ----- + generateLarge: states + "Generate untempered numbers into the states variable. Split up the operation into three parts to avoid the use of #atWrap: for accessing the states array. Optimized for LargeInteger operations." + + | i limit y offset | + "Part 1" + i := 0. + offset := m. + limit := n - offset. + [ (i := i + 1) <= limit ] whileTrue: [ + y := (upperMask bitAnd: (states at: i)) bitOr: (lowerMask bitAnd: (states at: i + 1)). + states + at: i + put: (y even + ifTrue: [ (states at: i + offset) bitXor: y // 2 ] + ifFalse: [ a bitXor: ((states at: i + offset) bitXor: y // 2) ]) ]. + "Part 2" + limit := n - 1. + offset := m - n + 1. + [ (i := i + 1) <= limit ] whileTrue: [ + y := (upperMask bitAnd: (states at: i)) bitOr: (lowerMask bitAnd: (states at: i + 1)). + states + at: i + put: (y even + ifTrue: [ (states at: i + offset) bitXor: y // 2 ] + ifFalse: [ a bitXor: ((states at: i + offset) bitXor: y // 2) ]) ]. + "Part 3" + y := (upperMask bitAnd: (states at: i)) bitOr: (lowerMask bitAnd: (states at: 1)). + states + at: i + put: (y even + ifTrue: [ (states at: m) bitXor: y // 2 ] + ifFalse: [ a bitXor: ((states at: m) bitXor: y // 2) ])! Item was added: + ----- Method: MTRandomParameters>>generateSmall: (in category 'generatring') ----- + generateSmall: states + "Generate untempered numbers into the states variable. Split up the operation into three parts to avoid the use of #atWrap: for accessing the states array. Optimized for SmallInteger operations." + + | i limit y offset | + "Part 1" + i := 0. + offset := m. + limit := n - offset. + [ (i := i + 1) <= limit ] whileTrue: [ + y := (upperMask bitAnd: (states at: i)) bitOr: (lowerMask bitAnd: (states at: i + 1)). + states + at: i + put: ((y bitAnd: 1) = 0 + ifTrue: [ (states at: i + offset) bitXor: (y bitShift: -1) ] + ifFalse: [ a bitXor: ((states at: i + offset) bitXor: (y bitShift: -1)) ]) ]. + "Part 2" + limit := n - 1. + offset := m - n + 1. + [ (i := i + 1) <= limit ] whileTrue: [ + y := (upperMask bitAnd: (states at: i)) bitOr: (lowerMask bitAnd: (states at: i + 1)). + states + at: i + put: ((y bitAnd: 1) = 0 + ifTrue: [ (states at: i + offset) bitXor: (y bitShift: -1) ] + ifFalse: [ a bitXor: ((states at: i + offset) bitXor: (y bitShift: -1)) ]) ]. + "Part 3" + y := (upperMask bitAnd: (states at: i)) bitOr: (lowerMask bitAnd: (states at: 1)). + states + at: i + put: ((y bitAnd: 1) = 0 + ifTrue: [ (states at: m) bitXor: (y bitShift: -1) ] + ifFalse: [ a bitXor: ((states at: m) bitXor: (y bitShift: -1)) ])! Item was added: + ----- Method: MTRandomParameters>>hashSeed: (in category 'private') ----- + hashSeed: anInteger + "Use the 32-bit version of the FNV-1a algorithm to hash the seed, and produce a 32-bit unsigned integer." + + | fnvPrime hash | + fnvPrime := 16777619 " 32-bit FVN prime ". + hash := anInteger negative + ifTrue: [ 3490449840 " mix in the sign as (2166136261 bitXor: 2r1010101) * 16777619 bitAnd: 16rFFFFFFFF "] + ifFalse: [ 2166136261 " 32-bit FVN offset basis "]. + 1 to: anInteger digitLength do: [ :index | + hash := 16rFFFFFFFF bitAnd: (hash bitXor: (anInteger digitAt: index)) * fnvPrime ]. + ^hash! Item was added: + ----- Method: MTRandomParameters>>initializeFor30BitsMT521 (in category 'initialize-release') ----- + initializeFor30BitsMT521 + "30-bit MT521 parameters. generated with a modified version of dcmt, ID=4172. http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/DC/dc.html" + + p := 521. + w := 30. + m := 9. + a := 16r2c0b19af. + u := -12. + l := -18. + s := 7. + t := 15. + b := 16r1caf6480. + c := 16r3fcd0000. + self calculateValues + ! Item was added: + ----- Method: MTRandomParameters>>initializeFor31BitsMT521 (in category 'initialize-release') ----- + initializeFor31BitsMT521 + "31-bit MT521 parameters, generated with dcmt, ID=4172. http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/DC/dc.html" + + p := 521. + w := 31. + m := 8. + a := 16r54dc9020. + u := -12. + l := -18. + s := 7. + t := 15. + b := 16r4bbadf80. + c := 16r3dee8000. + self calculateValues! Item was added: + ----- Method: MTRandomParameters>>initializeForMT19937 (in category 'initialize-release') ----- + initializeForMT19937 + "32-bit MT19937 parameters as in http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/ARTICLES/mt.pdf on page 8." + + p := 19937. + w := 32. + m := 397. + a := 16r9908B0DF. + u := -11. + l := -18. + s := 7. + t := 15. + b := 16r9D2C5680. + c := 16rEFC60000. + self calculateValues! Item was added: + ----- Method: MTRandomParameters>>initializeForMT521 (in category 'initialize-release') ----- + initializeForMT521 + "32-bit MT521 parameters, generated with dcmt, ID=4172. http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/DC/dc.html" + + p := 521. + w := 32. + m := 8. + a := 16rF0C1E1B8. + u := -12. + l := -18. + s := 7. + t := 15. + b := 16r74BD5f80. + c := 16rFFD50000. + self calculateValues! Item was added: + ----- Method: MTRandomParameters>>l (in category 'accessing') ----- + l + + ^ l! Item was added: + ----- Method: MTRandomParameters>>lDiv (in category 'accessing') ----- + lDiv + + ^ lDiv! Item was added: + ----- Method: MTRandomParameters>>lowerMask (in category 'accessing') ----- + lowerMask + + ^ lowerMask! Item was added: + ----- Method: MTRandomParameters>>m (in category 'accessing') ----- + m + + ^ m! Item was added: + ----- Method: MTRandomParameters>>n (in category 'accessing') ----- + n + + ^ n! Item was added: + ----- Method: MTRandomParameters>>r (in category 'accessing') ----- + r + + ^ r! Item was added: + ----- Method: MTRandomParameters>>s (in category 'accessing') ----- + s + + ^ s! Item was added: + ----- Method: MTRandomParameters>>sMul (in category 'accessing') ----- + sMul + + ^ sMul! Item was added: + ----- Method: MTRandomParameters>>t (in category 'accessing') ----- + t + + ^ t! Item was added: + ----- Method: MTRandomParameters>>tMul (in category 'accessing') ----- + tMul + + ^ tMul! Item was added: + ----- Method: MTRandomParameters>>temperLarge: (in category 'tempering') ----- + temperLarge: anInteger + " Optimized for 32-bit LargeInteger operations. " + + | y | + y := anInteger bitXor: anInteger // uDiv. + y := y bitXor: ((y bitAnd: bShifted) * sMul). + y := y bitXor: ((y bitAnd: cShifted) * tMul). + ^y bitXor: y // lDiv! Item was added: + ----- Method: MTRandomParameters>>temperSmall: (in category 'tempering') ----- + temperSmall: anInteger + " Optimized for SmallInteger operations. " + + | y | + y := anInteger bitXor: (anInteger bitShift: u). + y := ((y bitAnd: bShifted) bitShift: s) bitXor: y. + y := ((y bitAnd: cShifted) bitShift: t) bitXor: y. + ^(y bitShift: l) bitXor: y! Item was added: + ----- Method: MTRandomParameters>>u (in category 'accessing') ----- + u + + ^ u! Item was added: + ----- Method: MTRandomParameters>>uDiv (in category 'accessing') ----- + uDiv + + ^ uDiv! Item was added: + ----- Method: MTRandomParameters>>upperMask (in category 'accessing') ----- + upperMask + + ^ upperMask! Item was added: + ----- Method: MTRandomParameters>>w (in category 'accessing') ----- + w + + ^ w! Item was added: + ----- Method: MTRandomParameters>>wFloatMultiplier (in category 'accessing') ----- + wFloatMultiplier + + ^ wFloatMultiplier! Item was added: + ----- Method: MTRandomParameters>>wordMask (in category 'accessing') ----- + wordMask + + ^ wordMask! Item was changed: ----- Method: ThreadSafeRandom class>>default (in category 'accessing') ----- default + ^self value: MTRandom new! - ^self value: Random new!
More information about the Squeak-dev mailing list |