/// <inheritdoc /> public override void VisitIntervalFloatValue(FloatIntervalValue value) { // When comparing, both operands are converted to boolean switch (operation) { case Operations.BitOr: case Operations.BitXor: IntervalValue <int> integerInterval; if (TypeConversion.TryConvertToIntegerInterval(OutSet, value, out integerInterval)) { result = integerInterval; } else { result = OutSet.AnyIntegerValue; } break; case Operations.Mod: result = ModuloOperation.Modulo(flow, TypeConversion.ToInteger(leftOperand), value); break; default: result = ArithmeticOperation.Arithmetic(flow, operation, TypeConversion.ToFloat(leftOperand), value); if (result != null) { break; } base.VisitIntervalFloatValue(value); break; } }
static void Main(string[] args) { ArithmeticOperation.ArOpDel additionDelegate = ArithmeticOperation.Addition; Console.WriteLine(ArithmeticOperation.ConvertResultToString(additionDelegate, 5, 6)); Console.ReadKey(); }
public void VisitArithmeticOperation(ArithmeticOperation node) { node.LeftOperand.Accept(this); node.RightOperand.Accept(this); switch (node.Operator.Tag) { case TokenTag.PLUS: _emitter.Emit(OpCodes.Add); return; case TokenTag.MINUS: _emitter.Emit(OpCodes.Sub); return; case TokenTag.MULTIPLY: _emitter.Emit(OpCodes.Mul); return; case TokenTag.DIVIDE: _emitter.Emit(OpCodes.Div); return; case TokenTag.MOD: _emitter.Emit(OpCodes.Rem); return; case TokenTag.LEFT_SHIFT: _emitter.Emit(OpCodes.Shl); return; case TokenTag.RIGHT_SHIFT: _emitter.Emit(OpCodes.Shr); return; case TokenTag.BIT_OR: _emitter.Emit(OpCodes.Or); return; case TokenTag.BIT_AND: _emitter.Emit(OpCodes.And); return; case TokenTag.BIT_XOR: _emitter.Emit(OpCodes.Xor); return; } throw new SemanticException("Not supported operator: {0}", node.Operator); }
/// <inheritdoc /> public override void VisitStringValue(StringValue value) { result = Comparison.AbstractCompare(OutSet, operation); if (result != null) { return; } int integerValue; double floatValue; bool isInteger; TypeConversion.TryConvertToNumber(value.Value, true, out integerValue, out floatValue, out isInteger); result = isInteger ? ArithmeticOperation.LeftAbstractArithmetic(flow, operation, integerValue) : ArithmeticOperation.LeftAbstractArithmetic(flow, operation, floatValue); if (result != null) { return; } base.VisitStringValue(value); }
/// <inheritdoc /> public override void VisitIntervalFloatValue(FloatIntervalValue value) { switch (operation) { case Operations.Identical: result = OutSet.CreateBool(false); break; case Operations.NotIdentical: result = OutSet.CreateBool(true); break; case Operations.Mod: result = ModuloOperation.AbstractModulo(flow, value); break; default: result = ArithmeticOperation.LeftAbstractArithmetic(flow, operation, value); if (result != null) { break; } base.VisitIntervalFloatValue(value); break; } }
/// <inheritdoc /> public override void VisitAnyStringValue(AnyStringValue value) { switch (operation) { case Operations.Identical: result = OutSet.CreateBool(false); break; case Operations.NotIdentical: result = OutSet.CreateBool(true); break; case Operations.Mod: result = ModuloOperation.AbstractModulo(flow); break; default: result = Comparison.AbstractCompare(OutSet, operation); if (result != null) { break; } result = ArithmeticOperation.AbstractFloatArithmetic(Snapshot, operation); if (result != null) { // A string can be converted into floating point number too. break; } base.VisitAnyStringValue(value); break; } }
/// <inheritdoc /> public override void VisitAssociativeArray(AssociativeArray value) { result = Comparison.RightAlwaysGreater(OutSet, operation); if (result != null) { return; } result = LogicalOperation.Logical(OutSet, operation, leftOperand, TypeConversion.ToNativeBoolean(Snapshot, value)); if (result != null) { return; } result = BitwiseOperation.Bitwise(OutSet, operation); if (result != null) { return; } if (ArithmeticOperation.IsArithmetic(operation)) { // TODO: This must be fatal error SetWarning("Unsupported operand type: Arithmetic of array and numeric type"); result = OutSet.AnyValue; return; } base.VisitAssociativeArray(value); }
public IActionResult Index(ArithmeticOperation model, string btnAction) { if (btnAction == "+") { ViewBag.ans = model.no1 + model.no2; } else if (btnAction == "-") { ViewBag.ans = model.no1 - model.no2; } else if (btnAction == "*") { ViewBag.ans = model.no1 * model.no2; } else { if (model.no1 != 0 && model.no2 != 0) { ViewBag.ans = model.no1 / model.no2; } else { ViewBag.ans = 0; } } return(View()); }
public double Calculate(string text) { var parsedValues = Parse(text); switch (parsedValues.Item2) { case "+": Operation = ArithmeticOperation.Addition; return(parsedValues.Item1 + parsedValues.Item3); case "-": Operation = ArithmeticOperation.Subtraction; return(parsedValues.Item1 - parsedValues.Item3); case "*": Operation = ArithmeticOperation.Multiplication; return(parsedValues.Item1 * parsedValues.Item3); case "/": Operation = ArithmeticOperation.Division; if (parsedValues.Item3 == 0) { throw new DivideByZeroException("Can't divide by 0"); } return((parsedValues.Item1 * (1.0d)) / ((1.0d) * parsedValues.Item3)); } return(0.0); }
/// <inheritdoc /> public override void VisitAnyStringValue(AnyStringValue value) { switch (operation) { case Operations.Equal: case Operations.NotEqual: case Operations.GreaterThanOrEqual: case Operations.LessThan: case Operations.Or: case Operations.Xor: result = OutSet.AnyBooleanValue; break; case Operations.Mod: result = ModuloOperation.AbstractModulo(flow); break; case Operations.BitOr: case Operations.BitXor: result = OutSet.AnyIntegerValue; break; default: result = ArithmeticOperation.AbstractFloatArithmetic(Snapshot, operation); if (result != null) { break; } base.VisitAnyStringValue(value); break; } }
/// <inheritdoc /> public override void VisitAnyObjectValue(AnyObjectValue value) { var rightBoolean = TypeConversion.ToBoolean(value); result = Comparison.Compare(OutSet, operation, leftOperand.Value, rightBoolean); if (result != null) { return; } result = ArithmeticOperation.RightAbstractArithmetic(flow, operation, TypeConversion.ToInteger(leftOperand.Value)); if (result != null) { SetWarning("Object cannot be converted to integer by arithmetic operation", AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER); return; } result = LogicalOperation.Logical(OutSet, operation, leftOperand.Value, rightBoolean); if (result != null) { return; } base.VisitAnyObjectValue(value); }
private IComparable PerformArithematicOperation(IEvaluable evaluable, IJSONDocument document, ArithmeticOperation operation) { IJsonValue value1, value2; if (!Evaluate(out value1, document)) { return(null); } if (!evaluable.Evaluate(out value2, document)) { return(null); } TypeCode actualType1, actualType2; FieldDataType fieldDataType1 = JSONType.GetJSONType(value1.Value, out actualType1); FieldDataType fieldDataType2 = JSONType.GetJSONType(value2.Value, out actualType2); if (fieldDataType1.CompareTo(fieldDataType2) != 0) { return(null); } return(Evaluator.PerformArithmeticOperation(value1, actualType1, value2, actualType2, operation, fieldDataType1)); }
/// <inheritdoc /> public override void VisitAnyArrayValue(AnyArrayValue value) { switch (operation) { case Operations.Mod: result = ModuloOperation.AbstractModulo(flow); break; default: result = BitwiseOperation.Bitwise(OutSet, operation); if (result != null) { break; } if (ArithmeticOperation.IsArithmetic(operation)) { // TODO: This must be fatal error SetWarning("Unsupported operand type: Arithmetic of array and scalar type"); result = OutSet.AnyValue; break; } base.VisitAnyArrayValue(value); break; } }
/// <inheritdoc /> public override void VisitIntervalFloatValue(FloatIntervalValue value) { switch (operation) { case Operations.Identical: result = OutSet.CreateBool(false); break; case Operations.NotIdentical: result = OutSet.CreateBool(true); break; case Operations.Mod: result = ModuloOperation.Modulo(flow, leftOperand, value); break; default: var floatInterval = TypeConversion.ToFloatInterval(OutSet, leftOperand); result = Comparison.IntervalCompare(OutSet, operation, floatInterval, value); if (result != null) { break; } result = ArithmeticOperation.Arithmetic(flow, operation, leftOperand, value); if (result != null) { break; } base.VisitIntervalFloatValue(value); break; } }
/// <inheritdoc /> public override void VisitUndefinedValue(UndefinedValue value) { switch (operation) { case Operations.Identical: case Operations.And: result = OutSet.CreateBool(false); break; case Operations.NotIdentical: result = OutSet.CreateBool(true); break; case Operations.BitAnd: result = OutSet.CreateInt(0); break; case Operations.Div: result = ArithmeticOperation.DivisionByNull(flow); break; case Operations.Mod: result = ModuloOperation.ModuloByNull(flow); break; default: base.VisitUndefinedValue(value); break; } }
/// <inheritdoc /> public override void VisitBooleanValue(BooleanValue value) { var leftBoolean = TypeConversion.ToBoolean(leftOperand.Value); result = Comparison.Compare(OutSet, operation, leftBoolean, value.Value); if (result != null) { return; } var rightInteger = TypeConversion.ToInteger(value.Value); result = ArithmeticOperation.Arithmetic(flow, operation, leftOperand.Value, rightInteger); if (result != null) { return; } result = LogicalOperation.Logical(OutSet, operation, leftBoolean, value.Value); if (result != null) { return; } result = BitwiseOperation.Bitwise(OutSet, operation, leftOperand.Value, rightInteger); if (result != null) { return; } base.VisitBooleanValue(value); }
/// <inheritdoc /> public override void VisitIntegerValue(IntegerValue value) { switch (operation) { case Operations.Identical: result = Comparison.Equal(OutSet, leftOperand, value.Value); break; case Operations.NotIdentical: result = Comparison.NotEqual(OutSet, leftOperand, value.Value); break; case Operations.Mod: result = ModuloOperation.Modulo(flow, leftOperand, value.Value); break; default: result = Comparison.IntervalCompare(OutSet, operation, leftOperand, value.Value); if (result != null) { break; } result = ArithmeticOperation.Arithmetic(flow, operation, leftOperand, value.Value); if (result != null) { break; } base.VisitIntegerValue(value); break; } }
/// <inheritdoc /> public override void VisitIntervalIntegerValue(IntegerIntervalValue value) { // When comparing, both operands are converted to boolean switch (operation) { case Operations.BitOr: case Operations.BitXor: result = value; break; case Operations.Mod: result = ModuloOperation.Modulo(flow, TypeConversion.ToInteger(leftOperand), value); break; default: result = ArithmeticOperation.Arithmetic(flow, operation, TypeConversion.ToInteger(leftOperand), value); if (result != null) { break; } base.VisitIntervalIntegerValue(value); break; } }
/// <inheritdoc /> public override void VisitAnyObjectValue(AnyObjectValue value) { if (Comparison.IsOperationComparison(operation)) { // The comparison of string with object depends upon whether the object has // the "__toString" magic method implemented. If so, the string comparison is // performed. Otherwise, the object is always greater than string. Since we cannot // determine whether the abstract object has or has not the method, // we must return indeterminate boolean value. result = OutSet.AnyBooleanValue; return; } result = LogicalOperation.AbstractLogical(OutSet, operation, TypeConversion.ToBoolean(value)); if (result != null) { return; } result = ArithmeticOperation.AbstractFloatArithmetic(Snapshot, operation); if (result != null) { SetWarning("Object cannot be converted to integer by arithmetic operation", AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER); return; } base.VisitAnyObjectValue(value); }
/// <inheritdoc /> public override void VisitAnyBooleanValue(AnyBooleanValue value) { switch (operation) { case Operations.Mod: SetWarning("Object cannot be converted to integer by modulo operation", AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER); result = ModuloOperation.ModuloByAnyBooleanValue(flow); break; default: result = Comparison.RightAbstractBooleanCompare(OutSet, operation, TypeConversion.ToBoolean(leftOperand)); if (result != null) { break; } result = ArithmeticOperation.RightAbstractBooleanArithmetic(flow, operation); if (result != null) { SetWarning("Object cannot be converted to integer by arithmetic operation", AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER); break; } base.VisitAnyBooleanValue(value); break; } }
/// <inheritdoc /> public override void VisitAnyStringValue(AnyStringValue value) { switch (operation) { case Operations.Mod: SetWarning("Object cannot be converted to integer by modulo operation", AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER); result = ModuloOperation.AbstractModulo(flow); break; default: if (Comparison.IsOperationComparison(operation)) { // TODO: The comparison of string with object depends upon whether the object has // the "__toString" magic method implemented. If so, the string comparison is // performed. Otherwise, the object is always greater than string. result = OutSet.AnyBooleanValue; break; } result = ArithmeticOperation.AbstractFloatArithmetic(Snapshot, operation); if (result != null) { // A string can be converted into floating point number too. break; } base.VisitAnyStringValue(value); break; } }
/// <inheritdoc /> public override void VisitIntervalFloatValue(FloatIntervalValue value) { switch (operation) { case Operations.Mod: SetWarning("Object cannot be converted to integer by modulo operation", AnalysisWarningCause.OBJECT_CONVERTED_TO_INTEGER); result = ModuloOperation.AbstractModulo(flow, value); break; default: result = ArithmeticOperation.LeftAbstractArithmetic(flow, operation, value); if (result != null) { break; } result = LogicalOperation.Logical(OutSet, operation, TypeConversion.ToBoolean(leftOperand), value); if (result != null) { break; } base.VisitIntervalFloatValue(value); break; } }
/// <inheritdoc /> public override void VisitAnyResourceValue(AnyResourceValue value) { result = Comparison.AbstractCompare(OutSet, operation); if (result != null) { // Comapring of resource and string makes no sence. return; } result = LogicalOperation.Logical(OutSet, operation, TypeConversion.ToBoolean(leftOperand.Value), TypeConversion.ToBoolean(value)); if (result != null) { return; } int integerValue; double floatValue; bool isInteger; TypeConversion.TryConvertToNumber(leftOperand.Value, true, out integerValue, out floatValue, out isInteger); result = isInteger ? ArithmeticOperation.RightAbstractArithmetic(flow, operation, integerValue) : ArithmeticOperation.RightAbstractArithmetic(flow, operation, floatValue); if (result != null) { // Arithmetic with resources is nonsence return; } base.VisitAnyResourceValue(value); }
// Recursively call the lower arithmetic stage until a primitive private Func <AbstractExpressionNode> ArithmeticOperation(ArithmeticLevel level) { return(() => { if (level == ArithmeticLevel.Primitive) { return ArithmeticPrimitive(); } return ExecuteIfOperator ( ArithmeticOperation(level - 1)(), ArithmeticOperation(level), GetOperators(level) ); }); }
/// <inheritdoc /> public override void VisitAnyScalarValue(AnyScalarValue value) { result = Comparison.AbstractCompare(OutSet, operation); if (result != null) { // Ommitted warning message that object cannot be converted to integer return; } result = ArithmeticOperation.AbstractFloatArithmetic(Snapshot, operation); if (result != null) { // Ommitted warning message that object cannot be converted to integer // Ommitted error report that array is unsupported operand in arithmetic operation return; } result = LogicalOperation.AbstractLogical(OutSet, operation); if (result != null) { return; } result = BitwiseOperation.Bitwise(OutSet, operation); if (result != null) { // Ommitted warning message that object cannot be converted to integer return; } base.VisitAnyScalarValue(value); }
/// <inheritdoc /> public override void VisitAnyResourceValue(AnyResourceValue value) { var rightBoolean = TypeConversion.ToBoolean(value); result = Comparison.Compare(OutSet, operation, leftOperand.Value, rightBoolean); if (result != null) { return; } result = LogicalOperation.Logical(OutSet, operation, leftOperand.Value, rightBoolean); if (result != null) { return; } result = ArithmeticOperation.RightAbstractArithmetic(flow, operation, TypeConversion.ToInteger(leftOperand.Value)); if (result != null) { // Arithmetic with resources is nonsence return; } base.VisitAnyResourceValue(value); }
/// <inheritdoc /> public override void VisitGenericIntervalValue <T>(IntervalValue <T> value) { switch (operation) { case Operations.Identical: result = OutSet.CreateBool(false); break; case Operations.NotIdentical: result = OutSet.CreateBool(true); break; default: result = Comparison.AbstractCompare(OutSet, operation); if (result != null) { break; } result = ArithmeticOperation.AbstractFloatArithmetic(Snapshot, operation); if (result != null) { break; } base.VisitGenericIntervalValue(value); break; } }
/// <inheritdoc /> public override void VisitStringValue(StringValue value) { switch (operation) { case Operations.Mod: result = ModuloOperation.Modulo(flow, leftOperand, value.Value); break; default: int integerValue; double floatValue; bool isInteger; TypeConversion.TryConvertToNumber(value.Value, true, out integerValue, out floatValue, out isInteger); result = Comparison.IntervalCompare(OutSet, operation, leftOperand, floatValue); if (result != null) { break; } result = ArithmeticOperation.Arithmetic(flow, operation, leftOperand, floatValue); if (result != null) { break; } base.VisitStringValue(value); break; } }
public ArithmeticExpression(ArithmeticOperation op, TextExpression exp1, TextExpression exp2) { this._op = op; this._exp1 = exp1; this._exp2 = exp2; this.RawValue = exp1.RawValue + (object)op + exp2.RawValue; }
/// <inheritdoc /> public override void VisitAnyValue(AnyValue value) { switch (operation) { case Operations.Identical: case Operations.NotIdentical: result = OutSet.AnyBooleanValue; break; case Operations.Mod: // Ommitted warning message that object cannot be converted to integer result = ModuloOperation.AbstractModulo(flow); break; default: result = ArithmeticOperation.AbstractFloatArithmetic(Snapshot, operation); if (result != null) { // Ommitted warning message that object cannot be converted to integer // Ommitted error report that array is unsupported operand in arithmetic operation break; } result = BitwiseOperation.Bitwise(OutSet, operation); if (result != null) { // Ommitted warning message that object cannot be converted to integer break; } base.VisitAnyValue(value); break; } }
public NumberChain(byte number, NumberChain previous = null, ArithmeticOperation? operation = null, ushort? result = null) { Number = number; Previous = previous; if (Previous != null) Operation = operation; Result = result; if (Result == null && Previous != null && Operation != null) Result = Operation.Value.GetResult(Previous.Result ?? Previous.Number, Number); }
public virtual TreeNode OnPerformArithmetic(TreeNode [] args, ArithmeticOperation operation) { double result = 0.0; bool as_int = true; for(int i = 0; i < args.Length; i++) { TreeNode arg = Evaluate(args[i]); if(arg is IntLiteral || arg is DoubleLiteral) { double arg_value; if(arg is DoubleLiteral) { as_int = false; arg_value = (arg as DoubleLiteral).Value; } else { arg_value = (int)(arg as IntLiteral).Value; } if(i == 0) { result = arg_value; continue; } switch(operation) { case ArithmeticOperation.Add: result += arg_value; break; case ArithmeticOperation.Subtract: result -= arg_value; break; case ArithmeticOperation.Multiply: result *= arg_value; break; case ArithmeticOperation.Divide: result /= arg_value; break; case ArithmeticOperation.Modulo: if(!(arg is IntLiteral)) { throw new ArgumentException("Modulo requires int arguments"); } result %= (int)arg_value; break; } } else { throw new ArgumentException("arguments must be double or int"); } } return as_int ? ((TreeNode)new IntLiteral((int)result)) : ((TreeNode)new DoubleLiteral(result)); }
private void ArithmeticPaste(ArithmeticOperation operation) { if (_systemInterface.Clipboard == null) { return; } var clipboard = _systemInterface.Clipboard; var height = clipboard.GetLength(Utils.IndexRowsOrHeight); var width = clipboard.GetLength(Utils.IndexColsOrWidth); AddUndoItem(new Rectangle(_selectedCells.X, _selectedCells.Y, width, height), UndoOriginalBehavior.Overwrite, Resources.UndoText_ArithmeticPaste); var minLevel = _sequence.MinimumLevel; var maxLevel = _sequence.MaximumLevel; var rowOffset = _selectedCells.Top; var colOffset = _selectedCells.Left; for (var row = 0; (row < height) && ((rowOffset + row) < _sequence.ChannelCount); row++) { var channel = GetEventFromChannelNumber(rowOffset + row); for (var col = 0; (col < width) && ((colOffset + col) < _sequence.TotalEventPeriods); col++) { var currentValue = _sequence.EventValues[channel, colOffset + col]; var clipValue = clipboard[row, col]; switch (operation) { case ArithmeticOperation.Addition: currentValue = (byte) Math.Min(currentValue + clipValue, maxLevel); break; case ArithmeticOperation.Subtraction: currentValue = (byte) Math.Max(currentValue - clipValue, minLevel); break; case ArithmeticOperation.Scale: currentValue = (byte) Math.Max(Math.Min(currentValue * (clipValue / (float) Utils.Cell8BitMax), maxLevel), minLevel); break; case ArithmeticOperation.Min: currentValue = Math.Max(Math.Min(clipValue, currentValue), minLevel); break; case ArithmeticOperation.Max: currentValue = Math.Min(Math.Max(clipValue, currentValue), maxLevel); break; } _sequence.EventValues[channel, colOffset + col] = currentValue; } } IsDirty = true; pictureBoxGrid.Refresh(); }
public ArithmeticResult Substract(ArithmeticOperation operation) { return new ArithmeticResult() { Result = operation.FirstOperand - operation.SecondOperand }; }
public ArithmeticResult Add(ArithmeticOperation operation) { return new ArithmeticResult() { Result = operation.FirstOperand + operation.SecondOperand }; }
public ArithmeticInstruction(int offset, ArithmeticOperation operation, Operand destination, Operand source) : base(offset, destination, source) { this.operation = operation; }
private static DataArray<double> PerformArithmeticOperation(DataArray<double> data, double value, ArithmeticOperation operation) { if (data == null) { throw new ArgumentNullException("data", "DataArray<double> must not be null."); } var array = new DataArray<double>(data.Count); for (int i = 0; i < data.StartIndex; i++) { array.Add(0.0); } switch (operation) { case ArithmeticOperation.Negation: for (int j = data.StartIndex; j < data.Count; j++) { array.Add(-data[j]); } break; case ArithmeticOperation.Addition: for (int k = data.StartIndex; k < data.Count; k++) { array.Add(data[k] + value); } break; case ArithmeticOperation.Subtraction: for (int m = data.StartIndex; m < data.Count; m++) { array.Add(data[m] - value); } break; case ArithmeticOperation.Multiplication: for (int n = data.StartIndex; n < data.Count; n++) { array.Add(data[n] * value); } break; case ArithmeticOperation.Division: for (int num6 = data.StartIndex; num6 < data.Count; num6++) { array.Add(data[num6] / value); } break; case ArithmeticOperation.Modulus: for (int num7 = data.StartIndex; num7 < data.Count; num7++) { array.Add(data[num7] % value); } break; case ArithmeticOperation.Power: for (int num8 = data.StartIndex; num8 < data.Count; num8++) { array.Add(Math.Pow(data[num8], value)); } break; } array.StartIndex = data.StartIndex; return array; }
private static DataArray<double> PerformArithmeticOperation(DataArray<double> data1, DataArray<double> data2, ArithmeticOperation operation) { if (data1 == null) { throw new ArgumentNullException("data1", "DataArray<double> must not be null."); } if (data2 == null) { throw new ArgumentNullException("data2", "DataArray<double> must not be null."); } if (data1.Count != data2.Count) { throw new ArgumentException("Array sizes do not match.", "data1"); } var array = new DataArray<double>(data1.Count); DataArray<double> array2 = data2; if (data1.StartIndex > data2.StartIndex) { array2 = data1; } for (int i = 0; i < array2.StartIndex; i++) { array.Add(0.0); } switch (operation) { case ArithmeticOperation.Addition: for (int j = array2.StartIndex; j < array2.Count; j++) { array.Add(data1[j] + data2[j]); } break; case ArithmeticOperation.Subtraction: for (int k = array2.StartIndex; k < array2.Count; k++) { array.Add(data1[k] - data2[k]); } break; case ArithmeticOperation.Multiplication: for (int m = array2.StartIndex; m < array2.Count; m++) { array.Add(data1[m] * data2[m]); } break; case ArithmeticOperation.Division: for (int n = array2.StartIndex; n < array2.Count; n++) { array.Add(data1[n] / data2[n]); } break; case ArithmeticOperation.Modulus: for (int num6 = array2.StartIndex; num6 < array2.Count; num6++) { array.Add(data1[num6] % data2[num6]); } break; case ArithmeticOperation.Power: for (int num7 = array2.StartIndex; num7 < array2.Count; num7++) { array.Add(Math.Pow(data1[num7], data2[num7])); } break; } array.StartIndex = array2.StartIndex; return array; }