4385132063

Build # 4385132063

Build Type

push

github

Committed by GitHub

Commit Message

Merge pull request #316 from jecisc/divers-cleanings

Run Details

2977 of 2977 new or added lines in 214 files covered. (100.0%)

19725 of 24212 relevant lines covered (81.47%)

2.44 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.0

/src/Math-ODE/PMODESolver.class.st

"
An ODE Solver uses a Stepper to solve a System. 

The main interface once the solver is set up (it has a stepper and a solver) is
        solve: system x0: aState t0: startTime t1: endTime
        solve: system x0: aState t0: startTime t1: endTime stepSize: dt
        
Announcements are made when a step is taken.
"
Class {
        #name : #PMODESolver,
        #superclass : #Object,
        #instVars : [
                'stepper',
                'system',
                'dt',
                'announcer',
                'lastTime',
                'state'
        ],
        #category : #'Math-ODE'
}

{ #category : #'class variables' }
PMODESolver class >> stepperClass [
        ^ShouldBeImplemented
]

{ #category : #solving }
PMODESolver >> announceState: aState time: aTime [
        self announcer announce: (self announcementClass state: aState time: aTime)
]

{ #category : #'announcement hooks' }
PMODESolver >> announcementClass [
        ^ self subclassResponsibility
]

{ #category : #accessing }
PMODESolver >> announcer [
        ^ announcer
]

{ #category : #accessing }
PMODESolver >> announcer: anAnnouncer [
        announcer  := anAnnouncer
]

{ #category : #'announcement hooks' }
PMODESolver >> announcerClass [

        ^ self subclassResponsibility
]

{ #category : #accessing }
PMODESolver >> dt [
        ^ dt
]

{ #category : #accessing }
PMODESolver >> dt: aFloat [
        dt := aFloat
]

{ #category : #initialization }
PMODESolver >> initialize [

        super initialize.
        announcer := self announcerClass new
]

{ #category : #solving }
PMODESolver >> lastStepState: aState endTime: endTime [
        "catch partial or full step at end"
        (lastTime closeTo: endTime )
                ifFalse:
                        [state := stepper
                                lastStep: state
                                time: lastTime
                                stepSize: endTime - lastTime
                                deltaT: dt.
                                self announceState: state time: endTime].
        ^ state
]

{ #category : #solving }
PMODESolver >> mainStepsState: aState startTime: initialTime endTime: endTime [
        state := aState.
        "don't go to end time to avoid overrunning"
        (initialTime to: endTime - self dt  by: self dt) do:
                [:time |
                        state := stepper
                                doStep: state
                                time:  time
                                stepSize: self dt.
                                "announce step results"
                                self announceState: state time: time + self dt.
                                lastTime := time + self dt].

        ^ state
]

{ #category : #solving }
PMODESolver >> solve: aSystem startState: initialState startTime: initialTime endTime: endTime [

        self system: aSystem.
        stepper ifNil: [
                self stepper: ((self stepperClass) onSystem: self system)].
        state := initialState.
      lastTime:=initialTime.

        "announce initial conditions"
        self announceState: state time: initialTime.

        (lastTime+dt > endTime and: lastTime < endTime)
        ifTrue:[
                state :=self lastStepState: state endTime: endTime].

        lastTime+dt<= endTime
        ifTrue:[
        "step until the end"
        state := self mainStepsState: state startTime: initialTime endTime: endTime.

        "sanity check"
        self assert: [(lastTime between: initialTime and: endTime)
                                or: [lastTime between: endTime and: initialTime]].

        "take another step if needed"
        state := self lastStepState: state endTime: endTime.].

        ^ state
]

{ #category : #solving }
PMODESolver >> solve: aSystem startState: initialState startTime: initialTime endTime: endTime stepSize: timeStep [
        self dt: timeStep.
        ^ self solve: aSystem  startState:  initialState  startTime:  initialTime endTime: endTime
]

{ #category : #accessing }
PMODESolver >> stepper: aStepper [

        stepper := aStepper.
        system ifNotNil: [ stepper system: system ]
]

{ #category : #private }
PMODESolver >> stepperClass [
        ^ self class stepperClass
]

{ #category : #accessing }
PMODESolver >> system [

        ^ system
]

{ #category : #accessing }
PMODESolver >> system: aSystem [

        system := aSystem.
        stepper ifNotNil: [ stepper system: aSystem ]
]

1	"
2	An ODE Solver uses a Stepper to solve a System.
3
4	The main interface once the solver is set up (it has a stepper and a solver) is
5	solve: system x0: aState t0: startTime t1: endTime
6	solve: system x0: aState t0: startTime t1: endTime stepSize: dt
7
8	Announcements are made when a step is taken.
9	"
10	Class {
11	#name : #PMODESolver,
12	#superclass : #Object,
13	#instVars : [
14	'stepper',
15	'system',
16	'dt',
17	'announcer',
18	'lastTime',
19	'state'
20	],
21	#category : #'Math-ODE'
22	}
23
24	{ #category : #'class variables' }
25	PMODESolver class >> stepperClass [	×
26	^ShouldBeImplemented	×
27	]	×
28
29	{ #category : #solving }
30	PMODESolver >> announceState: aState time: aTime [	3✔
31	self announcer announce: (self announcementClass state: aState time: aTime)	3✔
32	]	3✔
33
34	{ #category : #'announcement hooks' }
35	PMODESolver >> announcementClass [
36	^ self subclassResponsibility
37	]
38
39	{ #category : #accessing }
40	PMODESolver >> announcer [	3✔
41	^ announcer	3✔
42	]	3✔
43
44	{ #category : #accessing }
45	PMODESolver >> announcer: anAnnouncer [	×
46	announcer := anAnnouncer	×
47	]	×
48
49	{ #category : #'announcement hooks' }
50	PMODESolver >> announcerClass [
51
52	^ self subclassResponsibility
53	]
54
55	{ #category : #accessing }
56	PMODESolver >> dt [	3✔
57	^ dt	3✔
58	]	3✔
59
60	{ #category : #accessing }
61	PMODESolver >> dt: aFloat [	3✔
62	dt := aFloat	3✔
63	]	3✔
64
65	{ #category : #initialization }
66	PMODESolver >> initialize [	3✔
67		3✔
68	super initialize.	3✔
69	announcer := self announcerClass new	3✔
70	]	3✔
71
72	{ #category : #solving }
73	PMODESolver >> lastStepState: aState endTime: endTime [	3✔
74	"catch partial or full step at end"	3✔
75	(lastTime closeTo: endTime )	3✔
76	ifFalse:	3✔
77	[state := stepper	3✔
78	lastStep: state	3✔
79	time: lastTime	3✔
80	stepSize: endTime - lastTime	3✔
81	deltaT: dt.	3✔
82	self announceState: state time: endTime].	3✔
83	^ state	3✔
84	]	3✔
85
86	{ #category : #solving }
87	PMODESolver >> mainStepsState: aState startTime: initialTime endTime: endTime [	3✔
88	state := aState.	3✔
89	"don't go to end time to avoid overrunning"	3✔
90	(initialTime to: endTime - self dt by: self dt) do:	3✔
91	[:time \|	3✔
92	state := stepper	3✔
93	doStep: state	3✔
94	time: time	3✔
95	stepSize: self dt.	3✔
96	"announce step results"	3✔
97	self announceState: state time: time + self dt.	3✔
98	lastTime := time + self dt].	3✔
99		3✔
100	^ state	3✔
101	]	3✔
102
103	{ #category : #solving }
104	PMODESolver >> solve: aSystem startState: initialState startTime: initialTime endTime: endTime [	3✔
105		3✔
106	self system: aSystem.	3✔
107	stepper ifNil: [	3✔
108	self stepper: ((self stepperClass) onSystem: self system)].	3✔
109	state := initialState.	3✔
110	lastTime:=initialTime.	3✔
111		3✔
112	"announce initial conditions"	3✔
113	self announceState: state time: initialTime.	3✔
114		3✔
115	(lastTime+dt > endTime and: lastTime < endTime)	3✔
116	ifTrue:[	3✔
117	state :=self lastStepState: state endTime: endTime].	3✔
118		3✔
119	lastTime+dt<= endTime	3✔
120	ifTrue:[	3✔
121	"step until the end"	3✔
122	state := self mainStepsState: state startTime: initialTime endTime: endTime.	3✔
123		3✔
124	"sanity check"	3✔
125	self assert: [(lastTime between: initialTime and: endTime)	3✔
126	or: [lastTime between: endTime and: initialTime]].	3✔
127		3✔
128	"take another step if needed"	3✔
129	state := self lastStepState: state endTime: endTime.].	3✔
130		3✔
131	^ state	3✔
132	]	3✔
133
134	{ #category : #solving }
135	PMODESolver >> solve: aSystem startState: initialState startTime: initialTime endTime: endTime stepSize: timeStep [	3✔
136	self dt: timeStep.	3✔
137	^ self solve: aSystem startState: initialState startTime: initialTime endTime: endTime	3✔
138	]	3✔
139
140	{ #category : #accessing }
141	PMODESolver >> stepper: aStepper [	3✔
142		3✔
143	stepper := aStepper.	3✔
144	system ifNotNil: [ stepper system: system ]	3✔
145	]	3✔
146
147	{ #category : #private }
148	PMODESolver >> stepperClass [	3✔
149	^ self class stepperClass	3✔
150	]	3✔
151
152	{ #category : #accessing }
153	PMODESolver >> system [	3✔
154		3✔
155	^ system	3✔
156	]	3✔
157
158	{ #category : #accessing }
159	PMODESolver >> system: aSystem [	3✔
160		3✔
161	system := aSystem.	3✔
162	stepper ifNotNil: [ stepper system: aSystem ]	3✔
163	]	3✔

PolyMathOrg / PolyMath / 4385132063

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous