Proposal for Interpolation and Extrapolation Interfaces in System.Numerics

[StellarWolfEntertainment]

I apologize in advance if this post has landed in the wrong category.

I propose the introduction of generic interfaces for interpolation and extrapolation in the System.Numerics namespace. While the immediate use cases may seem limited, these interfaces can provide consistency and flexibility across numeric types.

Currently, handling interpolation and extrapolation in numeric operations lacks a standardized approach, which can lead to code duplication and inconsistencies.

The following interfaces could be implemented to streamline interpolation and extrapolation for numeric types:

namespace System.Numerics;

public interface IInterpolable<TSelf, TReturn, TFactor> where TSelf : IInterpolable<TSelf, TReturn, TFactor>
{
    static abstract TReturn Interpolate(TSelf start, TSelf end, TFactor factor);
}

public interface IExtrapolable<TSelf, TReturn, TFactor> where TSelf : IExtrapolable<TSelf, TReturn, TFactor>
{
    static abstract TReturn Extrapolate(TSelf start, TSelf end, TFactor factor);
}

public interface IBlendable<TSelf, TReturn, TFactor> : IInterpolable<TSelf, TReturn, TFactor>, IExtrapolable<TSelf, TReturn, TFactor> where TSelf : IInterpolable<TSelf, TReturn, TFactor>, IExtrapolable<TSelf, TReturn, TFactor>, IBlendable<TSelf, TReturn, TFactor>
{
}

An example implementation for the Single type (I am going to only post the code relevant to the operations at hand):

public readonly struct Single : IBlendable<Single, Single, Single>
{
    // Interpolate method
    public static Single Interpolate(Single start, Single end, Single factor)
    {
        return Extrapolate(start, end, Single.Clamp(factor, 0.0f, 1.0f));
    }

    // Extrapolate method
    public static Single Extrapolate(Single start, Single end, Single factor)
    {
        return start + ((end - start) * factor);
    }
}

By adding these interfaces to the definition of numeric types in C#, we can provide a consistent approach to fairly common operations. Much like how the ITrigonometricFunctions<T> interface standardizes handling trigonometric operations with generic types, these interfaces will enhance the flexibility of generic math operations.

While the immediate utility might not be apparent, I believe this proposal will open the door for more robust and maintainable code in the future.

[elgonzo]

Either i am misunderstanding the motivation behind your proposal (in which case, apologies!), or what exactly is there regarding your suggestion that can't already be relatively easily solved in a generic manner with generic methods constrained to the existing interfaces in the System.Numerics namespace?

Implementing Extrapolate/Interpolate as generic methods would not require a new interface and would avoid code duplication (and possible inconsistencies between duplicated code). With respect to your Single-based Blending example, this could for example look like this:

public static TValue Interpolate<TValue>(TValue start, TValue end, TValue factor) where TValue : INumber<TValue>
{
    return Extrapolate(start, end, TValue.Clamp(factor, TValue.Zero, TValue.One));
}

public static TValue Extrapolate<TValue>(TValue start, TValue end, TValue factor) where TValue : INumber<TValue>
{
    return start + ((end - start) * factor);
}

[StellarWolfEntertainment]

the specific purpose isn't specifically just for INumber, some types that would be 'blendable' aren't necessarily 'numbers', for example a 'Vector' should not be INumber but COULD be IBlendable, however you also aren't misunderstanding the request, if I had just wanted it so that I could interpolate or extrapolate with 'Scalar' types then it would be easily solved with a IFloatingPointNumber<TValue> constraint, however it could be applied to Vectors, Quaternions, Matrices [if one were so inclined], Colors none of which would be viable for implementing IFloatingPointNumber.