/// <summary>
/// Evaluates binary addition (+) for the given type(s); this will throw
/// an InvalidOperationException if the type T does not provide this operator, or for
/// Nullable<TInner> if TInner does not provide this operator.
/// </summary>
public static TArg1 AddAlternative <TArg1, TArg2>(TArg1 value1, TArg2 value2)
{
return(GenericMath <TArg2, TArg1> .Add(value1, value2));
}
/// <summary>
/// Performs a conversion between the given types; this will throw
/// an InvalidOperationException if the type T does not provide a suitable cast, or for
/// Nullable<TInner> if TInner does not provide this cast.
/// </summary>
public static TTo Convert <TFrom, TTo>(TFrom value)
{
return(GenericMath <TFrom, TTo> .Convert(value));
}
/// <summary>
/// Evaluates binary addition (+) for the given type; this will throw
/// an InvalidOperationException if the type T does not provide this operator, or for
/// Nullable<TInner> if TInner does not provide this operator.
/// </summary>
public static T Add <T>(T value1, T value2)
{
return(GenericMath <T> .Add(value1, value2));
}
/// <summary>
/// Evaluates bitwise not (~) for the given type; this will throw
/// an InvalidOperationException if the type T does not provide this operator, or for
/// Nullable<TInner> if TInner does not provide this operator.
/// </summary>
public static T Not <T>(T value)
{
return(GenericMath <T> .Not(value));
}
/// <summary>
/// Evaluates bitwise xor (^) for the given type; this will throw
/// an InvalidOperationException if the type T does not provide this operator, or for
/// Nullable<TInner> if TInner does not provide this operator.
/// </summary>
public static T Xor <T>(T value1, T value2)
{
return(GenericMath <T> .Xor(value1, value2));
}
/// <summary>
/// Evaluates binary less-than-or-equal (<=) for the given type; this will throw
/// an InvalidOperationException if the type T does not provide this operator, or for
/// Nullable<TInner> if TInner does not provide this operator.
/// </summary>
public static bool LessThanOrEqual <T>(T value1, T value2)
{
return(GenericMath <T> .LessThanOrEqual(value1, value2));
}
/// <summary>
/// Evaluates integer division (/) for the given type; this will throw
/// an InvalidOperationException if the type T does not provide this operator, or for
/// Nullable<TInner> if TInner does not provide this operator.
/// </summary><remarks>
/// This operation is particularly useful for computing averages and
/// similar aggregates.
/// </remarks>
public static T DivideInt32 <T>(T value, int divisor)
{
return(GenericMath <int, T> .Divide(value, divisor));
}
/// <summary>
/// Evaluates unary negation (-) for the given type; this will throw
/// an InvalidOperationException if the type T does not provide this operator, or for
/// Nullable<TInner> if TInner does not provide this operator.
/// </summary>
public static T Negate <T>(T value)
{
return(GenericMath <T> .Negate(value));
}
/// <summary>
/// Evaluates binary greater-than-on-eqauls (>=) for the given type; this will throw
/// an InvalidOperationException if the type T does not provide this operator, or for
/// Nullable<TInner> if TInner does not provide this operator.
/// </summary>
public static bool GreaterThanOrEqual <T>(T value1, T value2)
{
return(GenericMath <T> .GreaterThanOrEqual(value1, value2));
}
/// <summary>
/// Evaluates binary division (/) for the given type(s); this will throw
/// an InvalidOperationException if the type T does not provide this operator, or for
/// Nullable<TInner> if TInner does not provide this operator.
/// </summary>
public static TArg1 DivideAlternative <TArg1, TArg2>(TArg1 value1, TArg2 value2)
{
return(GenericMath <TArg2, TArg1> .Divide(value1, value2));
}
/// <summary>
/// Evaluates binary inequality (!=) for the given type; this will throw
/// an InvalidOperationException if the type T does not provide this operator, or for
/// Nullable<TInner> if TInner does not provide this operator.
/// </summary>
public static bool NotEqual <T>(T value1, T value2)
{
return(GenericMath <T> .NotEqual(value1, value2));
}
/// <summary>
/// Evaluates binary division (/) for the given type; this will throw
/// an InvalidOperationException if the type T does not provide this operator, or for
/// Nullable<TInner> if TInner does not provide this operator.
/// </summary>
public static T Divide <T>(T value1, T value2)
{
return(GenericMath <T> .Divide(value1, value2));
}
/// <summary>
/// Evaluates binary multiplication (*) for the given type(s); this will throw
/// an InvalidOperationException if the type T does not provide this operator, or for
/// Nullable<TInner> if TInner does not provide this operator.
/// </summary>
public static TArg1 MultiplyAlternative <TArg1, TArg2>(TArg1 value1, TArg2 value2)
{
return(GenericMath <TArg2, TArg1> .Multiply(value1, value2));
}
/// <summary>
/// Evaluates binary multiplication (*) for the given type; this will throw
/// an InvalidOperationException if the type T does not provide this operator, or for
/// Nullable<TInner> if TInner does not provide this operator.
/// </summary>
public static T Multiply <T>(T value1, T value2)
{
return(GenericMath <T> .Multiply(value1, value2));
}
/// <summary>
/// Evaluates binary subtraction(-) for the given type(s); this will throw
/// an InvalidOperationException if the type T does not provide this operator, or for
/// Nullable<TInner> if TInner does not provide this operator.
/// </summary>
public static TArg1 SubtractAlternative <TArg1, TArg2>(TArg1 value1, TArg2 value2)
{
return(GenericMath <TArg2, TArg1> .Subtract(value1, value2));
}
/// <summary>
/// Evaluates binary subtraction (-) for the given type; this will throw
/// an InvalidOperationException if the type T does not provide this operator, or for
/// Nullable<TInner> if TInner does not provide this operator.
/// </summary>
public static T Subtract <T>(T value1, T value2)
{
return(GenericMath <T> .Subtract(value1, value2));
}