public static double GetResult(char op, double number1, double number2)
{
OperatorReguler opReguler = null;
switch (op)
{
case ADDITION:
AddOperator add = new AddOperator(number1, number2);
opReguler = add;
break;
case SUBTRACK:
SubOperator sub = new SubOperator(number2, number1);
opReguler = sub;
break;
case MULTIPLY:
MulOperator mul = new MulOperator(number1, number2);
opReguler = mul;
break;
case DIVISION:
DivOperator div = new DivOperator(number2, number1);
opReguler = div;
break;
}
return(opReguler.GetResult());
}
public void ReplaceOperation_ReplacesCorrectOperation()
{
// Arrange
var otherOpd1 = new Operand(0);
var otherOp = new AddOperator();
var otherOpd2 = new Operand(0);
var lOperand = new Operand(0);
var op = new AddOperator();
var rOperand = new Operand(0);
var elements = new Element[]
{
otherOpd1, otherOp, otherOpd2,
lOperand, op, rOperand
};
var sut = new ElementList(elements);
var operation = new Operation(lOperand, op, rOperand);
// Act
sut.ReplaceOperation(operation, new Operand(0));
var result = sut.FindOperation();
// Assert
Assert.AreEqual(otherOpd1, result.LOperand);
Assert.AreEqual(otherOp, result.Op);
Assert.AreEqual(otherOpd2, result.ROperand);
}
public void ObservableInfoTest()
{
var operatorOne = new MultiplyOperator(TwentyOne, Two);
var expressionOne = new NumericExpressionTree(null, operatorOne);
var observableOne = new ObservableInfo(expressionOne);
Console.Write("Created new observable: ");
Console.WriteLine(observableOne);
Console.WriteLine("ObservableTest: testing anonymous observable Name property...");
Expect(observableOne.Name == string.Empty);
Console.WriteLine("ObservableTest: testing Expression property (observableOne)...");
Expect(observableOne.Expression == expressionOne);
const string observableName = "observableTwo";
var operatorTwo = new AddOperator(Two, Three);
var expressionTwo = new NumericExpressionTree(null, operatorTwo);
var observableTwo = new ObservableInfo(observableName, expressionTwo);
Console.Write("Created new ObservableInfo: ");
Console.WriteLine(observableTwo);
Console.WriteLine("ObservableTest: testing Name property...");
Expect(observableTwo.Name == observableName);
Console.WriteLine("ObservableTest: testing Expression property (observableTwo)...");
Expect(observableTwo.Expression == expressionTwo);
}
public void TestPrintIncompleteAdd()
{
BinaryOperator addOperation = new AddOperator();
addOperation.SetFirstOperand(new Value(1));
Assert.AreEqual("1 + ".Replace(" ", ""), addOperation.ToString().Replace(" ", ""));
}
public void AddOperatorExecuteTest()
{
Operator op = new AddOperator();
var result = op.Execute(SetStack());
Assert.Equal(7, result);
}
static void OperatorTest()
{
var t = new DataTree();
var t2 = new DataTree();
var t3 = new DataTree();
t.AddElement(new PNumber(200));
t.AddElement(new PNumber(3));
t2.AddElement(new PNumber(20));
t2.AddElement(new PNumber(100));
t2.AddElement(new PNumber(1000));
t3.AddElement(new PNumber(14));
t2.AddElement(t3);
var op = new AddOperator();
op.GroupingMode = DataGroupingModes.CrossReference;
var te = op.ProcessData(new List <IData>()
{
t, t2
});
foreach (var res in te)
{
Print(res);
}
}
public void TestAddition()
{
BinaryOperator addExpression = new AddOperator();
addExpression.SetFirstOperand(new Value(1.5M));
addExpression.SetSecondOperand(new Value(1.5M));
Assert.AreEqual(3.0M, addExpression.Evaluate());
}
public void TestPrintAddExpression()
{
BinaryOperator addOperation = new AddOperator();
addOperation.SetFirstOperand(new Value(1));
addOperation.SetSecondOperand(new Value(1));
Assert.AreEqual("1 + 1".Replace(" ", ""), addOperation.ToString().Replace(" ", ""));
}
private Operand Add(string p1, string p2)
{
var fraction = Operand.Parse(p1);
var fraction2 = Operand.Parse(p2);
var sut = new AddOperator();
return(sut.Solve(fraction, fraction2));
}
public override VariableValue Evaluate(IVariableStore variables)
{
var left = Left.Evaluate(variables);
var right = Right.Evaluate(variables);
var result = AddOperator.Add(this, ref left, ref right);
return(Assign(variables, ref result));
}
public void AddOperatorTest()
{
string path = @"addtest";
File.WriteAllText(path, "5\n3");
AddOperator add = new AddOperator(File.OpenText(path));
Assert.AreEqual(add.Evaluate(), 8);
Assert.AreEqual(add.ToString(), "(5+3)");
}
public void AddOperator_PrecedenceSetCorrectly()
{
// Arrange
var expected = 1;
var sut = new AddOperator();
// Act
var actual = sut.Precedence;
// Assert
Assert.AreEqual(expected, actual);
}
public void TakesPrecedenceBoostIntoAccount()
{
// Arrange
var precedenceBoost = 7;
var expected = 8;
var sut = new AddOperator(precedenceBoost);
// Act
var actual = sut.Precedence;
// Assert
Assert.AreEqual(expected, actual);
}
public void TestOperatorInequality()
{
BinaryOperator addOperation = new AddOperator();
addOperation.SetFirstOperand((Value)5);
addOperation.SetSecondOperand((Value)6);
BinaryOperator addOperation2 = new AddOperator();
addOperation2.SetFirstOperand((Value)4);
addOperation2.SetSecondOperand((Value)6);
Assert.AreNotEqual(addOperation, addOperation2);
}
public void TestOperatorMismatchInequality()
{
BinaryOperator addOperation = new AddOperator();
addOperation.SetFirstOperand((Value)5);
addOperation.SetSecondOperand((Value)6);
BinaryOperator divideOperation = new DivisionOperator();
divideOperation.SetFirstOperand((Value)5);
divideOperation.SetSecondOperand((Value)6);
Assert.AreNotEqual(addOperation, divideOperation);
}
public void AdditionOperator_ReturnsSum()
{
// Arrange
var operand1 = new Operand(10);
var operand2 = new Operand(20);
var expected = 30;
// Act
var sut = new AddOperator();
var actual = sut.Compute(operand1, operand2);
// Assert
Assert.AreEqual(expected, actual);
}
public void TestSingleOperator()
{
ExpressionBuilder expressionBuilder = new ExpressionBuilder();
expressionBuilder.PushValue((Value)5);
expressionBuilder.PushOperator <AddOperator>();
expressionBuilder.PushValue((Value)4);
AddOperator addOperation = new AddOperator();
addOperation.SetFirstOperand((Value)5);
addOperation.SetSecondOperand((Value)4);
Assert.AreEqual(addOperation, expressionBuilder.GenerateExpression());
}
void ExecuteTest()
{
IPostfixNotationExecuter executer = new PostfixNotationExecuter();
var op = new AddOperator();
Queue <PNToken> expr = new Queue <PNToken>(new List <PNToken> {
new PNOperandToken(1), new PNOperandToken(2), new PNOperatorToken(op)
});
var opList = new OperatorList();
opList.Add(op);
decimal result = executer.Execute(expr, opList);
Assert.Equal(3, result);
}
public void PeformLogic(OperatorElement input)
{
if (buffer[0] == null)
{
buffer[0] = input;
return;
}
// second input is a '+'
if (input.GetType() == typeof(AddOperator))
{
//Don't do anything if previous operator != '-' > a + - b == a - b
if (buffer[0].GetType() == typeof(SubTractOperator))
{
}
}
if (input.GetType() == typeof(SubTractOperator))
{
if (buffer[0].GetType() == typeof(SubTractOperator))
{
buffer[0] = new AddOperator();
}
if (buffer[0].GetType() == typeof(AddOperator))
{
buffer[0] = input;
}
if (buffer[0].GetType() == typeof(MultiplyOperator) || buffer[0].GetType() == typeof(DivideOperator))
{
buffer[1] = input;
}
}
if (input.GetType() == typeof(DivideOperator))
{
if (buffer[0].GetType() == typeof(SubTractOperator))
{
buffer[0] = input;
buffer[1] = new SubTractOperator();
}
}
if (input.GetType() == typeof(MultiplyOperator))
{
if (buffer[0].GetType() == typeof(SubTractOperator))
{
buffer[0] = input;
buffer[1] = new SubTractOperator();
}
}
}
void AddOp(out AddOperator op)
{
op = AddOperator.Plus;
if (la.kind == 11)
{
Get();
}
else if (la.kind == 12)
{
Get();
op = AddOperator.Minus;
}
else
{
SynErr(21);
}
}
public void First_ReturnsFirstElement()
{
// Arrange
var lOperand = new Operand(0);
var op = new AddOperator();
var rOperand = new Operand(0);
var elements = new Element[]
{
lOperand, op, rOperand
};
var sut = new ElementList(elements);
// Act
var result = sut.First;
// Assert
Assert.AreEqual(lOperand, result);
}
internal static void ShowOperatorDialog(OperatorDto operatorDto, Action <bool?> call)
{
//DispatcherHelper.UIDispatcher.Invoke(new Action(() =>
// {
var addOperator = new AddOperator();
var vm = operatorDto != null ? new AddOperatorViewModel(operatorDto) : new AddOperatorViewModel();
addOperator.DataContext = vm;
addOperator.Owner = Application.Current.MainWindow;
var dialogResult = addOperator.ShowDialog();
if (call != null)
{
call(dialogResult);
}
addOperator.DataContext = null;
//}));
}
public void PostfixParserTest()
{
var op = new AddOperator();
IPostfixNotationParser parser = new PostfixNotationParser();
List <PNToken> expr = new List <PNToken>
{
new PNOperandToken(3),
new PNOperatorToken(op),
new PNOperandToken(4)
};
var opList = new OperatorList();
opList.Add(op);
var res = parser.Parse(expr, opList);
Assert.Equal(3m, res.Dequeue().Subject);
Assert.Equal(4m, res.Dequeue().Subject);
Assert.Equal("+", ((Operator)(res.Dequeue().Subject)).Symbol);
}
public void ReplaceOperationWorks()
{
// Arrange
var lOperand = new Operand(0);
var op = new AddOperator();
var rOperand = new Operand(0);
var elements = new Element[]
{
lOperand, op, rOperand
};
var sut = new ElementList(elements);
var operation = new Operation(lOperand, op, rOperand);
// Act
sut.ReplaceOperation(operation, new Operand(0));
var result = sut.FindOperation();
// Assert
Assert.IsNull(result);
}
public void FindOperationCanHandleTwoSuccessiveOperators()
{
// Arrange
var opd1 = new Operand(1);
var op1 = new AddOperator();
var op2 = new SubOperator(10);
var opd2 = new Operand(2);
var elements = new Element[]
{
opd1, op1, op2, opd2
};
var sut = new ElementList(elements);
// Act
var result = sut.FindOperation();
// Assert
Assert.AreEqual(0, result.LOperand.Value);
Assert.AreEqual(op2, result.Op);
Assert.AreEqual(opd2, result.ROperand);
}
private void Form1_Paint(object sender, PaintEventArgs args)
{
var e = new StructureEngine();
var i = new If();
i.Condition = null;
e.Root.Body.Statements.Add(i);
var v = new VariableDeclaration();
v.Name = null;
v.InitialValue = null;
var p = new Print();
var s1 = new StringLiteral
{
Value = "hej du glade Tag en spade och..."
};
var s2 = new StringLiteral
{
Value = "Mer text",
};
var exp = new AddOperator()
{
LeftOperand = s1,
RightOperand = s2,
};
p.Value = exp;
i.Body.Statements.Add(v);
i.Body.Statements.Add(p);
args.Graphics.Clear(Color.White);
e.Render(args.Graphics);
}
private void Form1_Paint(object sender, PaintEventArgs args)
{
var e = new StructureEngine();
var i = new If();
i.Condition = null;
e.Root.Body.Statements.Add(i);
var v = new VariableDeclaration();
v.Name = null;
v.InitialValue = null;
var p = new Print();
var s1 = new StringLiteral
{
Value = "hej du glade Tag en spade och..."
};
var s2 = new StringLiteral
{
Value = "Mer text",
};
var exp = new AddOperator()
{
LeftOperand = s1,
RightOperand = s2,
};
p.Value = exp;
i.Body.Statements.Add(v);
i.Body.Statements.Add(p);
args.Graphics.Clear(Color.White);
e.Render(args.Graphics);
}
public void FindOperation_ReturnsFirstOperation()
{
// Arrange
var lOperand = new Operand(0);
var op = new AddOperator();
var rOperand = new Operand(0);
var elements = new Element[]
{
new Operand(0),
new Operand(0),
lOperand,
op,
rOperand
};
var sut = new ElementList(elements);
// Act
var result = sut.FindOperation();
// Assert
Assert.AreEqual(lOperand, result.LOperand);
Assert.AreEqual(op, result.Op);
Assert.AreEqual(rOperand, result.ROperand);
}
public IToken ParseTokens(string[] ops)
{
var stack = new Stack <ApOperator>();
IToken token = null;
for (int i = 0; i < ops.Length; i++)
{
var op = ops[i];
switch (op)
{
case "ap":
token = new ApOperator();
break;
case "inc":
token = IncOperator.Acquire();
break;
case "dec":
token = DecOperator.Acquire();
break;
case "neg":
token = NegOperator.Acquire();
break;
case "add":
token = AddOperator.Acquire();
break;
case "mul":
token = MulOperator.Acquire();
break;
//case "l":
// token = new LOperator();
// break;
case "div":
token = DivOperator.Acquire();
break;
//case "pwr2":
// return (new Pwr2Operator(), index);
case "t":
token = KComb.Acquire();
break;
//case "f":
// return (new FComb(), index);
case "s":
token = SComb.Acquire();
break;
case "c":
token = CComb.Acquire();
break;
case "b":
token = BComb.Acquire();
break;
case "i":
token = IComb.Acquire();
break;
case "cons":
case "vec":
token = ConsOperator.Acquire();
break;
case "car":
token = CarOperator.Acquire();
break;
case "cdr":
token = CdrOperator.Acquire();
break;
case "nil":
token = NilOperator.Acquire();
break;
case "isnil":
token = IsNilOperator.Acquire();
break;
case "eq":
token = EqOperator.Acquire();
break;
case "if0":
token = new If0Operator();
break;
case "lt":
token = LtOperator.Acquire();
break;
//case "mod":
// token = new ModOperator();
// break;
//case "dem":
// token = new DemodOperator();
// break;
case "interact":
token = new InteractOperator();
break;
default:
if (decimal.TryParse(op, out var constant)) // int constant
{
token = ConstantOperator.Acquire(decimal.Parse(op));
}
else if (op.StartsWith("x"))
{
token = VarOperator.Acquire(op);
}
else if (op.StartsWith(":")) // variable reference
{
token = LateBoundToken.Acquire(op);
}
else
{
throw new InvalidOperationException();
}
break;
}
if (stack.Count == 0)
{
if (!(token is ApOperator))
{
if (i != ops.Length - 1)
{
throw new InvalidOperationException();
}
return(token);
}
stack.Push((ApOperator)token);
}
else
{
var top = stack.Peek();
if (top.f == null)
{
top.f = token;
if (token is ApOperator ap)
{
stack.Push(ap);
}
}
else if (top.x == null)
{
top.x = token;
if (token is ApOperator ap)
{
stack.Push(ap);
}
else
{
while (stack.Count > 0 && stack.Peek().x != null)
{
token = stack.Pop();
}
}
}
else
{
throw new InvalidOperationException();
}
}
}
if (stack.Count == 1)
{
return(stack.Pop());
}
return(token);
}
public void ModelInfoTest()
{
const string modelName = "test model";
var builder = new ModelInfo.ModelBuilder(modelName);
const string constraintName = "test constraint";
const string constraintPredicateName = "constraint predicate";
var constraintExpression = new EqualToOperator(Two, Two);
var constraintPredicate = new BooleanExpressionTree(constraintPredicateName, constraintExpression);
var constraint = new ConstraintInfo(constraintName, constraintPredicate);
builder.AddConstraint(constraint);
/*
* const string eventName = "test event";
* const string eventPredicateName = "event predicate";
* var eventExpression = new GreaterThanOperator(Three, Two);
* var eventPredicate = new BooleanExpressionTree(eventPredicateName, eventExpression);
* int eventCount = 0;
* var testEvent = new EventInfo(eventName, eventPredicate, () => { eventCount++; });
* builder.AddEvent(testEvent);
*/
const string expressionName = "test expression";
var expression = new AddOperator(Three, Two);
var expressionTree = new NumericExpressionTree(expressionName, expression);
builder.AddExpression(expressionTree);
const string localeName = "test locale";
var locale = new LocaleInfo(localeName);
builder.AddLocale(locale);
const string observableName = "test observable";
const string observableExpressionName = "observable expression";
var rootOperator = new PowerOperator(Two, Three);
var observableExpressionTree = new NumericExpressionTree(observableExpressionName, rootOperator);
var observable = new ObservableInfo(observableName, observableExpressionTree);
builder.AddObservable(observable);
const string parameterName = "test parameter";
var parameter = new ParameterInfo(parameterName, 3.14159265f);
builder.AddParameter(parameter);
const string predicateName = "test predicate";
var predicateExpression = new LessThanOperator(Two, Three);
var predicate = new BooleanExpressionTree(predicateName, predicateExpression);
builder.AddPredicate(predicate);
const string speciesName = "reactant";
var reactant = new SpeciesDescription(speciesName, 2012, locale);
builder.AddSpecies(reactant);
const string reactionName = "test reaction";
var rBuilder = new ReactionInfo.ReactionBuilder(reactionName);
rBuilder.AddReactant(reactant);
var rateExpression = new MultiplyOperator(Ten, new SymbolReference(speciesName));
var reactionRate = new NumericExpressionTree(null, rateExpression);
rBuilder.SetRate(reactionRate);
var reaction = rBuilder.Reaction;
builder.AddReaction(reaction);
var modelInfo = builder.Model;
Console.WriteLine("ModelInfoTests: checking model name...");
Expect(modelInfo.Name == modelName);
Console.WriteLine("ModelInfoTests: checking constraint count (1)...");
Expect(modelInfo.Constraints.Count() == 1);
Console.WriteLine("ModelInfoTests: checking constraint...");
Expect(modelInfo.Constraints.First() == constraint);
/*
* Console.WriteLine("ModelInfoTests: checking event count (1)...");
* Expect(modelInfo.Events.Count() == 1);
* Console.WriteLine("ModelInfoTests: checking event...");
* Expect(modelInfo.Events.First() == testEvent);
*/
Console.WriteLine("ModelInfoTests: checking expression count (3)...");
Expect(modelInfo.Expressions.Count() == 3);
Console.WriteLine("ModelInfoTests: checking expressions...");
var expressions = modelInfo.Expressions.Where(net => net.Name == expressionName).ToList();
Expect(expressions.Count == 1);
Expect(expressions[0] == expressionTree);
Console.WriteLine("ModelInfoTests: checking locale count (1)...");
Expect(modelInfo.Locales.Count() == 1);
Console.WriteLine("ModelInfoTests: checking locale...");
Expect(modelInfo.Locales.First() == locale);
Console.WriteLine("ModelInfoTests: checking observable count (1)...");
Expect(modelInfo.Observables.Count() == 1);
Console.WriteLine("ModelInfoTests: checking observable...");
Expect(modelInfo.Observables.First() == observable);
Console.WriteLine("ModelInfoTests: checking parameter count (1)...");
Expect(modelInfo.Parameters.Count() == 1);
Console.WriteLine("ModelInfoTests: checking parameter...");
Expect(modelInfo.Parameters.First() == parameter);
/*
* Console.WriteLine("ModelInfoTests: checking predicate count (3)...");
* Expect(modelInfo.Predicates.Count() == 3);
*/
Console.WriteLine("ModelInfoTests: checking predicate count (2)...");
Expect(modelInfo.Predicates.Count() == 2);
Console.WriteLine("ModelInfoTests: checking predicate...");
var predicates = modelInfo.Predicates.Where(pi => pi.Name == predicateName).ToList();
Expect(predicates.Count == 1);
Expect(predicates[0] == predicate);
Console.WriteLine("ModelInfoTests: checking reaction count (1)...");
Expect(modelInfo.Reactions.Count() == 1);
Console.WriteLine("ModelInfoTests: checking reaction...");
Expect(modelInfo.Reactions.First() == reaction);
Console.WriteLine("ModelInfoTests: checking species count (1)...");
Expect(modelInfo.Species.Count() == 1);
Console.WriteLine("ModelInfoTests: checking species...");
Expect(modelInfo.Species.First() == reactant);
}
