WINAK

Waar elke student thuis is!
https://forum.winak.be/

[Prog] Reeks7

https://forum.winak.be/viewtopic.php?f=31&t=278

Page 1 of 2

Reeks7

Posted: Thu Dec 15, 2005 10:59 pm
by Shinta
OFF-LINE

Posted: Fri Dec 16, 2005 8:06 pm
by Nickman
Hier is mijn versie (heb ze eindelijk af gekregen, fucking oberon bleef maar zijken...). Er zitten op het eerste zicht mel nen helen hoop overbodige PROCEDURES in, maar oznder al mijn initializatieprocedures kon ik het niet tot een goed einde brengen :D.

MatrixOO.Mod

Code: Select all

MODULE MatrixOO;

	IMPORT
		OutExt, In;
	
	TYPE
		Element* = POINTER TO ElementNode;
		ElementNode* = RECORD
			END;
			
		RealElement* = POINTER TO RealElementNode;
		RealElementNode* =
			RECORD (ElementNode)
				r*: REAL;
			END;
			
		BooleanElement* = POINTER TO BooleanElementNode;
		BooleanElementNode* =
			RECORD (ElementNode)
				b*: BOOLEAN;
			END;
			
		IntegerElement* = POINTER TO IntegerElementNode;
		IntegerElementNode* =
			RECORD (ElementNode)
				i*: LONGINT;
			END;
				
		MATRIX* = POINTER TO MATRIXDesc;
		MATRIXDesc* =
			RECORD
				matrix*: ARRAY 4, 4 OF Element;
			END;
			
			
			
(*           -------===========<<<<<<<<     Matrices Initializeren     >>>>>>>>===========--------	        *)

	PROCEDURE (M : MATRIX) InitializeReal*;
		VAR
			x, y : INTEGER;
			Type: RealElement;
	BEGIN
		FOR y := 0 TO 3 DO
			FOR x := 0 TO 3 DO
				NEW(Type);
				M^.matrix[x, y] := Type;
			END;
		END;
	END InitializeReal;
	
	PROCEDURE (M : MATRIX) InitializeInteger*;
		VAR
			x, y : INTEGER;
			Type: IntegerElement;
	BEGIN
		FOR y := 0 TO 3 DO
			FOR x := 0 TO 3 DO
				NEW(Type);
				M^.matrix[x, y] := Type;
			END;
		END;
	END InitializeInteger;
	
	PROCEDURE (M : MATRIX) InitializeBoolean*;
		VAR
			x, y : INTEGER;
			Type: BooleanElement;
	BEGIN
		FOR y := 0 TO 3 DO
			FOR x := 0 TO 3 DO
				NEW(Type);
				M^.matrix[x, y] := Type;
			END;
		END;
	END InitializeBoolean;	
	
	PROCEDURE (Type : Element) InitializeSame*(VAR M : MATRIX);
	BEGIN
		OutExt.String("ERR: Je mag een Matrix niet met niets initializeren")
	END InitializeSame;
	
	PROCEDURE (Type : RealElement) InitializeSame*(VAR M : MATRIX);
	BEGIN
		M^.InitializeReal;
	END InitializeSame;
	
	PROCEDURE (Type : IntegerElement) InitializeSame*(VAR M : MATRIX);
	BEGIN
		M^.InitializeInteger;
	END InitializeSame;
	
	PROCEDURE (Type : BooleanElement) InitializeSame*(VAR M : MATRIX);
	BEGIN
		M^.InitializeBoolean;
	END InitializeSame;
	
	PROCEDURE (Type : Element) InitializeElement*(VAR n : Element);
	BEGIN
		OutExt.String("ERR: Je kan een element niet als niets initializeren");
	END InitializeElement;
	
	PROCEDURE (Type : RealElement) InitializeElement*(VAR n : Element);
		VAR
			Type2: RealElement;
	BEGIN
		NEW(Type2);
		n := Type2;
	END InitializeElement;
	
	PROCEDURE (Type : IntegerElement) InitializeElement*(VAR n : Element);
		VAR
			Type2: IntegerElement;
	BEGIN
		NEW(Type2);
		n := Type2;
	END InitializeElement;
	
	PROCEDURE (Type : BooleanElement) InitializeElement*(VAR n : Element);
		VAR
			Type2: BooleanElement;
	BEGIN
		NEW(Type2);
		n := Type2;
	END InitializeElement;
	
	
(*     -------===========<<<<<<<<     Elementen Toevoegen     >>>>>>>>===========--------	    *)

	PROCEDURE (n : Element) Insert*(Val: REAL);
	BEGIN
		OutExt.String("ERR: De Matrix is nog niet ge’nitializeerd");
		n := NIL;
	END Insert;
	
	PROCEDURE (n : RealElement) Insert*(Val: REAL);
	BEGIN
		n^.r := Val;
	END Insert;
	
	PROCEDURE (n : IntegerElement) Insert*(Val: REAL);
	BEGIN
		n^.i := ENTIER(Val);
	END Insert;
	
	PROCEDURE (n : BooleanElement) Insert*(Val: REAL);
	BEGIN
		IF (Val = 1.0) THEN
			n^.b := TRUE;
		ELSE
			n^.b := FALSE;
		END;
	END Insert;
	

(*      -------===========<<<<<<<<     Eenheidsmatrix aanmaken     >>>>>>>>===========--------	   *)

	PROCEDURE (M : MATRIX) Unity*;
		VAR
			x, y : INTEGER;
	BEGIN
		FOR y := 0 TO 3 DO
			FOR x := 0 TO 3 DO
				IF (x = y) THEN
					M^.matrix[x, y]^.Insert(1.0);
				ELSE
					M^.matrix[x, y]^.Insert(0.0);
				END;
			END;
		END;
	END Unity;


(*     -------===========<<<<<<<<     Elementen Afprinten     >>>>>>>>===========--------	    *)

	PROCEDURE (n : Element) PrintElement*;
	BEGIN
		OutExt.String("ERR: De Matrix is nog niet ge’nitializeerd");
	END PrintElement;
	
	PROCEDURE (n : RealElement) PrintElement*;
	BEGIN
		OutExt.RealFix(n^.r, 0, 2);
	END PrintElement;
	
	PROCEDURE (n : IntegerElement) PrintElement*;
	BEGIN
		OutExt.Int(n^.i, 0);
	END PrintElement;
	
	PROCEDURE (n : BooleanElement) PrintElement*;
	BEGIN
		IF n^.b THEN
			OutExt.String("TRUE ");
		ELSE
			OutExt.String("FALSE");
		END;
	END PrintElement;
	
	
(*    -------===========<<<<<<<<     Matrix Afprinten     >>>>>>>>===========--------   *)

	PROCEDURE (M : MATRIX) PrintMatrix*;
		VAR
			x, y : INTEGER;
	BEGIN
		FOR y := 0 TO 3 DO
			FOR x := 0 TO 3 DO	
				M^.matrix[x, y]^.PrintElement;
				OutExt.String("    ");
			END;
			
			OutExt.Ln;
		END;
	END PrintMatrix;
	

(*     -------===========<<<<<<<<     Elementen Inlezen     >>>>>>>>===========--------	  *)

	PROCEDURE (n : Element) ElementInlezen*;
	BEGIN
		OutExt.String("ERR: De Matrix is nog niet ge’nitializeerd");
	END ElementInlezen;
	
	PROCEDURE (n : RealElement) ElementInlezen*;
	BEGIN
		In.Real(n^.r);
	END ElementInlezen;
	
	PROCEDURE (n : IntegerElement) ElementInlezen*;
	BEGIN
		In.LongInt(n^.i);
	END ElementInlezen;
	
	PROCEDURE (n : BooleanElement) ElementInlezen*;
		VAR
			Temp, True : ARRAY 6 OF CHAR;
	BEGIN
		True := ("TRUE");
		In.String(Temp);
		
		IF (Temp = True) THEN
			n^.b := TRUE;
		ELSE
			n^.b := FALSE;
		END;
	END ElementInlezen;
	

(*   -------===========<<<<<<<<     Matrix Inlezen     >>>>>>>>===========--------  *)

	PROCEDURE (M : MATRIX) MatrixInlezen*;
		VAR
			x, y : INTEGER;
	BEGIN
		In.Open();
		FOR y := 0 TO 3 DO
			FOR x := 0 TO 3 DO
				M^.matrix[x, y]^.ElementInlezen;
			END;
		END;
	END MatrixInlezen;
	
	
(*  -------===========<<<<<<<<     Een Element met een getal vermenigvuldigen     >>>>>>>>===========--------  *)
	
	PROCEDURE (n : Element) Mult*(Val : REAL): Element;
	BEGIN
		OutExt.String("ERR: De Matrix is nog niet ge’nitializeerd");
		RETURN NIL;
	END Mult;
	
	PROCEDURE (n : RealElement) Mult*(Val : REAL): Element;
		VAR
			ReturnVal : RealElement;
	BEGIN
		NEW(ReturnVal);
		ReturnVal^.r := n^.r * Val;
		RETURN (ReturnVal);
	END Mult;
	
	PROCEDURE (n : IntegerElement) Mult*(Val : REAL): Element;
		VAR
			ReturnVal : IntegerElement;
	BEGIN
		NEW(ReturnVal);
		ReturnVal^.i := ENTIER(n^.i * Val);
		RETURN (ReturnVal);
	END Mult;
	
	PROCEDURE (n : BooleanElement) Mult*(Val : REAL): Element;
		VAR
			ReturnVal : BooleanElement;
	BEGIN
		NEW(ReturnVal);
		IF (Val < 0) THEN
			ReturnVal^.b := ~n^.b;
		ELSIF (Val = 0) THEN
			ReturnVal^.b := FALSE;
		END;
		RETURN (ReturnVal);
	END Mult;


(* -------===========<<<<<<<<     Een Matrix met een getal vermenigvuldigen     >>>>>>>>===========-------- *)
	
	PROCEDURE (M : MATRIX) ScalarMult*(Val : REAL): MATRIX;
		VAR
			x, y : INTEGER;
			O : MATRIX;
	BEGIN
		NEW(O);
		FOR y := 0 TO 3 DO
			FOR x := 0 TO 3 DO
				O^.matrix[x, y] := M^.matrix[x, y]^.Mult(Val);
			END;
		END;
		RETURN O;
	END ScalarMult;
	
	
(*    -------===========<<<<<<<<     Twee Elementen met elkaar optellen     >>>>>>>>===========--------  *)

	PROCEDURE (n : Element) SumElement*(Val : Element): Element;
	BEGIN
		OutExt.String("ERR: De Matrix is nog niet ge’nitializeerd");
		RETURN NIL;
	END SumElement;
	
	PROCEDURE (n : RealElement) SumElement*(Val : Element): Element;
		VAR
			ReturnVal : RealElement;
	BEGIN
		NEW(ReturnVal);
		ReturnVal^.r := n^.r + Val(RealElement)^.r;
		RETURN(ReturnVal);
	END SumElement;
	
	PROCEDURE (n : IntegerElement) SumElement*(Val : Element): Element;
		VAR
			ReturnVal : IntegerElement;
	BEGIN
		NEW(ReturnVal);
		ReturnVal^.i := n^.i + Val(IntegerElement)^.i;
		RETURN(ReturnVal);
	END SumElement;
	
	PROCEDURE (n : BooleanElement) SumElement*(Val : Element): Element;
		VAR
			ReturnVal : BooleanElement;
	BEGIN
		NEW(ReturnVal);
		IF (n^.b) OR (Val(BooleanElement)^.b) THEN
			ReturnVal^.b := TRUE;
		ELSE
			ReturnVal^.b := FALSE;
		END;
		RETURN(ReturnVal);
	END SumElement;
	
	
(*  -------===========<<<<<<<<     Twee Matrices met elkaar optellen     >>>>>>>>===========--------  *)

	PROCEDURE (M : MATRIX) Sum*(N : MATRIX): MATRIX;
		VAR
			x, y : INTEGER;
			O : MATRIX;
	BEGIN
		NEW(O);
		FOR y := 0 TO 3 DO
			FOR x := 0 TO 3 DO
				O^.matrix[x, y] := M^.matrix[x, y]^.SumElement(N^.matrix[x, y]);
			END;
		END;
		RETURN O;
	END Sum;
	

(*   -------===========<<<<<<<<     Twee Elementen van elkaar aftrekken     >>>>>>>>===========--------	   *)

	PROCEDURE (n : Element) DiffElement*(Val : Element): Element;
	BEGIN
		OutExt.String("ERR: De Matrix is nog niet ge’nitializeerd");
		RETURN NIL;
	END DiffElement;
	
	PROCEDURE (n : RealElement) DiffElement*(Val : Element): Element;
		VAR
			ReturnVal: RealElement;
	BEGIN
		NEW(ReturnVal);
		ReturnVal^.r := n^.r - Val(RealElement)^.r;
		RETURN (ReturnVal);
	END DiffElement;
	
	PROCEDURE (n : IntegerElement) DiffElement*(Val : Element): Element;
		VAR
			ReturnVal: IntegerElement;
	BEGIN
		NEW(ReturnVal);
		ReturnVal^.i := n^.i - Val(IntegerElement)^.i;
		RETURN (ReturnVal);
	END DiffElement;
	
	PROCEDURE (n : BooleanElement) DiffElement*(Val : Element): Element;
		VAR
			ReturnVal: BooleanElement;
	BEGIN
		NEW(ReturnVal);
		
		IF (n^.b) & (~Val(BooleanElement)^.b) THEN
			ReturnVal^.b := TRUE;
		ELSE
			ReturnVal^.b := FALSE;
		END;
		
		RETURN (ReturnVal);
	END DiffElement;
		
(*  -------===========<<<<<<<<     Twee Matrixen van elkaar aftrekken     >>>>>>>>===========--------	  *)

	PROCEDURE (M : MATRIX) Diff*(N : MATRIX): MATRIX;
		VAR
			O : MATRIX;
	BEGIN
		O := M^.Sum(N^.ScalarMult(-1.0));
		RETURN O;
	END Diff;

(*  -------===========<<<<<<<<     Twee Elementen met elkaar vermenigvuldigen     >>>>>>>>===========--------   *)

	PROCEDURE (n : Element) MultElement*(Val : Element): Element;
	BEGIN
		OutExt.String("ERR: De Matrix is nog niet ge’nitializeerd");
		RETURN NIL;
	END MultElement;
	
	PROCEDURE (n : RealElement) MultElement*(Val : Element): Element;
		VAR
			ReturnVal : RealElement;
	BEGIN
		NEW(ReturnVal);
		ReturnVal^.r := n^.r * Val(RealElement)^.r;
		RETURN (ReturnVal);
	END MultElement;
	
	PROCEDURE (n : IntegerElement) MultElement*(Val : Element): Element;
		VAR
			ReturnVal : IntegerElement;
	BEGIN
		NEW(ReturnVal);
		ReturnVal^.i := (n^.i * Val(IntegerElement)^.i);
		RETURN (ReturnVal);
	END MultElement;
	
	PROCEDURE (n : BooleanElement) MultElement*(Val : Element): Element;
		VAR
			ReturnVal : BooleanElement;
	BEGIN
		NEW(ReturnVal);
		IF n^.b & Val(BooleanElement)^.b THEN
			ReturnVal^.b := TRUE;
		ELSE
			ReturnVal^.b := FALSE;
		END;
		RETURN (ReturnVal);
	END MultElement;
	

(*  -------===========<<<<<<<<     Twee Matrices met elkaar vermenigvuldigen     >>>>>>>>===========--------  *)
	
	PROCEDURE (M : MATRIX) MultMatrix*(N : MATRIX): MATRIX;
		VAR
			x, y, z : INTEGER;
			O : MATRIX;
			Temp : Element;
	BEGIN
		NEW(O);
		M^.matrix[0, 0]^.InitializeSame(O);
								
		FOR y := 0 TO 3 DO
			FOR x := 0 TO 3 DO
				FOR z := 0 TO 3 DO
					NEW(Temp);
					Temp := M^.matrix[z, y]^.MultElement(N^.matrix[x, z]);
					O^.matrix[x, y] := O^.matrix[x,y].SumElement(Temp);
				END;
			END;
		END;
		RETURN O;
	END MultMatrix;
	
	
(* -------===========<<<<<<<<     Determinant van een matrix berekenen     >>>>>>>>===========-------- *)
	
	PROCEDURE (M : MATRIX) Determinant*(Dimentie: INTEGER): Element;
		VAR
			Det, TempElement: Element;
			x, xcount, ycount, count: INTEGER;
			Temp: MATRIX;
			
	
	BEGIN
		NEW(Det);
		NEW(Temp);
		M^.matrix[0,0]^.InitializeElement(Det);
		IF Dimentie = 2 THEN
			TempElement := (M^.matrix[0,0]^.MultElement(M^.matrix[1,1]));
			Det := TempElement^.DiffElement(M^.matrix[1,0]^.MultElement(M^.matrix[0,1]));
		ELSE
			FOR x := 0 TO (Dimentie-1) DO
				(* Kleine matrix opstellen *)	
				count := 0;
				
				FOR xcount := 0 TO (Dimentie - 1) DO
					IF xcount # x THEN
						FOR ycount := 1 TO (Dimentie-1) DO
							Temp^.matrix[count, (ycount-1)] := M^.matrix[xcount, ycount];
						END;
						INC(count);
					END;
				END;
				
				(* Determinant berekenen*)
				NEW(TempElement);
				TempElement := M^.matrix[x, 0]^.MultElement(Temp^.Determinant(Dimentie-1));
				IF ODD(x) THEN
					Det := Det^.DiffElement(TempElement);
				ELSE
					Det := Det^.SumElement(TempElement);
				END;
			END;	
		END;
		RETURN(Det);
	END Determinant;
	
BEGIN
END MatrixOO.
MatrixOOTest.Mod

Code: Select all

MODULE MatrixOOTest;
	IMPORT
		MatrixOO, OutExt, In;
	
	TYPE
		MATRIX = MatrixOO.MATRIX;
		Real = MatrixOO.RealElement;
		Integer = MatrixOO.IntegerElement;
		Boolean = MatrixOO.BooleanElement;
		Element = MatrixOO.Element;
		
	PROCEDURE TestReal*;
		VAR
			A: MATRIX;
			B: MATRIX;
			C: MATRIX;
			Det: Element;
			
	BEGIN
		OutExt.String("-----=====<<<<<  Matrices met REAL waardes  >>>>>=====-----");
		NEW(A);
		NEW(B);
		NEW(C);
		NEW(Det);
		A^.InitializeReal;
		B^.InitializeReal;
		C^.InitializeReal;
		
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("De eenheidsmatrix (A):");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;		
		A^.Unity;
		A^.PrintMatrix;
		
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("Een matrix inlezen (B):");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;
		B^.MatrixInlezen;
		B^.PrintMatrix;
		
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("Matrix A met 5 vermenigvuldigen (C):");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;
		C := A^.ScalarMult(5.0);
		C^.PrintMatrix;
			
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("Matrix C en Matrix A optellen (A):");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;
		A := C^.Sum(A);
		A^.PrintMatrix;
		
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("Matrix A van Matrix B Aftrekken (B):");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;
		B := B^.Diff(A);
		B^.PrintMatrix;
		
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("Matrix C vermenigvuldigen met Matrix A (C):");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;
		C := C^.MultMatrix(A);
		C^.PrintMatrix;
		
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("Determinant bepalen van Matrix B:");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;
		Det := B^.Determinant(4);
		OutExt.String("Determinant = ");
		Det^.PrintElement;

				
	END TestReal;

	PROCEDURE TestInteger*;
		VAR
			A: MATRIX;
			B: MATRIX;
			C: MATRIX;
			Det: Element;
			
	BEGIN
		OutExt.String("-----=====<<<<<  Matrices met INTEGER waardes  >>>>>=====-----");
		NEW(A);
		NEW(B);
		NEW(C);
		NEW(Det);
		A^.InitializeInteger;
		B^.InitializeInteger;
		C^.InitializeInteger;
		
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("De eenheidsmatrix (A):");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;		
		A^.Unity;
		A^.PrintMatrix;
		
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("Een matrix inlezen (B):");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;
		B^.MatrixInlezen;
		B^.PrintMatrix;
		
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("Matrix A met 5 vermenigvuldigen (C):");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;
		C := A^.ScalarMult(5.0);
		C^.PrintMatrix;
			
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("Matrix C en Matrix A optellen (A):");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;
		A := C^.Sum(A);
		A^.PrintMatrix;
		
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("Matrix A van Matrix B Aftrekken (B):");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;
		B := B^.Diff(A);
		B^.PrintMatrix;
		
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("Matrix C vermenigvuldigen met Matrix A (C):");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;
		C := C^.MultMatrix(A);
		C^.PrintMatrix;
		
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("Determinant bepalen van Matrix B:");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;
		Det := B^.Determinant(4);
		OutExt.String("Determinant = ");
		Det^.PrintElement;

				
	END TestInteger;

	PROCEDURE TestBoolean*;
		VAR
			A: MATRIX;
			B: MATRIX;
			C: MATRIX;
			Det: Element;
			
	BEGIN
		OutExt.String("-----=====<<<<<  Matrices met BOOLEAN waardes  >>>>>=====-----");
		NEW(A);
		NEW(B);
		NEW(C);
		NEW(Det);
		A^.InitializeBoolean;
		B^.InitializeBoolean;
		C^.InitializeBoolean;
		
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("De eenheidsmatrix (A):");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;		
		A^.Unity;
		A^.PrintMatrix;
		
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("Een matrix inlezen (B):");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;
		B^.MatrixInlezen;
		B^.PrintMatrix;
		
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("Matrix A met -1 vermenigvuldigen (C):");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;
		C := A^.ScalarMult(-1.0);
		C^.PrintMatrix;
			
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("Matrix C en Matrix A optellen (A):");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;
		A := C^.Sum(A);
		A^.PrintMatrix;
		
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("Matrix A van Matrix B Aftrekken (B):");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;
		B := B^.Diff(A);
		B^.PrintMatrix;
		
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("Matrix C vermenigvuldigen met Matrix A (C):");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;
		C := C^.MultMatrix(A);
		C^.PrintMatrix;
		
		OutExt.Ln;
		OutExt.Ln;
		OutExt.String("Determinant bepalen van Matrix B:");
		OutExt.Ln;
		OutExt.String("-------------------------------------------");
		OutExt.Ln;
		Det := B^.Determinant(4);
		OutExt.String("Determinant = ");
		Det^.PrintElement;

				
	END TestBoolean;
	
BEGIN
OutExt.Open();
OutExt.Clear;
END MatrixOOTest.
MatrixOO.Tool

Code: Select all

MatrixOO.Tool
(*
	Author: Nick De Frangh
	Date: 08-11-05
*)

Builder.Compile \ws2
	OutExt.Mod
	MatrixOO.Mod
	MatrixOOTest.Mod
	~
	
Builder.Compile \f2*

System.Free
	MatrixOOTest.Mod
	MatrixOO.Mod
	OutExt.Mod
	~

OutExt.Clear


MatrixOOTest.TestReal
	3.0   5.0   6.0   9.0
	8.0   2.0   1.0   4.0
	5.0   8.0   6.0   3.0
	2.0   1.0   4.0   5.0~
	
MatrixOOTest.TestInteger
	3   5   6   9
	8   2   1   4
	5   8   6   3
	2   1   4   5~

MatrixOOTest.TestBoolean
	"TRUE"   "FALSE"   "TRUE"   "FALSE"
	"FALSE"   "TRUE"   "TRUE"   "FALSE"
	"TRUE"   "FALSE"   "FALSE"   "TRUE"
	"TRUE"   "FALSE"   "TRUE"   "FALSE"~
(Ik denk dat dit 's werelds langste post is :D)

Posted: Fri Dec 16, 2005 9:59 pm
by Shinta
lol ;) en nog mor 1 pagina

Posted: Sun Dec 18, 2005 6:19 pm
by Wim
Nickman wrote:(* -------===========<<<<<<<< Twee Matrices met elkaar vermenigvuldigen >>>>>>>>===========-------- *)

PROCEDURE (M : MATRIX) MultMatrix*(N : MATRIX): MATRIX;
VAR
x, y, z : INTEGER;
O : MATRIX;
Temp : Element;
BEGIN
NEW(O);
M^.matrix[0, 0]^.InitializeSame(O);

FOR y := 0 TO 3 DO
FOR x := 0 TO 3 DO
FOR z := 0 TO 3 DO
NEW(Temp);
Temp := M^.matrix[z, y]^.MultElement(N^.matrix[x, z]);
O^.matrix[x, y] := O^.matrix[x,y].SumElement(Temp);
END;
END;
END;
RETURN O;
END MultMatrix;
Waarom moet ge hier nog deen 'InitializeSame' doen? In mijn programma moet ik da ook doen, anders krijg ik ne System.Trap.
Mor ik zou denke da hetzelfde zou zijn bij de som, en daar is da nie nodig.

Posted: Sun Dec 18, 2005 8:11 pm
by Nickman
Je moet bij die mult die Initialize same doen, omdat je hier de matrix O wil meegeven aan de Som denkik, en als die nog nooit geïnitializeerd is gewest, weet hij ook niet welk type van elementen er in zit.
Als je nergens de elementen van O zou moeten meegeven, dan zou je die ook niet perse moeten initializeren.

Code: Select all

O^.matrix[x, y] := O^.matrix[x,y].SumElement(Temp);

Posted: Sun Dec 18, 2005 8:39 pm
by Norfolk
bij mij is dat niet nodig omda mijn kleinere (SumElement) een element zelf return dus die maakt da aan en zet die pointer in da veld

Posted: Sun Dec 18, 2005 8:53 pm
by Nickman
Mja, bij mij returnt die ook gewoon een element zenne :).
Hetgeen ik misschien wel hadkunenn doen om die initialize same te kunnen vermijden is gewoon "Temp" en "O^.matrix[x, y]" van plaats verwisselen... :p

Posted: Sun Dec 18, 2005 9:08 pm
by Yo_rik
Nickman wrote:Mja, bij mij returnt die ook gewoon een element zenne :).
Hetgeen ik misschien wel hadkunenn doen om die initialize same te kunnen vermijden is gewoon "Temp" en "O^.matrix[x, y]" van plaats verwisselen... :p
Dan zult ge nog altijd nen trap hebben (Type-guard failed in uw MultElement) :wink:.

Posted: Sun Dec 18, 2005 9:48 pm
by Nickman
Waarom zou ik in mijn MultElement een trap krijgen? Aangezien ik nu geen trap krijg en die alleen gebruikt maakt van al geïnitializeerde matrices?

Code: Select all

Temp := M^.matrix[z, y]^.MultElement(N^.matrix[x, z]);
Het is enkel doordat de O matrix nog niet geïnitializeerd zou zijn dat ik daar een trap bij zal krijgen omdat hij niet weet welke elementen hij moet nemen.

Maar het kan wel zijn dat ik dan nog steeds op die plaats een trap krijg, aangezien er nog niets in die elementen zit, dat zou ik eens moeten proberen, maar heb ik nu niet veel zin in :D

Posted: Sun Dec 18, 2005 11:14 pm
by Yo_rik
Ik bedoelde alleen dat ge nen trap zou krijgen als ge geen InitializeSame doet en Temp en O^.matrix[x, y] omwisselt.
Dan probeert hij die type-guard op O^.matrix[x, y] en die is op dat moment nog NIL.

Zoals het er nu staat, is alles in orde :D.

Posted: Sun Dec 18, 2005 11:24 pm
by Yo_rik
Shinta wrote:lol :wink: en nog mor 1 pagina
Het is precies een vast aantal posts per pagina :lol:

Posted: Tue Dec 20, 2005 9:31 am
by Shinta
Klaaarr :mrgreen: nog een langere pagina.

Re: Reeks7

Posted: Tue Dec 20, 2005 11:16 am
by Norfolk
edit: was maar een grap zuh ..

Posted: Tue Dec 20, 2005 11:21 am
by WiDeCr0w
over nen erg onnodige reply te spreken.. :|

Posted: Tue Dec 20, 2005 6:00 pm
by Shinta
ja man wtf :!: edit die is zonder al die tekst
All times are UTC+02:00
Page 1 of 2
Powered by phpBB® Forum Software © phpBB Limited
https://www.phpbb.com/