|
static private Invoke ( |
||
| expression |
/// An |
|
| return | ||
/// <summary>
/// Creates an expression that defines a logical AND function
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns></returns>
public static Expression <Func <T, bool> > And <T>(this Expression <Func <T, bool> > left, Expression <Func <T, bool> > right)
{
var invokedExpr = XPR.Invoke(right, left.Parameters.Cast <XPR>());
return(XPR.Lambda <Func <T, bool> >
(XPR.AndAlso(left.Body, invokedExpr), left.Parameters));
}
static LambdaExpression EmptyWrapper(LambdaExpression functionLambda)
{
// We do the following transformation
// arg => arg
// to
// arg => (arg => arg)(arg)
// public static string dnaParameterConvertTest(string optTest) { ... };
//
// to
// (optTest) => dnaParameterConvertTest(optTest)
//// public static string dnaParameterConvertTest(string optTest)
//// {
//// return dnaParameterConvertTest(optTest);
//// };
var newParams = functionLambda.Parameters.Select(p => Expression.Parameter(p.Type, p.Name)).ToList();
var call = Expr.Invoke(functionLambda, newParams);
return(Expr.Lambda(call, functionLambda.Name, newParams));
//// build up the invoke expression for each parameter
//var wrappingParameters = new List<ParameterExpression>(functionLambda.Parameters);
//var paramExprs = functionLambda.Parameters.Select((param, i) =>
//{
// // Starting point is just the parameter expression
// Expression wrappedExpr = param;
// return wrappedExpr;
//}).ToArray();
//var wrappingCall = Expr.Invoke(functionLambda, paramExprs);
//return Expr.Lambda(wrappingCall, functionLambda.Name, wrappingParameters);
}
/// <summary>
/// Creates an expression tha defines an equality comparison
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
/// <returns></returns>
public static Expression <Func <bool> > Equal <X>(this Expression <Func <X> > left, Expression <Func <X> > right)
{
var lValue = XPR.Invoke(left);
var rValue = XPR.Invoke(right);
return(XPR.Lambda <Func <bool> >(XPR.Equal(lValue, rValue)));
}
public static Expression <Func <T, bool> > And <T>(this Expression <Func <T, bool> > expr1,
Expression <Func <T, bool> > expr2)
{
var invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast <Expression>());
return(Expression.Lambda <Func <T, bool> >
(Expression.AndAlso(expr1.Body, invokedExpr), expr1.Parameters));
}
static Expr InvokeExpression(DynamicMetaObject target, IEnumerable <Expr> mappedArgs, MethodInfo methodInfo)
{
var invokeExpr = Expr.Invoke(
Expr.Convert(target.Expression, target.LimitType),
mappedArgs);
if (methodInfo.ReturnType == typeof(void))
{
return(Expr.Block(invokeExpr, Expr.Default(typeof(object))));
}
return(Expr.Convert(invokeExpr, typeof(object)));
}
void ConvertArgumentToParamType(List <Argument> arguments, ParameterInfo[] parameters, out Expr failExpr)
{
failExpr = null;
for (int i = 0; i < arguments.Count; i++)
{
var arg = arguments[i];
var param = parameters[i];
if (param.ParameterType == typeof(bool) && arg.Type != typeof(bool))
{
arg.Expression = ExprHelpers.ConvertToBoolean(context, arg.Expression);
}
else if (param.ParameterType == typeof(double) && arg.Type == typeof(string))
{
arg.Expression = ExprHelpers.ConvertToNumberAndCheck(
context, arg.Expression,
ExceptionMessage.INVOKE_BAD_ARGUMENT_GOT, i + 1, "number", "string");
}
else if (param.ParameterType == typeof(string) && arg.Type != typeof(string))
{
arg.Expression = Expr.Call(arg.Expression, MemberInfos.ObjectToString, arg.Expression);
}
else
{
if (arg.Type == param.ParameterType || arg.Type.IsSubclassOf(param.ParameterType))
{
arg.Expression = Expr.Convert(arg.Expression, param.ParameterType);
}
else
{
Func <Expr, Expr> typeNameExpr =
obj => Expr.Invoke(
Expr.Constant((Func <object, string>)BaseLibrary.Type),
Expr.Convert(obj, typeof(object)));
// Ugly reflection hack
failExpr = Expr.Throw(
Expr.New(
MemberInfos.NewRuntimeException,
Expr.Constant(ExceptionMessage.INVOKE_BAD_ARGUMENT_GOT),
Expr.NewArrayInit(
typeof(object),
Expr.Constant(i + 1, typeof(object)),
typeNameExpr(Expr.Constant(Activator.CreateInstance(param.ParameterType))),
typeNameExpr(arg.Expression))));
break;
}
}
}
}
public static IEnumerable<Book> GetResults(Expression<Func<Book, bool>> criteria)
{
IQueryable<Book> db = new[] {
new Book { Title = "War and Peace", Author = "Leo Tolstoy"},
new Book { Title = "Hunger", Author = "Knut Hamsun" },
new Book { Title = "Embers", Author = "Sandor Marai" }
}.AsQueryable();
var query = from book in db.AsExpandable()
where criteria.Invoke(book)
select book;
return query;
}
public override Expression Compile(ParameterExpression stateParameterExpression, LabelTarget returnTarget)
{
switch (this.Op)
{
case "-":
return
(Expr.Invoke(
(Expression <Func <object, object> >)
(x => x is float? - (float)x: LogicBuiltins.Negate(new List <object> {
x
})),
Expr.Convert(this.Expression.Compile(stateParameterExpression, returnTarget), typeof(object))));
default:
throw new InvalidOperationException();
}
}
private InvocationExpression InvocationExpression(
ExpressionType nodeType, Type type, JObject obj)
{
var expression = Prop(obj, "expression", Expression);
var arguments = Prop(obj, "arguments", Enumerable(Expression));
switch (nodeType)
{
case ExpressionType.Invoke:
if (arguments == null)
{
return(Expr.Invoke(expression));
}
return(Expr.Invoke(expression, arguments));
default:
throw new NotSupportedException();
}
}
public LambdaExpression CreateLambda(Type from, Type to)
{
var input = Ex.Parameter(from, "input");
var type = Ex.Parameter(typeof(Type), "type");
var block =
Ex.Condition(
Ex.MakeBinary(Et.Equal, input, Ex.Default(typeof(object))),
NoResult(to),
Ex.Block(new[] { type },
Ex.Assign(type, Ex.Call(input, typeof(object).GetTypeInfo().GetDeclaredMethod(nameof(object.GetType)))),
Ex.Convert(Ex.Invoke(
Ex.Call(Ex.Constant(Ref), nameof(IDataConverter.GetGeneralConverter), Type.EmptyTypes, type, Ex.Constant(to)),
input),
typeof(ConversionResult <>).MakeGenericType(to))));
var lambda = Ex.Lambda(block, input);
return(lambda);
}
static ExpressionBase CreateInvokeExpression(string funcName, IReadOnlyCollection <ExpressionBase> args)
{
var lambda = RegisterDelegates[funcName];
var argTypes = lambda.GetType().GetMethod("Invoke").GetParameters();
if (argTypes.Length == 0 || argTypes[0].GetCustomAttributes(typeof(ParamArrayAttribute), true).Length == 0)
{
if (lambda.Method.GetParameters().Length != args.Count)
{
throw new InvalidOperationException($"函数{funcName}的参数数量不匹配。");
}
}
else
{
args = new[] { ExpressionBase.NewArrayInit(typeof(object), args) };
}
var lambdaExpr = ExpressionBase.Constant(lambda);
return(ExpressionBase.Invoke(lambdaExpr, args));
}
public static Expression Invoke(Expression function, IDictionary <string, Expression> args)
{
if (ReferenceEquals(function, null))
{
throw new ArgumentNullException(nameof(function));
}
if (ReferenceEquals(args, null))
{
throw new ArgumentNullException(nameof(args));
}
var funcArgs = new LinqExpression [args.Count];
var i = 0;
foreach (var param in ((LambdaExpression)function.internalExpression).Parameters)
{
funcArgs [i] = args [param.Name].internalExpression;
i++;
}
return(new Expression(LinqExpression.Invoke(function, funcArgs)));
}
public override Expression Compile(ParameterExpression stateParameterExpression, LabelTarget returnTarget)
{
Expression <Func <LogicStructureInstance, string, LogicField> > lookupField =
(x, z) => x.Fields.Keys.First(y => y.Name == z);
return
(Expr.Property(
Expr.Property(
Expr.Convert(
this.Expression.Compile(stateParameterExpression, returnTarget),
typeof(LogicStructureInstance)),
"Fields"),
"Item",
Expr.Invoke(
lookupField,
Expr.Convert(
this.Expression.Compile(stateParameterExpression, returnTarget),
typeof(LogicStructureInstance)),
Expr.Constant(this.Field))));
}
private Exp MakeStateRedirection(CompilerState state, Node node)
{
if (state == null)
{
throw new Exception();
}
if (node == null)
{
throw new Exception();
}
var data = node.Token.Data as Tokenizing.StateRedirectionData;
if (data == null)
{
throw new Exception();
}
if (node.Children.Count < 1)
{
throw new Exception();
}
var functionargs = MakeRedirectionDescendants(state, node);
var method = FindCorrectRedirectionMethod(data.Type, functionargs);
functionargs.Insert(0, state.FunctionState);
functionargs.Insert(1, state.ErrorVariable);
var callExp = Exp.Call(null, method, functionargs);
var oldState = state.FunctionState;
state.FunctionState = Exp.Parameter(typeof(Character));
var lambdaExp = Exp.Lambda(Make(state, node.Children[node.Children.Count - 1]), state.FunctionState);
state.FunctionState = oldState;
return(Exp.Invoke(lambdaExp, callExp));
}
/// <summary> /// Creates an expression to call a function /// </summary> /// <param name="f">An expression representing the function to invoke</param> /// <param name="args"></param> /// <returns></returns> public static InvocationExpression invoke(XPR f, params XPR[] args) => XPR.Invoke(f, args);
static LambdaExpression ApplyMethodHandler(string functionName, LambdaExpression functionLambda, IFunctionExecutionHandler handler)
{
// public static int MyMethod(object arg0, int arg1) { ... }
// becomes:
// (the 'handler' object is captured and called mh)
// public static int MyMethodWrapped(object arg0, int arg1)
// {
// var fhArgs = new FunctionExecutionArgs("MyMethod", new object[] { arg0, arg1});
// int result = default(int);
// try
// {
// fh.OnEntry(fhArgs);
// if (fhArgs.FlowBehavior == FlowBehavior.Return)
// {
// result = (int)fhArgs.ReturnValue;
// }
// else
// {
// // Inner call
// result = MyMethod(arg0, arg1);
// fhArgs.ReturnValue = result;
// fh.OnSuccess(fhArgs);
// result = (int)fhArgs.ReturnValue;
// }
// }
// catch ( Exception ex )
// {
// fhArgs.Exception = ex;
// fh.OnException(fhArgs);
// // Makes no sense to me yet - I've removed this FlowBehavior enum value.
// // if (fhArgs.FlowBehavior == FlowBehavior.Continue)
// // {
// // // Finally will run, but can't change return value
// // // Should we assign result...?
// // // So Default value will be returned....?????
// // fhArgs.Exception = null;
// // }
// // else
// if (fhArgs.FlowBehavior == FlowBehavior.Return)
// {
// // Clear the Exception and return the ReturnValue instead
// // Finally will run, but can't further change return value
// fhArgs.Exception = null;
// result = (int)fhArgs.ReturnValue;
// }
// else if (fhArgs.FlowBehavior == FlowBehavior.ThrowException)
// {
// throw fhArgs.Exception;
// }
// else // if (fhArgs.FlowBehavior == FlowBehavior.Default || fhArgs.FlowBehavior == FlowBehavior.RethrowException)
// {
// throw;
// }
// }
// finally
// {
// fh.OnExit(fhArgs);
// // NOTE: fhArgs.ReturnValue is not used again here...!
// }
//
// return result;
// }
// }
// CONSIDER: There are some helpers in .NET to capture the exception context, which would allow us to preserve the stack trace in a fresh throw.
// Ensure the handler object is captured.
var mh = Expression.Constant(handler);
var funcName = Expression.Constant(functionName);
// Prepare the functionHandlerArgs that will be threaded through the handler,
// and a bunch of expressions that access various properties on it.
var fhArgs = Expr.Variable(typeof(FunctionExecutionArgs), "fhArgs");
var fhArgsReturnValue = SymbolExtensions.GetProperty(fhArgs, (FunctionExecutionArgs mea) => mea.ReturnValue);
var fhArgsException = SymbolExtensions.GetProperty(fhArgs, (FunctionExecutionArgs mea) => mea.Exception);
var fhArgsFlowBehaviour = SymbolExtensions.GetProperty(fhArgs, (FunctionExecutionArgs mea) => mea.FlowBehavior);
// Set up expressions to call the various handler methods.
// TODO: Later we can determine which of these are actually implemented, and only write out the code needed in the particular case.
var onEntry = Expr.Call(mh, SymbolExtensions.GetMethodInfo <IFunctionExecutionHandler>(meh => meh.OnEntry(null)), fhArgs);
var onSuccess = Expr.Call(mh, SymbolExtensions.GetMethodInfo <IFunctionExecutionHandler>(meh => meh.OnSuccess(null)), fhArgs);
var onException = Expr.Call(mh, SymbolExtensions.GetMethodInfo <IFunctionExecutionHandler>(meh => meh.OnException(null)), fhArgs);
var onExit = Expr.Call(mh, SymbolExtensions.GetMethodInfo <IFunctionExecutionHandler>(meh => meh.OnExit(null)), fhArgs);
// Create the new parameters for the wrapper
var outerParams = functionLambda.Parameters.Select(p => Expr.Parameter(p.Type, p.Name)).ToArray();
// Create the array of parameter values that will be put into the method handler args.
var paramsArray = Expr.NewArrayInit(typeof(object), outerParams.Select(p => Expr.Convert(p, typeof(object))));
// Prepare the result and ex(ception) local variables
var result = Expr.Variable(functionLambda.ReturnType, "result");
var ex = Expression.Parameter(typeof(Exception), "ex");
// A bunch of helper expressions:
// : new FunctionExecutionArgs(new object[] { arg0, arg1 })
var fhArgsConstr = typeof(FunctionExecutionArgs).GetConstructor(new[] { typeof(string), typeof(object[]) });
var newfhArgs = Expr.New(fhArgsConstr, funcName, paramsArray);
// : result = (int)fhArgs.ReturnValue
var resultFromReturnValue = Expr.Assign(result, Expr.Convert(fhArgsReturnValue, functionLambda.ReturnType));
// : fhArgs.ReturnValue = (object)result
var returnValueFromResult = Expr.Assign(fhArgsReturnValue, Expr.Convert(result, typeof(object)));
// : result = function(arg0, arg1)
var resultFromInnerCall = Expr.Assign(result, Expr.Invoke(functionLambda, outerParams));
// Build the Lambda wrapper, with the original parameters
var lambda = Expr.Lambda(
Expr.Block(new[] { fhArgs, result },
Expr.Assign(fhArgs, newfhArgs),
Expr.Assign(result, Expr.Default(result.Type)),
Expr.TryCatchFinally(
Expr.Block(
onEntry,
Expr.IfThenElse(
Expr.Equal(fhArgsFlowBehaviour, Expr.Constant(FlowBehavior.Return)),
resultFromReturnValue,
Expr.Block(
resultFromInnerCall,
returnValueFromResult,
onSuccess,
resultFromReturnValue))),
onExit, // finally
Expr.Catch(ex,
Expr.Block(
Expr.Assign(fhArgsException, ex),
onException,
Expr.IfThenElse(
Expr.Equal(fhArgsFlowBehaviour, Expr.Constant(FlowBehavior.Return)),
Expr.Block(
Expr.Assign(fhArgsException, Expr.Constant(null, typeof(Exception))),
resultFromReturnValue),
Expr.IfThenElse(
Expr.Equal(fhArgsFlowBehaviour, Expr.Constant(FlowBehavior.ThrowException)),
Expr.Throw(fhArgsException),
Expr.Rethrow()))))
),
result),
functionName,
outerParams);
return(lambda);
}
/// <summary>
/// Generate plots for the signal
/// </summary>
/// <param name="queryable"></param>
/// <param name="sampleD"></param>
/// <param name="mvaValue"></param>
private static void PlotMVAResult(IQueryable<JetStream> source, FutureTDirectory dir, Expression<Func<TrainingTree, double>> mvaValue)
{
// Plot the weights. This can be used to plot signal vs background, ROC curves, etc.
var weights = source
.Select(j => TrainingUtils.TrainingTreeConverter.Invoke(j))
.Select(j => Tuple.Create(mvaValue.Invoke(j), j.Weight))
.FuturePlot(TrainingEventWeightFine.NameFormat, TrainingEventWeightFine.TitleFormat, TrainingEventWeightFine, "All")
.Save(dir);
// Next, let plot lots of kinematic plots so we can see what they look like.
var plotsFromJS = new IPlotSpec<JetStream>[]
{
JetPtPlotJetStream,
JetETPlotJetStream,
JetEtaPlotJetStream,
JetLxyPlotJetStream,
JetCalRPlotJetStream,
JetStreamSumPt,
JetStreamMaxPt,
JetCalRPlotFineJetStream,
};
var plots = plotsFromJS
.Select(myp => myp.FromType<JetStream, Tuple<JetStream, double>>(jinfo => jinfo.Item1, weight: jinfo => jinfo.Item2 * jinfo.Item1.Weight));
// We want weighted and unweighted plots here. We first have to normalize the weighting to be from 0 to 1.
// If there is only a single weight in the sample (which is just weird) then correctly make sure we are set to deal
// with things.
var firstNonZeroBinValue = weights.Value.FindNonZeroBinValue();
var lastNonZeroBinValue = weights.Value.FindNonZeroBinValue(HistogramUtils.BinSearchOrder.HighestBin);
if (firstNonZeroBinValue == lastNonZeroBinValue)
{
Console.WriteLine($" Sample has events with all one weight ({firstNonZeroBinValue}).");
}
var scaleing = lastNonZeroBinValue == firstNonZeroBinValue
? 1.0
: 1.0 / (lastNonZeroBinValue - firstNonZeroBinValue);
firstNonZeroBinValue = lastNonZeroBinValue == firstNonZeroBinValue
? firstNonZeroBinValue - 1.0
: firstNonZeroBinValue;
var mvaWeithedJetStream = source
.Select(j => Tuple.Create(j, j.Weight * (mvaValue.Invoke(TrainingUtils.TrainingTreeConverter.Invoke(j)) - firstNonZeroBinValue)*scaleing));
var weithedJetStream = source
.Select(j => Tuple.Create(j, j.Weight));
// And run through each plot
foreach (var p in plots)
{
mvaWeithedJetStream
.FuturePlot(p, "MVA")
.Save(dir);
weithedJetStream
.FuturePlot(p, "")
.Save(dir);
}
}
/// <summary>
/// Builds the childrens iterator.
/// </summary>
/// <param name="rootType">Type of the root.</param>
/// <returns>
/// A function that is able to process childrens from a node
/// </returns>
private static NodeProcessor BuildChildrensIterator(Type rootType)
{
var sourceParameter = LinqExpression.Parameter(typeof(Node), "source");
var explorerParameter = LinqExpression.Parameter(typeof(NodeProcessorContext).MakeByRefType(), "nodeProcessorContext");
var variableNodeProcessor = LinqExpression.Variable(typeof(NodeProcessor), "nodeProcessor");
var variableNodeListProcessor = LinqExpression.Variable(typeof(NodeListProcessor), "listProcessor");
var statements = new List <LinqExpression>();
// Cast source variable
var castVar = LinqExpression.Variable(rootType, "cast");
var variables = new List <ParameterExpression> {
castVar, variableNodeProcessor, variableNodeListProcessor
};
statements.Add(LinqExpression.Assign(castVar, LinqExpression.Convert(sourceParameter, rootType)));
statements.Add(LinqExpression.Assign(variableNodeProcessor, LinqExpression.Field(explorerParameter, nodeProcessorProperty)));
statements.Add(LinqExpression.Assign(variableNodeListProcessor, LinqExpression.Field(explorerParameter, nodeListProcessorProperty)));
// Get all types from most inherited
var types = new List <Type>();
for (var type = rootType; type != null; type = type.GetTypeInfo().BaseType)
{
types.Add(type);
}
types.Reverse();
// Iterate on inherited types
foreach (var type in types)
{
// Iterate on all properties in order to create the iterator.
foreach (var sourceField in type.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic))
{
// If the property is not read-writable or contains a visitor ignore attribute, skip it
if (sourceField.GetCustomAttribute <VisitorIgnoreAttribute>(true) != null)
{
continue;
}
var propertyType = sourceField.FieldType;
var interfaces = propertyType.GetTypeInfo().ImplementedInterfaces;
// Get the property type and check if the property inherit from IList<>
if (!typeof(StatementList).GetTypeInfo().IsAssignableFrom(propertyType.GetTypeInfo()))
{
foreach (var interfaceBase in interfaces)
{
if (interfaceBase.GetTypeInfo().IsGenericType&& interfaceBase.GetTypeInfo().GetGenericTypeDefinition() == typeof(IList <>))
{
var parameterType = interfaceBase.GetTypeInfo().GenericTypeArguments[0];
if (typeof(Node).GetTypeInfo().IsAssignableFrom(parameterType.GetTypeInfo()))
{
statements.Add(
LinqExpression.Invoke(variableNodeListProcessor, LinqExpression.Field(castVar, sourceField), explorerParameter));
}
break;
}
}
}
if (typeof(Node).GetTypeInfo().IsAssignableFrom(propertyType.GetTypeInfo()))
{
statements.Add(
LinqExpression.Assign(
LinqExpression.Field(castVar, sourceField),
LinqExpression.Convert(LinqExpression.Invoke(variableNodeProcessor, LinqExpression.Field(castVar, sourceField), explorerParameter), propertyType)));
}
}
}
// Return source parameter
statements.Add(sourceParameter);
// Lambda body
var block = LinqExpression.Block(variables, statements);
// Create lambda and return a compiled version
var lambda = LinqExpression.Lambda <NodeProcessor>(block, sourceParameter, explorerParameter);
return(lambda.Compile());
}
/// <summary>
/// Another way to formulate the preceding query.
/// </summary>
static void QueryCustomersManualJoin2 (Expression<Func<Purchase, bool>> purchasePredicate)
{
var data = new DemoData ();
// Here we're including the purchasePredicate in the filteredPurchases expression.
// We can combine lambda expressions by calling Invoke() on the variable
// expresssion. The AsExpandable() wrapper then strips out the call to Invoke
// and emits one clean expression:
var query =
from c in data.Customers.AsExpandable ()
let filteredPurchases = data.Purchases.Where (
p => p.CustomerID == c.ID && purchasePredicate.Invoke (p))
where filteredPurchases.Any ()
select new
{
c.Name,
FilteredPurchases =
from p in filteredPurchases
select p.Price
};
foreach (var customerResult in query)
{
Console.WriteLine (customerResult.Name);
foreach (decimal price in customerResult.FilteredPurchases)
Console.WriteLine (" $" + price);
}
}
public override SysExpr ToExpression() => SysExpr.Invoke(Expression.ToExpression(), ArgumentsToExpressions());
// returnsConversion and the entries in paramsConversions may be null.
static void ApplyConversions(ExcelFunctionRegistration reg, List <List <LambdaExpression> > paramsConversions, List <LambdaExpression> returnConversions)
{
// CAREFUL: The parameter transformations are applied in reverse order to how they're identified.
// We do the following transformation
// public static string dnaParameterConvertTest(double? optTest) { };
//
// with conversions convert1 and convert2 taking us from Type1 to double?
//
// to
// public static string dnaParameterConvertTest(Type1 optTest)
// {
// return convertRet2(convertRet1(
// dnaParameterConvertTest(
// paramConvert1(optTest)
// )));
// };
//
// and then with a conversion from object to Type1, resulting in
//
// public static string dnaParameterConvertTest(object optTest)
// {
// return convertRet2(convertRet1(
// dnaParameterConvertTest(
// paramConvert1(paramConvert2(optTest))
// )));
// };
Debug.Assert(reg.FunctionLambda.Parameters.Count == paramsConversions.Count);
// NOTE: To cater for the Range COM type equivalance, we need to distinguish the FunctionLambda's parameter type and the paramConversion ReturnType.
// These need not be the same, but the should at least be equivalent.
// build up the invoke expression for each parameter
var wrappingParameters = reg.FunctionLambda.Parameters.Select(p => Expression.Parameter(p.Type, p.Name)).ToList();
// Build the nested parameter convertion expression.
// Start with the wrapping parameters as they are. Then replace with the nesting of conversions as needed.
var paramExprs = new List <Expression>(wrappingParameters);
for (int i = 0; i < paramsConversions.Count; i++)
{
var paramConversions = paramsConversions[i];
if (paramConversions == null)
{
continue;
}
// If we have a list, there should be at least one conversion in it.
Debug.Assert(paramConversions.Count > 0);
// Update the calling parameter type to be the outer one in the conversion chain.
wrappingParameters[i] = Expr.Parameter(paramConversions.Last().Parameters[0].Type, wrappingParameters[i].Name);
// Start with just the (now updated) outer param which will be the inner-most value in the conversion chain
Expression wrappedExpr = wrappingParameters[i];
// Need to go in reverse for the parameter wrapping
// Need to now build from the inside out
foreach (var conversion in Enumerable.Reverse(paramConversions))
{
wrappedExpr = Expr.Invoke(conversion, wrappedExpr);
}
paramExprs[i] = wrappedExpr;
}
var wrappingCall = Expr.Invoke(reg.FunctionLambda, paramExprs);
if (returnConversions != null)
{
foreach (var conversion in returnConversions)
{
wrappingCall = Expr.Invoke(conversion, wrappingCall);
}
}
reg.FunctionLambda = Expr.Lambda(wrappingCall, reg.FunctionLambda.Name, wrappingParameters);
}
public void ClassSetUp() {
calc = (i => i * 10);
expr = LinqTool.Expr<int, int>(i => calc.Invoke(i) + 4);
func = LinqTool.Func<int, int>(i => calc.Invoke(i) + 2);
}
/// <summary>
/// Do the cut
/// </summary>
/// <param name="effResults"></param>
/// <param name="queryable1"></param>
/// <param name="queryable2"></param>
private static IFutureValue<double> CalcEff(FutureTDirectory effResults, Expression<Func<TrainingData,double>> selection, double threshold, IQueryable<TrainingData> background, IQueryable<TrainingData> signal)
{
background
.Select(t => selection.Invoke(t))
.FuturePlot("b_weight", "Background weight", 50, -1.1, 1.1)
.Save(effResults);
signal
.Select(t => selection.Invoke(t))
.FuturePlot("s_weight", "Signal weight", 50, -1.1, 1.1)
.Save(effResults);
var total_b = background.FutureCount();
var total_s = signal.FutureCount();
var selected_b = background.Where(t => selection.Invoke(t) > threshold).FutureCount();
var selected_s = signal.Where(t => selection.Invoke(t) > threshold).FutureCount();
var eff_b = from tb in total_b from ns in selected_b select (double) ns / (double) tb;
var eff_s = from tb in total_s from ns in selected_s select (double) ns / (double) tb;
//FutureWrite(from eb in eff_b from es in eff_s select $"Signal eff: {es}; Background eff: {eb}");
return eff_s;
}
public static Expression <Func <T, bool> > Or <T>(this Expression <Func <T, bool> > expr1, Expression <Func <T, bool> > expr2)
{
var invokedExpr = Expression.Invoke(expr2, expr1.Parameters);
return(Expression.Lambda <Func <T, bool> >(Expression.Or(expr1.Body, invokedExpr), expr1.Parameters));
}
