@jacksontian/equation-resolver 1.0.0 → 1.1.0

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

@@ -1,7 +1,7 @@
 import { Fraction } from './fraction.js';
 
 // 单方程求值器
-class EquationEvaluator {
+export class EquationEvaluator {
   constructor(ast) {
     this.ast = ast;
   }
@@ -71,10 +71,178 @@ 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();
     
+    // 检查整个表达式是否包含除法，如果有则统一处理
+    let formToUse = standardForm;
+    let hasAnyDivision = false;
+    
+    // 检查是否包含除以任何变量的项
+    for (const varName of allVariables) {
+      if (this.containsDivisionByVariable(standardForm, varName)) {
+        formToUse = this.multiplyByVariable(standardForm, varName);
+        hasAnyDivision = true;
+        break;
+      }
+    }
+    
+    // 如果没有直接除以变量的项，检查是否包含除以包含变量的表达式
+    if (!hasAnyDivision) {
+      for (const varName of allVariables) {
+        const divisionResult = this.containsDivisionByVariableExpression(standardForm, varName);
+        if (divisionResult.found) {
+          formToUse = this.multiplyByExpression(standardForm, divisionResult.divisor);
+          hasAnyDivision = true;
+          break;
+        }
+      }
+    }
+    
     // 使用两个不同的变量值来计算系数
     const values1 = {};
     const values0 = {};
@@ -89,9 +257,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 +270,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);
@@ -117,19 +291,44 @@ class EquationEvaluator {
   getConstantTermFraction(allVariables) {
     const standardForm = this.toStandardForm();
     
+    // 检查整个表达式是否包含除法，如果有则统一处理
+    let formToUse = standardForm;
+    let hasAnyDivision = false;
+    
+    // 检查是否包含除以任何变量的项
+    for (const variable of allVariables) {
+      if (this.containsDivisionByVariable(standardForm, variable)) {
+        formToUse = this.multiplyByVariable(standardForm, variable);
+        hasAnyDivision = true;
+        break;
+      }
+    }
+    
+    // 如果没有直接除以变量的项，检查是否包含除以包含变量的表达式
+    if (!hasAnyDivision) {
+      for (const variable of allVariables) {
+        const divisionResult = this.containsDivisionByVariableExpression(standardForm, variable);
+        if (divisionResult.found) {
+          formToUse = this.multiplyByExpression(standardForm, divisionResult.divisor);
+          hasAnyDivision = true;
+          break;
+        }
+      }
+    }
+    
     const values = {};
     allVariables.forEach(v => {
       values[v] = 0;
     });
     
-    const val0 = this.evaluateWithValues(standardForm, values);
+    const val0 = this.evaluateWithValues(formToUse, values);
     
     if (val0 === Infinity || !val0.isFinite()) {
       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,31 +1,43 @@
 {
   "name": "@jacksontian/equation-resolver",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "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"
   },
   "keywords": [
     "equation",
-    "solver"
+    "solver",
+    "math",
+    "algebra"
   ],
   "author": "Jackson Tian",
   "repository": {
     "type": "git",
-    "url": "https://github.com/JacksonTian/equation-resolver.git"
+    "url": "git+https://github.com/JacksonTian/equation-resolver.git"
+  },
+  "bugs": {
+    "url": "https://github.com/JacksonTian/equation-resolver/issues"
   },
-  "homepage": "https://github.com/JacksonTian/equation-resolver",
+  "homepage": "https://github.com/JacksonTian/equation-resolver#readme",
   "license": "MIT",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
   "devDependencies": {
     "@eslint/js": "^9.39.1",
     "c8": "^8.0.1",

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',
-    ],
-  },
-];
-