@jacksontian/equation-resolver 1.0.0

package/.github/workflows/nodejs.yml

@@ -0,0 +1,31 @@
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [18.x, 20.x, 22.x, 24.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: npm ci
+    - run: npm run build --if-present
+    - run: npm test

package/README.md

@@ -0,0 +1,114 @@
+# 方程求解器
+
+[![npm version](https://img.shields.io/npm/v/@jacksontian/equation-resolver.svg)](https://www.npmjs.com/package/@jacksontian/equation-resolver)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)](https://nodejs.org/)
+[![GitHub repository](https://img.shields.io/badge/GitHub-repository-blue.svg)](https://github.com/JacksonTian/equation-resolver)
+
+一个使用词法分析、语法分析和语义分析实现的方程求解程序。
+
+## 功能特性
+
+- 支持线性方程求解
+- **支持多元一次方程组求解**（用分号分隔多个方程）
+- 支持隐式乘法（如 `2x`, `x(`, `)x`, `xy`, `x2`）
+- 支持括号表达式
+- 支持除法表达式（如 `8 / 2x = 2`）
+- 使用分数（Fraction）类进行精确计算，避免浮点数精度丢失
+- 使用高斯消元法求解线性方程组
+
+## 安装
+
+```bash
+npm install @jacksontian/equation-resolver -g
+```
+
+## 使用方法
+
+### 命令行工具
+
+```bash
+# REPL 模式（交互式求解）
+solve
+
+# 在 REPL 中输入方程求解
+> 2x = 4
+x = 2
+
+> x + y = 5; x - y = 1
+x = 3
+y = 2
+
+> exit  # 退出
+```
+
+### 作为模块使用
+
+```javascript
+import { Lexer, Parser, SemanticChecker, Evaluator } from '@jacksontian/equation-resolver';
+
+// 单变量方程
+function solve(input) {
+  const lexer = new Lexer(input);
+  const parser = new Parser(lexer);
+  const ast = parser.parse();
+  const checker = new SemanticChecker(ast);
+  checker.check();
+  const evaluator = new Evaluator(ast);
+  return evaluator.solve();
+}
+
+// 使用示例
+const result = solve('2x + 3 = 7');
+console.log(result); // { x: 2 }
+
+// 多元一次方程组（用分号分隔）
+const systemResult = solve('x + y = 5; x - y = 1');
+console.log(systemResult); // { x: 3, y: 2 }
+```
+
+## 测试
+
+项目使用 Node.js 内置的 `test` 模块（Node.js 18+）进行测试。
+
+### 运行测试
+
+```bash
+npm test
+```
+
+### 测试覆盖率
+
+```bash
+# 生成 HTML 和文本覆盖率报告
+npm run test:cov
+```
+
+HTML 报告会生成在 `coverage/index.html`。
+
+## 测试用例
+
+测试用例覆盖了以下场景：
+
+- 基础线性方程（加法、减法、乘法）
+- **多元一次方程组**（二元、三元等）
+- 除法表达式
+- 括号和隐式乘法
+- 复杂分数方程
+- 小数系数
+- 负数
+- 多变量方程
+- 错误情况（恒等式、矛盾方程、语法错误等）
+
+## 技术实现
+
+- **词法分析器（Lexer）**：将输入字符串转换为 token 流，支持数字、变量、运算符、括号等
+- **语法分析器（Parser）**：使用递归下降解析器构建抽象语法树（AST），支持隐式乘法
+- **语义检查器（SemanticChecker）**：检查方程是否包含变量，验证 AST 的有效性
+- **求值器（Evaluator）**：遍历 AST 求解方程，支持单方程和方程组
+- **分数类（Fraction）**：使用分数进行精确计算，避免浮点数精度丢失
+- **方程组求解**：使用高斯消元法求解多元一次方程组，支持部分主元选择
+
+## 许可证
+
+The MIT License

package/bin/cli.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+import readline from 'readline';
+import { Lexer } from '../lib/lexer.js';
+import { Parser } from '../lib/parser.js';
+import { SemanticChecker } from '../lib/semantic-checker.js';
+import { Evaluator } from '../lib/evaluator.js';
+
+function main() {
+  // 进入 REPL 模式
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: '> '
+  });
+
+  console.log('解方程 REPL 模式');
+  console.log('输入方程求解（用分号分隔多个方程可求解方程组），输入 exit 或 quit 退出\n');
+  rl.prompt();
+
+  rl.on('line', (line) => {
+    const input = line.trim();
+
+    if (input === 'exit' || input === 'quit' || input === 'q') {
+      rl.close();
+      return;
+    }
+    
+    if (input === '') {
+      rl.prompt();
+      return;
+    }
+    
+    try {
+        // 词法分析
+      const lexer = new Lexer(input);
+      
+      // 语法分析
+      const parser = new Parser(lexer);
+      const ast = parser.parse();
+
+      const checker = new SemanticChecker(ast);
+      checker.check();
+
+      const evaluator = new Evaluator(ast);
+      const result = evaluator.solve();
+      for (const [variable, value] of Object.entries(result)) {
+        console.log(`${variable} = ${value}`);
+      }
+      console.log();
+    } catch (error) {
+      console.error('错误:', error.message, '\n');
+    }
+
+    rl.prompt();
+  });
+  
+  rl.on('close', () => {
+    console.log('\n再见!');
+    process.exit(0);
+  });
+}
+
+main();

package/eslint.config.js

@@ -0,0 +1,63 @@
+import js from '@eslint/js';
+
+export default [
+  js.configs.recommended,
+  {
+    languageOptions: {
+      ecmaVersion: 2024,
+      sourceType: 'module',
+      globals: {
+        console: 'readonly',
+        process: 'readonly',
+        Buffer: 'readonly',
+        __dirname: 'readonly',
+        __filename: 'readonly',
+        global: 'readonly',
+        module: 'readonly',
+        require: 'readonly',
+        exports: 'readonly',
+      },
+    },
+    rules: {
+      'no-unused-vars': ['error', { 
+        argsIgnorePattern: '^_',
+        varsIgnorePattern: '^_',
+      }],
+      'no-console': 'off',
+      'no-undef': 'error',
+      'no-redeclare': 'error',
+      'no-constant-condition': 'error',
+      'no-empty': 'error',
+      'no-extra-semi': 'error',
+      'no-func-assign': 'error',
+      'no-inner-declarations': 'error',
+      'no-sparse-arrays': 'error',
+      'no-unreachable': 'error',
+      'use-isnan': 'error',
+      'valid-typeof': 'error',
+      'no-var': 'error',
+      'prefer-const': 'error',
+      'prefer-arrow-callback': 'error',
+      'arrow-body-style': ['error', 'as-needed'],
+      'no-duplicate-imports': 'error',
+      'no-useless-constructor': 'error',
+      'no-useless-return': 'error',
+      'prefer-template': 'error',
+      'prefer-destructuring': ['error', {
+        array: false,
+        object: true,
+      }],
+      'object-shorthand': 'error',
+      'prefer-rest-params': 'error',
+      'prefer-spread': 'error',
+    },
+  },
+  {
+    ignores: [
+      'node_modules/**',
+      'coverage/**',
+      '*.min.js',
+    ],
+  },
+];
+

package/lib/evaluator.js

@@ -0,0 +1,308 @@
+import { Fraction } from './fraction.js';
+
+// 单方程求值器
+class EquationEvaluator {
+  constructor(ast) {
+    this.ast = ast;
+  }
+
+  // 将方程转换为标准形式: left - right = 0
+  toStandardForm() {
+    const {left} = this.ast;
+    const {right} = this.ast;
+    return {
+      type: 'BINARY_OP',
+      op: '-',
+      left,
+      right
+    };
+  }
+
+  // 使用给定的变量值计算表达式（支持多变量）
+  evaluateWithValues(node, variableValues) {
+    if (node.type === 'NUMBER') {
+      return Fraction.fromString(node.value);
+    }
+    
+    if (node.type === 'VARIABLE') {
+      const value = variableValues[node.name] || 0;
+      return Fraction.fromNumber(value);
+    }
+
+    if (node.type === 'BINARY_OP') {
+      const left = this.evaluateWithValues(node.left, variableValues);
+      const right = this.evaluateWithValues(node.right, variableValues);
+
+      // 处理 Infinity 情况
+      if (left === Infinity || right === Infinity) {
+        if (node.op === '/') {
+          // Infinity / Infinity = 0 (未定式，这里简化为 0)
+          if (right === Infinity) {
+            return new Fraction(0, 1);
+          }
+          // a / Infinity = 0 (a 为有限数)
+          return Infinity;
+        }
+        if (node.op === '*') {
+          // Infinity * a = Infinity (a 为有限数)
+          return Infinity;
+        }
+        if (node.op === '+' || node.op === '-') {
+          // Infinity + a = Infinity, Infinity - a = Infinity (a 为有限数)
+          return Infinity;
+        }
+        // 其他操作符不应该出现 Infinity，但为了安全返回 Infinity
+        return Infinity;
+      }
+
+      switch (node.op) {
+        case '+': return left.add(right);
+        case '-': return left.subtract(right);
+        case '*': return left.multiply(right);
+        case '/':
+          // 除以零返回 Infinity，与 Fraction.divide 保持一致
+          // 这样在计算系数时可以使用备用方法
+          return left.divide(right);
+        default:
+          throw new Error(`Unknown operator: ${node.op}`);
+      }
+    }
+
+    throw new Error(`Unknown node type: ${node.type}`);
+  }
+
+  // 获取指定变量的系数（支持多变量方程），返回 Fraction
+  getVariableCoefficientFraction(variable, allVariables) {
+    const standardForm = this.toStandardForm();
+    
+    // 使用两个不同的变量值来计算系数
+    const values1 = {};
+    const values0 = {};
+
+    allVariables.forEach(v => {
+      if (v === variable) {
+        values1[v] = 1;
+        values0[v] = 0;
+      } else {
+        values1[v] = 0;
+        values0[v] = 0;
+      }
+    });
+
+    const val1 = this.evaluateWithValues(standardForm, values1);
+    const val0 = this.evaluateWithValues(standardForm, values0);
+    
+    if (val0 === Infinity || !val0.isFinite()) {
+      const values2 = {};
+      allVariables.forEach(v => {
+        if (v === variable) {
+          values2[v] = 2;
+        } else {
+          values2[v] = 0;
+        }
+      });
+      const val2 = this.evaluateWithValues(standardForm, values2);
+      return val2.subtract(val1);
+    }
+    
+    return val1.subtract(val0);
+  }
+
+  // 获取指定变量的系数（支持多变量方程），返回数字（向后兼容）
+  getVariableCoefficient(variable, allVariables) {
+    return this.getVariableCoefficientFraction(variable, allVariables).toNumber();
+  }
+
+  // 获取常数项（支持多变量方程），返回 Fraction
+  getConstantTermFraction(allVariables) {
+    const standardForm = this.toStandardForm();
+    
+    const values = {};
+    allVariables.forEach(v => {
+      values[v] = 0;
+    });
+    
+    const val0 = this.evaluateWithValues(standardForm, values);
+    
+    if (val0 === Infinity || !val0.isFinite()) {
+      const values1 = {};
+      allVariables.forEach(v => {
+        values1[v] = 1;
+      });
+      const val1 = this.evaluateWithValues(standardForm, values1);
+      
+      // 计算所有变量的系数和
+      let totalCoeff = new Fraction(0, 1);
+      allVariables.forEach(v => {
+        const coeff = this.getVariableCoefficientFraction(v, allVariables);
+        totalCoeff = totalCoeff.add(coeff);
+      });
+      
+      return val1.subtract(totalCoeff);
+    }
+    
+    return val0;
+  }
+
+  // 获取常数项（支持多变量方程），返回数字（向后兼容）
+  getConstantTerm(allVariables) {
+    return this.getConstantTermFraction(allVariables).toNumber();
+  }
+}
+
+// 语义分析器/求值器
+export class Evaluator {
+  constructor(ast) {
+    this.ast = ast;
+  }
+
+  // 从 AST 中提取所有不同的变量名
+  extractAllVariables(node) {
+    const variables = new Set();
+
+    if (node.type === 'VARIABLE') {
+      variables.add(node.name);
+    } else if (node.type === 'BINARY_OP') {
+      this.extractAllVariables(node.left).forEach(v => variables.add(v));
+      this.extractAllVariables(node.right).forEach(v => variables.add(v));
+    } else if (node.type === 'EQUATION') {
+      this.extractAllVariables(node.left).forEach(v => variables.add(v));
+      this.extractAllVariables(node.right).forEach(v => variables.add(v));
+    } else if (node.type === 'EQUATION_SYSTEM') {
+      node.equations.forEach(eq => {
+        this.extractAllVariables(eq).forEach(v => variables.add(v));
+      });
+    }
+    
+    return variables;
+  }
+
+  // 求解方程组（实例方法）
+  solve() {
+    const {equations} = this.ast;
+    const allVariables = Array.from(this.extractAllVariables(this.ast)).sort();
+
+    if (equations.length < allVariables.length) {
+      throw new Error(`Equation count (${equations.length}) is less than variable count (${allVariables.length})`);
+    }
+
+    // 构建增广矩阵（直接使用 Fraction 保持精度）
+    const matrix = [];
+    const evaluators = equations.map(eq => new EquationEvaluator(eq));
+    for (const evaluator of evaluators) {
+      const row = [];
+      for (const variable of allVariables) {
+        const coeff = evaluator.getVariableCoefficientFraction(variable, allVariables);
+        row.push(coeff);
+      }
+      const constant = evaluator.getConstantTermFraction(allVariables);
+      row.push(constant.negate()); // 移项到右边
+      matrix.push(row);
+    }
+
+    // 使用高斯消元法求解（矩阵已经是 Fraction 数组）
+    const isSingleEquation = equations.length === 1;
+    const solution = Evaluator.gaussianElimination(matrix, isSingleEquation);
+
+    // 构建结果对象
+    const result = {};
+    allVariables.forEach((variable, index) => {
+      result[variable] = solution[index];
+    });
+
+    return result;
+  }
+
+  // 高斯消元法求解线性方程组（使用 Fraction 进行精确计算）
+  static gaussianElimination(matrix, isSingleEquation = false) {
+    const n = matrix.length;
+    const m = matrix[0].length - 1; // 变量数量
+    
+    // 将矩阵转换为 Fraction 矩阵（如果还不是 Fraction）
+    const fracMatrix = matrix.map(row => 
+      row.map(val => val instanceof Fraction ? val : Fraction.fromNumber(val))
+    );
+    
+    // 前向消元
+    for (let i = 0; i < Math.min(n, m); i++) {
+      // 找到主元（绝对值最大的行）
+      let maxRow = i;
+      let maxAbs = Math.abs(fracMatrix[i][i].toNumber());
+      for (let k = i + 1; k < n; k++) {
+        const absVal = Math.abs(fracMatrix[k][i].toNumber());
+        if (absVal > maxAbs) {
+          maxRow = k;
+          maxAbs = absVal;
+        }
+      }
+      
+      // 交换行
+      [fracMatrix[i], fracMatrix[maxRow]] = [fracMatrix[maxRow], fracMatrix[i]];
+
+      // 如果主元为 0，跳过
+      if (fracMatrix[i][i].isZero()) {
+        continue;
+      }
+
+      // 消元
+      for (let k = i + 1; k < n; k++) {
+        if (fracMatrix[k][i].isZero()) {
+          continue;
+        }
+        const factor = fracMatrix[k][i].divide(fracMatrix[i][i]);
+        for (let j = i; j <= m; j++) {
+          fracMatrix[k][j] = fracMatrix[k][j].subtract(factor.multiply(fracMatrix[i][j]));
+        }
+      }
+    }
+
+    // 回代（使用 Fraction 进行精确计算）
+    const solution = new Array(m);
+
+    for (let i = Math.min(n, m) - 1; i >= 0; i--) {
+      if (fracMatrix[i][i].isZero()) {
+        if (!fracMatrix[i][m].isZero()) {
+          throw new Error('Equation system has no solution');
+        }
+        continue;
+      }
+
+      let sum = fracMatrix[i][m];
+      for (let j = i + 1; j < m; j++) {
+        sum = sum.subtract(fracMatrix[i][j].multiply(solution[j]));
+      }
+      solution[i] = sum.divide(fracMatrix[i][i]);
+    }
+
+    // 检查是否有未确定的变量和恒等式
+    let allZeroRows = 0;
+    
+    for (let i = 0; i < n; i++) {
+      let hasNonZero = false;
+      for (let j = 0; j < m; j++) {
+        if (!fracMatrix[i][j].isZero()) {
+          hasNonZero = true;
+          break;
+        }
+      }
+      if (!hasNonZero) {
+        if (!fracMatrix[i][m].isZero()) {
+          throw new Error('Equation system has no solution');
+        } else {
+          // 所有系数为 0 且常数项为 0，这是恒等式
+          allZeroRows++;
+        }
+      }
+    }
+
+    // 检查是否所有行的系数都为 0（恒等式情况）
+    // 对于单方程，如果系数全为 0 且常数项为 0，则有无穷解
+    if (allZeroRows > 0 && isSingleEquation && m === 1) {
+      throw new Error('Equation has infinite solutions');
+    }
+
+    // 将 Fraction 数组转换为数字数组
+    return solution.map(sol => sol.toNumber());
+  }
+}
+

package/lib/fraction.js

@@ -0,0 +1,123 @@
+// 分数（有理数）类，用于精确计算，避免浮点数精度丢失
+class Fraction {
+  constructor(numerator, denominator = 1) {
+    if (denominator === 0) {
+      throw new Error('分母不能为0');
+    }
+
+    // 处理符号
+    if (denominator < 0) {
+      numerator = -numerator;
+      denominator = -denominator;
+    }
+
+    // 约分
+    const gcd = this.gcd(Math.abs(numerator), Math.abs(denominator));
+    this.numerator = numerator / gcd;
+    this.denominator = denominator / gcd;
+  }
+
+  // 最大公约数
+  gcd(a, b) {
+    if (b === 0) return a;
+    return this.gcd(b, a % b);
+  }
+
+  // 从字符串创建分数（支持整数和小数）
+  static fromString(str) {
+    if (str.includes('.')) {
+      // 小数：如 "3.14" -> 314/100
+      const parts = str.split('.');
+      const integerPart = parts[0];
+      const decimalPart = parts[1];
+      const denominator = Math.pow(10, decimalPart.length);
+      const numerator = parseInt(integerPart) * denominator + 
+                       (integerPart.startsWith('-') ? -1 : 1) * parseInt(decimalPart);
+      return new Fraction(numerator, denominator);
+    } else {
+      // 整数
+      return new Fraction(parseInt(str, 10), 1);
+    }
+  }
+
+  // 从数字创建分数（用于变量值等）
+  static fromNumber(num) {
+    if (Number.isInteger(num)) {
+      return new Fraction(num, 1);
+    }
+    // 对于浮点数，转换为分数
+    const str = num.toString();
+    return Fraction.fromString(str);
+  }
+
+  // 加法
+  add(other) {
+    if (typeof other === 'number') {
+      other = Fraction.fromNumber(other);
+    }
+    const num = this.numerator * other.denominator + other.numerator * this.denominator;
+    const den = this.denominator * other.denominator;
+    return new Fraction(num, den);
+  }
+
+  // 减法
+  subtract(other) {
+    if (typeof other === 'number') {
+      other = Fraction.fromNumber(other);
+    }
+    const num = this.numerator * other.denominator - other.numerator * this.denominator;
+    const den = this.denominator * other.denominator;
+    return new Fraction(num, den);
+  }
+
+  // 乘法
+  multiply(other) {
+    if (typeof other === 'number') {
+      other = Fraction.fromNumber(other);
+    }
+    const num = this.numerator * other.numerator;
+    const den = this.denominator * other.denominator;
+    return new Fraction(num, den);
+  }
+
+  // 除法
+  divide(other) {
+    if (typeof other === 'number') {
+      other = Fraction.fromNumber(other);
+    }
+    if (other.numerator === 0) {
+      return Infinity;
+    }
+    const num = this.numerator * other.denominator;
+    const den = this.denominator * other.numerator;
+    return new Fraction(num, den);
+  }
+
+  // 取负
+  negate() {
+    return new Fraction(-this.numerator, this.denominator);
+  }
+
+  // 转换为数字（用于最终结果）
+  toNumber() {
+    return this.numerator / this.denominator;
+  }
+
+  // 检查是否为有限值
+  isFinite() {
+    return isFinite(this.numerator) && isFinite(this.denominator);
+  }
+
+  // 检查是否为零
+  isZero() {
+    return this.numerator === 0;
+  }
+
+  // 获取数值（用于比较）
+  valueOf() {
+    return this.toNumber();
+  }
+}
+
+export { Fraction };
+

package/lib/index.js

@@ -0,0 +1,6 @@
+import { Lexer } from './lexer.js';
+import { Parser } from './parser.js';
+import { SemanticChecker } from './semantic-checker.js';
+import { Evaluator } from './evaluator.js';
+
+export { Lexer, Parser, SemanticChecker, Evaluator };