https://stackoverflow.com/questions/769
-
08-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian题
我需要以编程方式求解 C、Objective C 或（如果需要）C++ 中的线性方程组。
以下是方程式的示例：
-44.3940 = a * 50.0 + b * 37.0 + tx
-45.3049 = a * 43.0 + b * 39.0 + tx
-44.9594 = a * 52.0 + b * 41.0 + tx
由此，我想获得最佳近似值 a, b, ， 和 tx.
其他提示
您可以用程序解决这个问题，就像您手工解决这个问题一样（使用乘法和减法，然后将结果反馈到方程中）。这是相当标准的中学数学水平。
-44.3940 = 50a + 37b + c (A)
-45.3049 = 43a + 39b + c (B)
-44.9594 = 52a + 41b + c (C)
(A-B): 0.9109 = 7a - 2b (D)
(B-C): 0.3455 = -9a - 2b (E)
(D-E): 1.2564 = 16a (F)
(F/16): a = 0.078525 (G)
Feed G into D:
0.9109 = 7a - 2b
=> 0.9109 = 0.549675 - 2b (substitute a)
=> 0.361225 = -2b (subtract 0.549675 from both sides)
=> -0.1806125 = b (divide both sides by -2) (H)
Feed H/G into A:
-44.3940 = 50a + 37b + c
=> -44.3940 = 3.92625 - 6.6826625 + c (substitute a/b)
=> -41.6375875 = c (subtract 3.92625 - 6.6826625 from both sides)
所以你最终会得到：
a = 0.0785250
b = -0.1806125
c = -41.6375875
如果将这些值重新代入 A、B 和 C，您会发现它们是正确的。
诀窍是使用一个简单的 4x3 矩阵，依次减少为 3x2 矩阵，然后是“a = n”的 2x1 矩阵，n 是实际数字。一旦你有了这个，你就可以将它输入到下一个矩阵中以获得另一个值，然后将这两个值输入到下一个矩阵中，直到你解决了所有变量。
假设您有 N 个不同的方程，您始终可以求解 N 个变量。我说不同是因为这两者不是：
7a + 2b = 50
14a + 4b = 100
他们是 相同的 等式乘以二，所以你无法从中得到解 - 将第一个乘以二，然后减去，得到真实但无用的陈述：
0 = 0 + 0
举例来说，这里有一些 C 代码，可以计算出您在问题中放置的联立方程。首先是一些必要的类型、变量、用于打印方程的支持函数以及 main:
#include <stdio.h>
typedef struct { double r, a, b, c; } tEquation;
tEquation equ1[] = {
{ -44.3940, 50, 37, 1 }, // -44.3940 = 50a + 37b + c (A)
{ -45.3049, 43, 39, 1 }, // -45.3049 = 43a + 39b + c (B)
{ -44.9594, 52, 41, 1 }, // -44.9594 = 52a + 41b + c (C)
};
tEquation equ2[2], equ3[1];
static void dumpEqu (char *desc, tEquation *e, char *post) {
printf ("%10s: %12.8lf = %12.8lfa + %12.8lfb + %12.8lfc (%s)\n",
desc, e->r, e->a, e->b, e->c, post);
}
int main (void) {
double a, b, c;
接下来，将具有三个未知数的三个方程简化为具有两个未知数的两个方程：
// First step, populate equ2 based on removing c from equ.
dumpEqu (">", &(equ1[0]), "A");
dumpEqu (">", &(equ1[1]), "B");
dumpEqu (">", &(equ1[2]), "C");
puts ("");
// A - B
equ2[0].r = equ1[0].r * equ1[1].c - equ1[1].r * equ1[0].c;
equ2[0].a = equ1[0].a * equ1[1].c - equ1[1].a * equ1[0].c;
equ2[0].b = equ1[0].b * equ1[1].c - equ1[1].b * equ1[0].c;
equ2[0].c = 0;
// B - C
equ2[1].r = equ1[1].r * equ1[2].c - equ1[2].r * equ1[1].c;
equ2[1].a = equ1[1].a * equ1[2].c - equ1[2].a * equ1[1].c;
equ2[1].b = equ1[1].b * equ1[2].c - equ1[2].b * equ1[1].c;
equ2[1].c = 0;
dumpEqu ("A-B", &(equ2[0]), "D");
dumpEqu ("B-C", &(equ2[1]), "E");
puts ("");
接下来，将两个具有两个未知数的方程简化为一个具有一个未知数的方程：
// Next step, populate equ3 based on removing b from equ2.
// D - E
equ3[0].r = equ2[0].r * equ2[1].b - equ2[1].r * equ2[0].b;
equ3[0].a = equ2[0].a * equ2[1].b - equ2[1].a * equ2[0].b;
equ3[0].b = 0;
equ3[0].c = 0;
dumpEqu ("D-E", &(equ3[0]), "F");
puts ("");
现在我们有一个类型的公式 number1 = unknown * number2, ，我们可以简单地计算出未知值 unknown <- number1 / number2. 。然后，一旦计算出该值，将其代入具有两个未知数的方程之一并计算出第二个值。然后将这两个（现在已知的）未知数代入原始方程之一，现在您就拥有了所有三个未知数的值：
// Finally, substitute values back into equations.
a = equ3[0].r / equ3[0].a;
printf ("From (F ), a = %12.8lf (G)\n", a);
b = (equ2[0].r - equ2[0].a * a) / equ2[0].b;
printf ("From (D,G ), b = %12.8lf (H)\n", b);
c = (equ1[0].r - equ1[0].a * a - equ1[0].b * b) / equ1[0].c;
printf ("From (A,G,H), c = %12.8lf (I)\n", c);
return 0;
}
该代码的输出与此答案中之前的计算相匹配：
>: -44.39400000 = 50.00000000a + 37.00000000b + 1.00000000c (A)
>: -45.30490000 = 43.00000000a + 39.00000000b + 1.00000000c (B)
>: -44.95940000 = 52.00000000a + 41.00000000b + 1.00000000c (C)
A-B: 0.91090000 = 7.00000000a + -2.00000000b + 0.00000000c (D)
B-C: -0.34550000 = -9.00000000a + -2.00000000b + 0.00000000c (E)
D-E: -2.51280000 = -32.00000000a + 0.00000000b + 0.00000000c (F)
From (F ), a = 0.07852500 (G)
From (D,G ), b = -0.18061250 (H)
From (A,G,H), c = -41.63758750 (I)
对于 3x3 线性方程组，我想推出自己的算法就可以了。
但是，您可能需要担心准确性、除以零或非常小的数字以及如何处理无限多个解决方案。我的建议是使用标准的数值线性代数包，例如 拉帕克.
看看 微软求解器基金会.
有了它，你可以编写如下代码：
SolverContext context = SolverContext.GetContext();
Model model = context.CreateModel();
Decision a = new Decision(Domain.Real, "a");
Decision b = new Decision(Domain.Real, "b");
Decision c = new Decision(Domain.Real, "c");
model.AddDecisions(a,b,c);
model.AddConstraint("eqA", -44.3940 == 50*a + 37*b + c);
model.AddConstraint("eqB", -45.3049 == 43*a + 39*b + c);
model.AddConstraint("eqC", -44.9594 == 52*a + 41*b + c);
Solution solution = context.Solve();
string results = solution.GetReport().ToString();
Console.WriteLine(results);
这是输出：
===求解器基础服务报告===
约会时间：2009年4月20日 23:29:55
型号名称：默认
要求的能力：LP
求解时间（毫秒）：1027
总时间（毫秒）：1414
解决完成状态：最佳的
选择的求解器：Microsoft.SolverFoundation.Solvers.SimplexSolver
指令：
Microsoft.SolverFoundation.Services.Directive
算法：原始
算术：杂交种
定价（准确）：默认
定价（双）：最陡边缘
基础：松弛
枢轴计数：3
===解决方案详情===
目标：
决定：
A：0.0785250000000004
乙：-0.180612500000001
C：-41.6375875
从你的问题的措辞来看，你的方程似乎比未知数更多，并且你希望最大限度地减少不一致。这通常通过线性回归来完成，线性回归可以最小化不一致的平方和。根据数据的大小，您可以在电子表格或统计包中执行此操作。R 是一个高质量的免费软件包，可以进行线性回归等许多操作。线性回归有很多内容（以及很多陷阱），但对于简单的情况来说它很简单。这是使用您的数据的 R 示例。请注意，“tx”是模型的截距。
> y <- c(-44.394, -45.3049, -44.9594)
> a <- c(50.0, 43.0, 52.0)
> b <- c(37.0, 39.0, 41.0)
> regression = lm(y ~ a + b)
> regression
Call:
lm(formula = y ~ a + b)
Coefficients:
(Intercept) a b
-41.63759 0.07852 -0.18061
在运行时效率方面，其他人的回答比我更好。如果你总是有相同数量的方程作为变量，我喜欢 克莱默法则 因为它很容易实施。只需编写一个函数来计算矩阵的行列式（或使用已经编写的函数，我相信您可以在那里找到一个），然后除以两个矩阵的行列式。
function x = LinSolve(A,y)
%
% Recursive Solution of Linear System Ax=y
% matlab equivalent: x = A\y
% x = n x 1
% A = n x n
% y = n x 1
% Uses stack space extensively. Not efficient.
% C allows recursion, so convert it into C.
% ----------------------------------------------
n=length(y);
x=zeros(n,1);
if(n>1)
x(1:n-1,1) = LinSolve( A(1:n-1,1:n-1) - (A(1:n-1,n)*A(n,1:n-1))./A(n,n) , ...
y(1:n-1,1) - A(1:n-1,n).*(y(n,1)/A(n,n)));
x(n,1) = (y(n,1) - A(n,1:n-1)*x(1:n-1,1))./A(n,n);
else
x = y(1,1) / A(1,1);
end
