public static ComponentMask Get <C1>()
{
ComponentMask mask = new ComponentMask();
mask[1 << ComponentIndexer.GetFamily <C1>()] = true;
return(mask);
}
public void extract64()
{
var src = Random.Stream <ulong>().Take(SampleSize).ToArray();
var lower = Random.Stream(leftclosed <byte>(0, 32)).Take(SampleSize).ToArray();
var upper = Random.Stream(leftclosed <byte>(32, 64)).Take(SampleSize).ToArray();
for (var i = 0; i < SampleSize; i++)
{
var v1 = BitVector.Load(src[i]);
var v2 = BitVector64.FromScalar(src[i]);
Claim.eq(v1.ToBitVector(n64), v2);
var r1 = v1.SliceCell(lower[i], upper[i]);
var r2 = v2.Between(lower[i], upper[i]);
if (r1 != r2)
{
Trace($"v1 = {v1.ToBitString()}");
Trace($"v2 = {v2.ToBitString()}");
Trace($"v1[{lower[i]}, {upper[i]}] = {r1.ToBitString()}");
Trace($"v2[{lower[i]}, {upper[i]}] = {r2.ToBitString()}");
}
Claim.eq(r1, r2);
}
}
static void ApplyZobrist(ulong[] keys, BitVector64 bv, ref ulong hash)
{
long bv1 = bv.Data;
while (bv1 != 0)
{
long lsbMask = bv1 & -bv1;
hash ^= keys[BitOperations.TrailingZeroCount(bv1)];
bv1 ^= lsbMask;
}
}
public static ComponentMask Get <C1, C2, C3, C4, C5>()
{
ComponentMask mask = new ComponentMask();
mask[1 << ComponentIndexer.GetFamily <C1>()] = true;
mask[1 << ComponentIndexer.GetFamily <C2>()] = true;
mask[1 << ComponentIndexer.GetFamily <C3>()] = true;
mask[1 << ComponentIndexer.GetFamily <C4>()] = true;
mask[1 << ComponentIndexer.GetFamily <C5>()] = true;
return(mask);
}
public void span_bits()
{
var src = Random.Span <byte>(Pow2.T03);
var bvSrc = BitVector64.FromScalar(BitConverter.ToUInt64(src));
for (var i = 0; i < src.Length; i++)
{
ref var x = ref src[i];
for (var j = 0; j < Pow2.T03; j++)
{
Claim.eq(gbits.test(x, j), bvSrc.Test(i * Pow2.T03 + j));
}
}
public void Collections_BitVectorsBitIndicesEnumeratorTest()
{
var oddBits32 = (uint)MakeBitPatern(kMaskOddBits, Bits.kInt32BitCount);
var oddBits64 = MakeBitPatern(kMaskOddBits, Bits.kInt64BitCount);
#region 32-bit
{
var bv32 = new BitVector32(oddBits32);
Assert.AreEqual(bv32.Length / 2, bv32.Cardinality);
int idx_count = 0;
foreach (int idx in bv32.ClearBitIndices)
{
Assert.IsTrue(idx % 2 == 0);
idx_count++;
}
Assert.AreEqual(bv32.Length / 2, idx_count);
foreach (int idx in bv32.SetBitIndices)
{
Assert.IsTrue(idx % 2 == 1);
idx_count++;
}
Assert.AreEqual(bv32.Length, idx_count);
}
#endregion
#region 64-bit
{
var bv64 = new BitVector64(oddBits64);
Assert.AreEqual(bv64.Length / 2, bv64.Cardinality);
int idx_count = 0;
foreach (int idx in bv64.ClearBitIndices)
{
Assert.IsTrue(idx % 2 == 0);
idx_count++;
}
Assert.AreEqual(bv64.Length / 2, idx_count);
foreach (int idx in bv64.SetBitIndices)
{
Assert.IsTrue(idx % 2 == 1);
idx_count++;
}
Assert.AreEqual(bv64.Length, idx_count);
}
#endregion
}
private void BitVectorsOperationsTest64()
{
const int k_bit_count = Bits.kInt64BitCount;
var lhs_bits = 0x4; // 0100b
var lhs_bs = new BitVector64(lhs_bits);
var rhs_bits = 0xA; // 1010b
var rhs_bs = new BitVector64(rhs_bits);
lhs_bs = lhs_bs.Or(rhs_bs);
Assert.AreEqual(3, lhs_bs.Cardinality);
Assert.AreEqual(k_bit_count - lhs_bs.Cardinality, lhs_bs.CardinalityZeros);
Assert.AreEqual(lhs_bs[0], false);
Assert.AreEqual(lhs_bs[1], true);
Assert.AreEqual(lhs_bs[2], true);
Assert.AreEqual(lhs_bs[3], true);
// also undoes the OR operation
lhs_bs = lhs_bs.AndNot(rhs_bs);
Assert.AreEqual(1, lhs_bs.Cardinality);
Assert.AreEqual(k_bit_count - lhs_bs.Cardinality, lhs_bs.CardinalityZeros);
Assert.AreEqual(lhs_bs[0], false);
Assert.AreEqual(lhs_bs[1], false);
Assert.AreEqual(lhs_bs[2], true);
Assert.AreEqual(lhs_bs[3], false);
lhs_bs = lhs_bs.And(rhs_bs);
Assert.AreEqual(0, lhs_bs.Cardinality);
Assert.AreEqual(k_bit_count - lhs_bs.Cardinality, lhs_bs.CardinalityZeros);
Assert.AreEqual(lhs_bs[0], false);
Assert.AreEqual(lhs_bs[1], false);
Assert.AreEqual(lhs_bs[2], false);
Assert.AreEqual(lhs_bs[3], false);
// at this point lhs is zero, and the only bit in rhs which is on (relative to lhs's bit-space) is the 2nd
lhs_bs = lhs_bs.Xor(rhs_bs);
Assert.AreEqual(2, lhs_bs.Cardinality);
Assert.AreEqual(k_bit_count - lhs_bs.Cardinality, lhs_bs.CardinalityZeros);
Assert.AreEqual(lhs_bs[0], false);
Assert.AreEqual(lhs_bs[1], true);
Assert.AreEqual(lhs_bs[2], false);
Assert.AreEqual(lhs_bs[3], true);
lhs_bs = lhs_bs.Not();
Assert.AreEqual(k_bit_count - 2, lhs_bs.Cardinality);
Assert.AreEqual(k_bit_count - lhs_bs.Cardinality, lhs_bs.CardinalityZeros);
Assert.AreEqual(lhs_bs[0], true);
Assert.AreEqual(lhs_bs[1], false);
Assert.AreEqual(lhs_bs[2], true);
Assert.AreEqual(lhs_bs[3], false);
}
public void pack_span64u()
{
var x0 = BitVector32.FromScalar(0b00001010110000101001001111011001u);
var x1 = BitVector32.FromScalar(0b00001010110110101001001111000001u);
var src = Random.Span <byte>(Pow2.T04).ReadOnly();
var packed = span <ulong>(src.Length / 8);
gbits.pack(src, packed);
for (var i = 0; i < packed.Length; i++)
{
var x = BitVector64.FromScalar(BitConverter.ToUInt64(src.Slice(8 * i)));
var y = BitVector64.FromScalar(packed[i]);
Claim.eq((ulong)x, (ulong)y, AppMsg.Error($"{x.ToBitString()} != {y.ToBitString()}"));
}
}
public DiskSectors()
{
DoubleBuffered = true;
Margin = new Padding(0);
Size = new Size(310, 280);
Resize += DiskSectors_Resize;
Paint += DiskSectors_Paint;
// Force initial layout
sections[0] = BitVector64.CreateSection((int)BlockStatus.Max);
for (var i = 1; i < CLUSTERS_PER_VECTOR; i++)
{
sections[i] = BitVector64.CreateSection((int)BlockStatus.Max, sections[i - 1]);
}
ScaledClusterCount = 1;
}
/// <summary>
/// Converts an array of bytes containing the consecutive bitboards
/// of an EncodedPositionBoard which were expanded (each bit to a byte).
/// Inverse of ToExpandedBytes.
/// </summary>
/// <param name="bytes"></param>
/// <returns></returns>
public static EncodedPositionBoard FromExpandedBytes(byte[] bytes)
{
return(new(
BitVector64.FromExpandedBytes(bytes, 64 * 0),
BitVector64.FromExpandedBytes(bytes, 64 * 1),
BitVector64.FromExpandedBytes(bytes, 64 * 2),
BitVector64.FromExpandedBytes(bytes, 64 * 3),
BitVector64.FromExpandedBytes(bytes, 64 * 4),
BitVector64.FromExpandedBytes(bytes, 64 * 5),
BitVector64.FromExpandedBytes(bytes, 64 * 6),
BitVector64.FromExpandedBytes(bytes, 64 * 7),
BitVector64.FromExpandedBytes(bytes, 64 * 8),
BitVector64.FromExpandedBytes(bytes, 64 * 9),
BitVector64.FromExpandedBytes(bytes, 64 * 10),
BitVector64.FromExpandedBytes(bytes, 64 * 11),
bytes[^ 1] == 1 // The 64 bytes are either all 1's or all 0's.
/// <summary>
/// Converts to an array of bytes, each representing
/// a single bit (inverse of FromExpandedBytes).
/// </summary>
/// <returns></returns>
public byte[] ToExpandedBytes()
{
ulong[] decoded = new ulong[EncodedPositionBoard.NUM_PLANES_PER_BOARD];
ExtractPlanesValuesIntoArray(decoded, 0);
byte[] ret = new byte[64 * EncodedPositionBoard.NUM_PLANES_PER_BOARD];
int index = 0;
for (int i = 0; i < decoded.Length; i++)
{
BitVector64 bv = new BitVector64(decoded[i]);
for (int j = 0; j < 64; j++)
{
ret[index++] = bv.BitIsSet(j) ? 1 : 0;
}
}
return(ret);
}
/// <typeparam name="TEnum">Members should be bit indices, not literal flag values</typeparam>
/// <param name="valueSeperator">regex pattern used to seperate values</param>
public bool?GetFlagsValue <TEnum>(string valueName, ref BitVector64 retVal
, string valueSeperator = ",", bool logFailures = true)
where TEnum : struct, IComparable, IFormattable, IConvertible
{
object value = TryGetValueForName(valueName);
if (value == null)
{
return(null);
}
bool?result = null;
switch (Type.GetTypeCode(value.GetType()))
{
case TypeCode.String:
result = retVal.TryParseFlags <TEnum>((string)value, valueSeperator, logFailures ? JsonNodeGlobals.gErrorsOutputList : null);
break;
case TypeCode.Object:
{
if (!(value is List <object> objList))
{
return(false);
}
result = retVal.TryParseFlags <TEnum>(objList.OfType <string>(), logFailures ? JsonNodeGlobals.gErrorsOutputList : null);
break;
}
default:
return(false);
}
if (logFailures && JsonNodeGlobals.gErrorsOutputList.Count > 0)
{
Debug.Trace.IO.TraceDataSansId(System.Diagnostics.TraceEventType.Error, string.Format(Util.InvariantCultureInfo,
"Failed parsing {0} value '{1}' as an {2}:\n{3}",
valueName, value, "FLAGS", JsonNodeGlobals.gErrorsOutputList.Join("\n")));
JsonNodeGlobals.gErrorsOutputList.Clear();
}
return(result);
}
public void bmv_64x64x8()
{
for (var sample = 0; sample < SampleSize; sample++)
{
var A = Random.BitMatrix64();
var x = Random.BitVector64();
var z = A * x;
var y = BitVector64.Alloc();
for (var i = 0; i < A.RowCount; i++)
{
var r = A.RowVector(i);
y[i] = r % x;
}
Claim.yea(z == y);
}
}
/// <typeparam name="TEnum">Members should be bit indices, not literal flag values</typeparam>
/// <param name="useArray">A JSON array is used instead of a single seperated string</param>
public bool SetFlagsValue <TEnum>(string valueName, BitVector64 value
, TEnum maxValue
, string valueSeperator = ",", bool useArray = true)
where TEnum : struct, IComparable, IFormattable, IConvertible
{
if (value.IsAllClear)
{
return(false);
}
if (useArray)
{
var values = value.ToStrings(maxValue, valueSeperator);
return(SetValuesForName(valueName, values));
}
else
{
string values = value.ToString(maxValue, valueSeperator);
return(SetValueForName(valueName, values));
}
}
public EncodedPositionBoard(BitVector64 ourPawns, BitVector64 ourKnights,
BitVector64 ourBishops, BitVector64 ourRooks,
BitVector64 ourQueens, BitVector64 ourKing,
BitVector64 theirPawns, BitVector64 theirKnights,
BitVector64 theirBishops, BitVector64 theirRooks,
BitVector64 theirQueens, BitVector64 theirKing,
bool repetitions)
{
OurPawns = new EncodedPositionBoardPlane(ourPawns);
OurKnights = new EncodedPositionBoardPlane(ourKnights);
OurBishops = new EncodedPositionBoardPlane(ourBishops);
OurRooks = new EncodedPositionBoardPlane(ourRooks);
OurQueens = new EncodedPositionBoardPlane(ourQueens);
OurKing = new EncodedPositionBoardPlane(ourKing);
TheirPawns = new EncodedPositionBoardPlane(theirPawns);
TheirKnights = new EncodedPositionBoardPlane(theirKnights);
TheirBishops = new EncodedPositionBoardPlane(theirBishops);
TheirRooks = new EncodedPositionBoardPlane(theirRooks);
TheirQueens = new EncodedPositionBoardPlane(theirQueens);
TheirKing = new EncodedPositionBoardPlane(theirKing);
Repetitions = repetitions ? new EncodedPositionBoardPlane(ALL_ONES_LONG) : default;
}
/// <summary>
/// Constructor from long.
/// </summary>
/// <param name="data"></param>
public EncodedPositionBoardPlane(long data)
{
Bits = data;
}
/// <summary>
/// Constructor from bitvector.
/// </summary>
/// <param name="bits"></param>
public EncodedPositionBoardPlane(BitVector64 bits)
{
Bits = bits;
}
