public void GeneticCrossOver() { if (simManager.genNum == 1) // If this is the first generation { return; } int[] parentIndexes = SelectParents(); basicLayer = simManager.lastSquares[parentIndexes[0]].basicLayer; // Copy one parent's neural network layer to the new one's if (basicLayer == null) //parentIndexes[0] < 10) { print(parentIndexes[0] + ", " + simManager.lastSquares[parentIndexes[0]].id + ", " + simManager.lastSquares[parentIndexes[0]].basicLayer[0, 0]); } for (int i = 0; i < basicLayer.GetLength(0); i++) { for (int j = 0; j < basicLayer.GetLength(1); j++) { if (BetterRandom.betterRandom(0, 1000000) / 1000000f <= SimulationManager.sCrossOverRate) // Cross over { basicLayer[i, j] = simManager.lastSquares[parentIndexes[1]].basicLayer[i, j]; } } } }
public string ThrowGrenade() { var eligableHalls = _halls.Where(hall => !hall.PartOfTree && !hall.IsDestroyed).ToList(); if (!eligableHalls.Any()) { return("You fear the whole dungeon would collapse if you threw another grenade."); } var destroyed = 0; while (destroyed < Math.Min(15, eligableHalls.Count) && eligableHalls.Count > 0) { var index = new BetterRandom().Next(eligableHalls.Count); eligableHalls[index].IsDestroyed = true; eligableHalls.RemoveAt(index); destroyed++; } // Kill enemy Player.Position.Enemy = null; DrawCompassRoute(); return("You hear a trembling in the distance, a part of the dungeon has collapsed."); }
/// <summary> /// Randomly generate a new enemy type with a certain total power /// 1: move /// 2: hp /// 3: power /// 4: range /// </summary> /// <param name="totalPower"></param> /// <returns></returns> public EnemyTypeInfo CreateNewEnemyType(int totalPower) { EnemyTypeInfo newTypeInfo = new EnemyTypeInfo(); int[] abilityStrength = { maxEnemyMoveRange, maxEnemyMaxHealth, maxEnemyAttackPower, maxEnemyAttackRange }; int[] minAbilityStrength = { minEnemyMoveRange, minEnemyMaxHealth, minEnemyAttackPower, minEnemyAttackRange }; int targetDifference = maxEnemyMoveRange + maxEnemyMaxHealth + maxEnemyAttackPower + maxEnemyAttackRange - totalPower; // Reduce ability strength to match total power while (targetDifference > 0) { int ability = BetterRandom.betterRandom(0, abilityStrength.Length - 1); // If strength can be decreased if (abilityStrength[ability] > minAbilityStrength[ability]) { abilityStrength[ability]--; targetDifference--; } } newTypeInfo.moveRange = abilityStrength[0]; newTypeInfo.maxHealth = abilityStrength[1]; newTypeInfo.attackPower = abilityStrength[2]; newTypeInfo.attackRange = abilityStrength[3]; return(newTypeInfo); }
private double GetRandomGen() { BetterRandom random = new BetterRandom(); return(random.Range(genMin, genMax)); //return Random.Range(genMin, genMax); }
public void RandomVector(ref Vector3 start, ref Vector3 end, float offsetAmount, out Vector3 result) { if (orthographic) { Vector3 directionNormalized = (end - start).normalized; Vector3 side = new Vector3(-directionNormalized.y, directionNormalized.x, directionNormalized.z); //float distance = ((float)RandomGenerator.NextDouble() * offsetAmount * 2.0f) - offsetAmount; float distance = ((float)BetterRandom.betterRandom(0, 1000000) / 1000000f * offsetAmount * 2.0f) - offsetAmount; result = side * distance; } else { Vector3 directionNormalized = (end - start).normalized; Vector3 side; GetPerpendicularVector(ref directionNormalized, out side); // generate random distance //float distance = (((float)RandomGenerator.NextDouble() + 0.1f) * offsetAmount); float distance = (((float)BetterRandom.betterRandom(0, 1000000) / 1000000f + 0.1f) * offsetAmount); // get random rotation angle to rotate around the current direction //float rotationAngle = ((float)RandomGenerator.NextDouble() * 360.0f); float rotationAngle = ((float)BetterRandom.betterRandom(0, 1000000) / 1000000f * 360.0f); // rotate around the direction and then offset by the perpendicular vector result = Quaternion.AngleAxis(rotationAngle, directionNormalized) * side * distance; } }
public ActionResult CreateRandomOrder(OrderInfoDTO orderInfoDTO) { IRestResponse <OrderResponseDTO> response = null; var toppings = _distributedPizzaDbContext.Toppings.ToList(); BetterRandom random = new BetterRandom(); for (int i = 0; i < orderInfoDTO.NumberOfRequests; i++) { var orderManager = new OrderManager(toppings, random); var order = orderManager.GenerateRandomOrder(); order.QueueType = orderInfoDTO.QueueType; order.ReportBackToClient = orderInfoDTO.NumberOfRequests == 1; var client = new RestClient("http://localhost/DistributedPizza.Web.Api"); var request = new RestRequest("api/orders/create", Method.POST); request.AddHeader("Accept", "application/json"); request.RequestFormat = DataFormat.Json; request.AddBody(order); response = client.Execute <OrderResponseDTO>(request); } if (orderInfoDTO.NumberOfRequests == 1 & response != null) { response.Data.NumberOfRequests = orderInfoDTO.NumberOfRequests; return(Json(response.Data)); } else { return(Json(new OrderResponseDTO { NumberOfRequests = orderInfoDTO.NumberOfRequests })); } }
public static double RandomNext() { double one = BetterRandom.NextDouble(); double two = BetterRandom.NextDouble(); return(Math.Sqrt(-2.0 * Math.Log(one)) * Math.Cos(6.2831853071795862 * two)); }
/// <summary> /// Get the win condition for current game /// </summary> public void GetWinCondition() { int requiredEvolvePower = BetterRandom.betterRandom(11, 15); int powerDifference = 16 - requiredEvolvePower; int[] targetAbilityPowers = { 4, 4, 4, 4 }; while (powerDifference > 0) { int ability = BetterRandom.betterRandom(0, 3); if (targetAbilityPowers[ability] > 0) { targetAbilityPowers[ability]--; powerDifference--; } } gameGoal.maxHealth = playerUnitInitialMaxHealth + targetAbilityPowers[0]; gameGoal.moveRange = playerUnitInitialMoveRange + targetAbilityPowers[1]; gameGoal.attackPower = playerUnitInitialAttackPower + targetAbilityPowers[2]; gameGoal.attackRange = playerUnitInitialAttackRange + targetAbilityPowers[3]; gameGoal.CreateCloneLook(); gameGoal.health = 0; // Hide health bar }
private static IEnumerable <StatementSyntax> FindRandomExtractableCode(BaseMethodDeclarationSyntax extractFrom) { var statementsCount = extractFrom.Body.Statements.Count; var startingPosition = BetterRandom.Between(0, statementsCount - 2); var depth = BetterRandom.Between(1, statementsCount - startingPosition - 1); var constraint = startingPosition + depth; if (statementsCount < constraint) { throw new ArgumentOutOfRangeException($"startingPosition = {startingPosition}, depth = {depth}"); } var returnNodes = new List <StatementSyntax>(); for (var i = startingPosition; i < constraint; i++) { var node = extractFrom.Body.Statements[i]; if (node != null) { returnNodes.Add(node); } } return(returnNodes); }
public void PlaySFXOneShot(AudioClip sfx) { sfxPlayer.Stop(); float k = BetterRandom.betterRandom(-100, 100) / 1000;// avoid machine gun sound sfxPlayer.volume = masterVolume + masterVolume * k; sfxPlayer.PlayOneShot(sfx); }
/// <summary> /// Place down enemy units /// </summary> public void PlaceNewEnemies() { // Get a list of empty map border tiles List <GridTileInfo> emptyBorderTiles = MapManager.sMapManager.GetEmptyBorderTiles(); // Get number of enemies to be generated int maxEnemyAmount = Mathf.Clamp(Mathf.FloorToInt(GameManager.playerTotalPower / EnemyManager.minEnemyPower), 0, emptyBorderTiles.Count); int minEnemyAmount = Mathf.Clamp(Mathf.CeilToInt(GameManager.playerTotalPower / EnemyManager.maxEnemyPower), 1, maxEnemyAmount); // Make sure there is at least one enemy being generated int enemyAmount = BetterRandom.betterRandom(minEnemyAmount, maxEnemyAmount); // Get individual power for each enemy int[] individualEnemyPower = new int[enemyAmount]; for (int i = 0; i < individualEnemyPower.Length; i++) { individualEnemyPower[i] = EnemyManager.maxEnemyPower; } int powerDifference = enemyAmount * EnemyManager.maxEnemyPower - GameManager.playerTotalPower; // Get power difference while (powerDifference > 0) // Randomly decrease enemy power { int selectedEnemy = BetterRandom.betterRandom(0, individualEnemyPower.Length - 1); // Randomly select an enemy // Decrement selected enemy power if it has not reached minEnemyPower if (individualEnemyPower[selectedEnemy] > EnemyManager.minEnemyPower) { individualEnemyPower[selectedEnemy]--; powerDifference--; } } // Assign spawn positions List <int> spawnPosition = new List <int>(); for (int i = 0; i < enemyAmount; i++) { int newPosition = BetterRandom.betterRandom(0, emptyBorderTiles.Count - 1); while (spawnPosition.Contains(newPosition)) { newPosition = BetterRandom.betterRandom(0, emptyBorderTiles.Count - 1); } spawnPosition.Add(newPosition); } // Create new enemies for (int i = 0; i < enemyAmount; i++) { EnemyManager.sEnemyManager.CreateEnemy(EnemyManager.sEnemyManager.CreateNewEnemyType(individualEnemyPower[i]), emptyBorderTiles[spawnPosition[i]].xCoord, emptyBorderTiles[spawnPosition[i]].zCoord); } // Test //EnemyManager.sEnemyManager.CreateEnemy(EnemyManager.EnemyType.Test, 4, 4); }
void Awake() { betterRandom = new BetterRandom(); if (instance == null) { instance = this; } else if (instance != this) { Destroy(gameObject); } }
public float[] Noise(float frequency) // Generate a shifted sine wave { float[] newWave = new float[actualTerrainSize]; float phaseShift = BetterRandom.betterRandom(0, Mathf.RoundToInt(20000000 * Mathf.PI)) / 10000000f; for (int i = 0; i < map.GetLength(0); i++) { newWave[i] = Mathf.Sin(2 * Mathf.PI * frequency * i / actualTerrainSize + phaseShift); } return(newWave); }
public static List <double> RandomDoubles(int length) { Random r = BetterRandom.NewRandom(); var result = new List <double>(length); double multiplier = Math.Pow(10.0, Math.Floor(Math.Log10(length) + 1.0)); for (int i = 0; i < length; i++) { result.Add(Math.Floor(r.NextDouble() * multiplier)); } return(result); }
public void Start() { offsetX = Random.Range(0, 99999); offsetY = Random.Range(0, 99999); Random.InitState(System.DateTime.Now.Millisecond); randomGradientVector2D = new Vector2[width, height]; for (int i = 0; i < width; i++) { for (int j = 0; j < height; j++) { //randomGradientVector2D[i, j] = new Vector2(Random.Range(-0.5f, 0.5f), Random.Range(-0.5f, 0.5f)); //print(randomGradientVector2D[i, j]); do { randomGradientVector2D[i, j] = new Vector2(BetterRandom.betterRandom(-50000, 50000) / 100000f, BetterRandom.betterRandom(-50000, 50000) / 100000f); } while (randomGradientVector2D[i, j].x == 0 || randomGradientVector2D[i, j].y == 0 || randomGradientVector2D[i, j].x == randomGradientVector2D[i, j].y); } } do { randomVector = new Vector2(BetterRandom.betterRandom(-10000000, 10000000) / 100000f, BetterRandom.betterRandom(-10000000, 10000000) / 100000f); } while (randomVector.x == 0 || randomVector.y == 0 || randomVector.x == randomVector.y); randomSinMulti = BetterRandom.betterRandom(10000, 100000) + (BetterRandom.betterRandom(1000000, 10000000) / 10000000f); //randomSinMulti = 1; randomWarpStartCoords = new Vector2[20]; for (int i = 0; i < 10; i++) // Generate random start coorinations for each warping { randomWarpStartCoords[i] = new Vector2(BetterRandom.betterRandom(0, 1000) / 100f, BetterRandom.betterRandom(0, 1000) / 100f); randomWarpStartCoords[i + 10] = new Vector2(BetterRandom.betterRandom(0, 1000) / 100f, BetterRandom.betterRandom(0, 1000) / 100f); } terrain = GetComponent <Terrain>(); //for Terrain Data terrain.terrainData.heightmapResolution = width; terrain.terrainData.alphamapResolution = width; terrain.terrainData.size = new Vector3(width, depth, height); map = new float[width, height]; // Storing the heightmap data (for the noise combination) if (useAlone) { terrain.terrainData = GenerateTerrain(terrain.terrainData); } else if (!useAlone) { terrain.terrainData = GenerateTerrain(terrain.terrainData); map = GenerateHeights(); // Storing the heightmap data (for the noise combination) } domainWarpingFBM = GetComponent <DomainWarpingFBM>(); }
public IHttpActionResult Post(OrderDTO orderDTO) { Order order = _mapper.Map <OrderDTO, Order>(orderDTO); order.Status = Status.Started; order.CreateDate = DateTime.Now; BetterRandom random = new BetterRandom(); var toppings = _distributedPizzaDbContext.Toppings.ToList(); var orderManager = new OrderManager(toppings, random); order.OrderReferenceId = GetNextSeqAPI(); //order.OrderReferenceId = Guid.NewGuid().ToString(); foreach (var pizza in order.Pizza) { int toppingsTogenerate = random.Next(1, 3); for (var x = 0; x < toppingsTogenerate; x++) { int index = random.Next(toppings.Count); var topping = toppings[index]; pizza.Toppings.Add(topping); } } _distributedPizzaDbContext.Orders.Add(order); _distributedPizzaDbContext.SaveChanges(); IStreamProcessingQueue queue; switch (order.QueueType) { case QueueType.Kafka: queue = new KafkaStreamProcessing(); break; case QueueType.AmazonSQS: queue = new AmazonSQSProcessingQueue(); break; default: queue = new KafkaStreamProcessing(); break; } queue.QueueOrder(order); return(Ok(new OrderResponseDTO { OrderReferenceId = order.OrderReferenceId })); }
public void GenerateRandomCustomer() { var random = new BetterRandom(); var customerManager = new CustomerManager(random); List <Customer> customers = new List <Customer>(); for (var x = 0; x < 9; x++) { var customer = customerManager.GetRandomCustomer(random.Next(0, 6)); customers.Add(customer); } var count = customers.Count; }
public void GenerateRandomOrder() { IKernel _Kernal = new StandardKernel(); _Kernal.Load(Assembly.GetExecutingAssembly()); IDistributedPizzaDbContext dbContext = _Kernal.Get <DistributedPizzaDbContext>(); var toppings = dbContext.Toppings.ToList(); BetterRandom random = new BetterRandom(); var orderManager = new OrderManager(toppings, random); var order = orderManager.GenerateRandomOrder(); var order2 = orderManager.GenerateRandomOrder(); }
/// <summary> /// Set start point and exit point randomly /// </summary> private void SetRandomStartAndExit() { while (true) { startPointXcoord = BetterRandom.betterRandom(0, currentLevel.width - 1); startPointYcoord = BetterRandom.betterRandom(0, currentLevel.height - 1); //get a random start point exitPointXcoord = BetterRandom.betterRandom(0, currentLevel.width - 1); exitPointYcoord = BetterRandom.betterRandom(0, currentLevel.height - 1); //get a random exit point if (startPointXcoord != exitPointXcoord || startPointYcoord != exitPointYcoord) { break;//check if player was born at exit } } }
public DNA(int size, Func <T> getRandomGene, Func <int, float> fitnessFunction, bool shouldInitGenes = true) { Genes = new T[size]; this.getRandomGene = getRandomGene; this.fitnessFunction = fitnessFunction; betterRandom = new BetterRandom(); if (shouldInitGenes) { for (int i = 0; i < Genes.Length; i++) { Genes[i] = getRandomGene(); } } }
private void SelectOffsetFromAnimationMode() { int index; if (AnimationMode == LightningBoltAnimationMode.None) { lineRenderer.material.mainTextureOffset = offsets[0]; return; } else if (AnimationMode == LightningBoltAnimationMode.PingPong) { index = animationOffsetIndex; animationOffsetIndex += animationPingPongDirection; if (animationOffsetIndex >= offsets.Length) { animationOffsetIndex = offsets.Length - 2; animationPingPongDirection = -1; } else if (animationOffsetIndex < 0) { animationOffsetIndex = 1; animationPingPongDirection = 1; } } else if (AnimationMode == LightningBoltAnimationMode.Loop) { index = animationOffsetIndex++; if (animationOffsetIndex >= offsets.Length) { animationOffsetIndex = 0; } } else { //index = RandomGenerator.Next(0, offsets.Length); index = BetterRandom.betterRandom(0, offsets.Length); } if (index >= 0 && index < offsets.Length) { lineRenderer.material.mainTextureOffset = offsets[index]; } else { lineRenderer.material.mainTextureOffset = offsets[0]; } }
public void GeneticMutation() { for (int i = 0; i < basicLayer.GetLength(0); i++) { for (int j = 0; j < basicLayer.GetLength(1); j++) { if (BetterRandom.betterRandom(0, 100000000) / 100000000f <= SimulationManager.sMutationRate) // Mutate { basicLayer[i, j] = BetterRandom.betterRandom(SimulationManager.sMinWeightValue * 10000, SimulationManager.sMaxWeightValue * 10000) / 10000f; } else if (simManager.genNum == 1) // If this is the first generation { basicLayer[i, j] = BetterRandom.betterRandom(SimulationManager.sMinWeightValue * 10000, SimulationManager.sMaxWeightValue * 10000) / 10000f; } } } }
public int[] SelectParents() { int[] parentIndexes = new int[2]; // Index in square array for parent A and B float totalFitness = 0; for (int i = 0; i < simManager.lastSquares.Length; i++) // Add up total fitness { totalFitness += simManager.lastSquares[i].fitnessScore; } // Select first parent float parent = BetterRandom.betterRandom(0, Mathf.RoundToInt(totalFitness * 10000)) / 10000f; float selector = 0; for (int i = 0; i < simManager.lastSquares.Length; i++) { selector += simManager.lastSquares[i].fitnessScore; if (selector >= parent) { parentIndexes[0] = i; break; } } // Select second parent parentIndexes[1] = parentIndexes[0]; while (parentIndexes[1] == parentIndexes[0]) { parent = BetterRandom.betterRandom(0, Mathf.RoundToInt(totalFitness * 10000)) / 10000f; selector = 0; for (int i = 0; i < simManager.lastSquares.Length; i++) { selector += simManager.lastSquares[i].fitnessScore; if (selector >= parent) { parentIndexes[1] = i; break; } } } return(parentIndexes); }
public static double RandomInDiscrete(List <double> probabilities) { double r = BetterRandom.NewRandom().NextDouble(); double sum = 0.0; double result; for (int i = 0; i < probabilities.Count; i++) { sum += probabilities[i]; if (sum >= r) { result = i; return(result); } } result = -1.0; return(result); }
public void GenerateMap() { for (int f = 0; f < frequencies.Length; f++) { for (int c = 0; c < counts[f]; c++) { float phaseShift = BetterRandom.betterRandom(0, Mathf.RoundToInt(20000000 * Mathf.PI)) / 10000000f; int centerI = BetterRandom.betterRandom(0, actualTerrainSize - 1); int centerJ = BetterRandom.betterRandom(0, actualTerrainSize - 1); for (int i = 0; i < actualTerrainSize; i++) { for (int j = 0; j < actualTerrainSize; j++) { map[i, j] += (Mathf.Sin(Mathf.Pow(Mathf.Pow(2 * Mathf.PI * frequencies[f] * (i - centerI) / actualTerrainSize + phaseShift, 2) + Mathf.Pow(2 * Mathf.PI * frequencies[f] * (j - centerJ) / actualTerrainSize + phaseShift, 2), 0.5f)) * amplitudes[f]) / (float)counts[f]; } } } } for (int i = 0; i < frequencies.Length; i++) // Calculating the scale of the height map { heightScale += amplitudes[i]; // * counts[i]; } for (int i = 0; i < actualTerrainSize; i++) // Normalize height map data to a scale of 1 { for (int k = 0; k < actualTerrainSize; k++) { map[k, i] /= heightScale; } } for (int i = 0; i < actualTerrainSize; i++) // Convert negative value to positive { for (int k = 0; k < actualTerrainSize; k++) { map[k, i] = Mathf.Abs(map[k, i]); } } }
public void CreateChild_Given2DifferentParents_ReturnsAChild() { var random = new BetterRandom(1); var childFactory = new ChildFactory(new BiologyFactory(new Blender(random, 1, 2, 1), random)); var fathersBiology = new Biology(Sex.Male, 81.0m, 182.88m, new Color(42, 42, 9), new Color(42, 42, 0), new Color(210, 210, 155), 180, 90, 80); var father = new Person(null, null, fathersBiology); var mothersBiology = new Biology(Sex.Female, 54m, 165m, new Color(230, 230, 90), new Color(5, 135, 60), new Color(210, 185, 120), 130, 150, 130); var mother = new Person(null, null, mothersBiology); var child = childFactory.CreateChild(father, mother); Assert.IsType <Person>(child); Assert.NotNull(child); }
public GeneticAlgorithm(int populationSize, int dnaSize, Func <T> getRandomGene, Func <int, float> fitnessFunction, int elitism, float mutationRate = 0.01f) { Generation = 1; Elitism = elitism; MutationRate = mutationRate; Population = new List <DNA <T> >(populationSize); newPopulation = new List <DNA <T> >(populationSize); this.dnaSize = dnaSize; this.getRandomGene = getRandomGene; this.fitnessFunction = fitnessFunction; betterRandom = new BetterRandom(); BestGenes = new T[dnaSize]; for (int i = 0; i < populationSize; i++) { Population.Add(new DNA <T>(dnaSize, getRandomGene, fitnessFunction, shouldInitGenes: true)); } }
public float[,] map; // Storing the heightmap data (for the noise combination) public void Start() { offsetX = Random.Range(0, 99999); offsetY = Random.Range(0, 99999); do { randomVector2D = new Vector2(BetterRandom.betterRandom(-10000000, 10000000) / 100000f, BetterRandom.betterRandom(-10000000, 10000000) / 100000f); } while (randomVector2D.x == 0 || randomVector2D.y == 0 || randomVector2D.x == randomVector2D.y); randomSinMulti = BetterRandom.betterRandom(10000, 100000) + (BetterRandom.betterRandom(1000000, 10000000) / 10000000f); if (!useAlone) { map = new float[width, height]; // Storing the heightmap data (for the noise combination) map = GenerateHeights(); // Storing the heightmap data (for the noise combination) Terrain terrain = GetComponent <Terrain>(); //for Terrain Data terrain.terrainData = GenerateTerrain(terrain.terrainData); } }
public void IfMakeNewPlatform() // Should we make new platforms? (new random seed) { avgBestTime = 0; for (int i = 0; i < bestSquares.Length; i++) // Add up best fitness scores { avgBestTime += bestSquares[i].timeBeforeDrop; } avgBestTime /= (float)bestSquares.Length; // Take the average if (avgBestTime >= cycleDuration * 0.75f) // If the average fitness score is greater than some value then get new random seed { randomSeed = BetterRandom.betterRandom(0, Mathf.RoundToInt(Mathf.Infinity)); Random.InitState(randomSeed); for (int i = 0; i < bestSquares.Length; i++) // Decrease every best squares' fitness score from the last platform layout { bestSquares[i].timeBeforeDrop = 0; bestSquares[i].fitnessScore *= 0.8f; } } }
/// <summary> /// Randomizes the list, be arbitrarily reordering /// sublists of stride elements. As the stride approaches /// the size of the list, the options become very /// limited. /// </summary> /// <remarks> /// This could take a while for very large list /// sizes. /// </remarks> public LSL_List llListRandomize(LSL_List src, int stride) { LSL_List result; BetterRandom rand = new BetterRandom(); int chunkk; int[] chunks; m_host.AddScriptLPS(1); if (stride <= 0) { stride = 1; } // Stride MUST be a factor of the list length // If not, then return the src list. This also // traps those cases where stride > length. if (src.Length != stride && src.Length % stride == 0) { chunkk = src.Length/stride; chunks = new int[chunkk]; for (int i = 0; i < chunkk; i++) { chunks[i] = i; } // Knuth shuffle the chunkk index for (int i = chunkk - 1; i > 0; i--) { // Elect an unrandomized chunk to swap int index = rand.Next(i + 1); // and swap position with first unrandomized chunk int tmp = chunks[i]; chunks[i] = chunks[index]; chunks[index] = tmp; } // Construct the randomized list result = new LSL_List(); for (int i = 0; i < chunkk; i++) { for (int j = 0; j < stride; j++) { result.Add(src.Data[chunks[i] * stride + j]); } } } else { object[] array = new object[src.Length]; Array.Copy(src.Data, 0, array, 0, src.Length); result = new LSL_List(array); } return result; }
public static int RandomInUniform(int a) { Random r = BetterRandom.NewRandom(); return((int)(r.NextDouble() * a)); }