/// <summary>
/// Returns the sampler for a specified rng, data type and distribution spec
/// </summary>
/// <param name="rng">The random stream</param>
/// <param name="spec">The distribution specifier</param>
/// <typeparam name="T">The sample point type</typeparam>
public static IRngSampler <T> Sampler <T>(this MklRng rng, IDistributionSpec <T> spec)
where T : unmanaged
{
var sampler = default(IRngSampler <T>);
switch (spec.DistKind)
{
case DistributionKind.Uniform:
sampler = rng.UniformSampler <T>(Distributions.uniform(spec));
break;
case DistributionKind.UniformBits:
sampler = rng.UniformBitsSampler <T>(Distributions.uniformbits(spec));
break;
case DistributionKind.Bernoulli:
sampler = rng.BernoulliSampler <T>(Distributions.bernoulli(spec));
break;
case DistributionKind.Gaussian:
sampler = rng.GaussianSampler <T>(Distributions.gaussian(spec));
break;
default:
throw Unsupported.define <T>();
}
return(sampler);
}
static unsafe Observations <T> ApplyRadixSort <T>(this Observations <T> samples, Observations <T> dst)
where T : unmanaged
{
var dim = samples.Dim;
var sampleCount = samples.Count;
var iStorage = (int)VslSSMatrixStorage.VSL_SS_MATRIX_STORAGE_ROWS;
var mformat = VslSSMatrixStorage.VSL_SS_MATRIX_STORAGE_ROWS;
var taskPtr = IntPtr.Zero;
if (typeof(T) == typeof(float))
{
VSL.vslsSSNewTask(ref taskPtr, ref dim, ref sampleCount, ref mformat,
ref MemoryMarshal.Cast <T, float>(samples)[0]).AutoThrow();
}
else if (typeof(T) == typeof(double))
{
VSL.vsldSSNewTask(ref taskPtr, ref dim, ref sampleCount, ref mformat,
ref MemoryMarshal.Cast <T, double>(samples)[0]).AutoThrow();
}
else
{
throw Unsupported.define <T>();
}
using var handle = VslSSTaskHandle.Wrap <T>(taskPtr);
handle.Set(VSL_SS_ED_OBSERV_STORAGE, ref iStorage);
handle.Set(VSL_SS_ED_SORTED_OBSERV, ref dst[0]);
handle.Set(VSL_SS_ED_SORTED_OBSERV_STORAGE, ref iStorage);
handle.Compute(VSL_SS_SORTED_OBSERV, VSL_SS_METHOD_RADIX);
return(dst);
}
protected override int FillBuffer(Span <T> buffer)
{
if (typeof(T) == typeof(int))
{
sample.poisson(Source, ScalarCast.float64(DistSpec.Rate), memory.int32(buffer));
}
else
{
throw Unsupported.define <T>();
}
return(buffer.Length);
}
protected override int FillBuffer(Span <T> buffer)
{
if (typeof(T) == typeof(int))
{
sample.geometric(Source, DistSpec, memory.int32(buffer));
}
else
{
throw Unsupported.define <T>();
}
return(buffer.Length);
}
public static IRngSampler <T> BernoulliSampler <T>(this MklRng rng, BernoulliSpec <T> spec)
where T : unmanaged
{
var sampler = default(IRngSampler <T>);
if (typeof(T) == typeof(int))
{
sampler = samplers.bernoulli(rng, spec) as IRngSampler <T>;
}
else
{
throw Unsupported.define <T>();
}
return(sampler);
}
public static void Compute <T>(this VslSSTaskHandle <T> task, VslSSComputeRoutine routine, VslSSComputeMethod method, [CallerFilePath] string file = null, [CallerLineNumber] int?line = null)
where T : unmanaged
{
if (typeof(T) == typeof(float))
{
VSL.vslsSSCompute(task, routine, method).AutoThrow(file, line);
}
else if (typeof(T) == typeof(double))
{
VSL.vsldSSCompute(task, routine, method).AutoThrow(file, line);
}
else
{
throw Unsupported.define <T>();
}
}
protected override int FillBuffer(Span <T> buffer)
{
if (typeof(T) == typeof(float))
{
sample.laplace(Source, float32(DistSpec.Location), float32(DistSpec.Scale), float32(buffer));
}
else if (typeof(T) == typeof(double))
{
sample.laplace(Source, float64(DistSpec.Location), float64(DistSpec.Scale), float64(buffer));
}
else
{
throw Unsupported.define <T>();
}
return(buffer.Length);
}
public static IRngSampler <T> GaussianSampler <T>(this MklRng rng, GaussianSpec <T> spec)
where T : unmanaged
{
var sampler = default(IRngSampler <T>);
if (typeof(T) == typeof(float))
{
sampler = samplers.gaussian(rng, spec.ToFloat32()) as IRngSampler <T>;
}
else if (typeof(T) == typeof(double))
{
sampler = samplers.gaussian(rng, spec.ToFloat64()) as IRngSampler <T>;
}
else
{
throw Unsupported.define <T>();
}
return(sampler);
}
public static IRngSampler <T> UniformBitsSampler <T>(this MklRng rng, UniformBitsSpec <T>?spec = null)
where T : unmanaged
{
var sampler = default(IRngSampler <T>);
var _spec = spec ?? Distributions.uniformbits <T>();
if (typeof(T) == typeof(uint))
{
sampler = samplers.bits(rng, _spec.ToUInt32()) as IRngSampler <T>;
}
else if (typeof(T) == typeof(ulong))
{
sampler = samplers.bits(rng, _spec.ToUInt64()) as IRngSampler <T>;
}
else
{
throw Unsupported.define <T>();
}
return(sampler);
}
VslSSTaskHandle(Span <T> samples, int dim)
{
this.Dim = new int[] { dim };
this.SampleCount = new int[] { samples.Length / dim };
this.MatrixFormat = new VslSSMatrixStorage[] { VslSSMatrixStorage.VSL_SS_MATRIX_STORAGE_ROWS };
this.TaskPtr = IntPtr.Zero;
if (typeof(T) == typeof(float))
{
VSL.vslsSSNewTask(ref TaskPtr, ref Dim[0], ref SampleCount[0], ref MatrixFormat[0],
ref MemoryMarshal.Cast <T, float>(samples)[0]).AutoThrow();
}
else if (typeof(T) == typeof(double))
{
VSL.vsldSSNewTask(ref TaskPtr, ref Dim[0], ref SampleCount[0], ref MatrixFormat[0],
ref MemoryMarshal.Cast <T, double>(samples)[0]).AutoThrow();
}
else
{
throw Unsupported.define <T>();
}
}
