是否有python模块来求解线性方程式？（用python求解线性方程组）

25-03-31 5

在本文中，我们将详细介绍是否有python模块来求解线性方程式？的各个方面，并为您提供关于用python求解线性方程组的相关解答，同时，我们也将为您带来关于c++高斯消元法求解线性方程组、Matlab

在本文中，我们将详细介绍是否有python模块来求解线性方程式？的各个方面，并为您提供关于用python求解线性方程组的相关解答，同时，我们也将为您带来关于c++高斯消元法求解线性方程组、Matlab 随笔之求解线性方程、Numpy库进阶教程（一）求解线性方程组、numpy线性代数与求解线性方程的有用知识。

本文目录一览：

是否有python模块来求解线性方程式？（用python求解线性方程组）
c++高斯消元法求解线性方程组
Matlab 随笔之求解线性方程
Numpy库进阶教程（一）求解线性方程组
numpy线性代数与求解线性方程

是否有python模块来求解线性方程式？（用python求解线性方程组）

我想用三个或更多变量求解线性方程。python中有一个好的库吗？

答案1

小编典典

参见http://sympy.org/和http://numpy.scipy.org/。

具体来说，http://docs.scipy.org/doc/numpy/reference/routines.linalg.html

和http://docs.sympy.org/0.7.0/tutorial.html#algebra，http://docs.sympy.org/dev/modules/solvers/solvers.html

编辑：从注释中添加了求解器链接。

c++高斯消元法求解线性方程组

#include<iostream>
#include<math.h>
#include<string.h>
using namespace std;
#define MaxNum 10
int unuse_result[MaxNum];
int GaussFun(int equ, int var, int result[],int array[MaxNum][MaxNum])
{
    int i, j, k, col, num1, num2;
    int max_r, ta, tb, gcdtemp, lcmtemp;
    int temp, unuse_x_num, unuse_index;
    col = 0;
    for (k = 0; k < equ && col < var; k++, col++)//循环处理增广矩阵的各行 
    {
        max_r = k;
        for (i = k + 1; i < equ; i++)
        {
            if (abs(array[i][col]) > abs(array[max_r][col]))
            {
                max_r = i;//保存绝对值最大的行 
            }
        }
        if (max_r != k)
        {
            for (j = k; j < var + 1; j++)
            {
                temp = array[k][j];
                array[k][j] = array[max_r][j];
                array[max_r][j] = temp;
            }
        }
        if (array[k][col] == 0)
        {
            k--;
            continue;
        }
        for (i = k + 1; i < equ; i++)
        {
            if (array[i][col] != 0)
            {
                num1 = abs(array[i][col]);
                num2 = abs(array[k][col]);
                while (num2 != 0)
                {
                    temp = num2;
                    num2 = num1 % num2;
                    num1 = temp;
                }
                gcdtemp = num1;//最大公约数 
                lcmtemp = (abs(array[i][col]) * abs(array[k][col])) / gcdtemp;
                ta = lcmtemp / abs(array[i][col]);
                tb = lcmtemp / abs(array[k][col]);
                if (array[i][col] * array[k][col] < 0)
                {
                    tb = -tb;
                }
                for (j = col; j < var + 1; j++)
                {
                    array[i][j] = array[i][j] * ta - array[k][j] * tb;
                }
            }
        }
    }
    for (i = k; i < equ; i++)
    {
        if (array[i][col] != 0)
        {
            return -1;
        }
    }
    if (k < var)
    {
        for (i = k - 1; i >= 0; i--)
        {
            unuse_x_num = 0;
            for (j = 0; j < var; j++)
            {
                if (array[i][j] != 0 && unuse_result[j])
                {
                    unuse_x_num++;
                    unuse_index = j;
                }
            }
            if (unuse_x_num > 1)
            {
                continue;
            }
            temp = array[i][var];
            for (j = 0; j < var; j++)
            {
                if (array[i][j] != 0 && j != unuse_index)
                {
                    temp -= array[i][j] * result[j];
                }
            }
            result[unuse_index] = temp / array[i][unuse_index];
            unuse_result[unuse_index] = 0;
        }
        return var - k;
    }
    for (i = var - 1; i >= 0; i--)
    {
        temp = array[i][var];
        for (j = i + 1; j < var; j++)
        {
            if (array[i][j] != 0)
            {
                temp -= array[i][j] * result[j];
            }
        }
        if (temp % array[i][i] != 0)
        {
            return -2;
        }
        result[i] = temp / array[i][i];
    }
    return 0;
}
int main()
{
    int i, type;
    int equnum, varnum;
    int array[MaxNum][MaxNum] = {
                            {3,5,-4,0},
                            {7,2,6,-4},
                            {4,-1,5,-5} };
    int result[MaxNum];
    equnum = 3;
    varnum = 3;
    type = GaussFun(equnum, varnum, result,array);//调用高斯函数
    if (type == -1)
    {
        cout << "该方程无解。" << endl;
    }
    else if (type == -2)
    {
        cout << "该方程又浮点数解没有整数解。" << endl;
    }
    else if (type > 0)
    {
        cout << "该方程有无穷多解！自由变量的数量为" << type << endl;
        for (i = 0; i < varnum; i++)
        {
            if (unuse_result[i])
            {
                cout << i + 1 << "是不确定的" << endl;
            }
            else
            {
                cout << i + 1 << result[i] << endl;
            }
        }
    }
    else
    {
        cout << "该方程的解为：" << endl;
        for (i = 0; i < varnum; i++)
        {
            cout << i + 1 << result[i] << endl;
        }
    }
    return 0;
}

Matlab 随笔之求解线性方程

原文: Matlab 随笔之求解线性方程

理论知识补充：

% 矩阵除分为矩阵右除和矩阵左除。

% 矩阵右除的运算符号为 “/”，设 A，B 为两个矩阵，则 “A/B” 是指方程 X*B=A 的解矩阵 X。

% 矩阵 A 和 B 的列数必须是相等。

% 矩阵左除的运算符号为 “\”，设 A，B 为两个矩阵，则 “B\A” 是指方程 B*X=A 的解矩阵 X。

% 矩阵 A 和 B 的行数必须是相等。

% 求解多项式的解，用 roots 函数

% 求解定解方程组（未知数个数等于方程总数）

%A*x=b 
A=[1,2; 
   3,4]; 
b=[5;11]; 
y=A\b
z=inv(A)*b

运行结果：

% 求解不定方程组（未知数个数大于方程总数）

A=[4,5,1; 
   1,2,3]; 
b=[3;5]; 
x=A\b

运行结果：

% 求解超定方程组（未知数个数小于方程总数）

A=[1,1; 
   -2,-4; 
   1,-2]; 
b=[2;-3;2]; 
x=A\b

求解输出如下图所示，需要说明时，求得结果是以一最小二乘近似解。

% 求解奇异方程组（多个方程之间有重复）

A=[1,2,1; 
    -2,-4,-2; 
    1,-2,5]; 
b=[6;-12;3]; 
x=A\b

此时，结果为

警告: 矩阵为奇异工作精度。 
> In test at 5

x =

   NaN 
   NaN 
   NaN

此时，可以做同解异构，如下：

A=[1,2,1; 
   -2,-4,-2; 
    1,-2,5; 
    0,0,0]; 
b=[6;-12;3;0]; 
x=A\b

运行结果为：

　总结：将上面的所有情况封装起来，做成一个函数，代码如下：

function X=solveEquation(A,b)
% 解方程A*x=b
% A为系数方程,b为列向量
[temp1,temp2]=size(b);
if(temp2~=1)%判断b是否为列向量
    disp(''b不是列向量!'');
    return
end
[c,d]=size(A);%c为方程数,d为未知量个数
if(c~=temp1)
    disp(''A,b行数不一致!'');
    return
end
if(c==d)
    if(det(A)==0)%奇异方程组
        disp(''奇异方程组问题'');
        A=[A;zeros(1,d)];
        b=[b;0];
        X=A\b;
        return
    end
    %定解方程组    
    disp(''定解方程组问题'');
    X=A\b;
    return
elseif(c>d)%超定方程
    disp(''超定方程组问题'');
    X=A\b;
    return
else
    disp(''不定方程问题'');
    X=A\b;
    return
end

Numpy库进阶教程（一）求解线性方程组

前言

Numpy是一个很强大的python科学计算库。为了机器学习的须要。想深入研究一下Numpy库的使用方法。用这个系列的博客。记录下我的学习过程。

系列：
Numpy库进阶教程（二）
正在持续更新

计算逆矩阵

numpy.linalg模块包括线性代数的函数。能够用来求矩阵的逆，求解线性方程组、求特征值及求解行列式。
mat函数能够用来构造一个矩阵，传进去一个专用字符串，矩阵的行与行之间用分号隔开，行内的元素用空格隔开。

import numpy as np

A = np.mat("0 1 2;1 0 3;4 -3 8")
print "A\n", A

如今我们使用inv函数计算逆矩阵

inverse = np.linalg.inv(A)
print "inverse of A\n", inverse

我们检查一下两矩阵相乘的结果

print "Check\n", A * inverse

须要说明的是这里的 A * inverse是两个矩阵中相应元素逐个相乘。这就要求了两矩阵的行和列相等。

求解线性方程组

创建矩阵A和数组b：


A = np.mat("1 -2 1;0 2 -8;-4 5 9")
print "A\n", A

b = np.array([0, 8, -9])
print "b\n", b

这里能够直接调用linalg中的solve函数求解

x = np.linalg.solve(A, b)
print "Solution", x

使用dot函数检查解的正确性：

print "Check\n", np.dot(A , x)

这里的dot函数是两个矩阵相乘，而非矩阵内元素逐个相乘

numpy线性代数与求解线性方程

线性代数

numpy.linalg模块包含线性代数的函数, 可以求逆矩阵,求特征值,解线性方程组及求行列式

计算逆矩阵

Key_Function

np.linalg.inv函数, 求出给定矩阵的逆矩阵

np.mat函数, 创建矩阵

Code

import numpy as np

A = np.mat("0 1 2; 1 0 3; 4 -3 8")
print(A)
''''''
[[ 0  1  2]
 [ 1  0  3]
 [ 4 -3  8]]
''''''

inverse = np.linalg.inv(A)
print(inverse)
''''''
[[-4.5  7.  -1.5]
 [-2.   4.  -1. ]
 [ 1.5 -2.   0.5]]
''''''

print(A * inverse)
''''''
[[ 1.  0.  0.]
 [ 0.  1.  0.]
 [ 0.  0.  1.]]
''''''

求解线性方程组

矩阵可以对向量进行线性变换

Key_Function

np.linalg.solve函数, 求解形如Ax=b的线性方程组, 其中A为矩阵, b为一维或二维的数组, x是未知变量

np.dot函数, 计算两个数组的点积, 即内积

Code

import numpy as np

A = np.mat("1 -2 1; 0 2 -8; -4 5 9")
print(A)
''''''
[[ 1 -2  1]
 [ 0  2 -8]
 [-4  5  9]]
''''''

b = np.array([0, 8, -9])
print(b)
''''''
[ 0  8 -9]
''''''

x = np.linalg.solve(A, b)
print(x)
# [ 29.  16.   3.]

print(np.dot(A, x))
# [[ 0.  8. -9.]]

今天关于是否有python模块来求解线性方程式？和用python求解线性方程组的讲解已经结束，谢谢您的阅读，如果想了解更多关于c++高斯消元法求解线性方程组、Matlab 随笔之求解线性方程、Numpy库进阶教程（一）求解线性方程组、numpy线性代数与求解线性方程的相关知识，请在本站搜索。

本文标签：