/** * 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 testNaNConst() throws ParseException { Term term = parser.parse("NaN"); assertTrue(Double.isNaN(term.evalD(env))); }
@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)); }
@Test public void testSubstraction() throws ParseException { final Term term = parser.parse("24 - 4"); assertEquals(20, term.evalI(env)); }
@Test public void testSubstractionNumber() throws ParseException { final Term term = parser.parse("24 -4"); assertEquals(20, term.evalI(env)); }
@Test public void testAddition() throws ParseException { final Term term = parser.parse("24 + 4"); assertEquals(28, term.evalI(env)); }
@Test public void testAdditionNumber() throws ParseException { final Term term = parser.parse("24 +4"); assertEquals(28, term.evalI(env)); }
@Test public void testSubstractionPositive() throws ParseException { final Term term = parser.parse("24 - +4"); assertEquals(20, term.evalI(env)); }
@Test public void testSubstractionWithoutSpaces() throws ParseException { final Term term = parser.parse("24-4"); assertEquals(20, term.evalI(env)); }
@Test public void testAdditionWithoutSpaces() throws ParseException { final Term term = parser.parse("24+4"); assertEquals(28, term.evalI(env)); }
@Test public void testDistanceDerivFunction() throws ParseException { Term term = parser.parse("distance_deriv(0.1, 0.2, 0.3, 1.4, 1.3, 1.1)"); assertNotNull(term); assertNotNull(term.getChildren()); assertEquals(6, term.getChildren().length); double d1 = (0.2 - 0.1) - (1.3 - 1.4); double d2 = (0.3 - 0.2) - (1.1 - 1.3); assertEquals(Math.sqrt(d1 * d1 + d2 * d2), term.evalD(env), 1.e-10); }
@Test public void testDistanceFunction() throws ParseException { Term term = parser.parse("distance(0.1, 0.2, 0.3, 0.4, 0.3, 0.1)"); assertNotNull(term); assertNotNull(term.getChildren()); assertEquals(6, term.getChildren().length); double d1 = 0.1 - 0.4; double d2 = 0.2 - 0.3; double d3 = 0.3 - 0.1; assertEquals(Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3), term.evalD(env), 1.e-10); }
@Test public void testDistanceIntegFunction() throws ParseException { Term term = parser.parse("distance_integ(0.1, 0.2, 0.3, 1.4, 1.3, 1.1)"); assertNotNull(term); assertNotNull(term.getChildren()); assertEquals(6, term.getChildren().length); double d1 = (0.1) - (1.4); double d2 = (0.1 + 0.2) - (1.4 + 1.3); double d3 = (0.1 + 0.2 + 0.3) - (1.4 + 1.3 + 1.1); assertEquals(Math.sqrt(d1 * d1 + d2 * d2 + d3 * d3), term.evalD(env), 1.e-10); }
@Test public void testIntegerMaxValueConst() throws ParseException { final int maxValue = Integer.MAX_VALUE; final String maxValueString = Integer.toString(maxValue); Term term = parser.parse(maxValueString); assertEquals(true, term.evalB(env)); assertEquals(maxValue, term.evalI(env)); assertEquals(maxValue, term.evalD(env), 0.0); assertEquals(maxValueString, term.evalS(env)); assertEquals(maxValueString, term.toString()); }
@Test public void testBooleanConst() throws ParseException { Term term = parser.parse("true"); assertEquals(true, term.evalB(env)); assertEquals(1, term.evalI(env)); assertEquals(1.0, term.evalD(env), 0.0); assertEquals("true", term.evalS(env)); assertEquals("true", term.toString()); }
@Test public void testIntegerConst() throws ParseException { Term term = parser.parse("85321"); assertEquals(true, term.evalB(env)); assertEquals(85321, term.evalI(env)); assertEquals(85321.0, term.evalD(env), 0.0); assertEquals("85321", term.evalS(env)); assertEquals("85321", term.toString()); }
@Test public void testFloatConst() throws ParseException { Term term = parser.parse("1.79"); assertEquals(true, term.evalB(env)); assertEquals(1, term.evalI(env)); assertEquals(1.79, term.evalD(env), 1e-10); assertEquals("1.79", term.evalS(env)); assertEquals("1.79", term.toString()); }
@Test public void testNumberString() throws ParseException { Term term = parser.parse("\"374\""); try { assertEquals(true, term.evalB(env)); fail("EvalException?"); } catch (EvalException e) { } assertEquals(374, term.evalI(env)); assertEquals(374.0, term.evalD(env), 1e-10); assertEquals("374", term.evalS(env)); assertEquals("\"374\"", term.toString()); }
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)); }