public StepFunction(StepFunction <double> steps) { evaluator = steps; abscissae = steps.Pillars; values = steps.Values; leftValue = steps.LeftValue; }
public StepFunction(double[] abscissae, double[] values, double leftValue) { evaluator = new StepFunction <double>(abscissae, values, leftValue); this.abscissae = abscissae; this.values = values; this.leftValue = leftValue; }
public override RrFunction Add(RrFunction other) { var cst = other as ConstantRrFunction; if (cst != null) { return(RrFunctions.Constant(Value + cst.Value)); } var step = other as StepFunction; if (step != null) { return(StepFunction.Add(step, this)); } var spline = other as SplineInterpoler; if (spline != null) { return(SplineInterpoler.Add(spline, this)); } return(base.Add(other)); }
public WeightedStepFunction(RrFunction weight, double[] abscissae, double[] values, double leftValue) { this.weight = weight; this.abscissae = abscissae; this.values = values; this.leftValue = leftValue; stepEval = new StepFunction <double>(abscissae, values, leftValue); }
private static RrFunction BinaryOp(StepFunction left, StepFunction right, Func <double, double, double> binaryOp) { var mergedAbscissae = left.abscissae.Union(right.abscissae).OrderBy(p => p).ToArray(); var multValues = mergedAbscissae.Map(p => binaryOp(left.Eval(p), right.Eval(p))); var multLeftValue = binaryOp(left.Eval(double.NegativeInfinity), right.Eval(double.NegativeInfinity)); return(new StepFunction(mergedAbscissae, multValues, multLeftValue)); }
public static RrFunction Add(StepFunction step, ConstantRrFunction cst) { if (DoubleUtils.EqualZero(cst.Value)) { return(step); } var shiftedValues = step.values.Map(v => v + cst.Value); return(new StepFunction(step.abscissae, shiftedValues, step.leftValue + cst.Value)); }
public static RrFunction Mult(StepFunction step, ConstantRrFunction cst) { if (DoubleUtils.MachineEquality(cst.Value, 1.0)) { return(step); } if (DoubleUtils.EqualZero(cst.Value)) { return(RrFunctions.Zero); } var multValues = step.values.Map(v => v * cst.Value); return(new StepFunction(step.abscissae, multValues, step.leftValue * cst.Value)); }
public override RrFunction Integral(double basePoint) { var weightIntegral = weight.Integral(basePoint); var stepPartVals = new double[abscissae.Length]; double prev = 0.0; for (int i = 0; i < abscissae.Length; i++) { prev += weightIntegral.Eval(abscissae[i]) * (values[i] - (i > 0 ? values[i - 1] : leftValue)); stepPartVals[i] = -prev; } RrFunction stepPart = new StepFunction(abscissae, stepPartVals, 0.0); var unbasedResult = new WeightedStepFunction(weightIntegral, abscissae, values, leftValue) + stepPart; return(unbasedResult - unbasedResult.Eval(basePoint)); }
public override RrFunction Mult(RrFunction other) { var cst = other as ConstantRrFunction; if (cst != null) { return(ProductRrFunctions.Mult(this, cst)); } var exp = other as ExpRrFunction; if (exp != null) { return(ProductRrFunctions.Mult(exp, this)); } var step = other as StepFunction; if (step != null) { return(StepFunction.Mult(step, this)); } var spline = other as SplineInterpoler; if (spline != null) { return(SplineInterpoler.Mult(spline, this)); } var lc = other as LinearCombinationRrFunction; if (lc != null) { return(ProductRrFunctions.Mult(lc, this)); } return(base.Mult(other)); }
public static RrFunction Add(StepFunction left, StepFunction right) { return(BinaryOp(left, right, (l, r) => l + r)); }
public static RrFunction Mult(StepFunction leftStep, StepFunction rightStep) { return(BinaryOp(leftStep, rightStep, (l, r) => l * r)); }