Gyakorlati alapok
Műveletek mátrixban
Honlapomon gyakorlati bevezetőként már esett szó a kétdimenziós tömbökről a Kétdimenziós tömb című fejezetben. Ezen matematikai szerkezetek másik neve egyébként "neósan" fogalmazva mátrix. Folytassuk tovább felfedezésüket és alapszintű felhasználásukat, de először nézzük meg a kötelező elméletet!
A matematikai mátrix mennyiségek, értékek táblázat alakú elrendezése:
Rajta egzakt matematikai műveletek kiválóan végezhetők, felhasználása ezért rendkívül sokoldalú: a fizikától, a számítógépes grafikától kezdve a biológián át egészen a nyelvészetig, számtalan tudományágban használhatók akár az elméleti leírás tömör megfogalmazására, akár a számítások megkönnyítésére vagy automatizálására.
A mátrix vízszintes vonalban elhelyezkedő elemei sorokat, függőleges vonalban elhelyezkedő elemei oszlopokat alkotnak. Egy m sorból és n oszlopból álló mátrixot m-szer n mátrixnak nevezzük (m × n), az m és n pozitív egész számok a mátrix dimenziói (kiterjedései). A mátrix dimenzióit mindig először a sorok számával, majd az oszlopok számával adjuk meg.
Programozás-technikailag a mátrix tehát kétdimenziós tömbként értelmezhető és ilyen megközelítésben a tömbökkel azonos módon kell őket létrehozni és kezelni.
Az alábbi kód további óriási előnye, hogy funkcionálisan szétosztott -tehát a funkciókat külön metódusokban valósítjuk meg-, ezért bármelyik funkció tetszőleges mennyiségben használható fel. A funkciók a következők:
-
matrixFeltoltes() - 1 és 90 közötti véletlenszámokkal tölt fel egy mátrixot,
-
matrixKiiras() - kiírja a paraméterül kapott mátrixot,
-
minimum() - megkeresi a paraméterül kapott mátrix legkisebb elemét,
-
minimumKereses() - megkeresi és kiírja a paraméterül kapott mátrix legkisebb elemének helyét,
-
maximum() - megkeresi a paraméterül kapott mátrix legnagyobb elemét,
-
maximumKereses() - megkeresi és kiírja a paraméterül kapott mátrix legnagyobb elemének helyét,
-
matrixOsszeadas() - összead 2 db paraméterül kapott mátrixot,
-
matrixKivonas() - kivonja egymásból a 2 db paraméterül kapott mátrixot,
-
matrixSzorzas() - összead 2 db paraméterül kapott mátrixot,
-
matrixOsztas() - elosztja egymással a 2 db paraméterül kapott mátrixot,
-
main() - már csak deklarációkat és metódushívásokat tartalmaz.
Az összes funkció viszonylag homogén, a meglévő tudásszintükkel hamar implementálható. Kis gondot talán a legutolsó matrixOsztas() metódus okozhat, hiszen 2 db int típusú mátrixszal dolgozunk, amelynek végeredménye így az osztás jellege miatt garantáltan csonkolódni fog. Ezt több helyen is le kell kezelnünk:
-
eredménymátrixként külön, double típusú mátrixot kell megadnunk:
-
mind a main() főprogramban - double tombOsztasiEredmeny[][] = new double[4][4];
-
mind a matrixOsztas() metódus bemeneti paraméterlistájában - public static double[][] matrixOsztas(int tombMatrix1[][], int tombMatrix2[][], double tombEredmeny[][]),
-
-
2 db int típusú mátrix osztása még ezek után is csonkolódni fog, ezért az 1. (az osztandó) mátrixot kasztolnunk kell: (double)tombMatrix1[i][j].
-
Érdekes programozás-technikai trükk a következő kasztolási forma: 1.0 * tombMatrix1[i][j]. Hatása a fenti deklarációval azonos.
-
Az osztás problematikájából következő további érdekesség -amely csak a Java-kód figyelmes olvasása közben tűnhet fel-, hogy a matrixKiiras() metódus kétszer is deklarálásra került azonos tartalommal, de különböző paraméterekkel. Ezt szintén meg kell tennünk, másként fordítási hibát kapunk:
public static void matrixKiiras(int matrix[][]){
for(int i = 0; i <= 3; i++){
System.out.println();
for(int j = 0; j <= 3; j++){
System.out.print(matrix[i][j] + " ");
}
}
}
public static void matrixKiiras(double matrix[][]){
for(int i = 0; i <= 3; i++){
System.out.println();
for(int j = 0; j <= 3; j++){
System.out.print(matrix[i][j] + " ");
}
}
}
-
Ez tipikus metódus-túlterhelés (method-overloading), amely eleddig még nem merült fel a honlapon; részletesen erről az Ahol az elnevezésnek köze nincs a tartalomhoz: a metódus-túlterhelés című fejezetben olvashatunk.
Nézzük meg a futtatható Java-kódot!
import java.util.Random;
public class Main {
public static int[][] matrixFeltoltes(){
Random rnd = new Random();
int matrix[][] = new int[4][4];
for(int i = 0; i < matrix.length; i++){
for(int j = 0; j < matrix.length;
j++){
matrix[i][j]
= rnd.nextInt(90) + 1;
}
}
return matrix;
}
public static void matrixKiiras(int matrix[][]){
for(int i = 0; i <= 3; i++){
System.out.println();
for(int j = 0; j <= 3; j++){
System.out.print(matrix[i][j] + " ");
}
}
}
public static void matrixKiiras(double matrix[][]){
for(int i = 0; i <= 3; i++){
System.out.println();
for(int j = 0; j <= 3; j++){
System.out.print(matrix[i][j] + " ");
}
}
}
public static int minimum(int matrix[][]){
int min = 91;
for(int i = 0; i < matrix.length; i++){
for(int j = 0; j < matrix[i].length;
j++){
if(min >
matrix[i][j]){
min = matrix[i][j];
}
}
}
return min;
}
public static int maximum(int matrix[][]){
int max = 0;
for(int i = 0; i < matrix.length; i++){
for(int j = 0; j < matrix[i].length;
j++){
if(max <
matrix[i][j]){
max = matrix[i][j];
}
}
}
return max;
}
public static void minimumKereses(int matrix[][], int min){
int i, j;
for(i = 0; i < matrix.length; i++){
for(j = 0; j < matrix[i].length;
j++){
if(min ==
matrix[i][j]){
System.out.println((j + 1) + ". oszlop " + (i + 1) + ". sorában van.");
}
}
}
}
public static void maximumKereses(int matrix[][], int max){
int i, j;
for(i = 0; i < matrix.length; i++){
for(j = 0; j < matrix[i].length;
j++){
if(max ==
matrix[i][j]){
System.out.println((j + 1) + ". oszlop " + (i + 1) + ". sorában van.");
}
}
}
}
public static int[][] matrixOsszeadas(int tombMatrix1[][], int
tombMatrix2[][], int tombEredmeny[][]){
for(int i = 0; i <= 3; i++){
for(int j = 0; j <= 3; j++){
tombEredmeny[i][j] = tombMatrix1[i][j] + tombMatrix2[i][j];
}
}
return tombEredmeny;
}
public static int[][] matrixKivonas(int tombMatrix1[][], int tombMatrix2[][],
int tombEredmeny[][]){
for(int i = 0; i <= 3; i++){
for(int j = 0; j <= 3; j++){
tombEredmeny[i][j] = tombMatrix1[i][j] - tombMatrix2[i][j];
}
}
return tombEredmeny;
}
public static int[][] matrixSzorzas(int tombMatrix1[][], int tombMatrix2[][],
int tombEredmeny[][]){
for(int i = 0; i <= 3; i++){
for(int j = 0; j <= 3; j++){
tombEredmeny[i][j] = tombMatrix1[i][j] * tombMatrix2[i][j];
}
}
return tombEredmeny;
}
public static double[][] matrixOsztas(int tombMatrix1[][], int
tombMatrix2[][], double tombEredmeny[][]){
for(int i = 0; i <= 3; i++){
for(int j = 0; j <= 3; j++){
tombEredmeny[i][j] = (double)tombMatrix1[i][j] / tombMatrix2[i][j];
}
}
return tombEredmeny;
}
public static void main(String[] args) {
int tombMatrix1[][] = new int[4][4];
tombMatrix1 = matrixFeltoltes();
matrixKiiras(tombMatrix1);
System.out.println();
int min = minimum(tombMatrix1);
System.out.println("\nA legkisebb elem: " + min);
minimumKereses(tombMatrix1, min);
int max = maximum(tombMatrix1);
System.out.println("\nA legnagyobb elem: " + max);
maximumKereses(tombMatrix1, max);
int tombMatrix2[][] = new int[4][4];
int tombEredmeny[][] = new int[4][4];
tombMatrix2 = matrixFeltoltes();
matrixKiiras(tombMatrix2);
System.out.println("\n");
System.out.print("Összeadás:");
matrixOsszeadas(tombMatrix1, tombMatrix2, tombEredmeny);
matrixKiiras(tombEredmeny);
System.out.println("\n");
System.out.print("Különbség:");
matrixKivonas(tombMatrix1, tombMatrix2, tombEredmeny);
matrixKiiras(tombEredmeny);
System.out.println("\n");
System.out.print("Szorzat:");
matrixSzorzas(tombMatrix1, tombMatrix2, tombEredmeny);
matrixKiiras(tombEredmeny);
System.out.println("\n");
System.out.print("Hányados:");
double tombOsztasiEredmeny[][] = new double[4][4];
matrixOsztas(tombMatrix1, tombMatrix2, tombOsztasiEredmeny);
matrixKiiras(tombOsztasiEredmeny);
}
}
Végeredmény (például):
7 70 28 45
2 9 16 39
40 59 48 8
39 23 87 81
A legkisebb elem: 2
1. oszlop 2. sorában van.
A legnagyobb elem: 87
3. oszlop 4. sorában van.
60 78 49 70
23 67 75 89
77 57 50 86
30 2 82 23
Összeadás:
67 148 77 115
25 76 91 128
117 116 98 94
69 25 169 104
Különbség:
-53 -8 -21 -25
-21 -58 -59 -50
-37 2 -2 -78
9 21 5 58
Szorzat:
420 5460 1372 3150
46 603 1200 3471
3080 3363 2400 688
1170 46 7134 1863
Hányados:
0.11666666666666667 0.8974358974358975 0.5714285714285714 0.6428571428571429
0.08695652173913043 0.13432835820895522 0.21333333333333335
0.43820224719101125
0.5194805194805194 1.0350877192982457 0.96 0.09302325581395349
1.3 11.5 1.0609756097560976 3.5217391304347827
Pénzes László