public void Return_Clean_Sumandos() { CalculatorParser parserString = new CalculatorParser("//;1\n2;3"); CollectionAssert.AreEqual(new List <int>() { 1, 2, 3 }, parserString.Sumandos.ToList()); }
public void TestTrigFunction() { Assert.AreEqual(3 + Math.Sin(30) - 1, CalculatorParser.Resolve("3+sin(30)-1")); Assert.AreEqual(Math.Sin(330), CalculatorParser.Resolve("sin(330)")); Assert.AreEqual(Math.Sin(-330), CalculatorParser.Resolve("sin(-330)")); Assert.AreEqual(3 + Math.Cos(30) - 1 * 5, CalculatorParser.Resolve("3+cos(30)-1*5")); Assert.AreEqual(Math.Cos(300), CalculatorParser.Resolve("cos(300)")); Assert.AreEqual(Math.Cos(-300), CalculatorParser.Resolve("cos(-300)")); }
public void ParseTest2() { CalculatorParser parser = new CalculatorParser(); var actualResult = parser.Parse("(3.8-6.77)*(2.8+1)"); List <string> expectedResult = new List <string> { "(", "3.8", "-", "6.77", ")", "*", "(", "2.8", "+", "1", ")" }; CollectionAssert.AreEqual(expectedResult, actualResult); }
public void ParseTest4() { CalculatorParser parser = new CalculatorParser(); var actualResult = parser.Parse("-5a+6"); List <string> expectedResult = new List <string> { "-", "5", "a", "+", "6" }; CollectionAssert.AreEqual(expectedResult, actualResult); }
public void ParseTest1() { CalculatorParser parser = new CalculatorParser(); var actualResult = parser.Parse("1+2-3"); List <string> expectedResult = new List <string> { "1", "+", "2", "-", "3" }; CollectionAssert.AreEqual(expectedResult, actualResult); }
public void TestAdvancedExpression() { try { CalculatorParser.Resolve("5+4-3*2/1"); Assert.IsTrue(true); } catch (Exception) { Assert.Fail(); } }
public void TestSimpleExpression() { try { CalculatorParser.Resolve("1+1"); Assert.IsTrue(true); } catch (Exception) { Assert.Fail(); } }
public void TestInvalidCharacter() { try { CalculatorParser.Resolve("1+O"); Assert.Fail(); } catch (Exception ex) { Assert.AreEqual("Unknown term: 'O'", ex.Message); } }
public void TestMissingOperand() { try { CalculatorParser.Resolve("1+"); Assert.Fail(); } catch (Exception ex) { Assert.AreEqual("Invalid expression", ex.Message); } }
public void Test(string source, string expected) { Lexer lexer = new Lexer(source); Parser parser = new CalculatorParser(lexer); double result = parser.ParseExpression(); string actual = result.ToString(); if (expected != actual) { throw new ResultException(); } }
static void Main(string[] args) { Stream inputStream = Console.OpenStandardInput(); AntlrInputStream input = new AntlrInputStream(inputStream); CalculatorLexer lexer = new CalculatorLexer(input); lexer.AddErrorHandlers(); CommonTokenStream tokens = new CommonTokenStream(lexer); CalculatorParser parser = new CalculatorParser(tokens); parser.addSubExpr(); Console.ReadLine(); }
static int Evaluate(string input) { var stream = new AntlrInputStream(input); var lexer = new CalculatorLexer(stream); var tokens = new CommonTokenStream(lexer); var parser = new CalculatorParser(tokens); var program = parser.program(); var visitor = new CalcGrammarVisitor(); var result = visitor.Visit(program); return(result); }
public object Evaluate(string expression) { AntlrInputStream stream = new AntlrInputStream(expression); CalculatorLexer lexer = new CalculatorLexer(stream); CommonTokenStream tokenStream = new CommonTokenStream(lexer); CalculatorParser parser = new CalculatorParser(tokenStream); var root = parser.expression(); object result = root.Accept(m_processor); return(result); }
public void TestCalculator() { var testString = @"a=1+2*3; print a;"; CalculatorLexer lexer = new CalculatorLexer(new AntlrInputStream(testString)); CommonTokenStream tokens = new CommonTokenStream(lexer); CalculatorParser p = new CalculatorParser(tokens); p.BuildParseTree = true; p.AddParseListener(new CalculatorListener()); ParserRuleContext t = p.program(); }
public static void Main(String[] args) { var data = File.ReadAllText("input.txt"); var input = new AntlrInputStream(data); CalculatorLexer lexer = new CalculatorLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); CalculatorParser parser = new CalculatorParser(tokens); var tree = parser.input(); CalculatorBaseVisitorImpl calcVisitor = new CalculatorBaseVisitorImpl(); double result = calcVisitor.Visit(tree); Console.WriteLine("Result: " + result); }
public void TestOrderOfOperations() { Assert.AreEqual(5 + 3 * 6, CalculatorParser.Resolve("5+3*6")); Assert.AreEqual(7 * 3 - 10 / 2, CalculatorParser.Resolve("7*3-10/2")); Assert.AreEqual(4 * 6 / 3, CalculatorParser.Resolve("4*6/3")); // (4*6)/3 Assert.AreEqual(4 * 5 + 4 * 3, CalculatorParser.Resolve("4*5+4*3")); // (4*5) + (4*3) Assert.AreEqual(Math.Pow(4, 2) / 2, CalculatorParser.Resolve("4^2/2")); Assert.AreEqual(7 - 4 + 6 - 2, CalculatorParser.Resolve("7-4+6-2")); Assert.AreEqual(5 + 10 * 5, CalculatorParser.Resolve("5+10*5")); // 5+(10*5) Assert.AreEqual(8 + Math.Pow(5, 2) - 9, CalculatorParser.Resolve("8+5^2-9")); Assert.AreEqual(6 * 5 / 10 - 7, CalculatorParser.Resolve("6*5/10-7")); // (6*5) / (10-7) Assert.AreEqual(8 - 5 * Math.Pow(2, 2), CalculatorParser.Resolve("8-5*2^2")); Assert.AreEqual(2 + 3 * 5 - 4, CalculatorParser.Resolve("2+3*5-4")); }
private void button1_Click(object sender, EventArgs e) { var reader = new StringReader(Formula.Text); var input = new AntlrInputStream(reader.ReadToEnd()); var lexer = new CalculatorLexer(input); var tokens = new CommonTokenStream(lexer); var parser = new CalculatorParser(tokens); IParseTree tree = parser.prog(); Tree.Text = tree.ToStringTree(parser); var visitor = new CalculatorVisitor(); Result.Text = visitor.Visit(tree).ToString(); }
static void Main(string[] args) { while (true) { Stream inputStream = Console.OpenStandardInput(); AntlrInputStream input = new AntlrInputStream(inputStream); CalculatorLexer lexer = new CalculatorLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); CalculatorParser parser = new CalculatorParser(tokens); parser.prog(); Console.WriteLine("done"); Console.ReadLine(); } }
static void Main(string[] args) { var inputStream = new StreamReader(Console.OpenStandardInput()); var input = new AntlrInputStream(inputStream.ReadToEnd()); var lexer = new CalculatorLexer(input); var tokens = new CommonTokenStream(lexer); var parser = new CalculatorParser(tokens); IParseTree tree = parser.prog(); Console.WriteLine(tree.ToStringTree(parser)); var visitor = new CalculatorVisitor(); Console.WriteLine(visitor.Visit(tree)); }
static void Main(string[] args) { Stream inputStream = Console.OpenStandardInput(); AntlrInputStream input = new AntlrInputStream(inputStream); CalculatorLexer lexer = new CalculatorLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); CalculatorParser parser = new CalculatorParser(tokens); IParseTree tree = parser.prog(); Console.WriteLine(tree.ToStringTree()); Console.WriteLine("done"); //to know when it's done Console.ReadLine(); //to see the result }
private int EvaluateInput(string input) { CalculatorLexer lexer = new CalculatorLexer(new AntlrInputStream(input)); lexer.RemoveErrorListeners(); lexer.AddErrorListener(new ThrowingErrorListener <int>()); CalculatorParser parser = new CalculatorParser(new CommonTokenStream(lexer)); parser.RemoveErrorListeners(); parser.AddErrorListener(new ThrowingErrorListener <IToken>()); return(new CalculatorVisitor().Visit(parser.expression())); }
public void EvaluateTest() { // arrange string expresie = "1 ? 2"; CalculatorParser cp = new CalculatorParser(expresie); Operatie operatie = null; /// instructiune switch care foloseste type pattern /// valabil doar in C# v7.0 sau mai mare. switch (cp.Operatie) { case Add op: operatie = Operatii.Add; break; case Subtract op: operatie = Operatii.Subtract; break; case Multiply op: operatie = Operatii.Multiply; break; case Divide op: operatie = Operatii.Divide; break; default: break; } if (operatie == null) { return; } Calculator3 c3 = new Calculator3(cp.Op1, cp.Op2, operatie); // act c3.Evaluate(); int expected = -1; int actual = c3.Value; // assert Assert.AreEqual(expected, actual); }
public static double Evaluate(string expression) { var lexer = new CalculatorLexer(new AntlrInputStream(expression)); lexer.RemoveErrorListeners(); lexer.AddErrorListener(new ThrowExceptionErrorListener()); var tokens = new CommonTokenStream(lexer); var parser = new CalculatorParser(tokens); var tree = parser.compileUnit(); var visitor = new ExcelVisitor(); return(visitor.Visit(tree)); }
public CalculatorParserTest() { this._operations = new Mock <IOperationCollection>(); _operations.Setup(x => x.OperationList) .Returns(new List <IOperation>() { new Addition(), new Substraction(), new Multiplication(), new Division(), new Pow(), new Cos(), new Sin() }); this._parser = new CalculatorParser(_operations.Object); }
public void TestAngleModes() { Assert.AreEqual(CalculatorParser.Resolve("cos(sin(1))"), CalculatorParser.Resolve("cos(sin(1))", Utils.AngleMode.Rad)); Assert.AreEqual(0.034899496702501, CalculatorParser.Resolve("sin(2)", Utils.AngleMode.Deg), 0.000000000000001); Assert.AreEqual(1.460139105621001, CalculatorParser.Resolve("atan(9)", Utils.AngleMode.Rad), 0.000000000000001); Assert.AreEqual(0.998026728428272, CalculatorParser.Resolve("cos(4)", Utils.AngleMode.Grad), 0.000000000000001); Assert.AreEqual(28.63625328291560, CalculatorParser.Resolve("tan(88)", Utils.AngleMode.Deg), 0.0000000000001); try { CalculatorParser.Resolve("asin(62)", Utils.AngleMode.Rad); Assert.Fail(); } catch (Exception ex) { Assert.AreEqual("Invalid input", ex.Message); } }
static void Main(string[] args) { try { StreamReader inputStream = new StreamReader(Console.OpenStandardInput()); AntlrInputStream input = new AntlrInputStream(inputStream.ReadToEnd()); CalculatorLexer lexer = new CalculatorLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); CalculatorParser parser = new CalculatorParser(tokens); IParseTree tree = parser.prog(); Console.WriteLine(tree.ToStringTree(parser)); CalculatorVisitor visitor = new CalculatorVisitor(); Console.WriteLine(visitor.Visit(tree)); } catch (Exception ex) { Console.WriteLine(ex.Message); } Console.ReadLine(); }
static void Main(string[] args) { try { StreamReader inputStream = new StreamReader(Console.OpenStandardInput()); AntlrInputStream input = new AntlrInputStream(inputStream.ReadToEnd()); CalculatorLexer lexer = new CalculatorLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); CalculatorParser parser = new CalculatorParser(tokens); IParseTree tree = parser.input(); Console.WriteLine(tree.ToStringTree(parser)); CalculatorVisitor visitor = new CalculatorVisitor(); Console.WriteLine(visitor.Visit(tree)); } catch (DivideByZeroException ex) { Console.WriteLine("Cannot Divide By Zero"); } Console.ReadLine(); }
public void Test_Visitor_With_SingleExpression_And_MultipleVariables_Returns_Variables() { var expressions = @"x = (((nrm / (1 + pct)) * (1 + (iss/100) + (pis/100))) / (1 + (iss/100) + (pis/100))) * (1 + (iss/100) + (pis/100) + frd)"; AntlrInputStream input = new AntlrInputStream(expressions); CalculatorLexer lexer = new CalculatorLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); CalculatorParser parser = new CalculatorParser(tokens); IParseTree tree = parser.input(); CalculatorBaseVisitorImpl visitor = new CalculatorBaseVisitorImpl(); visitor.Variables.Add("nrm", 1223.5251m); visitor.Variables.Add("pct", 0.05m); visitor.Variables.Add("iss", 5m); visitor.Variables.Add("pis", 3m); visitor.Variables.Add("frd", 0.012m); visitor.Visit(tree); var result = visitor.Variables["x"]; }
public object Execute(string script) { AntlrInputStream stream = new AntlrInputStream(script); CalculatorLexer lexer = new CalculatorLexer(stream); CommonTokenStream tokenStream = new CommonTokenStream(lexer); CalculatorParser parser = new CalculatorParser(tokenStream); var root = parser.program(); if (root.IsEmpty && root.exception != null) { if (root.exception is RecognitionException) { throw new Exception("null"); } else { throw new InvalidOperationException(); } } object result = root.Accept(m_processor); return(result); }
static void Main(string[] args) { var expressions = @"x = (((nrm / (1 + pct)) * (1 + (iss/100) + (pis/100))) / (1 + (iss/100) + (pis/100))) * (1 + (iss/100) + (pis/100) + frd)"; AntlrInputStream input = new AntlrInputStream(expressions); CalculatorLexer lexer = new CalculatorLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); CalculatorParser parser = new CalculatorParser(tokens); IParseTree tree = parser.input(); CalculatorBaseVisitorImpl visitor = new CalculatorBaseVisitorImpl(); visitor.Variables.Add("nrm", 1223.5251m); visitor.Variables.Add("pct", 0.05m); visitor.Variables.Add("iss", 5m); visitor.Variables.Add("pis", 3m); visitor.Variables.Add("frd", 0.012m); visitor.Visit(tree); var result = visitor.Variables["x"]; Console.ReadLine(); }
/// <summary> /// This will attempt to recalculate if an error was encountered. Will try to skip whitespaces /// and comments so to prevent number literals and function qualifiers not being identified. /// </summary> /// <param name="formula"></param> /// <param name="secondRun"></param> /// <returns></returns> private static CalculationResult CalculateResult(string formula, bool secondRun) { if (string.IsNullOrWhiteSpace(formula)) { return(new CalculationResult { IsValid = true, Result = 0 }); } var inputStream = new AntlrInputStream(formula); var lexer = new CalculatorLexer(inputStream); var tokenStream = new CommonTokenStream(lexer); var parser = new CalculatorParser(tokenStream); // Removing default error listeners due to noise in debug lexer.RemoveErrorListeners(); parser.RemoveErrorListeners(); // But adding the custom one var customErrorListener = new CalculatorErrorListener(); parser.AddErrorListener(customErrorListener); var visitor = new CalculatorVisitor(); var calculatorExpression = parser.calculator().expression(); var result = visitor.Visit(calculatorExpression); var isValid = customErrorListener.IsValid; var errorLocation = customErrorListener.ErrorLocation; var errorMessage = customErrorListener.ErrorMessage; if (double.IsInfinity(result)) { isValid = false; } if (!isValid && !secondRun) { var cleanedFormula = string.Empty; var tokenList = tokenStream.GetTokens().ToList(); for (var i = 0; i < tokenList.Count - 1; i++) { cleanedFormula += tokenList[i].Text; } var originalErrorLocation = errorLocation; var retriedResult = CalculateResult(cleanedFormula, true); if (!retriedResult.IsValid) { retriedResult.ErrorPosition = originalErrorLocation; retriedResult.ErrorMessage = errorMessage; } return(retriedResult); } return(new CalculationResult { IsValid = isValid, Result = isValid || double.IsInfinity(result) ? result : double.NaN, ErrorPosition = errorLocation, ErrorMessage = isValid ? null : errorMessage }); }