public 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 e1) {
        // 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.ceil(dn);

      double result;
      try {
        double[] ds = 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);
    }
Exemple #2
0
 /** @return the de-referenced criteria arg (possibly {@link ErrorEval}) */
 private static ValueEval evaluateCriteriaArg(ValueEval arg, int srcRowIndex, int srcColumnIndex) {
   try {
     return OperandResolver.getSingleValue(arg, srcRowIndex, srcColumnIndex);
   } catch (EvaluationException e) {
     return e.getErrorEval();
   }
 }
  public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0) {

    try {
      OperandResolver.getSingleValue(arg0, srcRowIndex, srcColumnIndex);
      return ErrorEval.NA;
    } catch (EvaluationException e) {
      int result = translateErrorCodeToErrorTypeValue(e.getErrorEval().getErrorCode());
      return new NumberEval(result);
    }
  }
    public 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 e1) {
        // 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 = 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);
    }
  public ValueEval evaluate(ValueEval[] args, OperationEvaluationContext ec) {

    // verify that we have enough data
    if (args.length != 3) {
      return ErrorEval.VALUE_INVALID;
    }

    // declare doubles for values
    double principal, rate, years, result;
    try {
      // extract values as ValueEval
      ValueEval v1 = OperandResolver.getSingleValue(args[0], ec.getRowIndex(), ec.getColumnIndex());
      ValueEval v2 = OperandResolver.getSingleValue(args[1], ec.getRowIndex(), ec.getColumnIndex());
      ValueEval v3 = OperandResolver.getSingleValue(args[2], ec.getRowIndex(), ec.getColumnIndex());

      // get data as doubles
      principal = OperandResolver.coerceValueToDouble(v1);
      rate = OperandResolver.coerceValueToDouble(v2);
      years = OperandResolver.coerceValueToDouble(v3);

      result = calculateMortgagePayment(principal, rate, years);
      System.out.println("Result = " + result);

      checkValue(result);

    } catch (EvaluationException e) {
      return e.getErrorEval();
    }

    return new NumberEval(result);
  }
Exemple #6
0
 public boolean matches(ValueEval x) {
   double testValue;
   if (x instanceof StringEval) {
     // if the target(x) is a string, but parses as a number
     // it may still count as a match, only for the equality operator
     switch (getCode()) {
       case CmpOp.EQ:
       case CmpOp.NONE:
         break;
       case CmpOp.NE:
         // Always matches (inconsistent with above two cases).
         // for example '<>123' matches '123', '4', 'abc', etc
         return true;
       default:
         // never matches (also inconsistent with above three cases).
         // for example '>5' does not match '6',
         return false;
     }
     StringEval se = (StringEval) x;
     Double val = OperandResolver.parseDouble(se.getStringValue());
     if (val == null) {
       // x is text that is not a number
       return false;
     }
     return _value == val.doubleValue();
   } else if ((x instanceof NumberEval)) {
     NumberEval ne = (NumberEval) x;
     testValue = ne.getNumberValue();
   } else if ((x instanceof BlankEval)) {
     switch (getCode()) {
       case CmpOp.NE:
         // Excel counts blank values in range as not equal to any value. See Bugzilla 51498
         return true;
       default:
         return false;
     }
   } else {
     return false;
   }
   return evaluate(Double.compare(testValue, _value));
 }
Exemple #7
0
  /** When the second argument is a string, many things are possible */
  private static I_MatchPredicate createGeneralMatchPredicate(StringEval stringEval) {
    String value = stringEval.getStringValue();
    CmpOp operator = CmpOp.getOperator(value);
    value = value.substring(operator.getLength());

    Boolean booleanVal = parseBoolean(value);
    if (booleanVal != null) {
      return new BooleanMatcher(booleanVal.booleanValue(), operator);
    }

    Double doubleVal = OperandResolver.parseDouble(value);
    if (doubleVal != null) {
      return new NumberMatcher(doubleVal.doubleValue(), operator);
    }
    ErrorEval ee = parseError(value);
    if (ee != null) {
      return new ErrorMatcher(ee.getErrorCode(), operator);
    }

    // else - just a plain string with no interpretation.
    return new StringMatcher(value, operator);
  }