线性代数整理(三)行列式特征值和特征向量

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]]))

@Getter
@AllArgsConstructor
public class Vector<T extends Number> implements Attribute<T>,Cloneable {
    private T[] values;

    @SuppressWarnings("unchecked")
    public static <T extends Number> Attribute<T> zero(int dim,Addr<T> addr) {
        T[] values = (T[])new Number[dim];
        Arrays.fill(values,addr.zero());
        return new Vector<>(values);
    }

    @Override
    public String toString() {
        return "Vector{" +
                "values=" + Arrays.toString(values) +
                '}';
    }

    @Override
    @SuppressWarnings("unchecked")
    public Vector clone() throws CloneNotSupportedException {
        T[] values = Arrays.copyOf(this.values,this.len());
        return new Vector(values);
    }

    @Override
    @SuppressWarnings("unchecked")
    public boolean equals(Attribute<T> another,Addr<T> addr) {
        if (this.len() != another.len()) {
            return false;
        }
        for (int i = 0; i < len(); i++) {
            if (!addr.equals(this.get(i),another.get(i))) {
                return false;
            }
        }
        return true;
    }

    @Override
    public int len() {
        return values.length;
    }

    @Override
    public T get(int index) {
        if (index >= len() || index < 0) {
            throw new IllegalArgumentException("索引超出范围");
        }
        return values[index];
    }

    @Override
    public void set(int index, T value) {
        if (index >= len() || index < 0) {
            throw new IllegalArgumentException("索引超出范围");
        }
        this.values[index] = value;
    }

    @Override
    @SuppressWarnings("unchecked")
    public Attribute<T> add(Attribute<T> another,Addr<T> addr) {
        if (this.len() != another.len()) {
            throw new IllegalArgumentException("加法错误，两个向量的维度必须相等");
        }
        T[] newValues = (T[])new Number[this.len()];
        for (int i = 0; i < this.len(); i++) {
            newValues[i] = addr.add(this.get(i),another.get(i));
        }
        this.values = newValues;
        return this;
    }

    @Override
    @SuppressWarnings("unchecked")
    public Attribute<T> sub(Attribute<T> another, Addr<T> addr) {
        if (this.len() != another.len()) {
            throw new IllegalArgumentException("减法错误，两个向量的维度必须相等");
        }
        T[] newValues = (T[])new Number[this.len()];
        for (int i = 0; i < this.len(); i++) {
            newValues[i] = addr.sub(this.get(i),another.get(i));
        }
        this.values = newValues;
        return this;
    }

    @Override
    @SuppressWarnings("unchecked")
    public Attribute<T> div(T k, Addr<T> addr) {
        T[] newValues = (T[])new Number[this.len()];
        for (int i = 0; i < this.len(); i++) {
            newValues[i] = addr.div(this.get(i),k);
        }
        this.values = newValues;
        return this;
    }

    @Override
    @SuppressWarnings("unchecked")
    public Attribute<T> mul(T k, Addr<T> addr) {
        T[] newValues = (T[])new Number[this.len()];
        for (int i = 0; i < this.len(); i++) {
            newValues[i] = addr.mul(k,this.get(i));
        }
        this.values = newValues;
        return this;
    }

    @Override
    public double norm(Addr<T> addr) {
        T total = addr.zero();
        for (int i = 0; i < this.len(); i++) {
            total = addr.add(total,addr.square(this.get(i)));
        }
        return addr.prescription(total);
    }

    @Override
    public Attribute<Double> normalize(Addr<T> addr) {
        Double[] newValues = new Double[this.len()];
        double norm = this.norm(addr);
        for (int i = 0; i < this.len(); i++) {
            newValues[i] = addr.div(this.get(i),norm);
        }
        return new Vector<>(newValues);
    }

    @Override
    public T dot(Attribute<T> another, Addr<T> addr) {
        if (this.len() != another.len()) {
            throw new IllegalArgumentException("点乘错误，两个向量的维度必须相等");
        }
        T total = addr.zero();
        for (int i = 0; i < this.len(); i++) {
            total = addr.add(total,addr.mul(this.get(i),another.get(i)));
        }
        return total;
    }

    @Override
    public double degree(Attribute<T> another, Addr<T> addr) {
        T dot = this.dot(another,addr);
        double selfNorm = this.norm(addr);
        double anotherNorm = another.norm(addr);
        double productNorm = selfNorm * anotherNorm;
        return addr.toDegree(addr.acos(addr.div(dot,productNorm)));
    }

    @Override
    public Attribute<Double> project(Attribute<T> another, Addr<T> addr) {
        T dot = this.dot(another,addr);
        double selfNorm = this.norm(addr);
        Attribute<Double> unitVector = this.normalize(addr);
        double d = addr.div(dot, selfNorm);
        return mul(d,unitVector);
    }

    private Attribute<Double> mul(double d,Attribute<Double> v) {
        Double[] values = new Double[v.len()];
        for (int i = 0; i < v.len(); i++) {
            values[i] = d * v.get(i);
        }
        return new Vector<>(values);
    }

    @Override
    @SuppressWarnings("unchecked")
    public Attribute<Double> rectangular(Attribute<T> another, Addr<T> addr) {
        Attribute<Double> att = (Attribute<Double>) another;
        Addr<Double> add = (Addr<Double>) addr;
        return att.sub(this.project(another,addr),add);
    }

    @SuppressWarnings("unchecked")
    public static void main(String[] args) throws CloneNotSupportedException {
        Attribute<Integer> vector = new Vector<>(new Integer[]{5,2});
        System.out.println(vector.toString());
        System.out.println(vector.len());
        System.out.println(vector.get(0));
        Attribute<Integer> vector1 = new Vector<>(new Integer[]{6,3});
        Addr<Integer> addr = new Addr<Integer>() {
            @Override
            public Integer zero() {
                return 0;
            }

            @Override
            public Integer one() {
                return 1;
            }

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

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

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

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

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

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

            @Override
            public Integer div(Integer hs, Integer 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(Integer lhs, Integer rhs) {
                if (lhs - rhs > 0) {
                    return 1;
                }else if (lhs - rhs < 0) {
                    return -1;
                }else {
                    return 0;
                }
            }

            @Override
            public boolean equals(Integer lhs, Integer rhs) {
                return lhs == rhs;
            }

            @Override
            public Integer neg(Integer hs) {
                return -hs;
            }
        };
        Addr<Double> addr1 = 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-6;
                if (Math.abs(lhs - rhs) < dis) {
                    return true;
                }
                return false;
            }

            @Override
            public Double neg(Double hs) {
                return -hs;
            }
        };
        //(5,2)*(6,3)
        System.out.println(vector.dot(vector1,addr));
        //(5,2),(6,3)的夹角
        System.out.println(vector.degree(vector1,addr));
        //(6,3)在(5,2)上的映射
        System.out.println(vector.project(vector1,addr));
        //(5,2)+(6,3)
        vector.add(vector1, addr);
        System.out.println(vector);
        vector.mul(3,addr);
        System.out.println(vector);
        System.out.println(Vector.zero(4,addr));
        System.out.println(vector.norm(addr));
        Attribute<Double> unitVector = vector.normalize(addr);
        System.out.println(unitVector);
        System.out.println(unitVector.norm(addr1));
        Attribute<Double> v1 = new Vector<>(new Double[]{5.0,2.0});
        Attribute<Double> v2 = new Vector<>(new Double[]{6.0,3.0});
        Attribute<Double> v3 = v1.rectangular(v2,addr1);
        //(5,2)的垂直向量
        System.out.println(v3);
        //垂直的两个向量点乘为0
        System.out.println(v1.dot(v3,addr1));
        System.out.println(addr1.equals(addr1.zero(),v1.dot(v3,addr1)));
        Attribute<Double> line = new Vector<>(new Double[]{2.0,1.0});
        Attribute<Double> v = new Vector<>(new Double[]{2.0,5.0});
        Attribute<Double> u = new Vector<>(new Double[]{-4.0,-4.0});
        Attribute<Double> vc = ((Vector) v).clone();
        Attribute<Double> uc = ((Vector) u).clone();
        //先相加，再投影
        System.out.println(line.project(v.add(u,addr1),addr1));
        //先投影，再相加
        System.out.println(line.project(vc,addr1).add(line.project(u,addr1),addr1));
        //先相乘，再投影
        System.out.println(line.project(u.mul(3.0,addr1),addr1));
        //先投影，再相乘
        System.out.println(line.project(uc,addr1).mul(3.0,addr1));
    }
}

Vector{values=[5, 2]}
2
5
36
4.763641690726143
Vector{values=[6.20689655172414, 2.4827586206896552]}
Vector{values=[11, 5]}
Vector{values=[33, 15]}
Vector{values=[0, 0, 0, 0]}
36.24913792078372
Vector{values=[0.9103664774626047, 0.413802944301184]}
0.9999999999999999
Vector{values=[-0.20689655172413968, 0.5172413793103448]}
-8.881784197001252E-15
true
Vector{values=[-1.2, -0.6]}
Vector{values=[-1.2000000000000002, -0.6000000000000001]}
Vector{values=[-14.399999999999999, -7.199999999999999]}
Vector{values=[-14.399999999999999, -7.199999999999999]}

import numpy as np
from numpy.linalg import eig

if __name__ == "__main__":

    A1 = np.array([[4, -2],
                   [1, 1]])
    eigenvalues1, eigenvectors1 = eig(A1)
    print(eigenvalues1)
    print(eigenvectors1)
    print()
    # 关于y=x翻转
    A2 = np.array([[0, 1],
                   [1, 0]])
    eigenvalues2, eigenvectors2 = eig(A2)
    print(eigenvalues2)
    print(eigenvectors2)
    print()
    # 旋转270度
    A3 = np.array([[0, -1],
                   [1, 0]])
    eigenvalues3, eigenvectors3 = eig(A3)
    print(eigenvalues3)
    print(eigenvectors3)
    print()
    # 单位矩阵
    A4 = np.array([[1, 0],
                   [0, 1]])
    eigenvalues4, eigenvectors4 = eig(A4)
    print(eigenvalues4)
    print(eigenvectors4)
    print()
    # 几何重数为1
    A5 = np.array([[3, 1],
                   [0, 3]])
    eigenvalues5, eigenvectors5 = eig(A5)
    print(eigenvalues5)
    print(eigenvectors5)
    print()

[3. 2.]    //这里的3，2都是特征值
[[0.89442719 0.70710678]
 [0.4472136  0.70710678]]
//这里看特征向量是需要看该矩阵的列向量的，对应着相同位置的特征值的特征空间的一组基
[ 1. -1.]
[[ 0.70710678 -0.70710678]
 [ 0.70710678  0.70710678]]

[0.+1.j 0.-1.j]    //这里是两个复数
[[0.70710678+0.j         0.70710678-0.j        ]
 [0.        -0.70710678j 0.        +0.70710678j]]
//这里特征向量也是两个复数
[1. 1.]    //这里具有相同的特征值，重数为2
[[1. 0.]
 [0. 1.]]
//特征向量的矩阵的列向量共同构成了二维空间的一组基
[3. 3.]    //这里也具有相同的特征值，重数为2
[[ 1.00000000e+00 -1.00000000e+00]
 [ 0.00000000e+00  6.66133815e-16]]
//这两个特征向量是线性相关的