public LightMathCalculateDataFieldInfo(DataEntityMapping mapping, MathOperator opera, object left, object right) : base(mapping) { _opera = opera; _left = left; _right = right; }
static void Main(string[] args) { //MathOperator MethodPointer = new MathOperator(Add); //Console.WriteLine(MethodPointer(5, 7)); //MathOperator MethodPointer2 = new MathOperator((num1, num2) => { return num1 + num2; }); //Console.WriteLine(MethodPointer2(5, 7)); //MathOperator MethodPointer3 = (num1, num2) => { return num1 + num2; }; //Console.WriteLine(MethodPointer3(5, 7)); MathOperator op = Add; op += Sub; Console.WriteLine(op(12, 5)); //var array = new string[] //{ // "omer", "meital", "matan" //}; //for (int i = 0; i < array.Length; i++) //{ // Console.WriteLine(array[i]); //} //var list = array.ToList(); //list.ForEach(x => x.Replace('e', 'f')); }
public static double Test5(double num1, double num2, MathOperator op) { double num3; switch (op) { case MathOperator.Add: num3 = num1 + num2; return(num3); case MathOperator.Subtract: num3 = num1 - num2; return(num3); case MathOperator.Multiply: num3 = num1 * num2; return(num3); case MathOperator.Divide: num3 = num1 / num2; return(num3); } ; return(0); }
public static double Test5(double num1, double num2, MathOperator op) { double num3; switch (op) { case MathOperator.Add: num3 = num1 + num2; return(num3); case MathOperator.Subtract: num3 = num1 - num2; return(num3); case MathOperator.Multiply: num3 = num1 * num2; return(num3); case MathOperator.Divide: num3 = num1 / num2; return(num3); //add default switch case for error: not all code paths return a value bla bla.. default: return(0); } ; }
public static List <string> InfixToPostfix(List <string> infixExpression) { List <string> postfixExpression = new List <string>(); Heap <MathOperator> signHeap = new Heap <MathOperator>(); int openBrackets = 0; for (int i = 0; i < infixExpression.Count; i++) { if (IsMathOperator(infixExpression[i])) { MathOperator inputOperator = new MathOperator(infixExpression[i], openBrackets); if (signHeap.Amount == 0) { signHeap.Push(inputOperator); } else { while (signHeap.Amount != 0) { MathOperator tempOperator = signHeap.Pop(); if (tempOperator.Priority <= inputOperator.Priority) { signHeap.Push(tempOperator); signHeap.Push(inputOperator); break; } else { postfixExpression.Add(tempOperator.Type); if (signHeap.Amount == 0) { signHeap.Push(inputOperator); break; } } } } } else if (IsBracket(infixExpression[i])) { if (infixExpression[i].Equals("(")) { openBrackets++; } else { openBrackets--; } } else { postfixExpression.Add(infixExpression[i]); } } while (signHeap.Amount != 0) { postfixExpression.Add(signHeap.Pop().Type); } return(postfixExpression); }
public ExpressionResult RunExpression(MathOperator op, string expression) { long result = 0; var values = tokenizer.Parse(expression); switch (op) { case MathOperator.Add: result = math.Add(values.ToArray()); break; case MathOperator.Subtract: result = math.Subtract(values.ToArray()); break; case MathOperator.Divide: result = math.Divide(values.ToArray()); break; case MathOperator.Multiply: result = math.Multiply(values.ToArray()); break; } return(new ExpressionResult(result, values.ToArray())); }
private MathOpcode CreateMathOpcode(MathOperator op) { MathOpcode opcode = null; switch (op) { case MathOperator.None: return(opcode); case MathOperator.Plus: return(new PlusOpcode()); case MathOperator.Minus: return(new MinusOpcode()); case MathOperator.Div: return(new DivideOpcode()); case MathOperator.Multiply: return(new MultiplyOpcode()); case MathOperator.Mod: return(new ModulusOpcode()); case MathOperator.Negate: return(new NegateOpcode()); } return(opcode); }
public void GetMaxPrecedence() { List <MathToken> tokens = _lexer.GetTokens("3 + 3 * 2"); MathToken token = _precedence.GetMaxPrecedence(tokens); MathOperator op = OperatorFactory.Create(token.Token); Assert.AreEqual(op.Token, "*"); }
public static void VisitDic(MathOperator key, string cfg) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (key != 0) { throw new FacadePropertyStruct(key, cfg); } }
public FacadePropertyStruct(MathOperator ident, string ord) { //Discarded unreachable code: IL_0002, IL_0006 //IL_0003: Incompatible stack heights: 0 vs 1 //IL_0007: Incompatible stack heights: 0 vs 1 SingletonReader.PushGlobal(); base._002Ector(LogoutDic(ident, ord)); m_WatcherList = ident; collectionList = ord; }
public void SetExpression(Expression leftExpression, Expression rightExpression, MathOperator newMathOperator) { leftOperand = new Expression(leftExpression); rightOperand = new Expression(rightExpression); mathOperator = newMathOperator; mathOperand = MathOperand.Expression; constant = 0; symbol = '\0'; }
public void RetornaExeptionNaDivisaoPorZero() { //Given decimal first = 10; decimal second = 0; var mathOperator = new MathOperator(); //When //Then Assert.Throws <DivideByZeroException>(() => mathOperator.Divide(first, second)); }
public void DeveDarErroAoTentarDividirPorDoisNumeros() { //Given var first = 100; var second = 2; var mathOperator = new MathOperator(); decimal expected = 50; decimal result; //When result = mathOperator.Divide(first, second); //Then Assert.Equal(expected, result); }
public void RetunrSumOfTwoNumbers() { //Given decimal first = 10; decimal second = 20; decimal expected = 30; decimal result; var mathOperator = new MathOperator(); //When result = mathOperator.Add(first, second); //Then Assert.Equal(expected, result); }
public void GenerateQuiz() { operandA = Random.Range(10, 50); operandB = Random.Range(10, 50); mathOperator = (MathOperator)Random.Range(0, 3); string sign = ""; switch (mathOperator) { case MathOperator.PLUS: correctResult = operandA + operandB; sign = "+"; break; case MathOperator.MINUS: correctResult = operandA - operandB; sign = "-"; break; case MathOperator.MULTIPLY: correctResult = operandA * operandB; sign = "*"; break; case MathOperator.DEVIDE: correctResult = operandA / operandB; sign = "/"; break; } question = operandA + " " + sign + " " + operandB + " = ?"; Debug.Log("Question : " + question); Debug.Log("Correct result : " + correctResult); results = new int[4]; results[0] = correctResult; GenerateFakeResults(); Debug.Log("Answer 1: " + results[0]); Debug.Log("Answer 2: " + results[1]); Debug.Log("Answer 3: " + results[2]); Debug.Log("Answer 4: " + results[3]); }
private string MathOperatorToString(MathOperator @operator) { switch (@operator) { case MathOperator.Add: return _schema.Operators.Add; case MathOperator.Subtract: return _schema.Operators.Subtract; case MathOperator.Multiply: return _schema.Operators.Multiply; case MathOperator.Divide: return _schema.Operators.Divide; case MathOperator.Modulo: return _schema.Operators.Modulo; default: throw new InvalidOperationException("Invalid MathOperator specified."); } }
private static string MathOperatorToString(MathOperator @operator) { switch (@operator) { case MathOperator.Add: return "+"; case MathOperator.Subtract: return "-"; case MathOperator.Multiply: return "*"; case MathOperator.Divide: return "/"; case MathOperator.Modulo: return "%"; default: throw new InvalidOperationException("Invalid MathOperator specified."); } }
private int CalculateNextAssignment(int current, int numeric, MathOperator mathOperator) { if (mathOperator == MathOperator.Multiply) { return(current * numeric); } else if (mathOperator == MathOperator.Add) { return(current + numeric); } else if (mathOperator == MathOperator.Subtract) { return(current - numeric); } else { throw new Exception("Unknown operator: " + mathOperator); } }
private string MathOperatorToString(MathOperator @operator) { switch (@operator) { case MathOperator.Add: return(_schema.Operators.Add); case MathOperator.Subtract: return(_schema.Operators.Subtract); case MathOperator.Multiply: return(_schema.Operators.Multiply); case MathOperator.Divide: return(_schema.Operators.Divide); case MathOperator.Modulo: return(_schema.Operators.Modulo); default: throw new InvalidEnumArgumentException("Invalid MathOperator specified."); } }
private static string MathOperatorToString(MathOperator @operator) { switch (@operator) { case MathOperator.Add: return("+"); case MathOperator.Subtract: return("-"); case MathOperator.Multiply: return("*"); case MathOperator.Divide: return("/"); case MathOperator.Modulo: return("%"); default: throw new InvalidOperationException("Invalid MathOperator specified."); } }
MathOpcode CreateMathOpcode(MathOperator op) { MathOpcode opcode = null; switch (op) { case MathOperator.None: Fx.Assert(""); break; case MathOperator.Plus: opcode = new PlusOpcode(); break; case MathOperator.Minus: opcode = new MinusOpcode(); break; case MathOperator.Div: opcode = new DivideOpcode(); break; case MathOperator.Multiply: opcode = new MultiplyOpcode(); break; case MathOperator.Mod: opcode = new ModulusOpcode(); break; case MathOperator.Negate: opcode = new NegateOpcode(); break; } return(opcode); }
public OperatorSymbol(MathOperator o) { this.ContainedOperator = o; if (o == MathOperator.CloseBracket) { this.precedence = -2; } else if (o == MathOperator.Divide) { this.precedence = 8; } else if (o == MathOperator.Minus) { this.precedence = 6; } else if (o == MathOperator.Multiply) { this.precedence = 8; } else if (o == MathOperator.OpenBracket) { this.precedence = -1; } else if (o == MathOperator.Plus) { this.precedence = 6; } else if (o == MathOperator.Power) { this.precedence = 9; } else { this.precedence = -62345; } }
private void onMathOperatorEnter(MathOperator op) { solve(); currentOperator = op; prevNumber = result.Text; }
private static OperatorToken OperatorToken(string token, int index) { OperatorToken t = null; if (token.StartsWith(CONST_AND)) { t = new OperatorToken(); } else if (token.StartsWith(CONST_OR)) { t = new OperatorToken(); } else if (token.StartsWith(CONST_BIT_LEFT)) { t = new BitOperator(); } else if (token.StartsWith(CONST_BIT_RIGHT)) { t = new BitOperator(); } else if (token.StartsWith(CONST_NOT_EQUALS)) { t = new ConditionToken(); } else if (token.StartsWith(CONST_GREATER_EQUALS)) { t = new ConditionToken(); } else if (token.StartsWith(CONST_LESS_EQUALS)) { t = new ConditionToken(); } else if (token.StartsWith(CONST_EQUALS)) { t = new ConditionToken(); } else if (token.StartsWith(CONST_GREATER)) { t = new ConditionToken(); } else if (token.StartsWith(CONST_LESS)) { t = new ConditionToken(); } else if (token.StartsWith(CONST_PLUS)) { t = new MathOperator(); } else if (token.StartsWith(CONST_MINUS)) { t = new MathOperator(); } else if (token.StartsWith(CONST_MULT)) { t = new MathOperator(); } else if (token.StartsWith(CONST_DIVD)) { t = new MathOperator(); } else if (token.StartsWith(CONST_MOD)) { t = new MathOperator(); } else if (token.StartsWith(CONST_BIT_AND)) { t = new BitOperator(); } else if (token.StartsWith(CONST_BIT_LEFT)) { t = new BitOperator(); } else if (token.StartsWith(CONST_BIT_NOT)) { t = new BitOperator(); } else if (token.StartsWith(CONST_BIT_OR)) { t = new BitOperator(); } else if (token.StartsWith(CONST_BIT_RIGHT)) { t = new BitOperator(); } else if (token.StartsWith(CONST_BIT_XOR)) { t = new BitOperator(); } t.Value = token; t.Index = index; t.Length = token.Length; return(t); }
protected ExpressionString(MathOperator op) { Operator = op; List = new List <TElem>(); }
internal MathOpcode(OpcodeID id, MathOperator op) : base(id) { this.mathOp = op; }
private MathOpcode CreateMathOpcode(MathOperator op) { MathOpcode opcode = null; switch (op) { case MathOperator.None: return opcode; case MathOperator.Plus: return new PlusOpcode(); case MathOperator.Minus: return new MinusOpcode(); case MathOperator.Div: return new DivideOpcode(); case MathOperator.Multiply: return new MultiplyOpcode(); case MathOperator.Mod: return new ModulusOpcode(); case MathOperator.Negate: return new NegateOpcode(); } return opcode; }
MathOpcode CreateMathOpcode(MathOperator op) { MathOpcode opcode = null; switch (op) { case MathOperator.None: Fx.Assert(""); break; case MathOperator.Plus: opcode = new PlusOpcode(); break; case MathOperator.Minus: opcode = new MinusOpcode(); break; case MathOperator.Div: opcode = new DivideOpcode(); break; case MathOperator.Multiply: opcode = new MultiplyOpcode(); break; case MathOperator.Mod: opcode = new ModulusOpcode(); break; case MathOperator.Negate: opcode = new NegateOpcode(); break; } return opcode; }
internal XPathMathExpr(MathOperator op, XPathExpr left, XPathExpr right) : base(XPathExprType.Math, ValueDataType.Double, left, right) { this.op = op; }
internal MathCalculateDataFieldInfo(DataFieldInfo info, MathOperator opera, object value) : base(info) { _opera = opera; _value = value; }
private static Price MathOperation(Price lhs, Price rhs, MathOperator op) { if (((Object)rhs == null) && ((Object)lhs == null)) { //throw new ApplicationException("Both Prices may not be Null!"); return null; } else if (((Object)rhs == null) || ((Object)lhs == null)) { if ((Object)rhs == null) { return (Price)lhs.MemberwiseClone(); } else { switch (op) { case MathOperator.Add: return (Price)rhs.MemberwiseClone(); case MathOperator.Subtract: return (rhs * -1); default: throw new ApplicationException("You did not select a valid math operation"); } } } else { // Use Eq because it is not possible to do operator overloading on an interface if (!(lhs.Underlying.Equals(rhs.Underlying))) { throw new ApplicationException("Cannot add Two different currencies!"); } else if (!(lhs.Instrument.Equals(rhs.Instrument))) { throw new ApplicationException("Cannot add Two different instruments!"); } else { switch (op) { case MathOperator.Add: return lhs.Clone(lhs.Quantity + rhs.Quantity); case MathOperator.Subtract: return lhs.Clone(lhs.Quantity - rhs.Quantity); default: throw new ApplicationException("You did not select a valid math operation"); } } } }
public TestCalcService() { op = MathOperator.Add; }
public GraphElement CreateNode(MathNode mathNode) { if (mathNode is MathOperator) { MathOperator add = mathNode as MathOperator; return(CreateMathNode(mathNode, mathNode.name, add.m_Position, 2, 1)); } else if (mathNode is MathStackNode) { MathStackNode mathStackNode = mathNode as MathStackNode; return(CreateStackNode(mathStackNode, mathStackNode.m_Position)); } else if (mathNode is MathFunction) { MathFunction fn = mathNode as MathFunction; Debug.Assert(fn.parameterCount == fn.parameterNames.Length); Node nodeUI = CreateMathNode(mathNode, mathNode.name, mathNode.m_Position, fn.parameterNames.Length, 1); for (int i = 0; i < fn.parameterNames.Length; ++i) { (nodeUI.inputContainer.ElementAt(i) as Port).portName = fn.parameterNames[i]; } return(nodeUI); } else if (mathNode is IMathBookFieldNode) { IMathBookFieldNode mathBookFieldNode = mathNode as IMathBookFieldNode; SimpleTokenNode tokenNode = new SimpleTokenNode(mathBookFieldNode); tokenNode.SetPosition(new Rect(mathNode.m_Position, Vector2.zero)); tokenNode.RefreshPorts(); tokenNode.visible = true; return(tokenNode); } else if (mathNode is MathConstant) { MathConstant mathConstant = mathNode as MathConstant; Node nodeUI = CreateMathNode( mathNode, mathConstant.name, mathConstant.m_Position, 0, 1); var field = new DoubleField() { value = mathConstant.m_Value }; field.SetEnabled(!(mathConstant is PIConstant)); field.RegisterValueChangedCallback(evt => mathConstant.m_Value = (float)evt.newValue); nodeUI.inputContainer.Add(field); nodeUI.RefreshExpandedState(); return(nodeUI); } else if (mathNode is MathResult) { MathResult mathResult = mathNode as MathResult; Node nodeUI = CreateMathNode( mathNode, "Result", mathResult.m_Position, 1, 0); nodeUI.inputContainer.Add(new Button(() => Debug.Log(mathResult.Evaluate())) { text = "Print result" }); return(nodeUI); } else if (mathNode is MathGroupNode) { MathGroupNode mathGroupNode = mathNode as MathGroupNode; if (mathGroupNode.m_IsScope) { return(CreateScope(mathGroupNode, mathGroupNode.m_Position)); } else { return(CreateGroupNode(mathGroupNode, mathGroupNode.m_Title, mathGroupNode.m_Position)); } } return(null); }
public MathReference(object leftOperand, object rightOperand, MathOperator @operator) { _leftOperand = leftOperand; _rightOperand = rightOperand; _operator = @operator; }
private static InstrumentSize MathOperation(InstrumentSize lhs, InstrumentSize rhs, MathOperator op, bool noRounding) { if (((Object)rhs == null) && ((Object)lhs == null)) { //throw new ApplicationException("Both Instruments may not be Null!"); return null; } else if (((Object)rhs == null) || ((Object)lhs == null)) { if ((Object)rhs == null) { return (InstrumentSize)lhs.MemberwiseClone(); } else { switch (op) { case MathOperator.Add: return (InstrumentSize)rhs.MemberwiseClone(); case MathOperator.Subtract: return InstrumentSize.Multiply(rhs, -1M, noRounding); default: throw new ApplicationException("You did not select a valid math operation"); } } } else { // Use Eq because it is not possible to do operator overloading on an interface if (!(lhs.Underlying.Equals(rhs.Underlying))) { string errorMessage; if (lhs.IsMoney) { errorMessage = "Cannot add Two different currencies!"; } else { errorMessage = "Cannot add two different Intruments"; } throw new ApplicationException(errorMessage); } else { switch (op) { case MathOperator.Add: return new InstrumentSize(lhs.Quantity + rhs.Quantity, lhs.Underlying, noRounding); case MathOperator.Subtract: return new InstrumentSize(lhs.Quantity - rhs.Quantity, lhs.Underlying, noRounding); default: throw new ApplicationException("You did not select a valid math operation"); } } } }
private MathReference(object leftOperand, object rightOperand, MathOperator @operator, string alias) : base(alias) { _leftOperand = leftOperand; _rightOperand = rightOperand; _operator = @operator; }
public MathExpressionResult(MathOperator op, char opChar, string expression) { this.op = op; this.opChar = opChar; this.expression = expression; }
public void Reload(IEnumerable <MathNode> nodesToReload, IEnumerable <MathPlacemat> placemats, IEnumerable <MathStickyNote> stickies, Dictionary <string, string> oldToNewIdMapping = null) { string oldId; var nodes = new Dictionary <MathNode, GraphElement>(); var oldIdToNewNode = new Dictionary <string, ISelectable>(); var newToOldIdMapping = new Dictionary <string, string>(); if (oldToNewIdMapping != null) { foreach (var oldIdKV in oldToNewIdMapping) { newToOldIdMapping[oldIdKV.Value] = oldIdKV.Key; } } // Create the nodes. foreach (MathNode mathNode in nodesToReload) { GraphElement node = m_SimpleGraphViewWindow.CreateNode(mathNode); if (node is Group) { node.name = "SimpleGroup"; } else if (node is Scope) { node.name = "SimpleScope"; } else { node.name = "SimpleNode"; } if (node == null) { Debug.LogError("Could not create node " + mathNode); continue; } nodes[mathNode] = node; if (mathNode.groupNode == null) { if (newToOldIdMapping.TryGetValue(mathNode.nodeID.ToString(), out oldId)) { oldIdToNewNode.Add(oldId, node); } } AddElement(node); } // Assign scopes foreach (MathNode mathNode in nodesToReload) { if (mathNode.groupNode == null) { continue; } Scope graphScope = nodes[mathNode.groupNode] as Scope; graphScope.AddElement(nodes[mathNode]); } // Add to stacks foreach (MathNode mathNode in nodesToReload) { MathStackNode stack = mathNode as MathStackNode; if (stack == null) { continue; } StackNode graphStackNode = nodes[stack] as StackNode; for (int i = 0; i < stack.nodeCount; ++i) { MathNode stackMember = stack.GetNode(i); if (stackMember == null) { Debug.LogWarning("null stack member! Item " + i + " of stack " + stack.name + " is null. Possibly a leftover from bad previous manips."); } graphStackNode.AddElement(nodes[stackMember]); } } // Connect the presenters. foreach (var mathNode in nodesToReload) { if (mathNode is MathOperator) { MathOperator mathOperator = mathNode as MathOperator; if (!nodes.ContainsKey(mathNode)) { Debug.LogError("No element found for " + mathNode); continue; } var graphNode = nodes[mathNode] as Node; if (mathOperator.left != null && nodes.ContainsKey(mathOperator.left)) { var outputPort = (nodes[mathOperator.left] as Node).outputContainer[0] as Port; var inputPort = graphNode.inputContainer[0] as Port; Edge edge = inputPort.ConnectTo(outputPort); edge.viewDataKey = mathOperator.left.nodeID + "_edge"; AddElement(edge); } else if (mathOperator.left != null) { //add.m_Left = null; Debug.LogWarning("Invalid left operand for operator " + mathOperator + " , " + mathOperator.left); } if (mathOperator.right != null && nodes.ContainsKey(mathOperator.right)) { var outputPort = (nodes[mathOperator.right] as Node).outputContainer[0] as Port; var inputPort = graphNode.inputContainer[1] as Port; Edge edge = inputPort.ConnectTo(outputPort); edge.viewDataKey = mathOperator.right.nodeID + "_edge"; AddElement(edge); } else if (mathOperator.right != null) { Debug.LogWarning("Invalid right operand for operator " + mathOperator + " , " + mathOperator.right); } } else if (mathNode is MathFunction) { MathFunction mathFunction = mathNode as MathFunction; if (!nodes.ContainsKey(mathNode)) { Debug.LogError("No element found for " + mathNode); continue; } var graphNode = nodes[mathNode] as Node; for (int i = 0; i < mathFunction.parameterCount; ++i) { MathNode param = mathFunction.GetParameter(i); if (param != null && nodes.ContainsKey(param)) { var outputPort = (nodes[param] as Node).outputContainer[0] as Port; var inputPort = graphNode.inputContainer[i] as Port; Edge edge = inputPort.ConnectTo(outputPort); edge.viewDataKey = param.nodeID + "_edge"; AddElement(edge); } else if (param != null) { Debug.LogWarning("Invalid parameter for function" + mathFunction + " , " + param); } } } else if (mathNode is MathResult) { MathResult mathResult = mathNode as MathResult; var graphNode = nodes[mathNode] as Node; if (mathResult.root != null) { var outputPort = (nodes[mathResult.root] as Node).outputContainer[0] as Port; var inputPort = graphNode.inputContainer[0] as Port; Edge edge = inputPort.ConnectTo(outputPort); edge.viewDataKey = mathResult.root.nodeID + "_edge"; AddElement(edge); } } } foreach (var matModel in placemats.OrderBy(p => p.zOrder)) { var newPlacemat = placematContainer.CreatePlacemat <SimplePlacemat>(matModel.position, matModel.zOrder, matModel.title); newPlacemat.userData = matModel; newPlacemat.viewDataKey = matModel.identification; newPlacemat.Model = matModel; if (newToOldIdMapping.TryGetValue(matModel.identification, out oldId)) { oldIdToNewNode.Add(oldId, newPlacemat); } } if (stickies != null) { var existingStickies = this.Query <SimpleStickyNote>().ToList(); foreach (var sticky in existingStickies.Where(t => !stickies.Contains(t.model))) { RemoveElement(sticky); } foreach (var stickyModel in stickies.Except(existingStickies.Select(t => t.model))) { var newSticky = new SimpleStickyNote(); newSticky.model = stickyModel; newSticky.userData = stickyModel; AddElement(newSticky); if (newToOldIdMapping.TryGetValue(stickyModel.id, out oldId)) { oldIdToNewNode.Add(oldId, newSticky); } } } // Now that all graph elements have been created, init the collapsed elements of each placemat. foreach (var p in this.Query <SimplePlacemat>().ToList()) { p.InitCollapsedElementsFromModel(); } // Make sure collapsed edges are hidden. placematContainer.HideCollapsedEdges(); UpdateSelection(oldIdToNewNode); RebuildBlackboard(); }