C#

using System;
using System.Runtime.InteropServices.WindowsRuntime;

namespace Utilities
{
    public static class MathExtensions
    {
        // ideas from: Lippert, Gravell, Skeet
        public static double ModT<T>(this T i1, T i2)
        {
            double v1 = i1.GetDouble();
            double v2 = i2.GetDouble();
            return v1 - v2 * Math.Floor(v1 / v2);
        }

        public static double ModT1T2<T1, T2>(this T1 i1, T2 i2)
        {
            double v1 = i1.GetDouble();
            double v2 = i2.GetDouble();
            return v1 - v2 * Math.Floor(v1 / v2);
        }

        public static double GetDouble<T>(this T i1)
        {
            double v1;

            try
            {
                v1 = Convert.ToDouble(i1);
            }
            catch (InvalidCastException iex)
            {
                throw new InvalidCastException($"type {typeof(T)} cannot be cast to double: {iex.Message}");
            }

            catch (FormatException fex)
            {
                throw new FormatException($"type {typeof(T)} cannot be used: {fex.Message}");
            }

            catch (OverflowException oex)
            {
                throw new OverflowException($"type {typeof(T)} result is an overflow: {oex.Message}");
            }

            return v1;
        }
    }
}

double dbl = -1.779406909.ModT(2 * Math.PI);

double int1 = 221.ModT(20);

double sngl = 102.0f.ModT(20.0f);

double deci = 102.0m.ModT(20.0m);

double intdecicombo = 100.0.ModT1T2(34.56m);

double dbl2 = 100.0.ModT(34.56);

BillWoodruff wrote:

C#

catch (InvalidCastException iex)
{
    throw new InvalidCastException($"type {typeof(T)} cannot be cast to double: {iex.Message}");
}

catch (InvalidCastException iex)
{
    throw new InvalidCastException($"Type {typeof(T)} cannot be cast to double: {iex.Message}", iex);
}
catch (FormatException fex)
{
    throw new FormatException($"Value '{i1}' of type {typeof(T)} cannot be converted to a double: {fex.Message}", fex);
}
catch (OverflowException oex)
{
    throw new OverflowException($"Value '{i1}' of type {typeof(T)} is too large for a double: {oex.Message}", oex);
}

public static double ModT<T>(this T i1, T i2) where T : IConvertible { ... }
public static double ModT1T2<T1, T2>(this T1 i1, T2 i2) where T1 : IConvertible where T2 : IConvertible { ... }
public static double GetDouble<T>(this T i1) where T : IConvertible { ... }

where T:
     struct,
     IComparable,
     IComparable<T>,
     IConvertible,
     IEquatable<T>,
     IFormattable

char c = '*';
double a = (double)c; // Works
double b = Convert.ToDouble(c); // Throws

using System.Linq.Expressions;

public static class GenericOperators<T>
{
    public static readonly Func<T, T, T> Add = Create(Expression.Add);
    public static readonly Func<T, T, T> Subtract = Create(Expression.Subtract);
    public static readonly Func<T, T, T> Multiply = Create(Expression.Multiply);
    public static readonly Func<T, T, T> Divide = Create(Expression.Divide);
    
    private static Func<T, T, T> Create(Func<Expression, Expression, BinaryExpression> body)
    {
        try
        {
            Type typeT = typeof(T);
            var left = Expression.Parameter(typeT, "left");
            var right = Expression.Parameter(typeT, "right");

            if (typeT.IsEnum)
            {
                Type enumType = Enum.GetUnderlyingType(typeT);
                var x = Expression.Convert(left, enumType);
                var y = Expression.Convert(right, enumType);

                Expression op = body(x, y);
                if (op.Type == enumType) op = Expression.Convert(op, typeT);

                return Expression.Lambda<Func<T, T, T>>(op, left, right).Compile();
            }

            return Expression.Lambda<Func<T, T, T>>(body(left, right), left, right).Compile();
        }
        catch (InvalidOperationException ex)
        {
            string message = ex.Message;
            return delegate { throw new InvalidOperationException(message); };
        }
        catch (ArgumentException ex)
        {
            string message = ex.Message;
            return delegate { throw new InvalidOperationException(message); };
        }
    }
}

Zaphod Beeblebrox:

"Every time you try and operate these weird black controls that are labeled in black on a black background, a little black light lights up in black to let you know you've done it"