mat

//Quadrant sum

#include<stdio.h>
#include<omp.h>

void main()
{
        int N, i, j;
        printf("Enter size of matrix:");
        scanf("%d", &N);
        int matrix[N][N];
        printf("Enter matrix elements: \n");
        for(i = 0; i < N; i++)
        {
                for(j = 0; j < N; j++)
                {
                        scanf("%d", &matrix[i][j]);
                }
        }
        printf("Input matrix: \n");
        for(i = 0; i < N; i++)
        {
                for(j = 0; j < N; j++)
                {
                        printf("%d", matrix[i][j]);
                }
        printf("\n");
        }
        int sumA = 0, sumB = 0, sumC = 0, sumD = 0;
        #pragma omp parallel sections reduction(+:sumA, sumB, sumC, sumD)
        {
                #pragma omp section
                {
                        for(i=0; i<N/2; i++)
                        {
                                for(j=0; j<N/2; j++)
                                {
                                        sumA+=matrix[i][j];
                                }
                        }
                }
                #pragma omp section
                {
                        for(i=0; i<N/2; i++)
                        {
                                for(j=N/2; j<N; j++)
                                {
                                        sumB+=matrix[i][j];
                                }
                        }
                }
                #pragma omp section
                {
                        for(i=N/2; i<N; i++)
                        {
                                for(j=0; j<N/2; j++)
                                {
                                        sumC+=matrix[i][j];
                                }
                        }
                }
                #pragma omp section
                {
                        for(i=N/2; i<N; i++)
                        {
                                for(j=N/2; j<N; j++)
                                {
                                        sumD+=matrix[i][j];
                                }
                        }
                }
        }
        printf("SumA= %d", sumA);
        printf("SumB= %d", sumB);
        printf("SumC= %d", sumC);
        printf("SumD= %d", sumD);
}
//-------------------------------------
// Trace of a Matrix using OpenMP
#include <stdio.h>
#include <stdlib.h>
#include <omp.h>

#define SIZE 1000  // Define matrix size

// Function to calculate the trace sequentially
int trace_sequential(int matrix[SIZE][SIZE]) {
    int trace = 0;
    for (int i = 0; i < SIZE; i++) {
        trace += matrix[i][i];
    }
    return trace;
}

// Function to calculate the trace using OpenMP
int trace_parallel(int matrix[SIZE][SIZE]) {
    int trace = 0;
    #pragma omp parallel for reduction(+:trace)
    for (int i = 0; i < SIZE; i++) {
        trace += matrix[i][i];
    }
    return trace;
}

int main() {
    int matrix[SIZE][SIZE];

    // Initialize matrix with random values
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            matrix[i][j] = rand() % 100;
        }
    }

    double start, end;

    // Sequential Trace Calculation
    start = omp_get_wtime();
    int trace_seq = trace_sequential(matrix);
    end = omp_get_wtime();
    printf("Sequential Trace: %d\n", trace_seq);
    printf("Sequential Time: %f seconds\n", end - start);

    // Parallel Trace Calculation
    start = omp_get_wtime();
    int trace_par = trace_parallel(matrix);
    end = omp_get_wtime();
    printf("Parallel Trace: %d\n", trace_par);
    printf("Parallel Time: %f seconds\n", end - start);

    // Correctness Check
    printf("Correctness Check: %s\n", (trace_seq == trace_par) ? "PASS" : "FAIL");

    return 0;
}
//--------------------------------------------
// Parallel vs Sequential Matrix Multiplication
#include <stdio.h>
#include <stdlib.h>
#include <omp.h>

#define N 500 // Matrix size

int A[N][N], B[N][N], C_seq[N][N], C_par[N][N];

int main() {
    // Initialize matrices A and B
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            A[i][j] = i + j;
            B[i][j] = i - j;
            C_seq[i][j] = 0;
            C_par[i][j] = 0;
        }
    }

    // Sequential Matrix Multiplication
    double seq_start = omp_get_wtime();
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            for (int k = 0; k < N; k++) {
                C_seq[i][j] += A[i][k] * B[k][j];
            }
        }
    }
    double seq_end = omp_get_wtime();

    // Parallel Matrix Multiplication
    double par_start = omp_get_wtime();
    #pragma omp parallel for collapse(2)
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            for (int k = 0; k < N; k++) {
                C_par[i][j] += A[i][k] * B[k][j];
            }
        }
    }
    double par_end = omp_get_wtime();

    // Verify correctness
    int correct = 1;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            if (C_seq[i][j] != C_par[i][j]) {
                correct = 0;
                break;
            }
        }
        if (!correct) break;
    }

    // Print results
    printf("Sequential Time: %.6f seconds\n", seq_end - seq_start);
    printf("Parallel Time:   %.6f seconds\n", par_end - par_start);
    printf("Correctness Check: %s\n", correct ? "PASS" : "FAIL");

    return 0;
}

//Parallel Matrix Determinant Calculation
#include <stdio.h> 
#include <stdlib.h> 
#include <omp.h> 
 
#define N 100 
 
int determinant(int mat[N][N], int n) { 
    int det = 0; 
    if (n == 1) return mat[0][0]; 
 
    int temp[N][N]; 
    int sign = 1; 
 
    #pragma omp parallel for reduction(+:det) private(temp, sign) 
    for (int f = 0; f < n; f++) { 
        int i = 0, j = 0; 
        for (int row = 1; row < n; row++) { 
            for (int col = 0; col < n; col++) { 
                if (col == f) continue; 
                temp[i][j++] = mat[row][col]; 
                if (j == n - 1) { 
                    j = 0; 
                    i++; 
                } 
            } 
        } 
        det += sign * mat[0][f] * determinant(temp, n - 1); 
        sign = -sign; 
    } 
    return det; 
} 
 
int main() { 
    int mat[N][N]; 
 
    // Initialize matrix with random values 
    for (int i = 0; i < N; i++) { 
        for (int j = 0; j < N; j++) { 
            mat[i][j] = rand() % 10; 
        } 
    } 
 
    double start_time = omp_get_wtime(); 
    int det = determinant(mat, N); 
    double end_time = omp_get_wtime(); 
 
    printf("Determinant: %d\n", det); 
    printf("Time taken: %f seconds\n", end_time - start_time); 
 
    return 0; 
}

// Parallel Convolution of Two Matrices 
#include <stdio.h> 
#include <stdlib.h> 
#include <omp.h> 
 
#define N 100 
#define KERNEL_SIZE 3 
 
void convolution(int input[N][N], int kernel[KERNEL_SIZE][KERNEL_SIZE], int output[N][N]) { 
    int pad = KERNEL_SIZE / 2; 
 
    #pragma omp parallel for 
    for (int i = pad; i < N - pad; i++) { 
        for (int j = pad; j < N - pad; j++) { 
            int sum = 0; 
            for (int ki = 0; ki < KERNEL_SIZE; ki++) { 
                for (int kj = 0; kj < KERNEL_SIZE; kj++) { 
                    sum += input[i - pad + ki][j - pad + kj] * kernel[ki][kj]; 
                } 
            } 
            output[i][j] = sum; 
        } 
    } 
} 
 
int main() { 
    int input[N][N], kernel[KERNEL_SIZE][KERNEL_SIZE], output[N][N]; 
 
    // Initialize input matrix and kernel 
    for (int i = 0; i < N; i++) { 
        for (int j = 0; j < N; j++) { 
            input[i][j] = rand() % 10; 
        } 
    } 
    for (int i = 0; i < KERNEL_SIZE; i++) { 
        for (int j = 0; j < KERNEL_SIZE; j++) { 
            kernel[i][j] = rand() % 3 - 1; // Random kernel values between -1 and 1 
        } 
    } 
 
    double start_time = omp_get_wtime(); 
    convolution(input, kernel, output); 
    double end_time = omp_get_wtime(); 
 
    printf("Time taken: %f seconds\n", end_time - start_time); 
 
    return 0; 
} 

// Parallel Matrix Transposition 
#include <stdio.h> 
#include <stdlib.h> 
#include <omp.h> 
 
#define N 1000 
 
void transpose(int A[N][N], int B[N][N]) { 
    #pragma omp parallel for 
    for (int i = 0; i < N; i++) { 
        for (int j = 0; j < N; j++) { 
            B[j][i] = A[i][j]; 
        } 
    } 
} 
 
int main() { 
    int A[N][N], B[N][N]; 
 
    // Initialize matrix A with random values 
    for (int i = 0; i < N; i++) { 
        for (int j = 0; j < N; j++) { 
            A[i][j] = rand() % 100; 
        } 
    } 
 
    double start_time = omp_get_wtime(); 
    transpose(A, B); 
    double end_time = omp_get_wtime(); 
 
    printf("Time taken: %f seconds\n", end_time - start_time); 
 
    return 0;
}