/// <summary>
/// [Thread-Unsafe] Get multiple normal distribution random values of <see cref="double"/>.
/// </summary>
/// <param name="count"></param>
/// <returns></returns>
public double[] NextNorm64(int count)
{
var half = count / 2;
var retval = NextFloat64(count);
for (var i = 0; i < half; ++i)
{
var j = i << 1; // 2 * i
var x = retval[j];
var y = retval[j + 1];
var mag = NdMath.Sqrt(-2 * NdMath.Log(x));
var ang = 2 * NdMath.PI <double>() * y;
retval[j] = mag * NdMath.Cos(ang);
retval[j + 1] = mag * NdMath.Sin(ang);
}
if ((count & 1) == 1) // count % 2 == 1
{
var x = retval[count - 1];
var y = NextFloat64();
retval[count - 1] = NdMath.Sqrt(-2 * NdMath.Log(x)) * NdMath.Cos(2 * NdMath.PI <double>() * y);
}
return(retval);
}
/// <summary>
/// [Thread-Unsafe] Get single normal distribution random value of <see cref="double"/>.
/// </summary>
/// <returns></returns>
public double NextNorm64()
{
var x = NextFloat64();
var y = NextFloat64();
return(NdMath.Sqrt(-2 * NdMath.Log(x)) * NdMath.Cos(2 * NdMath.PI <double>() * y));
}
/// <summary>
/// [Thread-Unsafe] Get single normal distribution random value of <see cref="float"/>.
/// </summary>
/// <returns></returns>
public float NextNorm32()
{
var x = NextFloat32();
var y = NextFloat32();
return(NdMath.Sqrt(-2 * NdMath.Log(x)) * NdMath.Cos(2 * NdMath.PI <float>() * y));
}
public void DecimalTest()
{
Assert.Equal(1m, NdMath.Exp(0m), 27);
Assert.Equal(NdMath.E <decimal>(), NdMath.Exp(1m), 27);
Assert.Equal(1.64872127070012814684865078781m, NdMath.Exp(0.5m), 27);
Assert.Equal(4.48168907033806482260205546012m, NdMath.Exp(1.5m), 27);
Assert.Equal(0.223130160148429828933280470764m, NdMath.Exp(-1.5m), 27);
}
/// <summary>
/// [Pure] Returns the 2-D norm of all elements of <paramref name="ndArray"/>.
/// </summary>
/// <param name="ndArray"></param>
/// <returns></returns>
public static T Norm2 <T>(this INdArray <T> ndArray)
{
var len = ndArray.Shape.TotalLength;
Guard.AssertOperation(len > 0, "ndArray has no elements.");
var norm = ValueTrait.Zero <T>();
for (var i = 0; i < len; ++i)
{
var element = ndArray.GetItem(i);
norm = ValueTrait.Add(norm, ValueTrait.Multiply(element, element));
}
return(NdMath.Sqrt(norm));
}
public static IEnumerable <object[]> FloatTestArgs()
{
object[] core(float x, float ans)
=> new object[]
{
x, ans
};
yield return(core(0, 1));
yield return(core(1, NdMath.E <float>()));
yield return(core(0.5f, 1.6487212707f));
yield return(core(1.5f, 4.48168907034f));
yield return(core(-1.5f, 0.22313016014f));
}
/// <summary>
/// Generates npy header by this instance.
/// </summary>
/// <returns></returns>
public byte[] GenerateHeader()
{
var headerText =
"{"
+ $"'descr': '{NumpyType.Expression}', "
+ $"'fortran_order': {(FortranOrder ? "True" : "False")}, "
+ $"'shape': ({string.Join(", ", Shape)}{(Shape.Length <= 1 ? "," : "")}), "
+ "}";
var header = Encoding.UTF8.GetBytes(headerText);
var bufferLen =
NdMath.Max(128, Align16(_HeaderMagicNumber.Length + 4 + header.Length + 1));
var version = bufferLen < 65536 ? (byte)1 : (byte)2;
var headerDicAlign = _HeaderDicAligns[version];
var buffer = new byte[bufferLen];
buffer.AsSpan().Fill(0x20);
Buffer.BlockCopy(_HeaderMagicNumber, 0, buffer, 0, _HeaderMagicNumber.Length);
buffer[_MajorVersionAlign] = version;
buffer[_MinorVersionAlign] = 0;
switch (version)
{
case 1:
LittleEndiannessBitConverter.Instance.TryWritePrimitive(buffer.AsSpan(_HeaderLenAlign),
(ushort)(bufferLen - headerDicAlign));
break;
case 2:
LittleEndiannessBitConverter.Instance.TryWritePrimitive(buffer.AsSpan(_HeaderLenAlign),
(ushort)(bufferLen - headerDicAlign));
break;
}
Buffer.BlockCopy(header, 0, buffer, headerDicAlign, header.Length);
buffer[bufferLen - 1] = 0x0A;
return(buffer);
}
/// <summary>
/// Creates new <see cref="T:NeodymiumDotNet.Random.MersenneTwisterGenerator" /> instance with seed array.
/// </summary>
/// <param name="seedArray"></param>
public MersenneTwisterGenerator(IReadOnlyList <int> seedArray)
: this(19650218)
{
var i = 1;
var j = 0;
var k = NdMath.Max(_N, seedArray.Count);
for (; k > 0; --k)
{
var prev = _mt[i - 1];
_mt[i] = (_mt[i] ^ ((prev ^ (prev >> 30)) * 1664525u)) + (uint)seedArray[j] + (uint)j;
++i;
++j;
if (i >= _N)
{
_mt[0] = _mt[_N - 1];
i = 1;
}
if (j >= seedArray.Count)
{
j = 0;
}
}
for (k = _N - 1; k > 0; --k)
{
var prev = _mt[i - 1];
_mt[i] = (_mt[i] ^ ((prev ^ (prev >> 30)) * 1566083941)) - (uint)i;
++i;
if (i >= _N)
{
_mt[0] = _mt[_N - 1];
i = 1;
}
}
_mt[0] = _UpperMask;
}
public void FloatTest(float x, float ans) => Assert.Equal(ans, NdMath.Exp(x), 6);
/// <summary> /// Computes sample variance from all elements of the <paramref name="ndArray"/>. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="ndArray"></param> /// <returns></returns> public static T StdDev <T>(this INdArray <T> ndArray) => NdMath.Sqrt(ndArray.SampleVar());
