Exemple #1
0
        public string Calculate()
        {
            IExpressionValidator expressionValidator = Factory.CreateExpressionValidator();

            expressionValidator.Expression = string.Join("", InfixNotationValue);

            if (expressionValidator.Validate())
            {
                PostfixNotationValue = NotationConverter.ConvertToPostfix(string.Join("", InfixNotationValue), _operators);

                foreach (var item in PostfixNotationValue)
                {
                    if (_operators.Contains(item))
                    {
                        B = double.Parse(Stack.Pop());
                        A = double.Parse(Stack.Pop());

                        if (item == "/")
                        {
                            State = ExpressionSubjectState.Division;
                            this.Notify();
                        }
                        else if (item == "*")
                        {
                            State = ExpressionSubjectState.Multiplication;
                            this.Notify();
                        }
                        else if (item == "+")
                        {
                            State = ExpressionSubjectState.Addition;
                            this.Notify();
                        }
                        else if (item == "-")
                        {
                            State = ExpressionSubjectState.Subtraction;
                            this.Notify();
                        }
                    }
                    else
                    {
                        Stack.Push(item);
                    }
                }

                return(Result = Stack.Pop());
            }
            else
            {
                return(Result);
            }
        }
        /// <summary>
        /// 入力 Weight を基に、Validation を行い実際にモデルに適用される Weights を計算し、Merger を介して適用する。
        /// この際、LookAt の情報を pull してそれも適用する。
        /// </summary>
        private void Apply()
        {
            // 1. Get eye direction from provider.
            _inputEyeDirection = _eyeDirectionProvider?.EyeDirection ?? default;

            // 2. Validate user input, and Output as actual weights.
            _validator.Validate(_inputWeights, _actualWeights,
                                _inputEyeDirection, out _actualEyeDirection,
                                out var blink, out var lookAt, out var mouth);

            // 3. Set eye direction expression weights or any other side-effects (ex. eye bone).
            _eyeDirectionApplicable?.Apply(_actualEyeDirection, _actualWeights);

            // 4. Set actual weights to raw blendshapes.
            _merger.SetValues(_actualWeights);

            BlinkOverrideRate  = blink;
            LookAtOverrideRate = lookAt;
            MouthOverrideRate  = mouth;
        }
Exemple #3
0
        public void Run()
        {
            Log.Information("Application was started.");
            _consoleMessenger.WelcomeMessage();

            string userInput = _userInputCatcher.Capture();

            if (string.IsNullOrEmpty(userInput) == false)
            {
                _fileValidator.FilePath = userInput;

                if (_fileValidator.Validate())
                {
                    Log.Information("User input is determined as a file path.");
                    _unitOfWork.FileRepository.SetInputFilePath(userInput);

                    List <IExpressionSubject> fileExpressions = _unitOfWork.FileRepository.Get();
                    Log.Information("Input file was loaded.");

                    foreach (IExpressionSubject expression in fileExpressions)
                    {
                        _expressionValidator.Expression = string.Join("", expression.InfixNotationValue);

                        if (_expressionValidator.Validate())
                        {
                            expression.Calculate();
                            _unitOfWork.DatabaseRepository.AddExpressionToStore(expression);
                        }
                    }

                    _unitOfWork.FileRepository.Add();
                    _unitOfWork.DatabaseRepository.Add();
                    Log.Information("The result was written to output the file and database.");
                }
                else
                {
                    Log.Information("User input was determined as a mathematical expression.");
                    _unitOfWork.ConsoleRepository.AddExpressionToStore(userInput);

                    List <IExpressionSubject> consoleExpressions = _unitOfWork.ConsoleRepository.Get();
                    Log.Information("Input expression was loaded.");

                    foreach (IExpressionSubject expression in consoleExpressions)
                    {
                        expression.Calculate();
                        _unitOfWork.DatabaseRepository.AddExpressionToStore(expression);
                    }

                    _unitOfWork.ConsoleRepository.Add();
                    _unitOfWork.DatabaseRepository.Add();
                    Log.Information("Result was written to console.");
                }
            }
            else
            {
                _consoleMessenger.EmptyInputMessage();
                Log.Error("Empty input.");
            }

            Log.Information("Application was ended.");
        }
Exemple #4
0
        public CompilationStatus CompileWithStats(string argPattern, StringBuilder argSBStats)
        {
            if (argSBStats == null)
            {
                return(Compile(argPattern));
            }

            TransitionState.ResetCounter();

            int lineLength = 0;

            ValidationInfo vi = _expressionValidator.Validate(argPattern);

            UpdateValidationInfo(vi);

            if (vi.ErrorCode != CompilationStatus.SUCCESS)
            {
                return(vi.ErrorCode);
            }

            string regExpressionPostfix = ConvertToPostfix(vi.FormattedString);

            argSBStats.AppendLine("Original pattern:\t\t" + argPattern);
            argSBStats.AppendLine("Pattern after formatting:\t" + vi.FormattedString);
            argSBStats.AppendLine("Pattern after postfix:\t\t" + regExpressionPostfix);
            argSBStats.AppendLine(Environment.NewLine);

            TransitionState stateStartNfa = CreateNfa(regExpressionPostfix);

            argSBStats.AppendLine(Environment.NewLine);
            argSBStats.AppendLine("NFA Table:");

            lineLength = GetSerializedFsa(stateStartNfa, argSBStats);

            argSBStats.AppendFormat(("").PadRight(lineLength, '*'));
            argSBStats.AppendLine(Environment.NewLine);

            TransitionState.ResetCounter();
            TransitionState stateStartDfa = ConvertToDfa(stateStartNfa);

            argSBStats.AppendLine(Environment.NewLine);

            argSBStats.AppendLine("DFA Table:");

            lineLength = GetSerializedFsa(stateStartDfa, argSBStats);

            argSBStats.AppendFormat(("").PadRight(lineLength, '*'));
            argSBStats.AppendLine(Environment.NewLine);

            TransitionState stateStartDfaM = ReduceDfa(stateStartDfa);

            _startingDFAState = stateStartDfaM;
            argSBStats.AppendLine(Environment.NewLine);

            argSBStats.AppendLine("DFA M' Table:");

            lineLength = GetSerializedFsa(stateStartDfaM, argSBStats);
            argSBStats.AppendFormat(("").PadRight(lineLength, '*'));
            argSBStats.AppendLine(Environment.NewLine);

            return(CompilationStatus.SUCCESS);
        }