protected NumberLookupComparer(NumberEval ne) { super(ne); _value = ne.getNumberValue(); } protected CompareResult compareSameType(ValueEval other) {
private static Double getValue(AreaEval aeRange, int relRowIndex, int relColIndex) { ValueEval addend = aeRange.getRelativeValue(relRowIndex, relColIndex); if (addend instanceof NumberEval) { return ((NumberEval)addend).getNumberValue(); } // everything else (including string and boolean values) counts as zero return null; }
protected CompareResult compareSameType(ValueEval other) { NumberEval ne = (NumberEval) other; return CompareResult.valueOf(Double.compare(_value, ne.getNumberValue())); } protected String getValueAsString() {
/** * For counts, this would return 1, for sums it returns a cell value or zero. * This is only called after all the criteria are confirmed true for the coordinates. * @param sumRange if used * @param relRowIndex * @param relColIndex * @return the aggregate input value corresponding to the given range coordinates */ private static double accumulate(AreaEval sumRange, int relRowIndex, int relColIndex) { if (sumRange == null) return 1.0; // count ValueEval addend = sumRange.getRelativeValue(relRowIndex, relColIndex); if (addend instanceof NumberEval) { return ((NumberEval)addend).getNumberValue(); } // everything else (including string and boolean values) counts as zero return 0.0; }
private static void collectValue(ValueEval arg, List<Double> temp, boolean mustBeNumber) throws EvaluationException { if (arg instanceof ErrorEval) { throw new EvaluationException((ErrorEval) arg); } if (arg == BlankEval.instance || arg instanceof BoolEval || arg instanceof StringEval) { if (mustBeNumber) { throw EvaluationException.invalidValue(); } return; } if (arg instanceof NumberEval) { temp.add(Double.valueOf(((NumberEval) arg).getNumberValue())); return; } throw new RuntimeException("Unexpected value type (" + arg.getClass().getName() + ")"); } }
@Override public Set<ValueAndFormat> evaluate(List<ValueAndFormat> allValues) { double total = 0; ValueEval[] pop = new ValueEval[allValues.size()]; for (int i = 0; i < allValues.size(); i++) { ValueAndFormat v = allValues.get(i); total += v.value.doubleValue(); pop[i] = new NumberEval(v.value.doubleValue()); } final Set<ValueAndFormat> avgSet = new LinkedHashSet<>(1); avgSet.add(new ValueAndFormat(Double.valueOf(allValues.size() == 0 ? 0 : total / allValues.size()), null, decimalTextFormat)); final double stdDev = allValues.size() <= 1 ? 0 : ((NumberEval) AggregateFunction.STDEV.evaluate(pop, 0, 0)).getNumberValue(); avgSet.add(new ValueAndFormat(Double.valueOf(stdDev), null, decimalTextFormat)); return avgSet; } }));
private static int compareBlank(ValueEval v) { if (v == BlankEval.instance) { return 0; } if (v instanceof BoolEval) { BoolEval boolEval = (BoolEval) v; return boolEval.getBooleanValue() ? -1 : 0; } if (v instanceof NumberEval) { NumberEval ne = (NumberEval) v; return NumberComparer.compare(0.0, ne.getNumberValue()); } if (v instanceof StringEval) { StringEval se = (StringEval) v; return se.getStringValue().length() < 1 ? 0 : -1; } throw new IllegalArgumentException("bad value class (" + v.getClass().getName() + ")"); }
private static double accumulate(AreaEval aeRange, I_MatchPredicate mp, AreaEval aeSum, int relRowIndex, int relColIndex) { if (!mp.matches(aeRange.getRelativeValue(relRowIndex, relColIndex))) { return 0.0; } ValueEval addend = aeSum.getRelativeValue(relRowIndex, relColIndex); if (addend instanceof NumberEval) { return ((NumberEval)addend).getNumberValue(); } // everything else (including string and boolean values) counts as zero return 0.0; }
private boolean areValuesEqual(ValueEval a, ValueEval b) { if (a == null) { return false; } Class<?> cls = a.getClass(); if (cls != b.getClass()) { // value type is changing return false; } if (a == BlankEval.instance) { return b == a; } if (cls == NumberEval.class) { return ((NumberEval)a).getNumberValue() == ((NumberEval)b).getNumberValue(); } if (cls == StringEval.class) { return ((StringEval)a).getStringValue().equals(((StringEval)b).getStringValue()); } if (cls == BoolEval.class) { return ((BoolEval)a).getBooleanValue() == ((BoolEval)b).getBooleanValue(); } if (cls == ErrorEval.class) { return ((ErrorEval)a).getErrorCode() == ((ErrorEval)b).getErrorCode(); } throw new IllegalStateException("Unexpected value class (" + cls.getName() + ")"); }
public void setValue(ValueEval value) { Class<? extends ValueEval> cls = value.getClass(); if (cls == NumberEval.class) { _cellType = CellType.NUMERIC; _numberValue = ((NumberEval)value).getNumberValue(); return; } if (cls == StringEval.class) { _cellType = CellType.STRING; _stringValue = ((StringEval)value).getStringValue(); return; } if (cls == BoolEval.class) { _cellType = CellType.BOOLEAN; _booleanValue = ((BoolEval)value).getBooleanValue(); return; } if (cls == ErrorEval.class) { _cellType = CellType.ERROR; _errorValue = ((ErrorEval)value).getErrorCode(); return; } if (cls == BlankEval.class) { _cellType = CellType.BLANK; return; } throw new IllegalArgumentException("Unexpected value class (" + cls.getName() + ")"); } public void copyValue(Cell destCell) {
private static boolean areValuesEqual(ValueEval a, ValueEval b) { if (a == null) { return false; } Class<? extends ValueEval> cls = a.getClass(); if (cls != b.getClass()) { // value type is changing return false; } if (a == BlankEval.instance) { return b == a; } if (cls == NumberEval.class) { return ((NumberEval)a).getNumberValue() == ((NumberEval)b).getNumberValue(); } if (cls == StringEval.class) { return ((StringEval)a).getStringValue().equals(((StringEval)b).getStringValue()); } if (cls == BoolEval.class) { return ((BoolEval)a).getBooleanValue() == ((BoolEval)b).getBooleanValue(); } if (cls == ErrorEval.class) { return ((ErrorEval)a).getErrorCode() == ((ErrorEval)b).getErrorCode(); } throw new IllegalStateException("Unexpected value class (" + cls.getName() + ")"); }
private double getValue(ValueEval arg) throws EvaluationException { if (arg instanceof NumberEval) { return ((NumberEval) arg).getNumberValue(); } if(arg instanceof BlankEval) { return 0; } if (arg instanceof RefEval) { RefEval refEval = (RefEval)arg; if (refEval.getNumberOfSheets() > 1) { // Multi-Sheet references are not supported throw new EvaluationException(ErrorEval.VALUE_INVALID); } ValueEval innerValueEval = refEval.getInnerValueEval(refEval.getFirstSheetIndex()); if(innerValueEval instanceof NumberEval) { return ((NumberEval) innerValueEval).getNumberValue(); } if(innerValueEval instanceof BlankEval) { return 0; } } throw new EvaluationException(ErrorEval.VALUE_INVALID); } }
if (eval instanceof NumberEval) return Double.valueOf(((NumberEval) eval).getNumberValue()); if (eval instanceof StringEval) { final String value = ((StringEval) eval).getStringValue();
/** * Creates a criteria predicate object for the supplied criteria arg * @return <code>null</code> if the arg evaluates to blank. */ /* package */ static I_MatchPredicate createCriteriaPredicate(ValueEval arg, int srcRowIndex, int srcColumnIndex) { ValueEval evaluatedCriteriaArg = evaluateCriteriaArg(arg, srcRowIndex, srcColumnIndex); if(evaluatedCriteriaArg instanceof NumberEval) { return new NumberMatcher(((NumberEval)evaluatedCriteriaArg).getNumberValue(), CmpOp.OP_NONE); } if(evaluatedCriteriaArg instanceof BoolEval) { return new BooleanMatcher(((BoolEval)evaluatedCriteriaArg).getBooleanValue(), CmpOp.OP_NONE); } if(evaluatedCriteriaArg instanceof StringEval) { return createGeneralMatchPredicate((StringEval)evaluatedCriteriaArg); } if(evaluatedCriteriaArg instanceof ErrorEval) { return new ErrorMatcher(((ErrorEval)evaluatedCriteriaArg).getErrorCode(), CmpOp.OP_NONE); } if(evaluatedCriteriaArg == BlankEval.instance) { return null; } throw new RuntimeException("Unexpected type for criteria (" + evaluatedCriteriaArg.getClass().getName() + ")"); }
private static ValueEval eval(double arg0, RefListEval aeRange, boolean descending_order) { int rank = 1; for(ValueEval ve : aeRange.getList()) { if (ve instanceof RefEval) { ve = ((RefEval) ve).getInnerValueEval(((RefEval) ve).getFirstSheetIndex()); } final Double value; if (ve instanceof NumberEval) { value = ((NumberEval)ve).getNumberValue(); } else { continue; } if(descending_order && value>arg0 || !descending_order && value<arg0){ rank++; } } return new NumberEval(rank); }
} else if((x instanceof NumberEval)) { NumberEval ne = (NumberEval) x; testValue = ne.getNumberValue(); } else if((x instanceof BlankEval)) { switch (getCode()) {
/** * @param ref needed for offsets from region anchor - may be null! * @param region for adjusting relative formulas * @return true/false using the same rules as Data Validation evaluations */ private boolean checkFormula(CellReference ref, CellRangeAddress region) { ValueEval comp = unwrapEval(workbookEvaluator.evaluate(rule.getFormula1(), ref, region)); // Copied for now from DataValidationEvaluator.ValidationEnum.FORMULA#isValidValue() if (comp instanceof BlankEval) { return true; } if (comp instanceof ErrorEval) { return false; } if (comp instanceof BoolEval) { return ((BoolEval) comp).getBooleanValue(); } // empirically tested in Excel - 0=false, any other number = true/valid // see test file DataValidationEvaluations.xlsx if (comp instanceof NumberEval) { return ((NumberEval) comp).getNumberValue() != 0; } return false; // anything else is false, such as text }
/** * Returns a CellValue wrapper around the supplied ValueEval instance. */ protected CellValue evaluateFormulaCellValue(Cell cell) { EvaluationCell evalCell = toEvaluationCell(cell); ValueEval eval = _bookEvaluator.evaluate(evalCell); if (eval instanceof NumberEval) { NumberEval ne = (NumberEval) eval; return new CellValue(ne.getNumberValue()); } if (eval instanceof BoolEval) { BoolEval be = (BoolEval) eval; return CellValue.valueOf(be.getBooleanValue()); } if (eval instanceof StringEval) { StringEval ne = (StringEval) eval; return new CellValue(ne.getStringValue()); } if (eval instanceof ErrorEval) { return CellValue.getError(((ErrorEval)eval).getErrorCode()); } throw new RuntimeException("Unexpected eval class (" + eval.getClass().getName() + ")"); }
/** * Note the formula result must either be a boolean result, or anything not in error. * If boolean, value must be true to pass, anything else valid is also passing, errors fail. * @see org.apache.poi.ss.formula.DataValidationEvaluator.ValidationEnum#isValidValue(Cell, DataValidationContext) */ public boolean isValidValue(Cell cell, DataValidationContext context) { // unwrapped single value ValueEval comp = context.getEvaluator().getWorkbookEvaluator().evaluate(context.getFormula1(), context.getTarget(), context.getRegion()); if (comp instanceof RefEval) { comp = ((RefEval) comp).getInnerValueEval(((RefEval) comp).getFirstSheetIndex()); } if (comp instanceof BlankEval) return true; if (comp instanceof ErrorEval) return false; if (comp instanceof BoolEval) { return ((BoolEval) comp).getBooleanValue(); } // empirically tested in Excel - 0=false, any other number = true/valid // see test file DataValidationEvaluations.xlsx if (comp instanceof NumberEval) { return ((NumberEval) comp).getNumberValue() != 0; } return false; // anything else is false, such as text } },
if (isType(cell, CellType.NUMERIC) && ((NumberEval) comp).getNumberValue() == cell.getNumericCellValue()) { return true; } else {