private void btnGoooo_Click(object sender, RoutedEventArgs e) { var selectedPath = txtPath.Text; if (string.IsNullOrEmpty(selectedPath)) { var fbd = new System.Windows.Forms.FolderBrowserDialog(); if (fbd.ShowDialog() != System.Windows.Forms.DialogResult.OK) { return; } selectedPath = txtPath.Text = fbd.SelectedPath; } // Start _pictures.Clear(); var paths = selectedPath.Split('%'); foreach (var path in paths) { FindFilesInDirectory(path); } _pictures.Shuffle(); _pictureTimer.Interval = 1; _pictureTimer.Elapsed += (o, args) => { _pictureTimer.Stop(); _pictureTimer.Interval = 1800; if (_pictures.Count > _pictureIndex) { // turn down for shuffle _pictures.Shuffle(); _pictures.Shuffle(); _pictures.Shuffle(); _pictureIndex = 0; } Dispatcher.Invoke( new Action(() => { pictureBoxSlideshowMask.Source = pictureBoxSlideshow.Source = new BitmapImage( new Uri(_pictures[_pictureIndex])); PathTextBox.Text = _pictures[_pictureIndex]; _pictureTimer.Start(); })); _pictureIndex++; }; _pictureTimer.Start(); }
/** * Loads terms and frequencies from Wikipedia (cached). */ public override void SetUp() { Debug.Assert(false, "disable assertions before running benchmarks!"); IList <Input> input = ReadTop50KWiki(); input.Shuffle(); dictionaryInput = input.ToArray(); input.Shuffle(); benchmarkInput = input; }
/// <summary> /// Reset the deck to its original state, restoring any cards that were consumed. /// </summary> public void Reset() { var _fascistCards = Enumerable.Range(1, Constants.TotalFascistPolicies).Select(_ => PolicyType.Fascist); var _liberalCards = Enumerable.Range(1, Constants.TotalLiberalPolicies).Select(_ => PolicyType.Liberal); _policyDeck.Clear(); _policyDeck.AddRange(_fascistCards.Concat(_liberalCards)); _policyDeck.Shuffle(); _discardDeck.Clear(); }
/** * Loads terms and frequencies from Wikipedia (cached). */ public override void SetUp() { if (Debugging.AssertsEnabled) { Debugging.Assert(false, () => "disable assertions before running benchmarks!"); } IList <Input> input = ReadTop50KWiki(); input.Shuffle(Random); dictionaryInput = input.ToArray(); input.Shuffle(Random); benchmarkInput = input; }
public void Train(IList<InputOutput> trainingSet, INeuralNetwork nn) { Validate(); if (nn == null) throw new ArgumentNullException(nameof(nn)); var rand = RandomProvider.GetRandom(Seed); if (ShouldInitializeWeights) InitializeWeights(nn, rand); var validationSetFraction = GetValidationSetFraction(); IList<InputOutput> trainingSubSet; IList<InputOutput> validationSubSet = null; if (validationSetFraction > 0) { var split = trainingSet.Shuffle(rand).Split(validationSetFraction); validationSubSet = split.First; trainingSubSet = split.Second; } else { trainingSubSet = trainingSet; } Train(trainingSubSet, validationSubSet, rand, nn); }
public Deck() { IList <Card> cards = CreateCardsOrdered(); cards.Shuffle(); Cards = new Stack <Card>(cards); }
/// <summary> /// will use Shuffle if you want many of the items, as it will be more efficient /// </summary> /// <typeparam name="T"></typeparam> /// <param name="list"></param> /// <param name="count"></param> /// <param name="rand"></param> /// <returns></returns> public static List <T> SampleAtRandomWithoutReplacement <T>(this IList <T> list, int count, Random rand) { Helper.CheckCondition(count <= list.Count, "Can't sample without replacement more items that there are"); if (count > list.Count / 4) { list.Shuffle(rand).Take(count).ToList(); } //first sample the indexes, and make sure there are no duplicates: HashSet <int> sampledIndexes = new HashSet <int>(); while (sampledIndexes.Count < count) { int nxtIndex = rand.Next(list.Count); if (!sampledIndexes.Contains(nxtIndex)) { sampledIndexes.Add(nxtIndex); } } Helper.CheckCondition(sampledIndexes.Distinct().Count() == count, "something went wrong--bug"); List <T> results = list.SubList(sampledIndexes.ToList()); return(results); }
public void Train(IList <InputOutput> trainingSet, INeuralNetwork nn) { Validate(); if (nn == null) { throw new ArgumentNullException(nameof(nn)); } var rand = RandomProvider.GetRandom(Seed); if (ShouldInitializeWeights) { InitializeWeights(nn, rand); } var validationSetFraction = GetValidationSetFraction(); IList <InputOutput> trainingSubSet; IList <InputOutput> validationSubSet = null; if (validationSetFraction > 0) { var split = trainingSet.Shuffle(rand).Split(validationSetFraction); validationSubSet = split.First; trainingSubSet = split.Second; } else { trainingSubSet = trainingSet; } Train(trainingSubSet, validationSubSet, rand, nn); }
/// <summary> /// Returns a list of matches where each team from list1 plays against a team from teams2. /// All teams from both lists play one match. Whether a team plays home or away is determined randomly. /// The total number of teams for both lists must be an even number and both lists must contain an equal number of teams. /// </summary> public List<Match> GetMatches(IList<Team> teams1, IList<Team> teams2) { // Total number of teams must be even and both lists same number of teams. bool isValid = (teams1.Count + teams2.Count) % 2 == 0 && teams1.Count == teams2.Count; if (!isValid) { throw new Exception("Even number of teams expected and both lists same number of teams"); } teams1.Shuffle(); teams2.Shuffle(); var matches = new List<Match>(); for (int i = 0; i < teams1.Count; i++) { // Optionally swith home/away var homeTeam = teams1[i]; var awayTeam = teams2[i]; bool switchHomeAndAway = _randomizer.GetRandomBoolean(); if (switchHomeAndAway) { homeTeam = teams2[i]; awayTeam = teams1[i]; } var match = MatchFactory.CreateMatch(homeTeam, awayTeam); matches.Add(match); } return matches; }
/// <summary> /// Shuffles an IList in place as many times as specified. /// </summary> /// <typeparam name="T">The type of elements in the list</typeparam> public static void Shuffle <T>(this IList <T> list, int numberOfRuns) { for (int i = 0; i < numberOfRuns; i++) { list.Shuffle(new Random()); } }
//--------------------------------------------------------------------- public void Shuffle() { this.listOfCards = AllCards.Shuffle(Random).ToList(); mapSameTypeCard = new Dictionary <CardTypeNiuNiu, List <Card> >(); mapSameSuitCard = new Dictionary <CardSuit, List <Card> >(); foreach (var i in listOfCards) { CardTypeNiuNiu card_type = (CardTypeNiuNiu)i.Type; List <Card> list_sametypecard = null; mapSameTypeCard.TryGetValue(card_type, out list_sametypecard); if (list_sametypecard == null) { list_sametypecard = new List <Card>(); mapSameTypeCard[card_type] = list_sametypecard; } list_sametypecard.Add(i); CardSuit card_suit = (CardSuit)i.Suit; List <Card> list_samesuitcard = null; mapSameSuitCard.TryGetValue(card_suit, out list_samesuitcard); if (list_samesuitcard == null) { list_samesuitcard = new List <Card>(); mapSameSuitCard[card_suit] = list_samesuitcard; } list_samesuitcard.Add(i); } }
private void Awake() { Log.Verbose("Game Awake", "Unity"); // TODO: Random Start _eventAggregator = new EventAggregator(); _first = PhotonNetwork.isMasterClient ? PlayerType.Player : PlayerType.Opponent; _idFactory = new CardIdFactory(); _players = new Dictionary <PlayerType, Player>(); foreach (var type in Extension.GetValues <PlayerType>()) { _players.Add(type, new Player(this, type)); } _battle = null; _deck = new List <string>(Deck.Get().GetList()); _deck.Shuffle(); Subscribe(this); GuiMediator.OnButtonClick += OnButtonClick; GuiMediator.SetButtonClickable(ButtonType.NextPhaseButton, PhotonNetwork.isMasterClient); GuiMediator.OnCardDragToZone += OnCardDragToZone; GuiMediator.OnCardDragToCard += OnCardDragToCard; QuitButton.onClick.AddListener(() => { PhotonNetwork.LeaveRoom(); }); End = false; }
private static void CreateLeagueMatches(IList <Team> teams, ICollection <Match> listOfMatches, int leagueId, Func <int, LeagueMatchCreationMode> getMatchCreationMode) { teams.Shuffle(); var mode = getMatchCreationMode(leagueId); List <Match> generateMatches; switch (mode) { case LeagueMatchCreationMode.Single: generateMatches = new SingleRoundMatchCreator().CreateMatches(teams); break; case LeagueMatchCreationMode.Double: generateMatches = new DoubleRoundMatchCreator().CreateMatches(teams); break; default: throw new Exception("Unknown match creation mode"); } foreach (var match in generateMatches) { match.LeagueId = leagueId; listOfMatches.Add(match); } }
public Task RandomPruneAsync(IList <Edge> edges, int removeEdgesCount, int[] verticesDegree, CancellationToken token) { edges.Shuffle(); return(Task.Run(() => { var sw = new Stopwatch(); sw.Start(); var maxrun = edges.Count; while (removeEdgesCount > 0 && !token.IsCancellationRequested && maxrun > 0) { maxrun--; var edge = edges.First(); var couldRemoveV1 = (verticesDegree[edge.V1] - 1) > 0; var couldRemoveV2 = (verticesDegree[edge.V2] - 1) > 0; if (couldRemoveV1 && couldRemoveV2) { removeEdgesCount--; verticesDegree[edge.V1]--; verticesDegree[edge.V2]--; edges.RemoveAt(0); } } sw.Stop(); Console.WriteLine($" SAMPLE takes {sw.ElapsedMilliseconds / 1000f} seconds to prune"); })); }
public IList <Matchday> CreateSchedule(IList <Team> teams, bool withReverseFixtures) { var teamToMakeEven = new Team(); if (teams.Count % 2 != 0) { teams.Add(teamToMakeEven); } teams.Shuffle(); Team markerTeam = teams[1]; List <Matchday> matchdays = new List <Matchday>(); int matchDayNumber = 1; do { matchdays.Add(createMatchday(matchDayNumber, teams)); advanceTeams(teams); matchDayNumber++; } while (teams[1] != markerTeam); if (withReverseFixtures) { matchdays.AddRange(createReverseMatchdays(matchdays)); } teams.Remove(teamToMakeEven); return(matchdays); }
public static IList <string> SortearTabelaCampeonato(IList <string> competidores) { if (competidores.Count < 3) { throw new ArgumentException("A lista de competidoes não pode ser menor que 3", "competidores"); } competidores.Shuffle(); int qtd_competidores = competidores.Count; IList <string> competidores_1 = new List <string>(); IList <string> competidores_2 = new List <string>(); definir_lista_competidores(ref competidores, ref competidores_1, ref competidores_2); List <string> partidas_torneio = new List <string>(); // A quantidade de rodadas do torneio é igual a quantidade de competidores no caso de quantidade de competidores ímpar // No caso de quantidade de competidores par, a quantidade de rodadas é a quantidade de competidores menos 1. int qtd_rodadas = qtd_competidores - (competidores.Contains("Folga") ? 0 : 1); for (int rodada = 0; rodada < qtd_rodadas; rodada++) { // A quantidade de partidas da rodada é igual a quantidade de competidores "real" dividido por 2. int qtd_partidas_rodada = qtd_competidores / 2; string[] partidas_rodada = new string[qtd_partidas_rodada]; for (int partida = 0, competidor = 0; partida < qtd_partidas_rodada; partida++, competidor++) { // Se for uma partida válida, insere na rodada, senão, reduz o número da partida para não ignorar o último confronto da rodada. if (competidores_2[competidor] != "Folga" && competidores_1[competidor] != "Folga") { partidas_rodada[partida] = String.Format("Rodada {0}: {1} vs {2}", rodada + 1, competidores_1[competidor], competidores_2[competidor]); } else { partida--; } } // Pega os competidores que trocarão de lista. string competidor_lista1_para_lista2 = competidores_1[competidores_1.Count - 1]; string competidor_lista2_para_lista1 = competidores_2[0]; // Remove os competidores da lista. competidores_1.Remove(competidor_lista1_para_lista2); competidores_2.Remove(competidor_lista2_para_lista1); // Insere o competidor logo após o primeiro da lista. competidores_1.Insert(1, competidor_lista2_para_lista1); // Insere o competidor no final da lista. competidores_2.Add(competidor_lista1_para_lista2); partidas_torneio.AddRange(partidas_rodada); } return(partidas_torneio); }
//--------------------------------------------------------------------- public void Shuffle() { this.listOfCards = AllCards.Shuffle(Random).ToList(); mapSameTypeCard = new Dictionary <MaJiangType, List <Card> >(); mapSameSuitCard = new Dictionary <MaJiangSuit, List <Card> >(); foreach (var i in listOfCards) { List <Card> list_sametypecard = null; mapSameTypeCard.TryGetValue((MaJiangType)i.Type, out list_sametypecard); if (list_sametypecard == null) { list_sametypecard = new List <Card>(); mapSameTypeCard[(MaJiangType)i.Type] = list_sametypecard; } list_sametypecard.Add(i); List <Card> list_samesuitcard = null; mapSameSuitCard.TryGetValue((MaJiangSuit)i.Suit, out list_samesuitcard); if (list_samesuitcard == null) { list_samesuitcard = new List <Card>(); mapSameSuitCard[(MaJiangSuit)i.Suit] = list_samesuitcard; } list_samesuitcard.Add(i); } }
/// <summary> /// Regenerates stock state by randomizing some values, /// such as amount of different items and number of new items in the stock. /// </summary> public void RegenerateStock() { // Create a fast variable, in case if I will change the target. IList <IItem> stock = myStock; // Randomize item positions (just for a visible effect) stock.Shuffle(); // Update last update time myLastStockUpdateTime = DateTime.Now; // Randomize items amount for (int ma = 0; ma < stock.Count; ++ma) { int randomAmount = Random.Next(0, 20); // Remove if amount is 0 if (randomAmount == 0) { stock.RemoveAt(ma); continue; } // Update item amount stock[ma].Amount = randomAmount; } // Add new items int newItemsCount = (Random.Next(2) == 0) ? 0 : Random.Next(1, 4); for (var ma = 0; ma < newItemsCount; ++ma) { stock.Add(GenerateItem()); } }
public static T PickAndRemoveBest <T>(this IList <T> enumerable, Func <T, IComparable> keySelector, Random random) { var pick = enumerable.Shuffle(random).OrderByDescending(keySelector).First(); enumerable.Remove(pick); return(pick); }
/// <summary>Compute parameters (latent factors) for a user represented by ratings</summary> /// <returns>a vector of latent factors</returns> /// <param name='rated_items'>a list of (item ID, rating value) pairs</param> protected virtual float[] FoldIn(IList <Tuple <int, float> > rated_items) { var user_vector = new float[NumFactors]; user_vector.InitNormal(InitMean, InitStdDev); rated_items.Shuffle(); double lr = LearnRate; for (uint it = 0; it < NumIter; it++) { for (int index = 0; index < rated_items.Count; index++) { int item_id = rated_items[index].Item1; float err = rated_items[index].Item2 - Predict(user_vector, item_id, false); // adjust factors for (int f = 0; f < NumFactors; f++) { float u_f = user_vector[f]; float i_f = item_factors[item_id, f]; double delta_u = err * i_f - Regularization * u_f; user_vector[f] += (float)(lr * delta_u); } } lr *= Decay; } return(user_vector); }
public static void ShuffleManyTimes <T>(this IList <T> list, int nbOfShuffles) { for (int i = 0; i < nbOfShuffles; i++) { list.Shuffle(); } }
public void Returns_shuffled_collection(IList <int> collection) { IEnumerable <int> shuffled = collection.Shuffle(); shuffled.ShouldNotBeSameAs(collection); shuffled.ShouldNotBe(new [] { 1, 2, 3, 4, 5, 6 }); }
/// <summary> /// Trains the <paramref name="network"/> using <paramref name="trainingDatasetEntries"/> and return the average training cost of the final iteration. /// </summary> /// <param name="network">The neural network that is to be trained.</param> /// <param name="trainingDatasetEntries">The training iterations to train the network with.</param> /// <returns>Returns the average training cost of the final iteration.</returns> private IDFFNeuralNetwork TrainNetwork(IDFFNeuralNetwork network, IList <INetworkTrainingIteration> trainingDatasetEntries) { var priorTrainingCost = 999.0; var trainingIteration = 0; while (true) { trainingDatasetEntries.Shuffle(); // TODO: Implement Clone() method for NeuralNetwork and store the BEST network. var trainingCost = network.Train(trainingDatasetEntries).Average(i => i.TrainingCost); Console.WriteLine($"{trainingIteration} : {trainingCost}"); // Check the training cost every 500 iterations to ensure it's continuing to improve if (trainingIteration % 500 == 0) { if ((priorTrainingCost - trainingCost) < .01) { break; } else { priorTrainingCost = trainingCost; } } trainingIteration++; } return(network); }
/// <summary> /// Returns a list of matches where each team from list1 plays against a team from teams2. /// All teams from both lists play one match. Whether a team plays home or away is determined randomly. /// The total number of teams for both lists must be an even number and both lists must contain an equal number of teams. /// </summary> public List <Match> GetMatches(IList <Team> teams1, IList <Team> teams2) { // Total number of teams must be even and both lists same number of teams. bool isValid = (teams1.Count + teams2.Count) % 2 == 0 && teams1.Count == teams2.Count; if (!isValid) { throw new Exception("Even number of teams expected and both lists same number of teams"); } teams1.Shuffle(); teams2.Shuffle(); var matches = new List <Match>(); for (int i = 0; i < teams1.Count; i++) { // Optionally swith home/away var homeTeam = teams1[i]; var awayTeam = teams2[i]; bool switchHomeAndAway = _randomizer.GetRandomBoolean(); if (switchHomeAndAway) { homeTeam = teams2[i]; awayTeam = teams1[i]; } var match = MatchFactory.CreateMatch(homeTeam, awayTeam); matches.Add(match); } return(matches); }
/// <summary> /// Randomly select specified number of items from the list. /// The items with higher weight are in the result with higher probability /// </summary> /// <typeparam name="T"></typeparam> /// <param name="items"></param> /// <param name="weight"></param> /// <returns></returns> public static IList <T> WeightedChoice <T>(this IList <T> items, int selectCount, Func <T, double> weight) { if (selectCount < 1 || selectCount > items.Count) { throw new ArgumentOutOfRangeException("The size of the selection must be a positive number equal or less than the size of the list"); } if (selectCount == items.Count) { return(items); } items.Shuffle(); List <Flagable <T> > _list = ConvertToFlagable(items); var result = new List <Flagable <T> >(); while (selectCount > 0) { var selected = SelectItems(_list, weight, selectCount); selectCount -= selected.Count; result.AddRange(selected); _list.RemoveAll(item => item.Flag == true); //remove those that are already selected } return(result.Select(item => item.obj).ToList <T>()); }
public RandomSimilarityProvider(Random random) { perFieldSeed = random.Next(); coordType = random.Next(3); shouldQueryNorm = random.NextBoolean(); knownSims = new List <Similarity>(allSims); knownSims.Shuffle(random); }
// Select N random items from list, without replacement. // Modifies the given list. public static SCG.IEnumerable <T> RandomWithout1 <T>(IList <T> list, int N) { list.Shuffle(rnd); foreach (T x in list.View(0, N)) { yield return(x); } }
public void Shuffle() { do { Cards.Shuffle(); }while (_unshuffledDeck.Cards.SequenceEqual(Cards)); IsShuffled = true; }
void Awake() { foreach (Transform Child in transform) { SpawnLocations.Add(Child); } SpawnLocations.Shuffle(); }
/// protected override float[] FoldIn(IList <Tuple <int, float> > rated_items) { var user_p = new float[NumFactors]; user_p.InitNormal(InitMean, InitStdDev); float user_bias = 0; var items = (from pair in rated_items select pair.Item1).ToArray(); float user_reg_weight = FrequencyRegularization ? (float)(Regularization / Math.Sqrt(items.Length)) : Regularization; // compute stuff that will not change var y_sum_vector = y.SumOfRows(items); double norm_denominator = Math.Sqrt(items.Length); for (int f = 0; f < y_sum_vector.Count; f++) { y_sum_vector[f] = (float)(y_sum_vector[f] / norm_denominator); } rated_items.Shuffle(); for (uint it = 0; it < NumIter; it++) { for (int index = 0; index < rated_items.Count; index++) { int item_id = rated_items[index].Item1; double prediction = global_bias + user_bias + item_bias[item_id]; prediction += DataType.MatrixExtensions.RowScalarProduct(item_factors, item_id, y_sum_vector); prediction += DataType.MatrixExtensions.RowScalarProduct(item_factors, item_id, user_p); float err = (float)(rated_items[index].Item2 - prediction); // adjust bias user_bias += BiasLearnRate * LearnRate * ((float)err - BiasReg * user_reg_weight * user_bias); // adjust factors for (int f = 0; f < NumFactors; f++) { float u_f = user_p[f]; float i_f = item_factors[item_id, f]; double delta_u = err * i_f - user_reg_weight * u_f; user_p[f] += (float)(LearnRate * delta_u); } } } // assign final parameter values to return vector var user_vector = new float[NumFactors + 1]; user_vector[0] = user_bias; for (int f = 0; f < NumFactors; f++) { user_vector[f + 1] = (float)y_sum_vector[f] + user_p[f]; } return(user_vector); }
public void ShouldThrowExceptionBecauseOfNull() { // Given IList <int> arr = null; Action action = () => arr.Shuffle(); // Then action.ShouldThrow <ArgumentNullException>(); }
public static void Shuffle <T>(this IList <T> self, System.Random random) { int GetRandomIndex(int i) { return(random.Next(0, i + 1)); } self.Shuffle(GetRandomIndex); }
/// <summary>Online evaluation for rankings of items</summary> /// <remarks> /// The evaluation protocol works as follows: /// For every test user, evaluate on the test items, and then add the those test items to the training set and perform an incremental update. /// The sequence of users is random. /// </remarks> /// <param name="recommender">the item recommender to be evaluated</param> /// <param name="test">test cases</param> /// <param name="training">training data (must be connected to the recommender's training data)</param> /// <param name="test_users">a list of all test user IDs</param> /// <param name="candidate_items">a list of all candidate item IDs</param> /// <param name="candidate_item_mode">the mode used to determine the candidate items</param> /// <returns>a dictionary containing the evaluation results (averaged by user)</returns> public static ItemRecommendationEvaluationResults EvaluateOnline( this IRecommender recommender, IPosOnlyFeedback test, IPosOnlyFeedback training, IList<int> test_users, IList<int> candidate_items, CandidateItems candidate_item_mode) { var incremental_recommender = recommender as IIncrementalItemRecommender; if (incremental_recommender == null) throw new ArgumentException("recommender must be of type IIncrementalItemRecommender"); // prepare candidate items once to avoid recreating them switch (candidate_item_mode) { case CandidateItems.TRAINING: candidate_items = training.AllItems; break; case CandidateItems.TEST: candidate_items = test.AllItems; break; case CandidateItems.OVERLAP: candidate_items = new List<int>(test.AllItems.Intersect(training.AllItems)); break; case CandidateItems.UNION: candidate_items = new List<int>(test.AllItems.Union(training.AllItems)); break; } test_users.Shuffle(); var results_by_user = new Dictionary<int, ItemRecommendationEvaluationResults>(); foreach (int user_id in test_users) { if (candidate_items.Intersect(test.ByUser[user_id]).Count() == 0) continue; // prepare data var current_test_data = new PosOnlyFeedback<SparseBooleanMatrix>(); foreach (int index in test.ByUser[user_id]) current_test_data.Add(user_id, test.Items[index]); // evaluate user var current_result = Items.Evaluate(recommender, current_test_data, training, current_test_data.AllUsers, candidate_items, CandidateItems.EXPLICIT); results_by_user[user_id] = current_result; // update recommender var tuples = new List<Tuple<int, int>>(); foreach (int index in test.ByUser[user_id]) tuples.Add(Tuple.Create(user_id, test.Items[index])); incremental_recommender.AddFeedback(tuples); } var results = new ItemRecommendationEvaluationResults(); foreach (int u in results_by_user.Keys) foreach (string measure in Items.Measures) results[measure] += results_by_user[u][measure]; foreach (string measure in Items.Measures) results[measure] /= results_by_user.Count; results["num_users"] = results_by_user.Count; results["num_items"] = candidate_items.Count; results["num_lists"] = results_by_user.Count; return results; }
public InfectionDeck(IList<InfectionCard> infectionCards) { infectionCards.Shuffle(); foreach (InfectionCard card in infectionCards) { card.Discarded += CardDiscarded; } cardPile = new Stack<InfectionCard>(infectionCards); discardPile = new Stack<InfectionCard>(); }
/// <summary> /// Used by the producer to send a metadata request since it has access to the ProducerConfig /// </summary> /// <param name="topics">The topics for which the metadata needs to be fetched</param> /// <param name="brokers">The brokers in the cluster as configured on the client</param> /// <param name="producerConfig">The producer's config</param> /// <param name="correlationId">topic metadata response</param> /// <returns></returns> public static TopicMetadataResponse FetchTopicMetadata( ISet<string> topics, IList<Broker> brokers, ProducerConfig producerConfig, int correlationId) { var fetchMetaDataSucceeded = false; var i = 0; var topicMetadataRequest = new TopicMetadataRequest( TopicMetadataRequest.CurrentVersion, correlationId, producerConfig.ClientId, topics.ToList()); TopicMetadataResponse topicMetadataResponse = null; Exception t = null; // shuffle the list of brokers before sending metadata requests so that most requests don't get routed to the same broker var shuffledBrokers = brokers.Shuffle(); while (i < shuffledBrokers.Count() && !fetchMetaDataSucceeded) { var producer = ProducerPool.CreateSyncProducer(producerConfig, shuffledBrokers[i]); Logger.InfoFormat("Fetching metadata from broker {0} with correlation id {1} for {2} topic(s) {3}", shuffledBrokers[i], correlationId, topics.Count, string.Join(",", topics)); try { topicMetadataResponse = producer.Send(topicMetadataRequest); fetchMetaDataSucceeded = true; } catch (Exception e) { Logger.Warn(string.Format("Fetching topic metadata with correlation id {0} for topic [{1}] from broker [{2}] failed", correlationId, topics, shuffledBrokers[i]), e); t = e; } finally { i++; producer.Dispose(); } } if (!fetchMetaDataSucceeded) { throw new KafkaException( string.Format( "fetching topic metadata for topics [{0}] from broker [{1}] failed", string.Join(",", topics), string.Join(", ", shuffledBrokers)), t); } Logger.DebugFormat("Successfully fetched metadata for {0} topic(s) {1}", topics.Count(), string.Join(",", topics)); return topicMetadataResponse; }
/// <summary> /// SIDE EFFECT: Sets the Victim property if needed /// </summary> /// <param name="zoo"></param> /// <param name="killer"></param> /// <returns>the night activity text</returns> public IList<string> GetNightActivity(IList<string> zoo, string killer) { if (!zoo.Contains(killer)) { return new List<string>(); } zoo.Shuffle(); Victim = GetVictim(zoo, killer); IList<string> nightCopy = new List<string>(GameResources.TwoPersonNightActivities); nightCopy.Shuffle(); IList<string> activities = new List<string>(); for (int i = 0; i < zoo.Count - 1; i++) { activities.Add(String.Format(nightCopy[i], zoo[i], zoo[i + 1])); } activities.Add(String.Format(nightCopy[zoo.Count], zoo[zoo.Count - 1], zoo[0])); activities.Shuffle(); return activities; }
void StartRound() { int round = rounds.Count + 1; var previousRound = currentRound; if (currentRound != null) rounds.Add(currentRound); currentRound = new List<Attempt>(); items = previousRound != null ? new List<PracticeItem>(from x in previousRound where !x.Correct select x.Item) : Owner.GetAllItems(); items.Shuffle(rng); index = 0; score = 0; state = items.Count > 0 ? State.Guessing : State.GameOverview; }
/// <summary> /// Returns a list of matches where all teams play one match. /// Whether a team plays home or away is determined randomly. /// The given team list must contain an even number of teams. /// </summary> public List<Match> GetMatches(IList<Team> teams) { // Even number of teams expected. bool isValid = teams.Count % 2 == 0; if (!isValid) { throw new Exception("Even number of teams expected"); } teams.Shuffle(); var matches = new List<Match>(); for (int i = 0; i < teams.Count; i += 2) { var match = MatchFactory.CreateMatch(teams[i], teams[i + 1]); matches.Add(match); } return matches; }
/// protected override float[] FoldIn(IList<Tuple<int, float>> rated_items) { SetupLoss(); // initialize user parameters float user_bias = 0; var factors = new float[NumFactors]; factors.InitNormal(InitMean, InitStdDev); float reg_weight = FrequencyRegularization ? (float) (RegU / Math.Sqrt(rated_items.Count)) : RegU; // perform training rated_items.Shuffle(); for (uint it = 0; it < NumIter; it++) for (int index = 0; index < rated_items.Count; index++) { int item_id = rated_items[index].Item1; // compute rating and error double score = global_bias + user_bias + item_bias[item_id] + DataType.MatrixExtensions.RowScalarProduct(item_factors, item_id, factors); double sig_score = 1 / (1 + Math.Exp(-score)); double prediction = min_rating + sig_score * rating_range_size; double err = rated_items[index].Item2 - prediction; float gradient_common = compute_gradient_common(sig_score, err); // adjust bias user_bias += BiasLearnRate * LearnRate * (gradient_common - BiasReg * reg_weight * user_bias); // adjust factors for (int f = 0; f < NumFactors; f++) { float u_f = factors[f]; float i_f = item_factors[item_id, f]; double delta_u = gradient_common * i_f - reg_weight * u_f; factors[f] += (float) (LearnRate * delta_u); } } var user_vector = new float[NumFactors + 1]; user_vector[FOLD_IN_BIAS_INDEX] = user_bias; Array.Copy(factors, 0, user_vector, FOLD_IN_FACTORS_START, NumFactors); return user_vector; }
/// protected override float[] FoldIn(IList<Tuple<int, float>> rated_items) { var user_p = new float[NumFactors]; user_p.InitNormal(InitMean, InitStdDev); float user_bias = 0; var items = (from pair in rated_items select pair.Item1).ToArray(); float user_reg_weight = FrequencyRegularization ? (float) (Regularization / Math.Sqrt(items.Length)) : Regularization; // compute stuff that will not change var y_sum_vector = y.SumOfRows(items); double norm_denominator = Math.Sqrt(items.Length); for (int f = 0; f < y_sum_vector.Count; f++) y_sum_vector[f] = (float) (y_sum_vector[f] / norm_denominator); rated_items.Shuffle(); for (uint it = 0; it < NumIter; it++) { for (int index = 0; index < rated_items.Count; index++) { int item_id = rated_items[index].Item1; double prediction = global_bias + user_bias + item_bias[item_id]; prediction += DataType.MatrixExtensions.RowScalarProduct(item_factors, item_id, y_sum_vector); prediction += DataType.MatrixExtensions.RowScalarProduct(item_factors, item_id, user_p); float err = (float) (rated_items[index].Item2 - prediction); // adjust bias user_bias += BiasLearnRate * LearnRate * ((float) err - BiasReg * user_reg_weight * user_bias); // adjust factors for (int f = 0; f < NumFactors; f++) { float u_f = user_p[f]; float i_f = item_factors[item_id, f]; double delta_u = err * i_f - user_reg_weight * u_f; user_p[f] += (float) (LearnRate * delta_u); } } } // assign final parameter values to return vector var user_vector = new float[NumFactors + 1]; user_vector[0] = user_bias; for (int f = 0; f < NumFactors; f++) user_vector[f + 1] = (float) y_sum_vector[f] + user_p[f]; return user_vector; }
public async Task BonusGenerateAsync(int count) { var connect = new SQLiteAsyncConnection(DataBaseFile); _bonuses = await connect.Table<BonusTable>().Take(count).ToListAsync(); _bonuses.Shuffle(); }
/// protected override float[] FoldIn(IList<Tuple<int, float>> rated_items) { SetupLoss(); float user_bias = 0; var items = (from pair in rated_items select pair.Item1).ToArray(); float user_reg_weight = FrequencyRegularization ? (float) (Regularization / Math.Sqrt(items.Length)) : Regularization; // compute stuff that will not change var y_sum_vector = y.SumOfRows(items); double norm_denominator = Math.Sqrt(items.Length); for (int f = 0; f < y_sum_vector.Count; f++) y_sum_vector[f] = (float) (y_sum_vector[f] / norm_denominator); rated_items.Shuffle(); for (uint it = 0; it < NumIter; it++) { for (int index = 0; index < rated_items.Count; index++) { int item_id = rated_items[index].Item1; double score = global_bias + user_bias + item_bias[item_id]; score += item_factors.RowScalarProduct(item_id, y_sum_vector); double sig_score = 1 / (1 + Math.Exp(-score)); double prediction = min_rating + sig_score * rating_range_size; float err = (float) (rated_items[index].Item2 - prediction); float gradient_common = compute_gradient_common(sig_score, err); // adjust bias user_bias += BiasLearnRate * LearnRate * ((float) gradient_common - BiasReg * user_reg_weight * user_bias); } } // assign final parameter values to return vector var user_vector = new float[NumFactors + 1]; user_vector[0] = user_bias; for (int f = 0; f < NumFactors; f++) user_vector[f + 1] = (float) y_sum_vector[f]; return user_vector; }
/// <summary>Compute parameters (latent factors) for a user represented by ratings</summary> /// <returns>a vector of latent factors</returns> /// <param name='rated_items'>a list of (item ID, rating value) pairs</param> protected virtual float[] FoldIn(IList<Pair<int, float>> rated_items) { var user_vector = new float[NumFactors]; user_vector.InitNormal(InitMean, InitStdDev); rated_items.Shuffle(); for (uint it = 0; it < NumIter; it++) { for (int index = 0; index < rated_items.Count; index++) { int item_id = rated_items[index].First; float err = rated_items[index].Second - Predict(user_vector, item_id, false); // adjust factors for (int f = 0; f < NumFactors; f++) { float u_f = user_vector[f]; float i_f = item_factors[item_id, f]; double delta_u = err * i_f - Regularization * u_f; user_vector[f] += (float) (LearnRate * delta_u); } } } return user_vector; }