public PinkNoise(IRandomGenerator randomGenerator, float rmsAmplitude)
        {
            if (null == randomGenerator)
                throw new ArgumentNullException("randomGenerator");

            _whiteGenerator = new NormalDistribution(randomGenerator, 0, RmsScale * rmsAmplitude);
        }

        public void GenerateData(CompanyEntities data, IRandomGenerator random, int count)
        {
            var allAddedEmployees = new List<Employee>();
            var departmentIds = data.Departments.Select(d => d.Id).ToList();

            for (int i = 0; i < count; i++)
            {
                var employee = new Employee
                                   {
                                       FirstName = random.GetRandomString(random.GetRandomNumber(5, 20)),
                                       LastName = random.GetRandomString(random.GetRandomNumber(5, 20)),
                                       Salary = random.GetRandomNumber(50000, 200000),
                                       DepartmentId =
                                           departmentIds[random.GetRandomNumber(0, departmentIds.Count - 1)]
                                   };

                if (allAddedEmployees.Count > 0 && random.GetRandomNumber(1, 100) <= 95)
                {
                    employee.Employee1 = allAddedEmployees[random.GetRandomNumber(0, allAddedEmployees.Count - 1)];
                }

                allAddedEmployees.Add(employee);
            }

            data.Employees.AddRange(allAddedEmployees);
        }

        public override void Initialize()
        {
            randomGenerator = GameServiceManager.GetService<IRandomGenerator>();
            ResetTimer();

            base.Initialize();
        }

 public void SetUp()
 {
     var builderSetup = new BuilderSettings();
     reflectionUtil = Substitute.For<IReflectionUtil>();
     generator = Substitute.For<IRandomGenerator>();
     propertyNamer = new RandomValuePropertyNamer(generator, reflectionUtil, false,builderSetup);
 }

        public override void Train(IList<InputOutput> trainingSet,
            IList<InputOutput> validationSet,
            IRandomGenerator rand,
            INeuralNetwork nn)
        {
            var prevWeightGradients = nn.Weights.DeepClone();

            foreach (var gradSet in prevWeightGradients)
            {
                for (var j = 0; j < gradSet.Length; j++)
                    gradSet[j] = 0;
            }

            for (var s = 0; s < NumEpochs; s++)
            {
                var t = rand.Next(trainingSet.Count);
                var inputOutput = trainingSet[t];

                var batch = GetBatch(trainingSet, BatchSize, rand);

                var gradients = nn.Weights.DeepCloneToZeros();

                for (var j = 0; j < BatchSize; j++)
                {
                    gradients.AddInPlace(
                        nn.CalculateGradients(batch[j].Input.AddRelativeNoise(MaxRelativeNoise, rand), batch[j].Output));
                }

                gradients.MultiplyInPlace(1 / ((double)BatchSize));

                //var gradients = nn.CalculateGradients(inputOutput.Input, inputOutput.Output);
                AdjustWeights(nn, gradients, prevWeightGradients);
                gradients.DeepCopyTo(prevWeightGradients);
            }
        }

        public void GenerateData(MongoDatabase db, IRandomGenerator random, int count)
        {
            string name;
            decimal price;
            int? upgradeToId;

            List<MongoUpgrade> mongoUpgrades = new List<MongoUpgrade>();

            for (int i = 0; i < count; i++)
            {
                name = random.GetRandomString(random.GetRandomNumber(5, 50));
                price = (decimal)(random.GetRandomNumber(10000, 1000000) / 100);
                upgradeToId = i;
                if(i % 4 == 0)
                {
                    upgradeToId = null;
                }

                var upgrade = new MongoUpgrade(name, price, upgradeToId);
                mongoUpgrades.Add(upgrade);
            }

            MongoCollection<MongoUpgrade> upgrades = db.GetCollection<MongoUpgrade>("Upgrades");
            upgrades.InsertBatch(mongoUpgrades);
        }

 public Player(IRandomGenerator generator, IBoard gameBoard, string name = "")
 {
     Generator = generator;
     GameBoard = gameBoard;
     Name = name;
     Position = 0;
 }

 public void Setup()
 {
     _udp = MockRepository.GenerateMock<IStatsdUDP>();
     _randomGenerator = MockRepository.GenerateMock<IRandomGenerator>();
     _randomGenerator.Stub(x => x.ShouldSend(Arg<double>.Is.Anything)).Return(true);
     _stopwatch = MockRepository.GenerateMock<IStopWatchFactory>();
 }

		/// <summary>
		/// Initializes a new instance of the DefaultFieldRandomizer class.
		/// </summary>
		/// <param name="randomGenerator">The random generator.</param>
		public DefaultFieldRandomizer(IRandomGenerator randomGenerator)
		{
			Validation.ThrowIfNull(randomGenerator);

			this._randomGenerator = randomGenerator;
			this._totalElementsInDirection = Enum.GetNames(typeof(Direction)).Length;
		}

        public void GenerateData(CompanyEntities data, IRandomGenerator random, int count)
        {
            var employeeIds = data.Employees.Select(e => e.Id).ToList();
            var projectIds = data.Projects.Select(p => p.Id).ToList();

            foreach (var employeeId in employeeIds)
            {
                var employeeProjectsCount = random.GetRandomNumber((int)(count * 0.5), (int)(count * 1.5));
                var currentProjects = new HashSet<int>();

                while (currentProjects.Count < employeeProjectsCount)
                {
                    var randomProjectId = projectIds[random.GetRandomNumber(0, projectIds.Count - 1)];
                    currentProjects.Add(randomProjectId);
                }

                foreach (var projectId in currentProjects)
                {
                    var endDateTimeSpan = random.GetRandomNumber(-500, 1000);
                    var startDateTimeSpan = endDateTimeSpan + random.GetRandomNumber(1, 500);

                    data.EmployeesInProjects.Add(new EmployeesInProject
                                                     {
                                                         EmployeeId = employeeId,
                                                         ProjectId = projectId,
                                                         StartDate = DateTime.Now.AddDays(-startDateTimeSpan),
                                                         EndDate = DateTime.Now.AddDays(-endDateTimeSpan)
                                                     });
                }
            }
        }

        public void GenerateData(CompanyEntities data, IRandomGenerator random, int count)
        {
            var employeeIds = data.Employees.Select(x => x.EmployeeId);
            var projectIds = data.Projects.Select(x => x.ProjectId).ToList();

            foreach (var employee in employeeIds)
            {
                var employeeProjects = random.GetRandomNumber((int)count / 2, (int)(count * 1.5));

                for (var i = 0; i < employeeProjects; i++)
                {
                    var projectId = projectIds[random.GetRandomNumber(1, projectIds.Count - 1)];

                    var startDate = DateTime.Now.AddDays(-random.GetRandomNumber(-500, 1000));
                    var endDate = startDate.AddDays(random.GetRandomNumber(1, 1234));

                    var employeeInProj = new Employees_Projects
                    {
                        ProjectId = projectId,
                        Startdate = startDate,
                        Enddate = endDate,
                        EmployeeId = employee
                    };

                    data.Employees_Projects.Add(employeeInProj);
                }
            }
        }

 public void GenerateData(CompanyEntities data, IRandomGenerator random, int count)
 {
     for (int i = 0; i < count; i++)
     {
         var project = new Project { Name = random.GetRandomString(random.GetRandomNumber(5, 50)) };
         data.Projects.Add(project);
     }
 }

 /// <summary>
 /// Returns a random number generator.
 /// </summary>
 /// <returns></returns>
 public static IRandomGenerator Get()
 {
     if (_generator == null)
     {
         _generator = new RandomGenerator();
     }
     return _generator;
 }

 public Roulette(IRandomGenerator randomGenerator)
 {
     if (RunningGames == null)
     {
         RunningGames = new Dictionary<string, Game>();
     }
     _randomGenerator = randomGenerator;
 }

 public Person(IRandomGenerator random, List<IGene> genes, bool isFemale)
 {
     _random = random;
     _personId = Guid.NewGuid();
     _age = 0;
     _isFemale = isFemale;
     _genes = genes;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Board" /> class.
 /// Board object containing multiple Balloon objects. The Board serves as the interface through which Balloons are accessed.
 /// </summary>
 /// <param name="rows">The max amount of rows the board will contain.</param>
 /// <param name="cols">The max amount of columns the board will contain.</param>
 /// <param name="randomGenerator">The random generator on which depends the balloons' randomness.</param>
 public Board(int rows, int cols, IRandomGenerator randomGenerator)
 {
     this.Rows = rows;
     this.Cols = cols;
     this.board = new IBalloon[this.Rows, this.Cols];
     this.RandomGenerator = randomGenerator;
     this.balloonFactory = new BalloonFactory();
     this.Fill();
 }

        public override void Initialize()
        {
            var health = ParentGameObject.GetComponent<IHealthComponent>();
            health.OnHealthDepleted += HealthOnOnHealthDepleted;

            randGen = GameServiceManager.GetService<IRandomGenerator>();
            
            base.Initialize();
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="GameField" /> class.
 /// </summary>
 /// <param name="random">Random generator.</param>
 /// <param name="mineFactory">Mine factory.</param>
 /// <param name="size">Size of the game field.</param>
 /// <param name="isExplosionChained">True if there is explosions chaining.</param>
 public GameField(IRandomGenerator random, IMineFactory mineFactory, int size, bool isExplosionChained = false)
 {
     this.random = random;
     this.mineFactory = mineFactory;
     this.field = new Cell[size, size];
     this.MinesCount = this.CalculateInitialMineCount();
     this.FillFieldWithEmptyCells();
     this.FillFieldMines();
     this.isExplosionChained = isExplosionChained;
 }

        public ReversedWindowGenerator(IRandomGenerator generator, int windowSize)
        {
            if (generator == null)
                throw new ArgumentNullException("generator");
            if (windowSize < 2)
                throw new ArgumentException(@"Window size must be at least 2", "windowSize");

            _generator = generator;
            _window = new byte[windowSize];
        }

        //========================= Misc public helpers =========================
        public static void InitializeWeights(INeuralNetwork nn, IRandomGenerator rand)
        {
            var weights = nn.Weights;

            foreach (var weightsSubList in weights)
            {
                for (int i = 0; i < weightsSubList.Length; i++)
                    weightsSubList[i] = rand.NextDouble() - 0.5;
            }
        }