public void GenerateDouble(ILGenerator generator, FunctionSet set, FunctionParams pars) { // We check constants. double s1, s2; if (src2.HasConstantValue(set, pars, out s2)) { if (src1.HasConstantValue(set, pars, out s1)) { generator.Emit(OpCodes.Ldc_R8, s1 / s2); return; } else { // Because division sucks, we convert it to multiplication. double inv_s2 = 1.0 / s2; src1.GenerateDouble(generator, set, pars); generator.Emit(OpCodes.Ldc_R8, inv_s2); generator.Emit(OpCodes.Mul); return; } } src1.GenerateDouble(generator, set, pars); src2.GenerateDouble(generator, set, pars); // We just generate add. generator.Emit(OpCodes.Div); }
public bool HasConstantValue(FunctionSet set, FunctionParams pars, out double val) { double s1, s2; if (src1.HasConstantValue(set, pars, out s1)) { if (src2.HasConstantValue(set, pars, out s2)) { val = s1 * s2; return(true); } // We check if src is 0.0. if (s1 == 0.0) { val = 0.0; return(true); } } // Src2 may be 0.0. if (src2.HasConstantValue(set, pars, out s2)) { if (s2 == 0.0) { val = 0.0; return(true); } } val = 0.0; return(false); }
public bool HasConstantValue(FunctionSet set, FunctionParams pars, out double val) { double s1, s2; if (src1.HasConstantValue(set, pars, out s1)) { if (src2.HasConstantValue(set, pars, out s2)) { val = global::System.Math.Pow(s1, s2); return(true); } // Anything 1.0^x is 1.0. if (s1 == 1.0) { val = 1.0; return(true); } } if (src2.HasConstantValue(set, pars, out s2)) { // Anything x^0.0 is 1.0 (except 0.0^0.0 what is not defined ...). if (s2 == 0.0) { val = 1.0; return(true); } } val = 0.0; return(false); }
/// <summary> /// Obtains floating point function (64-bit). If expression is in vector form, /// this will return the function defined for x. /// </summary> /// <param name="m">The module we should append this delegate to.</param> /// <param name="set">The function set, use null or FunctionSet.Default if you do not /// want anything specific.</param> /// <param name="pars">The parameters, cannot be null.</param> public Function4d GetFunction4d([NotNull] FunctionParams pars, FunctionSet set, [NotNull] Module m) { if (pars.Creator != this) { throw new ArgumentException("Parameters not generated by expression."); } if (!pars.IsDefined) { throw new ArgumentException("The parameters for the function are not defined fully."); } if (pars.VariableCount > 4) { throw new ArgumentException("Too many variables are used for 4D function."); } lock (root) { if (set == null) { set = FunctionSet.Default; } // We define method. DynamicMethod method = new DynamicMethod(name + "4d", typeof(double), new Type[] { typeof(double), typeof(double), typeof(double), typeof(double) }, m); // We emit body. ILGenerator g = method.GetILGenerator(); root.GenerateDouble(g, set, pars); g.Emit(OpCodes.Ret); // We create delegate. return((Function4d)method.CreateDelegate(typeof(Function4d))); } }
public bool CheckRestrictions(SimplexPlanningParams param, FunctionParams funcParam) { bool breakFlag = true; //ищем минимальное значение, после подсчётов матрицы в функции funcParam.MinFilling = param.indexOfRestrictions.Select(v => v.Value.Filling).Min(); funcParam.MaxForce = param.indexOfRestrictions.Select(v => v.Value.Force).Max(); double countOfGoodNodes = param.indexOfRestrictions.Where(v => v.Value.Filling >= 95).Count(); if (param.arrayStatus == false && countOfGoodNodes < 2 && funcParam.MinFilling < 95) { MessageBox.Show("Choose another starting point!"); breakFlag = false; } if (funcParam.MinFilling >= 95) { funcParam.Index = param.indexOfRestrictions.Where(v => v.Value.Force == funcParam.MaxForce).Select(k => k.Key).FirstOrDefault(); funcParam.IndexFilling = param.indexOfRestrictions.Where(v => v.Value.Force == funcParam.MaxForce).Select(v => v.Value.Filling).FirstOrDefault(); funcParam.IndexForce = param.indexOfRestrictions.Where(v => v.Value.Force == funcParam.MaxForce).Select(v => v.Value.Force).FirstOrDefault(); } if (funcParam.MinFilling < 95) { funcParam.Index = param.indexOfRestrictions.Where(v => v.Value.Filling == funcParam.MinFilling).Select(k => k.Key).FirstOrDefault(); funcParam.IndexFilling = param.indexOfRestrictions.Where(v => v.Value.Filling == funcParam.MinFilling).Select(v => v.Value.Filling).FirstOrDefault(); funcParam.IndexForce = param.indexOfRestrictions.Where(v => v.Value.Filling == funcParam.MinFilling).Select(v => v.Value.Force).FirstOrDefault(); } return(breakFlag); }
public void FNull_should_create_another_function_with_defaults_passing_one_parameter_for_X_arg() { var hello = new FunctionParams <object, object, object, object, object>((x, y, z, rest) => funclib.Core.Apply(new Str(), "Hello", " ", x, " ", y, " ", z, " ", rest)); var defaults = (FNull.Function)funclib.Core.FNull(hello, "David"); Assert.AreEqual("Hello John Black Smith 123", defaults.Invoke("John", "Black", "Smith", 1, 2, 3)); Assert.AreEqual("Hello David Black Smith 123", defaults.Invoke(null, "Black", "Smith", 1, 2, 3)); Assert.Throws <ArityException>(() => defaults.Invoke(1)); Assert.Throws <ArityException>(() => defaults.Invoke(1, 2)); Assert.Throws <ArityException>(() => defaults.Invoke(1, 2, 3)); }
public bool HasConstantValue(FunctionSet set, FunctionParams pars, out double val) { double s1, s2; if (src2.HasConstantValue(set, pars, out s2) && src1.HasConstantValue(set, pars, out s1)) { val = s1 / s2; return(true); } val = 0.0; return(false); }
public bool HasConstantValue(FunctionSet set, FunctionParams pars, out double val) { // We have constant value if and only if subelement is constant. double[] v = new double[arguments.Length]; int index = 0; foreach (IElement el in arguments) { if (el.HasConstantValue(set, pars, out v[index])) { continue; } val = 0.0; return(false); } // We find delegate Delegate s = null; switch (arguments.Length) { case 1: s = set.Findd(Name); break; case 2: s = set.Find2d(Name); break; case 3: s = set.Find3d(Name); break; case 4: s = set.Find4d(Name); break; default: throw new InvalidMathExpression("Trying to call method with more then 4 arguments, unsuported."); } if (s == null) { throw new InvalidMathExpression("We cannot compile expression because the function " + Name + " does not exist in set."); } // We execute it. val = (double)s.DynamicInvoke(v[0]); return(true); }
public void Reduce_should_be_able_to_reimplement_map() { var remap = new FunctionParams <object, object, object>((f, c) => { var inter = funclib.Core.Apply(new Interleave(), c); var neuesc = new Partition().Invoke(funclib.Core.Count(c), inter); return(funclib.Core.Reduce(new Function <object, object, object>((s, k) => funclib.Core.Conj(s, funclib.Core.Apply(f, k))), funclib.Core.Vector(), neuesc)); }); var expected = funclib.Core.Vector(0.0, 0.2, 0.6); var actual = remap.Invoke(new Multiply(), funclib.Core.Vector(0.1, 0.2, 0.3), funclib.Core.Range()); Assert.AreEqual(expected, actual); }
public void GenerateDouble(ILGenerator generator, FunctionSet set, FunctionParams pars) { // We check if we have const value expression. double constValue; if (HasConstantValue(set, pars, out constValue)) { generator.Emit(OpCodes.Ldc_R8, constValue); return; } foreach (IElement el in arguments) { el.GenerateDouble(generator, set, pars); } // We perform the call of this function. The function is prototyped // float F(float x). Delegate s = null; switch (arguments.Length) { case 1: s = set.Findd(Name); break; case 2: s = set.Find2d(Name); break; case 3: s = set.Find3d(Name); break; case 4: s = set.Find4d(Name); break; default: throw new InvalidMathExpression("Trying to call method with more then 4 arguments, unsuported."); } if (s == null) { throw new InvalidMathExpression("We cannot compile expression because the function " + Name + " does not exist in set."); } // Call the method with argument. generator.EmitCall(OpCodes.Call, s.Method, null); }
public void GenerateDouble(ILGenerator generator, FunctionSet set, FunctionParams pars) { double val; if (HasConstantValue(set, pars, out val)) { generator.Emit(OpCodes.Ldc_R8, val); return; } src1.GenerateDouble(generator, set, pars); src2.GenerateDouble(generator, set, pars); // We just generate add. generator.Emit(OpCodes.Mul); }
public void GenerateDouble(ILGenerator generator, FunctionSet set, FunctionParams pars) { if (isNumeric) { // We push argument on stack. generator.Emit(OpCodes.Ldc_R8, numericValue); } else { // Check for binding. if (pars.HasBinding(value)) { VariableBinding binding; pars.GetBinding(value, out binding); switch (binding.Position) { case 0: generator.Emit(OpCodes.Ldarg_0); break; case 1: generator.Emit(OpCodes.Ldarg_1); break; case 2: generator.Emit(OpCodes.Ldarg_2); break; case 3: generator.Emit(OpCodes.Ldarg_3); break; default: throw new InvalidMathExpression("Trying non-used position."); } } else { // Must succeed. double v = pars[value]; generator.Emit(OpCodes.Ldc_R8, v); } } }
public void GenerateDouble(ILGenerator generator, FunctionSet set, FunctionParams pars) { double val; if (HasConstantValue(set, pars, out val)) { generator.Emit(OpCodes.Ldc_R8, val); return; } // We must make sure all params are in double form! src1.GenerateDouble(generator, set, pars); src2.GenerateDouble(generator, set, pars); // We generate the call on those two params. PowDelegate pow = global::System.Math.Pow; generator.EmitCall(OpCodes.Call, pow.Method, null); }
public bool HasConstantValue(FunctionSet set, FunctionParams pars, out double val) { if (isNumeric) { val = numericValue; return(true); } // Parameters (not variables) are also constants. if (pars.HasBinding(value)) { val = 0.0; return(false); } else { val = pars[value]; return(true); } }
/// <summary> /// Evaluates constant expression /// </summary> /// <returns></returns> public double Evalf([NotNull] FunctionParams pars, FunctionSet set, Module m) { if (pars.Creator != this) { throw new ArgumentException("Parameters not generated by expression."); } if (!pars.IsDefined) { throw new ArgumentException("The parameters for the function are not defined fully."); } if (pars.VariableCount > 0) { throw new ArgumentException("Too many variables are used for constant function."); } lock (root) { if (set == null) { set = FunctionSet.Default; } if (pars == null) { throw new ArgumentNullException("The parameters of function are null."); } // We define method. DynamicMethod method = new DynamicMethod(name + "f", typeof(float), new Type[] { }, m); // We emit body. ILGenerator g = method.GetILGenerator(); root.GenerateSingle(g, set, pars); g.Emit(OpCodes.Ret); // We create delegate. return(((ConstFunctionf)method.CreateDelegate(typeof(ConstFunctionf)))()); } }
public SalariosMinimos_ZonaC(FunctionParams functionParams) { _functionParams = functionParams; }
public SalariosMinimos_ZonaC(FunctionParams functionParams, double x) { _functionParams = functionParams; _x = x; }
public IncidenciaAnteriorHE1Function(FunctionParams functionParams) { _functionParams = functionParams; }
public DeduccionPrestamoEmpresaPorcentajeFunction(FunctionParams functionParams) { _functionParams = functionParams; }
public TopesSGDF_Cesantia_y_vejez_6Function(FunctionParams functionParams, double x) { _functionParams = functionParams; _x = x; }
public TopesSGDF_Cesantia_y_vejez_6Function(FunctionParams functionParams) { _functionParams = functionParams; }
public DiasInfonavitPorcentajeVigenteFunction(FunctionParams functionParams) { _functionParams = functionParams; }
public FRACFunction(FunctionParams functionParams) { _functionParams = functionParams; }
public DiasLFTSinSeptimoAnteriorFunction(FunctionParams functionParams) { _functionParams = functionParams; }
public IncidenciaVigenteHE3Function(FunctionParams functionParams) { _functionParams = functionParams; }
public PercepcionIncentivosDemorasTotalFunction(FunctionParams functionParams) { _functionParams = functionParams; }
public FRACFunction(FunctionParams functionParams, double x) { _functionParams = functionParams; _x = x; }
public OpcionDiasPeriodoFunction(FunctionParams functionParams) { _functionParams = functionParams; }
public AcumuladoMesISRRetenidoMesFunction(FunctionParams functionParams) { _functionParams = functionParams; }
public DiasIMSSVigenteFunction(FunctionParams functionParams, double x) { _functionParams = functionParams; _x = x; }