public void Clone_CotExpression()
{
//Arrange
var expected = new CosExpression(new NumberExpression(0), new Complex(3, 2));
//Act
var actual = (CosExpression)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(CosExpression cosExpression) => this.VisitInstrinsicsCore(cosExpression, "cos");
public override LE.Expression Visit(CosExpression cosExpression) => this.VisitIntrinsicsCore(cosExpression, Intrinsics.Cos);
