êFMTINVE MOD _«MTMATH MOD2ËMTPTR MOD"hbMTQSOR MOD8ØÒMTREAD MODGewMTSIEV MODMúíMTSORT MODSÙ*MTWRIT MODeŒÿ ÿ ÿ MODULE MTINVERT; (* Program to test speed of floating point matrix inversion. *) (* The program will form a matrix with ones' in every member, *) (* except the diagonals which will have values of 2. *) FROM RealInOut IMPORT WriteReal; FROM InOut IMPORT WriteLn, WriteString; CONST MAX = 20; TYPE MATRIX = ARRAY [1..MAX], [1..MAX] OF REAL; VAR J, K, L: INTEGER; DET, PIVOT, TEMPO: REAL; A: MATRIX; BEGIN (* Creating test matrix *) FOR J := 1 TO MAX DO FOR K := 1 TO MAX DO A[J, K] := 1.0 END; A[J, J] := 2.0; END; (* The test below will ensure that the user does not spend *) (* a lot of time looking at a rather obvious matrix when its *) (* size is large. *) WriteString('Starting matrix invertion'); WriteLn; DET := 1.0; FOR J := 1 TO MAX DO PIVOT := A[J, J]; DET := DET*PIVOT; A[J, J] := 1.0; FOR K := 1 TO MAX DO A[J, K] := A[J, K]/PIVOT END; FOR K := 1 TO MAX DO IF K <> J THEN TEMPO := A[K, J]; A[K, J] := 0.0; FOR L := 1 TO MAX DO A[K, L] := A[K, L]-A[J, L]*TEMPO END; END END; END; (* End of outer for-loop *) WriteLn; WriteString('Determinant = '); WriteReal(DET,14); WriteLn; END MTINVERT. MODULE MTMath; (* Program tests the speed of math function. *) (* Each function is timed separately. *) (* Functions are shown in the import list *) FROM MathLib0 IMPORT arctan, cos, exp, ln, sin, sqrt; FROM InOut IMPORT Read, Write, WriteLn, WriteString; VAR i, j: INTEGER; pi, angle, result, argument: REAL; dummy: CHAR; BEGIN WriteString('START SQUARE ROOT TEST'); WriteLn; WriteString('PRESS TO START'); Read(dummy); WriteLn; FOR i := 1 TO 10 DO Write('.'); argument := 0.0; WHILE argument <= 1000.0 DO result := sqrt(argument); argument := argument + 1.0 END; END; (* FOR *) WriteLn; WriteString('END OF SQUARE ROOT TEST'); WriteLn; WriteString('START LOG TEST'); WriteLn; WriteString('PRESS TO START'); Read(dummy); WriteLn; FOR i := 1 TO 10 DO Write('.'); argument := 0.1; WHILE argument <= 1000.1 DO result := ln(argument); argument := argument + 1.0 END; END; (* FOR *) WriteLn; WriteString('END OF LOG TEST'); WriteLn; WriteString('START EXPONENTIAL TEST'); WriteLn; WriteString('PRESS TO START'); Read(dummy); WriteLn; FOR i := 1 TO 10 DO Write('.'); argument := 0.1; WHILE argument <= 10.0 DO result := exp(argument); argument := argument + 0.01 END; END; (* FOR *) WriteLn; WriteString('END OF EXPONENTIAL TEST'); WriteLn; WriteString('START ARCTANGENT TEST'); WriteLn; WriteString('PRESS TO START'); Read(dummy); WriteLn; FOR i := 1 TO 10 DO Write('.'); argument := 0.1; WHILE argument <= 10.0 DO angle := arctan(argument); argument := argument + 0.01 END; END; (* FOR *) WriteLn; WriteString('END OF ARCTANGENT TEST'); WriteLn; pi := 355.0 / 113.0; WriteString('START SINE TEST'); WriteLn; WriteString('PRESS TO START'); Read(dummy); WriteLn; FOR i := 1 TO 10 DO Write('.'); angle := 0.0; WHILE angle <= 2.0 * pi DO result := sin(angle); angle := angle + pi / 360.0 END; END; (* FOR *) WriteLn; WriteString('END OF SINE TEST'); WriteLn; WriteLn; WriteString('DONE'); WriteLn; WriteLn; END MTMath. MODULE MTPtr; (*---------------------------------------------*) (* Program to measure the speed of: *) (* *) (* 1) Allocating dynamic binary-tree structure *) (* *) (* 2) Searching through the binary-tree *) (*---------------------------------------------*) FROM InOut IMPORT WriteString, WriteLn, Read, Write; FROM SYSTEM IMPORT TSIZE; FROM Storage IMPORT ALLOCATE; FROM MathLib0 IMPORT sin, entier; CONST SIZE = 1000; MainLoopCount = 30; TYPE Ptr = POINTER TO Node; Node = RECORD Value : INTEGER; Left, Right : Ptr; END; VAR Numbers : ARRAY [1..SIZE] OF INTEGER; Iter, I : CARDINAL; TreeRoot : Ptr; Pi : REAL; dummy : CHAR; PROCEDURE Create; (* Create array using sin() *) VAR J : CARDINAL; Angle, FloatSize, Increment : REAL; BEGIN Angle := 0.0; J := 1; Increment := Pi / 360.0; FloatSize := FLOAT(SIZE); WHILE J <= SIZE DO Numbers[J] := entier(sin(Angle) * FloatSize); Angle := Angle + Increment; INC(J); END; END Create; PROCEDURE Insert(VAR Root : Ptr; Item : INTEGER); (* Insert element in binary-tree *) BEGIN IF Root = NIL THEN ALLOCATE(Root,TSIZE(Node)); Root^.Value := Item; Root^.Left := NIL; Root^.Right := NIL ELSE WITH Root^ DO IF Item < Value THEN Insert(Left,Item) ELSE Insert(Right,Item) END; END; END; END Insert; PROCEDURE Search(VAR Root : Ptr; Target : INTEGER); (* Recursive procedure to search for Target value *) BEGIN IF Root <> NIL THEN IF Target <> Root^.Value THEN IF Target < Root^.Value THEN Root := Root^.Left; Search(Root,Target) ELSE Root := Root^.Right; Search(Root,Target) END END; END; END Search; BEGIN (* MAIN *) Pi := 355. / 113.; Create; WriteString('Created array'); WriteLn; (* Building the binary tree *) WriteString('Press to time tree creation '); WriteLn; Read(dummy); NEW(TreeRoot); TreeRoot := NIL; FOR I := 1 TO SIZE DO Insert(TreeRoot,Numbers[I]); END; (* FOR I *) WriteLn; WriteString('Created Tree'); WriteLn; WriteString('Press to time tree search'); WriteLn; Read(dummy); WriteLn; FOR Iter := 1 TO MainLoopCount DO FOR I := SIZE TO 1 BY -1 DO Search(TreeRoot,Numbers[I]); END; (* FOR I *) END; (* FOR Iter *) WriteLn; WriteString('DONE'); WriteLn; END MTPtr.MODULE QSort2; (* The test uses QuickSort to measure recursion speed *) (* An ordered array is created by the program and is *) (* reverse sorted. The process is performed 'MAXITER'*) (* number of times. *) FROM InOut IMPORT WriteString, WriteLn, WriteCard, Write; CONST SIZE = 1000; MAXITER = 10; WantToListArray = FALSE; (* Flag used for debugging *) TYPE NUMBERS = ARRAY[1..SIZE] OF CARDINAL; VAR Iter, Offset, I, J, Temporary : CARDINAL; A : NUMBERS; PROCEDURE InitializeArray ; (* Procedure to initialize array *) VAR I : CARDINAL; BEGIN FOR I := 1 TO SIZE DO A[I] := SIZE - I + 1 END; (* FOR I *) END InitializeArray; PROCEDURE QuickSort; (* Procedure to perform a QuickSort *) PROCEDURE Sort(Left, Right : CARDINAL); VAR i, j : CARDINAL; Data1, Data2 : CARDINAL; BEGIN i := Left; j := Right; Data1 := A[(Left + Right) DIV 2]; REPEAT WHILE A[i] < Data1 DO INC(i) END; WHILE Data1 < A[j] DO DEC(j) END; IF i <= j THEN Data2 := A[i]; A[i] := A[j]; A[j] := Data2; INC(i); DEC(j) END; UNTIL i > j; IF Left < j THEN Sort(Left,j) END; IF i < Right THEN Sort(i,Right) END; END Sort; BEGIN (* QuickSort *) Sort(1,SIZE); END QuickSort; PROCEDURE DisplayArray; (* Display array members *) BEGIN FOR I := 1 TO SIZE DO WriteCard(A[I],3); WriteString(' '); END; (* FOR I *) WriteLn; END DisplayArray; BEGIN (* Main *) FOR Iter := 1 TO MAXITER DO InitializeArray; Write('.'); QuickSort END; (* FOR Iter *) WriteLn; WriteString('Finished sorting!'); IF WantToListArray THEN DisplayArray END; END QSort2.MODULE MTREAD; (* Program to measure the speed of reading sequential *) (* data to an empty floppy disk. *) FROM InOut IMPORT WriteString, WriteLn; FROM FileSystem IMPORT File, Lookup, Reset, ReadChar, Close; CONST RecordNumber = 512; BlockLen = 128; Filename = 'B:TEMPO.DAT'; VAR Ch : CHAR; I,J : INTEGER; F : File; NewFile : BOOLEAN; BEGIN NewFile := FALSE; (* Create new file if not found *) Lookup(F, Filename, NewFile); Reset(F); FOR I := 1 TO RecordNumber DO FOR J := 1 TO BlockLen DO ReadChar(F,Ch) END; END; Close(F); WriteString('DONE'); WriteLn; END MTREAD.MODULE MTSIE10; (* Sieve test with ten iterations *) FROM InOut IMPORT WriteLn, WriteString, WriteInt; CONST SIZE = 7000; VAR I, PRIME, K, COUNT, ITER: INTEGER; FLAGS: ARRAY [0..SIZE] OF BOOLEAN; BEGIN WriteString('START TEN ITERATIONS'); WriteLn; FOR ITER := 1 TO 10 DO COUNT := 0; FOR I := 0 TO SIZE DO FLAGS[I] := TRUE END; FOR I := 0 TO SIZE DO IF FLAGS[I] THEN PRIME := I+I+3; K := I+PRIME; WHILE K <= SIZE DO FLAGS[K] := FALSE; INC(K, PRIME) END; INC(COUNT) END END; END; WriteInt(COUNT,8); WriteString(' PRIMES'); WriteLn; END MTSIE10. MODULE MTSort2; (* Program will test the speed of sorting an integer array. *) (* The program will create an array sorted from smaller to larger *) (* integers, then sort them in the reverse order. *) (* The array is reverse sorted ten times. *) FROM InOut IMPORT WriteString, WriteLn, WriteCard, Read, Write; CONST SIZE = 1000; TYPE NUMBERS = ARRAY[1..SIZE] OF CARDINAL; VAR InOrder, AscendingOrder : BOOLEAN; Iter, Offset, I, J, Temporary : CARDINAL; Ch : CHAR; A : NUMBERS; PROCEDURE InitializeArray ; (* Procedure to initialize array *) BEGIN WriteString('Initializing integer array'); WriteLn; FOR I := 1 TO SIZE DO A[I] := I END; (* FOR I *) END InitializeArray; PROCEDURE ShellSort ; (* Procedure to perform a Shell-Meztner sorting *) PROCEDURE SwapThem; (* Local procedure to swap elements A[I] and A[J] *) BEGIN InOrder := FALSE; Temporary := A[I]; A[I] := A[J]; A[J] := Temporary; END SwapThem; BEGIN (* Toggle 'AscendingOrder' flag status *) AscendingOrder := NOT AscendingOrder; Offset := SIZE; WHILE Offset > 1 DO Offset := Offset DIV 2; REPEAT InOrder := TRUE; FOR J := 1 TO (SIZE - Offset) DO I := J + Offset; IF AscendingOrder THEN IF A[I] < A[J] THEN SwapThem END ELSE IF A[I] > A[J] THEN SwapThem END END; (* IF AscendingOrder *) END; (* FOR J *) UNTIL InOrder; END; (* End of while-loop *) END ShellSort; PROCEDURE DisplayArray; (* Display array members *) BEGIN FOR I := 1 TO SIZE DO WriteCard(A[I],3); WriteString(' '); END; (* FOR I *) WriteLn; END DisplayArray; BEGIN (* Main *) InitializeArray; AscendingOrder := TRUE; WriteString('Beginning to sort press '); Read(Ch); WriteLn; FOR Iter := 1 TO 10 DO Write('.'); ShellSort END; (* FOR Iter *) WriteString('Finished sorting!'); DisplayArray; END MTSort2.MODULE MTWRITE; (* Program to measure the speed of writing sequential *) (* data to an empty floppy disk. *) FROM InOut IMPORT WriteString, WriteLn; FROM FileSystem IMPORT File, Lookup, Reset, WriteChar, Close; CONST RecordNumber = 512; BlockLen = 127; Filename = 'B:TEMPO.DAT'; VAR Ch : CHAR; I,J : INTEGER; F : File; NewFile : BOOLEAN; BEGIN Ch := 'A'; (* Initialize character *) NewFile := TRUE; (* Create new file if not found *) Lookup(F, Filename, NewFile); Reset(F); FOR I := 1 TO RecordNumber DO FOR J := 1 TO BlockLen DO WriteChar(F,Ch) END; WriteChar(F,36C) END; Close(F); WriteString('DONE'); WriteLn; END MTWRITE.