public void RaisedToNumberThenAddTest() { var actual = AddOp.Create(PowerOp.Create(A, One), Two); Assert.AreEqual(ExprParser.ParseOrThrow("a^1+2"), actual); Assert.AreEqual(A.Raise(One) + Two, actual.Simplify()); }
public void ExprTest() { const string input = "12 * 3 + foo(-3, x)() * (2 + 1)"; var actual = AddOp.Create( MultiplyOp.Create( Literal.Create(12), Literal.Create(3) ), MultiplyOp.Create( Call.Create( Call.Create( new Identifier("foo"), NegativeOp.Create(Literal.Create(3)), new Identifier("x") ) ), AddOp.Create( new Two(), new One() ) ) ).Simplify(); var expected = ExprParser.ParseOrThrow(input); Assert.AreEqual(expected.Simplify(), actual); }
static void Main() { int expressionsLength = 2; int operatorsLength = 1; var expressions = new var[expressionsLength]; expressions[0] = new IntegerValue(3); expressions[1] = new DoubleValue(4.3); var operators = new var[operatorsLength]; operators[0] = new AddOp(); int i = 0; for (; i < 2; i = i + 1) { int j = 0; while (j < operatorsLength) { int k = 0; for (; k < 2; k = k + 1) { var op1 = expressions[i]; var op = operators[j]; var op2 = expressions[k]; var result = Evaluate(op1, op, op2); Console.WriteLine(op1.ToString() + " " + op.ToString() + " " + op2.ToString() + " = " + result.ToString()); } j = j + 1; } } }
public void BracketsTest() { var actual = ExprParser.ParseOrThrow("1+[2+y]/{x*(y+4)}"); var expected = new One() + (AddOp.Create(new Two(), new Identifier("y")) / MultiplyOp.Create(new Identifier("x"), AddOp.Create(4, new Identifier("y")))); Assert.AreEqual(expected, actual); }
private Node ArithExprP(Node term) { string first = "+ - or"; string follow = "eq neq lt gt leq geq ] ) ; ,"; this.SkipErrors(first, follow); var lookaheadToken = this.TokenStream.Peek(); string lookahead = lookaheadToken.AToCCFormat(); if (first.HasToken(lookahead)) { this.ApplyDerivation("arithExprP -> addOp term arithExprP"); var arithExpr = new AddOp(lookaheadToken.SourceLocation); string op = AddOp(); Node nextTerm = Term(); Node trailingExpr = ArithExprP(nextTerm); arithExpr.LHS = term; arithExpr.Operator = op; arithExpr.RHS = trailingExpr; return(arithExpr); } if (follow.HasToken(lookahead)) { this.ApplyDerivation("arithExprP -> EPSILON"); return(term); } return(null); }
public static void Test() { // Initialize the math solving engine. MathSolver.Init(); EvalData evalData = ConstructEvalData(); // Object deriving from ExComp representing a algebraic variable. AlgebraComp x = new AlgebraComp("x"); ExComp complexExpression = ConstructEx("3x^2 - 3", evalData); ExComp combined = AddOp.StaticCombine(x, complexExpression); // Square the expression. ExComp squared = PowOp.RaiseToPower(complexExpression, new ExNumber(2.0), ref evalData, false); // String containing the evaluated result. string result = squared.ToAlgTerm().FinalToDispStr(); ExComp left = ConstructEx(¨ln(x - 2) ¨, evalData); ExComp right = ConstructEx(¨3¨, evalData); // The object containing the functionality used to solve algebraic equations. AlgebraSolver agSolver = new AlgebraSolver(); // Any additional information regarding the result will be stored in the evalData object. ExComp solveResult = agSolver.SolveEq(left, right, new AlgebraVar(¨x¨), evalData); }
public void QuantityTwoMinus_a_raisedTo1Plus3Test() { const string input = "(2-a)^1+3"; var actual = AddOp.Create(PowerOp.Create(SubtractOp.Create(new Two(), new Identifier("a")), new One()), Literal.Create(3)).Simplify(); var expected = ExprParser.ParseOrThrow(input).Simplify(); Assert.AreEqual(expected, actual); }
public void Test1() { const string input = "-(2-a)^1+3"; var actual = AddOp.Create(NegativeOp.Create(PowerOp.Create(SubtractOp.Create(new Two(), new Identifier("a")), new One())), Literal.Create(3)).Simplify(); var expected = ExprParser.ParseOrThrow(input); Assert.AreEqual(expected.Simplify(), actual); }
public override RegisterLabelContext Visit(AddOp addOp) { var c1 = Visit(addOp.Lhs); var c2 = Visit(addOp.Rhs); var nextRegister = _state.NewRegister; switch (addOp.Add, c1.Type, c2.Type) {
public void AddToLiteralTest() { var actual1 = AddOp.Create(new Identifier("x"), 1); var actual2 = AddOp.Create(1, new Identifier("x")); Assert.AreEqual(X + One, actual1); Assert.AreEqual(One + X, actual2); }
public BasicNumericOperation(AddOp add, RemoveOp remove) { if (add == null || remove == null) { throw new ArgumentNullException(); } this.addImpl = add; this.remImpl = remove; }
public static Expr Create(Expr left, Expr right) => (left, right) switch { (Zero _, _) => - right, (_, Zero _) => left, (_, NegativeOp { Expr : Literal l }) => AddOp.Create(left, l), _ => new SubtractOp(left, right) };
public void XRaiseToXTimesXRaiseTo2() { var x = new Identifier("x"); var xToX = x.Raise(x); var xTo2 = x.Raise(new Two()); var expected = x.Raise(AddOp.Create(2, x)); Assert.AreEqual(xToX * xTo2, expected); }
public void AddTest1() { var d = ExprParser.ParseOrThrow("2*x"); var e = ExprParser.ParseOrThrow("1*x"); var f = ExprParser.ParseOrThrow("2"); var h = ExprParser.ParseOrThrow("2"); Assert.AreEqual(d + e + f + h, AddOp.Create(MultiplyOp.Create(3, new Identifier("x")), 4)); }
public void SubtractToNegativeLiteralTest() { var num = new One(); var actual1 = AddOp.Create(new Identifier("x"), 1); var actual2 = AddOp.Create(1, new Identifier("x")); Assert.AreEqual(X - NegativeOp.Create(num), actual1); Assert.AreEqual(num - NegativeOp.Create(X), actual2); }
public async Task <IActionResult> AddOperation(AddOp addOp) { db.Operations.Add(new Operation { Name = addOp.Name, NameAct = addOp.NameAct, Sum = addOp.Sum, Coment = addOp.Coment, PlanId = addOp.PlId }); await db.SaveChangesAsync(); return(RedirectToAction("Operation")); }
public void DecimalTest() { var onePthree = ExprParser.ParseOrThrow("1.3"); Assert.AreEqual(onePthree, DivideOp.Create(13, 10)); var actual = AddOp.Create(PowerOp.Create(A, onePthree), Two); Assert.AreEqual(ExprParser.ParseOrThrow("a^1.3+2"), actual); Assert.AreEqual(A.Raise(onePthree) + Two, actual.Simplify()); }
public void Test3() { const string input = "-a/b^1+3-a/b^1"; var term1 = DivideOp.Create(NegativeOp.Create(new Identifier("a")), PowerOp.Create(new Identifier("b"), new One())); var term2 = Literal.Create(3); var term3 = DivideOp.Create(new Identifier("a"), PowerOp.Create(new Identifier("b"), new One())); var actual = SubtractOp.Create(AddOp.Create(term1, term2), term3).Simplify(); var expected = ExprParser.ParseOrThrow(input); Assert.AreEqual(expected.Simplify(), actual); }
public void NegativeBeforeAddTest() { const string input = "-12 + 3"; var actual = AddOp.Create( NegativeOp.Create(Literal.Create(12)), Literal.Create(3) ).Simplify(); var expected = ExprParser.ParseOrThrow(input); Assert.AreEqual(expected.Simplify(), actual); }
public void Test4() { const string input = "1-2/3+1-3+3*2"; var a = new One(); var b = DivideOp.Create(new Two(), Literal.Create(3)); var c = new One(); var d = Literal.Create(3); var e = MultiplyOp.Create(Literal.Create(3), new Two()); var actual = AddOp.Create(SubtractOp.Create(AddOp.Create(SubtractOp.Create(a, b), c), d), e).Simplify(); var expected = ExprParser.ParseOrThrow(input); Assert.AreEqual(expected.Simplify(), actual); }
public IActionResult AddOperation(int id) { if (id == 0) { return(RedirectToAction("Plan")); } else { AddOp addOp = new AddOp(); addOp.id = id; return(View()); } }
public override Expr Visit(AddOp addOp) { return((addOp.Add, Visit(addOp.Lhs), Visit(addOp.Rhs)) switch { (Add.Plus, Int i1, Int i2) => new Int { Value = i1.Value + i2.Value }, (Add.Minus, Int i1, Int i2) => new Int { Value = i1.Value - i2.Value }, (Add.Plus, Str s1, Str s2) => new Str { Value = s1.Value + s2.Value }, (_, Expr e1, Expr e2) => new AddOp { Add = addOp.Add, Lhs = e1, Rhs = e2 } });
public override void Visit(AddOp addOp) { if (addOp.RHS is Node rhs) { if (addOp.LHS is Node lhs) { if (lhs.SemanticalType != rhs.SemanticalType) { ErrorManager.Add($"Inconsistent types: Cannot perform {lhs.SemanticalType} {addOp.Operator} {rhs.SemanticalType}", addOp.Location); } } addOp.SemanticalType = rhs.SemanticalType; } else { ErrorManager.Add("There is no RHS for this add operation.", addOp.Location); } }
public void SubtractThenMultTest() { var input = "(d-12) * 3"; var actual = MultiplyOp.Create( SubtractOp.Create(new Identifier("d"), Literal.Create(12)), Literal.Create(3) ).Simplify(); var expected = ExprParser.ParseOrThrow(input); Assert.AreEqual(expected.ToString(), "3×(d-12)"); Assert.AreEqual(expected.Simplify(), actual); input = "(d+12) * 3"; actual = MultiplyOp.Create( AddOp.Create(new Identifier("d"), Literal.Create(12)), Literal.Create(3) ).Simplify(); expected = ExprParser.ParseOrThrow(input).Simplify(); Assert.AreEqual(expected, actual); }
/// <summary> /// 线程同步,“阻塞”调用,两个线程工作 /// </summary> static void Demo04() { Console.WriteLine("******* 线程同步,“阻塞”调用,两个线程工作 *********"); Console.WriteLine("Main() invokee on thread {0}.", Thread.CurrentThread.ManagedThreadId); //将委托实例指向Add()方法 AddOp pAddOp = new AddOp(Add); IAsyncResult iftAR = pAddOp.BeginInvoke(10, 10, null, null); //判断委托线程是否执行完任务, //没有完成的话,主线程就做其他的事 while (!iftAR.IsCompleted) { Console.WriteLine("Main()方法工作中.......线程ID是:{0}", Thread.CurrentThread.ManagedThreadId); Thread.Sleep(1000); } //获得返回值 int answer = pAddOp.EndInvoke(iftAR); Console.WriteLine("10 + 10 = {0}.", answer); Console.ReadLine(); }
/// <summary> /// 线程异步 委托异步线程 两个线程“同时”工作 /// </summary> static void Demo03() { Console.WriteLine("******* 委托异步线程 两个线程“同时”工作 *********"); //显示主线程的唯一标示 Console.WriteLine("调用Main()的主线程的线程ID是:{0}.", Thread.CurrentThread.ManagedThreadId); //将委托实例指向Add()方法 AddOp pAddOp = new AddOp(Add); //开始委托次线程调用。委托BeginInvoke()方法返回的类型是IAsyncResult, //包含这委托指向方法结束返回的值,同时也是EndInvoke()方法参数 IAsyncResult iftAR = pAddOp.BeginInvoke(10, 10, null, null); //int i = 0; //while (!iftAR.IsCompleted) //{ // Console.WriteLine("Main()方法中执行其他任务........线程ID是:{0},执行第{1}次", Thread.CurrentThread.ManagedThreadId, i.ToString()); // i++; //} int sum = pAddOp.EndInvoke(iftAR); Console.WriteLine("10 + 10 = {0}.", sum); Console.ReadLine(); }
public override void Visit(AddOp addOp) { this.AddToStack(addOp); }
public override void Visit(AddOp addOp) { addOp.NodeMemorySize = Sizes[addOp.SemanticalType]; }
public void AddToIdentifierDifferent() { Assert.AreEqual(i1 + i3, AddOp.Create(new Identifier("x"), new Identifier("y"))); Assert.AreEqual(i3 + i1, AddOp.Create(new Identifier("y"), new Identifier("x"))); }
public virtual Result Visit(AddOp addOp) { return(default(Result)); }