예제 #1
0
        public void Run(string[] delimiters, bool allowNegative = true, int?upperBound = null, OperatorTypes mathOperator = OperatorTypes.Add)
        {
            try
            {
                if (delimiters?.Length > 0)
                {
                    _parser.SetDelimiters(delimiters);
                }
                _parser.AllowNegative = allowNegative;
                _parser.UpperBound    = upperBound;

                do
                {
                    try
                    {
                        _parser.Reset();

                        Console.Write("Please enter numbers: ");

                        int input;
                        do
                        {
                            input = Console.Read();

                            char ch;
                            try
                            {
                                ch = Convert.ToChar(input);
                            }
                            catch (OverflowException)
                            {
                                ch = 'a'; // causes entry to be 0
                            }

                            _parser.Read(ch);
                        }while (input != 13);
                        Console.ReadLine(); // read the rest of the line - \n

                        List <int>         numbers = _parser.GetNumbers();
                        ICalculationResult result  = _calculator.Calculate(numbers, mathOperator);
                        PrintResult(result.Text);
                    }
                    catch (FormatException formatException)
                    {
                        PrintError("Failed to process input: " + formatException.Message);
                        Console.ReadLine();
                    }
                    catch (Exception exception)
                    {
                        PrintError("Failed to read input: " + exception.Message);
                        Console.ReadLine();
                    }
                }while (true);
            }
            catch (Exception exception)
            {
                PrintError("Failed to run calculator: " + exception.Message);
            }
        }
예제 #2
0
 public ConditionEvaluationResultBase(DateTime creationTime, ICondition condition, IReferenceValue referenceValue, bool conditionIsMet, ICalculationResult calculationResult)
     : base(creationTime, calculationResult.Successful)
 {
     Condition         = condition;
     ReferenceValue    = referenceValue;
     ConditionIsMet    = conditionIsMet;
     CalculationResult = calculationResult;
 }
예제 #3
0
        /// <summary>
        /// Automatic update function called by manager
        /// </summary>
        /// <param name="parser">Receiver reference object from the android system</param>
        internal void Update(AndroidJavaObject parser)
        {
            // This date is used for removing anchors that are not up-to-date
            DateTime now = DateTime.Now;

            // This loop is done as long as the device has packets
            while (parser.Call <bool>("hasPacket"))
            {
                // Getting the packet
                AndroidJavaObject packet = parser.Call <AndroidJavaObject>("popPacket");
                // Taking the information
                int id       = packet.Call <int>("getAnchorId");
                int distance = packet.Call <int>("getDistanceInMillimeters");

                // Anchor creation/get
                Anchor anchor;
                if (anchors.ContainsKey(id))
                {
                    anchor = anchors[id];
                }
                else
                {
                    anchor = new Anchor(this, id);
                    anchors.Add(id, anchor);
                    // On new anchor -> inform
                    OnAnchorAppeared(anchor);
                }
                // Setting data
                anchor.Set(now, distance);
                locator.SetAnchorDistance(id, distance * .001f);

                // if superautoupdate => update
                if (UpdateLevel == UpdateLevel.OnValueUpdate)
                {
                    CalculationResult = locator.Calculate();
                }
            }

            // Remove all anchors that are invalid (haven't updated in a "long" time)
            HashSet <int> removables = new HashSet <int>();

            foreach (int anchorId in anchors.Keys)
            {
                if ((now - anchors[anchorId].Timestamp) > Manager.DiscardInterval)
                {
                    anchors[anchorId].Remove();
                    anchors.Remove(anchorId);
                    locator.UnsetAnchorDistance(anchorId);
                }
            }

            // if autoupdate => update
            if (UpdateLevel == UpdateLevel.OnUpdate)
            {
                CalculationResult = locator.Calculate();
            }
        }
        public void DivisionArithmeticTest()
        {
            List <int> numbers = new List <int>(new int[3] {
                60, 5, 2
            });
            ICalculationResult result = _calculator.Calculate(numbers, OperatorTypes.Divide);

            Assert.AreEqual(6, result.Numeric);
            Assert.AreEqual("60/5/2 = 6", result.Text);
        }
예제 #5
0
        public void LogCalculation(ICalculationResult result)
        {
            string calculation = JsonConvert.SerializeObject(result, Formatting.None);

            lock (_SyncLock)
            {
                string filePath = Path.Combine(Directory.GetCurrentDirectory(), "Logs", "CalculationHistory.txt");
                File.AppendAllText(filePath, calculation + Environment.NewLine);
            }
        }
예제 #6
0
        public void CanGetCalculationResultObj()
        {
            // Arrange
            double inputResult = 1;

            // Act
            ICalculationResult result = AppCoreFactory.CreateCalculatinoResult(inputResult);

            // Assert
            Assert.IsNotNull(result);
            Assert.AreEqual(result.Result, inputResult);
        }
예제 #7
0
        private char[,] CloneData(char[,] boardData, ICalculationResult current)
        {
            char[,] cloneData = new char[boardData.GetLength(0), boardData.GetLength(1)];

            for (int i = 0; i < boardData.GetLength(0); ++i)
            {
                for (int j = 0; j < boardData.GetLength(0); ++j)
                {
                    cloneData[i, j] = boardData[i, j];
                }
            }
            cloneData[current.RowIndex, current.ColumnIndex] = this.PlayerID;
            return(cloneData);
        }
        public ICalculationResult GetCalculationResult(
            double leftInput,
            double rightInput,
            int logicCode
            )
        {
            if (!IsInputsValidForProbabilityCalculation(leftInput, rightInput))
            {
                throw new InvalidOperationException(c_InvalidInputErrMsg);
            }

            if (logicCode == default(int))
            {
                throw new InvalidOperationException(nameof(logicCode));
            }

            ICalculationResult result           = null;
            IProbabilityLogic  probabilityLogic =
                AppCoreFactory.CreateCalculationLogic(logicCode);

            if (probabilityLogic != null)
            {
                result = AppCoreFactory.CreateCalculatinoResult(
                    // using Decorator Pattern
                    probabilityLogic.GetCalculationResult(leftInput, rightInput)
                    );

                result.CalculationLogging = AppCoreFactory.GetCalculationLoggingObj(
                    c_ResultLogginMessage,
                    leftInput,
                    rightInput,
                    (int)logicCode,
                    result.Result,
                    // TODO : fix testability technical debt
                    DateTime.Now
                    );

                _logger.LogInformation(
                    $"{result.CalculationLogging.Message} " +
                    $"timeStamp = {result.CalculationLogging.TimeStamp}, " +
                    $"leftInput = {result.CalculationLogging.LeftInput}, " +
                    $"rightInput = {result.CalculationLogging.RightInput}, " +
                    $"calculationLogic = {result.CalculationLogging.LogicId}, " +
                    $"result = {result.CalculationLogging.Result}"
                    );
            }

            return(result);
        }
예제 #9
0
        public int GenerateMove(IGameEngine gameEngine, IPlayer otherPlayer)
        {
            char[,] boardData = gameEngine.BoardData;

            ICalculationResult result = CalculateResult(gameEngine, otherPlayer.PlayerID);

            if (result == null)
            {
                return(-1);
            }
            else
            {
                return(result.ColumnIndex);
            }
        }
예제 #10
0
        private void Operate(ICalculationResult result, OperatorTypes mathOperator, int nextNumber)
        {
            string text = nextNumber < 0 ? "(" + nextNumber.ToString() + ")" : nextNumber.ToString();

            if (result.Text == "")
            {
                result.Numeric = nextNumber;
                result.Text    = text;
                return;
            }

            switch (mathOperator)
            {
            case OperatorTypes.Add:
                result.Numeric += nextNumber;
                if (!string.IsNullOrEmpty(result.Text))
                {
                    result.Text += "+";
                }
                break;

            case OperatorTypes.Subtract:
                result.Numeric -= nextNumber;
                if (!string.IsNullOrEmpty(result.Text))
                {
                    result.Text += "-";
                }
                break;

            case OperatorTypes.Multiply:
                result.Numeric *= nextNumber;
                if (!string.IsNullOrEmpty(result.Text))
                {
                    result.Text += "*";
                }
                break;

            case OperatorTypes.Divide:
                result.Numeric /= nextNumber;
                if (!string.IsNullOrEmpty(result.Text))
                {
                    result.Text += "/";
                }
                break;
            }

            result.Text += text;
        }
        public void MultiplicationArithmeticTest()
        {
            List <int> numbers = new List <int>(new int[5] {
                1, 2, 3, 4, 5
            });
            ICalculationResult result = _calculator.Calculate(numbers, OperatorTypes.Multiply);

            Assert.AreEqual(120, result.Numeric);
            Assert.AreEqual("1*2*3*4*5 = 120", result.Text);

            numbers = new List <int>(new int[5] {
                -3, 10, -28, -25, 4
            });
            result = _calculator.Calculate(numbers, OperatorTypes.Multiply);
            Assert.AreEqual(-84000, result.Numeric);
            Assert.AreEqual("(-3)*10*(-28)*(-25)*4 = -84000", result.Text);
        }
 public void AdditionBoundaryTest()
 {
     try
     {
         List <int> numbers = new List <int>(new int[2] {
             int.MaxValue, int.MaxValue
         });
         ICalculationResult result = _calculator.Calculate(numbers, OperatorTypes.Add);
         long sum = (long)int.MaxValue + (long)int.MaxValue;
         Assert.AreEqual(sum, result.Numeric);
         Assert.AreEqual(int.MaxValue.ToString() + "+" + int.MaxValue.ToString() + " = " + sum.ToString(), result.Text);
     }
     catch (Exception exception)
     {
         Assert.Fail("Large integer addition exception is unhandled. " + exception.Message);
     }
 }
        public void AdditionArithmeticTest()
        {
            List <int> numbers = new List <int>(new int[10] {
                1, 2, 3, 4, 5, 6, 7, 8, 9, 10
            });
            ICalculationResult result = _calculator.Calculate(numbers, OperatorTypes.Add);

            Assert.AreEqual(55, result.Numeric);
            Assert.AreEqual("1+2+3+4+5+6+7+8+9+10 = 55", result.Text);

            numbers = new List <int>(new int[10] {
                -4, 0, 2, -5, -2, 7, 100, -13, 99, -200
            });
            result = _calculator.Calculate(numbers, OperatorTypes.Add);
            Assert.AreEqual(-16, result.Numeric);
            Assert.AreEqual("(-4)+0+2+(-5)+(-2)+7+100+(-13)+99+(-200) = -16", result.Text);
        }
 public void MultiplicationBoundaryTest()
 {
     try
     {
         List <int> numbers = new List <int>(new int[2] {
             int.MaxValue, int.MaxValue
         });
         ICalculationResult result = _calculator.Calculate(numbers, OperatorTypes.Multiply);
         long product = (long)int.MaxValue * (long)int.MaxValue;
         Assert.AreEqual(product, result.Numeric);
         Assert.AreEqual(int.MaxValue.ToString() + "*" + int.MaxValue.ToString() + " = " + product.ToString(), result.Text);
     }
     catch (Exception exception)
     {
         Assert.Fail("Large integer multiplication exception is unhandled. " + exception.Message);
     }
 }
        public void SubtractionArithmeticTest()
        {
            List <int> numbers = new List <int>(new int[4] {
                55, 22, 11, 2
            });
            ICalculationResult result = _calculator.Calculate(numbers, OperatorTypes.Subtract);

            Assert.AreEqual(20, result.Numeric);
            Assert.AreEqual("55-22-11-2 = 20", result.Text);

            numbers = new List <int>(new int[5] {
                0, -10, 4, 99, -150
            });
            result = _calculator.Calculate(numbers, OperatorTypes.Subtract);
            Assert.AreEqual(57, result.Numeric);
            Assert.AreEqual("0-(-10)-4-99-(-150) = 57", result.Text);
        }
 public void SubtractionBoundaryTest()
 {
     try
     {
         List <int> numbers = new List <int>(new int[2] {
             int.MinValue, int.MaxValue
         });
         ICalculationResult result = _calculator.Calculate(numbers, OperatorTypes.Subtract);
         long difference           = (long)int.MinValue - (long)int.MaxValue;
         Assert.AreEqual(difference, result.Numeric);
         Assert.AreEqual("(" + int.MinValue.ToString() + ")-" + int.MaxValue.ToString() + " = " + difference.ToString(), result.Text);
     }
     catch (Exception exception)
     {
         Assert.Fail("Small integer subtraction exception is unhandled. " + exception.Message);
     }
 }
예제 #17
0
        protected bool IsOpponentNextMoveWinningMove(IGameEngine gameEngine, ICalculationResult current, char[,] boardData, char otherPlayer)
        {
            char[,] cloneData = CloneData(boardData, current);
            for (int i = 0; i < boardData.GetLength(1); ++i)
            {
                int rowIndex = GetRow(i, cloneData);
                if (rowIndex >= 0)
                {
                    IMove move = new ConnectMove(new WebPlayer("Player 1", otherPlayer), 0, rowIndex, i);
                    if (ConnectFourGameEngine.IsWinningMove(move, cloneData))
                    {
                        return(true);
                    }
                }
            }

            return(false);
        }
예제 #18
0
        protected virtual ICalculationResult CalculateResult(IGameEngine gameEngine, char otherPlayerID)
        {
            char[,] boardData = gameEngine.BoardData;

            ICalculationResult max = null;

            for (int i = 0; i < boardData.GetLength(1); ++i)
            {
                int rowIndex = GetRow(i, boardData);
                if (rowIndex >= 0)
                {
                    ICalculationResult current = CalculateColumnBlocks(rowIndex, i, boardData, otherPlayerID);
                    if (max == null || current.CompareTo(max) == 1)
                    {
                        if (!IsOpponentNextMoveWinningMove(gameEngine, current, boardData, otherPlayerID))
                        {
                            max = current;
                        }
                    }
                }
            }
            return(max);
        }
예제 #19
0
        protected override ICalculationResult CalculateResult(IGameEngine gameEngine, char otherPlayerID)
        {
            ICalculationResult max = null;

            char[,] boardData = gameEngine.BoardData;
            for (int i = 0; i < boardData.GetLength(1); ++i)
            {
                int rowIndex = GetRow(i, boardData);
                if (rowIndex >= 0)
                {
                    IMove move = new ConnectMove(this, 0, rowIndex, i);

                    if (gameEngine.IsWinningMove(move))
                    {
                        CalculationResult result = new CalculationResult(rowIndex, i, boardData.GetLength(1));
                        result.IsWinningMove = true;

                        return(result);
                    }
                }
            }
            return(base.CalculateResult(gameEngine, otherPlayerID));
        }
예제 #20
0
    // Update is called once per frame
    void Update()
    {
        // Update manager to actively keep track of data (Use this as often as you want, but remember: The data will not disappear until popped by update)
        manager.Update();

        // Example string build for data
        StringBuilder builder = new StringBuilder();

        foreach (Receiver receiver in manager.Receivers)
        {
            builder.AppendLine("Receiver \"" + receiver.Serial + "\"");

            // Get latest calculation result
            ICalculationResult result = receiver.CalculationResult;
            foreach (Anchor anchor in receiver.Anchors)
            {
                if (anchorPositions.ContainsKey(anchor.Id))
                {
                    builder.AppendLine("Anchor " + anchor.Id + " distance: " + anchor.Distance + " (position: " + VectorString(anchorPositions[anchor.Id]) + ")");
                }
                else
                {
                    builder.AppendLine("Anchor " + anchor.Id + " distance: " + anchor.Distance);
                }
            }
            builder.AppendLine("----- RESULT -----");

            // how to handle the result: Check the type from enum field and then cast
            switch (result.ResultType)
            {
            case CalculationResultType.Null:
                builder.AppendLine("No result");
                break;

            case CalculationResultType.Single:
                SinglePointCalculationResult singleResult = (SinglePointCalculationResult)result;
                builder.AppendLine("Single point");
                builder.AppendLine("Position: " + VectorString(singleResult.Position));
                builder.AppendLine("Radius: " + singleResult.Distance);
                break;

            case CalculationResultType.Double:
                DoublePointCalculationResult doubleResult = (DoublePointCalculationResult)result;
                builder.AppendLine("Circle result");
                builder.AppendLine("Center position: " + VectorString(doubleResult.Position));
                builder.AppendLine("Normal Direction: " + VectorString(doubleResult.Normal));
                builder.AppendLine("Radius: " + doubleResult.Radius);
                break;

            case CalculationResultType.Trilinear:
                TrilinearCalculationResult triResult = (TrilinearCalculationResult)result;
                builder.AppendLine("Trilinear result");
                if (triResult.CalculationErrored)
                {
                    builder.AppendLine("ERROR: Trilinear calculation failed");
                }
                else
                {
                    builder.AppendLine("Result 1: " + VectorString(triResult.Result1));
                    builder.AppendLine("Result 2: " + VectorString(triResult.Result2));
                }
                break;

            case CalculationResultType.Quadlinear:
                QuadlinearCalculationResult quadResult = (QuadlinearCalculationResult)result;
                builder.AppendLine("Quadlinear result");
                builder.AppendLine("Calculated from " + quadResult.CalculationOptions + " points");
                builder.AppendLine("Calculated with " + quadResult.CalculationLevel + " calculation level");
                if (quadResult.Errored)
                {
                    builder.AppendLine("ERROR: Quadlinear calculation failed");
                }
                else
                {
                    builder.AppendLine("Position: " + VectorString(quadResult.Position));
                }
                break;
            }
            builder.AppendLine();
        }

        // build to string
        dataString = builder.ToString();
    }
 public void LogCalculation(ICalculationResult result)
 {
 }
예제 #22
0
 public SimpleConditionEvaluationResult(DateTime creationTime, ICondition condition, IReferenceValue referenceValue, bool conditionIsMet, ICalculationResult calculationResult)
     : base(creationTime, condition, referenceValue, conditionIsMet, calculationResult)
 {
 }
예제 #23
0
 /// <summary>
 /// Calculates the current position
 /// Can always be used but best used when there is no
 /// </summary>
 public void Calculate()
 {
     CalculationResult = locator.Calculate();
 }