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 ValueEval Evaluate(ValueEval[] args, OperationEvaluationContext ec)
{
if (args.Length != 2)
{
return(ErrorEval.VALUE_INVALID);
}
try
{
double startDateAsNumber = NumericFunction.SingleOperandEvaluate(args[0], ec.RowIndex, ec.ColumnIndex);
int months = (int)NumericFunction.SingleOperandEvaluate(args[1], ec.RowIndex, ec.ColumnIndex);
// Excel treats date 0 as 1900-01-00; EOMONTH results in 1900-01-31
if (startDateAsNumber >= 0.0 && startDateAsNumber < 1.0)
{
startDateAsNumber = 1.0;
}
DateTime startDate = DateUtil.GetJavaDate(startDateAsNumber, false);
//the month
DateTime dtEnd = startDate.AddMonths(months);
//next month
dtEnd = dtEnd.AddMonths(1);
//first day of next month
dtEnd = new DateTime(dtEnd.Year, dtEnd.Month, 1);
//last day of the month
dtEnd = dtEnd.AddDays(-1);
return(new NumberEval(DateUtil.GetExcelDate(dtEnd)));
}
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 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 serialNumVE, ValueEval returnTypeVE)
{
double serialNum = 0.0;
try
{
serialNum = NumericFunction.SingleOperandEvaluate(serialNumVE, srcRowIndex, srcColumnIndex);
}
catch (EvaluationException)
{
return(ErrorEval.VALUE_INVALID);
}
//Calendar serialNumCalendar = new GregorianCalendar();
//serialNumCalendar.setTime(DateUtil.GetJavaDate(serialNum, false));
DateTime serialNumCalendar = DateUtil.GetJavaDate(serialNum, false);
int returnType = 0;
try
{
ValueEval ve = OperandResolver.GetSingleValue(returnTypeVE, srcRowIndex, srcColumnIndex);
returnType = OperandResolver.CoerceValueToInt(ve);
}
catch (EvaluationException)
{
return(ErrorEval.NUM_ERROR);
}
if (returnType != 1 && returnType != 2)
{
return(ErrorEval.NUM_ERROR);
}
return(new NumberEval(getWeekNo(serialNumCalendar, returnType)));
}
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 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));
}
protected double Eval(ValueEval[] args, int srcCellRow, short srcCellCol)
{
if (args.Length != 1)
{
throw new EvaluationException(ErrorEval.VALUE_INVALID);
}
double d = NumericFunction.SingleOperandEvaluate(args[0], srcCellRow, srcCellCol);
return(Evaluate(d));
}
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, ValueEval arg2)
{
double result;
try
{
double d0 = NumericFunction.SingleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex);
double d1 = NumericFunction.SingleOperandEvaluate(arg1, srcRowIndex, srcColumnIndex);
ValueEval ve = OperandResolver.GetSingleValue(arg2, srcRowIndex, srcColumnIndex);
bool? method = OperandResolver.CoerceValueToBoolean(ve, false);
result = Evaluate(d0, d1);
}
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));
}
public ValueEval Evaluate(ValueEval[] args, int srcRowIndex,
int srcColumnIndex)
{
if (args.Length < 2 || args.Length > 5)
{
return(ErrorEval.VALUE_INVALID);
}
try
{
bool pAbsRow, pAbsCol;
int row = (int)NumericFunction.SingleOperandEvaluate(args[0], srcRowIndex, srcColumnIndex);
int col = (int)NumericFunction.SingleOperandEvaluate(args[1], srcRowIndex, srcColumnIndex);
int refType;
if (args.Length > 2 && args[2] != MissingArgEval.instance)
{
refType = (int)NumericFunction.SingleOperandEvaluate(args[2], srcRowIndex, srcColumnIndex);
}
else
{
refType = REF_ABSOLUTE; // this is also the default if parameter is not given
}
switch (refType)
{
case REF_ABSOLUTE:
pAbsRow = true;
pAbsCol = true;
break;
case REF_ROW_ABSOLUTE_COLUMN_RELATIVE:
pAbsRow = true;
pAbsCol = false;
break;
case REF_ROW_RELATIVE_RELATIVE_ABSOLUTE:
pAbsRow = false;
pAbsCol = true;
break;
case REF_RELATIVE:
pAbsRow = false;
pAbsCol = false;
break;
default:
throw new EvaluationException(ErrorEval.VALUE_INVALID);
}
bool a1;
if (args.Length > 3)
{
ValueEval ve = OperandResolver.GetSingleValue(args[3], srcRowIndex, srcColumnIndex);
// TODO R1C1 style is not yet supported
a1 = ve == MissingArgEval.instance ? true : OperandResolver.CoerceValueToBoolean(ve, false).Value;
}
else
{
a1 = true;
}
string sheetName;
if (args.Length == 5)
{
ValueEval ve = OperandResolver.GetSingleValue(args[4], srcRowIndex, srcColumnIndex);
sheetName = ve == MissingArgEval.instance ? null : OperandResolver.CoerceValueToString(ve);
}
else
{
sheetName = null;
}
CellReference ref1 = new CellReference(row - 1, col - 1, pAbsRow, pAbsCol);
StringBuilder sb = new StringBuilder(32);
if (sheetName != null)
{
SheetNameFormatter.AppendFormat(sb, sheetName);
sb.Append('!');
}
sb.Append(ref1.FormatAsString());
return(new StringEval(sb.ToString()));
}
catch (EvaluationException e)
{
return(e.GetErrorEval());
}
}