I don't know how to use Generics on matrix operations

You need to create a generic matrix class in C# that supports basic matrix operations using generics (T) and operator overloading. The key is to work within constraints that allow mathematical operations on T. Since T could be anything, we need to restrict it to types that support addition, multiplication, ...

using System;
using System.Collections.Generic;
using System.Linq;

public class Matrix where T : struct, IConvertible
{
    private T[,] data;
    public int Rows { get; }
    public int Cols { get; }

    public Matrix(int rows, int cols)
    {
        Rows = rows;
        Cols = cols;
        data = new T[rows, cols];
    }

    public Matrix(T[,] initialValues)
    {
        Rows = initialValues.GetLength(0);
        Cols = initialValues.GetLength(1);
        data = initialValues;
    }

    public T this[int i, int j]
    {
        get => data[i, j];
        set => data[i, j] = value;
    }

    // Addition operator overload
    public static Matrix operator +(Matrix a, Matrix b)
    {
        if (a.Rows != b.Rows || a.Cols != b.Cols)
            throw new InvalidOperationException("Matrices must have the same dimensions");

        var result = new Matrix(a.Rows, a.Cols);

        for (int i = 0; i < a.Rows; i++)
        {
            for (int j = 0; j < a.Cols; j++)
            {
                result[i, j] = Add(a[i, j], b[i, j]);
            }
        }
        return result;
    }

    // Multiplication operator overload
    public static Matrix operator *(Matrix a, Matrix b)
    {
        if (a.Cols != b.Rows)
            throw new InvalidOperationException("Invalid matrix multiplication dimensions");

        var result = new Matrix(a.Rows, b.Cols);

        for (int i = 0; i < a.Rows; i++)
        {
            for (int j = 0; j < b.Cols; j++)
            {
                dynamic sum = 0;
                for (int k = 0; k < a.Cols; k++)
                {
                    sum += (dynamic)a[i, k] * (dynamic)b[k, j];
                }
                result[i, j] = (T)Convert.ChangeType(sum, typeof(T));
            }
        }
        return result;
    }

    // Method to perform union of two arrays using IEnumerable
    public static IEnumerable Union(IEnumerable a, IEnumerable b)
    {
        return a.Concat(b).Distinct();
    }

    // Addition helper method (handles generics safely)
    private static T Add(T a, T b)
    {
        return (T)Convert.ChangeType((dynamic)a + (dynamic)b, typeof(T));
    }

    // Print matrix (for debugging)
    public void Print()
    {
        for (int i = 0; i < Rows; i++)
        {
            for (int j = 0; j < Cols; j++)
            {
                Console.Write($"{data[i, j]} ");
            }
            Console.WriteLine();
        }
    }
}

// Example Usage
class Program
{
    static void Main()
    {
        var mat1 = new Matrix(new int[,] { { 1, 2 }, { 3, 4 } });
        var mat2 = new Matrix(new int[,] { { 5, 6 }, { 7, 8 } });

        var sumMatrix = mat1 + mat2;
        var productMatrix = mat1 * mat2;

        Console.WriteLine("Matrix Sum:");
        sumMatrix.Print();

        Console.WriteLine("\nMatrix Product:");
        productMatrix.Print();

        // Union of two integer arrays
        var arr1 = new int[] { 1, 2, 3 };
        var arr2 = new int[] { 3, 4, 5 };
        var unionResult = Matrix.Union(arr1, arr2);

        Console.WriteLine("\nUnion of Arrays:");
        Console.WriteLine(string.Join(", ", unionResult));
    }
}