/// <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))); }
// Use this for initialization void Start() { predictor = new Predictor("1234"); totalElecciones = ""; eleccionesPredecir = ""; eleccionesRegistrar = ""; }
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))); }
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); }
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 }
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("------------------------------"); }
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); } }
// Use this for initialization void Start() { predictor = new Predictor(); totalChoices = new List <Movements>(); choicesToPredict = new List <Movements>(); choicesToRegister = new List <Movements>(); }
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); }
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("-------------------- .. "); }
public void PossibleDecks_OneMetaDeckSameClass() { AddMetaDeck("Hunter"); var predictor = new Predictor(new MockOpponent("Hunter"), _metaDecks.AsReadOnly()); Assert.IsTrue(_metaDecks.SequenceEqual(predictor.PossibleDecks)); }
public void PossibleDecks_OneMetaDeckDifferentClass() { AddMetaDeck("Hunter"); var predictor = new Predictor(new MockOpponent("Mage"), _metaDecks.AsReadOnly()); Assert.AreEqual(0, predictor.PossibleDecks.Count); }
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); }
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))); }
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); }
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); }
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(); }
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()); }
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()); }
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); }
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); }
/// <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> >(); } }
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; } }
void Awake() { predictor = GetComponent<Predictor>(); }
// 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 }
public void SetPredictorValue(Predictor value) { m_predictor = value; }
public void Init() { Predictor = new Predictor(ConfigurationManager.AppSettings["PredictorKey"]); }
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; }
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); } } }