public void Clone_SinExpression() { //Arrange var expected = new SinExpression(new NumberExpression(0), new Complex(3, 2)); //Act var actual = (SinExpression)expected.Clone(); //Assert Assert.IsTrue(!Object.ReferenceEquals(actual, expected)); Assert.IsTrue(!Object.ReferenceEquals(actual.Argument, expected.Argument)); Assert.AreEqual(expected.Count.Re.Numerator, actual.Count.Re.Numerator); Assert.AreEqual(expected.Count.Re.Denominator, actual.Count.Re.Denominator); Assert.AreEqual(expected.Count.Im.Numerator, actual.Count.Im.Numerator); Assert.AreEqual(expected.Count.Im.Denominator, actual.Count.Im.Denominator); }
//Sin(Expr) //Random(10,20) //Avg([1,3,4]) //Sum([10,20,30,40,50]) private Expression Factor() { Token token; Expression expression; if (_currentToken == Token.Double) { expression = new NumericConstant(_lexicalAnalyzer.GetDigits()); _currentToken = _lexicalAnalyzer.GetToken(); } else if (_currentToken == Token.Param) { expression = new Var(); _currentToken = _lexicalAnalyzer.GetToken(); } else if (_currentToken == Token.Sin || _currentToken == Token.Cos) { Token old = _currentToken; _currentToken = _lexicalAnalyzer.GetToken(); if (_currentToken != Token.OParen) { throw new Exception("Illegal Token"); } _currentToken = _lexicalAnalyzer.GetToken(); expression = Expr(); if (_currentToken != Token.CParen) { throw new Exception("Missing Closeing Parenthesis\n"); } if (old == Token.Cos) { expression = new CosExpression(expression); } else { expression = new SinExpression(expression); } _currentToken = _lexicalAnalyzer.GetToken(); } else if (_currentToken == Token.OParen) { _currentToken = _lexicalAnalyzer.GetToken(); expression = Expr(); if (_currentToken != Token.CParen) { throw new Exception("Missing Closing Parenthesis\n"); } _currentToken = _lexicalAnalyzer.GetToken(); } else if (_currentToken == Token.Plus || _currentToken == Token.Sub) { var old = _currentToken; _currentToken = _lexicalAnalyzer.GetToken(); expression = Factor(); expression = new UnaryExpression(expression, old == Token.Plus?Operator.Plus:Operator.Minus); } else { throw new Exception("error"); } return(expression); }
private IExpression DoFactor() { if (currentToken == Token.Double) { var expression = new NumericConstantExpression(lexicalAnalyzer.CurrentValue); currentToken = lexicalAnalyzer.GetCurrentToken(); return(expression); } else if (currentToken == Token.Param) { var expression = new VariableExpression(lexicalAnalyzer.CurrentParameter); currentToken = lexicalAnalyzer.GetCurrentToken(); return(expression); } else if (currentToken == Token.Sin || currentToken == Token.Cos || currentToken == Token.Tan || currentToken == Token.Cot) { var old = currentToken; currentToken = lexicalAnalyzer.GetCurrentToken(); if (currentToken != Token.OParen) { throw new Exception("Illegal Token"); } currentToken = lexicalAnalyzer.GetCurrentToken(); var expression = DoExpression(); if (currentToken != Token.CParen) { throw new Exception("Missing Closeing Parenthesis\n"); } if (old == Token.Cos) { expression = new CosExpression(expression); } else { expression = new SinExpression(expression); } currentToken = lexicalAnalyzer.GetCurrentToken(); return(expression); } else if (currentToken == Token.OParen) { currentToken = lexicalAnalyzer.GetCurrentToken(); var expression = DoExpression(); if (currentToken != Token.CParen) { throw new Exception("Missing Closing Parenthesis\n"); } currentToken = lexicalAnalyzer.GetCurrentToken(); return(expression); } else if (currentToken == Token.Plus || currentToken == Token.Sub) { var old = currentToken; currentToken = lexicalAnalyzer.GetCurrentToken(); var expression = DoFactor(); expression = new UnaryExpression(expression, old == Token.Plus ? OperationType.Plus : OperationType.Minus); return(expression); } else if (currentToken == Token.Random) // random(1,2) { currentToken = lexicalAnalyzer.GetCurrentToken(); if (currentToken != Token.OParen) { throw new Exceptions.IllegalTokenException( "Illegal Token: Need Open Parenthesis!"); } currentToken = lexicalAnalyzer.GetCurrentToken(); if (currentToken != Token.Double) { throw new Exceptions.IllegalTokenException( "Illegal token: Need Double Token 1!"); } var minValue = lexicalAnalyzer.CurrentValue; currentToken = lexicalAnalyzer.GetCurrentToken(); if (currentToken != Token.Comma) { throw new Exceptions.IllegalTokenException( "Illegal token: Need Comma Token!"); } currentToken = lexicalAnalyzer.GetCurrentToken(); if (currentToken != Token.Double) { throw new Exceptions.IllegalTokenException( "Illegal token: Need Double Token 2!"); } var maxValue = lexicalAnalyzer.CurrentValue; currentToken = lexicalAnalyzer.GetCurrentToken(); if (currentToken != Token.CParen) { throw new Exceptions.IllegalTokenException( "Missing Closeing Parenthesis!"); } IExpression expression = new RandomExpression((int)minValue, (int)maxValue); currentToken = lexicalAnalyzer.GetCurrentToken(); return(expression); } else { throw new Exceptions.IllegalTokenException( $"Illegal Token: {currentToken}!"); } }
// Syntax analysis of reverse polish notation expression private Stack <double> SyntaxAnalysisRPN(Stack <double> stack, string token) { // if it's operand then just push to stack if (token[0] == NumberMarker[0]) { stack.Push(double.Parse(token.Remove(0, 1))); } // otherwise apply operator or funtion to elements in stack else if (NumberOfArguments(token) == 1) { double argument = stack.Pop(); NumExpression arg = new NumExpression(argument); if (!isRadians) { argument = argument * Math.PI / 180; // Convert value to degree } NumExpression trigArg = new NumExpression(argument); double result; switch (token) { case UnaryPlus: result = arg.evaluate(); break; case UnaryMinus: NegateExpresion neg = new NegateExpresion(arg); result = neg.evaluate(); break; case Sqrt: SqrtExpression sqrt = new SqrtExpression(arg); result = sqrt.evaluate(); break; case Log: LogarithmExpression log = new LogarithmExpression(arg); result = log.evaluate(); break; case Ln: LnExpression ln = new LnExpression(arg); result = ln.evaluate(); break; case Sin: SinExpression sin = new SinExpression(trigArg); result = sin.evaluate(); break; case Cos: CosExpression cos = new CosExpression(trigArg); result = cos.evaluate(); break; case Tan: TanExpression tan = new TanExpression(trigArg); result = tan.evaluate(); break; case Csc: CscExpression csc = new CscExpression(trigArg); result = csc.evaluate(); break; case Sec: SecExpression sec = new SecExpression(trigArg); result = sec.evaluate(); break; case Cot: CotExpression cot = new CotExpression(trigArg); result = cot.evaluate(); break; default: throw new ArgumentException("Unknown operator"); } stack.Push(result); } else { // otherwise operator's number of arguments equal to 2 double argument2 = stack.Pop(); double argument1 = stack.Pop(); NumExpression arg1 = new NumExpression(argument1); NumExpression arg2 = new NumExpression(argument2); double result; switch (token) { case Plus: AdditionExpression add = new AdditionExpression(arg1, arg2); result = add.evaluate(); break; case Minus: MinusExpression minus = new MinusExpression(arg1, arg2); result = minus.evaluate(); break; case Multiply: MultiplyExpression multiply = new MultiplyExpression(arg1, arg2); result = multiply.evaluate(); break; case Divide: if (argument2 == 0) { throw new DivideByZeroException("Second argument is zero"); } DivideExpression divide = new DivideExpression(arg1, arg2); result = divide.evaluate(); break; case Mod: ModExpression mod = new ModExpression(arg1, arg2); result = mod.evaluate(); break; case Exponent: ExpononetExpression exp = new ExpononetExpression(arg1, arg2); result = exp.evaluate(); break; default: throw new ArgumentException("Unknown operator"); } stack.Push(result); } return(stack); }
public override bool Visit(SinExpression sinExpression) => this.VisitInstrinsicsCore(sinExpression, "sin");
public override LE.Expression Visit(SinExpression sinExpression) => this.VisitIntrinsicsCore(sinExpression, Intrinsics.Sin);