// This method runs the inner functions for calculation and calls the subscribers public double Calculate(double value) { this.result = this.CalculateRecursively(this.funcComp.Last, value); // call method with the last node // if not null then invoke the function inside with the parameter 'result' OnCalculate?.Invoke(this, result); // Raise the event return(this.result); }
public double Calculate(double value) { double res = mission(value); OnCalculate?.Invoke(this, res); return(res); }
//Calculate the value using a single function. public double Calculate(double value) { value = calcDelegate(value); //notify all those who are subscribed to the event. OnCalculate?.Invoke(this, value); return(value); }
/** * Calculate and return the result of the mission with the received value, * And invoke the event if its not null. **/ public double Calculate(double value) { double answer = singleMission(value); OnCalculate?.Invoke(this, answer); return(answer); }
public double Calculate(double value) { double ans = this.func(value); // calculat the mission OnCalculate?.Invoke(this, ans); //if the onCalculat isnt null return(ans); }
public double Calculate(double value) { double returnVal = funcMission(value); OnCalculate?.Invoke(this, returnVal); return(returnVal); }
/// <summary> /// The function get a double, calculate by the calculate function, /// and return the a /// </summary> /// <param name="value">number as input (double)</param> /// <returns>numbner as return value (double)</returns> public double Calculate(double value) { double ans = calculateFunc(value); OnCalculate?.Invoke(this, ans); return(ans); }
/// <summary> /// the execute part of the command design pattern. /// also activates the EventHandler. /// this method calculates the final result /// </summary> /// <param name="value"></param> /// <returns>the value after calculated</returns> public double Calculate(double value) { double result = this.mission.Invoke(value); OnCalculate?.Invoke(this, result); //activates event handler return(result); }
public event EventHandler <double> OnCalculate; // An Event of when a mission is activated /// <summary> /// calculates the value. /// </summary> /// <param name="value"></param> /// <returns> returnes the value after operating the function. /// </returns> public double Calculate(double value) { double funcValue = missionFunction(value); OnCalculate?.Invoke(this, funcValue); return(funcValue); }
public double Calculate(double value) { double result = operation(value); OnCalculate?.Invoke(this, result); return(result); }
public double Calculate(double value) { double rtr = func(value); //calculate by the single function we have OnCalculate?.Invoke(this, rtr); //the events are now being running return(rtr); }
public override double Calculate(double value) { value = base.Calculate(value); OnCalculate?.Invoke(this, value); return(value); }
public double Calculate(double value) { double val = delegateFunc(value); OnCalculate?.Invoke(this, val); return(val); }
// This method runs the inner function for calculation and calls the subscribers public double Calculate(double value) { this.result = this.func(value); // if not null then invoke the function inside with the parameter 'result' OnCalculate?.Invoke(this, this.result); // raise the event return(this.result); }
//calculate function. public double Calculate(double value) { value = Action(value); //invoking the event handler. OnCalculate?.Invoke(this, value); return(value); }
/// <summary> /// The Calculate Function /// which gets as a parameter /// a double value /// and calculates the expression value /// given the value from the parameters /// and returns the expression value /// for it. /// Before each return it calls the functions /// which OnCalculate EventHandler points to. /// It's only if it points to at least /// one function. /// <param name="value">double value to which we calculate /// the expression value</para> /// <retValue>double the expression value for /// the given value from the parameters</retValue> /// </summary> public double Calculate(double value) { double returnValue = Func(value); OnCalculate?.Invoke(this, returnValue); return(returnValue); }
// When this function is activate it activates the function from // it's member. public double Calculate(double value) { double result = this.thisFunc(value); OnCalculate?.Invoke(this, result); return(result); }
/* This method calculates the new value using the function * and returns it. Also it invokes calculation event. */ public double Calculate(double value) { double newValue = function(value); OnCalculate.Invoke(this, newValue); return(function(newValue)); }
public double Calculate(double value) { double result = functionMission(value); OnCalculate?.Invoke(this, result); return(result); }
/*calculate the mission (use the function and invoke the * event handler about the soloution*/ public double Calculate(double val) { double newval = this.function(val); OnCalculate?.Invoke(this, newval); return(newval); }
// calculate the mission. public double Calculate(double var) { double result = mis(var); OnCalculate?.Invoke(this, mis(var)); return(result); }
public double Calculate(double value) { // if the event isn't null run it. OnCalculate?.Invoke(this, function(value)); // calculate the return value. return(function(value)); }
/** * calculate the delegate based on double input. */ public double Calculate(double d) { double result = delegate1(d); OnCalculate?.Invoke(this, result); return(result); }
//calculates the value with given value and by the function public double Calculate(double value) { value = sfunction(value); //raise the event OnCalculate?.Invoke(this, value); return(value); }
/// <summary> /// Calculate - calvulate value by its mission /// </summary> /// <param name="value"></param> /// <returns>result (type: double)</returns> public double Calculate(double value) { double result = func(value); //invoke event if not empty OnCalculate?.Invoke(this, result); return(result); }
//calculates the mission public double Calculate(double value) { double myVal = this.myDel(value); //if not null - Raise the event OnCalculate?.Invoke(this, myVal); return(myVal); }
//calculates the function with the input value public double Calculate(double value) { double result = funcMission(value); //if there are an events, invoke OnCalculate?.Invoke(this, result); return(result); }
// Calculates the value of the function. public double Calculate(double val) { // Calculate the value. val = CalcDel(val); // Notify everyone. OnCalculate?.Invoke(this, val); return(val); }
/*override*/ public double Calculate(double value) { double x = funcToCalc(value); //raise the event. OnCalculate?.Invoke(this, x); return(x); }
/** * Invokes the calculate method on a given value, and returns the result of * the specific single mission. **/ public double Calculate(double value) { //put in result the value and invoke the event handler. double result = this.mathFunctionPtr(value); OnCalculate?.Invoke(this, result); return(result); }