LittleSheep/SimpleMathCalc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

✨ Support multi variables

Browse Source
This commit is contained in:
LittleSheep
2025-09-16 22:47:48 +08:00
parent 1b80702bbe
commit 1455c0b98c
1 changed files with 126 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

197
lib/solver.dart
View File

@@ -37,8 +37,8 @@ class SolverService {
for (int m = -100; m <= 100; m++) { for (int m = -100; m <= 100; m++) {
for (int n = -100; n <= 100; n++) { for (int n = -100; n <= 100; n++) {
if (m + n == -bb && m * n == cc) { if (m + n == -bb && m * n == cc) {
String factor1 = _formatFactorTerm(1, -m); String factor1 = _formatFactorTerm(1, -m, 'x');
String factor2 = _formatFactorTerm(1, -n); String factor2 = _formatFactorTerm(1, -n, 'x');
return '($factor1)($factor2)'; return '($factor1)($factor2)';
} }
} }
@@ -65,15 +65,15 @@ class SolverService {
} }
/// 格式化因式中的项 /// 格式化因式中的项
String _formatFactorTerm(int coeff, int constTerm) { String _formatFactorTerm(int coeff, int constTerm, [String variable = 'x']) {
String result = ''; String result = '';
if (coeff != 0) { if (coeff != 0) {
if (coeff == 1) if (coeff == 1)
result += 'x'; result += variable;
else if (coeff == -1) else if (coeff == -1)
result += '-x'; result += '-$variable';
else else
result += '${coeff}x'; result += '${coeff}$variable';
} }
if (constTerm != 0) { if (constTerm != 0) {
if (result.isNotEmpty) { if (result.isNotEmpty) {
@@ -89,15 +89,36 @@ class SolverService {
return result; return result;
} }
/// 检测方程中的变量
Set<String> _detectVariables(String input) {
final variablePattern = RegExp(r'\b([a-zA-Z])\b');
final matches = variablePattern.allMatches(input);
return matches.map((match) => match.group(1)!).toSet();
}
/// 主入口方法，识别并分发任务 /// 主入口方法，识别并分发任务
CalculationResult solve(String input) { CalculationResult solve(String input) {
// 预处理输入字符串 // 预处理输入字符串
final cleanInput = input.replaceAll(' ', '').toLowerCase(); final cleanInput = input.replaceAll(' ', '').toLowerCase();
// 对包含x的方程进行预处理，展开表达式 // 检测方程中的变量
final variables = _detectVariables(cleanInput);
if (variables.isEmpty) {
// 如果没有变量，当作简单表达式处理
try {
return _solveSimpleExpression(input);
} catch (e) {
throw Exception('无法识别的格式。请检查您的方程或表达式。');
}
}
// 获取主变量（第一个检测到的变量）
final mainVariable = variables.first;
// 对包含变量的方程进行预处理，展开表达式
String processedInput = cleanInput; String processedInput = cleanInput;
if (processedInput.contains('x') && processedInput.contains('(')) { if (processedInput.contains(mainVariable) && processedInput.contains('(')) {
processedInput = _expandExpressions(processedInput); processedInput = _expandExpressions(processedInput, mainVariable);
} }
// 0. 检查是否是 (expr)^n = constant 的形式（任意次幂） // 0. 检查是否是 (expr)^n = constant 的形式（任意次幂）
@@ -113,13 +134,19 @@ class SolverService {
final rightValue = double.tryParse(rightStr); final rightValue = double.tryParse(rightStr);
if (rightValue != null) { if (rightValue != null) {
return _solveGeneralPowerEquation(exprStr, n, rightValue, cleanInput); return _solveGeneralPowerEquation(
exprStr,
n,
rightValue,
cleanInput,
mainVariable,
);
} }
} }
// 0.5. 检查是否是 a(expr)^2 = b 的形式（向后兼容） // 0.5. 检查是否是 a(expr)^2 = b 的形式（向后兼容）
final squareEqMatch = RegExp( final squareEqMatch = RegExp(
r'^(\d*\.?\d*)\(([^)]+)\)\^2\s*=\s*(.+)$', r'^(\d*\.?\d*)?\(([^)]+)\)\^2\s*=\s*(.+)$',
).firstMatch(cleanInput); ).firstMatch(cleanInput);
if (squareEqMatch != null) { if (squareEqMatch != null) {
final coeffStr = squareEqMatch.group(1)!; final coeffStr = squareEqMatch.group(1)!;
@@ -132,14 +159,16 @@ class SolverService {
// 解析右边 // 解析右边
double right = double.parse(rightStr); double right = double.parse(rightStr);
// 解析 expr 为 x ± h // 解析 expr 为 variable ± h
final exprMatch = RegExp(r'x\s*([+-]\s*\d*\.?\d*)?').firstMatch(exprStr); final exprMatch = RegExp(
r'$mainVariable\s*([+-]\s*\d*\.?\d*)?',
).firstMatch(exprStr);
if (exprMatch != null) { if (exprMatch != null) {
final hStr = exprMatch.group(1) ?? ''; final hStr = exprMatch.group(1) ?? '';
double constant = hStr.isEmpty double constant = hStr.isEmpty
? 0.0 ? 0.0
: double.parse(hStr.replaceAll(' ', '')); : double.parse(hStr.replaceAll(' ', ''));
double h = -constant; // For (x - h)^2, h is the center double h = -constant; // For (var - h)^2, h is the center
// 使用有理数计算 // 使用有理数计算
final coeffRat = _rationalFromDouble(coeff); final coeffRat = _rationalFromDouble(coeff);
@@ -173,44 +202,49 @@ class SolverService {
title: '开方', title: '开方',
explanation: '对方程两边同时开平方。', explanation: '对方程两边同时开平方。',
formula: formula:
'\$\$x ${h >= 0 ? '+' : ''}$h = \\pm \\sqrt{\\frac{${innerRat.numerator}}{${innerRat.denominator}}}\$\$', '\$\$${mainVariable} ${h >= 0 ? '+' : ''}$h = \\pm \\sqrt{\\frac{${innerRat.numerator}}{${innerRat.denominator}}}\$\$',
), ),
CalculationStep( CalculationStep(
stepNumber: 4, stepNumber: 4,
title: '解出 x', title: '解出 ${mainVariable}',
explanation: '分别取正负号，解出 x 的值。', explanation: '分别取正负号，解出 ${mainVariable} 的值。',
formula: '\$\$x_1 = $x1Str, \\quad x_2 = $x2Str\$\$', formula:
'\$\$${mainVariable}_1 = $x1Str, \\quad ${mainVariable}_2 = $x2Str\$\$',
), ),
], ],
finalAnswer: '\$\$x_1 = $x1Str, \\quad x_2 = $x2Str\$\$', finalAnswer:
'\$\$${mainVariable}_1 = $x1Str, \\quad ${mainVariable}_2 = $x2Str\$\$',
); );
} }
} }
} }
// 1. 检查是否为二元一次方程组 (格式: ...;...) // 1. 检查是否为多元一次方程组 (格式: ...;...)
if (processedInput.contains(';') && if (processedInput.contains(';') && variables.length > 1) {
processedInput.contains('x') && return _solveSystemOfLinearEquations(processedInput, variables);
processedInput.contains('y')) {
return _solveSystemOfLinearEquations(processedInput);
} }
// 2. 检查是否为一元二次方程 (包含 x^2 或 x²) // 2. 检查是否为一元二次方程 (包含 variable^2 或 variable²)
if (processedInput.contains('x^2') || processedInput.contains('x²')) { if (processedInput.contains('${mainVariable}^2') ||
return _solveQuadraticEquation(processedInput.replaceAll('x²', 'x^2')); processedInput.contains('${mainVariable}²')) {
return _solveQuadraticEquation(
processedInput.replaceAll('${mainVariable}²', '${mainVariable}^2'),
mainVariable,
);
} }
// 3. 检查是否为幂次方程 (x^n = a 的形式) // 3. 检查是否为幂次方程 (variable^n = a 的形式)
if (processedInput.contains('x^') && processedInput.contains('=')) { if (processedInput.contains('${mainVariable}^') &&
return _solvePowerEquation(processedInput); processedInput.contains('=')) {
return _solvePowerEquation(processedInput, mainVariable);
} }
// 4. 检查是否为一元一次方程 (包含 x 但不包含 y 或 x^2) // 4. 检查是否为一元一次方程 (包含主变量)
if (processedInput.contains('x') && !processedInput.contains('y')) { if (processedInput.contains(mainVariable)) {
return _solveLinearEquation(processedInput); return _solveLinearEquation(processedInput, mainVariable);
} }
// 4. 如果都不是，则作为简单表达式计算 // 如果都不是，则作为简单表达式计算
try { try {
return _solveSimpleExpression(input); // 使用原始输入以保留运算符 return _solveSimpleExpression(input); // 使用原始输入以保留运算符
} catch (e) { } catch (e) {
@@ -287,7 +321,10 @@ class SolverService {
} }
/// 2. 求解一元一次方程 /// 2. 求解一元一次方程
CalculationResult _solveLinearEquation(String input) { CalculationResult _solveLinearEquation(
String input, [
String variable = 'x',
]) {
final steps = <CalculationStep>[]; final steps = <CalculationStep>[];
// Parse the input to get LaTeX-formatted version // Parse the input to get LaTeX-formatted version
final parser = Parser(input); final parser = Parser(input);
@@ -303,7 +340,7 @@ class SolverService {
), ),
); );
final parts = _parseLinearEquation(input); final parts = _parseLinearEquation(input, variable);
final a = parts.a, b = parts.b, c = parts.c, d = parts.d; final a = parts.a, b = parts.b, c = parts.c, d = parts.d;
final newA = _rationalFromDouble(a) - _rationalFromDouble(c); final newA = _rationalFromDouble(a) - _rationalFromDouble(c);
@@ -313,9 +350,9 @@ class SolverService {
CalculationStep( CalculationStep(
stepNumber: 1, stepNumber: 1,
title: '移项', title: '移项',
explanation: '将所有含 x 的项移到等式左边，常数项移到右边。', explanation: '将所有含 ${variable} 的项移到等式左边，常数项移到右边。',
formula: formula:
'\$\$${a}x ${c >= 0 ? '-' : '+'} ${c.abs()}x = $d ${b >= 0 ? '-' : '+'} ${b.abs()}\$\$', '\$\$${a}${variable} ${c >= 0 ? '-' : '+'} ${c.abs()}${variable} = $d ${b >= 0 ? '-' : '+'} ${b.abs()}\$\$',
), ),
); );
@@ -325,7 +362,7 @@ class SolverService {
title: '合并同类项', title: '合并同类项',
explanation: '合并等式两边的项。', explanation: '合并等式两边的项。',
formula: formula:
'\$\$${_formatNumber(newA.toDouble())}x = ${_formatNumber(newD.toDouble())}\$\$', '\$\$${_formatNumber(newA.toDouble())}${variable} = ${_formatNumber(newD.toDouble())}\$\$',
), ),
); );
@@ -340,17 +377,23 @@ class SolverService {
steps.add( steps.add(
CalculationStep( CalculationStep(
stepNumber: 3, stepNumber: 3,
title: '求解 x', title: '求解 ${variable}',
explanation: '两边同时除以 x 的系数 ($newA)。', explanation: '两边同时除以 ${variable} 的系数 ($newA)。',
formula: '\$\$x = \\frac{$newD}{$newA}\$\$', formula: '\$\$${variable} = \\frac{$newD}{$newA}\$\$',
), ),
); );
return CalculationResult(steps: steps, finalAnswer: '\$\$x = $x\$\$'); return CalculationResult(
steps: steps,
finalAnswer: '\$\$${variable} = $x\$\$',
);
} }
/// 3. 求解一元二次方程 (升级版) /// 3. 求解一元二次方程 (升级版)
CalculationResult _solveQuadraticEquation(String input) { CalculationResult _solveQuadraticEquation(
String input, [
String variable = 'x',
]) {
final steps = <CalculationStep>[]; final steps = <CalculationStep>[];
final eqParts = input.split('='); final eqParts = input.split('=');
@@ -376,8 +419,8 @@ class SolverService {
// ); // );
// Also get numeric values for calculations // Also get numeric values for calculations
final leftCoeffs = _parsePolynomial(eqParts[0]); final leftCoeffs = _parsePolynomial(eqParts[0], variable);
final rightCoeffs = _parsePolynomial(eqParts[1]); final rightCoeffs = _parsePolynomial(eqParts[1], variable);
final a = (leftCoeffs[2] ?? 0) - (rightCoeffs[2] ?? 0); final a = (leftCoeffs[2] ?? 0) - (rightCoeffs[2] ?? 0);
final b = (leftCoeffs[1] ?? 0) - (rightCoeffs[1] ?? 0); final b = (leftCoeffs[1] ?? 0) - (rightCoeffs[1] ?? 0);
final c = (leftCoeffs[0] ?? 0) - (rightCoeffs[0] ?? 0); final c = (leftCoeffs[0] ?? 0) - (rightCoeffs[0] ?? 0);
@@ -579,6 +622,7 @@ class SolverService {
int n, int n,
double rightValue, double rightValue,
String originalInput, String originalInput,
String variable,
) { ) {
final steps = <CalculationStep>[]; final steps = <CalculationStep>[];
@@ -666,8 +710,8 @@ class SolverService {
} }
} }
/// 3.6. 求解幂次方程 (x^n = a 的形式) /// 3.6. 求解幂次方程 (variable^n = a 的形式)
CalculationResult _solvePowerEquation(String input) { CalculationResult _solvePowerEquation(String input, [String variable = 'x']) {
final steps = <CalculationStep>[]; final steps = <CalculationStep>[];
// 解析方程 // 解析方程
@@ -677,10 +721,12 @@ class SolverService {
final leftSide = parts[0].trim(); final leftSide = parts[0].trim();
final rightSide = parts[1].trim(); final rightSide = parts[1].trim();
// 检查左边是否为 x^n 的形式 // 检查左边是否为 variable^n 的形式
final powerMatch = RegExp(r'^x\^(\d+)$').firstMatch(leftSide); final powerMatch = RegExp(
r'^${RegExp.escape(variable)}\^(\d+)$',
).firstMatch(leftSide);
if (powerMatch == null) { if (powerMatch == null) {
throw Exception("不支持的幂次方程格式。当前支持 x^n = a 的形式。"); throw Exception("不支持的幂次方程格式。当前支持 ${variable}^n = a 的形式。");
} }
final n = int.parse(powerMatch.group(1)!); final n = int.parse(powerMatch.group(1)!);
@@ -711,8 +757,8 @@ class SolverService {
CalculationStep( CalculationStep(
stepNumber: 2, stepNumber: 2,
title: '对方程两边同时开 $n 次方', title: '对方程两边同时开 $n 次方',
explanation: '对方程两边同时开 $n 次方以解出 x。', explanation: '对方程两边同时开 $n 次方以解出 ${variable}。',
formula: '\$\$x = \\sqrt[$n]{$a}\$\$', formula: '\$\$${variable} = \\sqrt[$n]{$a}\$\$',
), ),
); );
@@ -740,18 +786,21 @@ class SolverService {
stepNumber: 3, stepNumber: 3,
title: '计算结果', title: '计算结果',
explanation: '计算开 $n 次方的结果。', explanation: '计算开 $n 次方的结果。',
formula: '\$\$x = $resultStr\$\$', formula: '\$\$${variable} = $resultStr\$\$',
), ),
); );
return CalculationResult( return CalculationResult(
steps: steps, steps: steps,
finalAnswer: '\$\$x = $resultStr\$\$', finalAnswer: '\$\$${variable} = $resultStr\$\$',
); );
} }
/// 4. 求解二元一次方程组 /// 4. 求解二元一次方程组
CalculationResult _solveSystemOfLinearEquations(String input) { CalculationResult _solveSystemOfLinearEquations(
String input, [
Set<String> variables = const {'x', 'y'},
]) {
final steps = <CalculationStep>[]; final steps = <CalculationStep>[];
final equations = input.split(';'); final equations = input.split(';');
if (equations.length != 2) throw Exception("格式错误, 请用 ';' 分隔两个方程。"); if (equations.length != 2) throw Exception("格式错误, 请用 ';' 分隔两个方程。");
@@ -998,7 +1047,7 @@ ${b1}y &= ${c1 - a1 * x.toDouble()}
/// ---- 辅助函数 ---- /// ---- 辅助函数 ----
String _expandExpressions(String input) { String _expandExpressions(String input, [String variable = 'x']) {
String result = input; String result = input;
int maxIterations = 10; // Prevent infinite loops int maxIterations = 10; // Prevent infinite loops
int iterationCount = 0; int iterationCount = 0;
@@ -1017,7 +1066,7 @@ ${b1}y &= ${c1 - a1 * x.toDouble()}
} }
final factor = powerMatch.group(2)!; final factor = powerMatch.group(2)!;
final coeffs = _parsePolynomial(factor); final coeffs = _parsePolynomial(factor, variable);
final a = coeffs[1] ?? 0; final a = coeffs[1] ?? 0;
final b = coeffs[0] ?? 0; final b = coeffs[0] ?? 0;
@@ -1040,8 +1089,8 @@ ${b1}y &= ${c1 - a1 * x.toDouble()}
final factor2 = factorMulMatch.group(2)!; final factor2 = factorMulMatch.group(2)!;
log('Expanding: ($factor1) * ($factor2)'); log('Expanding: ($factor1) * ($factor2)');
final coeffs1 = _parsePolynomial(factor1); final coeffs1 = _parsePolynomial(factor1, variable);
final coeffs2 = _parsePolynomial(factor2); final coeffs2 = _parsePolynomial(factor2, variable);
log('Coeffs1: $coeffs1, Coeffs2: $coeffs2'); log('Coeffs1: $coeffs1, Coeffs2: $coeffs2');
final a = coeffs1[1] ?? 0; final a = coeffs1[1] ?? 0;
@@ -1078,8 +1127,8 @@ ${b1}y &= ${c1 - a1 * x.toDouble()}
} }
// Parse the term (coefficient and x power) // Parse the term (coefficient and x power)
final termCoeffs = _parsePolynomial(termStr); final termCoeffs = _parsePolynomial(termStr, variable);
final factorCoeffs = _parsePolynomial(factorStr); final factorCoeffs = _parsePolynomial(factorStr, variable);
final termA = termCoeffs[1] ?? 0; // x coefficient final termA = termCoeffs[1] ?? 0; // x coefficient
final termB = termCoeffs[0] ?? 0; // constant term final termB = termCoeffs[0] ?? 0; // constant term
@@ -1122,8 +1171,8 @@ ${b1}y &= ${c1 - a1 * x.toDouble()}
final rightSide = parts[1]; final rightSide = parts[1];
// 解析左边的多项式 // 解析左边的多项式
final leftCoeffs = _parsePolynomial(leftSide); final leftCoeffs = _parsePolynomial(leftSide, variable);
final rightCoeffs = _parsePolynomial(rightSide); final rightCoeffs = _parsePolynomial(rightSide, variable);
// 计算标准形式 ax^2 + bx + c = 0 的系数 // 计算标准形式 ax^2 + bx + c = 0 的系数
// A = B 转换为 A - B = 0，所以右边的系数要取相反数 // A = B 转换为 A - B = 0，所以右边的系数要取相反数
@@ -1165,12 +1214,15 @@ ${b1}y &= ${c1 - a1 * x.toDouble()}
return result; return result;
} }
LinearEquationParts _parseLinearEquation(String input) { LinearEquationParts _parseLinearEquation(
String input, [
String variable = 'x',
]) {
final parts = input.split('='); final parts = input.split('=');
if (parts.length != 2) throw Exception("方程格式错误，应包含一个'='。"); if (parts.length != 2) throw Exception("方程格式错误，应包含一个'='。");
final leftCoeffs = _parsePolynomial(parts[0]); final leftCoeffs = _parsePolynomial(parts[0], variable);
final rightCoeffs = _parsePolynomial(parts[1]); final rightCoeffs = _parsePolynomial(parts[1], variable);
return LinearEquationParts( return LinearEquationParts(
(leftCoeffs[1] ?? 0.0), (leftCoeffs[1] ?? 0.0),
@@ -1180,7 +1232,7 @@ ${b1}y &= ${c1 - a1 * x.toDouble()}
); );
} }
Map<int, double> _parsePolynomial(String side) { Map<int, double> _parsePolynomial(String side, [String variable = 'x']) {
final coeffs = <int, double>{}; final coeffs = <int, double>{};
// 如果输入包含括号，去掉括号 // 如果输入包含括号，去掉括号
@@ -1189,9 +1241,12 @@ ${b1}y &= ${c1 - a1 * x.toDouble()}
cleanSide = cleanSide.substring(1, cleanSide.length - 1); cleanSide = cleanSide.substring(1, cleanSide.length - 1);
} }
// 扩展模式以支持 sqrt 函数 // 扩展模式以支持 sqrt 函数，使用动态变量
final escapedVar = RegExp.escape(variable);
final pattern = RegExp( final pattern = RegExp(
r'([+-]?(?:\d*\.?\d*|sqrt\(\d+\)))x(?:\^(\d+))?|([+-]?(?:\d*\.?\d*|sqrt\(\d+\)))', r'([+-]?(?:\d*\.?\d*|sqrt\(\d+\)))' +
escapedVar +
r'(?:\^(\d+))?|([+-]?(?:\d*\.?\d*|sqrt\(\d+\)))',
); );
var s = cleanSide.startsWith('+') || cleanSide.startsWith('-') var s = cleanSide.startsWith('+') || cleanSide.startsWith('-')
? cleanSide ? cleanSide
@@ -1206,7 +1261,7 @@ ${b1}y &= ${c1 - a1 * x.toDouble()}
final constValue = _parseCoefficientWithSqrt(constStr); final constValue = _parseCoefficientWithSqrt(constStr);
coeffs[0] = (coeffs[0] ?? 0) + constValue; coeffs[0] = (coeffs[0] ?? 0) + constValue;
} else { } else {
// x 的幂次项 // 变量的幂次项
int power = match.group(2) != null ? int.parse(match.group(2)!) : 1; int power = match.group(2) != null ? int.parse(match.group(2)!) : 1;
String coeffStr = match.group(1) ?? '+'; String coeffStr = match.group(1) ?? '+';
final coeff = _parseCoefficientWithSqrt(coeffStr); final coeff = _parseCoefficientWithSqrt(coeffStr);