线性代数-如何用java实现向量

• 维基百科：

  • 向量（英语：vector，物理、工程等也称作矢量）是数学、物理学和工程科学等多个自然科学中的基本概念。指一个同时具有大小和方向，且满足平行四边形法则的几何对象。一般地，同时满足具有大小和方向两个性质的几何对象即可认为是向量（特别地，电流属既有大小、又有正负方向的量，但由于其运算不满足平行四边形法则，公认为其不属于向量）。向量常常在以符号加箭头标示以区别于其它量。与向量相对的概念称标量或数量，即只有大小、绝大多数情况下没有方向（电流是特例）、不满足平行四边形法则的量。
  • 在线性代数中，向量常采用更为抽象的向量空间（也称为线性空间）来定义。向量是所谓向量空间中的基本构成元素。
    向量空间是基于物理学或几何学中的空间概念而形成的一个抽象概念，是满足一系列法则的元素的集合，而欧几里得空间便是线性空间的一种。向量空间中的元素就可以被称为向量，而欧几里得向量则是特指欧几里得空间中的向量。

• 向量的简单应用（基础级推荐系统）：

  • 在简单的推荐系统中，根据向量的点积定义：
    • a·b=|a||b|·cosθ 可得
      • 当两个向量的点积大于0，则cos的角度为锐角。
      • 当两个向量的点积等于0，则cos的调度为直角。
      • 当两个向量的点积大于0，则cos的调度为钝角。
  • 通过上面的结论可以算出，当一个商品与顾客想要购买的商品之间，他们的锐角越小，说明该商品越符合用户的需求，简尔可以推送最适合的商品或者服务给消费者。

• java实现向量起始非常简单，只要用到数组即可

/**
 * 向量对象
 * @author show
 */
public class Vector {
    /**向量的底层结构*/
    private Object[] self;
    /**一个无限接近于0的数*/
    private static final double EPSILON = 1e-8;

    /**
     * 构造函数
     * 根据向量数值数量
     * @author show
     */
    private Vector(Object... numbers) {

        self = new Object[numbers.length];
        System.arraycopy(numbers, 0, this.self, 0, numbers.length);
    }

    /**
     * 构造函数(浮点数)
     * @author show
     */
    public Vector(int... numbers) {

        self = new Object[numbers.length];
        for (int i = 0; i < numbers.length; i++) {
            this.self[i] = numbers[i];
        }
    }

    /**
     * 构造函数(整数)
     * @author show
     */
    public Vector(double... numbers) {

        self = new Object[numbers.length];
        for (int i = 0; i < numbers.length; i++) {
            this.self[i] = doubleIsInt(numbers[i]);
        }
    }

    /**
     * 构造函数
     * 根据向量长度，也是获取零向量
     * @author show
     */
    public Vector(int size) {

        this.self = new Object[size];
        for (int i = 0; i < size; i++) {
            this.self[i] = 0;
        }

    }

    /**
     * 取向量的第Index个元素
     * @author show
     */
    public Object getItem(int index) throws RuntimeException {

        if (index > self.length) {
            throw new RuntimeException("查询的下标超过向量的维度");
        }
        return self[index];
    }

    /**
     * 获取向量的维度
     * @author show
     */
    public int length() {

        return self.length;
    }

    /**
     * 判断double是否没小数，是的话，返回int，否则返回自身
     * @author show
     * @param d 入参
     * @return java.lang.Object
     */
    private static Object doubleIsInt(Double d) {

        if (d % 1 == 0) {
            return d.intValue();
        } else {
            return d;
        }
    }

    /**
     * 输出向量
     * @author show
     */
    @Override
    public String toString() {

        StringBuilder str = new StringBuilder();
        str.append("(");
        int selfLength = self.length;
        for (int i = 0; i < selfLength; i++) {
            str.append(self[i]);
            if (i < selfLength - 1) {
                str.append(",");
            }
        }
        str.append(")");
        return str.toString();
    }

    /**
     * 复制一个 Vector 防止污染源对象
     * @author show
     * @date 11:30 2019/6/20
     */
    private Vector copy(Object[] self) {

        Object[] selfCopy = new Object[self.length];
        System.arraycopy(self, 0, selfCopy, 0, selfCopy.length);
        return new Vector(selfCopy);
    }

    /**
     * 向量加法
     * @author show
     */
    public static Vector add(Vector vec1, Vector vec2) throws RuntimeException {

        int vec1Size = vec1.length();
        int vec2Size = vec2.length();
        if (vec1Size != vec2Size) {
            throw new VectorLengthError("两个向量的维度不一致，无法计算");
        }
        Vector vector = new Vector(vec1Size);
        for (int i = 0; i < vec1Size; i++) {
            double count = Double.parseDouble(vec1.self[i].toString()) + Double.parseDouble(vec2.self[i].toString());
            vector.self[i] = doubleIsInt(count);
        }
        return vector;
    }

    /**
     * 向量减法
     * @author show
     */
    public static Vector sub(Vector vec1, Vector vec2) {

        int vec1Size = vec1.length();
        int vec2Size = vec2.length();
        if (vec1Size != vec2Size) {
            throw new VectorLengthError("两个向量的维度不一致，无法计算");
        }
        Vector vector = new Vector(vec1Size);
        for (int i = 0; i < vec1Size; i++) {
            double count = Double.parseDouble(vec1.self[i].toString()) - Double.parseDouble(vec2.self[i].toString());
            vector.self[i] = doubleIsInt(count);
        }
        return vector;
    }

    /**
     * 向量乘法
     * @date 10:57 2019/6/20
     */
    public Vector mul(int k) {

        Vector copyVec = copy(self);
        Object[] copyVecSelf = copyVec.self;
        for (int i = 0; i < copyVec.length(); i++) {
            copyVecSelf[i] = doubleIsInt((Double.parseDouble(copyVecSelf[i].toString())) * k);
        }
        return copyVec;
    }

    /**
     * 向量除法
     * @date 10:57 2019/6/20
     */
    public Vector div(int k) throws ZeroDivisionError {

        if (k == 0) {
            throw new ZeroDivisionError("div error，norm is zero");
        }
        Vector copyVec = copy(self);
        Object[] copyVecSelf = copyVec.self;
        for (int i = 0; i < copyVec.length(); i++) {
            copyVecSelf[i] = doubleIsInt((Double.parseDouble(copyVecSelf[i].toString())) / k);
        }
        return copyVec;
    }

    /**
     * 求一个向量的模
     * @author show
     */
    public double norm() {

        Object[] selfArray = copy(self).self;
        double count = 0;
        for (Object i : selfArray) {
            count += Math.pow(Double.parseDouble(i.toString()), 2);
        }
        return Math.sqrt(count);
    }

    /**
     * 求一个向量的单位向量
     * @author show
     */
    public Vector normalize() throws ZeroDivisionError {

        Vector copyVec = copy(self);
        double norm = copyVec.norm();
        //判断模是否为0，因为任何数不能除0，因为double精度问题，我们要让它少于1e-8(一个非常小的数)
        if (norm < EPSILON) {
            throw new ZeroDivisionError("normalize error，norm is zero");
        }
        for (int i = 0; i < copyVec.length(); i++) {
            double v = Double.parseDouble(copyVec.self[i].toString());
            copyVec.self[i] = 1.0 / norm * v;
        }
        return copyVec;
    }

    /**
     * 向量点乘
     * @date 10:57 2019/6/20
     */
    public static Object dot(Vector vec1, Vector vec2) {

        int vec1Size = vec1.length();
        int vec2Size = vec2.length();
        if (vec1Size != vec2Size) {
            throw new VectorLengthError("两个向量的维度不一致，无法计算");
        }
        double count = 0;
        for (int i = 0; i < vec1Size; i++) {
            count += Double.parseDouble(vec1.self[i].toString()) * Double.parseDouble(vec2.self[i].toString());

        }
        return doubleIsInt(count);
    }

    /**
     * 返回向量取正的结果向量
     * @author show
     */
    public Vector pos() {

        return copy(self);
    }

    /**
     * 返回向量取负的结果向量
     * @author show
     */
    public Vector neg() {

        Vector vec = copy(self);
        for (int i = 0; i < vec.length(); i++) {
            vec.self[i] = doubleIsInt((Double.parseDouble(self[i].toString())) * -1);
        }
        return vec;
    }
}

• 验证代码

/**
 * 向量验证类
 * @author show
 */
public class MainVector {
    /** 向量初始化*/
    /** 二维向量：(5,2)*/
    private static Vector vec1 = new Vector(5, 2);
    /** 二维向量：(3,1)*/
    private static Vector vec2 = new Vector(3, 1);
    /** 二维零向量：(0,0)*/
    private static Vector zero2 = new Vector(2);

    /**
     * 向量的基本运算及零算量的验证
     * @author show
     */
    private static void vector1() {
        // 打印向量
        System.out.println(vec1);
        // 向量维度
        System.out.println(vec1.length());
        // 向量坐标值
        System.out.println("vec1[0]=" + vec1.getItem(0) + ",vec1[1]=" + vec1.getItem(1));
        //向量相加(5,2)+(3,1)
        System.out.println(vec1 + "+" + vec2 + "=" + Vector.add(vec1, vec2));
        //向量相减 (5,2)-(3,1)
        System.out.println(vec1 + "-" + vec2 + "=" + Vector.sub(vec1, vec2));
        //向量乘法(5,2)*3
        System.out.println(vec1 + "*" + 3 + "=" + vec1.mul(3));
        //向量乘法(5,2)/3
        System.out.println(vec1 + "/" + 3 + "=" + vec1.div(3));
        //获取向量取正
        System.out.println("+" + vec1 + "=" + vec1.pos());
        //获取向量取负
        System.out.println("-" + vec1 + "=" + vec1.neg());
    }

    /**
     * 向量的高级运算(向量的模，单位向量，零向量的模)
     * @author show
     */
    private static void vector2() {
        //二维零向量
        System.out.println(zero2);
        //任何向量加零向量都等于他本身
        System.out.println(vec1 + "+" + zero2 + "=" + Vector.add(vec1, zero2));
        //求 vec1 vec2 的模
        System.out.println("norm(" + vec1 + ") = " + vec1.norm());
        System.out.println("norm(" + vec2 + ") = " + vec2.norm());
        System.out.println("norm(" + zero2 + ") = " + zero2.norm());
        // 求 vec1 vec2 的单位向量
        System.out.println("normalize " + vec1 + " is " + vec1.normalize());
        System.out.println("normalize " + vec2 + " is " + vec2.normalize());
        // 测试 vec1 vec2 的单位向量的模是否为1
        System.out.println(vec1.normalize().norm());
        System.out.println(vec2.normalize().norm());
        //求零向量的模
        try {
            System.out.println(zero2.normalize());
        } catch (ZeroDivisionError error) {
            System.out.println("Cannot normalize zero vector {" + zero2 + "}");
        }
    }

    /**
     * 向量的高级运算(向量相乘的点乘(向量相乘的内积))
     * # 向量点乘的应用：如果可以知道向量的点乘 根据cos x = 向量的点乘/向量的模
     * # 可得 当x=90°时，向量的点乘为0，
     * # 如果向量的点乘为0，两个向量垂直
     * # 如果向量的点乘>0，两个向量夹角为锐角，反之为钝角
     * ## 判断两个向量的相似程度(推荐系统)
     * ## 如果点乘结果大于0，说明相似
     * ## 如果点乘结果等于0，说明无关
     * ## 如果点乘结果小于0，说明背离
     * @author show
     */
    private static void vector3() {
        // vec1和vec2的点乘结果
        System.out.println(Vector.dot(vec1, vec2).toString());

    }

    public static void main(String[] args) {

        vector1();
        vector2();
        vector3();
    }
}

上述代码Github地址：LinearAlgebra-study(Vector)