Generic using Arithmetic

[byzantium0001]

I want to create a type in my application that is a generic over unit types and allows arithmetic. Something like this:

public class Range<T> where T : UnitsNet.IQuantity, IComparable // I want this to also have IArithmeticQuantity
{
    public T Start {get; internal set;}
    public T Stop {get; internal set;}

    public Range(T start, T stop) {
        // I don't think this is necessary - but it is
        //   the only way I could think of that would allow me to
        //   do arithmetic on start/stop in the same base unit.
        if (start.Unit != stop.Unit) {
            stop = (T)stop.ToUnit(start.Unit);
        }
        if (stop.CompareTo(start) < 0) {
            throw new ArgumentOutOfRangeException(nameof(stop), $"The 'stop' value must be greater than the 'start' value: ${start} < ${stop}");
        }
        Start = start;
        Stop = stop;
    }

    public T GetSpan() {
        // Here I want to do 'Stop - Start' but have it
        //  return in the same unit type.
        // return T.From(....) ?
        // `return Stop - Start` doesn't work.
        // I can't seem to add `IArithmeticQuantity` to the type constraint on `T`
    }

    public Range<T> Shift(T amount) {
        /// Here I want to add `amount` to start/stop and return a new Range.
    }

    // etc for other ops.
}

The goal would be to have something like:

var R = new Range<Frequency>(
   Frequency.FromHertz(10),
   Frequency.FromKiloHertz(100)
); 

var R2 = R.Shift(Frequency.FromHertz(50)); 

The trouble I'm having is figuring out how to do arithmetic over the type T. I'm not exactly sure how to use IArtihmeticQuantity because I don't know how to get the IUnitType from T in the type constraint.

Is there another way to do arithmetic over a generic type T ?
Can you point me to any examples that do something similar that I can learn from ?