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, 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)
{
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 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)
{
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,
ValueEval arg1)
{
double dn;
try
{
ValueEval ve1 = OperandResolver.GetSingleValue(arg1, srcRowIndex, srcColumnIndex);
dn = OperandResolver.CoerceValueToDouble(ve1);
}
catch (EvaluationException)
{
// 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.Core.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 d = NumericFunction.SingleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex);
result = Evaluate(d);
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)
{
// 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.Core.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)
{
double result;
try
{
double rate = 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);
result = Evaluate(rate, d1, d2, d3);
NumericFunction.CheckValue(result);
}
catch (EvaluationException e)
{
return(e.GetErrorEval());
}
return(new NumberEval(result));
}
