private static void DumpValueExpression(StringWriter s, SBExpression expression, string ident = " ")
{
if (expression is NegativeExpression)
{
NegativeExpression negativeExpression = (NegativeExpression)expression;
s.WriteLine(ident + $"-----> Expression: {negativeExpression.Expression.Dump()}");
DumpValueExpression(s, negativeExpression.Expression, ident + " ");
}
else if (expression is BinaryExpression)
{
BinaryExpression binaryExpression = (BinaryExpression)expression;
s.WriteLine(ident + $"-----> Operator: {binaryExpression.Operator.Dump()}");
s.WriteLine(ident + $"-----> LeftHandSide: {binaryExpression.LeftHandSide.Dump()}");
DumpValueExpression(s, binaryExpression.LeftHandSide, ident + " ");
s.WriteLine(ident + $"-----> RightHandSide: {binaryExpression.RightHandSide.Dump()}");
DumpValueExpression(s, binaryExpression.RightHandSide, ident + " ");
}
else if (expression is MethodCallExpression)
{
MethodCallExpression methodCallExpression = (MethodCallExpression)expression;
s.WriteLine($"{ident}-----> MethodName: {methodCallExpression.MethodName.Dump()}");
s.WriteLine($"{ident}-----> TypeName: {methodCallExpression.TypeName.Dump()}");
s.WriteLine($"{ident}-----> Arguments: {methodCallExpression.Arguments}");
}
else if (expression is PropertyExpression)
{
PropertyExpression propertyExpression = (PropertyExpression)expression;
s.WriteLine($"{ident}-----> PropertyName: {propertyExpression.PropertyName.Dump()}");
s.WriteLine($"{ident}-----> TypeName: {propertyExpression.TypeName.Dump()}");
}
}
public static IEnumerable <SBExpression> GetSubExpressions(this SBExpression expression)
{
if (expression is NegativeExpression)
{
NegativeExpression negativeExpression = (NegativeExpression)expression;
return(new SBExpression[] { negativeExpression.Expression }.Concat(negativeExpression.Expression.GetSubExpressions()));
}
else if (expression is BinaryExpression)
{
BinaryExpression binaryExpression = (BinaryExpression)expression;
return(new SBExpression[] { binaryExpression.LeftHandSide, binaryExpression.RightHandSide }
.Concat(binaryExpression.LeftHandSide.GetSubExpressions())
.Concat(binaryExpression.RightHandSide.GetSubExpressions()));
}
else if (expression is ArrayExpression)
{
ArrayExpression arrayExpression = (ArrayExpression)expression;
return(new SBExpression[] { arrayExpression.LeftHand, arrayExpression.Indexer }
.Concat(arrayExpression.LeftHand.GetSubExpressions())
.Concat(arrayExpression.Indexer.GetSubExpressions()));
}
else if (expression is MethodCallExpression)
{
MethodCallExpression methodCallExpression = (MethodCallExpression)expression;
return(methodCallExpression.Arguments
.Concat(methodCallExpression.Arguments.SelectMany(a => a.GetSubExpressions())));
}
else
{
return(new SBExpression[0]);
}
}
public TypeNode Dispatch(ExpressionNode node, List <TypeNode> parameterTypes)
{
return(node switch
{
IBinaryNumberOperator n => _numberHelper.VisitBinaryNumOp(n, parameterTypes),
IBinaryBooleanOperator n => _booleanHelper.VisitBinaryBoolOp(n, parameterTypes),
IBinarySetOperator n => _setHelper.VisitBinarySetOp(n, parameterTypes),
SubsetExpression n => _setHelper.VisitSubset(n, parameterTypes),
SetExpression n => _setHelper.VisitSet(n, parameterTypes),
NotExpression n => _booleanHelper.VisitNot(n, parameterTypes),
FunctionCallExpression n => _declarationHelper.VisitFunctionCall(n, parameterTypes),
IdentifierExpression n => _declarationHelper.VisitIdentifier(n, parameterTypes),
IntegerLiteralExpression _ => _declarationHelper.VisitIntegerLiteral(),
RealLiteralExpression _ => _declarationHelper.VisitRealLiteral(),
BooleanLiteralExpression _ => _declarationHelper.VisitBooleanLiteral(),
StringLiteralExpression _ => _declarationHelper.VisitStringLiteral(),
EmptySetLiteralExpression _ => _declarationHelper.VisitEmptySetLiteral(),
AdditionExpression n => _commonOperatorHelper.VisitAddition(n, parameterTypes),
SubtractionExpression n => _commonOperatorHelper.VisitSubtraction(n, parameterTypes),
AbsoluteValueExpression n => _commonOperatorHelper.VisitAbsoluteValue(n, parameterTypes),
IRelationOperator n => _commonOperatorHelper.VisitRelationalOperator(n, parameterTypes),
IEquivalenceOperator n => _commonOperatorHelper.VisitEquivalenceOperator(n, parameterTypes),
NegativeExpression n => _numberHelper.VisitNegative(n, parameterTypes),
ElementExpression n => _commonOperatorHelper.VisitElement(n, parameterTypes),
ISetGraphField n => _commonOperatorHelper.VisitISetGraphField(n, parameterTypes),
IFunctionGraphField n => _commonOperatorHelper.VisitIFunctionGraphField(n, parameterTypes),
GraphExpression n => _commonOperatorHelper.VisitGraph(n, parameterTypes),
AnonymousFunctionExpression n => _declarationHelper.VisitAnonymousFunction(n, parameterTypes),
_ => throw new UnimplementedTypeCheckerException(node, "Dispatch"),
});
public TypeNode VisitNegative(NegativeExpression node, List <TypeNode> parameterTypes)
{
TypeNode childNodeType = _getType(node.Children[0], parameterTypes);
if (!IsNumber(childNodeType.Type))
{
throw new UnableToNegateTermException(node.Children[0], childNodeType.ToString());
}
return(childNodeType);
}
public void ParseNegativeInteger()
{
Parser parser = new Parser("-123");
var expected = new NegativeExpression(new ConstantExpression(123));
var result = parser.ParseExpression();
Assert.IsNotNull(result);
Assert.AreEqual(expected, result);
Assert.IsNull(parser.ParseExpression());
}
public void Equals()
{
NegativeExpression expr1 = new NegativeExpression(new ConstantExpression(1));
NegativeExpression expr2 = new NegativeExpression(new ConstantExpression(2));
NegativeExpression expr3 = new NegativeExpression(new ConstantExpression(1));
Assert.IsTrue(expr1.Equals(expr3));
Assert.IsTrue(expr3.Equals(expr1));
Assert.AreEqual(expr1.GetHashCode(), expr3.GetHashCode());
Assert.IsFalse(expr1.Equals(null));
Assert.IsFalse(expr1.Equals("foo"));
Assert.IsFalse(expr1.Equals(expr2));
Assert.IsFalse(expr2.Equals(expr1));
}
public void NegativeReal_Real_CorrectNegativeValue(double input, double expected)
{
RealLiteralExpression realLitExpr = new RealLiteralExpression(input, 0, 0);
NegativeExpression negExpr = new NegativeExpression(new List <ExpressionNode>()
{
realLitExpr
}, 0, 0);
IInterpreterReal parent = Substitute.For <IInterpreterReal>();
parent.DispatchReal(realLitExpr, Arg.Any <List <object> >()).Returns(input);
RealHelper realHelper = SetUpHelper(parent);
double res = realHelper.NegativeReal(negExpr, new List <object>());
Assert.AreEqual(expected, res);
}
public void NegativeInteger_Integer_CorrectNegativeValue(int input, int expected)
{
IntegerLiteralExpression intLitExpr = new IntegerLiteralExpression(input, 0, 0);
NegativeExpression negExpr = new NegativeExpression(new List <ExpressionNode>()
{
intLitExpr
}, 0, 0);
IInterpreterInteger parent = Substitute.For <IInterpreterInteger>();
parent.DispatchInt(intLitExpr, Arg.Any <List <object> >()).Returns(input);
IntegerHelper integerHelper = SetUpHelper(parent);
double res = integerHelper.NegativeInteger(negExpr, new List <object>());
Assert.AreEqual(expected, res);
}
public override void Visit(NegativeExpression node)
{
unfinishedClone = new NegativeExpression(GetCloneOf(node.Expression));
base.Visit(node);
}
public override bool Apply(NegativeExpression expression, NormalizedCharSet param)
{
return(false);
}
public void NegativeIntegers()
{
NegativeExpression expr = new NegativeExpression(new ConstantExpression(1));
Assert.AreEqual(-1, expr.Evaluate(null));
}
public ValueType Visit(NegativeExpression expression, ITypeEnvironment environment)
{
return(this.CheckUnaryMatematicalExpression(expression, environment));
}
public override void Visit(NegativeExpression node)
{
UpdateType(node, TypeCalculator.GetType(node));
}
private IExpression ParseTerm()
{
IExpression expression = null;
if (this.TryParseToken(TokenType.Operator, "-"))
{
expression = new NegativeExpression(this.ParseTerm());
}
else if (this.TryParseToken(TokenType.Operator, "+"))
{
expression = this.ParseTerm();
}
else if (this.TryParseToken(TokenType.Operator, "!"))
{
expression = new NegationExpression(this.ParseTerm());
}
else
{
expression = this.ParseSimpleTerm();
}
if (expression == null)
{
return(null);
}
while (true)
{
if (this.TryParseToken(TokenType.Separator, "."))
{
string name = this.ParseName();
if (this.TryParseToken(TokenType.Separator, "{"))
{
expression = new DotExpression(expression, name, new IExpression[] { this.ParseBlockExpression(true) });
}
else if (this.NextTokenStartsExpressionList())
{
expression = new DotExpression(expression, name, this.ParseExpressionList());
}
else
{
expression = new DotExpression(expression, name, new IExpression[0]);
}
continue;
}
if (this.TryParseToken(TokenType.Separator, "::"))
{
string name = this.ParseName();
expression = new DoubleColonExpression(expression, name);
continue;
}
if (this.TryParseToken(TokenType.Separator, "["))
{
IExpression indexexpr = this.ParseExpression();
this.ParseToken(TokenType.Separator, "]");
expression = new IndexedExpression(expression, indexexpr);
continue;
}
break;
}
return(expression);
}
// Menghasilkan output dari list of string dari input
public static dynamic solver(List <string> input)
{
dynamic Ret = 0;
Boolean isNow = false;
Stack <double> NumS = new Stack <double>();
Stack <string> OpS = new Stack <string>();
// Memisahkan ke dalam stack
for (int i = 0; i < input.Count; i++)
{
// Kalau operator masuk sini
if (input[i].Equals("+") || input[i].Equals("-") || input[i].Equals("x") || input[i].Equals(":") || input[i].Equals("√"))
{
if (!isNow && (input[i].Equals("x") || input[i].Equals(":") || input[i].Equals("-")))
{
isNow = true;
OpS.Push(input[i]);
}
else if (isNow && input[i].Equals("-"))
{
if (input[i - 1].Equals("+"))
{
dynamic Num1 = input[i + 1];
NegativeExpression <dynamic> E = new NegativeExpression <dynamic>(new TerminalExpression <dynamic>(Num1));
NumS.Push(E.solve());
i++;
isNow = false;
}
else if (input[i - 1].Equals("-"))
{
dynamic Num1 = input[i + 1];
NegativeExpression <dynamic> E = new NegativeExpression <dynamic>(new TerminalExpression <dynamic>(Num1));
NumS.Push(E.solve());
i++;
isNow = false;
}
else
{
dynamic Num1 = input[i + 1];
NegativeExpression <dynamic> E = new NegativeExpression <dynamic>(new TerminalExpression <dynamic>(Num1));
dynamic Num3 = E.solve();
dynamic Num4 = NumS.Pop(); //Convert.ToDouble(input[i-2]);
if (input[i - 1].Equals("x"))
{
MultiplyExpression <dynamic> E2 = new MultiplyExpression <dynamic>(new TerminalExpression <dynamic>(Num3), new TerminalExpression <dynamic>(Num4));
NumS.Push(E2.solve());
Ret = E2.solve();
isNow = false;
i++;
}
else
{
DivideExpression <dynamic> E2 = new DivideExpression <dynamic>(new TerminalExpression <dynamic>(Num4), new TerminalExpression <dynamic>(Num3));
NumS.Push(E2.solve());
Ret = E2.solve();
isNow = false;
i++;
}
}
}
else
{
OpS.Push(input[i]);
}
}
else // Kalau angka masuk sini
{
if (isNow)
{
string Op = OpS.Pop(); // OMengambil Operatornya dan solve
if (Op.Equals("x"))
{
dynamic Num1 = NumS.Pop();
dynamic Num2 = Convert.ToDouble(input[i]);
MultiplyExpression <dynamic> E = new MultiplyExpression <dynamic>(new TerminalExpression <dynamic>(Num1), new TerminalExpression <dynamic>(Num2));
NumS.Push(E.solve());
Ret = E.solve();
}
else if (Op.Equals(":"))
{
dynamic Num1 = NumS.Pop();
dynamic Num2 = Convert.ToDouble(input[i]);
DivideExpression <dynamic> E = new DivideExpression <dynamic>(new TerminalExpression <dynamic>(Num1), new TerminalExpression <dynamic>(Num2));
NumS.Push(E.solve());
Ret = E.solve();
}
else if (Op.Equals("-"))
{
dynamic Num1 = input[i];
NegativeExpression <dynamic> E = new NegativeExpression <dynamic>(new TerminalExpression <dynamic>(Num1));
if (i != 1 && (!input[i - 2].Equals("+") && !input[i - 2].Equals("√")))
{
OpS.Push("+");
}
NumS.Push(E.solve());
}
isNow = false;
}
else
{
double P = Convert.ToDouble(input[i]);
NumS.Push(P);
}
}
}
// Solve dari Stack
int count = OpS.Count;
for (int i = 0; i < count; i++)
{
string Op = OpS.Pop();
if (Op.Equals("+"))
{
dynamic Num1 = NumS.Pop();
dynamic Num2 = NumS.Pop();
AddExpression <dynamic> E = new AddExpression <dynamic>(new TerminalExpression <dynamic>(Num1), new TerminalExpression <dynamic>(Num2));
NumS.Push(E.solve());
Ret = E.solve();
}
else if (Op.Equals("-"))
{
dynamic Num1 = NumS.Pop();
dynamic Num2 = NumS.Pop();
SubstractExpression <dynamic> E = new SubstractExpression <dynamic>(new TerminalExpression <dynamic>(Num2), new TerminalExpression <dynamic>(Num1));
NumS.Push(E.solve());
Ret = E.solve();
}
else if (Op.Equals("√"))
{
dynamic Num1 = NumS.Pop();
RootExpression <dynamic> E = new RootExpression <dynamic>(new TerminalExpression <dynamic>(Num1));
double temp = Convert.ToDouble(E.solve());
NumS.Push(temp);
Ret = E.solve();
}
}
return(Ret);
}
public IValue Visit(NegativeExpression expression, TypeEnvironment environment)
{
return(expression.Expression
.Accept(this, environment)
.Negative());
}
private void buttonResult_onClick(object sender, EventArgs e)
{
int i = 0;
string ekspresi = labelScreen.Text;
double ans;
TerminalExpression ansNow;
TerminalExpression operandWithClass;
ansNow = new TerminalExpression();
//double ansNow = 0;
StringBuilder ekspresi1 = new StringBuilder();
if (ekspresi.Length == 0)
{
labelScreen.Text = "Error: Nothing inside";
isError = true;
}
else
{
double operand;
try
{
while (i < ekspresi.Length)
{
if (ekspresi[i] == '-' && ekspresi[i + 1] != ' ')
{
unaryOp = '-';
}
else if (ekspresi[i] == '+' || ekspresi[i] == '-' || ekspresi[i] == '*' || ekspresi[i] == '÷')
{
operand = double.Parse(ekspresi1.ToString(), System.Globalization.CultureInfo.InvariantCulture);
TerminalExpression transition = new TerminalExpression(operand);
if (unaryOp == '-')
{
NegativeExpression <double> negative = new NegativeExpression <double>(transition);
ansNow.setX(negative.solve());
unaryOp = ' ';
}
else
{
ansNow.setX(operand);
}
op = ekspresi[i];
ekspresi1.Clear();
}
else if (ekspresi[i] == '√')
{
unaryOp = '√';
}
else
{
ekspresi1.Append(ekspresi[i]);
}
i++;
}
operand = double.Parse(ekspresi1.ToString(), System.Globalization.CultureInfo.InvariantCulture);
if (unaryOp == '-')
{
operand = operand * -1;
unaryOp = ' ';
}
operandWithClass = new TerminalExpression(operand);
if (unaryOp == '√')
{
ans = CalculateUnary(operandWithClass);
//operand = Math.Sqrt(operand);
unaryOp = ' ';
}
else if (op == ' ')
{
ans = operand;
}
else
{
ans = CalculateBinary(ansNow, operandWithClass);
}
ans = Math.Round(ans, 5);
labelScreen.Text = ans.ToString(System.Globalization.CultureInfo.InvariantCulture);
lastStrNumber = ans.ToString(System.Globalization.CultureInfo.InvariantCulture);
isDecimal = false;
isNegative = false;
numberDecimal.Clear();
isOpInLast = false;
isRoot = false;
isOneOp = false;
nilaiAnswer = double.Parse(ans.ToString(System.Globalization.CultureInfo.InvariantCulture), System.Globalization.CultureInfo.InvariantCulture);
isAnswer = true;
hasAnswer = true;
bool hasKoma = false;
int temp = 0;
while ((temp < labelScreen.Text.Length) && (!hasKoma))
{
if (labelScreen.Text[temp] == '.')
{
hasKoma = true;
}
else
{
temp++;
}
}
if (hasKoma)
{
isDecimal = true;
}
op = ' ';
}
catch (Error a)
{
clearData();
isError = true;
op = ' ';
labelScreen.Text = a.printMessage();
}
}
isDecimal = true;
}
static void Main(string[] args)
{
Calculator Calcu = new Calculator();
/*
* Testing Kalkulasi
* 1) 2+3
* 2) 2-3
* 3) 10:2
* 4) 10.5x2.3
* 5) √99
* 6) -5+-5
* 7) 5x-10
* 8) √10+10
* 9) -10+5x-10--5
* 10) -10+-5:10--5
* 11) 20+-10+√100
* 12) -30-100:10+-10+√1000
*
* Testing Exception
* 1) 10:0
* 2) √-10
* 3) +5-3
* 4) 5++2
* 5) 12-98-
* 6) 12-+32
* 7) 10√
* 8) √:10
* 9) 10.12√2
* 10) 10.2.3
*
*/
Calcu.Input = "-30-100:10+-10+√1000";
Console.WriteLine("Input : " + Calcu.Input);
Calcu.Input = Calcu.Input.Replace(".", ",");
Calcu.Lstring = Parse.makeList(Calcu.Input);
//Testing parse
Console.WriteLine("\nHasil Parse Input");
foreach (var elmt in Calcu.Lstring)
{
Console.WriteLine(elmt);
}
try
{
bool valid = Calcu.Validate(Calcu.Lstring);
if (Calcu.Lstring.Count != 1)
{
Calcu.Hasil = Solving.solver(Calcu.Lstring).ToString();
Calcu.Hasil = Calcu.Hasil.Replace(",", ".");
Console.WriteLine("\nHasil : " + Calcu.Hasil);
Calcu.Ans = Calcu.Hasil;
}
else
{
Calcu.Ans = Calcu.Input.Replace(",", ".");
}
}
catch (InvalidExpression Error)
{
Console.WriteLine("Hasil : " + Error.Message);
}
// Testing Expression
double Num1 = 5;
double Num2 = 4;
Console.WriteLine("\nTestingExpression");
AddExpression <dynamic> E = new AddExpression <dynamic>(new TerminalExpression <dynamic>(Num1), new TerminalExpression <dynamic>(Num2));
Console.WriteLine("Terminal Ekspression 1 : " + Num1);
Console.WriteLine("Terminal Ekspression 2 : " + Num2);
Console.WriteLine("Hasil AddExpression : " + E.solve());
SubstractExpression <dynamic> E2 = new SubstractExpression <dynamic>(new TerminalExpression <dynamic>(Num1), new TerminalExpression <dynamic>(Num2));
Console.WriteLine("\nTerminal Ekspression 1 : " + Num1);
Console.WriteLine("Terminal Ekspression 2 : " + Num2);
Console.WriteLine("Hasil SubstractExpression : " + E2.solve());
MultiplyExpression <dynamic> E3 = new MultiplyExpression <dynamic>(new TerminalExpression <dynamic>(Num1), new TerminalExpression <dynamic>(Num2));
Console.WriteLine("\nTerminal Ekspression 1 : " + Num1);
Console.WriteLine("Terminal Ekspression 2 : " + Num2);
Console.WriteLine("Hasil MultiplyExpression : " + E3.solve());
DivideExpression <dynamic> E4 = new DivideExpression <dynamic>(new TerminalExpression <dynamic>(Num1), new TerminalExpression <dynamic>(Num2));
Console.WriteLine("\nTerminal Ekspression 1 : " + Num1);
Console.WriteLine("Terminal Ekspression 2 : " + Num2);
Console.WriteLine("Hasil DivideExpression : " + E4.solve());
NegativeExpression <dynamic> E5 = new NegativeExpression <dynamic>(new TerminalExpression <dynamic>(Num1));
Console.WriteLine("\nTerminal Ekspression 1 : " + Num1);
Console.WriteLine("Hasil NegativeExpression : " + E5.solve());
RootExpression <dynamic> E6 = new RootExpression <dynamic>(new TerminalExpression <dynamic>(Num1));
Console.WriteLine("\nTerminal Ekspression 1 : " + Num1);
Console.WriteLine("Hasil RootExpression : " + E6.solve());
Console.ReadLine();
}
public int NegativeInteger(NegativeExpression node, List <object> parameters)
{
return(-_interpreter.DispatchInt(node.Children[0], parameters));
}
public virtual TResult Visit(NegativeExpression expression, TEnvironment environment)
{
return(this.Visit((UnaryExpression)expression, environment));
}
public override void Visit(NegativeExpression node)
{
Visit((UnaryExpression)node);
}
public double NegativeReal(NegativeExpression node, List <object> parameters)
{
return(-_interpreter.DispatchReal(node.Children[0], parameters));
}
public override void Visit(NegativeExpression node)
{
AssignToImplicitReturn(node);
}
