public void FloatBits_TEST()
{
Xorshift random = new Xorshift(Seed);
for (int i = 0; i < 100000; ++i)
{
double value = random.Uniform(-1.0e+9, 1.0e+9);
var enc = new Float64Bits(value);
var ms = new MemoryStream();
enc.Write(ms);
var dec = new Float64Bits(ms.ToArray(), 0);
// perfect equal
Assert.AreEqual(dec.Value, value);
}
for (int i = 0; i < 100000; ++i)
{
float value = (float)random.Uniform(-1.0e+6, 1.0e+6);
var enc = new Float32Bits(value);
var ms = new MemoryStream();
enc.Write(ms);
var dec = new Float32Bits(ms.ToArray(), 0);
// perfect equal
Assert.AreEqual(dec.Value, value);
}
}
public void Plist_Binary_TEST()
{
Xorshift random = new Xorshift(Seed);
// Trailer
for (int i = 0; i < 100000; ++i)
{
var trailer = new Plist.Trailer();
trailer.ShortVersion = (byte)(random.Generate() & 0xFF);
trailer.OffsetIntSize = (byte)(random.Generate() & 0xFF);
trailer.ObjectRefSize = (byte)(random.Generate() & 0xFF);
trailer.NumObjects = (ulong)random.Generate() | ((ulong)random.Generate() << 32);
trailer.TopObject = (ulong)random.Generate() | ((ulong)random.Generate() << 32);
trailer.OffsetTableOffset = (ulong)random.Generate() | ((ulong)random.Generate() << 32);
var ms = new MemoryStream();
Plist.WriteTrailerBinary(ms, trailer);
var read = Plist.ReadTrailerBinary(ms.ToArray());
Assert.AreEqual(trailer.GetHashCode(), read.GetHashCode());
Assert.AreEqual(trailer, read);
}
for (int i = 0; i < 5000; ++i)
{
object value1 = Arbitrary.Plist();
var data = Plist.WriteObjectBinary(value1);
object value2 = Plist.ReadObjectBinary(data);
Assert.IsTrue(Plist.EqualObject(value1, value2, 1.0e-9, 1.0e-3), string.Format("serialize error [{0}]", i));
}
}
public void Plist_XML_TEST()
{
Xorshift random = new Xorshift(Seed);
for (int i = 0; i < 1000; ++i)
{
object value1 = Arbitrary.Plist();
var data = Plist.WriteObjectXML(value1);
object value2 = Plist.ReadObjectXML(data);
Assert.IsTrue(Plist.EqualObject(value1, value2, 1.0e-9, 1.5), string.Format("serialize error [{0}]", i));
}
}
public T Operator(Xorshift xorshift)
{
if (xorshift == null)
{
throw new ArgumentNullException(nameof(xorshift));
}
xorshift.ThrowIfDisposed();
this.ThrowIfDisposed();
return(this._Implement.Operator(this.NativePtr, xorshift.NativePtr));
}
/// <summary>
/// パーリンノイズ用のグリッドを生成する
/// </summary>
/// <returns></returns>
static public int[] CreateGrid(int seed)
{
Xorshift xorshift = new Xorshift((uint)seed);
int[] p = new int[256];
for (int i = 0; i < p.Length; i++)
{
p[i] = (int)Mathf.Floor(xorshift.Random() * 256);
}
int[] p2 = new int[512];
for (int i = 0; i < p2.Length; i++)
{
p2[i] = p[i & 255];
}
return(p2);
}
public PerlinNoise(uint seed)
{
_xorshift = new Xorshift(seed);
int[] p = new int[256];
for (int i = 0; i < p.Length; i++)
{
p[i] = (int)Mathf.Floor(_xorshift.Random() * 256);
}
int[] p2 = new int[512];
for (int i = 0; i < p2.Length; i++)
{
p2[i] = p[i & 255];
}
_p = p2;
}
public void BigEndianIO_TEST()
{
for (int i = 0; i <= ushort.MaxValue; ++i)
{
ushort value = (ushort)i;
var ms = new MemoryStream();
BigEndianWriter.WriteUShort(ms, value);
ushort read1 = BigEndianReader.ReadUShort(ms.ToArray(), 0);
Assert.AreEqual(read1, value);
ulong read2 = BigEndianReader.ReadNBytesUnsignedInteger(ms.ToArray(), 2, 0);
Assert.IsTrue(read2 <= ushort.MaxValue);
Assert.AreEqual((ushort)read2, value);
}
Xorshift random = new Xorshift(Seed);
for (int i = 0; i < 100000; ++i)
{
uint value = random.Generate();
var ms = new MemoryStream();
BigEndianWriter.WriteUInt(ms, value);
uint read1 = BigEndianReader.ReadUInt(ms.ToArray(), 0);
Assert.AreEqual(read1, value);
ulong read2 = BigEndianReader.ReadNBytesUnsignedInteger(ms.ToArray(), 4, 0);
Assert.IsTrue(read2 <= uint.MaxValue);
Assert.AreEqual((uint)read2, value);
}
for (int i = 0; i < 100000; ++i)
{
ulong value = (ulong)random.Generate() | ((ulong)random.Generate() << 32);
var ms = new MemoryStream();
BigEndianWriter.WriteULong(ms, value);
ulong read1 = BigEndianReader.ReadULong(ms.ToArray(), 0);
Assert.AreEqual(read1, value);
ulong read2 = BigEndianReader.ReadNBytesUnsignedInteger(ms.ToArray(), 8, 0);
Assert.AreEqual(read2, value);
}
}
/// <summary>
/// Constructor
/// </summary>
public PerlinNoise(uint seed)
{
_xorshit = new Xorshift(seed);
int[] p = new int[256];
for (int i = 0; i < p.Length; i++)
{
// 0 - 255の間のランダムな値を生成する
p[i] = (int)Mathf.Floor(_xorshit.Random() * 256);
}
// pの倍の数の配列を生成する
int[] p2 = new int[p.Length * 2];
for (int i = 0; i < p2.Length; i++)
{
p2[i] = p[i & 255];
}
_p = p2;
}
public Vector2[] GetPointsFromGameCollider()
{
if (collider2D == null)
{
return(null);
}
if (collider2D is PolygonCollider2D)
{
return(((PolygonCollider2D)collider2D).points);
}
if (collider2D is BoxCollider2D)
{
var boxCollider2D = (BoxCollider2D)collider2D;
Vector2[] ret = new Vector2[4];
Vector2 leftBottom = boxCollider2D.offset - boxCollider2D.size / 2;;
Vector2 rightTop = boxCollider2D.offset + boxCollider2D.size / 2;
ret[0] = leftBottom;
ret[1] = new Vector2(leftBottom.x, rightTop.y);
ret[2] = rightTop;
ret[3] = new Vector2(rightTop.x, leftBottom.y);
return(ret);
}
Xorshift xorShift = new Xorshift(1234);
if (collider2D is CircleCollider2D)
{
var circleCollider2D = (CircleCollider2D)collider2D;
int split = 30;
Vector2[] ret = new Vector2[split];
for (int i = 0; i < split; i++)
{
float angle = -Mathf.PI * 2 * i / split;
float radius = circleCollider2D.radius;
ret[i] = (new Vector2(Mathf.Cos(angle), Mathf.Sin(angle))) * (radius * (xorShift.Range(995, 1005) / 1000.0f)) + circleCollider2D.offset;
}
return(ret);
}
return(null);
}
public void DenseGraphCheck()
{
const uint N = 500;
using var a = new Dense <double>(N);
using var r = new Xorshift(1234);
using var urd = new StdUniformRealDistribution <double>(-10, 10);
for (uint i = 0; i < N; i++)
{
for (uint j = i; j < N; j++)
{
a.J[i, j] = urd.Operator(r);
}
}
using var r2 = new Xorshift(1234);
// check if graph holds correct variables
for (uint i = 0; i < N; i++)
{
for (uint j = i; j < N; j++)
{
Assert.Equal(a.J[i, j], urd.Operator(r2));
}
}
using var r3 = new Xorshift(1234);
// check if graph index is reversible (Jij = Jji)
for (uint i = 0; i < N; i++)
{
for (uint j = i; j < N; j++)
{
Assert.Equal(a.J[j, i], urd.Operator(r3));
}
}
}
/// <summary>
/// 初期化処理
/// </summary>
private void Initialize()
{
int seed = Mathf.Clamp(_seed, 0, 2 << 30 - 1);
_xorshift = new Xorshift((uint)seed);
_p = CreateGrid();
_particleNumPerMesh = MAX_VERTEX_NUM / _mesh.vertexCount;
_meshNum = (int)Mathf.Ceil((float)_maxParticleNum / _particleNumPerMesh);
for (int i = 0; i < _meshNum; i++)
{
Material material = new Material(_shader);
material.SetInt("_IdOffset", _particleNumPerMesh * i);
_materials.Add(material);
}
_combinedMesh = CreateCombinedMesh(_mesh, _particleNumPerMesh);
_particles = new ComputeBuffer(_maxParticleNum, Marshal.SizeOf(typeof(Particle)));
Particle[] particles = GenerateParticles();
_particles.SetData(particles);
_renderTexture = new RenderTexture(256, 256, 0);
_renderTexture.enableRandomWrite = true;
_renderTexture.useMipMap = false;
_renderTexture.Create();
Renderer ren = _quad.GetComponent <Renderer>();
_material = ren.material;
_material.mainTexture = _renderTexture;
_kernelIndex = _computeShader.FindKernel("CurlNoiseMain");
_kernelIndex2 = _computeShader.FindKernel("OutputResult");
}
public void StaticSamplesConsistent()
{
Assert.That(Xorshift.Doubles(1000, 1), Is.EqualTo(new Xorshift(1).NextDoubles(1000)).Within(1e-12).AsCollection);
}
public void SparseGraphCheck()
{
const uint N = 500;
using var b = new Sparse <double>(N, N - 1);
using var r = new Xorshift(1234);
using var urd = new StdUniformRealDistribution <double>(-10, 10);
for (uint i = 0; i < N; i++)
{
for (uint j = i + 1; j < N; j++)
{
b.J[i, j] = urd.Operator(r);
}
}
using var r2 = new Xorshift(1234);
// check if graph holds correct variables
for (uint i = 0; i < N; i++)
{
for (uint j = i + 1; j < N; j++)
{
Assert.Equal(b.J[i, j], urd.Operator(r2));
}
}
using var r3 = new Xorshift(1234);
// check if graph index is reversible (Jij = Jji)
for (uint i = 0; i < N; i++)
{
for (uint j = i + 1; j < N; j++)
{
Assert.Equal(b.J[j, i], urd.Operator(r3));
}
}
//check adj_nodes
for (uint i = 0; i < N; i++)
{
ulong tot = 0;
foreach (var elem in b.GetAdjacentNodes(i))
{
tot += elem.Value;
}
Assert.Equal(tot, N * (N - 1) / 2 - i);
}
Assert.Equal(b.Edges, N - 1);
using var c = new Sparse <double>(N, N);
using var r4 = new Xorshift(1234);
for (uint i = 0; i < N; i++)
{
for (uint j = i; j < N; j++)
{
c.J[j, i] = urd.Operator(r4);
}
}
using var r5 = new Xorshift(1234);
for (uint i = 0; i < N; i++)
{
for (uint j = i; j < N; j++)
{
Assert.Equal(c.J[i, j], urd.Operator(r5));
}
}
using var r6 = new Xorshift(1234);
for (uint i = 0; i < N; i++)
{
for (uint j = i; j < N; j++)
{
Assert.Equal(c.J[j, i], urd.Operator(r6));
}
}
for (uint i = 0; i < N; i++)
{
ulong tot = 0;
foreach (var elem in c.GetAdjacentNodes(i))
{
tot += elem.Value;
}
Assert.Equal(tot, N * (N - 1) / 2);
}
Assert.Equal(c.Edges, N);
}
public void Max()
{
Assert.Equal(uint.MaxValue, Xorshift.Max());
}
public void ObjectEquality_TEST()
{
Xorshift random = new Xorshift(Seed);
double delta = 1.0e-6;
double deltaDateSeconds = 1.0e-3;
// bool
Assert.IsTrue(Plist.EqualObject(true, true, delta, deltaDateSeconds));
Assert.IsTrue(Plist.EqualObject(false, false, delta, deltaDateSeconds));
Assert.IsTrue(Plist.EqualObject(true, false, delta, deltaDateSeconds) == false);
Assert.IsTrue(Plist.EqualObject(true, false, delta, deltaDateSeconds) == false);
for (int i = 0; i < 100000; ++i)
{
int value1 = (int)random.Generate() * (random.Uniform() < 0.5 ? 1 : -1);
int value2 = (int)random.Generate() * (random.Uniform() < 0.5 ? 1 : -1);
Assert.IsTrue(Plist.EqualObject(value1, value1, delta, deltaDateSeconds));
Assert.IsTrue(Plist.EqualObject(value1, value2, delta, deltaDateSeconds) == (value1 == value2));
Assert.IsTrue(Plist.EqualObject(value1, value2, delta, deltaDateSeconds) == Plist.EqualObject(value2, value1, delta, deltaDateSeconds));
}
for (int i = 0; i < 100000; ++i)
{
double value1 = random.Uniform(-1.0e+9, 1.0e+9);
Assert.IsTrue(Plist.EqualObject(value1, value1, delta, deltaDateSeconds));
Assert.IsTrue(Plist.EqualObject(value1, value1 + random.Uniform(0.1, 1000.0), delta, deltaDateSeconds) == false);
Assert.IsTrue(Plist.EqualObject(value1, value1 - random.Uniform(0.1, 1000.0), delta, deltaDateSeconds) == false);
}
for (int i = 0; i < 100000; ++i)
{
DateTime value1 = DateTime.Now.Add(TimeSpan.FromSeconds(random.Uniform(-1.0e+6, 1.0e+6)));
Assert.IsTrue(Plist.EqualObject(value1, value1, delta, deltaDateSeconds));
Assert.IsTrue(Plist.EqualObject(value1, value1.AddSeconds(random.Uniform(0.1, 1000.0)), delta, deltaDateSeconds) == false);
Assert.IsTrue(Plist.EqualObject(value1, value1.AddSeconds(-random.Uniform(0.1, 1000.0)), delta, deltaDateSeconds) == false);
}
for (int i = 0; i < 10000; ++i)
{
string value1 = Arbitrary.Text();
string value2 = Arbitrary.Text();
Assert.IsTrue(Plist.EqualObject(value1, value1, delta, deltaDateSeconds));
Assert.IsTrue(Plist.EqualObject(value1 + value2, value1 + value2, delta, deltaDateSeconds));
Assert.IsTrue(Plist.EqualObject(value1, value1 + "a", delta, deltaDateSeconds) == false);
Assert.IsTrue(Plist.EqualObject(value1, value2, delta, deltaDateSeconds) == Plist.EqualObject(value2, value1, delta, deltaDateSeconds));
Assert.IsTrue(Plist.EqualObject(value1, value2, delta, deltaDateSeconds) == (value2 == value1));
}
for (int i = 0; i < 10000; ++i)
{
byte[] value1 = Arbitrary.BinaryData();
byte[] valueA = value1.Concat(new byte[] { (byte)(random.Generate() & 0xFF) }).ToArray();
byte[] valueB = value1.Concat(new byte[] { (byte)(random.Generate() & 0xFF) }).ToArray();
Assert.IsTrue(Plist.EqualObject(valueA, valueB, delta, deltaDateSeconds) == Plist.EqualObject(valueB, valueA, delta, deltaDateSeconds));
Assert.IsTrue(Plist.EqualObject(value1, valueA, delta, deltaDateSeconds) == false);
}
for (int i = 0; i < 5000; ++i)
{
List <object> value1 = new List <object>();
int n = (int)random.Generate() % 100;
for (int j = 0; j < n; ++j)
{
value1.Add(Arbitrary.PlistValue());
}
Assert.IsTrue(Plist.EqualObject(value1, value1, delta, deltaDateSeconds));
// Insert Test
List <object> value2 = new List <object>(value1);
value2.Insert((int)random.Generate() % (value1.Count + 1), Arbitrary.PlistValue());
Assert.IsTrue(Plist.EqualObject(value1, value2, delta, deltaDateSeconds) == false);
// Modify Test
if (n > 0)
{
List <object> value3 = new List <object>(value1);
int index = (int)random.Generate() % value1.Count;
object newValue = Arbitrary.PlistValue();
object oldValue = value3[index];
value3[index] = newValue;
if (Plist.EqualObject(oldValue, newValue, delta, deltaDateSeconds))
{
Assert.IsTrue(Plist.EqualObject(value1, value3, delta, deltaDateSeconds));
}
else
{
Assert.IsTrue(Plist.EqualObject(value1, value3, delta, deltaDateSeconds) == false);
}
}
}
for (int i = 0; i < 1000; ++i)
{
Dictionary <string, object> value1 = new Dictionary <string, object>();
int n = (int)random.Generate() % 100;
for (int j = 0; j < n; ++j)
{
value1[Arbitrary.Text()] = Arbitrary.PlistValue();
}
Assert.IsTrue(Plist.EqualObject(value1, value1, delta, deltaDateSeconds));
// Add Test
Dictionary <string, object> value2 = new Dictionary <string, object>(value1);
var newKey = Arbitrary.Text();
if (value2.ContainsKey(newKey) == false)
{
value2[newKey] = Arbitrary.PlistValue();
Assert.IsTrue(Plist.EqualObject(value1, value2, delta, deltaDateSeconds) == false);
}
// Modify Test
Dictionary <string, object> value3 = new Dictionary <string, object>(value1);
if (n > 0)
{
var key = value3.Keys.ToArray()[(int)random.Generate() % value3.Count];
object newValue = Arbitrary.PlistValue();
object oldValue = value3[key];
value3[key] = newValue;
if (Plist.EqualObject(oldValue, newValue, delta, deltaDateSeconds))
{
Assert.IsTrue(Plist.EqualObject(value1, value3, delta, deltaDateSeconds));
}
else
{
Assert.IsTrue(Plist.EqualObject(value1, value3, delta, deltaDateSeconds) == false);
}
}
}
}
public void Min()
{
Assert.Equal(uint.MinValue, Xorshift.Min());
}
public void Create()
{
var xorshiftTest = new Xorshift(100);
this.DisposeAndCheckDisposedState(xorshiftTest);
}
protected virtual void Start()
{
this.xorshift = new Xorshift(0);
RandomEx.ValueFunc = this.xorshift.Value;
}
/// <summary>
/// Run example
/// </summary>
/// <seealso cref="http://en.wikipedia.org/wiki/Random_number_generation">Random number generation</seealso>
/// <seealso cref="http://en.wikipedia.org/wiki/Linear_congruential_generator">Linear congruential generator</seealso>
/// <seealso cref="http://en.wikipedia.org/wiki/Mersenne_twister">Mersenne twister</seealso>
/// <seealso cref="http://en.wikipedia.org/wiki/Lagged_Fibonacci_generator">Lagged Fibonacci generator</seealso>
/// <seealso cref="http://en.wikipedia.org/wiki/Xorshift">Xorshift</seealso>
public void Run()
{
// All RNG classes in MathNet have next counstructors:
// - RNG(int seed, bool threadSafe): initializes a new instance with specific seed value and thread safe property
// - RNG(int seed): iуууnitializes a new instance with specific seed value. Thread safe property is set to Control.ThreadSafeRandomNumberGenerators
// - RNG(bool threadSafe) : initializes a new instance with the seed value set to DateTime.Now.Ticks and specific thread safe property
// - RNG(bool threadSafe) : initializes a new instance with the seed value set to DateTime.Now.Ticks and thread safe property set to Control.ThreadSafeRandomNumberGenerators
// All RNG classes in MathNet have next methods to produce random values:
// - double[] NextDouble(int n): returns an "n"-size array of uniformly distributed random doubles in the interval [0.0,1.0];
// - int Next(): returns a nonnegative random number;
// - int Next(int maxValue): returns a random number less then a specified maximum;
// - int Next(int minValue, int maxValue): returns a random number within a specified range;
// - void NextBytes(byte[] buffer): fills the elements of a specified array of bytes with random numbers;
// All RNG classes in MathNet have next extension methods to produce random values:
// - long NextInt64(): returns a nonnegative random number less than "Int64.MaxValue";
// - int NextFullRangeInt32(): returns a random number of the full Int32 range;
// - long NextFullRangeInt64(): returns a random number of the full Int64 range;
// - decimal NextDecimal(): returns a nonnegative decimal floating point random number less than 1.0;
// 1. Multiplicative congruential generator using a modulus of 2^31-1 and a multiplier of 1132489760
var mcg31M1 = new Mcg31m1(1);
Console.WriteLine(@"1. Generate 10 random double values using Multiplicative congruential generator with a modulus of 2^31-1 and a multiplier of 1132489760");
var randomValues = mcg31M1.NextDouble(10);
for (var i = 0; i < randomValues.Length; i++)
{
Console.Write(randomValues[i].ToString("N") + @" ");
}
Console.WriteLine();
Console.WriteLine();
// 2. Multiplicative congruential generator using a modulus of 2^59 and a multiplier of 13^13
var mcg59 = new Mcg59(1);
Console.WriteLine(@"2. Generate 10 random integer values using Multiplicative congruential generator with a modulus of 2^59 and a multiplier of 13^13");
for (var i = 0; i < 10; i++)
{
Console.Write(mcg59.Next() + @" ");
}
Console.WriteLine();
Console.WriteLine();
// 3. Random number generator using Mersenne Twister 19937 algorithm
var mersenneTwister = new MersenneTwister(1);
Console.WriteLine(@"3. Generate 10 random integer values less then 100 using Mersenne Twister 19937 algorithm");
for (var i = 0; i < 10; i++)
{
Console.Write(mersenneTwister.Next(100) + @" ");
}
Console.WriteLine();
Console.WriteLine();
// 4. Multiple recursive generator with 2 components of order 3
var mrg32K3A = new Mrg32k3a(1);
Console.WriteLine(@"4. Generate 10 random integer values in range [50;100] using multiple recursive generator with 2 components of order 3");
for (var i = 0; i < 10; i++)
{
Console.Write(mrg32K3A.Next(50, 100) + @" ");
}
Console.WriteLine();
Console.WriteLine();
// 5. Parallel Additive Lagged Fibonacci pseudo-random number generator
var palf = new Palf(1);
Console.WriteLine(@"5. Generate 10 random bytes using Parallel Additive Lagged Fibonacci pseudo-random number generator");
var bytes = new byte[10];
palf.NextBytes(bytes);
for (var i = 0; i < bytes.Length; i++)
{
Console.Write(bytes[i] + @" ");
}
Console.WriteLine();
Console.WriteLine();
// 6. A random number generator based on the "System.Security.Cryptography.RandomNumberGenerator" class in the .NET library
var systemCryptoRandomNumberGenerator = new SystemCryptoRandomNumberGenerator();
Console.WriteLine(@"6. Generate 10 random decimal values using RNG based on the 'System.Security.Cryptography.RandomNumberGenerator'");
for (var i = 0; i < 10; i++)
{
Console.Write(systemCryptoRandomNumberGenerator.NextDecimal().ToString("N") + @" ");
}
Console.WriteLine();
Console.WriteLine();
// 7. Wichmann-Hill’s 1982 combined multiplicative congruential generator
var rngWh1982 = new WH1982();
Console.WriteLine(@"7. Generate 10 random full Int32 range values using Wichmann-Hill’s 1982 combined multiplicative congruential generator");
for (var i = 0; i < 10; i++)
{
Console.Write(rngWh1982.NextFullRangeInt32() + @" ");
}
Console.WriteLine();
Console.WriteLine();
// 8. Wichmann-Hill’s 2006 combined multiplicative congruential generator.
var rngWh2006 = new WH2006();
Console.WriteLine(@"8. Generate 10 random full Int64 range values using Wichmann-Hill’s 2006 combined multiplicative congruential generator");
for (var i = 0; i < 10; i++)
{
Console.Write(rngWh2006.NextFullRangeInt32() + @" ");
}
Console.WriteLine();
Console.WriteLine();
// 9. Multiply-with-carry Xorshift pseudo random number generator
var xorshift = new Xorshift();
Console.WriteLine(@"9. Generate 10 random nonnegative values less than Int64.MaxValue using Multiply-with-carry Xorshift pseudo random number generator");
for (var i = 0; i < 10; i++)
{
Console.Write(xorshift.NextInt64() + @" ");
}
Console.WriteLine();
}
private void ProfileRNGs()
{
// Time it takes for many RNG implementations to fill a buffer with random 32 bit floats with distribution [0,1)
// For each RNG I list two times measures on my machine: editor with safetychecks, build without safetychecks
// If burst job is used, it is single-threaded. Obviously, using multiple threads with multiple RNGs is faster.
var values = new NativeArray <float>(numVals, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
// 220ms, 55ms
var rs = new System.Random(1234);
var sw = System.Diagnostics.Stopwatch.StartNew();
for (int i = 0; i < values.Length; i++)
{
values[i] = (float)rs.NextDouble();
}
sw.Stop();
Debug.Log("System.Random: " + sw.ElapsedMilliseconds);
// 171ms, 40ms
sw = System.Diagnostics.Stopwatch.StartNew();
for (int i = 0; i < values.Length; i++)
{
values[i] = UnityEngine.Random.value;
}
sw.Stop();
Debug.Log("Unity.Random: " + sw.ElapsedMilliseconds);
// 245ms, 84ms
sw = System.Diagnostics.Stopwatch.StartNew();
var uMathRng = new Unity.Mathematics.Random(1234);
for (int i = 0; i < values.Length; i++)
{
values[i] = uMathRng.NextFloat();
}
sw.Stop();
Debug.Log("Unity.Mathematics.Random: " + sw.ElapsedMilliseconds);
// 248ms, 10ms
sw = System.Diagnostics.Stopwatch.StartNew();
var umrj = new UMathRngJob();
umrj.Random = uMathRng;
umrj.Values = values;
umrj.Schedule().Complete();
sw.Stop();
Debug.Log("Unity.Mathematics.Random BurstJob: " + sw.ElapsedMilliseconds);
// 226ms, 71ms
var rm = new Meisui.Random.MersenneTwister(1234);
sw = System.Diagnostics.Stopwatch.StartNew();
for (int i = 0; i < values.Length; i++)
{
values[i] = (float)rm.genrand_real2();
}
sw.Stop();
Debug.Log("MersenneTwister Managed: " + sw.ElapsedMilliseconds);
// 351ms, 91ms
var rrm = new Ramjet.MersenneTwister(1234);
sw = System.Diagnostics.Stopwatch.StartNew();
for (int i = 0; i < values.Length; i++)
{
values[i] = rrm.genrand_real2();
}
sw.Stop();
Debug.Log("MersenneTwister Burst: " + sw.ElapsedMilliseconds);
// 359ms, 15ms
sw = System.Diagnostics.Stopwatch.StartNew();
var mtj = new MTJob();
mtj.Values = values;
mtj.Random = rrm;
mtj.Schedule().Complete();
sw.Stop();
rrm.Dispose();
Debug.Log("MersenneTwister BurstJob: " + sw.ElapsedMilliseconds);
// 162ms, 76
var xor = new Xorshift(1234);
sw = System.Diagnostics.Stopwatch.StartNew();
for (int i = 0; i < values.Length; i++)
{
values[i] = xor.NextFloat();
}
sw.Stop();
Debug.Log("XORShift Managed: " + sw.ElapsedMilliseconds);
// 1107, 21ms
sw = System.Diagnostics.Stopwatch.StartNew();
var xorb = new XorshiftBurst(1234);
var xorj = new XorShiftJob();
xorj.Values = values;
xorj.Random = xorb;
xorj.Schedule().Complete();
sw.Stop();
Debug.Log("XORShift BurstJob: " + sw.ElapsedMilliseconds);
// Find min and max values in buffer, and turn it into a texture for visual inspection
// Todo: do this for all RNGs, not just for the last one to generate values.
// float min = 2f;
// float max = -1f;
// _tex = new Texture2D(res, res, TextureFormat.ARGB32, false, true);
// var data = new Color[res * res];
// for (int i = 0; i < numVals; i++) {
// float val = values[i];
// if (val > max) {
// max = val;
// }
// if (val < min) {
// min = val;
// }
// data[i] = new Color(val, val, val, 1f);
// }
// Debug.Log(min + ", " + max);
// _tex.SetPixels(0, 0, res, res, data, 0);
// _tex.Apply();
values.Dispose();
}
public RandomLocal(UInt64 seed)
{
rand_ = new Xorshift();
rand_.setSeed(seed);
}
/// <summary>
/// CMA-ES stochastic optimizer class with ask-and-tell interface.
/// </summary>
/// <param name="mean">Initial mean vector of multi-variate gaussian distributions.</param>
/// <param name="sigma">Initial standard deviation of covariance matrix.</param>
/// <param name="bounds">(Optional) Lower and upper domain boundaries for each parameter, (n_dim, 2)-dim matrix.</param>
/// <param name="nMaxResampling">(Optional) A maximum number of resampling parameters (default: 100).
/// If all sampled parameters are infeasible, the last sampled one will be clipped with lower and upper bounds.</param>
/// <param name="seed">(Optional) A seed number.</param>
/// <param name="tol_sigma">(Optional) Threshold for determining the convergence of sigma.</param>
/// <param name="tol_C">(Optional) Threshold for determining the convergence of Covariance matrix.</param>
public CMA(IList <double> mean, double sigma, Matrix <double> bounds = null, int nMaxResampling = 100, int seed = 0, double tol_sigma = 1e-4, double tol_C = 1e-4)
{
if (!(sigma > 0))
{
throw new ArgumentOutOfRangeException("sigma must be non-zero positive value");
}
int nDim = mean.Count;
if (!(nDim > 1))
{
throw new ArgumentOutOfRangeException("The dimension of mean must be larger than 1");
}
int populationSize = 4 + (int)Math.Floor(3 * Math.Log(nDim)); // # (eq. 48)
int mu = populationSize / 2;
Vector <double> weightsPrime = Vector <double> .Build.Dense(populationSize);
for (int i = 0; i < populationSize; i++)
{
weightsPrime[i] = Math.Log((populationSize + 1) / (double)2) - Math.Log(i + 1);
}
Vector <double> weightsPrimeMuEff = Vector <double> .Build.Dense(weightsPrime.Take(mu).ToArray());
double mu_eff = Math.Pow(weightsPrimeMuEff.Sum(), 2) / Math.Pow(weightsPrimeMuEff.L2Norm(), 2);
Vector <double> weightsPrimeMuEffMinus = Vector <double> .Build.Dense(weightsPrime.Skip(mu).ToArray());
double muEffMinus = Math.Pow(weightsPrimeMuEffMinus.Sum(), 2) / Math.Pow(weightsPrimeMuEffMinus.L2Norm(), 2);
int alphacCov = 2;
double c1 = alphacCov / (Math.Pow(nDim + 1.3, 2) + mu_eff);
double cmu = Math.Min(1 - c1, alphacCov * (mu_eff - 2 + (1 / mu_eff)) / (Math.Pow(nDim + 2, 2) + (alphacCov * mu_eff / 2)));
if (!(c1 <= 1 - cmu))
{
throw new Exception("invalid learning rate for the rank-one update");
}
if (!(cmu <= 1 - c1))
{
throw new Exception("invalid learning rate for the rank-μ update");
}
double minAlpha = Math.Min(1 + (c1 / cmu), Math.Min(1 + (2 * muEffMinus / (mu_eff + 2)), (1 - c1 - cmu) / (nDim * cmu)));
double positiveSum = weightsPrime.Where(x => x > 0).Sum();
double negativeSum = Math.Abs(weightsPrime.Where(x => x < 0).Sum());
Vector <double> weights = Vector <double> .Build.Dense(weightsPrime.Count);
weightsPrime.CopyTo(weights);
bool[] weightsIsNotNegative = weightsPrime.Select(x => x >= 0).ToArray();
for (int i = 0; i < weights.Count; i++)
{
weights[i] = weightsIsNotNegative[i] ? 1 / positiveSum * weightsPrime[i] : minAlpha / negativeSum * weightsPrime[i];
}
int cm = 1;
double c_sigma = (mu_eff + 2) / (nDim + mu_eff + 5);
double d_sigma = 1 + (2 * Math.Max(0, Math.Sqrt((mu_eff - 1) / (nDim + 1)) - 1)) + c_sigma;
if (!(c_sigma < 1))
{
throw new Exception("invalid learning rate for cumulation for the step-size control");
}
double cc = (4 + (mu_eff / nDim)) / (nDim + 4 + (2 * mu_eff / nDim));
if (!(cc <= 1))
{
throw new Exception("invalid learning rate for cumulation for the rank-one update");
}
Dim = nDim;
PopulationSize = populationSize;
_mu = mu;
_mu_eff = mu_eff;
_cc = cc;
_c1 = c1;
_cmu = cmu;
_c_sigma = c_sigma;
_d_sigma = d_sigma;
_cm = cm;
_chi_n = Math.Sqrt(Dim) * (1.0 - (1.0 / (4.0 * Dim)) + 1.0 / (21.0 * (Math.Pow(Dim, 2))));
_weights = weights;
_p_sigma = Vector <double> .Build.Dense(Dim, 0);
_pc = Vector <double> .Build.Dense(Dim, 0);
_mean = Vector <double> .Build.DenseOfArray(mean.ToArray());
_C = Matrix <double> .Build.DenseIdentity(Dim, Dim);
_sigma = sigma;
if (!(bounds == null || (bounds.RowCount == Dim && bounds.ColumnCount == 2)))
{
throw new Exception("bounds should be (n_dim, 2)-dim matrix");
}
_bounds = bounds;
_n_max_resampling = nMaxResampling;
Generation = 0;
_rng = new Xorshift(seed);
_epsilon = 1e-8;
_tol_sigma = tol_sigma;
_tol_C = tol_C;
}
protected virtual void Start()
{
xorshift = new Xorshift(0);
}
