Chuyển vị

At[j][i] = A[i][j]

A (2 x 3)          At (3 x 2)
| 1  2  3 |        | 1  4 |
| 4  5  6 |        | 2  5 |
                   | 3  6 |

/* A là m x n, At là n x m. Hai vùng không được trùng nhau. */
void chuyen_vi(const int *A, int *At, size_t m, size_t n)
{
    for (size_t i = 0; i < m; ++i)
        for (size_t j = 0; j < n; ++j)
            At[j * m + i] = A[i * n + j];
}

/* Chuyển vị theo khối: chia thành các ô vuông vừa bộ nhớ đệm.
   Nhanh hơn bản ngây thơ vài lần với ma trận lớn. */
enum { KHOI = 32 };

void chuyen_vi_khoi(const int *A, int *At, size_t m, size_t n)
{
    for (size_t i0 = 0; i0 < m; i0 += KHOI)
        for (size_t j0 = 0; j0 < n; j0 += KHOI) {
            size_t i_het = i0 + KHOI < m ? i0 + KHOI : m;
            size_t j_het = j0 + KHOI < n ? j0 + KHOI : n;

            for (size_t i = i0; i < i_het; ++i)
                for (size_t j = j0; j < j_het; ++j)
                    At[j * m + i] = A[i * n + j];
        }
}

/* Chuyển vị B trước rồi nhân: cả hai mảng đều đọc liền mạch. */
chuyen_vi(B, Bt, n, n);

for (size_t i = 0; i < n; ++i)
    for (size_t j = 0; j < n; ++j) {
        double s = 0.0;

        for (size_t k = 0; k < n; ++k)
            s += A[i * n + k] * Bt[j * n + k];

        C[i * n + j] = s;
    }

/* Ma trận đối xứng là ma trận bằng chính chuyển vị của nó. */
int la_doi_xung(const int *A, size_t n)
{
    for (size_t i = 0; i < n; ++i)
        for (size_t j = i + 1; j < n; ++j)      /* lại là nửa trên */
            if (A[i * n + j] != A[j * n + i])
                return 0;

    return 1;
}

/* Xoay 90 độ theo chiều kim đồng hồ = chuyển vị rồi đảo từng hàng. */
void xoay_phai(int *A, size_t n)
{
    chuyen_vi_tai_cho(A, n);

    for (size_t i = 0; i < n; ++i)
        for (size_t j = 0; j < n / 2; ++j) {
            int t = A[i * n + j];

            A[i * n + j] = A[i * n + (n - 1 - j)];
            A[i * n + (n - 1 - j)] = t;
        }
}

/* Xoay 90 độ ngược chiều kim đồng hồ = chuyển vị rồi đảo từng cột. */