Műveletek mátrixokkal

• Szerző: Sallai András
• Copyright © 2014, Sallai András
• Licenc: CC BY-SA 4.0
• Web: https://szit.hu

A mátrixok tulajdonképpen számok téglalap alakú tömbjei. A mátrixokkal való műveletvégzés a tudományos számítások alapjai.

Számok táblázatos formában, amelynek n darab sora és m darab oszlopa van.

3×4 mátrix:

Szögletes zárójelek helyett lehet szimpla zárójel is.

A mátrixban minden elemre tudunk hivatkozni az indexük alapján. Az első index a sor jelöli, a második az oszlopot.

A azt jelenti, az első sor, harmadik eleme.

Ha általánosan valamelyik elemre hivatkozunk akkor szokásos forma: . Ahol i sor, j az oszlop.

A főátlót azok az elem alkotják, amelyek sor- és oszlopindexei azonosak.

A fenti mátrixban főátlót a 8 5 és 3-as értékek alkotják, amelyeknek az indexe rendre: 11, 22, 33.

Minden mátrixhoz hozzárendelhető egy szám, amelyet determinánsnak nevezünk.

Ha a determináns 0, akkor szinguláris mátrixról beszélünk.

Ha determináns nem 0, akkor reguláris mátrixról beszélünk.

A determinánst számítása 2×2 mátrixban:

• veszem a fő átló elemeinek szorzatát
• veszem a másik átló elemeinek szorzatát
• a két szorzat különbsége a determináns

A determináns jelölése:

|A|

vagy:

det(A)

Legyen egy 2×2-es mátrix:

Ha kvadratikus mátrix mérete nagyobb mint 2, a determináns számítása másként történik.

A kifejtéshez ki kell választani egy sort vagy egy oszlopot. Bármely sor vagy oszlop alapján meghatározható a determináns.

Legyen a példa kedvéért a következő mátrix:

A bal felső sarkot jelöljük meg „+” jellel. Ez után sakktábla-szerűen a többit is:

Vegyük a kifejtéshez az első oszlopot: 2, 4, 6.

Jelöljük meg közülük az elsőt, azaz a 2-t. A 2-vel azonos sorban és oszlopban lévő elemekkel nem foglalkozunk. Így marad egy 2×2-es mátrix:

Ennek kiszámítjuk a determinánsát a 2×2 nagyságú mátrix esetén tanultak alapján.

Írjuk fel a fentebb kiválasztott 2-es számot és ezt a 37-es eredményt szorzatként:

2 * 37

Vegyük az oszlop következő elemét, ami 4. A 4-gyel azonos sorokkal és oszlopokkal most nem foglalkozunk. A megmaradt elemek egy megint egy 2×2-es mátrixot alkotnak, aminek kiszámítjuk a determinánsát.

A 2 * 37 szorzathoz hozzáadjuk az újabbat:

A táblázatból látjuk, hogy a 4-es érték negatívan számít.

Vegyük az oszlop utolsó elemét, amely a 6. A hozzátartozó sor és oszlop elemeivel itt sem foglalkozunk:

Kiszámítjuk a megmaradt 2×2-es mátrix determinánsát:

A fenti szorzatunkhoz hozzáadjuk a 6 * 3 szorzatot. A 6 itt is az oszlop utolsó eleme, a 27 pedig az utóbbi 2×2-es mátrix determinánsa.

A szorzatunk végül: Kiszámítva megkapjuk a determinánst:

A 3×3-as mátrixunk determináns számítás eredménye ezek után így írható fel:

A 4×4-s mátrixot úgy kezdjük mint a 3×3 méret esetén, de most négy oszloppal és sorral számolok. Az elsőként kiválasztott elem esetén, a kiválasztott elemhez tartozó sorok és oszlopokon kívül eső rész nem 2×2-s mátrix, helyette 3×3. A 3×3-as mátrix determinánsát a kifejtési tétellel számoljuk, mint azt az előbb láttuk.

Így járok el a többi sor és oszlop esetén is.

//Determináns számítása:
static double det(double[][] a, int n) {
	double d = 1;
	for(int k=0; k<n; k++){
		for(int i=k+1; i<n; i++) {
			double g = a[i][k] / a[k][k];
			for(int j=k+1; j<n; j++) {
				a[i][j] = a[i][j] - g * a[k][j];
			}
		}
		d = d * a[k][k];
	}
	return d;
}

1×1 dimenziós mátrix. Valójában egy szimpla szám.

Másként kvadratikus mátrix. A mátrix n x n elemből áll.

A nullmátrix minden eleme 0.

A főátlóban 1-es értékek vannak, a többi 0.

Az átló alatt 0 értékek.

Az átló fölött nulla értékek.

A főátlón kívül minden elem 0;

A transzponálás a sorok és oszlopok felcserélése.

A transzponáltja:

Program01.java

class Program01 {
	static int[][] a = { 
		{5, 2, 3, 4},
		{0, 1, 4, 5},
		{3, 2, 0, 6}};
	static int[][] b = new int[4][3];
 
	public static void transzponal() {
		for(int i=0; i<3; i++) {
			for(int j=0; j<4; j++) {
				b[j][i] = a[i][j];
			}
		}	
	}
	public static void kiir(int sor, int oszlop, int[][] matrix) {
		for(int i=0; i<sor; i++) {
			for(int j=0; j<oszlop; j++) {
				System.out.print(matrix[i][j] + " ");
			}
			System.out.println();			
		}
	}
	public static void main(String[] args) {
		kiir(3, 4, a);
		System.out.println("------------");
		transzponal();
		kiir(4, 3, b);
	}
}

Eredmény:

5 2 3 4 
0 1 4 5 
3 2 0 6 
------------
5 0 3 
2 1 2 
3 4 0 
4 5 6 

Meg kell vizsgálnunk a szorzás elvégezhető-e.

A következő nagyságú mátrixok szorozhatók:

n * k és k * m

Ahol n*k az első mátrix méretei, és k*m a másik mátrix méretei. A két mátrix akkor szorozható, ha k méreteik megegyeznek. Az összeszorzott mátrix mérete: n * m lesz.

n * k és k * m eredmény: n * m

Mátrix műveletek

• Nem kommutatív a szorzásra nézve→ A * B != B * A
• Asszociatív → (A * B) * C = A * (B * C)

Program01.java

class Program01 {
	static int[][] a = { 
		{1, 2},
		{3, 4}
		};
	static int[][] b = { 
		{10, 20, 30},
		{40, 50, 60}		
		};
	static int[][] c = new int[2][3];
 
	public static void szoroz() {
		int m = 2, n = 2, k = 3; //m-oszlop, n-sor (k-oszlop)
		int sum=0;
 
		for (int i = 0 ; i < n ; i++ ) {
			for (int j = 0 ; j < k ; j++ ) {
				for (int p = 0 ; p < m ; p++ ) {
					sum = sum + a[i][p] * b[p][j];
				}
				c[i][j] = sum;
				sum = 0;
			}
		}	
	}
	public static void kiir(int sor, int oszlop, int[][] matrix) {
		for(int i=0; i<sor; i++) {
			for(int j=0; j<oszlop; j++) {
				System.out.print(matrix[i][j] + " ");
			}
			System.out.println();			
		}
	}
	public static void main(String[] args) {
		kiir(2, 2, a);		System.out.println("------------");
		kiir(2, 3, b);		System.out.println("------------");
		szoroz();
		kiir(2, 3, c);
	}
}

Eredmény:

1 2 
3 4 
------------
10 20 30 
40 50 60 
------------
90 120 150 
190 260 330

Keressük azt a mátrixot, amelyet megszorozva az eredeti mátrixot, az egységmátrixot kapjuk.

Az eredmények közönséges törtként:

Az eredmények tizedestörtként:

Legyen A mátrix. Keressük az inverzét, amit így jelölünk: A^-1

Egy mátrix nem invertálható ha a determinánsa 0.

Ezért számítsuk ki a determinánst:

det A = 2 * 4 - 3 * 1 = 5 ≠ 0

Nem nulla, így a mátrix invertálható.

Leírjuk az A mátrixot és mellé az E egységmátrixot:

[A|E]

Osztjuk az első sort 2-vel:

Hozzáadjuk a második sorhoz az első -3 szorosát:

Osztjuk a második sort 5/2-vel:

Hozzáadjuk az első sorhoz, második sor -1/2 szeresét:

Az eredmény:

A^-1 =

Program01.java

import java.util.Scanner; 
 
class Program01 {
 
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.println("Mátrix invertálása");
 
		System.out.print("Mátrix mérete: ");
		int size = in.nextInt();
 
		double[][] a = new double[size][size+size];
 
 
		//Az egységmátrix elkészítése
		for (int i = 0; i < size; i++) {
			for (int j = 0; j < size+size; j++) {
				if (j == i + size) {
					a[i][j] = 1;
				} else {
					a[i][j] = 0;
				}
			}
		}
 
		//Mátrix bekérése
		System.out.printf("\nÍrd be a %d X %d mátrixot:\n", size, size);
		for (int i = 0; i < size; i++) {
			for (int j = 0; j < size; j++) {				
				a[i][j] = in.nextDouble();
			}
		}
 
 
		if(det(a, size)==0) {
			System.out.println("Nem invertálható, mert a determinánsa 0");
		}else {		
			inverz(a, size);
			kiir(a, size);
		}
	}
 
	//Determináns számítása:
	static double det(double[][] a, int n) {
		double d = 1;
		for(int k=0; k<n; k++){
			for(int i=k+1; i<n; i++) {
				double g = a[i][k] / a[k][k];
				for(int j=k+1; j<n; j++) {
					a[i][j] = a[i][j] - g * a[k][j];
				}
			}
			d = d * a[k][k];
		}
		return d;
	}
 
	static void inverz(double[][] a, int size) {
		//Oszloponként változtatok
		for (int i = 0; i < size; i++) {
			reduction(a, size, i, i);
		}		
	}
 
 
	static void kiir(double[][] a, int size) {
		System.out.println("\nInverz mátrix");
		for (int i = 0; i < size; i++) {			
			for (int j = 0; j < size; j++) {
				System.out.printf("%8.2f", a[i][j + size]);
			}
			System.out.println();
		}
 
	}
 
	static void reduction(double a[][], int size, int pivot, int col) {
		double factor = a[pivot][col];
 
		for (int i = 0; i < 2 * size; i++) {
			a[pivot][i] /= factor;
		}
 
		for (int i = 0; i < size; i++) {
			if (i != pivot) {
				factor = a[i][col];
				for (int j = 0; j < 2 * size; j++) {
					a[i][j] = a[i][j] - a[pivot][j] * factor;
				}
			}
		}
	}
}

Gauss-Jordan elimináció

Az első sort osztom 7-tel:

Hozzáadjuk a kettes sorhoz az első sor -1 szeresét:

A mátrix inverze:

Gauss-Jordan elimináció

A második sort osztom -2-vel:

Gauss-Jordan elimináció