Finding the Hessenberg decomposition of a matrix.

Here’s an example Java code for finding the Hessenberg decomposition of a matrix:

  import java.util.Arrays;

  public class HessenbergDecomposition {

    public static void main(String[] args) {

        double[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

        double[][] hessenbergMatrix = computeHessenberg(matrix);

        System.out.println("Original Matrix:");

        printMatrix(matrix);

        System.out.println("\nHessenberg Matrix:");

        printMatrix(hessenbergMatrix);

    }

    public static double[][] computeHessenberg(double[][] matrix) {

        int n = matrix.length;

        double[][] hessenberg = Arrays.copyOf(matrix, n);

        for (int k = 1; k < n - 1; k++) {

            double[] column = new double[n - k];

            for (int i = k; i < n; i++) {

                column[i - k] = hessenberg[i][k - 1];

            }

            double norm = getNorm(column);

            double[] u = new double[n - k];

            u[0] = column[0] + Math.signum(column[0]) * norm;

            double uNorm = getNorm(u);
          
            if (uNorm != 0) {

                for (int i = 0; i < n - k; i++) {

                    u[i] /= uNorm;

                }
              
               for (int i = k; i < n; i++) {

                    double[] v = new double[n - k];

                    for (int j = 0; j < n - k; j++) {

                        v[j] = u[j] * hessenberg[i][k - 1];

                    }

                    for (int j = 0; j < n - k; j++) {

                        hessenberg[i][k - 1] -= 2 * v[j];

                    }                  

                    for (int j = k; j < n; j++) {

                        double[] w = new double[n - k];

                        for (int l = 0; l < n - k; l++) {

                            w[l] = u[l] * hessenberg[i][j];

                        }

                        for (int l = 0; l < n - k; l++) {

                            hessenberg[i][j] -= 2 * w[l];

                        }

                    }

                }

                for (int i = 0; i < n; i++) {

                    double[] z = new double[n - k];

                    for (int j = 0; j < n - k; j++) {

                        z[j] = u[j] * hessenberg[i][k - 1];

                    }

                    for (int j = 0; j < n - k; j++) {

                        hessenberg[i][k - 1] -= 2 * z[j];

                    }

                }

            }

        }

        return hessenberg;

    }

    public static double getNorm(double[] vector) {

        double norm = 0;

        for (double element : vector) {

            norm += element * element;

        }

        return Math.sqrt(norm);

    }

    public static void printMatrix(double[][] matrix) {

        for (double[] row : matrix) {

            for (double element : row) {

                System.out.print(element + " ");

            }

            System.out.println();

        }

    }

}

This code demonstrates how to compute the Hessenberg decomposition of a matrix. It uses the Householder transformation to eliminate

the subdiagonal elements in the matrix and transform it into Hessenberg form. The `computeHessenberg` method takes a matrix as input and returns its Hessenberg form as a new matrix. The `getNorm` method calculates the norm of a vector, and the `printMatrix` method prints the elements of a matrix. The example code applies the Hessenberg decomposition to a sample matrix and displays both the original matrix and its Hessenberg form.