Question

我用C ++编写了一个例程，用Gauss-Seidel方法求解方程组Ax = b。但是，我想将此代码用于稀疏的特定“A”矩阵（大多数元素为零）。这样，此解算器所采用的大部分时间都是忙于将一些元素乘以零。

例如，对于以下方程组：

| 4 -1  0  0  0 | | x1 |   | b1 |
|-1  4 -1  0  0 | | x2 |   | b2 |
| 0 -1  4 -1  0 | | x3 | = | b3 |
| 0  0 -1  4 -1 | | x4 |   | b4 |
| 0  0  0 -1  4 | | x5 |   | b5 |

使用Gauss-Seidel方法，我们将为x1提供以下迭代公式：

x1 = [b1 - （ - 1 * x2 + 0 * x3 + 0 * x4 + 0 * x5）] / 4

如您所见，求解器通过乘以零元素来浪费时间。由于我使用大矩阵（例如，10 ^ 5乘10 ^ 5），这将以负面方式影响总CPU时间。我想知道是否有一种优化求解器的方法，以便省略与零元素乘法相关的那些计算部分。

请注意，上例中“A”矩阵的形式是任意的，求解器必须能够使用任何“A”矩阵。

以下是代码：

void GaussSeidel(double **A, double *b, double *x, int arraySize)
{   
const double tol = 0.001 * arraySize;
double error = tol + 1;

for (int i = 1; i <= arraySize; ++i)
    x[i] = 0;

double *xOld;
xOld = new double [arraySize];
for (int i = 1; i <= arraySize; ++i)
    xOld[i] = 101;

while (abs(error) > tol)
{

    for (int i = 1; i <= arraySize; ++i)
    {
        sum = 0;
        for (int j = 1; j <= arraySize; ++j)
        {
            if (j == i)
                continue;
            sum = sum + A[i][j] * x[j];
        }
        x[i] = 1 / A[i][i] * (b[i] - sum);
    }

    //cout << endl << "Answers:" << endl << endl;
    error = errorCalc(xOld, x, arraySize);

    for (int i = 1; i <= arraySize; ++i)
        xOld[i] = x[i];

cout << "Solution converged!" << endl << endl;
}

Answer 1

编写稀疏线性系统求解器很难。 非常难。

我会选择一个现有的实现。任何合理的LP解算器都有一个稀疏的线性系统求解器，例如参见lp_solve，GLPK等。

如果您可以接受许可，我建议Harwell Subroutine library。虽然接口C ++和Fortran并不好玩......

Answer 2

你的意思是多么稀疏？

这是一个糟糕的稀疏实现，应该可以很好地解决线性方程组。这可能是一个天真的实现，我对工业强度稀疏矩阵中通常使用的数据结构知之甚少。

The code, and an example, is here.

以下是完成大部分工作的课程：

template <typename T>
class SparseMatrix
{
private:
    SparseMatrix();

public:
    SparseMatrix(int row, int col);

    T Get(int row, int col) const;
    void Put(int row, int col, T value);

    int GetRowCount() const;
    int GetColCount() const;

    static void GaussSeidelLinearSolve(const SparseMatrix<T>& A, const SparseMatrix<T>& B, SparseMatrix<T>& X);

private:
    int dim_row;
    int dim_col;

    vector<map<int, T> > values_by_row;
    vector<map<int, T> > values_by_col;
};

其他方法定义包含在ideone中。我不测试收敛，而是简单地循环任意次。

稀疏表示使用STL映射按行和列存储所有值的位置。对于像你提供的那样非常稀疏的矩阵（密度<.001），我能够在1/4秒内解决10000个等式的系统。

我的实现应足够通用，以支持任何支持比较的整数或用户定义类型，4个算术运算符（+，-，*，/），可以从0显式转换（空节点的值为(T) 0）。

Answer 3

最近，我面临同样的问题。我的解决方案是使用向量数组来保存稀疏矩阵。这是我的代码：

#define PRECISION   0.01

inline bool checkPricision(float x[], float pre[], int n) {
    for (int i = 0; i < n; i++) {
        if (fabs(x[i] - pre[i]) > PRECISION) return false;
    }
    return true;
}

/* mx = b */
void gaussIteration(std::vector< std::pair<int, float> >* m, float x[], float b[], int n) {
    float* pre = new float[n];
    int cnt = 0;
    while (true) {
        cnt++;
        memcpy(pre, x, sizeof(float)* n);
        for (int i = 0; i < n; i++) {
            x[i] = b[i];
            float mii = -1;
            for (int j = 0; j < m[i].size(); j++) {
                if (m[i][j].first != i) {
                    x[i] -= m[i][j].second * x[m[i][j].first];
                }
                else {
                    mii = m[i][j].second;
                }
            }
            if (mii == -1) {
                puts("Error: No Solution");
                return;
            }
            x[i] /= mii;
        }
        if (checkPricision(x, pre, n)) {
            break;
        }
    }
    delete[] pre;
}

Answer 4

尝试PETSC。您需要CRS（压缩行存储）格式。

如何在C ++中为稀疏矩阵优化Gauss-Seidel例程？

4 个答案: