public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0) { ValueEval arg = arg0; if (arg is RefEval) { // always use the first sheet RefEval re = (RefEval)arg; arg = re.GetInnerValueEval(re.FirstSheetIndex); } else if (arg is AreaEval) { // when the arg is an area, choose the top left cell arg = ((AreaEval)arg).GetRelativeValue(0, 0); } if (arg is StringEval) { // Text values are returned unmodified return(arg); } if (arg is ErrorEval) { // Error values also returned unmodified return(arg); } // for all other argument types the result is empty string return(StringEval.EMPTY_INSTANCE); }
private double GetValue(ValueEval arg) { if (arg is NumberEval) { return(((NumberEval)arg).NumberValue); } if (arg is BlankEval) { return(0); } if (arg is RefEval) { RefEval refEval = (RefEval)arg; if (refEval.NumberOfSheets > 1) { // Multi-Sheet references are not supported throw new EvaluationException(ErrorEval.VALUE_INVALID); } ValueEval innerValueEval = refEval.GetInnerValueEval(refEval.FirstSheetIndex); if (innerValueEval is NumberEval) { return(((NumberEval)innerValueEval).NumberValue); } if (innerValueEval is BlankEval) { return(0); } } throw new EvaluationException(ErrorEval.VALUE_INVALID); }
private static void CollectValues(ValueEval arg, IList temp) { if (arg is TwoDEval) { TwoDEval ae = (TwoDEval)arg; int width = ae.Width; int height = ae.Height; for (int rrIx = 0; rrIx < height; rrIx++) { for (int rcIx = 0; rcIx < width; rcIx++) { ValueEval ve1 = ae.GetValue(rrIx, rcIx); CollectValue(ve1, temp, false); } } return; } if (arg is RefEval) { RefEval re = (RefEval)arg; for (int sIx = re.FirstSheetIndex; sIx <= re.LastSheetIndex; sIx++) { CollectValue(re.GetInnerValueEval(sIx), temp, true); } return; } CollectValue(arg, temp, true); }
private ValueEval UnwrapEval(ValueEval eval) { ValueEval comp = eval; while (comp is RefEval) { RefEval reference = (RefEval)comp; comp = reference.GetInnerValueEval(reference.FirstSheetIndex); } return(comp); }
public ValueEval GetItem(int index) { if (index >= _size) { throw new IndexOutOfRangeException("Specified index (" + index + ") is outside the allowed range (0.." + (_size - 1) + ")"); } int sheetIndex = _re.FirstSheetIndex + index; return(_re.GetInnerValueEval(sheetIndex)); }
/** * Collects values from a single argument */ private void CollectValues(ValueEval operand, DoubleList temp) { if (operand is ThreeDEval) { ThreeDEval ae = (ThreeDEval)operand; for (int sIx = ae.FirstSheetIndex; sIx <= ae.LastSheetIndex; sIx++) { int width = ae.Width; int height = ae.Height; for (int rrIx = 0; rrIx < height; rrIx++) { for (int rcIx = 0; rcIx < width; rcIx++) { ValueEval ve = ae.GetValue(sIx, rrIx, rcIx); if (!IsSubtotalCounted && ae.IsSubTotal(rrIx, rcIx)) { continue; } CollectValue(ve, true, temp); } } } return; } if (operand is TwoDEval) { TwoDEval ae = (TwoDEval)operand; int width = ae.Width; int height = ae.Height; for (int rrIx = 0; rrIx < height; rrIx++) { for (int rcIx = 0; rcIx < width; rcIx++) { ValueEval ve = ae.GetValue(rrIx, rcIx); if (!IsSubtotalCounted && ae.IsSubTotal(rrIx, rcIx)) { continue; } CollectValue(ve, true, temp); } } return; } if (operand is RefEval) { RefEval re = (RefEval)operand; for (int sIx = re.FirstSheetIndex; sIx <= re.LastSheetIndex; sIx++) { CollectValue(re.GetInnerValueEval(sIx), true, temp); } return; } CollectValue((ValueEval)operand, false, temp); }
/** * @return the number of evaluated cells in the range that match the specified criteria */ public static int CountMatchingCellsInRef(RefEval refEval, IMatchPredicate criteriaPredicate) { int result = 0; for (int sIx = refEval.FirstSheetIndex; sIx <= refEval.LastSheetIndex; sIx++) { ValueEval ve = refEval.GetInnerValueEval(sIx); if (criteriaPredicate.Matches(ve)) { result++; } } return(result); }
/** * @return the number of evaluated cells in the range that match the specified criteria */ public static int CountMatchingCellsInRef(RefEval refEval, IMatchPredicate criteriaPredicate) { int result = 0; for (int sIx = refEval.FirstSheetIndex; sIx <= refEval.LastSheetIndex; sIx++) { ValueEval ve = refEval.GetInnerValueEval(sIx); if (criteriaPredicate.Matches(ve)) { result++; } } return result; }
/** * Resolve reference(-chains) until we have a normal value. * * @param field a ValueEval which can be a RefEval. * @return a ValueEval which is guaranteed not to be a RefEval * @If a multi-sheet reference was found along the way. */ private static ValueEval solveReference(ValueEval field) { if (field is RefEval) { RefEval refEval = (RefEval)field; if (refEval.NumberOfSheets > 1) { throw new EvaluationException(ErrorEval.VALUE_INVALID); } return(solveReference(refEval.GetInnerValueEval(refEval.FirstSheetIndex))); } else { return(field); } }
private static ValueVector EvaluateLookupRange(ValueEval eval) { if (eval is RefEval) { RefEval re = (RefEval)eval; if (re.NumberOfSheets == 1) { return(new SingleValueVector(re.GetInnerValueEval(re.FirstSheetIndex))); } else { return(LookupUtils.CreateVector(re)); } } if (eval is TwoDEval) { ValueVector result = LookupUtils.CreateVector((TwoDEval)eval); if (result == null) { throw new EvaluationException(ErrorEval.NA); } return(result); } // Error handling for lookup_range arg Is also Unusual if (eval is NumericValueEval) { throw new EvaluationException(ErrorEval.NA); } if (eval is StringEval) { StringEval se = (StringEval)eval; double d = OperandResolver.ParseDouble(se.StringValue); if (double.IsNaN(d)) { // plain string throw new EvaluationException(ErrorEval.VALUE_INVALID); } // else looks like a number throw new EvaluationException(ErrorEval.NA); } throw new Exception("Unexpected eval type (" + eval.GetType().Name + ")"); }
private static double GetScalarValue(ValueEval arg) { ValueEval eval; if (arg is RefEval) { RefEval re = (RefEval)arg; if (re.NumberOfSheets > 1) { throw new EvaluationException(ErrorEval.VALUE_INVALID); } eval = re.GetInnerValueEval(re.FirstSheetIndex); } else { eval = arg; } if (eval == null) { throw new ArgumentException("parameter may not be null"); } if (eval is AreaEval) { AreaEval ae = (AreaEval)eval; // an area ref can work as a scalar value if it is 1x1 if (!ae.IsColumn || !ae.IsRow) { throw new EvaluationException(ErrorEval.VALUE_INVALID); } eval = ae.GetRelativeValue(0, 0); } if (!(eval is ValueEval)) { throw new ArgumentException("Unexpected value eval class (" + eval.GetType().Name + ")"); } return(GetProductTerm((ValueEval)eval, true)); }
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval numberVE) { String hex; if (numberVE is RefEval) { RefEval re = (RefEval)numberVE; hex = OperandResolver.CoerceValueToString(re.GetInnerValueEval(re.FirstSheetIndex)); } else { hex = OperandResolver.CoerceValueToString(numberVE); } try { return(new NumberEval(BaseNumberUtils.ConvertToDecimal(hex, HEXADECIMAL_BASE, MAX_NUMBER_OF_PLACES))); } catch (ArgumentException) { return(ErrorEval.NUM_ERROR); } }
private static ValueEval ChooseSingleElementFromRef(RefEval ref1) { return ref1.GetInnerValueEval(ref1.FirstSheetIndex); }
protected override ValueEval GetItemInternal(int index) { int sIx = (index % _width) + _ref.FirstSheetIndex; return(_ref.GetInnerValueEval(sIx)); }
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval numberVE) { String number; if (numberVE is RefEval) { RefEval re = (RefEval)numberVE; number = OperandResolver.CoerceValueToString(re.GetInnerValueEval(re.FirstSheetIndex)); } else { number = OperandResolver.CoerceValueToString(numberVE); } if (number.Length > 10) { return(ErrorEval.NUM_ERROR); } String unsigned; //If the leftmost bit is 0 -- number is positive. bool isPositive; if (number.Length < 10) { unsigned = number; isPositive = true; } else { unsigned = number.Substring(1); isPositive = number.StartsWith("0"); } String value; try { if (isPositive) { //bit9*2^8 + bit8*2^7 + bit7*2^6 + bit6*2^5 + bit5*2^4+ bit3*2^2+ bit2*2^1+ bit1*2^0 int sum = getDecimalValue(unsigned); value = sum.ToString(); } else { //The leftmost bit is 1 -- this is negative number //Inverse bits [1-9] String inverted = toggleBits(unsigned); // Calculate decimal number int sum = getDecimalValue(inverted); //Add 1 to obtained number sum++; value = "-" + sum.ToString(); } } catch (FormatException) { return(ErrorEval.NUM_ERROR); } return(new NumberEval(long.Parse(value))); }
private static ValueEval ChooseSingleElementFromRef(RefEval ref1) { return(ref1.GetInnerValueEval(ref1.FirstSheetIndex)); }
private bool Calculate(ValueEval[] args) { bool result = InitialResultValue; bool atleastOneNonBlank = false; /* * Note: no short-circuit bool loop exit because any ErrorEvals will override the result */ foreach (ValueEval arg in args) { bool?tempVe; if (arg is TwoDEval) { TwoDEval ae = (TwoDEval)arg; int height = ae.Height; int width = ae.Width; for (int rrIx = 0; rrIx < height; rrIx++) { for (int rcIx = 0; rcIx < width; rcIx++) { ValueEval ve = ae.GetValue(rrIx, rcIx); tempVe = OperandResolver.CoerceValueToBoolean(ve, true); if (tempVe != null) { result = PartialEvaluate(result, Convert.ToBoolean(tempVe, CultureInfo.InvariantCulture)); atleastOneNonBlank = true; } } } continue; } if (arg is RefEval) { RefEval re = (RefEval)arg; int firstSheetIndex = re.FirstSheetIndex; int lastSheetIndex = re.LastSheetIndex; for (int sIx = firstSheetIndex; sIx <= lastSheetIndex; sIx++) { ValueEval ve = re.GetInnerValueEval(sIx); tempVe = OperandResolver.CoerceValueToBoolean(ve, true); if (tempVe != null) { result = PartialEvaluate(result, tempVe.Value); atleastOneNonBlank = true; } } continue; } //else if (arg is ValueEval) //{ // ValueEval ve = (ValueEval)arg; // tempVe = OperandResolver.CoerceValueToBoolean(ve, false); //} if (arg == MissingArgEval.instance) { tempVe = null; // you can leave out parameters, they are simply ignored } else { tempVe = OperandResolver.CoerceValueToBoolean(arg, false); } if (tempVe != null) { result = PartialEvaluate(result, Convert.ToBoolean(tempVe, CultureInfo.InvariantCulture)); atleastOneNonBlank = true; } } if (!atleastOneNonBlank) { throw new EvaluationException(ErrorEval.VALUE_INVALID); } return(result); }