Question

#include <stdio.h>
#include <time.h>
#include <stdlib.h>

#define ROWS 2
#define COLS 3
#define ROW 3
#define COL 4
int main(void) 
{

    int e, f;

    srand((unsigned)time(NULL));

    int A[ROWS][COLS];

    int a; int b;
    for (a = 0; a < ROWS; ++a)
    {
        for (b = 0; b < COLS; ++b)
        {
            printf("%d ", A[a][b] = rand() % 9 + 1);

        }
        printf("\n");
    }

    printf("-------------------------\n");

    int B[ROW][COL];

    int c; int d;
    for (c = 0; c < ROW; ++c)
    {
        for (d = 0; d < COL; ++d)
        {
            printf("%d ", B[c][d] = rand() % 9 + 1);
        }

        printf("\n");
   }

   return 0;
}

此代码使用rand函数。制作2D数组。 [int A，int B]

我想在2d数组中使用随机值进行乘法。

我想制作另一个二维数组。和int A * int B 例如） int C = int A * int B（二维数组）

Answer 1

您可以在网络上找到大量用于矩阵乘法的C示例，所以我的第一个建议是在此之前进行一些探索！

一个简单的解决办法是：

#include <stdio.h>
#include <time.h>
#include <stdlib.h>

#define ROWS 2
#define COLS 3
#define ROW 3
#define COL 4
int main(void) 
{
    int A[ROWS][COLS];
    int B[ROW][COL];
    int C[ROWS][COL];
    int i, j, k;

    srand((unsigned)time(NULL));

    for (i = 0; i < ROWS; ++i)
    {
        for (j = 0; j < COLS; ++j)
        {
            printf("%d ", A[i][j] = rand() % 9 + 1);
        }
        printf("\n");
    }

    printf("-------------------------\n");

    for (i = 0; i < ROW; ++i)
    {
        for (j = 0; j < COL; ++j)
        {
            printf("%d ", B[i][j] = rand() % 9 + 1);
        }
        printf("\n");
    }

    printf("-------------------------\n");

    if (COLS != ROW) {
        printf("Unable to multiple the 2 matrixes!\n");
        return -1;
    }

    for (i = 0; i < ROWS; i++) {
        for (j = 0; j < COL; j++) {
            int tmp = 0;
            for (k = 0; k < COLS; k++) {
                tmp += A[i][k] * B[k][j];
            }
            printf("%d ", C[i][j] = tmp);
        }
        printf("\n");
    }

    return 0;
}

当然，需要检查第一个矩阵的列数是否与第二个矩阵的行数匹配。

我也简化了您使用的一些变量，因为它们是不必要的。

Answer 2

从 this page describing matrix multiplication 中，有一个以下二维矩阵插图：（您需要推断矩阵尺寸的其他阶数）

在C代码中，矩阵乘法的直接实现如下：（假设存在A和B，并且它们的填充与代码示例中的相似，但限制为2X2矩阵顺序。）

int C[2][2];

C[0][0] = A[0][0]*B[0][0]+
          A[0][1]*B[1][0]
C[0][1] = A[0][0]*B[0][1]+
          A[0][1]*B[1][1]
C[1][0] = A[1][0]*B[0][0]+
          A[1][1]*B[1][0]
C[1][1] = A[1][0]*B[0][1]+
          A[1][1]*B[1][1]

此实现不包含循环，也不是一般情况的解决方案。但是，以这种方式排列的A和B的索引揭示了暗示性的模式，可能有助于了解为2D矩阵的 general 解决方案创建步骤的方式乘法。

Answer 3

C中的矩阵乘法（高级方法）：

PS 我确实在这里说过” 高级 ” ，因此请先尝试一下代码，然后再进行投票就在这条路...

好的，您似乎想做的是一个名为matrix multiplication的过程。相信我，这不是一件简单的事情，尽管它是这样进行的...

注意：：这是一种执行您想做的高级方法，我相信会有比这更简单的方法，但是在这种方法中，这就是全部您必须写...

在代码顶部添加这些定义...

#define MAT_BYTE_TYPE double*
#define MAT_TYPE MAT_BYTE_TYPE*
#define RANGE_MAT(size) create_randomized_matrix(size, 0, 100)
#define CREATE_VEC2(x, y) (vec2) { x, y }

然后定义一个用于保存大小的结构...

typedef struct
{
    size_t w, h;
} vec2;

此函数创建一个具有指定大小的随机矩阵（只是不要忘记将srand((unsigned)time(0));放在main()函数的开头）...

MAT_TYPE create_randomized_matrix(vec2 const size, size_t const min_range, size_t const max_range)
{
    if (min_range > max_range)
        return (MAT_TYPE)0;
    MAT_TYPE matrix = calloc(size.h, sizeof(MAT_BYTE_TYPE));
    for (unsigned i = 0u; i < size.h; i++)
    {
        MAT_BYTE_TYPE mat_byte = calloc(size.w, sizeof(double));
        for (unsigned j = 0u; j < size.w; j++)
            mat_byte[j] = rand() % (max_range + min_range);
        matrix[i] = mat_byte;
    }
    return matrix;
}

还有一个用于创建具有指定大小的空矩阵的函数...

MAT_TYPE create_empty_matrix(vec2 const size)
{
    MAT_TYPE matrix = calloc(size.h, sizeof(MAT_BYTE_TYPE));
    for (unsigned i = 0u; i < size.h; i++)
    {
        MAT_BYTE_TYPE mat_byte = calloc(size.w, sizeof(double));
        matrix[i] = mat_byte;
    }
    return matrix;
}

还有 magic 函数，用于将矩阵相乘...

MAT_TYPE multiply_matrix(MAT_TYPE a, MAT_TYPE b, vec2 const a_size, vec2 
const b_size)
{
    if (a_size.w != b_size.h)
        return (MAT_TYPE)0;
    MAT_TYPE result = create_empty_matrix(CREATE_VEC2(a_size.w, b_size.h));
    for (size_t i = 0; i < a_size.h; i++)
        for (size_t j = 0; j < b_size.w; j++)
        {
            result[i][j] = 0;
            for (size_t k = 0; k < b_size.h; k++)
                result[i][j] += a[i][k] * b[k][j];
        }
    return result;
}

有用示例：-
int main(void)
{
    srand((unsigned)time(0));
    MAT_TYPE matrix = RANGE_MAT(CREATE_VEC2(3, 2));
    MAT_TYPE matrix2 = RANGE_MAT(CREATE_VEC2(4, 3));
    MAT_TYPE result = multiply_matrix(matrix, matrix2, CREATE_VEC2(3, 2), CREATE_VEC2(4, 3));
    printf("First matrix:-\n\n");
    print_matrix(matrix, CREATE_VEC2(3, 2));
    printf("\n\nSecond matrix:-\n\n");
    print_matrix(matrix2, CREATE_VEC2(4, 3));
    printf("\n\nAfter multiplication:-\n\n");
    print_matrix(result, CREATE_VEC2(4, 2));
    return 0;
}
此函数分别创建两个矩阵 2x3 和 4x3 （注意两个矩阵中的'x3'），然后将两个矩阵相乘并存储MAT_TYPE 结果中的结果矩阵，所有三个矩阵同时打印...（每次运行中所有值都是随机的）

编程愉快，

Ruks。

2D数组Rand函数乘法

3 个答案:

C中的矩阵乘法（高级方法）：