@jacksontian/equation-resolver 1.0.0

package/lib/lexer.js

@@ -0,0 +1,115 @@
+const TOKEN_TYPES = {
+  NUMBER: 'NUMBER',
+  VARIABLE: 'VARIABLE',
+  PLUS: 'PLUS', MINUS: 'MINUS', MULTIPLY: 'MULTIPLY', DIVIDE: 'DIVIDE',
+  LPAREN: 'LPAREN',
+  RPAREN: 'RPAREN',
+  EQUALS: 'EQUALS',
+  SEMICOLON: 'SEMICOLON',
+  EOF: 'EOF',
+};
+
+export class Token {
+  constructor(type, value) {
+    this.type = type;
+    this.value = value;
+  }
+}
+
+// 词法分析器
+export class Lexer {
+  constructor(input) {
+    this.input = input;
+    this.pos = 0;
+    this.currentChar = this.input[this.pos] || null;
+  }
+
+  advance() {
+    this.pos++;
+    this.currentChar = this.pos < this.input.length ? this.input[this.pos] : null;
+  }
+
+  skipWhitespace() {
+    while (this.currentChar === ' ') {
+      this.advance();
+    }
+  }
+
+  number() {
+    let result = '';
+    while (this.currentChar && /[0-9.]/.test(this.currentChar)) {
+      result += this.currentChar;
+      this.advance();
+    }
+    return new Token(TOKEN_TYPES.NUMBER, result);
+  }
+
+  identifier() {
+    // 只支持单字符变量
+    const result = this.currentChar;
+    this.advance();
+    return new Token(TOKEN_TYPES.VARIABLE, result);
+  }
+
+  getNextToken() {
+    while (this.currentChar !== null) {
+      if (this.currentChar === ' ') {
+        this.skipWhitespace();
+        continue;
+      }
+
+      if (/[0-9]/.test(this.currentChar)) {
+        return this.number();
+      }
+
+      if (/[a-z]/i.test(this.currentChar)) {
+        return this.identifier();
+      }
+
+      if (this.currentChar === '+') {
+        this.advance();
+        return new Token(TOKEN_TYPES.PLUS, '+');
+      }
+
+      if (this.currentChar === '-') {
+        this.advance();
+        return new Token(TOKEN_TYPES.MINUS, '-');
+      }
+
+      if (this.currentChar === '*') {
+        this.advance();
+        return new Token(TOKEN_TYPES.MULTIPLY, '*');
+      }
+
+      if (this.currentChar === '/') {
+        this.advance();
+        return new Token(TOKEN_TYPES.DIVIDE, '/');
+      }
+
+      if (this.currentChar === '(') {
+        this.advance();
+        return new Token(TOKEN_TYPES.LPAREN, '(');
+      }
+
+      if (this.currentChar === ')') {
+        this.advance();
+        return new Token(TOKEN_TYPES.RPAREN, ')');
+      }
+
+      if (this.currentChar === '=') {
+        this.advance();
+        return new Token(TOKEN_TYPES.EQUALS, '=');
+      }
+
+      if (this.currentChar === ';') {
+        this.advance();
+        return new Token(TOKEN_TYPES.SEMICOLON, ';');
+      }
+
+      throw new Error(`Unexpected character: ${this.currentChar}`);
+    }
+
+    return new Token(TOKEN_TYPES.EOF, null);
+  }
+}
+

package/lib/parser.js

@@ -0,0 +1,118 @@
+// 语法分析器
+export class Parser {
+  constructor(lexer) {
+    this.lexer = lexer;
+    this.currentToken = this.lexer.getNextToken();
+  }
+
+  eat(tokenType) {
+    if (this.currentToken.type === tokenType) {
+      this.currentToken = this.lexer.getNextToken();
+    } else {
+      throw new Error(`Expected ${tokenType}，but got ${this.currentToken.type}`);
+    }
+  }
+
+  // 方程: expression = expression
+  equation() {
+    const left = this.expression();
+    this.eat('EQUALS');
+    const right = this.expression();
+    return { type: 'EQUATION', left, right };
+  }
+
+  // 表达式: term ((PLUS | MINUS) term)*
+  expression() {
+    let node = this.term();
+
+    while (this.currentToken.type === 'PLUS' || this.currentToken.type === 'MINUS') {
+      const op = this.currentToken.type === 'PLUS' ? '+' : '-';
+      this.eat(this.currentToken.type);
+      node = { type: 'BINARY_OP', op, left: node, right: this.term() };
+    }
+
+    return node;
+  }
+
+  // 项: factor ((MULTIPLY | DIVIDE) factor)*
+  term() {
+    let node = this.factor();
+
+    while (this.currentToken.type === 'MULTIPLY' || this.currentToken.type === 'DIVIDE') {
+      const op = this.currentToken.type === 'MULTIPLY' ? '*' : '/';
+      this.eat(this.currentToken.type);
+      node = { type: 'BINARY_OP', op, left: node, right: this.factor() };
+    }
+
+    return node;
+  }
+
+  // 因子: NUMBER | VARIABLE | (expression) | unaryOp factor
+  factor() {
+    const token = this.currentToken;
+    let node;
+
+    if (token.type === 'NUMBER') {
+      this.eat('NUMBER');
+      node = { type: 'NUMBER', value: token.value };
+      
+      // 处理隐式乘法: 2x, 2(, 2)
+      // 但要注意：如果是在除法后面（通过上下文判断），数字+变量应该作为一个整体
+      if (this.currentToken.type === 'VARIABLE' || this.currentToken.type === 'LPAREN') {
+        return { type: 'BINARY_OP', op: '*', left: node, right: this.factor() };
+      }
+      return node;
+    }
+
+    if (token.type === 'VARIABLE') {
+      this.eat('VARIABLE');
+      node = { type: 'VARIABLE', name: token.value };
+      
+      // 处理隐式乘法: xy, x(, x2
+      if (this.currentToken.type === 'VARIABLE' || 
+          this.currentToken.type === 'LPAREN' || 
+          this.currentToken.type === 'NUMBER') {
+        return { type: 'BINARY_OP', op: '*', left: node, right: this.factor() };
+      }
+      return node;
+    }
+
+    if (token.type === 'LPAREN') {
+      this.eat('LPAREN');
+      node = this.expression();
+      this.eat('RPAREN');
+      
+      // 处理隐式乘法: (expr)x, (expr)2, (expr)(
+      if (this.currentToken.type === 'VARIABLE' || 
+          this.currentToken.type === 'NUMBER' || 
+          this.currentToken.type === 'LPAREN') {
+        return { type: 'BINARY_OP', op: '*', left: node, right: this.factor() };
+      }
+      return node;
+    }
+
+    throw new Error(`Unexpected token: ${token.type}, expected NUMBER, VARIABLE, LPAREN`);
+  }
+
+  // 方程组: equation (SEMICOLON equation)*
+  equationList() {
+    const equations = [];
+    equations.push(this.equation());
+
+    while (this.currentToken.type === 'SEMICOLON') {
+      this.eat('SEMICOLON');
+      // 如果分号后是 EOF，说明分号是末尾的可选分号，忽略它
+      if (this.currentToken.type === 'EOF') {
+        break;
+      }
+      equations.push(this.equation());
+    }
+
+    return { type: 'EQUATION_SYSTEM', equations };
+  }
+
+  parse() {
+    return this.equationList();
+  }
+}
+

package/lib/semantic-checker.js

@@ -0,0 +1,56 @@
+// 语义检查器
+export class SemanticChecker {
+  constructor(ast) {
+    this.ast = ast;
+    this.variables = new Set();
+  }
+
+  visitEquationSystem(ast) {
+    if (ast.type !== 'EQUATION_SYSTEM') {
+      throw new Error('Invalid AST type');
+    }
+
+    ast.equations.forEach(equation => {
+      this.visitEquation(equation);
+    });
+  }
+
+  visitEquation(ast) {
+    if (ast.type !== 'EQUATION') {
+      throw new Error('Invalid AST type');
+    }
+
+    const leftCtx = {
+      variables: new Set(),
+    };
+    this.visitExpression(ast.left, leftCtx);
+    const rightCtx = {
+      variables: new Set(),
+    };
+    this.visitExpression(ast.right, rightCtx);
+    // 检查是否没有变量
+    if (leftCtx.variables.size === 0 && rightCtx.variables.size === 0) {
+      throw new Error('Equation does not contain any variables');
+    }
+  }
+
+  visitExpression(ast, ctx) {
+    if (ast.type === 'VARIABLE') {
+      ctx.variables.add(ast.name);
+      this.variables.add(ast.name);
+    } else if (ast.type === 'BINARY_OP') {
+      this.visitExpression(ast.left, ctx);
+      this.visitExpression(ast.right, ctx);
+    } else if (ast.type === 'NUMBER') {
+      // noop
+    } else {
+      console.log(ast);
+      throw new Error('Invalid AST type');
+    }
+  }
+
+  // 执行所有语义检查
+  check() {
+    this.visitEquationSystem(this.ast);
+  }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@jacksontian/equation-resolver",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "解方程程序",
+  "main": "lib/index.js",
+  "bin": {
+    "solve": "./bin/cli.js"
+  },
+  "scripts": {
+    "dev": "node --test",
+    "test": "node --test test/*.test.js",
+    "test:cov": "c8 --reporter=html --reporter=text npm run test",
+    "dev:cov": "c8 --reporter=html --reporter=text npm run dev",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  },
+  "keywords": [
+    "equation",
+    "solver"
+  ],
+  "author": "Jackson Tian",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JacksonTian/equation-resolver.git"
+  },
+  "homepage": "https://github.com/JacksonTian/equation-resolver",
+  "license": "MIT",
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "c8": "^8.0.1",
+    "eslint": "^9.39.1"
+  }
+}

package/test/evaluator.test.js

@@ -0,0 +1,230 @@
+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;
+        }
+      );
+    });
+  });
+});