Google
 

Trailing-Edge - PDP-10 Archives - decuslib20-03 - decus/20-0078/util/cadsim.sim
There is 1 other file named cadsim.sim in the archive. Click here to see a list.
00100	OPTIONS(/E);
00200	EXTERNAL PROCEDURE abort;
00300	EXTERNAL REF(Infile) PROCEDURE findinfile;
00400	EXTERNAL REF(Outfile) PROCEDURE findoutfile;
00500	EXTERNAL TEXT PROCEDURE conc,upcase,frontstrip,rest,
00600	checkextension;
00700	EXTERNAL CHARACTER PROCEDURE fetchar,findtrigger;
00800	EXTERNAL LONG REAL PROCEDURE scanreal;
00900	EXTERNAL INTEGER PROCEDURE checkreal,checkint,scanint,ilog;
01000	EXTERNAL BOOLEAN PROCEDURE menu;
01100	EXTERNAL CLASS simeio;
01200	COMMENT----------------------------------------------------------------+
01300	!                                                                      !
01400	!                                CADSIM                                !
01500	!                                ------                                !
01600	!                                                                      !
01700	!                 CONTINUOUS AND DISCRETE SIMULATION                   !
01800	!                                                                      !
01900	!         BY ROBERT J. W. SIM                                          !
02000	!            DEPARTMENT OF COMPUTING AND CONTROL,                      !
02100	!            IMPERIAL COLLEGE,                                         !
02200	!            LONDON S.W.7                                              !
02300	!                                                                      !
02400	!            IMPLEMENTED JULY 1975                                     !
02500	!                                                                      !
02600	!   THIS VERSION NO 1.0 1977-12-13 BY                                  !
02700	!            G.LYMAN AND I.NORDSTROEM                                  !
02800	!            DEPARTMENT OF WEAPON SYSTEMS                              !
02900	!                                                                      !
03000	!            M.OHLIN                                                   !
03100	!            DEPARTMENT OF PLANNING AND OPERATIONS RESEARCH            !
03200	!                                                                      !
03300	!            SWEDISH NATIONAL DEFENCE RESEARCH INSTITUTE               !
03400	!            S-104 50 STOCKHOLM 80                                     !
03500	!      							               !
03600	!   CADSIM IS A SUBCLASS OF SIMULATION AND SAFEIO DESIGNED TO PROVIDE  !
03700	!   FACILITIES FOR COMBINED DISCRETE EVENT AND CONTINUOUS SYSTEM       !
03800	!   SIMULATION.                                                        !
03900	!   CADSIM HAS ONE CLASS ATTRIBUTE                                     !
04000	!                                                                      !
04100	!           1) CLASS CONTINUOUS --- THIS IS THE COUNTERPART OF CLASS   !
04200	!                                  PROCESS IN DISCRETE EVENT SIMULATION!
04300	!                                  IT IS A SUBCLASS OF PROCESS.        !
04400	!                                                                      !
04500	+----------------------------------------------------------------------+
04600	;
04700	simeio CLASS cadsim;
04800	
04900	BEGIN
05000	
05100	    OPTIONS(/P:" ---*** CONTINUOUS ***---");
05200	
05300	    COMMENT----------------------------------------------------------------+
05400	    !                                                                      !
05500	    !   CLASS CONTINUOUS PROVIDES THE FRAMEWORK FOR OBJECTS WHICH OBEY     !
05600	    !   DIFFERENTIAL DYNAMICS.                                             !
05700	    !                                                                      !
05800	    !                                                                      !
05900	    !   THE PARAMETER, N, IS USED TO SPECIFY THE NUMBER OF FIRST ORDER     !
06000	    !   EQUATIONS USED IN PROCEDURE DERIVATIVES. ITS VALUE IS USED TO      !
06100	    !   DIMENSION ALL USER ACCESSIBLE ARRAYS AND IN PROCEDURES ERROR       !
06200	    !   AND TAKE_A_STEP.                                                   !
06300	    !                                                                      !
06400	    !                         VIRTUAL PROCEDURES                           !
06500	    !                                                                      !
06600	    !   DERIVATIVES   :THIS PROCEDURE GIVES THE RELATIONSHIP BETWEEN THE   !
06700	    !                  ELEMENTS OF THE RATE AND SATE VECTORS.              !
06800	    !                  IT MUST ALWAYS BE WRITTEN BY THE USER.              !
06900	    !                                                                      !
07000	    !   ERROR         :THE USER MAY REWRITE THIS IF HE BELIEVES THAT HE    !
07100	    !                  NEEDS A DIFFERENT WAY OF OBTAINING THE CRITERIA FOR !
07200	    !                  HALVING THE STEP LENGTH.                            !
07300	    !                                                                      !
07400	    !   TAKE_A_STEP   :THIS MAY BE REWRITTEN IF THE USER REQUIRES A        !
07500	    !                  DIFFERENT METHOD OF ADVANCING THE INTEGRATION BY    !
07600	    !                  ONE STEP.                                           !
07700	    !                                                                      !
07800	    !   THE VARIABLES LISTED BELOW ARE GLOBAL TO CONTINUOUS OBJECTS AND    !
07900	    !   ARE THEREFOR AVAILABLE TO THE USER.                                !
08000	    !                                                                      !
08100	    !   MAX_H         :USER DEFINED MAXIMUM INTEGRATION STEP LENGTH        !
08200	    !   MIN_H         :USER DEFINED MINIMUM INTEGRATION STEP LENGTH        !
08300	    !   ERROR_LIMIT   :THE ACCURACY WHICH THE USER REQUIRES FROM THE       !
08400	    !                  INTEGRATION ROUTINE.                                !
08500	    !   T             :THE TIME RELATIVE TO THE START OF INTEGRATION.      !
08600	    !                                                                      !
08700	    !   RATE          :A VECTOR WHICH HOLDS THE VALUES OF THE RATE OF      !
08800	    !                  CHANGE OF THE STATE VARIABLES.                      !
08900	    !   STATE         :A VECTOR HOLDING THE VALUE OF THE STATE VARIABLES.  !
09000	    !   ERROR_VECTOR  :A VECTOR HOLDING THE ESTIMATED ERROR OF EACH STATE  !
09100	    !                  VARIABLE.                                           !
09200	    !   INITIAL_STATE :A VECTOR WHICH HOLDS THE VALUES OF THE STATE        !
09300	    !                  VARIABLES AT THE BEGINING OF EACH TIME STEP.        !
09400	    !                                                                      !
09500	    !   SLOPE_1, SLOPE_2, SLOPE_3           : VECTORS WHICH HOLD THE VALUE ! 
09600	    !                                         OF THE SLOPE OF THE FUNCTION !
09700	    !                                         AT POINTS WITHIN THE STEP.   !
09800	    !                                         THESE ARE NECESSARY FOR THE  !
09900	    !                                          INTERPOLATION-PROCEDURES    !
10000	    !   RELATIVE      :A BOOLEAN INDICATING IF A RELATIVE OR ABSOLUTE ERROR!
10100	    !                  TEST IS TO BE MADE.                                 !
10200	    !                  I.E. RELATIVE = TRUE  ==> RELATIVE ERROR TEST       !
10300	    !                       RELATIVE = FALSE ==> ABSOLUTE ERROR TEST       !
10400	    !   STOP          :A BOOLEAN USED TO STOP THE INTEGRATION WHEN THE     !
10500	    !                  NORMAL END CONDITIONS ARE STILL TRUE C.F.'INTEGRATE'!
10600	    !   TRACE_LEVEL   :AN INTEGER DETERMINING HOW MUCH INFORMATION ABOUT   !
10700	    !                  THE INTEGRATION IS TO BE PRINTED.                   !
10800	    !                                                                      !
10900	    +----------------------------------------------------------------------+
11000	;
11100	    process CLASS nondiscrete;;
11200	
11300	    nondiscrete CLASS continuous(n);
11400	    INTEGER n;
11500	
11600	    VIRTUAL:PROCEDURE derivatives,take_a_step, error;
11700	
11800	    BEGIN
11900		REAL max_h, min_h, error_limit, t, start_time;
12000		REAL ARRAY rate, state, error_vector,
12100		initial_state, slope_1, slope_2, slope_3[1:n];
12200		BOOLEAN relative, stop, trace;
12300		TEXT trace_level;REAL ARRAY spec[1000:1005];
12400		OPTIONS(/P:" --- INTEGRATE(CONTINUOUS) ---");
12500	
12600		COMMENT----------------------------------------------------------------+
12700		!                                                                      !
12800		!   INTEGRATE IS THE PROCEDURE WHICH CONTROLS THE INTEGRATION OF STATE !
12900		!   VARIABLES. IT HAS THREE LOGICAL STEPS WHICH ARE REPEATED UNTIL     !
13000		!   ONE OF THE BOOLEAN CONDITIONS BECOMES FALSE:-                      !
13100		!                                                                      !
13200		!        1) FIND AN APPROPRIATE STEP LENGTH.                           !
13300		!        2) CALL A ROUTINE TO ADVANCE THE INTEGRATION BY THE CHOSEN    !
13400		!           STEP LENGTH.                                               !
13500		!        3) ESTIMATE IF THE ERROR IS SMALL ENOUGH.                     !
13600		!                                                                      !
13700		!                             PARAMETERS                               !
13800		!                                                                      !
13900		!   NOT_STATE_EVENT    :THIS GIVES THE CONDITION OF A STATE EVENT      !
14000		!   INTEGR_TIME      :THIS GIVES THE TIME OF INTEGRATION               !
14100		!                                                                      !
14200		!        BOTH PARAMETERS GIVE THE CONDITION FOR TERMINATION OF         !
14300		!        INTEGRATION                                                   !
14400		!                                                                      !
14500		!                             PROCEDURES                               !
14600		!                                                                      !
14700		!   REDUCE        :THIS GIVES THE CRITERIA FOR REDUCING THE STEP LENGTH!
14800		!   ERROR         :OPERATES ON ERROR_VECTOR TO PRODUCE A SCALER VALUE  !
14900		!                                                                      !
15000		!                             VARIABLES                                !
15100		!                                                                      !
15200		!   H             :THE CURRENT STEP LENGTH IN USE                      !
15300		!   LARGE_H       :EITHER HOLDS THE TIME INTERVAL TO THE NEXT DISCRETE !
15400		!                  EVENT OR, IF IT IS LESS THE USER DEFINED MAX_H      !
15500		!   SAVE_H        :SAVES THE VALUE OF H WHEN IT IS GOING TO BE REDUCED !
15600		!                  TO THE VALUE OF LARGE_H.                            !
15700		!   ERROR_VALUE   :HOLDS THE SCALAR VALUE RETURNED BY ERROR            !
15800		!   I             :FOR LOOP INDEX                                      !
15900		!   NEXT          :REFERENCE TO A PROCESS OBJECT, USED TO LOOK FOR A   !
16000		!                  DISCRETE EVENT. I.E. A PROCESS NOT IN CLASS         !
16100		!                  CONTINUOUS.                                         !
16200		!                                                                      !
16300		+----------------------------------------------------------------------+
16400	;
16500		PROCEDURE integrate(not_state_event, integr_time);
16600	
16700		NAME not_state_event;
16800		BOOLEAN not_state_event;
16900		REAL integr_time;
17000	
17100		BEGIN
17200		    REAL h, large_h, error_value, save_h;
17300		    INTEGER i, j, k;
17400		    REF(process) next; INTEGER ARRAY c[0:6];
17500	
17600		    OPTIONS(/P:" REDUCE(INTEGRATE) ---");
17700	
17800		    COMMENT----------------------------------------------------------------+
17900		    !                                                                      !
18000		    !   REDUCE DETERMINES IF THE INTEGRATION STEP SIZE SHOULD BE REDUCED   !
18100		    !                                                                      !
18200		    !   REDUCE:= 'TRUE'  IF THE ERROR IS TO GREAT AND H > 2*USERS MINIMUM  !
18300		    !                   VALUE FOR H                                        !
18400		    !                                                                      !
18500		    !   REDUCE:= 'FALSE'  IF THE ERROR IS SMALL ENOUGH OR H < 2*USERS      !
18600		    !                    MINIMUM VALUE FOR H. IN THE LATTER CASE AN ERROR  !
18700		    !                    CONDITION HAS ARISEN AND THE INTEGRATION IS HALTED!
18800		    !                                                                      !
18900		    +----------------------------------------------------------------------+
19000	;
19100		    BOOLEAN PROCEDURE reduce;
19200		    BEGIN
19300			error_value:= error;
19400			IF error_value <= error_limit
19500			THEN reduce:= FALSE ELSE
19600			IF h < 2*min_h THEN
19700			abort("? CADSIM ERROR 001"
19800			"- ERROR LIMIT NOT OBTAINABLE WITH CURRENT MIN_H")
19900			ELSE reduce:= TRUE;
20000		    END --- REDUCE ---;
20100		    OPTIONS(/P:" ERROR(INTEGRATE) ---");
20200	
20300		    COMMENT----------------------------------------------------------------+
20400		    !                                                                      !
20500		    !   ERROR PRODUCES A SCALER VALUE FROM ERROR_VECTOR.IT MAY BE REWRITTEN!
20600		    !   BY THE USER. THE FORM PROVIDED SELECTS THE LARGEST ELEMENT FROM    !
20700		    !   THE VECTOR.                                                        !
20800		    !                                                                      !
20900		    +----------------------------------------------------------------------+
21000	;
21100		    REAL PROCEDURE error;
21200		    BEGIN
21300			INTEGER i;
21400			REAL max_value;
21500	
21600			FOR i:= 1 STEP 1 UNTIL n DO
21700			IF error_vector[i] > max_value
21800			THEN max_value:= error_vector[i];
21900			error:= max_value;
22000	
22100		    END --- ERROR ---;
22200		    OPTIONS(/P:" --- TRACE HEADING ---");
22300	
22400		    PROCEDURE trace_heading;
22500		    BEGIN
22600			Outtext(" SYSTEM TIME"
22700			"     STEP LENGTH"
22800			"        LARGE_H"
22900			"    ERROR VALUE"
23000			"     NEXT DISCRETE");
23100			Outimage;
23200			Setpos(18);
23300			i:=1;
23400			WHILE c[i]>0 AND c[i]<=n DO
23500			BEGIN
23600			    Outtext("STATE[");
23700			    Outint(c[i],5);
23800			    Outtext("]   "); i:=i+1;
23900			END;
24000			WHILE c[i]>=1000 AND c[i]<= 1005 DO
24100			BEGIN
24200			    Outtext("SPEC[ ");
24300			    Outint(c[i],5);
24400			    Outtext("]   ");i:=i+1;
24500			END;
24600			Outimage;
24700			Outimage;
24800		    END *** TRACE HEADING ***;
24900		    OPTIONS(/P:" --- TRACE VALUES ---;");
25000	
25100		    PROCEDURE trace_values;
25200		    BEGIN
25300			Outfix(time+h,7,13);
25400			Outfix(h,7,15);
25500			Outfix(large_h,7,15);
25600			Outfix(error_value,7,15);
25700			Outfix(IF next=/=NONE
25800			THEN next.evtime
25900			ELSE 0.0        ,7,16);
26000			Outimage; Setpos(18);
26100			i:=1;
26200			WHILE c[i]>0 AND c[i]<=n DO
26300			BEGIN
26400			    Outfix(state[c[i]],7,15);
26500			    i:=i+1;
26600			END WHILE;
26700			WHILE c[i]>=1000 AND c[i]<=1005 DO
26800			BEGIN Outfix(spec[c[i]],7,15);
26900			    i:=i+1;
27000			END WHILE;
27100			Outimage;
27200		    END *** TRACE VALUES ***;
27300		    OPTIONS(/P:"   MAIN CODE FOR INTEGRATE");
27400	
27500		    ! SET START TIME;
27600		    start_time:= time;
27700	
27800		    IF trace_level NE "" THEN trace:=TRUE ELSE trace:=FALSE;
27900	
28000	            COMMENT----------------------------------------------------+
28100	            !   TRACE_LEVEL IS A TEXT VALUE WHICH CONTAINS INFORMATION !
28200	            !   FOR THE TRACING.                                       !
28300	            !   EXAMPLE: TRACE_LEVEL:="1 2 1003"                       !
28400	            !   MEANS THAT STATE[1],STATE[2] AND SPEC[1003] WILL BE    !
28500	            !   TRACED.                                                !
28600	            +----------------------------------------------------------+
28700	;
28800		    IF trace THEN
28900		    BEGIN TEXT t1;
29000			t1:-Blanks(trace_level.Length);
29100			t1:=trace_level;
29200			i:=1;
29300			WHILE i<7 AND t1 NE "" DO
29400			BEGIN
29500			    c[i]:=t1.Getint;
29600			    t1:-t1.Sub(t1.Pos,t1.Length-t1.Pos+1);
29700			    i:=i+1;
29800			END WHILE;
29900		    END IF;
30000	
30100		    IF max_h <= 0 OR min_h <= 0 THEN
30200		    abort("? CADSIM ERROR 002 -"
30300		    " MAX_H AND MIN_H HAVE NOT BEEN INITIALISED WITH POSITIVE "
30400		    "VALUES")
30500		    ELSE stop:= FALSE;
30600	
30700		    COMMENT *** PUT DUMMY EVENT ON SQS AND EXECUTE BOGUS STEP ***;
30800	
30900		    ACTIVATE NEW process AT start_time+integr_time;
31000		    ! ?	    HOLD(1/(10**70));  hold(0);
31100	
31200		    IF trace
31300		    THEN
31400		    BEGIN
31500			trace_heading;
31600			trace_values;
31700		    END;
31800	
31900		    large_h:= h := max_h;
32000		    IF integr_time <= 0 THEN integr_time:= &37;
32100	
32200		    WHILE (not_state_event) AND (t < integr_time) AND NOT stop DO
32300		    BEGIN
32400	
32500			COMMENT *** RECORD INITIAL VALUES OF STATE VARIABLES ***;
32600	
32700			FOR i:= 1 STEP 1 UNTIL n DO initial_state[i]:= state[i];
32800	
32900			COMMENT *** LOOK FOR DISCRETE EVENT IN RANGE TIME+MAX_H ***;
33000	
33100			next:- nextev;
33200			IF next =/= NONE THEN
33300			WHILE
33400			(IF next == NONE THEN FALSE ELSE
33500			next IN nondiscrete AND next.evtime < time + max_h) DO
33600			next:- next.nextev;
33700	
33800			COMMENT *** SET LARGE_H TO MAX POSSIBLE ***;
33900	
34000			large_h:= IF
34100			(IF  next =/= NONE THEN next.evtime < time + max_h ELSE FALSE)
34200			THEN next.evtime - time
34300			ELSE max_h;
34400	
34500			COMMENT *** IF H SHORTEND ON LAST STEP BY LARGE_H THEN RESTORE VALUE***;
34600	
34700			IF save_h > 0.0
34800			THEN
34900			BEGIN
35000			    h:= save_h;
35100			    save_h:= -1;
35200			END;
35300	
35400			COMMENT *** TEST H SAVE AND REASSIGN IF REQUIRED ***;
35500	
35600			IF h > large_h
35700			THEN
35800			BEGIN
35900			    save_h:= h;
36000			    h:= large_h;
36100			END;
36200	
36300			COMMENT *** ADVANCE INTEGRATION REDUCE STEP SIZE AS REQUIRED  ***;
36400	
36500			take_a_step(h);
36600			WHILE reduce DO
36700			BEGIN
36800			    h:= h / 2;
36900			    FOR i:= 1 STEP 1 UNTIL n DO state[i]:= initial_state[i];
37000			    take_a_step(h);
37100			END;
37200	
37300			COMMENT *** HAS INTEGRATION CAUSED A STATE EVENT ***;
37400	
37500			IF not_state_event
37600			THEN
37700			BEGIN
37800	
37900			    COMMENT *** NO, SO PROCEDE WITH HOLD ,INCREASE H IF POSSIBLE ***;
38000	
38100			    IF trace THEN trace_values;
38200	
38300			    hold(h);
38400			    t:= t + h;
38500	
38600			    IF error_value < 0.07*error_limit AND h <= max_h/2
38700			    THEN h:= 2*h;
38800			END
38900			ELSE
39000			BEGIN
39100	
39200			    COMMENT *** YES, SO START BINARY SEARCH FOR IT ***;
39300	
39400			    ACTIVATE NEW process DELAY h;
39500			    WHILE h >= 2*min_h DO
39600			    BEGIN
39700				WHILE NOT not_state_event AND h >= 2*min_h DO
39800				BEGIN
39900				    FOR i:= 1 STEP 1 UNTIL n DO state[i]:= initial_state[i];
40000				    h:= h/2;
40100				    take_a_step(h);
40200				END *** WHILE STATE EVENT ***;
40300	
40400				WHILE not_state_event AND h >= 2*min_h DO
40500				BEGIN
40600	
40700				    IF trace THEN trace_values;
40800	
40900				    hold(h);
41000				    FOR i:= 1 STEP 1 UNTIL n DO initial_state[i]:= state[i];
41100				    t:= t + h;   h:= h/2;
41200				    take_a_step(h);
41300				END *** WHILE NOT STATE EVENT ***;
41400	
41500			    END *** WHILE H>=2*MIN H ***;
41600			    IF trace THEN trace_values;
41700			    hold(h);
41800			    t:=t+h;
41900	
42000			    stop:= TRUE;
42100			END *** BINARY SEARCH FOR STATE EVENT ***;
42200	
42300		    END -- WHILE LOOP --;
42400	
42500		END --- INTEGRATE ---;
42600	
42700		REAL PROCEDURE state_(i,act_time);   INTEGER i; REAL act_time;
42800		IF (IF idle OR stop THEN TRUE ELSE evtime - start_time <= t) THEN
42900		state_:= state[i] ELSE
43000		BEGIN   REAL a,b,d,k,reltime;
43100		    reltime:= act_time - start_time;
43200		    d:= evtime - start_time - t;
43300		    k:= (state[i]-initial_state[i])/d;
43400		    a:= ((slope_1[i]-k) + (slope_2[i]-k))/(d*d);
43500		    b:= (slope_2[i]-k)/d - a*(evtime - start_time);
43600		    state_:= (reltime-t)*( (act_time-evtime)*
43700		    (reltime*a+b) + k) + initial_state[i];
43800		END OF STATE_ FOR INTERPOLATION OF STATE VARIABLES;
43900	
44000		REAL PROCEDURE rate_(i,act_time);   INTEGER i; REAL act_time;
44100		IF (IF idle OR stop THEN TRUE ELSE evtime-start_time <= t) THEN
44200		rate_:= rate[i] ELSE
44300		BEGIN   REAL a,b,k;
44400		    k:=(act_time-start_time-t)/(evtime-start_time-t);
44500		    a:=2*(slope_1[i]+slope_2[i]-2*slope_3[i]);
44600		    b:=4*slope_3[i]-3*slope_1[i]-slope_2[i];
44700		    rate_:=(a*k+b)*k+slope_1[i];
44800		END OF RATE_ FOR INTERPOLATION OF RATE VALUES;
44900	
45000		OPTIONS(/P:" --- TAKE A STEP(CONTINUOUS) ---");
45100	
45200		COMMENT----------------------------------------------------------------+
45300		!                                                                      !
45400		!   TAKE A STEP IS THE PROCEDURE WHICH ADVANCES THE INTEGRATION BY     !
45500		!   H. IT ALSO PROVIDES AN ESTIMATE OF THE ERROR IN EACH STATE         !
45600		!   VARIABLE. THE FORM PROVIDED IS THE FOURTH ORDER RUNGE-KUTTA MERSON !
45700		!   METHOD.                                                            !
45800		!                                                                      !
45900		!                             PARAMETERS                               !
46000		!                                                                      !
46100		!   H             :THIS, THE ONLY PARAMETER IS THE STEP SIZE THAT      !
46200		!                  THE INTEGRATION IS TO BE ADVANCED BY.               !
46300		!                                                                      !
46400		!                            VARIABLES                                 !
46500		!                                                                      !
46600		!   H_DIV_2, H_DIV_3, H_DIV_6, H_DIV_8  : THE STEP LENGTH, H, DIVIDED  !
46700		!                                         BY 2, 3, 6, 8 RESPECTIVELY.  !
46800		!   I                                   : FOR LOOP INDEX.              !
46900	        !   SLOPE[1],SLOPE[2] AND SLOPE[3] MUST BE CALCULATED HERE, THEY ARE   !
47000	        !   USED FOR THE INTERPOLATION-PROCEDURES (STATE_[ , ] AND RATE_[ , ]) !
47100		+----------------------------------------------------------------------+
47200	;
47300		PROCEDURE take_a_step(h);
47400		VALUE h;
47500		REAL h;
47600		BEGIN
47700		    REAL h_div_2, h_div_3, h_div_6, h_div_8;
47800		    INTEGER i;
47900	
48000		    h_div_2:= h/2;
48100		    h_div_3:= h/3;
48200		    h_div_6:= h/6;
48300		    h_div_8:= h/8;
48400	
48500		    derivatives(t);
48600		    FOR i:= 1 STEP 1 UNTIL n DO
48700		    BEGIN
48800			slope_1[i]:= rate[i];
48900			state[i]:= initial_state[i] + h_div_3 * slope_1[i];
49000		    END;
49100	
49200		    derivatives(t+h_div_3);
49300		    FOR i:= 1 STEP 1 UNTIL n DO
49400		    BEGIN
49500			slope_2[i]:= rate[i];
49600			state[i]:= initial_state[i] + h_div_6 * (slope_1[i] + slope_2[i]);
49700		    END;
49800	
49900		    derivatives(t+h_div_3);
50000		    FOR i:= 1 STEP 1 UNTIL n DO
50100		    BEGIN
50200			slope_2[i]:= rate[i];
50300			state[i]:= initial_state[i] +  h_div_8 * (slope_1[i] + 3 * slope_2[i]);
50400		    END;
50500	
50600		    derivatives(t+h_div_2);
50700		    FOR i:= 1 STEP 1 UNTIL n DO
50800		    BEGIN
50900			slope_3[i]:= rate[i];
51000			state[i]:= error_vector[i]:= initial_state[i] +
51100			h_div_2 * (slope_1[i] - 3*slope_2[i]+ 4*slope_3[i]);
51200		    END;
51300	
51400		    derivatives(t+h);
51500		    FOR i:= 1 STEP 1 UNTIL n DO
51600		    BEGIN
51700			slope_2[i]:= rate[i];
51800			state[i]:= initial_state[i] +
51900			h_div_6*(slope_1[i] + slope_2[i] + 4 * slope_3[i]);
52000			error_vector[i]:= IF relative
52100			THEN Abs(0.2*(1-state[i]/error_vector[i]))
52200			ELSE Abs(0.2*(error_vector[i]-state[i]));
52300	
52400		    END;
52500	
52600		END --- TAKE A STEP ---;
52700	
52800		OPTIONS(/P:" --- DERIVATIVES(CONTINUOUS) ---");
52900	
53000		COMMENT----------------------------------------------------------------+
53100		!                                                                      !
53200		!   DERIVATIVES IS THE PROCEDURE IN WHICH THE USER SPECIFIES THE       !
53300		!   STATE EQUATIONS WHICH GOVERN THE DIFFERENTIAL DYNAMICS OF THE      !
53400		!   CONTINUOUS OBJECT. THE FORM PROVIDED OUTPUTS AN ERROR MESSAGE      !
53500		!   AND ABORTS THE INTEGRATION.                                        !
53600		!                                                                      !
53700		!                             PARAMETERS                               !
53800		!   T             :THIS IS THE TIME RELATIVE TO THE INTEGRATION.       !
53900		!                                                                      !
54000		+----------------------------------------------------------------------+
54100	;
54200		PROCEDURE derivatives(t);
54300		VALUE t;   REAL t;
54400		BEGIN
54500		    abort("? CADSIM ERROR 003 - No PROC DERIVATIVES"
54600		    " HAS BEEN SPECIFIED");
54700		END --- DERIVATIVES ---;
54800	
54900	
55000		max_h:= 100;   min_h:= 0.01;
55100		INNER;
55200	
55300	    END ---*** CONTINUOUS ***---;
55400	
55500	
55600	END **** CADSIM ****;