C भाषा नेभिगेटर ― प्रणाली विकासका लागि सबैभन्दा शक्तिशाली स्रोत

C भाषा मा म्याट्रिक्स गुणनको पूर्ण व्याख्या｜मूलभूतदेखि अनुकूलन र प्रयोगसम्म

फङ्सनको प्रयोग
目次

1. परिचय

C भाषा प्रणाली विकास र एम्बेडेड प्रोग्रामिङमा व्यापक रूपमा प्रयोग हुने भाषा हो, र म्याट्रिक्स गणनाहरू पनि यसको एक भागको रूपमा महत्वपूर्ण भूमिका खेल्दछ। यस लेखमा, C भाषा प्रयोग गरेर म्याट्रिक्स गुणनको कार्यान्वयन विधि व्याख्या गरिनेछ, र आधारभूतदेखि अनुकूलन, गति वृद्धि सम्म व्यापक रूपमा समेटिनेछ।

यस लेखको लक्षित पाठकहरू:

  • Beginner Learning C Language
  • People who want to know the implementation method of matrix calculations
  • People interested in the optimization and speedup of matrix multiplication

यो लेख पढेर, C भाषामा म्याट्रिक्स गुणन कार्यान्वयन गर्ने आधारभूत विधिहरू र प्रभावकारी रूपमा गणना गर्नका लागि प्रविधिहरू सिक्न सक्नुहुन्छ। पहिले, म्याट्रिक्स गुणनको आधारभूत कुरा सिकौं।

2. म्याट्रिक्स गुणनको आधार

2.1 म्याट्रिक्स भनेको के हो? म्याट्रिक्स गुणनको आधारभूत कुराहरू सजिलो तरिकाले व्याख्या

Matrix भनेको संख्याहरूले उभिएर र तेर्सै क्रमबद्ध संरचना भएको डेटा समूह हो। सामान्यतया, पङ्क्ति र स्तम्भहरू भएको द्वि-आयामिक एरेको रूपमा प्रस्तुत गरिन्छ।

उदाहरणका लागि, तलको जस्तै 2×3 को म्याट्रिक्स छ：

A =
[ 1  2  3 ]
[ 4  5  6 ]

म्याट्रिक्स गुणन भनेको दुई म्याट्रिक्सलाई गुणा गरेर नतिजा पाउने गणना हो, र यसले तलका शर्तहरू पूरा गर्नुपर्छ：

  • Number of columns of the left matrix Anumber of rows of the right matrix B

उदाहरणका लागि, यदि 2×3 म्याट्रिक्स र 3×2 म्याट्रिक्सलाई यसरी गुणा गरियो भने, 2×2 को म्याट्रिक्स प्राप्त हुन्छ।

A =
[ 1  2  3 ]
[ 4  5  6 ]
B =
[ 7  8 ]
[ 9 10 ]
[11 12 ]

यस अवस्थामा म्याट्रिक्स गुणन C = A × B तलको जस्तै गणना गरिन्छ।

C =
[ 58  64 ]
[139 154 ]

2.2 म्याट्रिक्स गुणनको गणना विधि | उदाहरण र सूत्रहरूबाट बुझ्ने

म्याट्रिक्स गुणनको गणना प्रत्येक पङ्क्तिको तत्व र स्तम्भको तत्वलाई गुणा गरी, तिनीहरूको योग गरेर गरिन्छ।
सामान्यतया, म्याट्रिक्स A (आकार m × n) र म्याट्रिक्स B (आकार n × p) लाई गुणा गर्दा, प्राप्त हुने म्याट्रिक्स C को आकार m × p हुन्छ।

म्याट्रिक्स गुणनको सामान्य गणना सूत्र：

C[i][j] = Σ(A[i][k] * B[k][j])  (k=0 देखि n-1 सम्म)

यहाँ,

  • C[i][j]Cij
  • A[i][k]ikA
  • B[k][j]kjB

2.3 म्याट्रिक्स गुणनका गुणहरू (संयोजन नियम, वितरण नियम आदि)

म्याट्रिक्स गुणनमा तलका जस्ता गुणहरू छन्।

  1. सहयोग नियम (Associativity)
   (A × B) × C = A × (B × C)

तर, म्याट्रिक्सको गुणन विनिमेय छैन।

  1. वितरण नियम (Distributive Law)
   A × (B + C) = A × B + A × C
  1. पहिचान म्याट्रिक्स（Identity Matrix）पहिचान म्याट्रिक्स I सभी विकर्ण तत्वहरू 1, अन्य तत्वहरू 0 भएको म्याट्रिक्स हो, कुनै पनि म्याट्रिक्स A यससँग सम्बन्धित निम्न सम्बन्ध स्थापित हुन्छ।
   A × I = I × A = A

म्याट्रिक्स गुणनका गुणहरू बुझेर, गणनाको अनुकूलन र प्रयोगको दायरा विस्तार हुन्छ।

3. C भाषा मा म्याट्रिक्स गुणा कार्यान्वयन गर्ने तरिका | नमूना कोड सहित

3.1 C भाषा मा म्याट्रिक्सलाई 2-आयामिक एरेमा प्रतिनिधित्व गर्ने तरिका

स्थिर आकारको 2-आयामिक एरे प्रयोग गर्नुहोस्

म्याट्रिक्सलाई स्थिर आकारको 2-आयामिक एरे मा प्रतिनिधित्व गर्ने तरिका सरल र बुझ्न सजिलो छ, शुरुआतीहरूका लागि उपयुक्त छ।

#include 
#define ROWS 2
#define COLS 3
int main() {
    int matrix[ROWS][COLS] = {
        {1, 2, 3},
        {4, 5, 6}
    };
    // म्याट्रिक्स प्रदर्शन
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("n");
    }
    return 0;
}

डायनामिक मेमोरी आवंटन प्रयोग गर्ने

यदि म्याट्रिक्सको आकारलाई लचिलो रूपमा ह्यान्डल गर्न चाहनुहुन्छ भने, malloc() प्रयोग गरेर डायनामिक मेमोरी आवंटन गर्नुहोस्।

#include 
#include 
int main() {
    int rows = 2, cols = 3;
    int **matrix;
    // स्मृति आवंटन
    matrix = (int **)malloc(rows * sizeof(int *));
    for (int i = 0; i < rows; i++) {
        matrix[i] = (int *)malloc(cols * sizeof(int));
    }
    // डेटा इनपुट
    int value = 1;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = value++;
        }
    }
    // म्याट्रिक्स प्रदर्शन
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("n");
    }
    // स्मृति मुक्ती
    for (int i = 0; i < rows; i++) {
        free(matrix[i]);
    }
    free(matrix);
    return 0;
}

3.2 C भाषा मा म्याट्रिक्स गुणा कार्यान्वयन | आधारभूत कोडको व्याख्या

यहाँ, दुई म्याट्रिक्सको गुणनफल गणना गर्ने आधारभूत कार्यक्रम प्रस्तुत गरिन्छ।

#include 
#define N 3  // म्याट्रिक्सको आकार
// म्याट्रिक्स गुणा गणना गर्ने फङ्सन
void matrixMultiplication(int A[N][N], int B[N][N], int C[N][N]) {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            C[i][j] = 0; // प्रारम्भिकरण
            for (int k = 0; k < N; k++) {
                C[i][j] += A[i][k] * B[k][j];
            }
        }
    }
}
// म्याट्रिक्स प्रदर्शन गर्ने फङ्सन
void printMatrix(int matrix[N][N]) {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("n");
    }
}
int main() {
    int A[N][N] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    int B[N][N] = {
        {9, 8, 7},
        {6, 5, 4},
        {3, 2, 1}
    };
    int C[N][N];  // परिणाम म्याट्रिक्स
    // म्याट्रिक्स गुणा गणना
    matrixMultiplication(A, B, C);
    // परिणाम प्रदर्शन
    printf("म्याट्रिक्स A:n");
    printMatrix(A);
    printf("म्याट्रिक्स B:n");
    printMatrix(B);
    printf("म्याट्रिक्स गुणा C:n");
    printMatrix(C);
    return 0;
}

यो कोडमा, matrixMultiplication() फङ्सनले 3-स्तरीय लूप प्रयोग गरी प्रत्येक तत्वको गुणा र योग गणना गर्दछ।

4. म्याट्रिक्स गुणनको अनुकूलन विधिहरू

4.1 लूप अनुकूलनद्वारा म्याट्रिक्स गुणनलाई तेज बनाउने

मूलभूत म्याट्रिक्स गुणन कोडमा、3-स्तरीय लूप प्रयोग गरेर गणना गरिन्छ। तर, लूपको क्रमलाई परिवर्तन गरेर क्यास दक्षता सुधार्न, प्रक्रिया गति तेज बनाउन सम्भव छ।

मेमोरी पहुँच र क्यास दक्षता

CPU को क्यास, मेमोरी पहुँचको स्थानीयता उच्च हुँदा प्रभावकारी रूपमा काम गर्छ। म्याट्रिक्स गुणनको गणनामा, तलको जस्तै लूप क्रम परिवर्तन प्रभावकारी हुन्छ।

#include 
#define N 3  // म्याट्रिक्सको आकार
// लूप क्रम परिवर्तन गरेर क्यास दक्षता सुधार
void optimizedMatrixMultiplication(int A[N][N], int B[N][N], int C[N][N]) {
    for (int i = 0; i < N; i++) {
        for (int k = 0; k < N; k++) {  // k लाई बाहिर राख्नुहोस्
            for (int j = 0; j < N; j++) {
                C[i][j] += A[i][k] * B[k][j];
            }
        }
    }
}
int main() {
    int A[N][N] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int B[N][N] = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}};
    int C[N][N] = {0};
    optimizedMatrixMultiplication(A, B, C);
    // परिणाम प्रदर्शन
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            printf("%d ", C[i][j]);
        }
        printf("n");
    }
    return 0;
}

4.2 Sutorassen-hō द्वारा म्याट्रिक्स गुणनलाई अनुकूलन

Sutorassen-hō（Strassen Algorithm） म्याट्रिक्स गुणनको गणनात्मक जटिलतालाई O(N³) → O(N^{2.81}) मा घटाउन सक्ने एल्गोरिदम हो।

Sutorassen-hō को C भाषा कार्यान्वयन

#include 
#include 
// 2×2 म्याट्रिक्सको लागि स्ट्रैसन विधि
void strassen(int A[2][2], int B[2][2], int C[2][2]) {
    int M1 = (A[0][0] + A[1][1]) * (B[0][0] + B[1][1]);
    int M2 = (A[1][0] + A[1][1]) * B[0][0];
    int M3 = A[0][0] * (B[0][1] - B[1][1]);
    int M4 = A[1][1] * (B[1][0] - B[0][0]);
    int M5 = (A[0][0] + A[0][1]) * B[1][1];
    int M6 = (A[1][0] - A[0][0]) * (B[0][0] + B[0][1]);
    int M7 = (A[0][1] - A[1][1]) * (B[1][0] + B[1][1]);
    C[0][0] = M1 + M4 - M5 + M7;
    C[0][1] = M3 + M5;
    C[1][0] = M2 + M4;
    C[1][1] = M1 - M2 + M3 + M6;
}
int main() {
    int A[2][2] = {{1, 2}, {3, 4}};
    int B[2][2] = {{5, 6}, {7, 8}};
    int C[2][2];
    strassen(A, B, C);
    // परिणाम प्रदर्शन
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            printf("%d ", C[i][j]);
        }
        printf("n");
    }
    return 0;
}

4.3 OpenMP द्वारा समानान्तर प्रक्रिया

म्याट्रिक्स गुणनको गणना प्रत्येक तत्व स्वतन्त्र रूपमा गणना गर्न सक्ने कारणले, समानान्तर प्रक्रिया द्वारा तेज बनाउने सम्भव छ। C भाषामा OpenMP प्रयोग गरेर सजिलै समानान्तर प्रक्रिया कार्यान्वयन गर्न सकिन्छ।

#include 
#include 
#define N 3  // म्याट्रिक्स आकार
// OpenMP प्रयोग गरेर समानान्तर म्याट्रिक्स गुणन
void parallelMatrixMultiplication(int A[N][N], int B[N][N], int C[N][N]) {
    #pragma omp parallel for collapse(2)
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            C[i][j] = 0;
            for (int k = 0; k < N; k++) {
                C[i][j] += A[i][k] * B[k][j];
            }
        }
    }
}
int main() {
    int A[N][N] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int B[N][N] = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}};
    int C[N][N] = {0};
    parallelMatrixMultiplication(A, B, C);
    // परिणाम प्रदर्शन
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            printf("%d ", C[i][j]);
        }
        printf("n");
    }
    return 0;
}

 

5. C भाषा को म्याट्रिक्स गुणनमा प्रायः हुने त्रुटिहरू र समाधानहरू

5.1 स्मृति लीक रोक्ने तरिका

स्मृति लीक भनेको के हो?

डायनामिक स्मृति आवंटन (malloc) गरेपछि free द्वारा मुक्त नगरेमा, अनावश्यक स्मृति कार्यक्रम समाप्त भएपछि पनि राखिएको रहन्छ, जसले स्मृति लीक उत्पन्न हुन्छ। यसले स्मृति प्रयोग मात्रा निरन्तर बढ्न सक्छ, र कार्यक्रमको कार्यक्षमता अस्थिर हुन सक्छ।

गलत कोड उदाहरण

#include 
#include 
int main() {
    int rows = 3, cols = 3;
    int **matrix;
    // मेमोरी आवंटन
    matrix = (int **)malloc(rows * sizeof(int *));
    for (int i = 0; i < rows; i++) {
        matrix[i] = (int *)malloc(cols * sizeof(int));
    }
    return 0;  // free गर्न नबिर्सनु भएको कारण मेमोरी लीक हुन्छ
}

समाधान

आवंटित स्मृति सधैँ मुक्त गर्न आवश्यक हुन्छ।

#include 
#include 
int main() {
    int rows = 3, cols = 3;
    int **matrix;
    // स्मृति आवंटन
    matrix = (int **)malloc(rows * sizeof(int *));
    for (int i = 0; i < rows; i++) {
        matrix[i] = (int *)malloc(cols * sizeof(int));
    }
    // स्मृति मुक्ती
    for (int i = 0; i < rows; i++) {
        free(matrix[i]);
    }
    free(matrix);
    return 0;
}

5.2 एरे बाहिर सन्दर्भ त्रुटिको कारण र समाधान

एरे बाहिर सन्दर्भ भनेको के हो?

एरेको सीमा बाहिरको स्मृतिमा पहुँच गर्दा, अनपेक्षित व्यवहार उत्पन्न हुन्छ, र कहिलेकाहीँ सेग्मेन्टेशन फाल्ट（Segmentation Fault） भन्ने त्रुटि हुन्छ।

गलत कोड उदाहरण

#include 
#define N 3
int main() {
    int matrix[N][N] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    // सीमा बाहिर पहुँच (N = 3 हुँदा, matrix[3][0] अवस्थित छैन)
    printf("%dn", matrix[3][0]);  
    return 0;
}

समाधान

#include 
#define N 3
int main() {
    int matrix[N][N] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("n");
    }
    return 0;
}

5.3 डिबग टूल GDB प्रयोग गरेर त्रुटि विश्लेषण

त्रुटि कहाँ उत्पन्न हुन्छ पत्ता लगाउन, C भाषा को डिबग टूल GDB（GNU Debugger） प्रयोग गर्नु उपयोगी हुन्छ।

GDB को आधारभूत प्रयोग

  1. कम्पाइल गर्दा डिबग जानकारी समावेश गर्नुहोस्.
   gcc -g program.c -o program
  1. GDB सुरु गर्नुहोस्
   gdb ./program
  1. प्रोग्राम चलाउनुहोस्
   run
  1. त्रुटि उत्पन्न हुँदा स्ट्याक ट्रेस जाँच गर्नुहोस्.
   backtrace

GDB प्रयोग गरेर उदाहरण

(gdb) run
Starting program: ./program
Program received signal SIGSEGV, Segmentation fault.
0x0000555555555142 in main () at program.c:10
10    printf("%dn", matrix[3][0]);  // यहाँ त्रुटि हुन्छ

6. म्याट्रिक्स गुणनको प्रयोग उदाहरण

6.1 ग्राफिक्समा रूपान्तरण म्याट्रिक्स

म्याट्रिक्स प्रयोग गरेर 2D‑3D रूपान्तरण

कम्प्युटर ग्राफिक्स（CG）मा、वस्तुको स्थानान्तरण（समांतर स्थानान्तरण）、घुमाउने、स्केलिङ（विस्तार‑संकुचन） आदि म्याट्रिक्स प्रयोग गरेर गणना गरिन्छ।

2D रूपान्तरण म्याट्रिक्स
2‑आयामको निर्देशांक रूपान्तरणले तलको जस्तै 3×3 म्याट्रिक्स प्रयोग गर्दछ।

[x']   [ a  b  tx ]   [x]
[y'] = [ c  d  ty ] * [y]
[ 1]   [ 0  0   1 ]   [1]

C भाषामा 2D रूपान्तरण म्याट्रिक्स लागू गर्ने

#include 
#include 
#define PI 3.14159265
// 2D समन्वय घुमाउने कार्य
void rotate2D(float x, float y, float angle, float *x_out, float *y_out) {
    float rad = angle * PI / 180.0;  // कोणलाई रेडियनमा रूपान्तरण गर्ने
    float rotationMatrix[2][2] = {
        {cos(rad), -sin(rad)},
        {sin(rad), cos(rad)}
    };
    // म्याट्रिक्स गुणन गणना गर्ने
    *x_out = rotationMatrix[0][0] * x + rotationMatrix[0][1] * y;
    *y_out = rotationMatrix[1][0] * x + rotationMatrix[1][1] * y;
}
int main() {
    float x = 1.0, y = 0.0;
    float angle = 90.0;
    float x_new, y_new;
    rotate2D(x, y, angle, &x_new, &y_new);
    printf("घुमाइपछि समन्वय: (%.2f, %.2f)n", x_new, y_new);
    return 0;
}

6.2 मेसिन लर्निङमा न्यूरल नेटवर्कको वजन गणना

न्यूरल नेटवर्कमा, इनपुट डेटा X मा, वजन W लाई गुणा गरेर अर्को तहको इनपुट गणना गरिन्छ।

Y = X × W

C भाषामा साधारण न्यूरल नेटवर्कको वजन गणना

#include 
// म्याट्रिक्स गुणन गणना गर्ने फंक्शन
void matrixMultiply(float X[2][3], float W[3][2], float Y[2][2]) {
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            Y[i][j] = 0;
            for (int k = 0; k < 3; k++) {
                Y[i][j] += X[i][k] * W[k][j];
            }
        }
    }
}
int main() {
    float X[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };
    float W[3][2] = {
        {0.1, 0.2},
        {0.3, 0.4},
        {0.5, 0.6}
    };
    float Y[2][2];
    matrixMultiply(X, W, Y);
    // परिणाम प्रदर्शन
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            printf("%.2f ", Y[i][j]);
        }
        printf("n");
    }
    return 0;
}

6.3 भौतिक सिमुलेशनमा अवस्था संक्रमण

अवस्था संक्रमण म्याट्रिक्स

उदाहरणका लागि, 2D वस्तुको स्थिति (x, y), गति (vx, vy) हो भने, समय t को पछि नयाँ अवस्था S' तलको म्याट्रिक्स गुणनले व्यक्त गर्न सकिन्छ।

S' = T × S
[x']   [ 1  0  t  0 ]   [ x ]
[y'] = [ 0  1  0  t ] * [ y ]
[vx']  [ 0  0  1  0 ]   [vx ]
[vy']  [ 0  0  0  1 ]   [vy ]

C भाषामा कार्यान्वयन उदाहरण

#include 
// अवस्था संक्रमण गणना
void stateTransition(float T[4][4], float S[4], float S_new[4]) {
    for (int i = 0; i < 4; i++) {
        S_new[i] = 0;
        for (int j = 0; j < 4; j++) {
            S_new[i] += T[i][j] * S[j];
        }
    }
}
int main() {
    float T[4][4] = {
        {1, 0, 1, 0},
        {0, 1, 0, 1},
        {0, 0, 1, 0},
        {0, 0, 0, 1}
    };
    float S[4] = {0, 0, 1, 1};  // प्रारम्भिक अवस्था (0,0) वेग (1,1)
    float S_new[4];
    stateTransition(T, S, S_new);
    printf("नयाँ अवस्था: %.2f %.2f %.2f %.2fn", S_new[0], S_new[1], S_new[2], S_new[3]);
    return 0;
}

7. FAQ（सामान्य प्रश्नहरू）

7.1 म्याट्रिक्सको आकार ठूलो भएमा गणना गति किन सुस्त हुन्छ?

गणना जटिलता O(N³) ले बढ्ने कारणले

मूलभूत म्याट्रिक्स गुणनको गणना 3-स्तरीय लूप प्रयोग गर्ने कारण, गणना जटिलता O(N³) हुन्छ।
म्याट्रिक्सको आकार दोब्बर भएमा, गणना次数 8倍 हुन्छ, त्यसैले आकार ठूलो भए जति प्रक्रिया समय तीव्र रूपमा बढ्छ।

समाधान

  1. सर्वोत्तमकरण विधिहरूको प्रयोग
  • Change the order of the loop
  • Using Strassen’s Method
  • Leveraging Parallelization Technologies Such as OpenMP
  1. समर्पित संख्यात्मक गणना लाइब्रेरी प्रयोग गर्नुहोस्
  • BLAS（Basic Linear Algebra Subprograms）
  • Intel MKL（Math Kernel Library）
  • OpenBLAS (open-source high-speed linear algebra library)

7.2 Strassen विधि कुन अवस्थामा प्रभावकारी?

ठूलो म्याट्रिक्स गुणन गणना गर्ने अवस्थामा

Strassen विधि, म्याट्रिक्सको आकार ठूलो भए जति गति वृद्धि प्रभाव ठूलो हुन्छ एल्गोरिद्म हो।
तर, तलका जस्ता प्रतिबन्धहरू छन्।

फाइदाहरू

  • The computational complexity becomes , enabling fast computation of large-scale matrix products
  • Compared to the general O(N³) method, it is particularly advantageous when

नोक्सानहरू

  • For small matrices, the overhead is large, and it actually becomes slower.
  • Memory usage may increase due to recursive calls

7.3 म्याट्रिक्स गुणन गणनामा ध्यान दिनुपर्ने संख्यात्मक त्रुटि के हो?

फ्लोटिंग पोइन्ट गणनाबाट त्रुटिको संचय

C भाषा मा, फ्लोटिंग पोइन्ट（float र double）प्रयोग गरेर गणना गर्दा गोलाई त्रुटि उत्पन्न हुन सक्छ।
म्याट्रिक्स गुणनमा, धेरै गुणा र जोड गर्ने कारण, यो त्रुटि सजिलै संचय हुन्छ।

संख्यात्मक त्रुटि घटाउने तरिका

  1. double प्रकार प्रयोग गर्नु
  • floatdouble(64bit) has higher precision
  • Example: has a precision of about 7 digits, has about 15 digits
  1. उच्च-सटीक गणना लाइब्रेरी प्रयोग गर्नुहोस्
  • GNU MP (GMP)Intel MKL

7.4 C भाषा बाहेकका भाषाहरूमा म्याट्रिक्स गुणनको कार्यान्वयन?

Python（NumPy प्रयोग गरेर）

Python मा NumPy प्रयोग गरेर, म्याट्रिक्स गुणनलाई अत्यन्तै सजिलै गणना गर्न सकिन्छ।

import numpy as np
A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
B = np.array([[9, 8, 7], [6, 5, 4], [3, 2, 1]])
C = np.dot(A, B)  # म्याट्रिक्स गुणन
print(C)

Java（मानक पुस्तकालय प्रयोग गरेर）

Java मा पनि 2-आयामी एरे प्रयोग गरेर कार्यान्वयन सम्भव छ।

public class MatrixMultiplication {
    public static void main(String[] args) {
        int[][] A = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
        int[][] B = { {9, 8, 7}, {6, 5, 4}, {3, 2, 1} };
        int[][] C = new int[3][3];
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                for (int k = 0; k < 3; k++) {
                    C[i][j] += A[i][k] * B[k][j];
                }
            }
        }
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(C[i][j] + " ");
            }
            System.out.println();
        }
    }
}