We Keep Coding

How to use the insertColumn(int j, vector column)

I just need to insert rows and columns of zeros in a matrix
tried to get exmples from web searches
ArrayList<double [][]> al = new ArrayList<>();
for (int i1= 0; i1<=i; i1++)
al.add(k);
System.out.println(al.size());
double[][] firstMatrix = al.get(i);
double [][] matrix1 = al.get(i);
double [][] matrix2 = al.get(i);
Matrix Matrix1 = new Matrix (matrix1);
Matrix1.show();
System.out.println();
Matrix1.insertColumn(0,0.0, 0.0, 0.0, 0.0);
Matrix1.show();
System.out.println();

Your question boils down to adding a new column/row to a Java array. This is not possible per se, because your array has an exact memory area allocated to it and you would need a larger memory area for the resulting array, so, the solution is to create a new array and solve the problem that way:
Adding a row
double[][] addRow(double[][] input, int where) {
double[][] output = new double[input.length + 1][input[0].length];
for (int rIndex = 0; rIndex < output.length; rIndex++) {
for (int cIndex = 0; cIndex < output[0].length; cIndex++) {
if (rIndex < where) output[rIndex][cIndex] = input[rIndex][cIndex];
else if (rIndex == where) output[rIndex][cIndex] = 0;
else output[rIndex][cIndex] = input[rIndex - 1][cIndex];
}
}
return output;
}
Adding a column
double[][] addColumn(double [][]input, int where) {
double[][] output = new double[input.length][input[0].length + 1];
for (int rIndex = 0; rIndex < output.length; rIndex++) {
for (int cIndex = 0; cIndex < output[0].length; cIndex++) {
if (cIndex < where) output[rIndex][cIndex] = input[rIndex][cIndex];
else if (cIndex == where) output[rIndex][cIndex] = 0;
else output[rIndex][cIndex] = input[rIndex][cIndex - 1];
}
}
return output;
}
and make sure you assign the result of these methods to whatever variable/member you have used as the data source.

Transposing a matrix from a 2D array

I'm self teaching myself some java and I'm stuck on creating a 2D array that initializes it with random values and then creates the transpose of the array.
An example output is:
$ java Test1 22 333 44 555 6
Enter the number of rows (1-10): 0
ERROR: number not in specified range (1-10) !
and so on until you enter the correct number of rows and columns.
Original matrix
1 22
333 44
555 6
Transposed matrix
1 333 555`
22 44 6`
^ Should be the final output. Some help with the code would appreciated!
I would like to code to generate error messages if the number of rows or columns is outside the specified range. And for if to read the matrix elements from the command line and not generate them randomly.
import java.util.Scanner;
public class Test1 {
/** Main method */
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("Enter the number of rows (1-10): ");
int rows = input.nextInt();
System.out.print("Enter the number of columns (1-10): ");
int cols = input.nextInt();
// Create originalMatrix as rectangular two dimensional array
int[][] originalMatrix = new int[rows][cols];
// Assign random values to originalMatrix
for (int row = 0; row < originalMatrix.length; row++)
for (int col = 0; col < originalMatrix[row].length; col++) {
originalMatrix[row][col] = (int) (Math.random() * 1000);
}
// Print original matrix
System.out.println("\nOriginal matrix:");
printMatrix(originalMatrix);
// Transpose matrix
int[][] resultMatrix = transposeMatrix(originalMatrix);
// Print transposed matrix
System.out.println("\nTransposed matrix:");
printMatrix(resultMatrix);
}
/** The method for printing the contents of a matrix */
public static void printMatrix(int[][] matrix) {
for (int row = 0; row < matrix.length; row++) {
for (int col = 0; col < matrix[row].length; col++) {
System.out.print(matrix[row][col] + " ");
}
System.out.println();
}
}
/** The method for transposing a matrix */
public static int[][] transposeMatrix(int[][] matrix) {
// Code goes here...
}
}

This is a simple method that return an int[][] of the transposed matrix...
public static int[][] transposeMatrix(int[][] matrix){
int m = matrix.length;
int n = matrix[0].length;
int[][] transposedMatrix = new int[n][m];
for(int x = 0; x < n; x++) {
for(int y = 0; y < m; y++) {
transposedMatrix[x][y] = matrix[y][x];
}
}
return transposedMatrix;
}
Than to print a 2D matrix you can use a method like this:
public static String matrixToString(int[][] a){
int m = a.length;
int n = a[0].length;
String tmp = "";
for(int y = 0; y<m; y++){
for(int x = 0; x<n; x++){
tmp = tmp + a[y][x] + " ";
}
tmp = tmp + "\n";
}
return tmp;
}

The answer provided above is not efficient in terms of memory. It is using another array - transposedMatrix apart from array supplied as argument. This will lead to consume double memory. We can do this in-place as follows:
public void transposeMatrix(int[][] a)
{
int temp;
for(int i=0 ; i<(a.length/2 + 1); i++)
{
for(int j=i ; j<(a[0].length) ; j++)
{
temp = a[i][j];
a[i][j] = a[j][i];
a[j][i] = temp;
}
}
displayMatrix(a);
}
public void displayMatrix(int[][] a){
for(int i=0 ; i<a.length ; i++)
{
for(int j=0 ; j<a[0].length ; j++)
{
System.out.print(a[i][j] + " ");
}
System.out.println();
}
}

You can use the below class it has most of the methods you want.
/**
* Class representing square matrix of given size.
* It has methods to rotate by 90, 180 and 270
* And also to transpose and flip on either axis.
*
* I have used both space efficient methods in transpose and flip
* And simple but more space usage for rotation.
*
* This is using builder pattern hence, you can keep on applying
* methods say rotate90().rotate90() to get 180 turn.
*
*/
public class Matrix {
private int[][] matrix;
final int size;
public Matrix(final int size) {
this.size = size;
matrix = new int[size][size];
for (int i=0;i<size;i++)
for (int j=0;j<size;j++)
matrix[i][j] = i*size + j;
}
public Matrix rotate90() {
int[][] temp = new int[size][size];
for (int i=0;i<size;i++)
for (int j=0;j<size;j++)
temp[i][j] = matrix[size-1-j][i];
matrix = temp;
return this;
}
public Matrix rotate180() {
int[][] temp = new int[size][size];
for (int i=0;i<size;i++)
for (int j=0;j<size;j++)
temp[i][j] = matrix[size-1-i][size-1-j];
matrix = temp;
return this;
}
public Matrix rotate270() {
int[][] temp = new int[size][size];
for (int i=0;i<size;i++)
for (int j=0;j<size;j++)
temp[i][j] = matrix[j][size-1-i];
matrix = temp;
return this;
}
public Matrix transpose() {
for (int i=0; i<size-1; i++) {
for (int j=i+1; j<size; j++) {
int tmp = matrix[i][j];
matrix[i][j] = matrix[j][i];
matrix[j][i] = tmp;
}
}
return this;
}
public Matrix flipVertical() {
for (int i=0; i<size; i++) {
for (int j=0; j<size/2; j++) {
int tmp = matrix[i][size-1-j];
matrix[i][size-1-j] = matrix[i][j];
matrix[i][j] = tmp;
}
}
return this;
}
public Matrix flipHorizontal() {
for (int i=0; i<size/2; i++) {
for (int j=0; j<size; j++) {
int tmp = matrix[size-1-i][j];
matrix[size-1-i][j] = matrix[i][j];
matrix[i][j] = tmp;
}
}
return this;
}
#Override
public String toString() {
StringBuilder sb = new StringBuilder();
for (int i=0;i<size;i++) {
for (int j=0;j<size;j++) {
sb.append("|");
sb.append(matrix[i][j]);
if (size > 3) {
sb.append("\t");
}
}
sb.append("|\n");
}
return sb.toString();
}
public static void main(String... args) {
Matrix m = new Matrix(3);
System.out.println(m);
//transpose and flipHorizontal is 270 turn (-90)
System.out.println(m.transpose());
System.out.println(m.flipHorizontal());
//rotate 90 further to bring it back to original position
System.out.println(m.rotate90());
//transpose and flip Vertical is 90 degree turn
System.out.println(m.transpose().flipVertical());
}
}
Output:
|0|1|2|
|3|4|5|
|6|7|8|
|0|3|6|
|1|4|7|
|2|5|8|
|2|5|8|
|1|4|7|
|0|3|6|
|0|1|2|
|3|4|5|
|6|7|8|
|6|3|0|
|7|4|1|
|8|5|2|

For a square matrix, instead of iterating through the entire array, you just iterate through the diagonally half of the 2D array and swap the values with the corresponding indices.
public void transposeMatrix(int[][] a) {
for(int i=0 ; i<n; i++) {
for(int j=0 ; j<i ; j++) {
int temp = a[i][j];
a[i][j] = a[j][i];
a[j][i] = temp;
}
}
}

Another Kotlin solution for n x m matrix
fun transpose(matrix: Array<Array<Double>>): Array<Array<Double>> {
return matrix[0].mapIndexed { col, _ ->
matrix.mapIndexed { row, _ ->
matrix[row][col]
}.toTypedArray()
}.toTypedArray()
}
fun printMatrix(matrix: Array<Array<Double>>) {
println(matrix.joinToString("\n") { it.contentToString() })
}
fun main() {
val matrix = arrayOf(
arrayOf( 1.0, 2.0, 3.0),
arrayOf( 4.0, 5.0, 6.0),
arrayOf( 7.0, 8.0, 9.0),
arrayOf( 1.0, 2.0, 3.0),
)
println("matrix:")
printMatrix(matrix)
println("transpose(matrix):")
printMatrix(transpose(matrix))
}
Output
matrix:
[1.0, 2.0, 3.0]
[4.0, 5.0, 6.0]
[7.0, 8.0, 9.0]
[1.0, 2.0, 3.0]
transpose(matrix):
[1.0, 4.0, 7.0, 1.0]
[2.0, 5.0, 8.0, 2.0]
[3.0, 6.0, 9.0, 3.0]
Try it in the Kotlin Playground

Here is Kotlin Solution!
fun displayMatrix(matrix: Array<IntArray>) {
for(row in matrix) {
for(column in row) {
print("$column ")
}
println()
}
}
fun main() {
//Create Array
val matrixA = arrayOf(intArrayOf(2, 3, 4), intArrayOf(5, 6, 4), intArrayOf(1, 6, 7), intArrayOf(0, 2, 8))
println("Dimension on X: ${matrixA[0].size}")
println("Dimension on Y: ${matrixA.size}")
displayMatrix(matrixA)
println()
val transposeMatrix = Array(matrixA[0].size) { IntArray(matrixA.size) }
for(i in 0..matrixA.size - 1) {
for(j in 0..matrixA[0].size - 1) {
transposeMatrix[j][i] = matrixA[i][j]
}
}
displayMatrix(transposeMatrix)
}

Calculating the exponential of a square matrix

I'm trying to write a method that calculates the exponential of a square matrix. In this instance, the matrix is a square array of value:
[1 0]
[0 10]
and the method should return a value of:
[e 0]
[0 e^10]
However, when I run my code, I get a range of values depending on what bits I've rearranged, non particularly close to the expected value.
The way the method works is to utilise the power series for the matrix, so basically for a matrix A, n steps and an identity matrix I:
exp(A) = I + A + 1/2!*AA + 1/3!*AAA + ... +1/n!*AAA..
The code follows here. The method where I'm having the issue is the method exponential(Matrix A, int nSteps). The methods involved are enclosed, and the Matrix objects take the arguments (int m, int n) to create an array of size double[m][n].
public static Matrix multiply(Matrix m1, Matrix m2){
if(m1.getN()!=m2.getM()) return null;
Matrix res = new Matrix(m1.getM(), m2.getN());
for(int i = 0; i < m1.getM(); i++){
for(int j = 0; j < m2.getN(); j++){
res.getArray()[i][j] = 0;
for(int k = 0; k < m1.getN(); k++){
res.getArray()[i][j] = res.getArray()[i][j] + m1.getArray()[i][k]*m2.getArray()[k][j];
}
}
}
return res;
}
public static Matrix identityMatrix(int M){
Matrix id = new Matrix(M, M);
for(int i = 0; i < id.getM(); i++){
for(int j = 0; j < id.getN(); j++){
if(i==j) id.getArray()[i][j] = 1;
else id.getArray()[i][j] = 0;
}
}
return id;
}
public static Matrix addMatrix(Matrix m1, Matrix m2){
Matrix m3 = new Matrix(m1.getM(), m2.getN());
for(int i = 0; i < m3.getM(); i++){
for(int j = 0; j < m3.getN(); j++){
m3.getArray()[i][j] = m1.getArray()[i][j] + m2.getArray()[i][j];
}
}
return m3;
}
public static Matrix scaleMatrix(Matrix m, double scale){
Matrix res = new Matrix(m.getM(), m.getN());
for(int i = 0; i < res.getM(); i++){
for(int j = 0; j < res.getN(); j++){
res.getArray()[i][j] = m.getArray()[i][j]*scale;
}
}
return res;
}
public static Matrix exponential(Matrix A, int nSteps){
Matrix runtot = identityMatrix(A.getM());
Matrix sum = identityMatrix(A.getM());
double factorial = 1.0;
for(int i = 1; i <= nSteps; i++){
sum = Matrix.multiply(Matrix.scaleMatrix(sum, factorial), A);
runtot = Matrix.addMatrix(runtot, sum);
factorial /= (double)i;
}
return runtot;
}
So my question is, how should I modify my code, so that I can input a matrix and a number of timesteps to calculate the exponential of said matrix after said timesteps?

My way to go would be to keep two accumulators :
the sum, which is your approximation of exp(A)
the nth term of the series M_n, that is A^n/n!
Note that there is a nice recursive relationship with M_n: M_{n+1} = M_n * A / (n+1)
Which yields :
public static Matrix exponential(Matrix A, int nSteps){
Matrix seriesTerm = identityMatrix(A.getM());
Matrix sum = identityMatrix(A.getM());
for(int i = 1; i <= nSteps; i++){
seriesTerm = Matrix.scaleMatrix(Matrix.multiply(seriesTerm,A),1.0/i);
sum = Matrix.addMatrix(seriesTerm, sum);
}
return sum;
}
I totally understand the sort of thrill that implementing such algorithms can give you. But if this is not a hobby project, I concur that you should that you should use a library for this kind of stuff. Making such computations precise and efficient is really not a trivial matter, and a huge wheel to reinvent.

How call and repeat a 2d array?

Basically my HW says to ask user for matrix of A. Then ask user by how much he would like to power Matrix A.
So basically,
I need to find a way to raise a matrix to the power. I can multiply them, but it's harder to raise them to the power because I must multiply it by itself. So What I do is create a variable to hold the matrix like so
for (i = 0; i < matrixARowSize; i++)
{
for (j = 0; j < matrixAColumnSize; j++)
{
for (k = 0; k < matrixARowSize; k++)
{
sum += matrixA[i][j] * matrixA[i][j];
}
matrixC[i][j] = sum;
sum = 0;
}
}
Then I would have to multiply to itself as much as the user wants to.
Eg:
matrixC[i][j] * matrixC[i][j]*matrixC[i][j] ...// etc
up to whatever power the user wants. I can do that with many If statements yes, but I also need to be able to add them together like so:
matrixC^6 + matrixC^5 + matrixC^4 ...
etc from whatever power the user wants. (Highest is 6).
Any suggestions on how to do this?

You can do this:
int raiseMethod(int val, int pow) {
int temp = val;
for (int i = 1; i < pow; i++) {
temp *= val;
}
return temp;
}
for (int i = 0; i < arrayColummns; i++) {
for (int j = 0; j < arrayRows; j++) {
array[i][j] = raiseMethod(array[i][j], powerToRaise);
}
}
This way, the array will be auto-updated with it's raised value on each position.

I believe you are looking for the Math.pow() method, which raises one number to the power of another, e.g.
sum += (int) Math.power(matrixA[i][j], raiseByPower);

You can do the binary multiplication of the matrix.

This Matrix structure contains everything you need.
#include <stdio.h>
#include <string.h>
const int SIZE = 6;
struct Matrix
{
int m[SIZE][SIZE];
Matrix()
{
memset(m,0,sizeof(m));
}
Matrix( int a[SIZE][SIZE] )
{
for(int i = 0;i<SIZE;++i)for(int j = 0;j<SIZE;++j)
{
m[i][j] = a[i][j];
}
}
Matrix operator * ( const Matrix &a )
{
Matrix ret;
for(int k = 0;k<SIZE;++k) for(int i = 0;i<SIZE;++i) for(int j = 0;j<SIZE;++j)
{
ret.m[i][j] += m[i][k] * a.m[k][j];
}
return ret;
}
Matrix operator ^ ( int P )
{
Matrix ret , a(this->m);
for(int i = 0;i<SIZE;++i)
ret.m[i][i] = 1;
while(P)
{
if( P&1 )
ret = ret * a;
a = a * a;
P >>= 1;
}
return ret;
}
Matrix operator + (const Matrix &a)
{
Matrix ret;
for(int i = 0;i<SIZE;++i) for(int j = 0;j<SIZE;++j)
{
ret.m[i][j] = m[i][j] + a.m[i][j];
}
return ret;
}
};
You can use this structure like the following:
Matrix A, B;
Matrix res = (A^6) + (B^5);
This Power function does log(n) multiplications of matrix.

Matrix multiplication - single-dimension * multi-dimensional

I need to multiply two matrices. I understand pretty well how matrices work however in Java I am finding this a bit complex, so I researched a bit and found this.
public static int[][] multiply(int a[][], int b[][]) {
int aRows = a.length,
aColumns = a[0].length,
bRows = b.length,
bColumns = b[0].length;
int[][] resultant = new int[aRows][bColumns];
for(int i = 0; i < aRows; i++) { // aRow
for(int j = 0; j < bColumns; j++) { // bColumn
for(int k = 0; k < aColumns; k++) { // aColumn
resultant[i][j] += a[i][k] * b[k][j];
}
}
}
return resultant;
This code works fine. However the problem with this is that I need to multiply a single dimension matrix (1*5) by a multidimensional matrix (5*4), so the result will be (1*4) matrix and later on in the same program multiply a (1*4) matrix by a (4*3) matrix resulting in (1*3).
And I need to store the single dimension matrix in a normal array (double []) not multidimensional one!
I altered this code to the following but it still doesn't resolve the correct results.
public static double[] multiplyMatrices(double[] A, double[][] B) {
int xA = A.length;
int yB = B[0].length;
double[] C = new double[yB];
for (int i = 0; i < yB; i++) { // bColumn
for (int j = 0; j < xA; j++) { // aColumn
C[i] += A[j] * B[j][i];
}
}
return C;
Thanks in advance for any tips you may give :)

You can use RealMatrix to make it easier.
RealMatrix result = MatrixUtils.createRealMatrix(a).multiply(MatrixUtils.createRealMatrix(b));
double[] array = result.getRow(0);