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);
lexer.AddErrorHandlers();
CommonTokenStream tokens = new CommonTokenStream(lexer);
CalculatorParser parser = new CalculatorParser(tokens);
parser.addSubExpr();
Console.ReadLine();
}
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
});
}
