有理数域上n个方程的n元线性方程组的解集

public static void main(String[] args) {
    // 初等行变换可能会出现分数
    double[][] A = {
            {4, 8, 3},
            {2, 4, 3},
            {3, 2, 4}
    };
    double[] B = {4, 2, 3};
    double[] X = disX(A, B);

    if (X == null) {
        System.out.println("本方程组无解或无穷多解");
    } else {
        System.out.println(Arrays.toString(X));
    }
}
// A 是原方程的系数矩阵，B 是常数项，求原方程的解集
public static double[] disX(double[][] A, double[] B) {
    int n = A.length;
    if (n != B.length) {
        throw new ArrayIndexOutOfBoundsException("B的长度应与A的长度一致");
    }
    for (int i = 0; i < n; i++) {
        if (n != A[i].length) {
            throw new ArrayIndexOutOfBoundsException("A某行元素个数不为" + n);
        }
    }
    // 求 |A|
    double detA = detA(A);
    if (detA == 0) {
        return null;
    }
    // 解集
    double[] X = new double[n];
    for (int index = 0; index < n; index++) {
        double[][] Bi = new double[n][n];
        // 将 A 的第 index 列换成常数项得到矩阵 Bi
        for (int i = 0; i < n; i++) {
            Bi[i][index] = B[i];
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                // 第 index 列已经赋过值，请跳过
                if (j == index) {
                    continue;
                }
                Bi[i][j] = A[i][j];
            }
        }
        X[index] = detA(Bi) / detA;
    }
    return X;
}
// 求n级矩阵A的行列式
public static double detA(double[][] A_) {
    int i = 0;
    int j = 0;
    double l = 1;
    int n = A_.length;
    double[][] A = new double[n][n];
    // 创建新的数组 A，以免换行时影响原数组 A_
    for (int k = 0; k < n; k++) {
        for (int m = 0; m < n; m++) {
            A[k][m] = A_[k][m];
        }
    }
    while (i < n && j < n) {
        // 如果第1行第1个元素为0，在第2、3、...n行中寻找第1个不为 0 的元素
        // 并将这两行替换
        if (A[i][j] == 0) {
            for (int k = i + 1; k < n; k++) {
                if (A[k][j] != 0) {
                    for (int m = 0; m < n; m++) {
                        double temp = A[k][m];
                        A[k][m] = A[i][m];
                        A[i][m] = temp;
                    }
                    // 两行互换后，行列式变号
                    l = -l;
                    break;
                }
            }
        }
        // 说明第一行这一列元素全为0，|A| = 0
        if (A[i][j] == 0) {
            return 0;
        }
        // 将第i行的-b倍加到第k行上
        for (int k = i + 1; k < n; k++) {
            double b = A[k][j] / A[i][j];
            for (int m = j; m < n; m++) {
                A[k][m] = A[k][m] - A[i][m] * b;
            }
        }
        i++;
        j++;
    }
    // 上述操作后，A_已转为上三角形行列式A，将A主对角线上的n个元素相乘得到|A|
    for (i = 0; i < n; i++) {
        l *= A[i][i];
    }
    return l;
}

浮点数有极小的误差，使用两个整数的组合表示有理数

public static void main(String[] args) {
    /*
        5x1 + 2x2 = 6;
        2x1 + 3x2 = -7;
        求 x1 = ?，x2 = ?
     */
     // 系数矩阵
    Rational[][] A = {
            {new Rational(5), new Rational(2)},
            {new Rational(2), new Rational(3)},
    };
    // 常数项
    Rational[] B = {new Rational(6), new Rational(-7)};
    // X = (x1, x2);
    Rational[] X = disX(A, B);
    // 修改成错误的解集 (2, -2)，使之不满足第二个方程
    // X[0] = new Rational(2);
    // X[1] = new Rational(-2);

    if (X == null) {
        System.out.println("本方程组无解或无穷多解");
    } else {
        System.out.println(Arrays.toString(X));
    }

    // 将解集(x1,x2,...,x3)代入方程中验证
    for (int i = 0; i < A.length; i++) {
        Rational r = Rational.zero;
        for (int j = 0; j < A.length; j++) {
            r = r.add(A[i][j].mul(X[j]));
        }
        System.out.print(r + " = ");
        System.out.println(B[i]);
        if (!r.equals(B[i])) {
            System.out.println("第 " + (i+1) + " 行结果错误！");
        }
    }
}

public static Rational[] disX(Rational[][] A, Rational[] B) {
    int n = A.length;
    if (n != B.length) {
        throw new ArrayIndexOutOfBoundsException("B的长度应与A的长度一致");
    }
    for (int i = 0; i < n; i++) {
        if (n != A[i].length) {
            throw new ArrayIndexOutOfBoundsException("A某行元素个数不为" + n);
        }
    }

    Rational detA = detA(A);
    if (detA.equals(Rational.zero)) {
        return null;
    }

    Rational[] X = new Rational[n];
    for (int index = 0; index < n; index++) {
        Rational[][] Bi = new Rational[n][n];
        for (int i = 0; i < n; i++) {
            Bi[i][index] = B[i];
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (j == index) {
                    continue;
                }
                Bi[i][j] = A[i][j];
            }
        }
        X[index] = detA(Bi).div(detA);
    }
    return X;
}
public static Rational detA(Rational[][] A_) {
    int i = 0;
    int j = 0;
    Rational l = new Rational(1);
    int n = A_.length;
    Rational[][] A = new Rational[n][n];
    for (int k = 0; k < n; k++) {
        for (int m = 0; m < n; m++) {
            A[k][m] = A_[k][m];
        }
    }
    while (i < n && j < n) {
        if (A[i][j].equals(Rational.zero)) {
            for (int k = i + 1; k < n; k++) {
                if (!A[k][j].equals(Rational.zero)) {
                    for (int m = 0; m < n; m++) {
                        Rational temp = A[k][m];
                        A[k][m] = A[i][m];
                        A[i][m] = temp;
                    }
                    l.sign();
                    break;
                }
            }
        }
        if (A[i][j].equals(Rational.zero)) {
            return Rational.zero;
        }
        for (int k = i + 1; k < n; k++) {
            Rational b = A[k][j].div(A[i][j]);
            for (int m = j; m < n; m++) {
                A[k][m] = A[k][m].sub(A[i][m].mul(b));
            }
        }
        i++;
        j++;
    }
    for (i = 0; i < n; i++) {
        l = l.mul(A[i][i]);
    }
    return l;
}

public class Rational {
    // 表示的值为 0
    public final static Rational zero = new Rational(0);
    // 分子
    private int numerator;
    // 分母
    private int denominator;

    public Rational(int numerator) {
        this.numerator = numerator;
        this.denominator = 1;
    }

    public Rational(int numerator, int denominator) {
        if (denominator == 0) {
            throw new ArithmeticException("分母不能为0！");
        }
        // 因为 -(-2147483648) = -2147483648，故舍去
        if (numerator == Integer.MIN_VALUE || denominator == Integer.MIN_VALUE) {
            throw new ArithmeticException("整数取值超过范围！");
        }
        // 使分母为正
        if (denominator < 0) {
            numerator = -numerator;
            denominator = -denominator;
        }
        // 约分，使分子、分母互质，表达形式唯一
        int gcd = gcd(numerator, denominator);
        this.numerator = numerator / gcd;
        this.denominator = denominator / gcd;
    }
	// 分数的加减乘除（通分、约分、倒数）
    public Rational add(Rational r2) {
        int d1 = this.denominator;
        int d2 = r2.denominator;
        int d3 = lcm(d1, d2);
        int n3 = (d3 / d1) * this.numerator + (d3 / d2) * r2.numerator;
        Rational r3 = new Rational(n3, d3);
        return r3;
    }

    public Rational sub(Rational r2) {
        int d1 = this.denominator;
        int d2 = r2.denominator;
        int d3 = lcm(d1, d2);
        int n3 = (d3 / d1) * this.numerator - (d3 / d2) * r2.numerator;
        Rational r3 = new Rational(n3, d3);
        return r3;
    }

    public Rational mul(Rational r2) {
        int n1 = this.numerator;
        int d1 = this.denominator;

        int n2 = r2.numerator;
        int d2 = r2.denominator;

        int g1 = gcd(n1, d2);
        int n31 = n1 / g1;
        int d32 = d2 / g1;

        int g2 = gcd(n2, d1);
        int n32 = n2 / g2;
        int d31 = d1 / g2;

        long n3 = (long)n31 * (long)n32;
        long d3 = (long)d31 * (long)d32;
        if (n3 > Integer.MAX_VALUE || d3 > Integer.MAX_VALUE) {
            throw new ArithmeticException("两数相乘溢出！");
        }
        return new Rational((int)n3, (int)d3);
    }

    public Rational div(Rational r2) {
        if (r2.numerator == 0) {
            throw new ArithmeticException("分母不能为0！");
        }
        int n1 = this.numerator;
        int d1 = this.denominator;

        int n2 = r2.numerator;
        int d2 = r2.denominator;

        int g1 = gcd(n1, n2);
        int n31 = n1 / g1;
        int d32 = n2 / g1;

        int g2 = gcd(d1, d2);
        int n32 = d2 / g2;
        int d31 = d1 / g2;

        long n3 = (long)n31 * (long)n32;
        long d3 = (long)d31 * (long)d32;
        if (n3 > Integer.MAX_VALUE || d3 > Integer.MAX_VALUE) {
            throw new ArithmeticException("两数相乘溢出！");
        }
        return new Rational((int)n3, (int)d3);
    }
	// 分式变号
    public void sign() {
        this.numerator *= (-1);
    }

    @Override
    public String toString() {
        if (this.numerator == 0) {return "0";}
        if (this.denominator == 1) {return "" + numerator;}
        return numerator + "/" + denominator;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Rational rational = (Rational) o;
        return numerator == rational.numerator && denominator == rational.denominator;
    }
	
	// 求最小公倍数，使用最小公倍数*最大公因数=两数之积的方法求得
    private static int lcm(int a, int b) {
        if (a == 0 || a == b) {
            return Math.abs(a);
        } else if (b == 0) {
            return 0;
        }
        int n = gcd(a, b);
        long result = Math.abs((long)a * (long)b);
        result = result / n;
        if (result > Integer.MAX_VALUE) {
            throw new ArithmeticException("两数相乘溢出！");
        }
        return (int)result;
    }
	
	// 求最大公因数，使用辗转相除法求得
    private static int gcd(int a, int b) {
        if (a == 0 || a == b) {
            return Math.abs(b);
        } else if (b == 0) {
            return Math.abs(a);
        }
        int m = Math.abs(a);
        int n = Math.abs(b);

        if (m < n) {
            int temp = m;
            m = n;
            n = temp;
        }
        for (int r = m % n; r != 0; r = m % n) {
            m = n;
            n = r;
        }
        return n;
    }
}