-
-
Save romulomourao/59ba066633c8fe4d3cac81d84f13abc7 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/** | |
* Created by IntelliJ IDEA. | |
* User: Milan Vít (Cellane) | |
* Date: May 12, 2010 | |
* Time: 2:16:44 PM | |
*/ | |
import java.text.MessageFormat; | |
public class MatrixDeterminant { | |
/** | |
* Main method that initializes the matrix and calls method to calculate | |
* its determinant | |
* | |
* @param args command line arguments; unused | |
*/ | |
public static void main (String[] args) { | |
double x[][] = { | |
{14, 5, 2, 10,}, | |
{12, -9, 0, 7,}, | |
{1, 2, 0, -4,}, | |
{-7, 29, 2, -16}, | |
}; | |
double determinant; | |
determinant = MatrixOperations.matrixDeterminant (x); | |
System.out.println (MessageFormat.format ("Determinant: {0}", Double.toString (determinant))); | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/** | |
* Created by IntelliJ IDEA. | |
* User: Milan Vít (Cellane) | |
* Date: May 13, 2010 | |
* Time: 1:10:02 PM | |
*/ | |
public class MatrixInversion { | |
/** | |
* Main method that initializes the matrix and calls method to calculate | |
* inverted matrix of given matrix | |
* | |
* @param args command line arguments; unused | |
*/ | |
public static void main (String[] args) { | |
double matrix[][] = { | |
{14, 5, 2, 10,}, | |
{12, -9, 0, 7,}, | |
{1, 2, 0, -4,}, | |
{-7, 29, 2, -16}, | |
}; | |
double invertedMatrix[][]; | |
invertedMatrix = MatrixOperations.invertMatrix (matrix); | |
MatrixOperations.printMatrix (invertedMatrix, 4); | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/** | |
* Created by IntelliJ IDEA. | |
* User: Milan Vít (Cellane) | |
* Date: May 12, 2010 | |
* Time: 10:32:52 AM | |
*/ | |
public class MatrixMultiplication { | |
/** | |
* Main method that initialises matrices we'll be counting with, calls | |
* method that does the multiplication and prints results | |
* | |
* @param args command line arguments; unused | |
*/ | |
public static void main (String args[]) { | |
int x[][] = { | |
{1, 2,}, | |
{4, 5,}, | |
{7, 8,}, | |
}; | |
int y[][] = { | |
{9, 8, 7,}, | |
{6, 5, 4,}, | |
}; | |
int z[][]; | |
z = MatrixOperations.multiplyMatrices (x, y); | |
MatrixOperations.printMatrix (z, 3); | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/** | |
* Created by IntelliJ IDEA. | |
* User: Milan Vít (Cellane) | |
* Date: May 12, 2010 | |
* Time: 11:17:33 AM | |
*/ | |
import java.text.MessageFormat; | |
public class MatrixOperations { | |
/** | |
* Method that multiplies two matrices and returns the result | |
* | |
* @param x first matrix | |
* @param y second matrix | |
* | |
* @return result after multiplication | |
*/ | |
public static int[][] multiplyMatrices (int[][] x, int[][] y) { | |
int[][] result; | |
int xColumns, xRows, yColumns, yRows; | |
xRows = x.length; | |
xColumns = x[0].length; | |
yRows = y.length; | |
yColumns = y[0].length; | |
result = new int[xRows][yColumns]; | |
if (xColumns != yRows) { | |
throw new IllegalArgumentException ( | |
MessageFormat.format ("Matrices don't match: {0} != {1}.", xColumns, yRows)); | |
} | |
for (int i = 0; i < xRows; i++) { | |
for (int j = 0; j < yColumns; j++) { | |
for (int k = 0; k < xColumns; k++) { | |
result[i][j] += (x[i][k] * y[k][j]); | |
} | |
} | |
} | |
return (result); | |
} | |
/** | |
* Method that calculates determinant of given matrix | |
* | |
* @param matrix matrix of which we need to know determinant | |
* | |
* @return determinant of given matrix | |
*/ | |
public static double matrixDeterminant (double[][] matrix) { | |
double temporary[][]; | |
double result = 0; | |
if (matrix.length == 1) { | |
result = matrix[0][0]; | |
return (result); | |
} | |
if (matrix.length == 2) { | |
result = ((matrix[0][0] * matrix[1][1]) - (matrix[0][1] * matrix[1][0])); | |
return (result); | |
} | |
for (int i = 0; i < matrix[0].length; i++) { | |
temporary = new double[matrix.length - 1][matrix[0].length - 1]; | |
for (int j = 1; j < matrix.length; j++) { | |
for (int k = 0; k < matrix[0].length; k++) { | |
if (k < i) { | |
temporary[j - 1][k] = matrix[j][k]; | |
} else if (k > i) { | |
temporary[j - 1][k - 1] = matrix[j][k]; | |
} | |
} | |
} | |
result += matrix[0][i] * Math.pow (-1, (double) i) * matrixDeterminant (temporary); | |
} | |
return (result); | |
} | |
public static double[][] invertMatrix (double[][] matrix) { | |
double[][] auxiliaryMatrix, invertedMatrix; | |
int[] index; | |
auxiliaryMatrix = new double[matrix.length][matrix.length]; | |
invertedMatrix = new double[matrix.length][matrix.length]; | |
index = new int[matrix.length]; | |
for (int i = 0; i < matrix.length; ++i) { | |
auxiliaryMatrix[i][i] = 1; | |
} | |
transformToUpperTriangle (matrix, index); | |
for (int i = 0; i < (matrix.length - 1); ++i) { | |
for (int j = (i + 1); j < matrix.length; ++j) { | |
for (int k = 0; k < matrix.length; ++k) { | |
auxiliaryMatrix[index[j]][k] -= matrix[index[j]][i] * auxiliaryMatrix[index[i]][k]; | |
} | |
} | |
} | |
for (int i = 0; i < matrix.length; ++i) { | |
invertedMatrix[matrix.length - 1][i] = (auxiliaryMatrix[index[matrix.length - 1]][i] / | |
matrix[index[matrix.length - 1]][matrix.length - 1]); | |
for (int j = (matrix.length - 2); j >= 0; --j) { | |
invertedMatrix[j][i] = auxiliaryMatrix[index[j]][i]; | |
for (int k = (j + 1); k < matrix.length; ++k) { | |
invertedMatrix[j][i] -= (matrix[index[j]][k] * invertedMatrix[k][i]); | |
} | |
invertedMatrix[j][i] /= matrix[index[j]][j]; | |
} | |
} | |
return (invertedMatrix); | |
} | |
public static void transformToUpperTriangle (double[][] matrix, int[] index) { | |
double[] c; | |
double c0, c1, pi0, pi1, pj; | |
int itmp, k; | |
c = new double[matrix.length]; | |
for (int i = 0; i < matrix.length; ++i) { | |
index[i] = i; | |
} | |
for (int i = 0; i < matrix.length; ++i) { | |
c1 = 0; | |
for (int j = 0; j < matrix.length; ++j) { | |
c0 = Math.abs (matrix[i][j]); | |
if (c0 > c1) { | |
c1 = c0; | |
} | |
} | |
c[i] = c1; | |
} | |
k = 0; | |
for (int j = 0; j < (matrix.length - 1); ++j) { | |
pi1 = 0; | |
for (int i = j; i < matrix.length; ++i) { | |
pi0 = Math.abs (matrix[index[i]][j]); | |
pi0 /= c[index[i]]; | |
if (pi0 > pi1) { | |
pi1 = pi0; | |
k = i; | |
} | |
} | |
itmp = index[j]; | |
index[j] = index[k]; | |
index[k] = itmp; | |
for (int i = (j + 1); i < matrix.length; ++i) { | |
pj = matrix[index[i]][j] / matrix[index[j]][j]; | |
matrix[index[i]][j] = pj; | |
for (int l = (j + 1); l < matrix.length; ++l) { | |
matrix[index[i]][l] -= pj * matrix[index[j]][l]; | |
} | |
} | |
} | |
} | |
/** | |
* Method that prints matrix | |
* | |
* @param matrix matrix to print | |
* @param id what does the matrix contain? | |
*/ | |
public static void printMatrix (int[][] matrix, int id) { | |
double doubleMatrix[][] = new double[matrix.length][matrix[0].length]; | |
for (int i = 0; i < matrix.length; i++) { | |
for (int j = 0; j < matrix[i].length; j++) { | |
doubleMatrix[i][j] = (double) matrix[i][j]; | |
} | |
} | |
printMatrix (doubleMatrix, id); | |
} | |
/** | |
* Method that prints matrix | |
* | |
* @param matrix matrix to print | |
* @param id what does the matrix contain? | |
*/ | |
public static void printMatrix (double[][] matrix, int id) { | |
int cols, rows; | |
rows = matrix.length; | |
cols = matrix[0].length; | |
switch (id) { | |
case 1: | |
System.out.print (MessageFormat.format ("First matrix[{0}][{1}]:", rows, cols)); | |
break; | |
case 2: | |
System.out.print (MessageFormat.format ("Second matrix[{0}][{1}]:", rows, cols)); | |
break; | |
case 3: | |
System.out.print (MessageFormat.format ("Result[{0}][{1}]:", rows, cols)); | |
break; | |
case 4: | |
System.out.print (MessageFormat.format ("Inverted matrix[{0}][{1}]:", rows, cols)); | |
break; | |
default: | |
System.out.print (MessageFormat.format ("Matrix[{0}][{1}]:", rows, cols)); | |
break; | |
} | |
System.out.println (); | |
for (int i = 0; i < matrix.length; i++) { | |
System.out.print ("["); | |
for (int j = 0; j < matrix[i].length; j++) { | |
System.out.print (matrix[i][j]); | |
if ((j + 1) != matrix[i].length) { | |
System.out.print (", "); | |
} | |
} | |
if ((i + 1) != matrix.length) { | |
System.out.println ("]"); | |
} else { | |
System.out.println ("]."); | |
} | |
} | |
System.out.println (); | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment