/** * Creates a parser for band arithmetic expressions. * The parser created will use a namespace comprising all tie-point grids, bands and flags of this product. * * @return a parser for band arithmetic expressions for this product, never null */ public Parser createBandArithmeticParser() { final Namespace namespace = createBandArithmeticDefaultNamespace(); return new ParserImpl(namespace, false); }
for (MosaicOp.Variable variable : variables) { try { new ParserImpl(namespace, false).parse(variable.getExpression()); } catch (ParseException e) { final String msg = String.format("Expression '%s' is invalid for product '%s'.\n%s", for (MosaicOp.Condition condition : conditions) { try { new ParserImpl(namespace, false).parse(condition.getExpression()); } catch (ParseException e) { final String msg = String.format("Expression '%s' is invalid for product '%s'.\n%s",
int tt = tokenizer.next(); if (tt == Tokenizer.TT_DOUBLE) { t1 = new Term.ConstD(convertDoubleToken()); } else if (tt == Tokenizer.TT_INT) { t1 = new Term.ConstI(convertIntToken()); } else if (tt == Tokenizer.TT_HEX_INT) { t1 = new Term.ConstI(convertHexIntToken()); } else if (tt == Tokenizer.TT_OCT_INT) { t1 = new Term.ConstI(convertOctIntToken()); } else if (tt == Tokenizer.TT_STRING) { t1 = new Term.ConstS(convertStringToken()); } else if (tt == Tokenizer.TT_KEYWORD) { String keyword = tokenizer.getToken(); t1 = new Term.ConstB(false); } else { reportError("Unexpected keyword '" + keyword + "'."); t1 = parseCallOrRef(name); } else if (tt == '(') { t1 = parseTerm(true); tt = tokenizer.next(); if (tt != ')') { tokenizer.pushBack(); reportError("Missing ')'."); /*I18N*/ reportError("Term expected."); /*I18N*/
/** * Parses the expression given in the code string. * Names in the code string are resolved using the default namespace. * * @param code the code string, for the syntax of valid expressions refer * to the class description * @throws ParseException if a parse reportError occurs */ public final Term parse(final String code) throws ParseException { return parse(code, defaultNamespace); }
@Test public void testNaNAndInf() throws ParseException { final Variable x = SymbolFactory.createVariable("x", 0.0); ((WritableNamespace) parser.getDefaultNamespace()).registerSymbol(x); Term term = parser.parse("inf(x) || nan(x)"); x.assignD(env, 0.0); assertEquals(false, term.evalB(env)); x.assignD(env, Math.log(0)); assertEquals(true, term.evalB(env)); x.assignD(env, (double) (float) Math.log(0)); assertEquals(true, term.evalB(env)); x.assignD(env, 0.0); assertEquals(false, term.evalB(env)); x.assignD(env, Math.sqrt(-1)); assertEquals(true, term.evalB(env)); x.assignD(env, (double) (float) Math.sqrt(-1)); assertEquals(true, term.evalB(env)); }
@Test public void testNaNConst() throws ParseException { Term term = parser.parse("NaN"); assertTrue(Double.isNaN(term.evalD(env))); }
private void testConditional(String code) throws ParseException { final Variable x = SymbolFactory.createVariable("x", 0.0); ((WritableNamespace) parser.getDefaultNamespace()).registerSymbol(x); Term term = parser.parse(code); assertNotNull(term); assertNotNull(term.getChildren()); int i = term.getChildren().length; assertEquals(3, i); x.assignI(null, -10); assertEquals(0, term.evalI(env)); x.assignI(null, 0); assertEquals(0, term.evalI(env)); x.assignI(null, 10); assertEquals(1, term.evalI(env)); }
private ParserImpl createFallbackParser() { final Namespace fallbackNS = new DummyNamespace(); final DefaultNamespace defaultNS = new DefaultNamespace(fallbackNS); return new ParserImpl(defaultNS, false); }
defaultProductIndex); namespace.registerSymbol(SymbolFactory.createConstant(paramName.getValueAsText(), 0)); final Term term = new ParserImpl(namespace, false).parse(expression); if (!term.isB()) { JOptionPane.showMessageDialog(dialog.getJDialog(),
@Test public void testSubstractionNegative() throws ParseException { Term term = parser.parse("24 - -4"); assertEquals(28, term.evalI(env)); term = parser.parse("24--4"); assertEquals(28, term.evalI(env)); term = parser.parse("24-(-4)"); assertEquals(28, term.evalI(env)); term = parser.parse("(24--4)"); assertEquals(28, term.evalI(env)); term = parser.parse("24.0--------------------++++++++++++++++++++++(4)"); assertEquals(28, term.evalI(env)); }
private void testNestedConditional(String code) throws ParseException { final Variable x = SymbolFactory.createVariable("x", 0.0); ((WritableNamespace) parser.getDefaultNamespace()).registerSymbol(x); Term term = parser.parse(code); assertNotNull(term); assertNotNull(term.getChildren()); int i = term.getChildren().length; assertEquals(3, i); x.assignI(null, -10); assertEquals(-1, term.evalI(env)); x.assignI(null, 0); assertEquals(0, term.evalI(env)); x.assignI(null, 10); assertEquals(1, term.evalI(env)); }
@Before public void setUp() throws Exception { env = new EvalEnv() { }; parser = new ParserImpl(); }
@Test public void testPow() throws ParseException { NamespaceImpl namespace = new NamespaceImpl(new DefaultNamespace()); namespace.registerSymbol(new AbstractSymbol.I("ix") { @Override public int evalI(EvalEnv env) throws EvalException { return ix; } }); namespace.registerSymbol(new AbstractSymbol.D("dx") { @Override public double evalD(EvalEnv env) throws EvalException { return dx; } }); ParserImpl parser = new ParserImpl(namespace); ix = 1; dx = 1.0; assertEquals(10.0, parser.parse("pow(10, ix)").evalD(null), 1E-10); assertEquals(10.0, parser.parse("pow(10, ix)").evalD(null), 1E-10); assertEquals(10.0, parser.parse("pow(10, dx)").evalD(null), 1E-10); assertEquals(10.0, parser.parse("pow(10, dx)").evalD(null), 1E-10); ix = 2; dx = 2.0; assertEquals(100.0, parser.parse("pow(10.0, ix)").evalD(null), 1E-10); assertEquals(100.0, parser.parse("pow(10.0, ix)").evalD(null), 1E-10); assertEquals(100.0, parser.parse("pow(10.0, dx)").evalD(null), 1E-10); assertEquals(100.0, parser.parse("pow(10.0, dx)").evalD(null), 1E-10); }
@Test public void testSubstractionPositive() throws ParseException { final Term term = parser.parse("24 - +4"); assertEquals(20, term.evalI(env)); }
private Term createTerm(String expression) { Namespace namespace = createNamespace(); final Term term; try { Parser parser = new ParserImpl(namespace, false); term = parser.parse(expression); } catch (ParseException e) { String msg = MessageFormat.format("Could not parse expression: ''{0}''. {1}", expression, e.getMessage()); throw new OperatorException(msg, e); } return term; }
public void testThatPerformanceIsSufficient() throws ParseException, IOException { final Band flags = new Band("flags", ProductData.TYPE_INT8, 1, 1); final SingleFlagSymbol s1 = new SingleFlagSymbol("flags.WATER", flags, 0x01); final SingleFlagSymbol s2 = new SingleFlagSymbol("flags.LAND", flags, 0x02); final SingleFlagSymbol s3 = new SingleFlagSymbol("flags.CLOUD", flags, 0x04); final int[] dataElems = new int[]{-1}; s1.setData(dataElems); s2.setData(dataElems); s3.setData(dataElems); final DefaultNamespace namespace = new DefaultNamespace(); namespace.registerSymbol(s1); namespace.registerSymbol(s2); namespace.registerSymbol(s3); final String code = "(flags.WATER OR flags.LAND) AND NOT flags.CLOUD"; final Term term = new ParserImpl(namespace, true).parse(code); final RasterDataEvalEnv evalEnv = new RasterDataEvalEnv(0, 0, 1, 1); long t1 = System.currentTimeMillis(); for (int i = 0; i < MAX_NUM_TEST_LOOPS; i++) { } long t2 = System.currentTimeMillis(); for (int i = 0; i < MAX_NUM_TEST_LOOPS; i++) { term.evalI(evalEnv); } long t3 = System.currentTimeMillis(); long dt = (t3 - t2) - (t2 - t1); long numOps = Math.round(MAX_NUM_TEST_LOOPS * (1000.0 / dt)); // System.out.println("numOps = " + numOps); assertTrue(String.format("Low evaluation performance detected (%d ops/s for term \"%s\"): Term implementation change?", numOps, code), numOps > MIN_NUM_OPS_PER_SECOND); }
@Test public void testSubstractionWithoutSpaces() throws ParseException { final Term term = parser.parse("24-4"); assertEquals(20, term.evalI(env)); }
private boolean isValidExpression() { final Product[] products = getCompatibleProducts(); if (products.length == 0 || getExpression().isEmpty()) { return false; } final int defaultIndex = Arrays.asList(products).indexOf(targetProduct); final Namespace namespace = BandArithmetic.createDefaultNamespace(products, defaultIndex == -1 ? 0 : defaultIndex); final Parser parser = new ParserImpl(namespace, false); try { parser.parse(getExpression()); } catch (ParseException e) { return false; } return true; }
@Test public void testAdditionWithoutSpaces() throws ParseException { final Term term = parser.parse("24+4"); assertEquals(28, term.evalI(env)); }
defaultIndex == -1 ? 0 : defaultIndex); setParser(new ParserImpl(namespace, false));