WINAK

Waar elke student thuis is!

Skip to content

[Prog] Reeks7

Forum van 1ste Bachelor Informatica.

Moderator: Praesidium

Post Reply
User avatar
Shinta
WOZ
Posts: 1122

Reeks7

Post#1 » Thu Dec 15, 2005 10:59 pm

OFF-LINE
Last edited by Shinta on Fri Jan 20, 2006 1:44 pm, edited 3 times in total.
Top
User avatar
Nickman
Posts: 391
Contact:
Contact Nickman

Post#2 » Fri Dec 16, 2005 8:06 pm

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)
Webmaster of http://www.bwf.be
Make it idiot proof and someone will make a better idiot!

[quote="zarry"][url=http://www.winak.be/forum/viewtopic.php?p=12475#12475]wickaaaah! thcikci tschiki paaaauuuuw wicked-original![/url][/quote]
Top
User avatar
Shinta
WOZ
Posts: 1122

Post#3 » Fri Dec 16, 2005 9:59 pm

lol ;) en nog mor 1 pagina
Top
User avatar
Wim
Posts: 16

Post#4 » Sun Dec 18, 2005 6:19 pm

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.
Top
User avatar
Nickman
Posts: 391
Contact:
Contact Nickman

Post#5 » Sun Dec 18, 2005 8:11 pm

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);
Top
User avatar
Norfolk
WOZ
Posts: 780
Contact:
Contact Norfolk

Post#6 » Sun Dec 18, 2005 8:39 pm

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
Top
User avatar
Nickman
Posts: 391
Contact:
Contact Nickman

Post#7 » Sun Dec 18, 2005 8:53 pm

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
Top
User avatar
Yo_rik
Posts: 69

Post#8 » Sun Dec 18, 2005 9:08 pm

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:.
Top
User avatar
Nickman
Posts: 391
Contact:
Contact Nickman

Post#9 » Sun Dec 18, 2005 9:48 pm

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
Top
User avatar
Yo_rik
Posts: 69

Post#10 » Sun Dec 18, 2005 11:14 pm

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.
Top
User avatar
Yo_rik
Posts: 69

Post#11 » Sun Dec 18, 2005 11:24 pm

Shinta wrote:lol :wink: en nog mor 1 pagina
Het is precies een vast aantal posts per pagina :lol:
Top
User avatar
Shinta
WOZ
Posts: 1122

Post#12 » Tue Dec 20, 2005 9:31 am

Klaaarr :mrgreen: nog een langere pagina.
Top
User avatar
Norfolk
WOZ
Posts: 780
Contact:
Contact Norfolk

Re: Reeks7

Post#13 » Tue Dec 20, 2005 11:16 am

edit: was maar een grap zuh ..
Last edited by Norfolk on Tue Dec 20, 2005 9:11 pm, edited 1 time in total.
Top
User avatar
WiDeCr0w
Posts: 38
Contact:
Contact WiDeCr0w

Post#14 » Tue Dec 20, 2005 11:21 am

over nen erg onnodige reply te spreken.. :|
Top
User avatar
Shinta
WOZ
Posts: 1122

Post#15 » Tue Dec 20, 2005 6:00 pm

ja man wtf :!: edit die is zonder al die tekst
Top
Post Reply

Return to “1ste Bachelor”

Who is online

Users browsing this forum: No registered users and 4 guests

Powered by phpBB® Forum Software © phpBB Limited
 

 

cron