forked from tsai/mathnet-numerics
Christoph Ruegg
13 years ago
10 changed files with 1111 additions and 13 deletions
@ -0,0 +1,763 @@ |
|||||
|
// TAKEN FROM:
|
||||
|
// Miscellaneous Utility Library
|
||||
|
// http://www.yoda.arachsys.com/csharp/miscutil/
|
||||
|
//
|
||||
|
// "Miscellaneous Utility Library" Software Licence
|
||||
|
//
|
||||
|
// Version 1.0
|
||||
|
//
|
||||
|
// Copyright (c) 2004-2008 Jon Skeet and Marc Gravell.
|
||||
|
// All rights reserved.
|
||||
|
//
|
||||
|
// Redistribution and use in source and binary forms, with or without
|
||||
|
// modification, are permitted provided that the following conditions
|
||||
|
// are met:
|
||||
|
//
|
||||
|
// 1. Redistributions of source code must retain the above copyright
|
||||
|
// notice, this list of conditions and the following disclaimer.
|
||||
|
//
|
||||
|
// 2. Redistributions in binary form must reproduce the above copyright
|
||||
|
// notice, this list of conditions and the following disclaimer in the
|
||||
|
// documentation and/or other materials provided with the distribution.
|
||||
|
//
|
||||
|
// 3. The end-user documentation included with the redistribution, if
|
||||
|
// any, must include the following acknowledgment:
|
||||
|
//
|
||||
|
// "This product includes software developed by Jon Skeet
|
||||
|
// and Marc Gravell. Contact skeet@pobox.com, or see
|
||||
|
// http://www.pobox.com/~skeet/)."
|
||||
|
//
|
||||
|
// Alternately, this acknowledgment may appear in the software itself,
|
||||
|
// if and wherever such third-party acknowledgments normally appear.
|
||||
|
//
|
||||
|
// 4. The name "Miscellaneous Utility Library" must not be used to endorse
|
||||
|
// or promote products derived from this software without prior written
|
||||
|
// permission. For written permission, please contact skeet@pobox.com.
|
||||
|
//
|
||||
|
// 5. Products derived from this software may not be called
|
||||
|
// "Miscellaneous Utility Library", nor may "Miscellaneous Utility Library"
|
||||
|
// appear in their name, without prior written permission of Jon Skeet.
|
||||
|
//
|
||||
|
// THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
|
||||
|
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
|
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
|
// IN NO EVENT SHALL JON SKEET BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
|
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
|
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
|
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
|
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
|
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
|
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
|
// POSSIBILITY OF SUCH DAMAGE.
|
||||
|
|
||||
|
using System; |
||||
|
using System.Linq.Expressions; |
||||
|
|
||||
|
namespace MathNet.Numerics.UnitTests |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// The Operator class provides easy access to the standard operators
|
||||
|
/// (addition, etc) for generic types, using type inference to simplify
|
||||
|
/// usage.
|
||||
|
/// </summary>
|
||||
|
internal static class Operator |
||||
|
{ |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Indicates if the supplied value is non-null,
|
||||
|
/// for reference-types or Nullable<T>
|
||||
|
/// </summary>
|
||||
|
/// <returns>True for non-null values, else false</returns>
|
||||
|
public static bool HasValue<T>(T value) |
||||
|
{ |
||||
|
return Operator<T>.NullOp.HasValue(value); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Increments the accumulator only
|
||||
|
/// if the value is non-null. If the accumulator
|
||||
|
/// is null, then the accumulator is given the new
|
||||
|
/// value; otherwise the accumulator and value
|
||||
|
/// are added.
|
||||
|
/// </summary>
|
||||
|
/// <param name="accumulator">The current total to be incremented (can be null)</param>
|
||||
|
/// <param name="value">The value to be tested and added to the accumulator</param>
|
||||
|
/// <returns>True if the value is non-null, else false - i.e.
|
||||
|
/// "has the accumulator been updated?"</returns>
|
||||
|
public static bool AddIfNotNull<T>(ref T accumulator, T value) |
||||
|
{ |
||||
|
return Operator<T>.NullOp.AddIfNotNull(ref accumulator, value); |
||||
|
} |
||||
|
|
||||
|
/// <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 Operator<T>.Negate(value); |
||||
|
} |
||||
|
|
||||
|
/// <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 Operator<T>.Not(value); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Evaluates bitwise or (|) 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 Or<T>(T value1, T value2) |
||||
|
{ |
||||
|
return Operator<T>.Or(value1, value2); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Evaluates bitwise and (&) 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 And<T>(T value1, T value2) |
||||
|
{ |
||||
|
return Operator<T>.And(value1, value2); |
||||
|
} |
||||
|
|
||||
|
/// <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 Operator<T>.Xor(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 Operator<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 Operator<T>.Add(value1, value2); |
||||
|
} |
||||
|
|
||||
|
/// <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 Operator<TArg2, TArg1>.Add(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 Operator<T>.Subtract(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 Operator<TArg2, TArg1>.Subtract(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 Operator<T>.Multiply(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 Operator<TArg2, TArg1>.Multiply(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 Operator<T>.Divide(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 Operator<TArg2, TArg1>.Divide(value1, value2); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Evaluates binary equality (==) 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 Equal<T>(T value1, T value2) |
||||
|
{ |
||||
|
return Operator<T>.Equal(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 Operator<T>.NotEqual(value1, value2); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Evaluates binary greater-than (>) 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 GreaterThan<T>(T value1, T value2) |
||||
|
{ |
||||
|
return Operator<T>.GreaterThan(value1, value2); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Evaluates binary less-than (<) 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 LessThan<T>(T value1, T value2) |
||||
|
{ |
||||
|
return Operator<T>.LessThan(value1, value2); |
||||
|
} |
||||
|
|
||||
|
/// <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 Operator<T>.GreaterThanOrEqual(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 Operator<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 Operator<int, T>.Divide(value, divisor); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Provides standard operators (such as addition) that operate over operands of
|
||||
|
/// different types. For operators, the return type is assumed to match the first
|
||||
|
/// operand.
|
||||
|
/// </summary>
|
||||
|
/// <seealso cref="Operator<T>"/>
|
||||
|
/// <seealso cref="Operator"/>
|
||||
|
internal static class Operator<TValue, TResult> |
||||
|
{ |
||||
|
static readonly Func<TValue, TResult> convert; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to convert a value between two types; this delegate 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 Func<TValue, TResult> Convert |
||||
|
{ |
||||
|
get { return convert; } |
||||
|
} |
||||
|
|
||||
|
static Operator() |
||||
|
{ |
||||
|
convert = ExpressionUtil.CreateExpression<TValue, TResult>(body => Expression.Convert(body, typeof (TResult))); |
||||
|
add = ExpressionUtil.CreateExpression<TResult, TValue, TResult>(Expression.Add, true); |
||||
|
subtract = ExpressionUtil.CreateExpression<TResult, TValue, TResult>(Expression.Subtract, true); |
||||
|
multiply = ExpressionUtil.CreateExpression<TResult, TValue, TResult>(Expression.Multiply, true); |
||||
|
divide = ExpressionUtil.CreateExpression<TResult, TValue, TResult>(Expression.Divide, true); |
||||
|
} |
||||
|
|
||||
|
static readonly Func<TResult, TValue, TResult> add, subtract, multiply, divide; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate binary addition (+) for the given types; this delegate 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 Func<TResult, TValue, TResult> Add |
||||
|
{ |
||||
|
get { return add; } |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate binary subtraction (-) for the given types; this delegate 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 Func<TResult, TValue, TResult> Subtract |
||||
|
{ |
||||
|
get { return subtract; } |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate binary multiplication (*) for the given types; this delegate 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 Func<TResult, TValue, TResult> Multiply |
||||
|
{ |
||||
|
get { return multiply; } |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate binary division (/) for the given types; this delegate 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 Func<TResult, TValue, TResult> Divide |
||||
|
{ |
||||
|
get { return divide; } |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Provides standard operators (such as addition) over a single type
|
||||
|
/// </summary>
|
||||
|
/// <seealso cref="Operator"/>
|
||||
|
/// <seealso cref="Operator<TValue,TResult>"/>
|
||||
|
internal static class Operator<T> |
||||
|
{ |
||||
|
static readonly INullOp<T> nullOp; |
||||
|
|
||||
|
internal static INullOp<T> NullOp |
||||
|
{ |
||||
|
get { return nullOp; } |
||||
|
} |
||||
|
|
||||
|
static readonly T zero; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns the zero value for value-types (even full Nullable<TInner>) - or null for reference types
|
||||
|
/// </summary>
|
||||
|
public static T Zero |
||||
|
{ |
||||
|
get { return zero; } |
||||
|
} |
||||
|
|
||||
|
static readonly Func<T, T> negate, not; |
||||
|
static readonly Func<T, T, T> or, and, xor; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate unary negation (-) for the given type; this delegate 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 Func<T, T> Negate |
||||
|
{ |
||||
|
get { return negate; } |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate bitwise not (~) for the given type; this delegate 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 Func<T, T> Not |
||||
|
{ |
||||
|
get { return not; } |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate bitwise or (|) for the given type; this delegate 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 Func<T, T, T> Or |
||||
|
{ |
||||
|
get { return or; } |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate bitwise and (&) for the given type; this delegate 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 Func<T, T, T> And |
||||
|
{ |
||||
|
get { return and; } |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate bitwise xor (^) for the given type; this delegate 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 Func<T, T, T> Xor |
||||
|
{ |
||||
|
get { return xor; } |
||||
|
} |
||||
|
|
||||
|
static readonly Func<T, T, T> add, subtract, multiply, divide; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate binary addition (+) for the given type; this delegate 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 Func<T, T, T> Add |
||||
|
{ |
||||
|
get { return add; } |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate binary subtraction (-) for the given type; this delegate 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 Func<T, T, T> Subtract |
||||
|
{ |
||||
|
get { return subtract; } |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate binary multiplication (*) for the given type; this delegate 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 Func<T, T, T> Multiply |
||||
|
{ |
||||
|
get { return multiply; } |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate binary division (/) for the given type; this delegate 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 Func<T, T, T> Divide |
||||
|
{ |
||||
|
get { return divide; } |
||||
|
} |
||||
|
|
||||
|
|
||||
|
static readonly Func<T, T, bool> equal, notEqual, greaterThan, lessThan, greaterThanOrEqual, lessThanOrEqual; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate binary equality (==) for the given type; this delegate 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 Func<T, T, bool> Equal |
||||
|
{ |
||||
|
get { return equal; } |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate binary inequality (!=) for the given type; this delegate 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 Func<T, T, bool> NotEqual |
||||
|
{ |
||||
|
get { return notEqual; } |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate binary greater-then (>) for the given type; this delegate 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 Func<T, T, bool> GreaterThan |
||||
|
{ |
||||
|
get { return greaterThan; } |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate binary less-than (<) for the given type; this delegate 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 Func<T, T, bool> LessThan |
||||
|
{ |
||||
|
get { return lessThan; } |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate binary greater-than-or-equal (>=) for the given type; this delegate 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 Func<T, T, bool> GreaterThanOrEqual |
||||
|
{ |
||||
|
get { return greaterThanOrEqual; } |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a delegate to evaluate binary less-than-or-equal (<=) for the given type; this delegate 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 Func<T, T, bool> LessThanOrEqual |
||||
|
{ |
||||
|
get { return lessThanOrEqual; } |
||||
|
} |
||||
|
|
||||
|
static Operator() |
||||
|
{ |
||||
|
add = ExpressionUtil.CreateExpression<T, T, T>(Expression.Add); |
||||
|
subtract = ExpressionUtil.CreateExpression<T, T, T>(Expression.Subtract); |
||||
|
divide = ExpressionUtil.CreateExpression<T, T, T>(Expression.Divide); |
||||
|
multiply = ExpressionUtil.CreateExpression<T, T, T>(Expression.Multiply); |
||||
|
|
||||
|
greaterThan = ExpressionUtil.CreateExpression<T, T, bool>(Expression.GreaterThan); |
||||
|
greaterThanOrEqual = ExpressionUtil.CreateExpression<T, T, bool>(Expression.GreaterThanOrEqual); |
||||
|
lessThan = ExpressionUtil.CreateExpression<T, T, bool>(Expression.LessThan); |
||||
|
lessThanOrEqual = ExpressionUtil.CreateExpression<T, T, bool>(Expression.LessThanOrEqual); |
||||
|
equal = ExpressionUtil.CreateExpression<T, T, bool>(Expression.Equal); |
||||
|
notEqual = ExpressionUtil.CreateExpression<T, T, bool>(Expression.NotEqual); |
||||
|
|
||||
|
negate = ExpressionUtil.CreateExpression<T, T>(Expression.Negate); |
||||
|
and = ExpressionUtil.CreateExpression<T, T, T>(Expression.And); |
||||
|
or = ExpressionUtil.CreateExpression<T, T, T>(Expression.Or); |
||||
|
not = ExpressionUtil.CreateExpression<T, T>(Expression.Not); |
||||
|
xor = ExpressionUtil.CreateExpression<T, T, T>(Expression.ExclusiveOr); |
||||
|
|
||||
|
Type typeT = typeof (T); |
||||
|
if (typeT.IsValueType && typeT.IsGenericType && (typeT.GetGenericTypeDefinition() == typeof (Nullable<>))) |
||||
|
{ |
||||
|
// get the *inner* zero (not a null Nullable<TValue>, but default(TValue))
|
||||
|
Type nullType = typeT.GetGenericArguments()[0]; |
||||
|
zero = (T)Activator.CreateInstance(nullType); |
||||
|
nullOp = (INullOp<T>)Activator.CreateInstance( |
||||
|
typeof (StructNullOp<>).MakeGenericType(nullType)); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
zero = default(T); |
||||
|
if (typeT.IsValueType) |
||||
|
{ |
||||
|
nullOp = (INullOp<T>)Activator.CreateInstance( |
||||
|
typeof (StructNullOp<>).MakeGenericType(typeT)); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
nullOp = (INullOp<T>)Activator.CreateInstance( |
||||
|
typeof (ClassNullOp<>).MakeGenericType(typeT)); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// General purpose Expression utilities
|
||||
|
/// </summary>
|
||||
|
internal static class ExpressionUtil |
||||
|
{ |
||||
|
/// <summary>
|
||||
|
/// Create a function delegate representing a unary operation
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TArg1">The parameter type</typeparam>
|
||||
|
/// <typeparam name="TResult">The return type</typeparam>
|
||||
|
/// <param name="body">Body factory</param>
|
||||
|
/// <returns>Compiled function delegate</returns>
|
||||
|
public static Func<TArg1, TResult> CreateExpression<TArg1, TResult>( |
||||
|
Func<Expression, UnaryExpression> body) |
||||
|
{ |
||||
|
ParameterExpression inp = Expression.Parameter(typeof (TArg1), "inp"); |
||||
|
try |
||||
|
{ |
||||
|
return Expression.Lambda<Func<TArg1, TResult>>(body(inp), inp).Compile(); |
||||
|
} |
||||
|
catch (Exception ex) |
||||
|
{ |
||||
|
string msg = ex.Message; // avoid capture of ex itself
|
||||
|
return delegate { throw new InvalidOperationException(msg); }; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Create a function delegate representing a binary operation
|
||||
|
/// </summary>
|
||||
|
/// <typeparam name="TArg1">The first parameter type</typeparam>
|
||||
|
/// <typeparam name="TArg2">The second parameter type</typeparam>
|
||||
|
/// <typeparam name="TResult">The return type</typeparam>
|
||||
|
/// <param name="body">Body factory</param>
|
||||
|
/// <returns>Compiled function delegate</returns>
|
||||
|
public static Func<TArg1, TArg2, TResult> CreateExpression<TArg1, TArg2, TResult>( |
||||
|
Func<Expression, Expression, BinaryExpression> body) |
||||
|
{ |
||||
|
return CreateExpression<TArg1, TArg2, TResult>(body, false); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Create a function delegate representing a binary operation
|
||||
|
/// </summary>
|
||||
|
/// <param name="castArgsToResultOnFailure">
|
||||
|
/// If no matching operation is possible, attempt to convert
|
||||
|
/// TArg1 and TArg2 to TResult for a match? For example, there is no
|
||||
|
/// "decimal operator /(decimal, int)", but by converting TArg2 (int) to
|
||||
|
/// TResult (decimal) a match is found.
|
||||
|
/// </param>
|
||||
|
/// <typeparam name="TArg1">The first parameter type</typeparam>
|
||||
|
/// <typeparam name="TArg2">The second parameter type</typeparam>
|
||||
|
/// <typeparam name="TResult">The return type</typeparam>
|
||||
|
/// <param name="body">Body factory</param>
|
||||
|
/// <returns>Compiled function delegate</returns>
|
||||
|
public static Func<TArg1, TArg2, TResult> CreateExpression<TArg1, TArg2, TResult>( |
||||
|
Func<Expression, Expression, BinaryExpression> body, bool castArgsToResultOnFailure) |
||||
|
{ |
||||
|
ParameterExpression lhs = Expression.Parameter(typeof (TArg1), "lhs"); |
||||
|
ParameterExpression rhs = Expression.Parameter(typeof (TArg2), "rhs"); |
||||
|
try |
||||
|
{ |
||||
|
try |
||||
|
{ |
||||
|
return Expression.Lambda<Func<TArg1, TArg2, TResult>>(body(lhs, rhs), lhs, rhs).Compile(); |
||||
|
} |
||||
|
catch (InvalidOperationException) |
||||
|
{ |
||||
|
if (castArgsToResultOnFailure && !( // if we show retry
|
||||
|
typeof (TArg1) == typeof (TResult) && // and the args aren't
|
||||
|
typeof (TArg2) == typeof (TResult))) |
||||
|
{ |
||||
|
// already "TValue, TValue, TValue"...
|
||||
|
// convert both lhs and rhs to TResult (as appropriate)
|
||||
|
Expression castLhs = typeof (TArg1) == typeof (TResult) ? |
||||
|
(Expression)lhs : |
||||
|
(Expression)Expression.Convert(lhs, typeof (TResult)); |
||||
|
Expression castRhs = typeof (TArg2) == typeof (TResult) ? |
||||
|
(Expression)rhs : |
||||
|
(Expression)Expression.Convert(rhs, typeof (TResult)); |
||||
|
|
||||
|
return Expression.Lambda<Func<TArg1, TArg2, TResult>>( |
||||
|
body(castLhs, castRhs), lhs, rhs).Compile(); |
||||
|
} |
||||
|
else throw; |
||||
|
} |
||||
|
} |
||||
|
catch (Exception ex) |
||||
|
{ |
||||
|
string msg = ex.Message; // avoid capture of ex itself
|
||||
|
return delegate { throw new InvalidOperationException(msg); }; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
internal interface INullOp<T> |
||||
|
{ |
||||
|
bool HasValue(T value); |
||||
|
bool AddIfNotNull(ref T accumulator, T value); |
||||
|
} |
||||
|
|
||||
|
internal sealed class StructNullOp<T> |
||||
|
: INullOp<T>, INullOp<T?> |
||||
|
where T : struct |
||||
|
{ |
||||
|
public bool HasValue(T value) |
||||
|
{ |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
public bool AddIfNotNull(ref T accumulator, T value) |
||||
|
{ |
||||
|
accumulator = Operator<T>.Add(accumulator, value); |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
public bool HasValue(T? value) |
||||
|
{ |
||||
|
return value.HasValue; |
||||
|
} |
||||
|
|
||||
|
public bool AddIfNotNull(ref T? accumulator, T? value) |
||||
|
{ |
||||
|
if (value.HasValue) |
||||
|
{ |
||||
|
accumulator = accumulator.HasValue ? |
||||
|
Operator<T>.Add( |
||||
|
accumulator.GetValueOrDefault(), |
||||
|
value.GetValueOrDefault()) |
||||
|
: value; |
||||
|
return true; |
||||
|
} |
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
internal sealed class ClassNullOp<T> |
||||
|
: INullOp<T> |
||||
|
where T : class |
||||
|
{ |
||||
|
public bool HasValue(T value) |
||||
|
{ |
||||
|
return value != null; |
||||
|
} |
||||
|
|
||||
|
public bool AddIfNotNull(ref T accumulator, T value) |
||||
|
{ |
||||
|
if (value != null) |
||||
|
{ |
||||
|
accumulator = accumulator == null ? |
||||
|
value : Operator<T>.Add(accumulator, value); |
||||
|
return true; |
||||
|
} |
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
Loading…
Reference in new issue