Fix two random failing tests by using a random generator with a fixed seed

jecisc · jecisc · commit 9dc5e564ed00 · 2023-03-13T15:50:24.000+01:00
Fixes #298
diff --git a/src/Math-Core-Process/PMIterativeProcess.class.st b/src/Math-Core-Process/PMIterativeProcess.class.st
@@ -82,8 +82,7 @@ PMIterativeProcess >> initialize [
 	super initialize.
 
 	desiredPrecision := self class defaultPrecision.
-	maximumIterations := self class defaultMaximumIterations.
-	^ self
+	maximumIterations := self class defaultMaximumIterations
 ]
 
 { #category : #operation }
diff --git a/src/Math-Numerical/PMFunctionOptimizer.class.st b/src/Math-Numerical/PMFunctionOptimizer.class.st
@@ -60,9 +60,10 @@ PMFunctionOptimizer >> initialValue: aVector [
 
 { #category : #initialization }
 PMFunctionOptimizer >> initialize [
-		"Private"
-	bestPoints := SortedCollection sortBlock: [ :a :b | a betterThan: b].
-	^super initialize
+	"Private"
+
+	super initialize.
+	bestPoints := SortedCollection sortBlock: [ :a :b | a betterThan: b ]
 ]
 
 { #category : #initialization }
diff --git a/src/Math-Numerical/PMOneVariableFunctionOptimizer.class.st b/src/Math-Numerical/PMOneVariableFunctionOptimizer.class.st
@@ -1,6 +1,9 @@
 Class {
 	#name : #PMOneVariableFunctionOptimizer,
 	#superclass : #PMFunctionOptimizer,
+	#instVars : [
+		'randomGenerator'
+	],
 	#classVars : [
 		'GoldenSection'
 	],
@@ -24,69 +27,86 @@ PMOneVariableFunctionOptimizer class >> goldenSection [
 { #category : #operation }
 PMOneVariableFunctionOptimizer >> computeInitialValues [
 
-	[ bestPoints size  > 3] whileTrue: [ bestPoints removeLast].
-	bestPoints size = 3
-		ifTrue: [ self hasBracketingPoints
-					ifFalse:[ bestPoints removeLast].
-				].
-	bestPoints size < 3
-		ifTrue: [ ( PMOptimizingBracketFinder forOptimizer: self) evaluate]
+	| finder |
+	[ bestPoints size > 3 ] whileTrue: [ bestPoints removeLast ].
+
+	bestPoints size = 3 ifTrue: [ self hasBracketingPoints ifFalse: [ bestPoints removeLast ] ].
+
+	bestPoints size < 3 ifFalse: [ ^ self ].
+
+	finder := PMOptimizingBracketFinder forOptimizer: self.
+	self randomGenerator ifNotNil: [ :generator | finder randomGenerator: generator ].
+	finder evaluate
 ]
 
 { #category : #information }
 PMOneVariableFunctionOptimizer >> computePrecision [
-	^self precisionOf: ( ( bestPoints at: 2) position - ( bestPoints at: 3) position) abs
-		   relativeTo: ( bestPoints at: 1) position abs
+
+	^ self precisionOf: ((bestPoints at: 2) position - (bestPoints at: 3) position) abs relativeTo: (bestPoints at: 1) position abs
 ]
 
 { #category : #operation }
 PMOneVariableFunctionOptimizer >> evaluateIteration [
+
 	self addPointAt: self nextXValue.
 	bestPoints removeAt: self indexOfOuterPoint.
-	^self computePrecision
+	^ self computePrecision
 ]
 
 { #category : #information }
 PMOneVariableFunctionOptimizer >> hasBracketingPoints [
-		"Private"
+	"Private"
+
 	| x1 |
-	x1 := ( bestPoints at: 1) position.
-	^( ( bestPoints at: 2) position - x1) * (( bestPoints at: 3) position - x1) < 0
+	x1 := (bestPoints at: 1) position.
+	^ (bestPoints at: 2) position - x1 * ((bestPoints at: 3) position - x1) < 0
 ]
 
 { #category : #information }
 PMOneVariableFunctionOptimizer >> indexOfOuterPoint [
-		"Private"
+	"Private"
+
 	| inferior superior x |
 	inferior := false.
 	superior := false.
 	x := bestPoints first position.
-	2 to: 4 do:
-		[ :n |
-		  ( bestPoints at: n) position < x
-				ifTrue: [ inferior
-							ifTrue: [ ^n].
-						  inferior := true.
-						]
-				ifFalse:[ superior
-							ifTrue: [ ^n].
-						  superior := true.
-						].
-		]
+	2 to: 4 do: [ :n |
+		(bestPoints at: n) position < x
+			ifTrue: [
+				inferior ifTrue: [ ^ n ].
+				inferior := true ]
+			ifFalse: [
+				superior ifTrue: [ ^ n ].
+				superior := true ] ]
 ]
 
 { #category : #information }
 PMOneVariableFunctionOptimizer >> nextXValue [
 	"Private"
+
 	| d3 d2 x1 |
-	x1 := ( bestPoints at: 1) position.
-	d2 := ( bestPoints at: 2) position - x1.
-	d3 := ( bestPoints at: 3) position - x1.
-	^( d3 abs > d2 abs ifTrue: [ d3]
-					   ifFalse:[ d2]) * self class goldenSection + x1
+	x1 := (bestPoints at: 1) position.
+	d2 := (bestPoints at: 2) position - x1.
+	d3 := (bestPoints at: 3) position - x1.
+	^ (d3 abs > d2 abs
+		   ifTrue: [ d3 ]
+		   ifFalse: [ d2 ]) * self class goldenSection + x1
+]
+
+{ #category : #accessing }
+PMOneVariableFunctionOptimizer >> randomGenerator [
+
+	^ randomGenerator
+]
+
+{ #category : #accessing }
+PMOneVariableFunctionOptimizer >> randomGenerator: anObject [
+
+	randomGenerator := anObject
 ]
 
 { #category : #transformation }
 PMOneVariableFunctionOptimizer >> reset [
-	[ bestPoints isEmpty] whileFalse: [ bestPoints removeLast]
+
+	bestPoints removeAll
 ]
diff --git a/src/Math-Numerical/PMOptimizingBracketFinder.class.st b/src/Math-Numerical/PMOptimizingBracketFinder.class.st
@@ -12,39 +12,45 @@ PMOptimizingBracketFinder class >> initialPoints: aSortedCollection function: aF
 
 { #category : #operation }
 PMOptimizingBracketFinder >> computeInitialValues [
-	| random |
-	random := Random new.
 
-	[ bestPoints size < 2 ] whileTrue: [
-		self addPointAt: random next ]
+	[ bestPoints size < 2 ] whileTrue: [ self addPointAt: self randomGenerator next ]
 ]
 
 { #category : #operation }
 PMOptimizingBracketFinder >> evaluateIteration [
+
 	| x1 x2 |
-	x1 := ( bestPoints at: 1) position.
-	x2 := ( bestPoints at: 2) position.
-	self addPointAt: ( x1 * 3 - ( x2 * 2)).
-	precision := ( x2 - x1) * ( ( bestPoints at: 3) position - x1).
-	self hasConverged
-		ifFalse:[ bestPoints removeLast].
-	^precision
+	x1 := (bestPoints at: 1) position.
+	x2 := (bestPoints at: 2) position.
+	self addPointAt: x1 * 3 - (x2 * 2).
+	precision := x2 - x1 * ((bestPoints at: 3) position - x1).
+	self hasConverged ifFalse: [ bestPoints removeLast ].
+	^ precision
 ]
 
 { #category : #operation }
 PMOptimizingBracketFinder >> finalizeIterations [
 	result := bestPoints
 ]
 
+{ #category : #initialization }
+PMOptimizingBracketFinder >> initialize [
+
+	super initialize.
+	self randomGenerator: Random new
+]
+
 { #category : #initialization }
 PMOptimizingBracketFinder >> initializeForOptimizer: aFunctionOptimizer [
-		"Private"
+	"Private"
+
 	super initializeForOptimizer: aFunctionOptimizer.
 	bestPoints := aFunctionOptimizer bestPoints
 ]
 
 { #category : #initialization }
 PMOptimizingBracketFinder >> setInitialPoints: aSortedCollection [
-		"Private"
+	"Private"
+
 	bestPoints := aSortedCollection
 ]
diff --git a/src/Math-Numerical/PMSimplexOptimizer.class.st b/src/Math-Numerical/PMSimplexOptimizer.class.st
@@ -2,7 +2,8 @@ Class {
 	#name : #PMSimplexOptimizer,
 	#superclass : #PMFunctionOptimizer,
 	#instVars : [
-		'worstVector'
+		'worstVector',
+		'randomGenerator'
 	],
 	#category : #'Math-Numerical-Math-FunctionIterator'
 }
@@ -18,26 +19,24 @@ PMSimplexOptimizer >> buildInitialSimplex [
 	"Private"
 
 	| projectedFunction finder partialResult |
-	projectedFunction := PMProjectedOneVariableFunction
-				function: functionBlock.
+	projectedFunction := PMProjectedOneVariableFunction function: functionBlock.
 	finder := PMOneVariableFunctionOptimizer forOptimizer: self.
+	self randomGenerator ifNotNil: [ :generator | finder randomGenerator: generator ].
 	finder setFunction: projectedFunction.
-	[bestPoints size < (result size + 1)] whileTrue:
-			[projectedFunction
-				setArgument: result;
-				bumpIndex.
-			partialResult := finder
-						reset;
-						evaluate.
-			bestPoints add: (optimizingPointClass
-						vector: (projectedFunction argumentWith: partialResult)
-						function: functionBlock)]
+	[ bestPoints size < (result size + 1) ] whileTrue: [
+		projectedFunction
+			setArgument: result;
+			bumpIndex.
+		partialResult := finder
+			                 reset;
+			                 evaluate.
+		bestPoints add: (optimizingPointClass vector: (projectedFunction argumentWith: partialResult) function: functionBlock) ]
 ]
 
 { #category : #initialization }
 PMSimplexOptimizer >> computeInitialValues [
-	bestPoints
-		add: (optimizingPointClass vector: result function: functionBlock).
+
+	bestPoints add: (optimizingPointClass vector: result function: functionBlock).
 	self buildInitialSimplex.
 	worstVector := bestPoints removeLast position
 ]
@@ -106,3 +105,15 @@ PMSimplexOptimizer >> printOn: aStream [
 	aStream cr.
 	worstVector printOn: aStream
 ]
+
+{ #category : #accessing }
+PMSimplexOptimizer >> randomGenerator [
+
+	^ randomGenerator
+]
+
+{ #category : #accessing }
+PMSimplexOptimizer >> randomGenerator: anObject [
+
+	randomGenerator := anObject
+]
diff --git a/src/Math-Tests-Numerical/PMNumericalMethodsTestCase.class.st b/src/Math-Tests-Numerical/PMNumericalMethodsTestCase.class.st
@@ -819,6 +819,7 @@ PMNumericalMethodsTestCase >> testOptimizeOneDimension [
 	| distr finder maximum |
 	distr := PMGammaDistribution shape: 2 scale: 5.
 	finder := PMOneVariableFunctionOptimizer maximizingFunction: distr.
+	finder randomGenerator: (Random seed: 42).
 	finder desiredPrecision: 1.0e-6.
 	maximum := finder evaluate.
 	self assert: (maximum - 5) abs < 1.0e-6.
@@ -848,8 +849,9 @@ PMNumericalMethodsTestCase >> testOptimizeSimplex [
 
 	| fBlock simplex educatedGuess result |
 	fBlock := [ :x | (x * x) negated exp ].
-	educatedGuess := #(0.5 1.0 0.5) asPMVector.
+	educatedGuess := #( 0.5 1.0 0.5 ) asPMVector.
 	simplex := PMSimplexOptimizer maximizingFunction: fBlock.
+	simplex randomGenerator: (Random seed: 42).
 	simplex initialValue: educatedGuess.
 	simplex desiredPrecision: 1.0e-6.
 	result := simplex evaluate.

Original file line number	Diff line number	Diff line change
`@@ -82,8 +82,7 @@ PMIterativeProcess >> initialize [`
`82`	`82`	`super initialize.`
`83`	`83`
`84`	`84`	`desiredPrecision := self class defaultPrecision.`
`85`		`- maximumIterations := self class defaultMaximumIterations.`
`86`		`- ^ self`
	`85`	`+ maximumIterations := self class defaultMaximumIterations`
`87`	`86`	`]`
`88`	`87`
`89`	`88`	`{ #category : #operation }`