线性代数组织（III）确定特征值和特征向量

public interface Formula<T extends Number> {
    /**
     * 求行列式的值
     * @return
     */
    T result(Addr<T> addr);
}

@ToString
public class Determinant<T extends Number> implements Formula<T> {
    //原始方阵
    private Ranks<T> source;
    //高斯消元法后的方阵
    private Ranks<T> matrix;

    @SuppressWarnings("unchecked")
    public Determinant(Ranks<T> matrix) throws CloneNotSupportedException {
        if (matrix.rowNum() != matrix.colNum()) {
            throw new IllegalArgumentException("矩阵必须为方阵");
        }
        this.source = matrix;
        this.matrix = ((Matrix) matrix).clone();
    }

    @Override
    public T result(Addr<T> addr) {
        T res = addr.one();
        int times = forword(addr);
        for (int i = 0; i < matrix.rowNum(); i++) {
            res = addr.mul(res,matrix.get(new int[]{i,i}));
        }
        //交换次数为奇数，结果取负
        if ((times & 1) == 1) {
            return addr.neg(res);
        }
        return res;
    }

    /**
     * 高斯消元，此处不可做归一化处理
     * @param addr
     * @return
     */
    @SuppressWarnings("unchecked")
    private int forword(Addr<T> addr) {
        int i = 0;
        int k = 0;
        //交换位置的次数
        int times = 0;
        while (i < matrix.rowNum() && k < matrix.colNum()) {
            int maxRow = maxRow(i, k, matrix.rowNum(), addr);
            T[] temp = (T[]) new Number[matrix.colNum()];
            if (maxRow != i) {
                times++;
            }
            //每一行无论是否有主元，都与主元最大值所在行进行交换
            for (int j = 0; j < matrix.colNum(); j++) {
                temp[j] = matrix.get(new int[]{i, j});
                matrix.set(new int[]{i, j}, matrix.get(new int[]{maxRow, j}));
                matrix.set(new int[]{maxRow, j}, temp[j]);
            }
            if (addr.equals(matrix.get(new int[]{i,k}),addr.zero())) {
                k++;
            }else {
                //将主元所在行以下的行的所有非主元数据全部变成0
                for (int m = i + 1; m < matrix.rowNum(); m++) {
                    T u1 = matrix.get(new int[]{m, k});
                    for (int l = 0; l < matrix.colNum(); l++) {
                        matrix.set(new int[]{m, l}, addr.sub(matrix.get(new int[]{m, l}),
                                addr.mul(matrix.get(new int[]{i, l}),
                                        addr.div(u1,matrix.get(new int[]{i,k})))));
                    }
                }
                i++;
            }
        }
        return times;
    }

    /**
     * 获取主元最大值所在的行
     * @param addr
     * @return
     */
    private int maxRow(int indexI,int indexJ,int n,Addr<T> addr) {
        T best = matrix.get(new int[]{indexI,indexJ});
        int ret = indexI;
        for (int i = indexI + 1; i < n; i++) {
            if (addr.compair(matrix.get(new int[]{i,indexJ}),best) == 1) {
                best = matrix.get(new int[]{i,indexJ});
                ret = i;
            }
        }
        return ret;
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        Addr<Double> addr = new Addr<Double>() {
            @Override
            public Double zero() {
                return 0.0;
            }

            @Override
            public Double one() {
                return 1.0;
            }

            @Override
            public Double add(Double lhs, Double rhs) {
                return lhs + rhs;
            }

            @Override
            public Double sub(Double lhs, Double rhs) {
                return lhs - rhs;
            }

            @Override
            public Double mul(Double k, Double hs) {
                return k * hs;
            }

            @Override
            public Double square(Double hs) {
                return hs * hs;
            }

            @Override
            public double prescription(Double hs) {
                return Math.sqrt(hs);
            }

            @Override
            public double div(Double hs, double nhs) {
                return hs / nhs;
            }

            @Override
            public Double div(Double hs, Double nhs) {
                return hs / nhs;
            }

            @Override
            public double acos(double hs) {
                return Math.acos(hs);
            }
            @Override
            public double toDegree(double hs) {
                return Math.toDegrees(hs);
            }

            @Override
            public int compair(Double lhs, Double rhs) {
                if (lhs - rhs > 0) {
                    return 1;
                }else if (lhs - rhs < 0) {
                    return -1;
                }else {
                    return 0;
                }
            }

            @Override
            public boolean equals(Double lhs, Double rhs) {
                double dis = 1e-8;
                if (Math.abs(lhs - rhs) < dis) {
                    return true;
                }
                return false;
            }

            @Override
            public Double neg(Double hs) {
                return -hs;
            }
        };
        Ranks<Double> matrix = new Matrix<>(new Double[][]{{7.0,3.0},{2.0,5.0}});
        Formula<Double> determinant = new Determinant<>(matrix);
        System.out.println(determinant.result(addr));
        System.out.println(determinant);
    }
}

29.000000000000004
Determinant(source=Matrix{values=[[7.0, 3.0],[2.0, 5.0]]}, matrix=Matrix{values=[[7.0, 3.0],[0.0, 4.142857142857143]]})

from ._global import is_zero
from .Matrix import Matrix

class Determinant:

    def __init__(self, matrix):
        assert matrix.row_num() == matrix.col_num(), "矩阵必须为方阵"
        self._source = matrix
        self._matrix = [matrix.row_vector(i) for i in range(matrix.row_num())]

    def result(self):
        # 求行列式的值
        res = 1
        times = self._forword()
        for i in range(len(self._matrix)):
            res *= self._matrix[i][i]
        if times % 2 == 1:
            return -res
        return res

    def _forword(self):
        # 高斯消元，此处不可做归一化处理
        i, k, times = 0, 0, 0
        while i < len(self._matrix) and k < len(self._matrix[0]):
            # 看matrix[i][k]位置是否可以为主元
            max_row = self._max_row(i, k, len(self._matrix))
            if max_row != i:
                times += 1
            self._matrix[i], self._matrix[max_row] = self._matrix[max_row], self._matrix[i]
            if is_zero(self._matrix[i][k]):
                k += 1
            else:
                for j in range(i + 1, len(self._matrix)):
                    self._matrix[j] = self._matrix[j] - self._matrix[j][k] * (self._matrix[i] / self._matrix[i][k])
                i += 1
        return times

    def _max_row(self, index_i, index_j, n):
        # 主元最大值所在的行
        best, ret = self._matrix[index_i][index_j], index_i
        for i in range(index_i + 1, n):
            if self._matrix[i][index_j] > best:
                best, ret = self._matrix[i][index_j], i
        return ret

    def __repr__(self):
        return "Determinant({},{})".format(self._source, Matrix(self._matrix))

    __str__ = __repr__

from playLA.Determinant import Determinant
from playLA.Matrix import Matrix

if __name__ == "__main__":
    matrix = Matrix([[7, 3], [2, 5]])
    determinant = Determinant(matrix)
    print(determinant.result())
    print(determinant)

29.000000000000004
Determinant(Matrix([[7, 3], [2, 5]]),Matrix([[7, 3], [0.0, 4.142857142857143]]))