@Override public ValueEval getResult() { return new NumberEval(totalValue); } }
protected NumberLookupComparer(NumberEval ne) { super(ne); _value = ne.getNumberValue(); } protected CompareResult compareSameType(ValueEval other) {
public final String toString() { return getClass().getName() + " [" + getStringValue() + "]"; } }
@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 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); }
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex) { return new NumberEval(Math.random()); } };
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; }
public final String toString() { StringBuffer sb = new StringBuffer(64); sb.append(getClass().getName()).append(" ["); sb.append(getStringValue()); sb.append("]"); return sb.toString(); } }
protected ValueEval evaluate(String arg) { return new NumberEval(arg.length()); } };
protected CompareResult compareSameType(ValueEval other) { NumberEval ne = (NumberEval) other; return CompareResult.valueOf(Double.compare(_value, ne.getNumberValue())); } protected String getValueAsString() {
public final String toString() { StringBuffer sb = new StringBuffer(64); sb.append(getClass().getName()).append(" ["); sb.append(getStringValue()); sb.append("]"); return sb.toString(); } }
private ValueEval eval(String haystack, String needle, int startIndex) { int result; if (_isCaseSensitive) { result = haystack.indexOf(needle, startIndex); } else { result = haystack.toUpperCase(Locale.ROOT) .indexOf(needle.toUpperCase(Locale.ROOT), startIndex); } if (result == -1) { return ErrorEval.VALUE_INVALID; } return new NumberEval(result + 1); } }
/** * 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; }
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0) { int result; if (arg0 instanceof TwoDEval) { result = ((TwoDEval) arg0).getHeight(); } else if (arg0 instanceof RefEval) { result = 1; } else { // anything else is not valid argument return ErrorEval.VALUE_INVALID; } return new NumberEval(result); } }
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() + ")"); } }
public ValueEval evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex) { switch (args.length) { case 1: return evaluate(srcRowIndex, srcColumnIndex, args[0]); case 0: return new NumberEval(srcColumnIndex+1); } return ErrorEval.VALUE_INVALID; } }
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() + ")"); }
public ValueEval evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex) { switch (args.length) { case 1: return evaluate(srcRowIndex, srcColumnIndex, args[0]); case 0: return new NumberEval(srcRowIndex+1); } return ErrorEval.VALUE_INVALID; } }
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; }
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0) { int result; if (arg0 instanceof TwoDEval) { result = ((TwoDEval) arg0).getWidth(); } else if (arg0 instanceof RefEval) { result = 1; } else { // anything else is not valid argument return ErrorEval.VALUE_INVALID; } return new NumberEval(result); } }