/// <summary>
        /// Constructs a new instance of <see cref="PredictorTests" />
        /// </summary>
        public PredictorTests(ModelFixture fixture)
        {
            this._fixture = fixture;
            var startHistory = $"{AzPredictorConstants.CommandPlaceholder}{AzPredictorConstants.CommandConcatenator}{AzPredictorConstants.CommandPlaceholder}";

            this._predictor = new Predictor(this._fixture.PredictionCollection[startHistory], null);
        }
        public async Task <JsonResult> CalculatePrice(CarModel carModel)
        {
            if (carModel is null)
            {
                return(new(new Either <int, Error>(0, Errors.CarWasNull)));
            }

            var userLogin = HttpContext.User.Identity.Name;

            var car = _mapper.Map <Car>(carModel);

            var cars = await _parserService.GetCars(car);

            string jsonString = JsonSerializer.Serialize(carModel);

            var price = Predictor.PredictOnePrice(jsonString);

            var historyModel = _mapper.Map <CarHistoryModel>(car);

            historyModel.UserLogin = userLogin;
            historyModel.Price     = price;

            await _historyService.AddCarHistoryDbAsync(historyModel);

            return(new(new Either <int, Error>(price, null)));
        }
Esempio n. 3
0
 // Use this for initialization
 void Start()
 {
     predictor           = new Predictor("1234");
     totalElecciones     = "";
     eleccionesPredecir  = "";
     eleccionesRegistrar = "";
 }
Esempio n. 4
0
        public void WithEnemyTryingToAttack_ThereAreBadCells()
        {
            var skeleton = World.Global.SpawnEntity(Zombie.Factory, new IntVector2(1, 1));
            var acting   = skeleton.GetActing();

            acting.CalculateAndSetAction();

            Assert.NotNull(acting._nextAction, "Will attack");

            var player    = World.Global.SpawnEntity(Player.Factory, new IntVector2(1, 0));
            var predictor = new Predictor(World.Global, Layers.REAL, Faction.Player);

            // Just in case, assert that the faction works correctly
            Assert.True(player.IsPlayer(), "IsPlayer says we are player");

            var predictedPositions = predictor.GetBadPositions();

            Assert.AreEqual(1, predictedPositions.Count());
            Assert.AreEqual(new IntVector2(1, 0), predictedPositions.First());

            player.GetTransform().ResetPositionInGrid(new IntVector2(0, 0));
            predictedPositions = predictor.GetBadPositions();
            Assert.AreEqual(2, predictedPositions.Count());
            Assert.True(predictedPositions.Contains(new IntVector2(1, 0)));
            Assert.True(predictedPositions.Contains(new IntVector2(0, 1)));
        }
Esempio n. 5
0
        public void WithoutEnemies_ThereAreNoBadCells()
        {
            var player    = World.Global.SpawnEntity(Player.Factory, new IntVector2(0, 0));
            var predictor = new Predictor(World.Global, Layers.REAL, Faction.Player);

            Assert.Zero(predictor.GetBadPositions().Count());
        }
        public void CanBeOnTheRoad_BacthTest()
        {
            // Arrange
            string[,] Params = new string[, ] {
                { "PDB-1032", "2017-06-19", "07:40", "false" },
                { "PDB-1032", "2017-06-19", "17:36", "false" },
                { "PDB-1032", "2017-06-19", "22:40", "true" },
                { "PDB-1032", "2017-06-20", "17:36", "true" },
                { "INVALID2", "2017-06-19", "17:36", "false" },
                { "PDB-1035", "2017-06-19", "17:36", "true" }
            };

            // Act
            bool bResult = true;

            for (int i = 0; i < Params.GetLength(0); i++)
            {
                Predictor predictor  = new Predictor(Params[i, 0], Params[i, 1], Params[i, 2]);
                var       testResult = predictor.CanBeOnTheRoad();
                bResult = bResult & (testResult.ToString().ToLower() == Params[i, 3]);
            }

            // Assert
            Assert.AreEqual(bResult, true);
        }
Esempio n. 7
0
 private void Start()
 {
     _line = GetComponent <UILineRenderer>();
     Invoke(nameof(SpellAndDestroy), _delay);
     _predictor = GameObject.Find("Predictor").GetComponent <Predictor>();
     // This will always be called in case the MouseButtonUp event is missed or the player takes too long to draw
 }
Esempio n. 8
0
        static void TrainEvaluatePredict(TrainerBase trainer, BostonHousingData newSample)
        {
            Console.WriteLine("*******************************");
            Console.WriteLine($"{ trainer.Name }");
            Console.WriteLine("*******************************");

            trainer.Fit("..\\Data\\boston_housing.csv");

            var modelMetrics = trainer.Evaluate();

            Console.WriteLine($"Loss Function: {modelMetrics.LossFunction:0.##}{Environment.NewLine}" +
                              $"Mean Absolute Error: {modelMetrics.MeanAbsoluteError:#.##}{Environment.NewLine}" +
                              $"Mean Squared Error: {modelMetrics.MeanSquaredError:#.##}{Environment.NewLine}" +
                              $"RSquared: {modelMetrics.RSquared:0.##}{Environment.NewLine}" +
                              $"Root Mean Squared Error: {modelMetrics.RootMeanSquaredError:#.##}");

            trainer.Save();

            var predictor  = new Predictor();
            var prediction = predictor.Predict(newSample);

            Console.WriteLine("------------------------------");
            Console.WriteLine($"Prediction: {prediction.MedianPrice:#.##}");
            Console.WriteLine("------------------------------");
        }
Esempio n. 9
0
        public ActivityType ClassifyActivity(Activity activity)
        {
            User user;

            if (activity.User == null)
            {
                user = _userService.FindUser(activity.UserId);
            }
            else
            {
                user = activity.User;
            }
            List <string> data = new List <string>()
            {
                user.BirthDate.Ticks.ToString(), GetUserHeightInMeters(user).ToString(), ConvertToKilograms(user.Weight).ToString(),
                activity.Duration.ToString(), (activity.Distance * MetersPerMile).ToString(), activity.Steps.ToString()
            };
            var typeStr = Predictor.predict(data);

            typeStr = typeStr.ToUpper();
            switch (typeStr)
            {
            case "R": return(ActivityType.Running);

            case "J": return(ActivityType.Jogging);

            case "B": return(ActivityType.Biking);

            case "W": return(ActivityType.Walking);

            case "O": return(ActivityType.Other);

            default:  return(ActivityType.Other);
            }
        }
Esempio n. 10
0
 // Use this for initialization
 void Start()
 {
     predictor         = new Predictor();
     totalChoices      = new List <Movements>();
     choicesToPredict  = new List <Movements>();
     choicesToRegister = new List <Movements>();
 }
Esempio n. 11
0
        public void leaguePositionPointsCalculationShouldBeCorrect()
        {
            //test calculations assume -0.2 per overall league position, -0.3 per homeOrAway league position
            double tolerance         = 0.01;
            double pointsCalculation = Predictor.leaguePositionPoints(1, 1);

            Assert.True(-0.5 - pointsCalculation < tolerance && pointsCalculation + 0.5 < tolerance);

            pointsCalculation = Predictor.leaguePositionPoints(2, 2);

            Assert.True(-1 - pointsCalculation < tolerance && pointsCalculation + 1 < tolerance);

            pointsCalculation = Predictor.leaguePositionPoints(3, 1);

            Assert.True(-0.9 - pointsCalculation < tolerance && pointsCalculation + 0.9 < tolerance);

            pointsCalculation = Predictor.leaguePositionPoints(10, 10);

            Assert.True(-5 - pointsCalculation < tolerance && pointsCalculation + 5 < tolerance);

            pointsCalculation = Predictor.leaguePositionPoints(20, 10);

            Assert.True(-7 - pointsCalculation < tolerance && pointsCalculation + 7 < tolerance);

            pointsCalculation = Predictor.leaguePositionPoints(10, 24);

            Assert.True(-9.2 - pointsCalculation < tolerance && pointsCalculation + 9.2 < tolerance);

            pointsCalculation = Predictor.leaguePositionPoints(24, 24);

            Assert.True(-12 - pointsCalculation < tolerance && pointsCalculation + 12 < tolerance);
        }
        public override async Task <ImagePredictionResultModel> PredictWithImageAsync(ImageInfo image, Guid projectId, Guid?iterationId = null)
        {
            Console.Write($"Prediction for {image.Path}...");
            var prediction = await Predictor.PredictWithImageAsync(image, projectId, iterationId);

            if (prediction == null)
            {
                Console.WriteLine("Failed.");
                Console.WriteLine($"Please make sure : \n- the project id {projectId} is valid; \n- prediction endpoint url is right;");
                if (iterationId == null)
                {
                    Console.WriteLine("- a default iteration is specified;");
                }

                return(null);
            }

            Console.WriteLine("Succeeded!");
            Console.Write("Predicted labels and probabilities: ");

            foreach (var label in prediction.Predictions)
            {
                Console.Write($"[Label: {label.Tag}, Probability: {label.Probability}]");
            }

            Console.WriteLine(string.Empty);
            Console.Write("True labels: ");
            foreach (var label in image.TagNames)
            {
                Console.Write($"[Label: {label}]");
            }

            Console.WriteLine(string.Empty);
            return(prediction);
        }
Esempio n. 13
0
        public void Train(Predictor predictor, double[] weightArray, DataSetObject dataSet, double learningRate)
        {
            int weightCount = weightArray.Length;

            double[] tmpWeightArray = new double[weightCount];

            foreach (var item in dataSet.DataSet)
            {
                DataObject data = item.Value;

                double DifferentialPerRow = (double)predictor.GetDifferential(item.Value, weightArray);

                double[] tmpFeature = data.Feature.GetFeature();

                for (int i = 0; i < weightCount; i++)
                {
                    tmpWeightArray[i] += DifferentialPerRow * tmpFeature[i];
                }
            }

            for (int i = 0; i < weightCount; i++)
            {
                weightArray[i] -= (tmpWeightArray[i] / dataSet.RowCount) * learningRate;
            }
        }
        static void debugFunc(ModelTrainer mt, Predictor predictor)
        {
            Console.WriteLine("-------- Model Data List ------- ..");
            foreach (var item in mt.getDataModelTrained())
            {
                Console.WriteLine("Label-ID: " + item.getDataModelLabelID() + "|| Word-Frequency: " + item.getDataModelTagInfo() +
                                  "|| Word: " + item.getDataModelString() + "|| Confidence Rate Probability: " + item.getConfidenceProcentRate());
            }
            Console.WriteLine("-------------------------------- .. ");

            Console.WriteLine("----- Threshold of removing the frequency of words ------ ..");
            Console.WriteLine(mt.getRemovingThresholdValue());
            Console.WriteLine("--------------------- .. ");

            Console.WriteLine("------ Values count of every Label-ID ------- .. ");
            foreach (var item in mt.countValues())
            {
                Console.WriteLine(item.Key + " => " + item.Value);
            }
            Console.WriteLine("--------------------- .. ");
            //Console.WriteLine("------ Prediction values (0.f) -------- ..");
            //foreach (var item in predictor.predictorValues)
            //{
            //    Console.WriteLine(item.Key + " -> " + item.Value);
            //}
            //Console.WriteLine("-------------------- .. ");

            //Console.WriteLine("------ Prediction probabilities (%) -------- ..");
            //foreach (var item in predictor.probabilities)
            //{
            //    Console.WriteLine(item.Key + " -> " + item.Value);
            //}
            //Console.WriteLine("-------------------- .. ");
        }
Esempio n. 15
0
        public void PossibleDecks_OneMetaDeckSameClass()
        {
            AddMetaDeck("Hunter");
            var predictor = new Predictor(new MockOpponent("Hunter"), _metaDecks.AsReadOnly());

            Assert.IsTrue(_metaDecks.SequenceEqual(predictor.PossibleDecks));
        }
Esempio n. 16
0
        public void PossibleDecks_OneMetaDeckDifferentClass()
        {
            AddMetaDeck("Hunter");
            var predictor = new Predictor(new MockOpponent("Mage"), _metaDecks.AsReadOnly());

            Assert.AreEqual(0, predictor.PossibleDecks.Count);
        }
Esempio n. 17
0
        public void GetNextPredictedCards_SortedByProbability()
        {
            AddMetaDeck("Hunter", new List <string> {
                "Alleycat"
            });
            AddMetaDeck("Hunter", new List <string> {
                "Deadly Shot", "Bear Trap", "Alleycat"
            });
            _metaDecks[1].Cards[0].Count = 40;
            _metaDecks[1].Cards[1].Count = 40;
            AddMetaDeck("Hunter", new List <string> {
                "Deadly Shot", "Alleycat",
            });
            _metaDecks[2].Cards[0].Count = 40;
            var opponent = new MockOpponent("Hunter");

            opponent.Mana = 1;
            var predictor = new Predictor(opponent, _metaDecks.AsReadOnly());

            var nextPredictedCards = predictor.GetNextPredictedCards(50);

            Assert.AreEqual("Deadly Shot", nextPredictedCards.ElementAt(0).Card.Name);
            Assert.AreEqual("Deadly Shot", nextPredictedCards.ElementAt(1).Card.Name);
            Assert.AreEqual("Bear Trap", nextPredictedCards.ElementAt(40).Card.Name);
        }
Esempio n. 18
0
        public void Test1()
        {
            Random randNum = new Random();

            int[] yValues = Enumerable.Repeat(0, 12).Select(i => randNum.Next(1, 30)).ToArray();

            Queue <ExchangeRate> rateQueue = new Queue <ExchangeRate>();

            foreach (int yValue in yValues)
            {
                ExchangeRate r = new ExchangeRate();
                r.rates = new JObject(new JProperty("VND", yValue));

                rateQueue.Enqueue(r);
            }

            Mock <IExchangeRateDataReader> readerMock = new Mock <IExchangeRateDataReader>();

            readerMock.Setup(reader => reader.Read(It.IsAny <DateTime>(), It.IsAny <string>())).Returns(rateQueue.Dequeue);

            PredictorOption predictorOption = new PredictorOption
            {
                FromCurrency = "USD",
                ToCurrency   = "VND",
                FromDate     = new DateTime(year: 2016, month: 1, day: 15),
                ToDate       = new DateTime(year: 2016, month: 12, day: 15),
                PredictDate  = new DateTime(year: 2017, month: 1, day: 15)
            };

            IPredictor predictor = new Predictor(readerMock.Object);
            decimal    rate      = predictor.Predict(predictorOption);

            Assert.True(rate > 0);
        }
        public async Task <JsonResult> GetCarBestDeals(CarBestDealFormModel carModel)
        {
            if (carModel is null)
            {
                return(new(new Either <Car[], Error>(null, Errors.CarWasNull)));
            }

            var userLogin = HttpContext.User.Identity.Name;

            var car = _mapper.Map <Car>(carModel);

            var cars = await _parserService.GetCars(car);

            var carsJson = JsonSerializer.Serialize(cars);

            var carsBestDealDataModel = Predictor.GetBestDeals(carsJson);
            var finalCars             = JsonSerializer.Deserialize <CarBestDealDataModel[]>(carsBestDealDataModel);

            var historyModel = _mapper.Map <CarHistoryModel>(car);

            historyModel.UserLogin = userLogin;

            await _historyService.AddCarHistoryDbAsync(historyModel);

            return(new(new Either <CarBestDealDataModel[], Error>(finalCars, null)));
        }
Esempio n. 20
0
        public Grid Solve(Grid source)
        {
            if (source == null)
            {
                throw new ArgumentNullException(nameof(source));
            }
            CalculationContextFactory calculationContextFactory = new CalculationContextFactory();
            Calculator             calculator         = new Calculator();
            Predictor              predictor          = new Predictor();
            Stack <PredictContext> predictionStack    = new Stack <PredictContext>();
            CalculationContext     calculationContext = calculationContextFactory.Create(source);
            CalculationResultData  calculationResult  = calculator.Process(calculationContext);

            while (calculationResult.Result != CalculationResult.Finish)
            {
                switch (calculationResult.Result)
                {
                case CalculationResult.NeedPrediction:
                    calculationContext = calculationContextFactory.Create(predictor.CreatePrediction(predictionStack, calculationContext));
                    break;

                case CalculationResult.Stop:
                    calculationContext = calculationContextFactory.Create(predictor.ApplyNextPrediction(predictionStack));
                    break;

                default:
                    throw new InvalidOperationException();
                }
                calculationResult = calculator.Process(calculationContext);
            }
            return(calculationResult.Context.Grid);
        }
Esempio n. 21
0
        private void UpdateBalance()
        {
            BalanceRecords.Clear();

            DateTime lastTransactionDate;
            decimal  startingBalance = Core.Instance.GetBalanceToDate(SelectedMonth, SelectedYear, out lastTransactionDate);

            // Add starting balance row
            BalanceRecords.Add(new BalanceItem
            {
                Date     = lastTransactionDate,
                Change   = 0m,
                Total    = startingBalance,
                Origin   = "Balance",
                Category = string.Empty
            });
            // Add all transactions for a selected period
            List <Transaction> transactions = Core.Instance.GetTransactions(SelectedYear, SelectedMonth);

            transactions.Reverse();
            foreach (Transaction tr in transactions)
            {
                // filter out transaction before the last transaction date
                if (tr.Date > lastTransactionDate)
                {
                    startingBalance += tr.Amount;
                    BalanceRecords.Add(new BalanceItem
                    {
                        Date     = tr.Date,
                        Change   = tr.Amount,
                        Total    = startingBalance,
                        Origin   = "Transaction",
                        Category = (new CategoryNode(tr.Category)).FullName
                    });
                }
            }
            // Add all predictors for a selected period.
            DateTime actualDate = DateTime.Today;
            DateTime futureDate = new DateTime(SelectedYear, SelectedMonth,
                                               DateTime.DaysInMonth(SelectedYear, SelectedMonth));

            // Repeat for every month before selected
            while (actualDate <= futureDate)
            {
                foreach (Prediction pr in Predictor.Predict(actualDate))
                {
                    startingBalance += pr.Amount;
                    BalanceRecords.Add(new BalanceItem
                    {
                        Date     = pr.Date,
                        Change   = pr.Amount,
                        Total    = startingBalance,
                        Origin   = "Prediction",
                        Category = (new CategoryNode(pr.Category)).FullName
                    });
                }
                actualDate = actualDate.AddMonths(1);
            }
        }
 public override async Task <ImagePredictionResultModel> PredictWithImageAsync(ImageInfo image, Guid projectId, Guid?iterationId = null)
 {
     return(await RetryHelper.RetryFuncAsync(
                async() => await Predictor.PredictWithImageAsync(image, projectId, iterationId),
                new[] { typeof(HttpOperationException), typeof(TaskCanceledException) },
                RetryTimes,
                GapTimeBetweenRetry));
 }
        /// <summary>
        /// Convert a Predictor into a IPredictor with method GetPredictorObject.
        /// As it generates a warning, all functions needing this conversion should call this
        /// function to minimize the number of raised warnings.
        /// </summary>
        public static IPredictor IPredictorFromPredictor(Predictor pred)
        {
#pragma warning disable CS0618
            var res = pred.GetPredictorObject() as IPredictor;
#pragma warning restore CS0618
            Contracts.Assert(res != null);
            return(res);
        }
Esempio n. 24
0
        private void cmdEvaluate_Click(object sender, EventArgs e)
        {
            Predictor predictor = new Predictor(txtPlate.Text, txtDate.Text, txtTime.Text);

            lblResult.Text  = "Predictor Status: " + predictor.PredictorStatus.ToString();
            lblResult.Text += System.Environment.NewLine;
            lblResult.Text += "Can Be On The Road: " + predictor.CanBeOnTheRoad().ToString();
        }
Esempio n. 25
0
        public ActionResult DeleteConfirmed(int id)
        {
            Predictor predictor = db.Predictors.Find(id);

            db.Predictors.Remove(predictor);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
		public void PredictorWrongKey()
		{
			var predictor = new Predictor("1111");
			var exception = Assert.Throws<YandexLinguisticsException>(() => predictor.GetLangs());
			Assert.AreEqual(
				new YandexLinguisticsException(401, "API key is invalid").ToString(),
				exception.ToString());
		}
Esempio n. 27
0
        public void PredictorWrongKey()
        {
            var predictor = new Predictor("1111");
            var exception = Assert.Throws <YandexLinguisticsException>(() => predictor.GetLangs());

            Assert.AreEqual(
                new YandexLinguisticsException(401, "API key is invalid").ToString(),
                exception.ToString());
        }
Esempio n. 28
0
        public void GetNextPredictedCards_EmptyByDefault()
        {
            AddMetaDeck("Hunter", new List <string> {
                "Alleycat"
            });
            var predictor = new Predictor(new MockOpponent("Hunter"), _metaDecks.AsReadOnly());

            Assert.AreEqual(0, predictor.GetNextPredictedCards(10).Count);
        }
Esempio n. 29
0
        public void GetPredictedCard_ProbabilityIsOneForSinglePossibleDeck()
        {
            AddMetaDeck("Hunter", new List <string> {
                "Tracking", "Alleycat"
            });
            var predictor = new Predictor(new MockOpponent("Hunter"), _metaDecks.AsReadOnly());

            Assert.AreEqual(1, predictor.GetPredictedCard(Key("Tracking", 1)).Probability);
        }
Esempio n. 30
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="env">environment</param>
        /// <param name="modelStream">stream</param>
        /// <param name="output">name of the output column</param>
        /// <param name="outputIsFloat">output is a gloat (true) or a vector of floats (false)</param>
        /// <param name="conc">number of concurrency threads</param>
        /// <param name="features">features name</param>
        public ValueMapperPredictionEngineFloat(IHostEnvironment env, Stream modelStream,
                                                string output   = "Probability", bool outputIsFloat = true, int conc = 1,
                                                string features = "Features")
        {
            _env = env;
            if (_env == null)
            {
                throw Contracts.Except("env must not be null");
            }
            var inputs = new FloatVectorInput[0];
            var view   = ComponentCreation.CreateStreamingDataView <FloatVectorInput>(_env, inputs);

            long modelPosition = modelStream.Position;

            _predictor = ComponentCreation.LoadPredictorOrNull(_env, modelStream);
            if (_predictor == null)
            {
                throw _env.Except("Unable to load a model.");
            }
            modelStream.Seek(modelPosition, SeekOrigin.Begin);
            _transforms = ComponentCreation.LoadTransforms(_env, modelStream, view);
            if (_transforms == null)
            {
                throw _env.Except("Unable to load a model.");
            }

            var data = _env.CreateExamples(_transforms, features);

            if (data == null)
            {
                throw _env.Except("Cannot create rows.");
            }
            var scorer = _env.CreateDefaultScorer(data, _predictor);

            if (scorer == null)
            {
                throw _env.Except("Cannot create a scorer.");
            }

            _valueMapper = new ValueMapperFromTransformFloat <VBuffer <float> >(_env,
                                                                                scorer, features, output, conc: conc);
            if (_valueMapper == null)
            {
                throw _env.Except("Cannot create a mapper.");
            }
            if (outputIsFloat)
            {
                _mapper       = _valueMapper.GetMapper <VBuffer <float>, float>();
                _mapperVector = null;
            }
            else
            {
                _mapper       = null;
                _mapperVector = _valueMapper.GetMapper <VBuffer <float>, VBuffer <float> >();
            }
        }
Esempio n. 31
0
        private async void btnSolve_Clicked(object sender, EventArgs e)
        {
            //BinaryReader reader = new BinaryReader(GetImageStream());

            try
            {
                if (_MediaFile == null)
                {
                    return;
                }

                IsLoading = true;

                var listbyte = await Task.Run(() =>
                {
                    SKBitmap myBitmap           = new SKBitmap();
                    myBitmap                    = SKBitmap.Decode(_MediaFile.GetStream());
                    List <double> listbyte_wait = new List <double>();
                    for (int j = 0; j < myBitmap.Height; j++)
                    {
                        for (int i = 0; i < myBitmap.Width; i++)
                        {
                            //for (int j = 0; j < myBitmap.Height; j++)
                            //{
                            var color = myBitmap.GetPixel(i, j);
                            listbyte_wait.Add(((int)color.Red) / 255.00);
                            listbyte_wait.Add(((int)color.Green) / 255.00);
                            listbyte_wait.Add(((int)color.Blue) / 255.00);
                        }
                    }

                    return(listbyte_wait);
                });

                if (listbyte.Count == 7581600)
                {
                    Predictor predictor  = new Predictor(App.assembly);
                    var       UnUsedMove = await predictor.PredictUnUsedMoveAsync(listbyte.ToArray());

                    var MoveLimit = await predictor.PredictMoveLimitAsync(listbyte.ToArray());
                    await DisplayAlert("Prediction", $"UnUsedMove : {UnUsedMove}{Environment.NewLine}MoveLimit : {MoveLimit}", "OK");
                }
                else
                {
                    await DisplayAlert("Not Support This Image", listbyte.Count.ToString(), "OK");
                }
            }
            catch (Exception ex)
            {
                await DisplayAlert("Error", ex.Message, "OK");
            }
            finally
            {
                IsLoading = false;
            }
        }
        private void OnNextTurn()
        {
            Turn++;

            foreach (var provinceViewModel in this.Provinces)
            {
                provinceViewModel.IsFirstTurn = false;
                var provinceHistory = provinceHistories.Single(p => p.ProvinceName == provinceViewModel.ProvinceName);

                provinceHistory.Add(
                    new ProvinceRevision(
                        provinceViewModel.FarmsViewModel.Count,
                        provinceViewModel.ResourceViewModel.ResourceLevel,
                        provinceViewModel.SoldiersViewModel.Count,
                        provinceViewModel.CultureViewModel.CultureLevel));

                var predictor = new Predictor();
                var buildPredictions = predictor.Predict(provinceHistory);

                var firstPrediction = buildPredictions.First();
                provinceViewModel.BuildPrediction.Building = firstPrediction.Building;
                provinceViewModel.BuildPrediction.TurnsLeft = firstPrediction.TurnsLeft;
            }
        }
Esempio n. 33
0
 void Awake()
 {
     predictor = GetComponent<Predictor>();
 }
Esempio n. 34
0
        // tagMethods can be null
        public void TIFFPredictorInit(TiffTagMethods tagMethods)
        {
            // Merge codec-specific tag information and override parent get/set field methods.
            m_tif.MergeFieldInfo(m_predictFieldInfo, m_predictFieldInfo.Length);
            m_childTagMethods = tagMethods;
            m_parentTagMethods = m_tif.m_tagmethods;
            m_tif.m_tagmethods = m_tagMethods;

            m_predictor = Predictor.NONE; // default value
            m_predictorType = PredictorType.ptNone; // no predictor method
        }
Esempio n. 35
0
 public void SetPredictorValue(Predictor value)
 {
     m_predictor = value;
 }
		public void Init()
		{
			Predictor = new Predictor(ConfigurationManager.AppSettings["PredictorKey"]);
		}
Esempio n. 37
0
		public frmMain()
		{
			Predictor = new Predictor(Settings.Default.PredictorKey);
			Dictionary = new Dictionary(Settings.Default.DictionaryKey);
			Translator = new Translator(Settings.Default.TranslatorKey);
			Speller = new Speller();
			Inflector = new Inflector();

			PredictorTimer = new System.Threading.Timer(_ => UpdatePredictorResult(), null, Timeout.Infinite, Timeout.Infinite);
			DictionaryTimer = new System.Threading.Timer(_ => UpdateDictionaryResult(), null, Timeout.Infinite, Timeout.Infinite);
			TranslatorTimer = new System.Threading.Timer(_ => UpdateTranslatorResult(), null, Timeout.Infinite, Timeout.Infinite);
			SpellerTimer = new System.Threading.Timer(_ => UpdateSpellerResult(), null, Timeout.Infinite, Timeout.Infinite);
			InflectorTimer = new System.Threading.Timer(_ => UpdateInflectorResult(), null, Timeout.Infinite, Timeout.Infinite);

			InitializeComponent();

			tcServices.SelectedIndex = Settings.Default.SelectedTabIndex;

			cmbPredictorLangs.Items.AddRange(Predictor.GetLangs().Select(lang => (object)lang).ToArray());
			cmbDictionaryLangPairs.Items.AddRange(Dictionary.GetLangs().Select(lang => (object)lang).ToArray());
			cmbDictionaryLangUi.Items.Add("");
			cmbDictionaryLangUi.Items.AddRange(Predictor.GetLangs().Select(lang => (object)lang).ToArray());

			cmbPredictorLangs.SelectedItem = Enum.Parse(typeof(Lang), Settings.Default.PredictorLanguage);
			nudMaxHintCount.Value = Settings.Default.PredictorMaxHintCount;
			nudPredictorDelay.Value = Settings.Default.PredictorHintDelay;
			tbPredictorInput.Text = Settings.Default.PredictorInput;

			cmbDictionaryLangPairs.SelectedItem = new LangPair(Settings.Default.DictionaryLangPair);
			cmbDictionaryLangUi.SelectedIndex = 0;
			
			cbFamily.Checked = Settings.Default.DictionaryFamily;
			cbMorpho.Checked = Settings.Default.DictionaryMorpho;
			cbPartOfSpeech.Checked = Settings.Default.DictionaryPartOfSpeech;
			nudPredictorDelay.Value = Settings.Default.DictionaryHintDelay;
			tbDictionaryInput.Text = Settings.Default.DictionaryInput;
			cbDictionaryFormatting.Checked = Settings.Default.DictionaryFormatting;
			rbDictionaryOutput.Text = Settings.Default.DictionaryOutputIndent;

			var langArray = ((Lang[])Enum.GetValues(typeof(Lang))).Select(lang => (object)lang).ToArray();
			cmbTranslatorInputLang.Items.AddRange(langArray);
			cmbTranslatorOutputLang.Items.AddRange(langArray);
			cmbTranslatorInputLang.SelectedItem = (Lang)Enum.Parse(typeof(Lang), Settings.Default.TranslatorInputLang);
			cmbTranslatorOutputLang.SelectedItem = (Lang)Enum.Parse(typeof(Lang), Settings.Default.TranslatorOutputLang);
			nudTranslatorDelay.Value = Settings.Default.TranslatorHintDelay;
			cbTranslatorDetectInputLang.Checked = Settings.Default.TranslatorDetectInputLang;
			tbTranslatorInput.Text = Settings.Default.TranslatorInput;

			cbSpellerRu.Checked = Settings.Default.SpellerRuLang;
			cbSpellerEn.Checked = Settings.Default.SpellerEnLang;
			cbSpellerUk.Checked = Settings.Default.SpellerUkLang;
			SpellerOptions options = (SpellerOptions)Settings.Default.SpellerOptions;
			cbIgnoreUppercase.Checked = options.HasFlag(SpellerOptions.IgnoreUppercase);
			cbIgnoreDigits.Checked = options.HasFlag(SpellerOptions.IgnoreDigits);
			cbIgnoreUrls.Checked = options.HasFlag(SpellerOptions.IgnoreUrls);
			cbFindRepeatWords.Checked = options.HasFlag(SpellerOptions.FindRepeatWords);
			cbIgnoreLatin.Checked = options.HasFlag(SpellerOptions.IgnoreLatin);
			cbNoSuggest.Checked = options.HasFlag(SpellerOptions.NoSuggest);
			cbFlagLatin.Checked = options.HasFlag(SpellerOptions.FlagLatin);
			cbByWords.Checked = options.HasFlag(SpellerOptions.ByWords);
			cbIgnoreCapitalization.Checked = options.HasFlag(SpellerOptions.IgnoreCapitalization);
			nudSpellerDelay.Value = Settings.Default.SpellerHintDelay;
			tbSpellerInput.Text = Settings.Default.SpellerInput;
			cbIncludeErrorWords.Checked = Settings.Default.SpellerIncludeErrorWords;

			tbInflectorInput.Text = Settings.Default.InflectorInput;

			tbPredictorKey.Text = Settings.Default.PredictorKey;
			tbDictionaryKey.Text = Settings.Default.DictionaryKey;
			tbTranslatorKey.Text = Settings.Default.TranslatorKey;
			tbPredictorBaseUrl.Text = Settings.Default.PredictorBaseUrl;
			tbDictionaryBaseUrl.Text = Settings.Default.DictionaryBaseUrl;
			tbTranslatorBaseUrl.Text = Settings.Default.TranslatorBaseUrl;
			tbSpellerBaseUrl.Text = Settings.Default.SpellerBaseUrl;
			tbInflectorBaseUrl.Text = Settings.Default.InflectorBaseUrl;
		}
Esempio n. 38
0
		private void tbPredictorKey_TextChanged(object sender, EventArgs e)
		{
			Predictor = new Predictor(tbPredictorKey.Text, tbPredictorBaseUrl.Text);
			tbPredictor_TextChanged(sender, e);
		}
        private void OnChangeCapital()
        {
            Turn = 1;

            Provinces.Clear();

            provinceHistories.Clear();

            if (SelectedCapital != null)
            {
                var predictor = new Predictor();
                foreach (var neighbour in new NeighbourProvider().GetNeighbours(SelectedCapital))
                {
                    var provinceHistory = new ProvinceHistory(neighbour);
                    provinceHistories.Add(provinceHistory);
                    // TODO should be from model not from this loop
                    var firstPrediction = predictor.Predict(provinceHistory).First();

                    var provinceViewModel = new ProvinceViewModel
                    {
                        ProvinceName = neighbour,
                        FarmsViewModel = new NumericViewModel { Count = 1 },
                        SoldiersViewModel = new NumericViewModel { Count = 1 },
                        CultureViewModel = new CultureViewModel(),
                        ResourceViewModel = new ResourceViewModel(),
                        BuildPrediction = new BuildPredictionViewModel
                        {
                            Building = firstPrediction.Building,
                            TurnsLeft = firstPrediction.TurnsLeft
                        },
                    };
                    provinceViewModel.ProvinceRemoved += provinceViewModel_OnProvinceRemoved;
                    provinceViewModel.IsFirstTurn = true;

                    Provinces.Add(provinceViewModel);
                }
            }
        }