Generic math extended example

//add 2 matrices
public unsafe static Matrix<TNumber> operator +(Matrix<TNumber> left, Matrix<TNumber> right)
{
    if (left.Rows != right.Rows || left.Columns != right.Columns) throw new("Sum of 2 matrices is only possible when they are same size");

    var data = new TNumber[left.Rows, left.Columns];
    var size = left.Rows * left.Columns;

    fixed (TNumber* lSource = left._data, rSource = right._data, target = data)
    {
        for (int i = 0; i < size; i++)
            target[i] = lSource[i] + rSource[i]; //checked operator version would differ only in this line
    }

    return new Matrix<TNumber>(data);
}

//right-side operator for adding single number element-wise
public unsafe static Matrix<TNumber> operator +(Matrix<TNumber> left, TNumber right)
{
    var data = new TNumber[left.Rows, left.Columns];
    var size = left.Rows * left.Columns;

    fixed (TNumber* lSource = left._data, target = data)
    {
        for (int i = 0; i < size; i++)
            target[i] = lSource[i] + right;
    }

    return new Matrix<TNumber>(data);
}
// Multiplication. More efficient function might be chosen for production code. 
// This is just to illustrate this operator
public static Matrix<TNumber> operator *(Matrix<TNumber> a, Matrix<TNumber> b)
{
    int rowsA = a.Rows, colsA = a.Columns, rowsB = b.Rows, colsB = b.Columns;

    if (colsA != rowsB) throw new("Matrixes can't be multiplied");

    var data = new TNumber[rowsA, colsB];

    for (int i = 0; i < rowsA; i++)
    {
        for (int j = 0; j < colsB; j++)
        {
            var temp = TNumber.Zero;
            for (int k = 0; k < colsA; k++)
                temp += a[i, k] * b[k, j];

            data[i, j] = temp;
        }
    }
    return new Matrix<TNumber>(data);
}

/// <summary>Parsing and formatting operation for matrices</summary>
public interface IMatrixTextFormat
{
    /// <summary>
    /// Parse matrix from text buffer 
    /// </summary>    
    Matrix<TNumber> Parse<TNumber>(ReadOnlySpan<char> s)
        where TNumber : unmanaged, IComparisonOperators<TNumber, TNumber, bool>, INumberBase<TNumber>;

    /// <summary>
    /// Attempt to format current matrix in provided text buffer
    /// </summary>        
    bool TryFormat<TNumber>(Matrix<TNumber> matrix, Span<char> destination, out int charsWritten, 
                            ReadOnlySpan<char> format)
        where TNumber : unmanaged, IComparisonOperators<TNumber, TNumber, bool>, INumberBase<TNumber>;
}

public readonly struct StandardFormat : IMatrixTextFormat
{
    private readonly IFormatProvider _underlyingProvider;
    private readonly NumberStyles? _numberStyles;
    private readonly char _elementSeparator;

    private static readonly char[] _rowSeparators = Environment.NewLine.ToCharArray();

    public StandardFormat() : this(CultureInfo.InvariantCulture) { }

    public StandardFormat(IFormatProvider? underlyingProvider, 
                          NumberStyles numberStyles = NumberStyles.Any)
    {
        _numberStyles = numberStyles;
        _underlyingProvider = underlyingProvider ?? CultureInfo.InvariantCulture;

        (_underlyingProvider, _elementSeparator) = GetParameters();
    }

    private (IFormatProvider Provider, char ElementSeparator) GetParameters()
    {
        var provider = _underlyingProvider ?? CultureInfo.InvariantCulture;
        char elementSeparator = _elementSeparator != '\0'
            ? _elementSeparator
            : (provider is CultureInfo ci ? ci.TextInfo.ListSeparator.Trim().Single() : ';');

        return (provider, elementSeparator);
    }

    public Matrix<TNumber> Parse<TNumber>(ReadOnlySpan<char> s)
        where TNumber : unmanaged, IComparisonOperators<TNumber, TNumber, bool>, INumberBase<TNumber>
    {
        var (provider, elementSeparator) = GetParameters();
        var numberStyles = _numberStyles ?? NumberStyles.Any;

        var rowsEnumerator = s.Split(_rowSeparators, true).GetEnumerator();
        if (!rowsEnumerator.MoveNext()) throw new FormatException("Non empty text is expected");
        var firstRow = rowsEnumerator.Current;
        int numCols = 0;

        using var buffer = new ValueSequenceBuilder<TNumber>(stackalloc TNumber[32]);
        foreach (var col in firstRow.Split(elementSeparator, true))
        {
            if (col.IsEmpty) continue;
            buffer.Append(TNumber.Parse(col, numberStyles, provider));
            numCols++;
        }
        int numRows = 1;

        while (rowsEnumerator.MoveNext())
        {
            var row = rowsEnumerator.Current;
            if (row.IsEmpty) continue;

            foreach (var col in row.Split(elementSeparator, true))
            {
                if (col.IsEmpty) continue;
                buffer.Append(TNumber.Parse(col, numberStyles, provider));
            }
            numRows++;
        }
        var matrix = new TNumber[numRows, numCols];

        buffer.AsSpan().CopyTo2D(matrix);

        return new Matrix<TNumber>(matrix);
    }

    public bool TryFormat<TNumber>(Matrix<TNumber> matrix, Span<char> destination, 
                                   out int charsWritten, ReadOnlySpan<char> format)
        where TNumber : unmanaged, IComparisonOperators<TNumber, TNumber, bool>, INumberBase<TNumber>
    {
        var (provider, elementSeparator) = GetParameters();

        var newLine = _rowSeparators.AsSpan();
        var newLineLen = newLine.Length;
        int charsWrittenSoFar = 0;

        for (int i = 0; i < matrix.Rows; i++)
        {
            for (int j = 0; j < matrix.Columns; j++)
            {
                bool tryFormatSucceeded = matrix[i, j].TryFormat(destination[charsWrittenSoFar..], 
                    out var tryFormatCharsWritten, format, provider);
                charsWrittenSoFar += tryFormatCharsWritten;

                if (!tryFormatSucceeded)
                {
                    charsWritten = charsWrittenSoFar;
                    return false;
                }

                if (j < matrix.Columns - 1)
                {
                    if (destination.Length < charsWrittenSoFar + 2)
                    {
                        charsWritten = charsWrittenSoFar;
                        return false;
                    }

                    destination[charsWrittenSoFar++] = elementSeparator;
                    destination[charsWrittenSoFar++] = ' ';
                }
            }

            if (i < matrix.Rows - 1)
            {
                if (destination.Length < charsWrittenSoFar + newLineLen)
                {
                    charsWritten = charsWrittenSoFar;
                    return false;
                }

                newLine.CopyTo(destination[charsWrittenSoFar..]);
                charsWrittenSoFar += newLineLen;
            }
        }

        charsWritten = charsWrittenSoFar;
        return true;
    }
}

public readonly record struct Rational<TNumber>(TNumber Numerator, TNumber Denominator) : IEquatable<Rational<TNumber>>, IComparisonOperators<Rational<TNumber>, Rational<TNumber>, bool>,
     INumberBase<Rational<TNumber>>
     where TNumber : IBinaryInteger<TNumber> //make sense to allow only integers for numerator and denominator
{
    public static Rational<TNumber> Zero => new(TNumber.Zero, TNumber.One);
    public static Rational<TNumber> One => new(TNumber.One, TNumber.One);
    public static Rational<TNumber> AdditiveIdentity => Zero;
    public static Rational<TNumber> MultiplicativeIdentity => One;
    public static int Radix => TNumber.Radix;

    public Rational() : this(TNumber.Zero, TNumber.One) { }

    public Rational<TNumber> Simplify()
    {
        var (num, denom) = this;
        int signNum = TNumber.Sign(num), signDenom = TNumber.Sign(denom);

        if (signDenom < 0 && (signNum < 0 || signNum > 0))
        {
            num = -num;
            denom = -denom;
        }

        if (num == TNumber.Zero || num == TNumber.One || num == -TNumber.One) return this;

        var gcd = GreatestCommonDivisor(num, denom);
        return gcd > TNumber.One ? new Rational<TNumber>(num / gcd, denom / gcd) : this;
    }

    private static TNumber GreatestCommonDivisor(TNumber a, TNumber b) => b == TNumber.Zero ? a : GreatestCommonDivisor(b, a % b);

    private static readonly string TopDigits = "⁰¹²³⁴⁵⁶⁷⁸⁹";
    private static readonly string BottomDigits = "₀₁₂₃₄₅₆₇₈₉";
    private static readonly char TopMinus = '⁻';
    private static readonly char BottomMinus = '₋';
    private static readonly char Divider = '⁄';

    public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
    {
        var (num, denom) = this;
        int signNum = TNumber.Sign(num), signDenom = TNumber.Sign(denom);

        if (signDenom < 0 && (signNum < 0 || signNum > 0))
        {
            num = -num;
            denom = -denom;
        }

        provider ??= CultureInfo.InvariantCulture;

        charsWritten = 0;

        if (destination.Length < 3) return false;

        bool tryFormatSucceeded = num.TryFormat(destination, out var tryFormatCharsWritten, format, provider);
        charsWritten += tryFormatCharsWritten;
        if (!tryFormatSucceeded || destination.Length < charsWritten + 2) return false;
        var numBlock = destination[..charsWritten];
        for (int i = 0; i < numBlock.Length; i++)
        {
            var c = numBlock[i];
            if (!IsSimpleDigit(c) && c != '-') return false;
            numBlock[i] = c == '-' ? TopMinus : TopDigits[c - '0'];
        }


        if (destination.Length < charsWritten + 2) return false;
        destination[charsWritten++] = Divider;


        tryFormatSucceeded = denom.TryFormat(destination[charsWritten..], out tryFormatCharsWritten, format, provider);
        var startOfDenomBlock = charsWritten;
        charsWritten += tryFormatCharsWritten;

        if (!tryFormatSucceeded)
            return false;

        var denomBlock = destination.Slice(startOfDenomBlock, tryFormatCharsWritten);
        for (int i = 0; i < denomBlock.Length; i++)
        {
            var c = denomBlock[i];
            if (!IsSimpleDigit(c) && c != '-') return false;
            denomBlock[i] = c == '-' ? BottomMinus : BottomDigits[c - '0'];
        }

        return true;

        static bool IsSimpleDigit(char c) => (uint)c < 128 && (uint)(c - '0') <= '9' - '0';
    }

    public string ToString(string? format, IFormatProvider? formatProvider) => this.FormatToString(format, formatProvider);

    public override string? ToString() => ToString("G", null);

    /*... remaining code omitted for brevity*/
}