/// <summary>
/// Shuffles span content as determined by a permutation
/// </summary>
/// <param name="src">The source span</param>
/// <param name="p">The permutation to apply</param>
public static Span <T> Permute <T>(this ReadOnlySpan <T> src, Perm p)
{
Span <T> dst = new T[src.Length];
for (var i = 0; i < p.Length; i++)
{
dst[i] = src[p[i]];
}
return(dst);
}
/// <summary>
/// Creates the matrix determined by a permutation
/// </summary>
/// <param name="src">The source permutation</param>
public static BitMatrix64 ToBitMatrix(this Perm <N64> src)
{
var dst = BitMatrix64.Alloc();
for (var row = 0; row < src.Length; row++)
{
dst[row, src[row]] = Bit.On;
}
return(dst);
}
/// <summary>
/// Maps a permutation on 16 symbols to its canonical scalar representation
/// </summary>
/// <param name="src">The source permutation</param>
public static Perm16 ToEnum(this Perm <N16> src)
{
var dst = 0ul;
for (int i = 0, offset = 0; i < src.Length; i++, offset += 3)
{
dst |= (ulong)src[i] << offset;
}
return((Perm16)dst);
}
/// <summary>
/// Shuffles bitstring content as determined by a permutation
/// </summary>
/// <param name="src">The source span</param>
/// <param name="p">The permutation to apply</param>
public static BitString Permute(this BitString src, Perm p)
{
var dst = BitString.Alloc(p.Length);
for (var i = 0; i < p.Length; i++)
{
dst[i] = src[p[i]];
}
return(dst);
}
/// <summary>
/// Maps a permutation on 8 symbols to its canonical scalar representation
/// </summary>
/// <param name="src">The source permutation</param>
public static Perm8Symbol ToScalar(this Perm <N8> src)
{
var dst = 0u;
for (int i = 0, offset = 0; i < src.Length; i++, offset += 3)
{
dst |= (uint)src[i] << offset;
}
return((Perm8Symbol)dst);
}
/// <summary>
/// Creates a permutation-defined mask
/// </summary>
/// <param name="spec">The permutation</param>
public static BitVector4 Mask(Perm spec)
{
var mask = Alloc();
var n = math.min(spec.Length, mask.Length);
for (var i = 0; i < n; i++)
{
mask[spec[i]] = i;
}
return(mask);
}
/// <summary>
/// Reifies a permutation of length 16 from its canonical scalar representative
/// </summary>
/// <param name="rep">The representative</param>
public static Perm <N16> ToPerm(this Perm16 rep)
{
uint data = (uint)rep;
var dst = Perm <N16> .Alloc();
for (int i = 0, offset = 0; i < dst.Length; i++, offset += 4)
{
dst[i] = (int)BitMask.between(in data, offset, offset + 3);
}
return(dst);
}
public void Shuffle1()
{
var src = Perm.Identity(24);
Perm dst0 = src;
Perm dst1 = Random.Shuffle(src.Replicate());
Perm dst2 = Random.Shuffle(src.Replicate());
Perm dst3 = Random.Shuffle(src.Replicate());
Claim.eq(dst1.Length, src.Length);
Claim.eq(dst2.Length, src.Length);
Claim.eq(dst3.Length, src.Length);
}
public void permrev_64x64()
{
for(var i= 0; i<SampleSize; i++)
{
//Creates an "exchange" matrix
var perm = Perm.Identity(n64).Reverse();
var mat = perm.ToBitMatrix();
var v1 = Random.BitVector(n64);
var v2 = mat * v1;
var v3 = v1.Replicate();
v3.Reverse();
Claim.eq(v3,v2);
}
}
OpTime Shuffle(int n, int count, out int duplicates)
{
duplicates = 0;
var sw = stopwatch();
var p0 = Perm.Identity(n);
var p1 = Random.Shuffle(in p0);
var p2 = Random.Shuffle(in p0);
for (var i = 0; i < count; i++)
{
p1 = Random.Shuffle(in p1);
p2 = Random.Shuffle(in p2);
if (p1 == p2)
{
duplicates++;
}
}
return(count, snapshot(sw));
}
public static ref BitVector64 mask(Perm spec, out BitVector64 mask)
{
mask = BitVector64.Mask(spec);
return(ref mask);
}
/// <summary> /// Formats the terms of a permutation /// </summary> /// <param name="terms">The permutation terms</param> /// <param name="colwidth">The width of each column</param> /// <typeparam name="T">The term type</typeparam> internal static string FormatPerm <T>(this ReadOnlySpan <T> terms, int?colwidth = null) => Perm.Format(terms, colwidth);
public static Span <T> Permute <T>(this Span <T> src, Perm p) => src.ReadOnly().Permute(p);
