private void registerDefaultSymbols() { registerSymbol(SymbolFactory.createConstant("PI", Math.PI)); registerSymbol(SymbolFactory.createConstant("E", Math.E)); registerSymbol(SymbolFactory.createConstant("NaN", Double.NaN)); }
private boolean isExpressionValid(String expression, String qualifiedSorceName) { if (expression == null || expression.trim().isEmpty()) { return true; } if (expression.trim().equals(qualifiedSorceName.trim())) { return false; } try { final DefaultNamespace expressionValidationNamespace = new DefaultNamespace(); expressionValidationNamespace.registerSymbol(SymbolFactory.createVariable(qualifiedSorceName, 0.0)); final Term term = parser.parse(expression, expressionValidationNamespace); return term != null && term.isB(); } catch (ParseException ignored) { return false; } }
private static void registerConstant(WritableNamespace namespace, final String symbolName, Object propertyValue) { final Class getterType = propertyValue.getClass(); if (getterType.equals(Double.class) || getterType.equals(Float.class)) { namespace.registerSymbol(SymbolFactory.createConstant(symbolName, ((Number) propertyValue).doubleValue())); } else if (getterType.equals(Byte.class) || getterType.equals(Short.class) || getterType.equals(Integer.class) || getterType.equals(Long.class)) { namespace.registerSymbol(SymbolFactory.createConstant(symbolName, ((Number) propertyValue).intValue())); } else if (getterType.equals(Boolean.class)) { namespace.registerSymbol( SymbolFactory.createConstant(symbolName, (Boolean) propertyValue)); } }
@Override public void adaptTo(Object timeSeriesKey, AxisMapping axisMapping) { if (timeSeriesExpressionsMap.containsKey(timeSeriesKey)) { currentExpressionMap = timeSeriesExpressionsMap.get(timeSeriesKey); } else { currentExpressionMap = new HashMap<String, String>(); timeSeriesExpressionsMap.put(timeSeriesKey, currentExpressionMap); } qualifiedSourceNames = extractQualifiedSourceNames(axisMapping); namespace = new DefaultNamespace(); for (String qualifiedSourceName : qualifiedSourceNames) { namespace.registerSymbol(SymbolFactory.createVariable(qualifiedSourceName, 0.0)); } if (qualifiedSourceNames.size() > 0 && hasUI) { expressionTextField.setEnabled(true); sourceNamesDropDown.setEnabled(true); sourceNamesDropDown.setModel(new DefaultComboBoxModel(getSourceNames())); final String expression = getExpressionFor(getSelectedSourceName()); expressionTextField.setText(expression == null ? "" : expression); } }
private Namespace createNamespace() { WritableNamespace namespace = BandArithmetic.createDefaultNamespace(sourceProducts, 0, new SourceProductPrefixProvider()); if (variables != null) { for (Variable variable : variables) { if (ProductData.isFloatingPointType(ProductData.getType(variable.type))) { Symbol symbol = SymbolFactory.createConstant(variable.name, Double.parseDouble(variable.value)); namespace.registerSymbol(symbol); } else if (ProductData.isIntType(ProductData.getType(variable.type))) { Symbol symbol = SymbolFactory.createConstant(variable.name, Long.parseLong(variable.value)); namespace.registerSymbol(symbol); } else if ("boolean".equals(variable.type)) { Symbol symbol = SymbolFactory.createConstant(variable.name, Boolean.parseBoolean(variable.value)); namespace.registerSymbol(symbol); } } } return namespace; }
private void initParser() { final String sourceName = getSelectedSourceName(); final Variable sourceVariable = SymbolFactory.createVariable(sourceName, 0.0); final DefaultNamespace namespace = new DefaultNamespace(); namespace.registerSymbol(sourceVariable); setParser(new ParserImpl(namespace, true)); }
final WritableNamespace namespace = BandArithmetic.createDefaultNamespace(products, defaultProductIndex); namespace.registerSymbol(SymbolFactory.createConstant(paramName.getValueAsText(), 0)); final Term term = new ParserImpl(namespace, false).parse(expression); if (!term.isB()) {
@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)); }
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)); }
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)); }