Package org.boris.expr

Examples of org.boris.expr.Expr

17
18
19
20
21
22
23
24
25
26
27
    }

    public static Expr min(Expr[] args) throws ExprException {
        double d = Double.MAX_VALUE;
        for (Expr a : args) {
            Expr res = min(a);
            if (res instanceof ExprError) {
                return res;
            } else {
                double r = ((ExprDouble) res).doubleValue();
                if (r < d)
View Full Code Here
11
12
13
14
15
16
17
18
19
20
21
public class TYPE extends AbstractFunction
{
    public Expr evaluate(Expr[] args) throws ExprException {
        assertArgCount(args, 1);
        Expr a = evalArg(args[0]);
        if (a instanceof ExprString) {
            return new ExprDouble(2);
        } else if (a instanceof ExprInteger || a instanceof ExprDouble) {
            return new ExprDouble(1);
        } else if (a instanceof ExprBoolean) {
View Full Code Here
7
8
9
10
11
12
13
14
public class ISNA extends AbstractFunction
{
    public Expr evaluate(Expr[] args) throws ExprException {
        assertArgCount(args, 1);
        Expr e = evalArg(args[0]);
        return bool(ExprError.NA.equals(e));
    }
View Full Code Here
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class LEN extends AbstractFunction
{
    public Expr evaluate(Expr[] args) throws ExprException {
        assertArgCount(args, 1);
        Expr a = evalArg(args[0]);
        if (a instanceof ExprArray)
            return ExprError.VALUE;
        String str = null;
        if (a instanceof ExprString)
            str = ((ExprString) a).str;
        else
            str = a.toString();
        return new ExprDouble(str.length());
    }
View Full Code Here
45
46
47
48
49
50
51
52
53
54
55
        return new ExprDouble(values[0] / (values[1] - (allPopulation ? 0 : 1)));
    }

    public static Expr stdev(Expr[] args, boolean allPopulation)
            throws ExprException {
        Expr res = variance(args, allPopulation);
        if (res instanceof ExprDouble) {
            res = new ExprDouble(Math.sqrt(((ExprDouble) res).doubleValue()));
        }
        return res;
    }
View Full Code Here
8
9
10
11
12
13
14
15
16
17
18
public class AREAS extends AbstractFunction
{
    public Expr evaluate(Expr[] args) throws ExprException {
        assertArgCount(args, 1);
        Expr e = args[0];
        if (e instanceof ExprVariable) {
            return new ExprDouble(1);
        }
        return null;
    }
View Full Code Here
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class FORECAST extends AbstractFunction
{
    public Expr evaluate(Expr[] args) throws ExprException {
        assertArgCount(args, 3);

        Expr eF = evalArg(args[0]);
        if (!(eF instanceof ExprNumber))
            return ExprError.VALUE;
        Expr eY = evalArg(args[1]);
        if (!(eY instanceof ExprArray))
            return ExprError.VALUE;
        Expr eX = evalArg(args[2]);
        if (!(eX instanceof ExprArray))
            return ExprError.VALUE;

        double forecastX = ((ExprNumber) eF).doubleValue();
        ExprArray knownY = (ExprArray) eY;
        ExprArray knownX = (ExprArray) eX;
        if (knownY.length() != knownX.length())
            return ExprError.NA;

        Expr aeY = AVERAGE.average(knownY);
        if (aeY instanceof ExprError)
            return aeY;
        Expr aeX = AVERAGE.average(knownX);
        if (aeX instanceof ExprError)
            return aeX;

        double averageY = ((ExprNumber) aeY).doubleValue();
        double averageX = ((ExprNumber) aeX).doubleValue();
View Full Code Here
8
9
10
11
12
13
14
15
16
17
18
public class NOT extends AbstractFunction
{
    public Expr evaluate(Expr[] args) throws ExprException {
        assertArgCount(args, 1);
        Expr a = evalArg(args[0]);
        if (a instanceof ExprNumber) {
            return bool(!((ExprNumber) a).booleanValue());
        }
        return ExprError.VALUE;
    }
View Full Code Here
7
8
9
10
11
12
13
14
public class ISTEXT extends AbstractFunction
{
    public Expr evaluate(Expr[] args) throws ExprException {
        assertArgCount(args, 1);
        Expr e = evalArg(args[0]);
        return bool(e instanceof ExprString);
    }
View Full Code Here
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class MOD extends AbstractFunction
{
    public Expr evaluate(Expr[] args) throws ExprException {
        assertArgCount(args, 2);

        Expr n = args[0];
        if (n instanceof ExprEvaluatable) {
            n = ((ExprEvaluatable) n).evaluate();
        }
        if (n instanceof ExprArray) {
            ExprArray a = (ExprArray) n;
            if (a.rows() > 1) {
                return ExprError.VALUE;
            }

            n = a.get(0, 0);
        }
        if (!(n instanceof ExprNumber)) {
            return ExprError.VALUE;
        }

        double num = ((ExprNumber) n).doubleValue();

        Expr d = args[1];
        if (d instanceof ExprEvaluatable) {
            d = ((ExprEvaluatable) d).evaluate();
        }
        if (!(d instanceof ExprNumber)) {
            return ExprError.VALUE;
View Full Code Here
TOP

Related Classes of org.boris.expr.Expr

  • org.boris.expr.engine.AbstractCalculationEngine
  • org.boris.expr.engine.DependencyEngine
  • org.boris.expr.engine.IterationEngine
  • org.boris.expr.engine.ListenerEngine
  • org.boris.expr.engine.SimpleGraphEngine
  • org.boris.expr.engine.SimpleGraphEngine$EngineFunctionManager
  • org.boris.expr.function.AbstractDatabaseFunction
  • org.boris.expr.function.AbstractFunction
  • org.boris.expr.function.DoubleInOutFunctionErr
  • org.boris.expr.function.excel.AREAS
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.