/// <summary>
/// Creates a new dot product expression.
/// </summary>
/// <param name="components">The ordered components of the two vectors in the order of first vectors coordinates then second vectors coordinates (ex: x0,y0,x1,y1).</param>
/// <param name="reductionExpressionGenerator">The optional expression generator that can be used to produce reduced expressions.</param>
public DotProductExpression(Expression[] components, IExpressionGenerator reductionExpressionGenerator = null)
: base(reductionExpressionGenerator)
{
if (null == components)
{
throw new ArgumentNullException("components");
}
if (components.Length == 0)
{
throw new ArgumentException("Must have at least 1 component.", "components");
}
if (components.Length % 2 != 0)
{
throw new ArgumentException("Must have an even number of components.", "components");
}
Contract.Requires(Contract.ForAll(components, x => x != null));
Contract.Ensures(Components != null);
Components = components; // TODO: clone?
if (Components.ContainsNull())
{
throw new ArgumentException("All components expressions must be non null.", "components");
}
}
public static Expression BuildConversionCall(this IExpressionGenerator gen, MethodInfo method, Expression input, Type resultType)
{
Contract.Requires(gen != null);
Contract.Requires(method != null);
Contract.Requires(input != null);
var methodParams = method.GetParameters();
if (methodParams.Length > 0)
{
Contract.Assume(methodParams[0] != null);
var paramType = methodParams[0].ParameterType;
if (input.Type != paramType)
{
input = gen.GenerateConversionOrThrow(paramType, input);
}
}
Expression result = method.BuildCallExpression(input);
if (resultType != null && result.Type != resultType)
{
result = gen.GenerateConversionOrThrow(resultType, result);
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="SingleInstanceProvider"/> class.
/// </summary>
/// <param name="type">
/// The type.
/// </param>
/// <param name="generator">
/// The generator.
/// </param>
public SingleInstanceProvider(Type type, IExpressionGenerator generator)
{
this.type = type;
this.generator = generator;
this.instance = new Lazy<object>(this.CreateInstance);
this.expression = new Lazy<Expression>(() => this.generator.GenerateExpression(this.type));
}
/// <summary>
/// Creates a new dot product expression.
/// </summary>
/// <param name="components">The ordered components of the two vectors in the order of first vectors coordinates then second vectors coordinates (ex: x0,y0,x1,y1).</param>
/// <param name="reductionExpressionGenerator">The optional expression generator that can be used to produce reduced expressions.</param>
public DistanceExpression(Expression[] components, IExpressionGenerator reductionExpressionGenerator = null)
: this(new SquaredDistanceExpression(components, reductionExpressionGenerator), reductionExpressionGenerator) {
Contract.Requires(components != null);
Contract.Requires(components.Length != 0);
Contract.Requires(components.Length % 2 == 0);
Contract.Requires(Contract.ForAll(components, x => null != x));
}
[ContractVerification(false)] // TODO: remove when CC bugs are fixed
public FunctionExpressionGenerationRequest(IExpressionGenerator generator, string expressionName, params Expression[] inputs)
{
if (null == generator)
{
throw new ArgumentNullException("generator");
}
if (String.IsNullOrEmpty(expressionName))
{
throw new ArgumentException("Invalid expression name.", "expressionName");
}
if (null == inputs)
{
throw new ArgumentNullException("inputs");
}
if (inputs.Length == 0)
{
throw new ArgumentException("At least one input expression is required.", "inputs");
}
Contract.Requires(Contract.ForAll(inputs, x => x != null));
TopLevelGenerator = generator;
ExpressionName = expressionName;
_inputExpressions = inputs; // TODO: consider a clone
if (_inputExpressions.ContainsNull())
{
throw new ArgumentException("No expressions may not be null", "inputs");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TransientInstanceProvider"/> class.
/// </summary>
/// <param name="type">
/// The type.
/// </param>
/// <param name="expressionGenerator">
/// The expression generator.
/// </param>
public TransientInstanceProvider(Type type, IExpressionGenerator expressionGenerator)
{
this.type = type;
this.generator = expressionGenerator;
this.func = new Lazy<Func<object>>(this.CreateObjectFunc);
this.expression = new Lazy<Expression>(() => this.generator.GenerateExpression(this.type));
}
/// <summary>
/// Creates a new magnitude expression.
/// </summary>
/// <param name="components">The coordinate expressions.</param>
/// <param name="reductionExpressionGenerator">The optional expression generator used for reduction.</param>
public MagnitudeExpression(Expression[] components, IExpressionGenerator reductionExpressionGenerator = null)
: this(new SquaredMagnitudeExpression(components, reductionExpressionGenerator), reductionExpressionGenerator)
{
Contract.Requires(components != null);
Contract.Requires(components.Length != 0);
Contract.Requires(Contract.ForAll(components, x => x != null));
}
public static Expression BuildConversionCall(this IExpressionGenerator gen, MethodInfo method, Type resultType, params Expression[] inputExpressions)
{
Contract.Requires(gen != null);
Contract.Requires(method != null);
Contract.Requires(inputExpressions != null);
Contract.Requires(Contract.ForAll(inputExpressions, x => x != null));
var methodParams = method.GetParameters();
if (methodParams.Length != inputExpressions.Length)
{
throw new ArgumentException(String.Format("{0} input expressions are required.", methodParams.Length));
}
for (int i = 0; i < methodParams.Length; i++)
{
Contract.Assume(methodParams[i] != null);
var paramType = methodParams[i].ParameterType;
var inputExpression = inputExpressions[i];
if (inputExpression.Type != paramType)
{
inputExpressions[i] = gen.GenerateConversionOrThrow(paramType, inputExpression);
}
}
Expression result = method.BuildCallExpression(inputExpressions);
if (resultType != null && result.Type != resultType)
{
result = gen.GenerateConversionOrThrow(resultType, result);
}
return(result);
}
/// <summary>
/// Creates a new dot product expression.
/// </summary>
/// <param name="components">The ordered components of the two vectors in the order of first vectors coordinates then second vectors coordinates (ex: x0,y0,x1,y1).</param>
/// <param name="reductionExpressionGenerator">The optional expression generator that can be used to produce reduced expressions.</param>
public DistanceExpression(Expression[] components, IExpressionGenerator reductionExpressionGenerator = null)
: this(new SquaredDistanceExpression(components, reductionExpressionGenerator), reductionExpressionGenerator)
{
Contract.Requires(components != null);
Contract.Requires(components.Length != 0);
Contract.Requires(components.Length % 2 == 0);
Contract.Requires(Contract.ForAll(components, x => null != x));
}
/// <summary>
/// Creates a new expression request.
/// </summary>
/// <param name="generator">The expression generator to use.</param>
/// <param name="expressionName">The name of the requested expression.</param>
/// <param name="resultType">The desired result type of the expression.</param>
/// <returns>A new expression generation request.</returns>
public static IExpressionGenerationRequest NewRequest(this IExpressionGenerator generator, string expressionName, Type resultType)
{
Contract.Requires(null != generator);
Contract.Requires(!String.IsNullOrEmpty(expressionName));
Contract.Requires(null != resultType);
Contract.Ensures(Contract.Result <IExpressionGenerationRequest>() != null);
return(new ConstantExpressionGenerationRequest(generator, expressionName, resultType));
}
/// <summary>
/// Creates a new reducible expression with the given single parameter.
/// </summary>
/// <param name="unaryParameter">The single input parameter for the expression.</param>
/// <param name="reductionExpressionGenerator">The optional expression generator used for reduction.</param>
protected ReducibleUnaryExpressionBase(
Expression unaryParameter,
IExpressionGenerator reductionExpressionGenerator = null
) : base(reductionExpressionGenerator) {
if (null == unaryParameter) throw new ArgumentNullException("unaryParameter");
Contract.EndContractBlock();
UnaryParameter = unaryParameter;
}
/// <summary>
/// Creates a new conversion expression request.
/// </summary>
/// <param name="generator">The expression generator to use.</param>
/// <param name="resultType">The desired result type of the conversion expression.</param>
/// <param name="input">The input expression to be converted.</param>
/// <returns>A new expression generation request.</returns>
public static IExpressionGenerationRequest NewConversionRequest(this IExpressionGenerator generator, Type resultType, Expression input)
{
Contract.Requires(null != generator);
Contract.Requires(null != resultType);
Contract.Requires(null != input);
Contract.Ensures(Contract.Result <IExpressionGenerationRequest>() != null);
return(new ConversionExpressionRequest(generator, input, resultType));
}
/// <summary>
/// Creates a new expression.
/// </summary>
/// <param name="generator">The expression generator to use.</param>
/// <param name="expressionName">The name of the requested expression.</param>
/// <param name="input">The requested input for the expression.</param>
/// <returns>A new requested expression or null if one could not be generated.</returns>
public static Expression Generate(this IExpressionGenerator generator, string expressionName, Expression input)
{
Contract.Requires(generator != null);
Contract.Requires(!String.IsNullOrEmpty(expressionName));
Contract.Requires(input != null);
var request = NewRequest(generator, expressionName, input);
return(generator.Generate(request));
}
private MagnitudeExpression(SquaredMagnitudeExpression innerExpression, IExpressionGenerator reductionExpressionGenerator = null)
{
if (innerExpression == null)
{
throw new ArgumentNullException("innerExpression");
}
Contract.EndContractBlock();
InnerExpression = innerExpression;
}
/// <summary>
/// Creates a new conversion expression.
/// </summary>
/// <param name="generator">The expression generator to use.</param>
/// <param name="resultType">The desired result type of the expression to convert to.</param>
/// <param name="input">The input expression to convert from.</param>
/// <returns>A new requested conversion expression or null if one could not be generated.</returns>
public static Expression GenerateConversion(this IExpressionGenerator generator, Type resultType, Expression input)
{
Contract.Requires(null != generator);
Contract.Requires(null != resultType);
Contract.Requires(null != input);
var request = NewConversionRequest(generator, resultType, input);
return(generator.Generate(request));
}
/// <summary>
/// Creates a new function expression generation request. This request is for a function that accepts one or more expressions as input.
/// </summary>
/// <param name="generator">The primary generator to be used for the generation of sub expressions.</param>
/// <param name="expressionName">The name of the requested constant.</param>
/// <param name="resultType">The desired type of the constant.</param>
public ConstantExpressionGenerationRequest(IExpressionGenerator generator, string expressionName, Type resultType) {
if (null == generator) throw new ArgumentNullException("generator");
if (String.IsNullOrEmpty(expressionName)) throw new ArgumentException("Invalid expression name.", "expressionName");
if (null == resultType) throw new ArgumentNullException("resultType");
Contract.EndContractBlock();
TopLevelGenerator = generator;
ExpressionName = expressionName;
DesiredResultType = resultType;
}
/// <summary>
/// Creates a new function expression generation request. This request is for a function that accepts one or more expressions as input.
/// </summary>
/// <param name="generator">The primary generator to be used for the generation of sub expressions.</param>
/// <param name="inputExpression">The name of the requested constant.</param>
/// <param name="resultType">The desired type of the constant.</param>
public ConversionExpressionRequest(IExpressionGenerator generator, Expression inputExpression, Type resultType) {
if (null == generator) throw new ArgumentNullException("generator");
if (null == inputExpression) throw new ArgumentNullException("inputExpression");
if (null == resultType) throw new ArgumentNullException("resultType");
Contract.EndContractBlock();
TopLevelGenerator = generator;
InputExpression = inputExpression;
DesiredResultType = resultType;
}
/// <summary>
/// Creates a new expression.
/// </summary>
/// <param name="generator">The expression generator to use.</param>
/// <param name="expressionName">The name of the requested expression.</param>
/// <param name="resultType">The desired result type of the expression.</param>
/// <returns>A new requested expression or null if one could not be generated.</returns>
public static Expression Generate(this IExpressionGenerator generator, string expressionName, Type resultType)
{
Contract.Requires(null != generator);
Contract.Requires(!String.IsNullOrEmpty(expressionName));
Contract.Requires(null != resultType);
var request = NewRequest(generator, expressionName, resultType);
return(generator.Generate(request));
}
private DistanceExpression(SquaredDistanceExpression innerExpression, IExpressionGenerator reductionExpressionGenerator = null)
: base(reductionExpressionGenerator)
{
if (innerExpression == null)
{
throw new ArgumentNullException("innerExpression");
}
Contract.EndContractBlock();
InnerExpression = innerExpression;
}
public Stage(IMode mode)
{
if (mode == null)
{
throw new ArgumentNullException("mode");
}
_mode = mode;
_generator = new ExpressionGenerator(mode);
_questionNumber = _mode.Operand.Random;
}
/// <summary>
/// Creates a new expression request.
/// </summary>
/// <param name="generator">The expression generator to use.</param>
/// <param name="expressionName">The name of the requested expression.</param>
/// <param name="inputExpressions">The requested inputs for the expression.</param>
/// <returns>A new expression generation request.</returns>
public static IExpressionGenerationRequest NewRequest(this IExpressionGenerator generator, string expressionName, params Expression[] inputExpressions)
{
Contract.Requires(null != generator);
Contract.Requires(!String.IsNullOrEmpty(expressionName));
Contract.Requires(null != inputExpressions);
Contract.Requires(inputExpressions.Length != 0);
Contract.Requires(Contract.ForAll(inputExpressions, x => x != null));
Contract.Ensures(Contract.Result <IExpressionGenerationRequest>() != null);
return(new FunctionExpressionGenerationRequest(generator, expressionName, inputExpressions));
}
/// <summary>
/// Creates a new reducible expression with the given left and right parameters.
/// </summary>
/// <param name="leftParameter">The first or left parameter.</param>
/// <param name="rightParameter">The second or right parameter.</param>
/// <param name="reductionExpressionGenerator">The optional expression generator used for reduction.</param>
protected ReducibleBinaryExpressionBase(
Expression leftParameter,
Expression rightParameter,
IExpressionGenerator reductionExpressionGenerator = null
) : base(reductionExpressionGenerator) {
if (null == leftParameter) throw new ArgumentNullException("leftParameter");
if (null == rightParameter) throw new ArgumentNullException("rightParameter");
Contract.EndContractBlock();
LeftParameter = leftParameter;
RightParameter = rightParameter;
}
/// <summary>
/// Creates a new squared magnitude expression.
/// </summary>
/// <param name="components">The coordinate expressions.</param>
/// <param name="reductionExpressionGenerator">The optional expression generator used for reduction.</param>
public SquaredMagnitudeExpression(Expression[] components, IExpressionGenerator reductionExpressionGenerator = null)
: base(reductionExpressionGenerator) {
if (null == components) throw new ArgumentNullException("components");
if (components.Length == 0) throw new ArgumentException("Must have at least 1 component.", "components");
Contract.Requires(Contract.ForAll(components, x => x != null));
Components = components; // TODO: clone?
if (Components.ContainsNull())
throw new ArgumentException("All components expressions must be non null.", "components");
}
/// <summary>
/// Creates a new expression.
/// </summary>
/// <param name="generator">The expression generator to use.</param>
/// <param name="expressionName">The name of the requested expression.</param>
/// <param name="inputExpressions">The requested inputs for the expression.</param>
/// <returns>A new requested expression or null if one could not be generated.</returns>
public static Expression Generate(this IExpressionGenerator generator, string expressionName, params Expression[] inputExpressions)
{
Contract.Requires(null != generator);
Contract.Requires(!String.IsNullOrEmpty(expressionName));
Contract.Requires(null != inputExpressions);
Contract.Requires(inputExpressions.Length != 0);
Contract.Requires(Contract.ForAll(inputExpressions, x => x != null));
var request = NewRequest(generator, expressionName, inputExpressions);
return(generator.Generate(request));
}
public IExpressionGenerator Create(IEnumerable <Type> functionTypeSamples)
{
IExpressionGenerator expressionGenerator = null;
expressionGenerator = new ExpressionGenerator(new ConstantExpressionGenerator(),
new FunctionExpressionGenerator(new FunctionMetadataResolver(new TypeSamplesAndSuffixConventionBasedFunctionNameToMetadataMapFactory(functionTypeSamples,
new FunctionContractProvider())),
new FunctionArgumentExpressionsGenerator(new FunctionArgumentExpressionGenerator(new Lazy <IExpressionGenerator>(() => expressionGenerator)))),
new BatchExpressionGenerator(new Lazy <IExpressionGenerator>(() => expressionGenerator)));
return(expressionGenerator);
}
/// <summary>
/// Initializes a new instance of the <see cref="TypeRegistration"/> class.
/// </summary>
/// <param name="concreteType">
/// The concrete type.
/// </param>
/// <param name="generator">
/// The generator.
/// </param>
/// <param name="providerFactory">
/// The provider factory.
/// </param>
public TypeRegistration(Type concreteType, IExpressionGenerator generator, IInstanceProviderFactory providerFactory)
{
Guard.ArgumentNotNull(concreteType, "concreteType");
Guard.ArgumentNotNull(generator, "generator");
Guard.ArgumentNotNull(providerFactory, "providerFactory");
this.concreteType = concreteType;
this.providerFactory = providerFactory;
this.Generator = generator;
this.provider = new Lazy<IInstanceProvider>(this.CreateProvider);
}
/// <summary>
/// Creates a new dot product expression.
/// </summary>
/// <param name="components">The ordered components of the two vectors in the order of first vectors coordinates then second vectors coordinates (ex: x0,y0,x1,y1).</param>
/// <param name="reductionExpressionGenerator">The optional expression generator that can be used to produce reduced expressions.</param>
public SquaredDistanceExpression(Expression[] components, IExpressionGenerator reductionExpressionGenerator = null)
: base(reductionExpressionGenerator) {
if (null == components) throw new ArgumentNullException("components");
if (components.Length == 0) throw new ArgumentException("Must have at least 1 component.", "components");
if (components.Length % 2 != 0) throw new ArgumentException("Must have an even number of components.", "components");
Contract.Requires(components.All(x => null != x));
Components = components; // TODO: clone?
if (Components.ContainsNull())
throw new ArgumentException("All components expressions must be non null.", "components");
}
/// <summary>
/// Creates a new reducible expression with the given single parameter.
/// </summary>
/// <param name="unaryParameter">The single input parameter for the expression.</param>
/// <param name="reductionExpressionGenerator">The optional expression generator used for reduction.</param>
protected ReducibleUnaryExpressionBase(
Expression unaryParameter,
IExpressionGenerator reductionExpressionGenerator = null
) : base(reductionExpressionGenerator)
{
if (null == unaryParameter)
{
throw new ArgumentNullException("unaryParameter");
}
Contract.EndContractBlock();
UnaryParameter = unaryParameter;
}
/// <summary>
/// Creates a new conversion expression.
/// </summary>
/// <param name="generator">The expression generator to use.</param>
/// <param name="resultType">The desired result type of the expression to convert to.</param>
/// <param name="input">The input expression to convert from.</param>
/// <returns>A new requested conversion expression or null if one could not be generated.</returns>
public static Expression GenerateConversionOrThrow(this IExpressionGenerator generator, Type resultType, Expression input)
{
Contract.Requires(null != generator);
Contract.Requires(null != resultType);
Contract.Requires(null != input);
var request = NewConversionRequest(generator, resultType, input);
var result = generator.Generate(request);
if (result == null)
{
throw InvalidOpConversion(input.Type, resultType);
}
return(result);
}
[ContractVerification(false)] // TODO: remove when CC bugs are fixed
public FunctionExpressionGenerationRequest(IExpressionGenerator generator, string expressionName, params Expression[] inputs) {
if (null == generator) throw new ArgumentNullException("generator");
if (String.IsNullOrEmpty(expressionName)) throw new ArgumentException("Invalid expression name.", "expressionName");
if (null == inputs) throw new ArgumentNullException("inputs");
if (inputs.Length == 0) throw new ArgumentException("At least one input expression is required.", "inputs");
Contract.Requires(Contract.ForAll(inputs, x => x != null));
TopLevelGenerator = generator;
ExpressionName = expressionName;
_inputExpressions = inputs; // TODO: consider a clone
if (_inputExpressions.ContainsNull())
throw new ArgumentException("No expressions may not be null", "inputs");
}
/// <summary>
/// Creates a new basic generic operations implementation using the given expression generator.
/// </summary>
/// <param name="expressionGenerator">The expression generator that will be used to build the generic methods at run-time.</param>
public BasicOperations(IExpressionGenerator expressionGenerator)
{
if (null == expressionGenerator)
{
throw new ArgumentNullException("expressionGenerator");
}
Contract.EndContractBlock();
ExpressionGenerator = expressionGenerator;
Add = BuildBinaryFunc("Add");
Subtract = BuildBinaryFunc("Subtract");
Multiply = BuildBinaryFunc("Multiply");
Divide = BuildBinaryFunc("Divide");
Negate = BuildUnaryFunc("Negate");
Sin = BuildUnaryFunc("Sin");
Cos = BuildUnaryFunc("Cos");
Tan = BuildUnaryFunc("Tan");
Asin = BuildUnaryFunc("Asin");
Acos = BuildUnaryFunc("Acos");
Atan = BuildUnaryFunc("Atan");
Sinh = BuildUnaryFunc("Sinh");
Cosh = BuildUnaryFunc("Cosh");
Tanh = BuildUnaryFunc("Tanh");
Asinh = BuildUnaryFunc("Asinh");
Acosh = BuildUnaryFunc("Acosh");
Atanh = BuildUnaryFunc("Atanh");
Log = BuildUnaryFunc("Log");
Log10 = BuildUnaryFunc("Log10");
Exp = BuildUnaryFunc("Exp");
Abs = BuildUnaryFunc("Abs");
Atan2 = BuildBinaryFunc <ReverseCoordinates, TValue>("Atan2");
Pow = BuildBinaryFunc("Pow");
Ceiling = BuildUnaryFunc("Ceiling");
Floor = BuildUnaryFunc("Floor");
Truncate = BuildUnaryFunc("Truncate");
Min = BuildBinaryFunc("Min");
Max = BuildBinaryFunc("Max");
Equal = BuildBinaryFunc <ComparisonTest, bool>("Equal");
NotEqual = BuildBinaryFunc <ComparisonTest, bool>("NotEqual");
Less = BuildBinaryFunc <ComparisonTest, bool>("Less");
LessOrEqual = BuildBinaryFunc <ComparisonTest, bool>("LessEqual");
Greater = BuildBinaryFunc <ComparisonTest, bool>("Greater");
GreaterOrEqual = BuildBinaryFunc <ComparisonTest, bool>("GreaterOrEqual");
CompareTo = BuildBinaryFunc <Comparison <TValue>, int>("CompareTo");
ToDouble = BuildConversion <TValue, double>();
FromDouble = BuildConversion <double, TValue>();
_zeroValueGenerator = BuildConstant("0");
}
/// <summary>
/// Creates a new expression.
/// </summary>
/// <param name="generator">The expression generator to use.</param>
/// <param name="expressionName">The name of the requested expression.</param>
/// <param name="resultType">The desired result type of the expression.</param>
/// <returns>A new requested expression or null if one could not be generated.</returns>
public static Expression GenerateOrThrow(this IExpressionGenerator generator, string expressionName, Type resultType)
{
Contract.Requires(null != generator);
Contract.Requires(!String.IsNullOrEmpty(expressionName));
Contract.Requires(null != resultType);
Contract.Ensures(Contract.Result <Expression>() != null);
var request = NewRequest(generator, expressionName, resultType);
var result = generator.Generate(request);
if (result == null)
{
throw InvalidOp(expressionName, resultType);
}
return(result);
}
/// <summary>
/// Creates a new vector operation implementation using the given expression generator.
/// </summary>
/// <param name="expressionGenerator">The expression generator which is used to generate expression for the generic operations at run-time.</param>
public VectorOperations(IExpressionGenerator expressionGenerator)
{
if (null == expressionGenerator)
{
throw new ArgumentNullException("expressionGenerator");
}
Contract.EndContractBlock();
ExpressionGenerator = expressionGenerator;
Magnitude2D = CreateCoordinateToValue2D("Magnitude");
SquaredMagnitude2D = CreateCoordinateToValue2D("SquaredMagnitude");
DotProduct2D = CreateTwoCoordinateToValue2D("DotProduct");
PerpendicularDotProduct2D = CreatePerpendicularDotProduct2D();
Distance2D = CreateTwoCoordinateToValue2D("Distance");
DistanceSquared2D = CreateTwoCoordinateToValue2D("SquaredDistance");
}
/// <summary>
/// Creates a new expression.
/// </summary>
/// <param name="generator">The expression generator to use.</param>
/// <param name="expressionName">The name of the requested expression.</param>
/// <param name="inputExpressions">The requested inputs for the expression.</param>
/// <returns>A new requested expression or null if one could not be generated.</returns>
public static Expression GenerateOrThrow(this IExpressionGenerator generator, string expressionName, params Expression[] inputExpressions)
{
Contract.Requires(null != generator);
Contract.Requires(!String.IsNullOrEmpty(expressionName));
Contract.Requires(null != inputExpressions);
Contract.Requires(inputExpressions.Length != 0);
Contract.Requires(Contract.ForAll(inputExpressions, x => x != null));
Contract.Ensures(Contract.Result <Expression>() != null);
var request = NewRequest(generator, expressionName, inputExpressions);
var result = generator.Generate(request);
if (result == null)
{
throw InvalidOp(expressionName, inputExpressions);
}
return(result);
}
/// <summary>
/// Creates a new expression.
/// </summary>
/// <param name="generator">The expression generator to use.</param>
/// <param name="expressionName">The name of the requested expression.</param>
/// <param name="input0">The first input argument.</param>
/// <param name="input1">The second input argument.</param>
/// <returns>A new requested expression or null if one could not be generated.</returns>
public static Expression GenerateOrThrow(this IExpressionGenerator generator, string expressionName, Expression input0, Expression input1)
{
Contract.Requires(null != generator);
Contract.Requires(!String.IsNullOrEmpty(expressionName));
Contract.Requires(input0 != null);
Contract.Requires(input1 != null);
Contract.Ensures(Contract.Result <Expression>() != null);
var inputs = new[] { input0, input1 };
var request = NewRequest(generator, expressionName, inputs);
var result = generator.Generate(request);
if (result == null)
{
throw InvalidOp(expressionName, inputs);
}
return(result);
}
/// <summary>
/// Creates a new reducible expression with the given left and right parameters.
/// </summary>
/// <param name="leftParameter">The first or left parameter.</param>
/// <param name="rightParameter">The second or right parameter.</param>
/// <param name="reductionExpressionGenerator">The optional expression generator used for reduction.</param>
protected ReducibleBinaryExpressionBase(
Expression leftParameter,
Expression rightParameter,
IExpressionGenerator reductionExpressionGenerator = null
) : base(reductionExpressionGenerator)
{
if (null == leftParameter)
{
throw new ArgumentNullException("leftParameter");
}
if (null == rightParameter)
{
throw new ArgumentNullException("rightParameter");
}
Contract.EndContractBlock();
LeftParameter = leftParameter;
RightParameter = rightParameter;
}
/// <summary>
/// Creates a new function expression generation request. This request is for a function that accepts one or more expressions as input.
/// </summary>
/// <param name="generator">The primary generator to be used for the generation of sub expressions.</param>
/// <param name="expressionName">The name of the requested constant.</param>
/// <param name="resultType">The desired type of the constant.</param>
public ConstantExpressionGenerationRequest(IExpressionGenerator generator, string expressionName, Type resultType)
{
if (null == generator)
{
throw new ArgumentNullException("generator");
}
if (String.IsNullOrEmpty(expressionName))
{
throw new ArgumentException("Invalid expression name.", "expressionName");
}
if (null == resultType)
{
throw new ArgumentNullException("resultType");
}
Contract.EndContractBlock();
TopLevelGenerator = generator;
ExpressionName = expressionName;
DesiredResultType = resultType;
}
/// <summary>
/// Creates a new function expression generation request. This request is for a function that accepts one or more expressions as input.
/// </summary>
/// <param name="generator">The primary generator to be used for the generation of sub expressions.</param>
/// <param name="inputExpression">The name of the requested constant.</param>
/// <param name="resultType">The desired type of the constant.</param>
public ConversionExpressionRequest(IExpressionGenerator generator, Expression inputExpression, Type resultType)
{
if (null == generator)
{
throw new ArgumentNullException("generator");
}
if (null == inputExpression)
{
throw new ArgumentNullException("inputExpression");
}
if (null == resultType)
{
throw new ArgumentNullException("resultType");
}
Contract.EndContractBlock();
TopLevelGenerator = generator;
InputExpression = inputExpression;
DesiredResultType = resultType;
}
/// <summary>
/// Creates a new logarithm of the given <paramref name="b">base</paramref>.
/// </summary>
/// <param name="value">The value expression to calculate the logarithm of.</param>
/// <param name="b">The base expression.</param>
/// <param name="generator">The optional expression generator used during reduction.</param>
public LogExpression(Expression value, Expression b, IExpressionGenerator generator = null)
: base(value, b, generator) {
Contract.Requires(value != null);
Contract.Requires(b != null);
}
/// <summary>
/// Creates a new floor expression.
/// </summary>
/// <param name="input">The expression to calculate the floor of.</param>
/// <param name="generator">The optional expression generator used during reduction.</param>
public FloorExpression(Expression input, IExpressionGenerator generator = null)
: base(input, generator) {
Contract.Requires(null != input);
}
/// <summary>
/// Creates a new magnitude expression.
/// </summary>
/// <param name="components">The coordinate expressions.</param>
/// <param name="reductionExpressionGenerator">The optional expression generator used for reduction.</param>
public MagnitudeExpression(Expression[] components, IExpressionGenerator reductionExpressionGenerator = null)
: this(new SquaredMagnitudeExpression(components, reductionExpressionGenerator), reductionExpressionGenerator) {
Contract.Requires(components != null);
Contract.Requires(components.Length != 0);
Contract.Requires(Contract.ForAll(components, x => x != null));
}
private MagnitudeExpression(SquaredMagnitudeExpression innerExpression, IExpressionGenerator reductionExpressionGenerator = null) {
if(innerExpression == null) throw new ArgumentNullException("innerExpression");
Contract.EndContractBlock();
InnerExpression = innerExpression;
}
/// <summary>
/// Implementation of <see cref="IInstanceProviderFactory.CreateProvider"/>
/// </summary>
/// <param name="type">
/// The type.
/// </param>
/// <param name="generator">
/// The generator.
/// </param>
/// <returns>
/// A new <see cref="TransientInstanceProvider"/> for the given type and generator
/// </returns>
public IInstanceProvider CreateProvider(Type type, IExpressionGenerator generator)
{
return new TransientInstanceProvider(type, generator);
}
/// <summary>
/// Creates a new square root expression.
/// </summary>
/// <param name="unaryParameter">The expression to find the square root of.</param>
/// <param name="reductionExpressionGenerator">The optional expression generator used for reduction.</param>
public SquareRootExpression(Expression unaryParameter, IExpressionGenerator reductionExpressionGenerator = null)
: base(unaryParameter, reductionExpressionGenerator)
{
Contract.Requires(null != unaryParameter);
}
private IBatchExpression Act(TokenTree tokenTree, IExpressionGenerator expressionGenerator = null)
{
var generator = new BatchExpressionGenerator(new Lazy <IExpressionGenerator>(() => expressionGenerator));
return(generator.Generate(tokenTree));
}
/// <summary>
/// Creates a new square root expression.
/// </summary>
/// <param name="unaryParameter">The expression to find the square root of.</param>
/// <param name="reductionExpressionGenerator">The optional expression generator used for reduction.</param>
public SquareRootExpression(Expression unaryParameter, IExpressionGenerator reductionExpressionGenerator = null)
: base(unaryParameter, reductionExpressionGenerator) {
Contract.Requires(null != unaryParameter);
}
private DistanceExpression(SquaredDistanceExpression innerExpression, IExpressionGenerator reductionExpressionGenerator = null)
: base(reductionExpressionGenerator) {
if (innerExpression == null) throw new ArgumentNullException("innerExpression");
Contract.EndContractBlock();
InnerExpression = innerExpression;
}
/// <summary>
/// Creates a new maximum value expression.
/// </summary>
/// <param name="left">An expression to use.</param>
/// <param name="right">An expression to use.</param>
/// <param name="generator">/// <inheritdoc/></param>
public MaxExpression(Expression left, Expression right, IExpressionGenerator generator = null)
: base(left, right, generator) {
Contract.Requires(null != left);
Contract.Requires(null != right);
}
public void SetUp()
{
instance = new object();
generator = new ConstantExpressionGenerator(instance);
expression = generator.GenerateExpression(typeof(object));
}
/// <summary>
/// Creates a new absolute value expression.
/// </summary>
/// <param name="input">The expression to find the absolute value of.</param>
/// <param name="generator">The optional expression generator used during reduction.</param>
public AbsExpression(Expression input, IExpressionGenerator generator = null) : base(input, generator)
{
Contract.Requires(null != input);
}
/// <summary>
/// A basic reducible expression.
/// </summary>
/// <param name="reductionExpressionGenerator">The optional expression generator to be used in reduction.</param>
protected ReducibleExpressionBase(IExpressionGenerator reductionExpressionGenerator = null) {
_reductionExpressionGenerator = reductionExpressionGenerator;
}
