@jacksontian/equation-resolver 1.0.0 → 1.0.1

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Jackson Tian
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -1,12 +1,18 @@
 # 方程求解器
 
+[![Node.js CI](https://github.com/JacksonTian/equation-resolver/actions/workflows/nodejs.yml/badge.svg)](https://github.com/JacksonTian/equation-resolver/actions/workflows/nodejs.yml)
+[![codecov](https://codecov.io/gh/JacksonTian/equation-resolver/branch/main/graph/badge.svg)](https://codecov.io/gh/JacksonTian/equation-resolver)
 [![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)
 
 一个使用词法分析、语法分析和语义分析实现的方程求解程序。
 
+## 介绍
+
+当你发现豆包等人工智能工具无法正确识别、无法正确计算结果，导致批改作业费时费力，你需要本方程求解器给你快速的得到确定性的答案。
+
+只要在本程序中输入方程，即可得到解答。快速批改作业，回归亲子时光。
+
 ## 功能特性
 
 - 支持线性方程求解

package/lib/evaluator.js

@@ -71,10 +71,168 @@ class EquationEvaluator {
     throw new Error(`Unknown node type: ${node.type}`);
   }
 
+  // 检查 AST 节点是否包含直接除以指定变量的项（不包括除以 2x 等情况）
+  containsDivisionByVariable(node, variable) {
+    if (node.type === 'BINARY_OP' && node.op === '/') {
+      // 只检查右操作数是否直接是变量（不包括 2x 等情况）
+      if (node.right.type === 'VARIABLE' && node.right.name === variable) {
+        return true;
+      }
+      // 递归检查左右子树
+      return this.containsDivisionByVariable(node.left, variable) ||
+             this.containsDivisionByVariable(node.right, variable);
+    } else if (node.type === 'BINARY_OP') {
+      return this.containsDivisionByVariable(node.left, variable) ||
+             this.containsDivisionByVariable(node.right, variable);
+    }
+    return false;
+  }
+
+  // 检查 AST 节点是否包含除以包含指定变量的表达式（如 3x, 2x 等）
+  containsDivisionByVariableExpression(node, variable) {
+    if (node.type === 'BINARY_OP' && node.op === '/') {
+      // 检查右操作数是否包含变量
+      if (this.containsVariable(node.right, variable)) {
+        return { found: true, divisor: node.right };
+      }
+      // 递归检查左右子树
+      const leftResult = this.containsDivisionByVariableExpression(node.left, variable);
+      if (leftResult.found) return leftResult;
+      const rightResult = this.containsDivisionByVariableExpression(node.right, variable);
+      if (rightResult.found) return rightResult;
+    } else if (node.type === 'BINARY_OP') {
+      const leftResult = this.containsDivisionByVariableExpression(node.left, variable);
+      if (leftResult.found) return leftResult;
+      const rightResult = this.containsDivisionByVariableExpression(node.right, variable);
+      if (rightResult.found) return rightResult;
+    }
+    return { found: false, divisor: null };
+  }
+
+  // 检查 AST 节点是否包含指定变量
+  containsVariable(node, variable) {
+    if (node.type === 'VARIABLE') {
+      return node.name === variable;
+    } else if (node.type === 'BINARY_OP') {
+      return this.containsVariable(node.left, variable) ||
+             this.containsVariable(node.right, variable);
+    }
+    return false;
+  }
+
+  // 将表达式乘以另一个表达式（用于消除除以包含变量的表达式）
+  multiplyByExpression(node, expression) {
+    if (node.type === 'NUMBER') {
+      return {
+        type: 'BINARY_OP',
+        op: '*',
+        left: node,
+        right: expression
+      };
+    }
+    if (node.type === 'VARIABLE') {
+      return {
+        type: 'BINARY_OP',
+        op: '*',
+        left: node,
+        right: expression
+      };
+    }
+    if (node.type === 'BINARY_OP') {
+      if (node.op === '/') {
+        // 如果除以表达式，直接返回左操作数（不需要再乘以表达式）
+        // 这里需要深度比较，简化处理：如果右操作数结构相同，直接返回左操作数
+        // 为了简化，我们假设如果右操作数包含变量，就认为匹配
+        if (this.isSameExpression(node.right, expression)) {
+          return node.left;
+        }
+        // 否则，左操作数乘以表达式，右操作数保持不变
+        return {
+          type: 'BINARY_OP',
+          op: node.op,
+          left: this.multiplyByExpression(node.left, expression),
+          right: node.right
+        };
+      }
+      // 对于其他操作符（+、-、*），递归处理左右子树
+      return {
+        type: 'BINARY_OP',
+        op: node.op,
+        left: this.multiplyByExpression(node.left, expression),
+        right: this.multiplyByExpression(node.right, expression)
+      };
+    }
+    return node;
+  }
+
+  // 简化版的表达式比较（用于判断两个表达式是否相同）
+  isSameExpression(expr1, expr2) {
+    // 简单的深度比较
+    return JSON.stringify(expr1) === JSON.stringify(expr2);
+  }
+
+  // 将表达式乘以变量（用于消除除以变量的项）
+  multiplyByVariable(node, variable) {
+    if (node.type === 'NUMBER') {
+      return {
+        type: 'BINARY_OP',
+        op: '*',
+        left: node,
+        right: { type: 'VARIABLE', name: variable }
+      };
+    }
+    if (node.type === 'VARIABLE') {
+      return {
+        type: 'BINARY_OP',
+        op: '*',
+        left: node,
+        right: { type: 'VARIABLE', name: variable }
+      };
+    }
+    if (node.type === 'BINARY_OP') {
+      if (node.op === '/') {
+        // 如果除以变量，直接返回左操作数（不需要再乘以变量）
+        if (node.right.type === 'VARIABLE' && node.right.name === variable) {
+          return node.left;
+        }
+        // 否则，左操作数乘以变量，右操作数保持不变
+        return {
+          type: 'BINARY_OP',
+          op: node.op,
+          left: this.multiplyByVariable(node.left, variable),
+          right: node.right
+        };
+      }
+      // 对于其他操作符（+、-、*），递归处理左右子树
+      return {
+        type: 'BINARY_OP',
+        op: node.op,
+        left: this.multiplyByVariable(node.left, variable),
+        right: this.multiplyByVariable(node.right, variable)
+      };
+    }
+    return node;
+  }
+
   // 获取指定变量的系数（支持多变量方程），返回 Fraction
   getVariableCoefficientFraction(variable, allVariables) {
     const standardForm = this.toStandardForm();
     
+    // 检查是否包含除以变量的项
+    const hasDivision = this.containsDivisionByVariable(standardForm, variable);
+    
+    // 检查是否包含除以包含变量的表达式（如 3x, 2x 等）
+    const divisionResult = this.containsDivisionByVariableExpression(standardForm, variable);
+    
+    let formToUse = standardForm;
+    if (hasDivision) {
+      // 如果包含除以变量的项，将整个表达式乘以变量
+      formToUse = this.multiplyByVariable(standardForm, variable);
+    } else if (divisionResult.found) {
+      // 如果包含除以包含变量的表达式，将整个表达式乘以该表达式
+      formToUse = this.multiplyByExpression(standardForm, divisionResult.divisor);
+    }
+    
     // 使用两个不同的变量值来计算系数
     const values1 = {};
     const values0 = {};
@@ -89,9 +247,10 @@ class EquationEvaluator {
       }
     });
 
-    const val1 = this.evaluateWithValues(standardForm, values1);
-    const val0 = this.evaluateWithValues(standardForm, values0);
+    const val1 = this.evaluateWithValues(formToUse, values1);
+    const val0 = this.evaluateWithValues(formToUse, values0);
     
+    // 如果 val0 是 Infinity，使用 x=1 和 x=2 来计算系数
     if (val0 === Infinity || !val0.isFinite()) {
       const values2 = {};
       allVariables.forEach(v => {
@@ -101,8 +260,13 @@ class EquationEvaluator {
           values2[v] = 0;
         }
       });
-      const val2 = this.evaluateWithValues(standardForm, values2);
-      return val2.subtract(val1);
+      const val2 = this.evaluateWithValues(formToUse, values2);
+      if (val2 !== Infinity && val2.isFinite() && val1 !== Infinity && val1.isFinite()) {
+        // 使用 val2 - val1 来计算系数
+        return val2.subtract(val1);
+      }
+      // 如果仍然有问题，返回 0（不应该到达这里）
+      return new Fraction(0, 1);
     }
     
     return val1.subtract(val0);
@@ -125,11 +289,33 @@ class EquationEvaluator {
     const val0 = this.evaluateWithValues(standardForm, values);
     
     if (val0 === Infinity || !val0.isFinite()) {
+      // 检查是否包含直接除以变量的项（检查所有变量）
+      let hasDivision = false;
+      let formToUse = standardForm;
+      for (const variable of allVariables) {
+        if (this.containsDivisionByVariable(standardForm, variable)) {
+          hasDivision = true;
+          formToUse = this.multiplyByVariable(standardForm, variable);
+          break; // 只需要转换一次
+        }
+      }
+      
+      // 如果没有直接除以变量的项，检查是否包含除以包含变量的表达式
+      if (!hasDivision) {
+        for (const variable of allVariables) {
+          const divisionResult = this.containsDivisionByVariableExpression(standardForm, variable);
+          if (divisionResult.found) {
+            formToUse = this.multiplyByExpression(standardForm, divisionResult.divisor);
+            break; // 只需要转换一次
+          }
+        }
+      }
+      
       const values1 = {};
       allVariables.forEach(v => {
         values1[v] = 1;
       });
-      const val1 = this.evaluateWithValues(standardForm, values1);
+      const val1 = this.evaluateWithValues(formToUse, values1);
       
       // 计算所有变量的系数和
       let totalCoeff = new Fraction(0, 1);

package/lib/fraction.js

@@ -19,8 +19,17 @@ class Fraction {
 
   // 最大公约数
   gcd(a, b) {
+    // 处理 Infinity 和 NaN
+    if (!isFinite(a) || !isFinite(b)) {
+      return 1;
+    }
     if (b === 0) return a;
-    return this.gcd(b, a % b);
+    const remainder = a % b;
+    // 如果 remainder 是 NaN 或 Infinity，返回 1
+    if (!isFinite(remainder)) {
+      return 1;
+    }
+    return this.gcd(b, remainder);
   }
 
   // 从字符串创建分数（支持整数和小数）

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "@jacksontian/equation-resolver",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "type": "module",
   "description": "解方程程序",
   "main": "lib/index.js",
   "bin": {
-    "solve": "./bin/cli.js"
+    "solve": "bin/cli.js"
   },
+  "files": [
+    "lib",
+    "bin"
+  ],
   "scripts": {
     "dev": "node --test",
     "test": "node --test test/*.test.js",
-    "test:cov": "c8 --reporter=html --reporter=text npm run test",
+    "test:cov": "c8 --reporter=html --reporter=lcov --reporter=text npm run test",
     "dev:cov": "c8 --reporter=html --reporter=text npm run dev",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix"
@@ -22,7 +26,7 @@
   "author": "Jackson Tian",
   "repository": {
     "type": "git",
-    "url": "https://github.com/JacksonTian/equation-resolver.git"
+    "url": "git+https://github.com/JacksonTian/equation-resolver.git"
   },
   "homepage": "https://github.com/JacksonTian/equation-resolver",
   "license": "MIT",

package/.github/workflows/nodejs.yml

@@ -1,31 +0,0 @@
-# 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/eslint.config.js

@@ -1,63 +0,0 @@
-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/test/evaluator.test.js

@@ -1,230 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import { Evaluator } from '../lib/evaluator.js';
-import { Lexer } from '../lib/lexer.js';
-import { Parser } from '../lib/parser.js';
-import { SemanticChecker } from '../lib/semantic-checker.js';
-
-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();
-}
-
-describe('solve', () => {
-  describe('basic linear equation', () => {
-    it('single variable simple multiplication should be solved', () => {
-      const result = solve('2x = 4');
-      assert.strictEqual(result.x, 2);
-    });
-
-    it('addition', () => {
-      const result = solve('3x + 2 = 8');
-      assert.strictEqual(result.x, 2);
-    });
-
-    it('subtraction', () => {
-      const result = solve('5x - 3 = 12');
-      assert.strictEqual(result.x, 3);
-    });
-
-    it('subtraction and multiplication', () => {
-      const result = solve('2x - 1 = 5');
-      assert.strictEqual(result.x, 3);
-    });
-  });
-
-  describe('division related', () => {
-    it('implicit multiplication by division', () => {
-      const result = solve('8 / 2x = 2');
-      assert.strictEqual(result.x, 2);
-    });
-
-    it('implicit multiplication by division 2', () => {
-      const result = solve('10 / 5x = 1');
-      assert.strictEqual(result.x, 2);
-    });
-
-    it('implicit multiplication by division 3', () => {
-      const result = solve('12 / 3x = 2');
-      assert.strictEqual(result.x, 2);
-    });
-  });
-
-  describe('parentheses and implicit multiplication', () => {
-    it('parentheses and implicit multiplication', () => {
-      const result = solve('2(3y-4)=4y-7(4-y)');
-      assert.strictEqual(result.y, 4);
-    });
-
-    it('explicit multiplication', () => {
-      const result = solve('2*(3y-4)=4y-7(4-y)');
-      assert.strictEqual(result.y, 4);
-    });
-
-    it('parentheses expression', () => {
-      const result = solve('3(x+2) = 15');
-      assert.strictEqual(result.x, 3);
-    });
-
-    it('parentheses subtraction', () => {
-      const result = solve('2(x-1) = 6');
-      assert.strictEqual(result.x, 4);
-    });
-  });
-
-  describe('complex equations', () => {
-    it('complex fraction equation', () => {
-      const result = solve('(x+3.5)/0.9=15*(x+3.5)-125');
-      assert.strictEqual(result.x, 5.5);
-    });
-
-    it('mixed expression', () => {
-      const result = solve('2x + 3(x-1) = 10');
-      assert.strictEqual(result.x, 2.6);
-    });
-  });
-
-  describe('decimal', () => {
-    it('decimal coefficient', () => {
-      const result = solve('0.5x = 2');
-      assert.strictEqual(result.x, 4);
-    });
-
-    it('decimal addition of constant', () => {
-      const result = solve('1.5x + 0.5 = 5');
-      assert.strictEqual(result.x, 3);
-    });
-  });
-
-  // describe('负数', () => {
-  //   it('负变量', () => {
-  //     const result = solve('-x = 5');
-  //     assert.strictEqual(result.x, -5);
-  //   });
-
-  //   it('负数结果', () => {
-  //     const result = solve('2x - 10 = -4');
-  //     assert.strictEqual(result.x, 3);
-  //   });
-  // });
-
-  describe('error cases', () => {
-    it('identity equation', () => {
-      assert.throws(
-        () => solve('2x = 2x'),
-        (error) => {
-          assert.strictEqual(error.message, 'Equation has infinite solutions');
-          return true;
-        }
-      );
-    });
-
-    it('contradictory equation', () => {
-      assert.throws(
-        () => solve('2x = 2x + 1'),
-        (error) => {
-          assert.strictEqual(error.message, 'Equation system has no solution');
-          return true;
-        }
-      );
-    });
-  });
-
-  describe('binary linear equation system', () => {
-    it('simple binary linear equation system', () => {
-      const result = solve('x + y = 5; x - y = 1');
-      assert.strictEqual(result.x, 3);
-      assert.strictEqual(result.y, 2);
-    });
-
-    it('binary linear equation system with coefficients', () => {
-      const result = solve('2x + 3y = 7; 3x - 2y = 4');
-      assert.strictEqual(result.x, 2);
-      assert.strictEqual(result.y, 1);
-    });
-
-    it('binary linear equation system with negative numbers', () => {
-      const result = solve('x - y = 3; 2x + y = 0');
-      assert.strictEqual(result.x, 1);
-      assert.strictEqual(result.y, -2);
-    });
-
-    it('binary linear equation system with decimals', () => {
-      const result = solve('0.5x + y = 2; x - 0.5y = 3');
-      assert.strictEqual(result.x, 3.2);
-      assert.strictEqual(result.y, 0.4);
-    });
-  });
-
-  describe('three linear equation system', () => {
-    it('simple three linear equation system', () => {
-      const result = solve('x + y + z = 6; x - y + z = 2; x + y - z = 0');
-      assert.strictEqual(result.x, 1);
-      assert.strictEqual(result.y, 2);
-      assert.strictEqual(result.z, 3);
-    });
-
-    it('three linear equation system with coefficients', () => {
-      const result = solve('2x + y - z = 8; x - 2y + 3z = 1; 3x + 2y + z = 9');
-      assert.strictEqual(result.x, 3.625);
-      assert.strictEqual(result.y, -0.375);
-      assert.strictEqual(result.z, -1.125);
-    });
-  });
-
-  describe('equation system with parentheses', () => {
-    it('parentheses expression', () => {
-      const result = solve('2(x + y) = 6; x - y = 1');
-      assert.strictEqual(result.x, 2);
-      assert.strictEqual(result.y, 1);
-    });
-
-    it('complex parentheses expression', () => {
-      const result = solve('3(x - 1) + 2y = 5; 2x + (y + 1) = 4');
-      assert.strictEqual(result.x, -2);
-      assert.strictEqual(result.y, 7);
-    });
-  });
-
-  describe('different variable names', () => {
-    it('different variable names', () => {
-      const result = solve('a + b = 5; a - b = 1');
-      assert.strictEqual(result.a, 3);
-      assert.strictEqual(result.b, 2);
-    });
-
-    it('mixed variable names', () => {
-      const result = solve('x + y = 5; x + z = 6; y + z = 7');
-      assert.strictEqual(result.x, 2);
-      assert.strictEqual(result.y, 3);
-      assert.strictEqual(result.z, 4);
-    });
-  });
-
-  describe('equation system error cases', () => {
-    it('equation count is less than variable count', () => {
-      assert.throws(
-        () => solve('x + y = 5'),
-        (error) => {
-          assert.strictEqual(error.message, 'Equation count (1) is less than variable count (2)');
-          return true;
-        }
-      );
-    });
-
-    it('equation system has no solution', () => {
-      assert.throws(
-        () => solve('x + y = 5; x + y = 10'),
-        (error) => {
-          assert.strictEqual(error.message, 'Equation system has no solution');
-          return true;
-        }
-      );
-    });
-  });
-});