- Refactor isNil ifTrue: as ifNil: (#229)

- Demos with announcement are working again
PolyMathOrg · Apr 3, 2022 · d70167c · d70167c
1 parent b5affe0
commit d70167c
Show file tree

Hide file tree

Showing 19 changed files with 296 additions and 170 deletions.
diff --git a/src/Math-ODE/PMAB2Stepper.class.st b/src/Math-ODE/PMAB2Stepper.class.st
@@ -15,9 +15,10 @@ PMAB2Stepper class >> order [
 
 { #category : #stepping }
 PMAB2Stepper >> doStep: aState prevState: prevState time: t [
-	self stepSize isNil
-		ifTrue: [ self error: 'step size required by stepper' ].
-	^ (self stepSize / 2) * (3 * (system state: aState time: t) - (system state: prevState time: t - self stepSize)) + aState
+
+	self stepSize ifNil: [ self error: 'step size required by stepper' ].
+	^ self stepSize / 2 * (3 * (system state: aState time: t)
+	   - (system state: prevState time: t - self stepSize)) + aState
 ]
 
 { #category : #stepping }
@@ -30,10 +31,10 @@ PMAB2Stepper >> doStep: aState prevState: prevState time: t  stepSize: timeStep
 { #category : #stepping }
 PMAB2Stepper >> lastStep: aState prevState: prevState time: t deltaT: incrementOfTime [
 
-	self stepSize isNil
-		ifTrue: [ self error: 'step size required by stepper' ].
+	self stepSize ifNil: [ self error: 'step size required by stepper' ].
 
-	^ self stepSize / 2 * (3 * (system state: aState time: t) - (system state: prevState time: t - incrementOfTime)) + aState
+	^ self stepSize / 2 * (3 * (system state: aState time: t)
+	   - (system state: prevState time: t - incrementOfTime)) + aState
 ]
 
 { #category : #stepping }

diff --git a/src/Math-ODE/PMAB3Stepper.class.st b/src/Math-ODE/PMAB3Stepper.class.st
@@ -15,12 +15,17 @@ PMAB3Stepper class >> order [
 ]
 
 { #category : #stepping }
-PMAB3Stepper >> doStep: thisState prevState:prevState prevPrevState: prevPrevState prevPrevTime: prevPrevTime [
-
-	self stepSize isNil
-		ifTrue: [ self error: 'step size required by stepper' ].
-	 ^ self stepSize * (  ( (23/12) * (system state: thisState time:  prevPrevTime+ (2* self stepSize) )) - ((4/3)*(system state: prevState time: prevPrevTime+ self stepSize)) + ((5/12)*(system state: prevPrevState time: prevPrevTime ) )) + thisState.
-
+PMAB3Stepper >> doStep: thisState prevState: prevState prevPrevState: prevPrevState prevPrevTime: prevPrevTime [
+
+	self stepSize ifNil: [ self error: 'step size required by stepper' ].
+	^ self stepSize * (23 / 12
+	   *
+	   (system state: thisState time: prevPrevTime + (2 * self stepSize))
+	   -
+	   (4 / 3
+	    * (system state: prevState time: prevPrevTime + self stepSize))
+	   + (5 / 12 * (system state: prevPrevState time: prevPrevTime)))
+	  + thisState
 ]
 
 { #category : #stepping }
@@ -31,11 +36,17 @@ PMAB3Stepper >> doStep: thisState prevState: prevState prevPrevState: prevPrevSt
 
 { #category : #stepping }
 PMAB3Stepper >> lastStep: thisState prevState: prevState prevPrevState: prevPrevState prevPrevTime: prevPrevTime deltaT: incrementOfTime [
-	self stepSize isNil
-		ifTrue: [ self error: 'step size required by stepper' ].	
-
-	 ^ self stepSize * (  ( (23/12) * (system state: thisState time:  prevPrevTime+ (2* incrementOfTime) )) - ((4/3)*(system state: prevState time: prevPrevTime+ incrementOfTime)) + ((5/12)*(system state: prevPrevState time: prevPrevTime ) )) + thisState.
 
+	self stepSize ifNil: [ self error: 'step size required by stepper' ].
+
+	^ self stepSize * (23 / 12
+	   *
+	   (system
+		    state: thisState
+		    time: prevPrevTime + (2 * incrementOfTime)) - (4 / 3
+	    * (system state: prevState time: prevPrevTime + incrementOfTime))
+	   + (5 / 12 * (system state: prevPrevState time: prevPrevTime)))
+	  + thisState
 ]
 
 { #category : #stepping }

diff --git a/src/Math-ODE/PMAB4Stepper.class.st b/src/Math-ODE/PMAB4Stepper.class.st
@@ -15,11 +15,18 @@ PMAB4Stepper class >> order [
 ]
 
 { #category : #stepping }
-PMAB4Stepper >> doStep3State: thirdState secondState:secondState firstState: firstState initState: initState initTime: initTime [
-
-	self stepSize isNil
-		ifTrue: [ self error: 'step size required by stepper' ].
-	 ^ self stepSize * (  ( (55/24) * (system state: thirdState time:  initTime+ (3* self stepSize) )) - ((59/24)*(system state: secondState time: initTime+ (2* self stepSize))) + ((37/24)*(system state: firstState time: initTime+ self stepSize ) )-   ((3/8)*(system state: initState time: initTime ) )) + thirdState.
+PMAB4Stepper >> doStep3State: thirdState secondState: secondState firstState: firstState initState: initState initTime: initTime [
+
+	self stepSize ifNil: [ self error: 'step size required by stepper' ].
+	^ self stepSize * (55 / 24
+	   * (system state: thirdState time: initTime + (3 * self stepSize))
+	   - (59 / 24
+		    *
+		    (system state: secondState time: initTime + (2 * self stepSize)))
+	   +
+	   (37 / 24
+	    * (system state: firstState time: initTime + self stepSize))
+	   - (3 / 8 * (system state: initState time: initTime))) + thirdState
 ]
 
 { #category : #stepping }
@@ -29,12 +36,21 @@ PMAB4Stepper >> doStep3State: thirdState secondState:secondState firstState: fir
 ]
 
 { #category : #stepping }
-PMAB4Stepper >> lastStep: thirdState secondState:secondState firstState: firstState initState: initState initTime: initTime deltaT: incrementOfTime [
-
-	self stepSize isNil
-		ifTrue: [ self error: 'step size required by stepper' ].
-	 ^ self stepSize * (  ( (55/24) * (system state: thirdState time:  initTime+ (3* incrementOfTime) )) - ((59/24)*(system state: secondState time: initTime+ (2* incrementOfTime))) + ((37/24)*(system state: firstState time: initTime+ incrementOfTime ) )-   ((3/8)*(system state: initState time: initTime ) )) + thirdState.
-
+PMAB4Stepper >> lastStep: thirdState secondState: secondState firstState: firstState initState: initState initTime: initTime deltaT: incrementOfTime [
+
+	self stepSize ifNil: [ self error: 'step size required by stepper' ].
+	^ self stepSize * (55 / 24
+	   *
+	   (system state: thirdState time: initTime + (3 * incrementOfTime))
+	   - (59 / 24
+		    *
+		    (system
+			     state: secondState
+			     time: initTime + (2 * incrementOfTime)))
+	   +
+	   (37 / 24
+	    * (system state: firstState time: initTime + incrementOfTime))
+	   - (3 / 8 * (system state: initState time: initTime))) + thirdState
 ]
 
 { #category : #stepping }

diff --git a/src/Math-ODE/PMAM3Stepper.class.st b/src/Math-ODE/PMAM3Stepper.class.st
@@ -17,22 +17,28 @@ PMAM3Stepper class >> order [
 
 { #category : #stepping }
 PMAM3Stepper >> doStep: aState prevState: prevState time: t [
+
 	| approximateState1 approximateState2 |
-	self stepSize isNil
-		ifTrue: [ self error: 'step size required by stepper' ].
-	approximateState1 := aState + (self stepSize * (system state: aState time: t + self stepSize)).
-	approximateState2 := aState
-		+
-			(self stepSize
-				*
-					(5 / 12 * (system state: approximateState1 time: t + (2 * self stepSize)) + (2 / 3 * (system state: aState time: t + self stepSize))
-						- (1 / 12 * (system state: prevState time: t)))).
-	^ aState
-		+
-			(self stepSize
-				*
-					(5 / 12 * (system state: approximateState2 time: t + (2 * self stepSize)) + (2 / 3 * (system state: aState time: t + self stepSize))
-						- (1 / 12 * (system state: prevState time: t))))
+	self stepSize ifNil: [ self error: 'step size required by stepper' ].
+	approximateState1 := aState
+	                     +
+	                     (self stepSize
+	                      *
+	                      (system state: aState time: t + self stepSize)).
+	approximateState2 := aState + (self stepSize * (5 / 12
+	                       *
+	                       (system
+		                        state: approximateState1
+		                        time: t + (2 * self stepSize))
+	                       +
+	                       (2 / 3
+	                        *
+	                        (system state: aState time: t + self stepSize))
+	                       - (1 / 12 * (system state: prevState time: t)))).
+	^ aState + (self stepSize * (5 / 12
+	    * (system state: approximateState2 time: t + (2 * self stepSize))
+	    + (2 / 3 * (system state: aState time: t + self stepSize))
+	    - (1 / 12 * (system state: prevState time: t))))
 ]
 
 { #category : #stepping }
@@ -45,22 +51,31 @@ PMAM3Stepper >> doStep: aState prevState: prevState time: t stepSize: timeStep [
 
 { #category : #stepping }
 PMAM3Stepper >> lastStep: aState prevState: prevState time: t deltaT: incrementOfTime [
+
 	| approximateState1 approximateState2 |
-	self stepSize isNil
-		ifTrue: [ self error: 'step size required by stepper' ].
-	approximateState1 := aState + (self stepSize * (system state: aState time: t + incrementOfTime)).
-	approximateState2 := aState
-		+
-			(self stepSize
-				*
-					(5 / 12 * (system state: approximateState1 time: t + (2 * incrementOfTime))
-						+ (2 / 3 * (system state: aState time: t + incrementOfTime)) - (1 / 12 * (system state: prevState time: t)))).
-	^ aState
-		+
-			(self stepSize
-				*
-					(5 / 12 * (system state: approximateState2 time: t + (2 * incrementOfTime))
-						+ (2 / 3 * (system state: aState time: t + incrementOfTime)) - (1 / 12 * (system state: prevState time: t))))
+	self stepSize ifNil: [ self error: 'step size required by stepper' ].
+	approximateState1 := aState
+	                     +
+	                     (self stepSize
+	                      *
+	                      (system state: aState time: t + incrementOfTime)).
+	approximateState2 := aState + (self stepSize * (5 / 12
+	                       *
+	                       (system
+		                        state: approximateState1
+		                        time: t + (2 * incrementOfTime))
+	                       +
+	                       (2 / 3
+	                        *
+	                        (system
+		                         state: aState
+		                         time: t + incrementOfTime))
+	                       - (1 / 12 * (system state: prevState time: t)))).
+	^ aState + (self stepSize * (5 / 12
+	    *
+	    (system state: approximateState2 time: t + (2 * incrementOfTime))
+	    + (2 / 3 * (system state: aState time: t + incrementOfTime))
+	    - (1 / 12 * (system state: prevState time: t))))
 ]
 
 { #category : #stepping }

diff --git a/src/Math-ODE/PMAM4Stepper.class.st b/src/Math-ODE/PMAM4Stepper.class.st
@@ -17,24 +17,41 @@ PMAM4Stepper class >> order [
 
 { #category : #stepping }
 PMAM4Stepper >> doStep: aState prevState: prevState prevPrevState: prevPrevState time: t [
+
 	| approximateState1 approximateState2 |
-	self stepSize isNil
-		ifTrue: [ self error: 'step size required by stepper' ].
-	approximateState1 := aState + (self stepSize * (system state: aState time: t)).
-	approximateState2 := aState
-		+
-			(self stepSize
-				*
-					(3 / 8 * (system state: approximateState1 time: t + self stepSize) + (19 / 24 * (system state: aState time: t))
-						- (5 / 24 * (system state: prevState time: t - self stepSize))
-						+ (1 / 24 * (system state: prevPrevState time: t - (2 * self stepSize))))).
-	^ aState
-		+
-			(self stepSize
-				*
-					(3 / 8 * (system state: approximateState2 time: t + self stepSize) + (19 / 24 * (system state: aState time: t))
-						- (5 / 24 * (system state: prevState time: t - self stepSize))
-						+ (1 / 24 * (system state: prevPrevState time: t - (2 * self stepSize)))))
+	self stepSize ifNil: [ self error: 'step size required by stepper' ].
+	approximateState1 := aState
+	                     +
+	                     (self stepSize * (system state: aState time: t)).
+	approximateState2 := aState + (self stepSize
+	                      *
+		                      (3 / 8
+		                       *
+		                       (system
+			                        state: approximateState1
+			                        time: t + self stepSize)
+		                       + (19 / 24 * (system state: aState time: t))
+		                       -
+		                       (5 / 24
+		                        *
+		                        (system
+			                         state: prevState
+			                         time: t - self stepSize))
+		                       +
+		                       (1 / 24
+		                        *
+		                        (system
+			                         state: prevPrevState
+			                         time: t - (2 * self stepSize))))).
+	^ aState + (self stepSize
+	   *
+		   (3 / 8
+		    * (system state: approximateState2 time: t + self stepSize)
+		    + (19 / 24 * (system state: aState time: t))
+		    - (5 / 24 * (system state: prevState time: t - self stepSize))
+		    +
+		    (1 / 24
+		     * (system state: prevPrevState time: t - (2 * self stepSize)))))
 ]
 
 { #category : #stepping }
@@ -51,24 +68,39 @@ PMAM4Stepper >> doStep: aState prevState: prevState prevPrevState: prevPrevState
 
 { #category : #stepping }
 PMAM4Stepper >> lastStep: aState prevState: prevState prevPrevState: prevPrevState time: t deltaT: incrementOfTime [
+
 	| approximateState1 approximateState2 |
-	self stepSize isNil
-		ifTrue: [ self error: 'step size required by stepper' ].
-	approximateState1 := aState + (self stepSize * (system state: aState time: t)).
-	approximateState2 := aState
-		+
-			(self stepSize
-				*
-					(3 / 8 * (system state: approximateState1 time: t + incrementOfTime) + (19 / 24 * (system state: aState time: t))
-						- (5 / 24 * (system state: prevState time: t - incrementOfTime))
-						+ (1 / 24 * (system state: prevPrevState time: t - (2 * incrementOfTime))))).
-	^ aState
-		+
-			(self stepSize
-				*
-					(3 / 8 * (system state: approximateState2 time: t + incrementOfTime) + (19 / 24 * (system state: aState time: t))
-						- (5 / 24 * (system state: prevState time: t - incrementOfTime))
-						+ (1 / 24 * (system state: prevPrevState time: t - (2 * incrementOfTime)))))
+	self stepSize ifNil: [ self error: 'step size required by stepper' ].
+	approximateState1 := aState
+	                     +
+	                     (self stepSize * (system state: aState time: t)).
+	approximateState2 := aState + (self stepSize
+	                      *
+		                      (3 / 8
+		                       *
+		                       (system
+			                        state: approximateState1
+			                        time: t + incrementOfTime)
+		                       + (19 / 24 * (system state: aState time: t))
+		                       -
+		                       (5 / 24
+		                        *
+		                        (system
+			                         state: prevState
+			                         time: t - incrementOfTime)) + (1 / 24
+		                        *
+		                        (system
+			                         state: prevPrevState
+			                         time: t - (2 * incrementOfTime))))).
+	^ aState + (self stepSize
+	   *
+		   (3 / 8
+		    * (system state: approximateState2 time: t + incrementOfTime)
+		    + (19 / 24 * (system state: aState time: t))
+		    - (5 / 24 * (system state: prevState time: t - incrementOfTime))
+		    + (1 / 24
+			     *
+			     (system state: prevPrevState time: t - (2 * incrementOfTime)))))
 ]
 
 { #category : #stepping }

diff --git a/src/Math-ODE/PMBDF2Stepper.class.st b/src/Math-ODE/PMBDF2Stepper.class.st
@@ -18,11 +18,13 @@ PMBDF2Stepper class >> order [
 
 { #category : #stepping }
 PMBDF2Stepper >> doStep: aState prevState: prevState time: t [
-	|approximateState |
-	self stepSize isNil
-		ifTrue: [ self error: 'step size required by stepper' ].
-approximateState := (system state: aState time: t) * self stepSize + aState.
-	^ ((4 / 3) * aState) - ((1 / 3) * prevState) + ((2 / 3) * self stepSize * (system state: approximateState time: t + self stepSize))
+
+	| approximateState |
+	self stepSize ifNil: [ self error: 'step size required by stepper' ].
+	approximateState := (system state: aState time: t) * self stepSize
+	                    + aState.
+	^ 4 / 3 * aState - (1 / 3 * prevState) + (2 / 3 * self stepSize
+	   * (system state: approximateState time: t + self stepSize))
 ]
 
 { #category : #stepping }

diff --git a/src/Math-ODE/PMBDF3Stepper.class.st b/src/Math-ODE/PMBDF3Stepper.class.st
@@ -17,12 +17,15 @@ PMBDF3Stepper class >> order [
 ]
 
 { #category : #stepping }
-PMBDF3Stepper >> doStep: aState prevState: prevState prevPrevState: prevPrevState time: t [ 
-	|approximateState |
-	self stepSize isNil
-		ifTrue: [ self error: 'step size required by stepper' ].
-approximateState := (system state: aState time: t) * self stepSize + aState.
-	^ ((18 / 11) * aState) - ((9 / 11) * prevState) +((2 / 11) * prevPrevState)+ ((6 / 11) * self stepSize * (system state: approximateState time: t + self stepSize))
+PMBDF3Stepper >> doStep: aState prevState: prevState prevPrevState: prevPrevState time: t [
+
+	| approximateState |
+	self stepSize ifNil: [ self error: 'step size required by stepper' ].
+	approximateState := (system state: aState time: t) * self stepSize
+	                    + aState.
+	^ 18 / 11 * aState - (9 / 11 * prevState) + (2 / 11 * prevPrevState)
+	  + (6 / 11 * self stepSize
+		   * (system state: approximateState time: t + self stepSize))
 ]
 
 { #category : #stepping }

diff --git a/src/Math-ODE/PMBDF4Stepper.class.st b/src/Math-ODE/PMBDF4Stepper.class.st
@@ -16,13 +16,16 @@ PMBDF4Stepper class >> order [
 ]
 
 { #category : #stepping }
-PMBDF4Stepper >> doStep3State: thirdState secondState:secondState firstState: firstState initState: initState
- thirdTime: t [ 
-	|approximateState |
-	self stepSize isNil
-		ifTrue: [ self error: 'step size required by stepper' ].
-approximateState := (system state: thirdState time: t) * self stepSize + thirdState.
-	^ ((48 / 25) * thirdState) - ((36 / 25) * secondState) + ((16 / 25) * firstState) - ((3 / 25) * initState) + ((12 / 25) * self stepSize * (system state: approximateState time: t + self stepSize))
+PMBDF4Stepper >> doStep3State: thirdState secondState: secondState firstState: firstState initState: initState thirdTime: t [
+
+	| approximateState |
+	self stepSize ifNil: [ self error: 'step size required by stepper' ].
+	approximateState := (system state: thirdState time: t)
+	                    * self stepSize + thirdState.
+	^ 48 / 25 * thirdState - (36 / 25 * secondState)
+	  + (16 / 25 * firstState) - (3 / 25 * initState)
+	  + (12 / 25 * self stepSize
+		   * (system state: approximateState time: t + self stepSize))
 ]
 
 { #category : #stepping }