public ValueEval Evaluate(ValueEval[] args, OperationEvaluationContext ec) { double result; if (args.Length != 2) { return(ErrorEval.VALUE_INVALID); } try { double startDateAsNumber = GetValue(args[0]); int offsetInMonthAsNumber = (int)GetValue(args[1]); // resolve the arguments DateTime startDate = DateUtil.GetJavaDate(startDateAsNumber); DateTime resultDate = startDate.AddMonths(offsetInMonthAsNumber); result = DateUtil.GetExcelDate(resultDate); NumericFunction.CheckValue(result); return(new NumberEval(result)); } catch (EvaluationException e) { return(e.GetErrorEval()); } }
public ValueEval Evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex) { if (args.Length == 0 || args.Length > 2) { // Wrong number of arguments return(ErrorEval.VALUE_INVALID); } try { double[] values = AggregateFunction.ValueCollector.CollectValues(args[0]); double guess; if (args.Length == 2) { guess = NumericFunction.SingleOperandEvaluate(args[1], srcRowIndex, srcColumnIndex); } else { guess = 0.1d; } double result = irr(values, guess); NumericFunction.CheckValue(result); return(new NumberEval(result)); } catch (EvaluationException e) { return(e.GetErrorEval()); } }
public ValueEval Evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex) { int nArgs = args.Length; if (nArgs < 2) { return(ErrorEval.VALUE_INVALID); } try { double rate = NumericFunction.SingleOperandEvaluate(args[0], srcRowIndex, srcColumnIndex); // convert tail arguments into an array of doubles ValueEval[] vargs = new ValueEval[args.Length - 1]; Array.Copy(args, 1, vargs, 0, vargs.Length); double[] values = AggregateFunction.ValueCollector.CollectValues(vargs); double result = FinanceLib.npv(rate, values); NumericFunction.CheckValue(result); return(new NumberEval(result)); } catch (EvaluationException e) { return(e.GetErrorEval()); } }
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1) { double result; try { double d0 = NumericFunction.SingleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex); double d1 = NumericFunction.SingleOperandEvaluate(arg1, srcRowIndex, srcColumnIndex); double multi = Math.Pow(10d, d1); if (d0 < 0) { result = -Math.Floor(-d0 * multi) / multi; } else { result = Math.Floor(d0 * multi) / multi; } //result = Math.Floor(d0 * multi) / multi; NumericFunction.CheckValue(result); } catch (EvaluationException e) { return(e.GetErrorEval()); } return(new NumberEval(result)); }
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1) { double dn; try { ValueEval ve1 = OperandResolver.GetSingleValue(arg1, srcRowIndex, srcColumnIndex); dn = OperandResolver.CoerceValueToDouble(ve1); } catch (EvaluationException e1) { // all errors in the second arg translate to #VALUE! return(ErrorEval.VALUE_INVALID); } if (dn < 0 || dn > 1) { // has to be percentage return(ErrorEval.NUM_ERROR); } double result; try { double[] ds = NPOI.SS.Formula.Functions.AggregateFunction.ValueCollector.CollectValues(arg0); int N = ds.Length; if (N == 0 || N > 8191) { return(ErrorEval.NUM_ERROR); } double n = (N - 1) * dn + 1; if (n == 1d) { result = StatsLib.kthSmallest(ds, 1); } else if (n == N) { result = StatsLib.kthLargest(ds, 1); } else { int k = (int)n; double d = n - k; result = StatsLib.kthSmallest(ds, k) + d * (StatsLib.kthSmallest(ds, k + 1) - StatsLib.kthSmallest(ds, k)); } NumericFunction.CheckValue(result); } catch (EvaluationException e) { return(e.GetErrorEval()); } return(new NumberEval(result)); }
private bool CheckArgument(double aDouble) { NumericFunction.CheckValue(aDouble); // make sure that the number is positive if (aDouble < 0) { throw new EvaluationException(ErrorEval.NUM_ERROR); } return(true); }
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0) { double result; try { double d0 = NumericFunction.SingleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex); result = Math.Log(d0) / NumericFunction.LOG_10_TO_BASE_e; NumericFunction.CheckValue(result); } catch (EvaluationException e) { return(e.GetErrorEval()); } return(new NumberEval(result)); }
public ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1) { double result; try { double rate = NumericFunction.SingleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex); double d1 = NumericFunction.SingleOperandEvaluate(arg1, srcRowIndex, srcColumnIndex); result = Evaluate(rate, d1); NumericFunction.CheckValue(result); } catch (EvaluationException e) { return(e.GetErrorEval()); } return(new NumberEval(result)); }
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1, ValueEval arg2) { double result; try { double d0 = NumericFunction.SingleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex); double d1 = NumericFunction.SingleOperandEvaluate(arg1, srcRowIndex, srcColumnIndex); double d2 = NumericFunction.SingleOperandEvaluate(arg2, srcRowIndex, srcColumnIndex); result = Evaluate(GetYear(d0), (int)d1, (int)d2); NumericFunction.CheckValue(result); } catch (EvaluationException e) { return(e.GetErrorEval()); } return(new NumberEval(result)); }
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1) { double dn; try { ValueEval ve1 = OperandResolver.GetSingleValue(arg1, srcRowIndex, srcColumnIndex); dn = OperandResolver.CoerceValueToDouble(ve1); } catch (EvaluationException e1) { // all errors in the second arg translate to #VALUE! return(ErrorEval.VALUE_INVALID); } // weird Excel behaviour on second arg if (dn < 1.0) { // values between 0.0 and 1.0 result in #NUM! return(ErrorEval.NUM_ERROR); } // all other values are rounded up to the next integer int k = (int)Math.Ceiling(dn); double result; try { double[] ds = NPOI.SS.Formula.Functions.AggregateFunction.ValueCollector.CollectValues(arg0); if (k > ds.Length) { return(ErrorEval.NUM_ERROR); } result = _isLarge ? StatsLib.kthLargest(ds, k) : StatsLib.kthSmallest(ds, k); NumericFunction.CheckValue(result); } catch (EvaluationException e) { return(e.GetErrorEval()); } return(new NumberEval(result)); }
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1, ValueEval arg2) { // arguments/result for this function double mean = 0; double x = 0; bool cumulative = ((BoolEval)arg2).BooleanValue; double result = 0; try { x = NumericFunction.SingleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex); mean = NumericFunction.SingleOperandEvaluate(arg1, srcRowIndex, srcColumnIndex); // check for default result : excel implementation for 0,0 // is different to Math Common. if (IsDefaultResult(x, mean)) { return(new NumberEval(DEFAULT_RETURN_RESULT)); } // check the arguments : as per excel function def CheckArgument(x); CheckArgument(mean); // truncate x : as per excel function def if (cumulative) { result = cumulativeProbability((int)x, mean); } else { result = probability((int)x, mean); } // check the result NumericFunction.CheckValue(result); } catch (EvaluationException e) { return(e.GetErrorEval()); } return(new NumberEval(result)); }
public ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1, ValueEval arg2, ValueEval arg3, ValueEval arg4) { double result; try { double d0 = NumericFunction.SingleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex); double d1 = NumericFunction.SingleOperandEvaluate(arg1, srcRowIndex, srcColumnIndex); double d2 = NumericFunction.SingleOperandEvaluate(arg2, srcRowIndex, srcColumnIndex); double d3 = NumericFunction.SingleOperandEvaluate(arg3, srcRowIndex, srcColumnIndex); double d4 = NumericFunction.SingleOperandEvaluate(arg4, srcRowIndex, srcColumnIndex); result = Evaluate(d0, d1, d2, d3, d4 != 0.0); NumericFunction.CheckValue(result); } catch (EvaluationException e) { return(e.GetErrorEval()); } return(new NumberEval(result)); }
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1) { double result; try { double d0 = NumericFunction.SingleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex); double d1 = NumericFunction.SingleOperandEvaluate(arg1, srcRowIndex, srcColumnIndex); double logE = Math.Log(d0); double base1 = d1; if (base1 == Math.E) // TODO: Double.compare(base, Math.E) == 0, , DOSE THE "==" operator equals Double.compare { result = logE; } else { result = logE / Math.Log(base1); } NumericFunction.CheckValue(result); } catch (EvaluationException e) { return(e.GetErrorEval()); } return(new NumberEval(result)); }
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0) { if (arg0 is AreaEval) { double[] result = null; double[,] resultArray; int width = 1, height = 1; try { double[] values = CollectValues(arg0); double[,] array = fillDoubleArray(values, ((AreaEval)arg0).Height, ((AreaEval)arg0).Width); resultArray = Evaluate(array); width = resultArray.GetLength(1); height = resultArray.GetLength(0); result = extractDoubleArray(resultArray); CheckValues(result); } catch (EvaluationException e) { return(e.GetErrorEval()); } ValueEval[] vals = new ValueEval[result.Length]; for (int idx = 0; idx < result.Length; idx++) { vals[idx] = new NumberEval(result[idx]); } if (result.Length == 1) { return(vals[0]); } else { /* find a better solution */ return(new CacheAreaEval(((AreaEval)arg0).FirstRow, ((AreaEval)arg0).FirstColumn, ((AreaEval)arg0).FirstRow + height - 1, ((AreaEval)arg0).FirstColumn + width - 1, vals)); } } else { double[,] result = null; try { double value = NumericFunction.SingleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex); double[,] temp = { { value } }; result = Evaluate(temp); NumericFunction.CheckValue(result[0, 0]); } catch (EvaluationException e) { return(e.GetErrorEval()); } return(new NumberEval(result[0, 0])); } }