2012-03-02 98 views
4

我正在寻找C中的Strassen's Algorithm的实现,并且我在最后发现了这个代码。如何使用此C代码使用Strassen算法来乘两个矩阵?

要使用multiply功能:

void multiply(int n, matrix a, matrix b, matrix c, matrix d); 

,它乘两个矩阵ab并提出在c结果(d是一个中介矩阵)。矩阵ab应具有以下类型:

typedef union _matrix 
{ 
    double **d; 
    union _matrix **p; 
} *matrix; 

我已动态分配四个矩阵abcd(双打的二维阵列),并分配其地址字段_matrix.d

#include "strassen.h" 

#define SIZE 50 

int main(int argc, char *argv[]) 
{ 
    double ** matA, ** matB, ** matC, ** matD; 
    union _matrix ma, mb, mc, md; 
    int i = 0, j = 0, n; 

    matA = (double **) malloc(sizeof(double *) * SIZE); 
    for (i = 0; i < SIZE; i++) 
     matA[i] = (double *) malloc(sizeof(double) * SIZE); 
    // Do the same for matB, matC, matD. 

    ma.d = matA; 
    mb.d = matB; 
    mc.d = matC; 
    md.d = matD; 

    // Initialize matC and matD to 0. 

    // Read n. 

    // Read matA and matB. 

    multiply(n, &ma, &mb, &mc, &md); 
    return 0; 
} 

此代码成功编译,但与n>BREAK崩溃。

strassen.c:

#include "strassen.h" 

/* c = a * b */ 
void multiply(int n, matrix a, matrix b, matrix c, matrix d) 
{ 
    if (n <= BREAK) { 
     double sum, **p = a->d, **q = b->d, **r = c->d; 
     int i, j, k; 

     for (i = 0; i < n; i++) 
     for (j = 0; j < n; j++) { 
      for (sum = 0., k = 0; k < n; k++) 
       sum += p[i][k] * q[k][j]; 
      r[i][j] = sum; 
     } 
    } else { 
     n /= 2; 
     sub(n, a12, a22, d11); 
     add(n, b21, b22, d12); 
     multiply(n, d11, d12, c11, d21); 
     sub(n, a21, a11, d11); 
     add(n, b11, b12, d12); 
     multiply(n, d11, d12, c22, d21); 
     add(n, a11, a12, d11); 
     multiply(n, d11, b22, c12, d12); 
     sub(n, c11, c12, c11); 
     sub(n, b21, b11, d11); 
     multiply(n, a22, d11, c21, d12); 
     add(n, c21, c11, c11); 
     sub(n, b12, b22, d11); 
     multiply(n, a11, d11, d12, d21); 
     add(n, d12, c12, c12); 
     add(n, d12, c22, c22); 
     add(n, a21, a22, d11); 
     multiply(n, d11, b11, d12, d21); 
     add(n, d12, c21, c21); 
     sub(n, c22, d12, c22); 
     add(n, a11, a22, d11); 
     add(n, b11, b22, d12); 
     multiply(n, d11, d12, d21, d22); 
     add(n, d21, c11, c11); 
     add(n, d21, c22, c22); 
    } 
} 

/* c = a + b */ 
void add(int n, matrix a, matrix b, matrix c) 
{ 
    if (n <= BREAK) { 
     double **p = a->d, **q = b->d, **r = c->d; 
     int i, j; 

     for (i = 0; i < n; i++) 
      for (j = 0; j < n; j++) 
       r[i][j] = p[i][j] + q[i][j]; 
    } else { 
     n /= 2; 
     add(n, a11, b11, c11); 
     add(n, a12, b12, c12); 
     add(n, a21, b21, c21); 
     add(n, a22, b22, c22); 
    } 
} 

/* c = a - b */ 
void sub(int n, matrix a, matrix b, matrix c) 
{ 
    if (n <= BREAK) { 
     double **p = a->d, **q = b->d, **r = c->d; 
     int i, j; 

     for (i = 0; i < n; i++) 
      for (j = 0; j < n; j++) 
       r[i][j] = p[i][j] - q[i][j]; 
    } else { 
     n /= 2; 
     sub(n, a11, b11, c11); 
     sub(n, a12, b12, c12); 
     sub(n, a21, b21, c21); 
     sub(n, a22, b22, c22); 
    } 
} 

strassen.h:

#define BREAK 8 

typedef union _matrix { 
    double **d; 
    union _matrix **p; 
} *matrix; 

/* Notational shorthand to access submatrices for matrices named a, b, c, d */ 

#define a11 a->p[0] 
#define a12 a->p[1] 
#define a21 a->p[2] 
#define a22 a->p[3] 
#define b11 b->p[0] 
#define b12 b->p[1] 
#define b21 b->p[2] 
#define b22 b->p[3] 
#define c11 c->p[0] 
#define c12 c->p[1] 
#define c21 c->p[2] 
#define c22 c->p[3] 
#define d11 d->p[0] 
#define d12 d->p[1] 
#define d21 d->p[2] 
#define d22 d->p[3] 

我的问题是如何使用功能multiply(如何实现矩阵)。

strassen.h

strassen.c

+4

不要在C中使用'malloc()'来返回返回值。 – 2012-03-02 19:24:29

+3

请不要倾销这么大的代码块,而是要清楚地解释问题所在!并告诉你所尝试的以及你怀疑的是什么?您当前版本的问题可能会让人发痒 – 2012-03-02 19:27:14

+2

'n'未初始化在您的'main'中 – pezcode 2012-03-07 02:55:55

回答

3

Atom said一样,您需要为两个矩阵正确初始化matrix.p。所有的

1)首先,你的matrixunion所以p实质上成为d解释为_matrix **它没有意义在这里 - 这就是为什么它崩溃。相反,您可能需要制作matrix a struct
最后,p根据定义是一个子矩阵数组,因此它应该是struct _matrix *(并且需要时您需要malloc实际数组)或struct _matrix[4](这是不可能的:))。

typedef struct _matrix 
{ 
    double **d; 
    struct _matrix *p; 
} *matrix; 

2)现在,让我们来看看p应该是什么。

      │ 
A.d -> d1 -> a[1,1] a[1,2]│a[1,3] a[1,4] 
     d2 -> a[2,1] a[2,2]│a[2,3] a[2,4] 
      ───────────────────────────── 
     d3 -> a[3,1] a[3,2]│a[3,3] a[3,4] 
     d4 -> a[4,1] a[4,2]│a[4,3] a[4,4] 
          │ 

pmatrix结构的数组!的特点是使d的这些结构的指向内部一个 以这样的方式(p[k].d)[i][j]是各子矩阵的元素:

p[0].d -> p01 -> a[1,1] p[1].d -> p11 -> a[1,3] 
      p02 -> a[2,1]    p12 -> a[2,3] 

p[2].d -> p21 -> a[3,1] p[3].d -> p31 -> a[3,3] 
      p22 -> a[4,1]    p32 -> a[4,3] 

你现在可以推断算法初始化p方形一任意均匀大小的

何时初始化它呢? ;)

+0

我认为,根据上述定义,作者想要为矩阵引入分层存储。假设你有一个8×8的矩阵,BREAK的值是2,你首先分配p来表示4个子矩阵,而这个p将代表4个矩阵d。所以你分配1 + 4倍的P和16倍的D。 否则为什么有人想要分而治之地添加矩阵? – zapstar 2015-05-31 09:45:36

2

当n> BREAK,矩阵乘法算法使用分层矩阵表示(该字段的union _matrixp,而非字段d)。

当分配内存和初始化矩阵ab时,您需要调整分层表示的代码。

+0

问题是我没有弄清楚如何做到这一点,我已经使用标准的动态分配为二维数组,但代码崩溃时,它涉及到n>休息,谢谢 – obo 2012-03-08 05:34:34

+0

你的意思是“two”而不是“tow”? – 2012-03-08 07:19:59

2

嗯,我不太确定你发布的代码有什么问题,但是我想指出一下刚刚在英特尔编程比赛中使用的Strassen算法的实现:http://software.intel.com/file/21818。也许你可以在那里找到一些有用的提示。

+0

这是仅有链接的答案的问题。您的链接不再指向Strassen算法的实现 - 仅仅是某种分形的图片...... – NoseKnowsAll 2017-04-22 20:49:17