Вычисление нулевого пространства Основы матрицы в Java

Question

Я пытаюсь получить нулевое пространство (ядро) матрицы 3x3 в Java.Я пытался использовать Efficient Java Matrix Library (Не обязательно, чтобы это был тот, это просто пример. Я пробовал с другими, как apache one, и получил тот же результат).

Это мой код:

public static void main(String[] args) {
    double[][] data = new double[][] {
        {1,2,3},
        {1,2,3},
        {1,2,3}
    };
    SimpleMatrix m = new SimpleMatrix(data);
    SimpleSVD svd = m.svd();
    SimpleMatrix nullSpace = svd.nullSpace();
    nullSpace.print();
}

Проблема в том, что я получаю Ортонормальный и хочу его основу

 0,964  0,000 
-0,148 -0,832 
-0,222  0,555 

Вот базис, полученный с помощью Matlab: null (M, 'r')

-2    -3
 1     0
 0     1

Answer 1

Так что я нашел ответ сам.Я заметил, что скрипты MATLAB можно редактировать и открыл тот, который я хотел, а затем сделал реализацию того же скрипта в Java.Я опубликую его здесь для всех, кому это может понадобиться, но имейте в виду, что этот скрипт не так хорошо сделан, как оригинал .m.

Я использую Apache Matrix Library, как было сказано ранее, в дополнение кеще две вещи с этим.

1. Я использую этот класс, который я обнаружил, переходя в тестовые файлы apache .
2. Я использую с ней эту функцию, которую парень сделал в другом вопросе java (только функция rref, но с некоторыми изменениями, поэтому я добавлю ее здесь так же, как и мою функцию ядра)

Теперь код (большую часть я поместил в MatrixFunctions.java для экономии места в основном):

MatrixFunctions.java

//...Some other stuff
    public static double[][] rref(double[][] matrix, List<Integer> pivot) {
        double[][] rref = new double[matrix.length][];
        for (int i = 0; i < matrix.length; i++)
            rref[i] = Arrays.copyOf(matrix[i], matrix[i].length);

        int r = 0;
        for (int c = 0; c < rref[0].length && r < rref.length; c++) {
            int j = r;
            for (int i = r + 1; i < rref.length; i++)
                if (Math.abs(rref[i][c]) > Math.abs(rref[j][c]))
                    j = i;
            if (Math.abs(rref[j][c]) < 0.00001)
                continue;

            //Remember where we pivoted
            pivot.add(j);

            double[] temp = rref[j];
            rref[j] = rref[r];
            rref[r] = temp;

            double s = 1.0 / rref[r][c];
            for (j = 0; j < rref[0].length; j++)
                rref[r][j] *= s;
            for (int i = 0; i < rref.length; i++) {
                if (i != r) {
                    double t = rref[i][c];
                    for (j = 0; j < rref[0].length; j++)
                        rref[i][j] -= t * rref[r][j];
                }
            }
            r++;
        }

        return rref;
    }

    public static RealMatrix kernel(RealMatrix A) {
        int m = A.getRowDimension(), n = A.getColumnDimension();
        List<Integer> pivot = new ArrayList<>();
        RealMatrix R = MatrixUtils.createRealMatrix(MatrixFunctions.rref(A.getData(), pivot));
        int r = pivot.size();
        HashMap<Integer, Integer> nopiv = new HashMap<>();
        for (int i = 0; i < n; i++) {
            nopiv.put(i, i+1);
        }
        for (Integer e : pivot) {
            if (nopiv.containsValue(e+1))
                nopiv.remove(e, e+1);
        }
        //Remove ones contained inside pivot from nopiv
        for (int j = 0; j < r; j++) {
            int index = pivot.get(j);
            if (nopiv.containsValue(index))
                nopiv.remove(index);
        }

        double[][] Z = new double[n][n-r];    

        //Add 1(s) in the main diagonal
        if (n > r) {
            double[][] eye = new double[n-r][n-r];
            for (int i = 0; i < eye.length; i++) {
                for (int j = 0; j < eye[i].length; j++) {
                    if (j==i)
                        eye[i][j] = 1;
                    else
                        eye[i][j] = 0;
                }
            }
            //Add eye in Z
            Integer[] loc = nopiv.values().toArray(new Integer[nopiv.size()]);
            for (int i = 0; i < loc.length; i++) {
                int index = loc[i];
                for (int j = 0; j < Z[0].length; j++) {
                    Z[index-1][j] = eye[i][j];
                }
            }

            if (r > 0) {
                for (int i = 0; i < r; i++) {
                    int indexi = pivot.get(i);
                    for (int j = 0; j < loc.length; j++) {
                        int indexd = loc[j]-1;
                        Z[indexi][j] = -R.getEntry(i, indexd);
                    }
                }
            }
        }

        return MatrixUtils.createRealMatrix(Z);
    }
//...NnanananananaBATMAN!!

Наконец, главное, чтобы проверить это:

    public static void main(String[] args) {
        double[][] matrix = new double[][] {
            {1,2,3},
            {1,2,3},
            {1,2,3}
        };
        //Calculate
        RealMatrix A = MatrixFunctions.kernel(MatrixUtils.createRealMatrix(matrix));
        System.out.println(A); // displays C formatted appropriately
    }

И вывод:

Array2DRowRealMatrix{
 {-2.0,-3.0},
 {1.0,0.0},
 {0.0,1.0}
}

Что соответствует тому, что мне нужно ....

Я проверялэта функция с большим количеством элементов, чтобы убедиться, и она работала довольно хорошо.Но я не могу гарантировать, что он будет работать нормально все время и, конечно, это не самый эффективный метод.