public static ExpressionStarter <T> PredicateByOperationType <T>(this ExpressionStarter <T> predicate,
BitwiseOperation operation,
Expression <Func <T, bool> > expr)
{
switch (operation)
{
case BitwiseOperation.And:
predicate = predicate.And(expr);
break;
case BitwiseOperation.Or:
predicate = predicate.Or(expr);
break;
}
return(predicate);
}
public static BitArray operator -(BitArray lhs, BitArray rhs)
{
var num = BitwiseOperation.Subtract(lhs.bits, rhs.bits);
return(new BitArray(num));
}
public void InvertMustWorkCorrectly(bool[] num, bool[] bits)
{
bool[] output = BitwiseOperation.Invert(num);
Assert.Equal <bool[]>(bits, output);
}
public void UnaryMinusMustWorkCorrectly(bool[] num, bool[] result)
{
bool[] output = BitwiseOperation.UnaryMinus(num);
Assert.Equal <bool[]>(result, output);
}
private static Variable Bitwise(BitwiseOperation op, Variable var1, Variable var2)
{
return(Bitwise(op, var1?.Value, var2?.Value));
}
public void ArithmeticRightShiftMustWorkCorrectly(bool[] num, bool[] bits, int shift)
{
bool[] output = BitwiseOperation.ArithmeticRightShift(num, shift);
Assert.Equal <bool[]>(bits, output);
}
public static ArrayBitwiseOperation <T> GetBitwiseOperationDelegateVector256 <T>(BitwiseOperation operation)
where T : unmanaged
{
switch (operation)
{
case BitwiseOperation.AND:
return(ANDArrayVector256);
case BitwiseOperation.OR:
return(ORArrayVector256);
case BitwiseOperation.XOR:
return(XORArrayVector256);
case BitwiseOperation.NAND:
return(NANDArrayVector256);
case BitwiseOperation.NOR:
return(NORArrayVector256);
case BitwiseOperation.XNOR:
return(XNORArrayVector256);
}
return(null);
}
public static BitArray operator -(BitArray bits)
{
var num = BitwiseOperation.UnaryMinus(bits.bits);
return(new BitArray(num));
}
public static bool PerformBitwiseOperationVector256CustomType <T>(T *origin, T *target, T mask, uint length, BitwiseOperation operation)
where T : unmanaged
{
switch (sizeof(T))
{
case sizeof(byte):
case sizeof(short):
case sizeof(int):
case sizeof(long):
return(GetBitwiseOperationDelegateVector256 <T>(operation)(origin, target, mask, length));
}
// TODO: Support types with different sizes too
return(false);
}
private static bool PerformArrayBitwiseOperationVector256CustomType <T>(T *origin, T *target, T mask, uint length, BitwiseOperation operation)
where T : unmanaged
{
if (EvaluateMaskConvertibility <T, byte>(&mask))
{
return(PerformBitwiseOperationVector256As <T, byte>(origin, target, &mask, length, operation));
}
if (EvaluateMaskConvertibility <T, short>(&mask))
{
return(PerformBitwiseOperationVector256As <T, short>(origin, target, &mask, length, operation));
}
if (EvaluateMaskConvertibility <T, int>(&mask))
{
return(PerformBitwiseOperationVector256As <T, int>(origin, target, &mask, length, operation));
}
if (EvaluateMaskConvertibility <T, long>(&mask))
{
return(PerformBitwiseOperationVector256As <T, long>(origin, target, &mask, length, operation));
}
return(false);
}
private static bool PerformBitwiseOperationCustomType <T>(T *origin, T *target, T mask, uint length, BitwiseOperation operation, SIMDVectorType vectorType)
where T : unmanaged
{
switch (sizeof(T))
{
case sizeof(byte):
case sizeof(short):
case sizeof(int):
case sizeof(long):
// Okay this is kinda ridiculous
return(GetBitwiseOperationDelegateReturner <T>(vectorType)(operation)(origin, target, mask, length));
}
// TODO: Support types with different sizes too
return(false);
}
private static bool PerformBitwiseOperationVector256As <TOrigin, TNew>(TOrigin *origin, TOrigin *target, TOrigin *mask, uint length, BitwiseOperation operation)
where TOrigin : unmanaged
where TNew : unmanaged
{
return(PerformBitwiseOperationAs(origin, target, mask, length, operation, GetBitwiseOperationDelegateVector256 <TNew>));
}
private static bool PerformBitwiseOperationAs <TOrigin, TNew>(TOrigin *origin, TOrigin *target, TOrigin *mask, uint length, BitwiseOperation operation, ArrayBitwiseOperationDelegateReturner <TNew> delegateReturner)
where TOrigin : unmanaged
where TNew : unmanaged
{
uint newLength = length * (uint)sizeof(TOrigin) / (uint)sizeof(TNew);
return(delegateReturner(operation)?.Invoke((TNew *)origin, (TNew *)target, *(TNew *)mask, newLength) == true);
}
public static BitArray operator *(BitArray lhs, BitArray rhs)
{
var num = BitwiseOperation.Multiply(lhs.bits, rhs.bits);
return(new BitArray(num));
}
public void MultiplyMustWorkCorrectly(bool[] lhs, bool[] rhs, bool[] result)
{
bool[] output = BitwiseOperation.Multiply(lhs, rhs);
Assert.Equal <bool[]>(result, output);
}
public static BitArray operator ~(BitArray bits)
{
var num = BitwiseOperation.Invert(bits.bits);
return(new BitArray(num));
}
public void SubtractMustWorkCorrectly(bool[] lhs, bool[] rhs, bool[] result)
{
bool[] output = BitwiseOperation.Subtract(lhs, rhs);
Assert.Equal <bool[]>(result, output);
}
public static BitArray operator >>(BitArray bits, int shift)
{
var num = BitwiseOperation.ArithmeticRightShift(bits.bits, shift);
return(new BitArray(num));
}
/// <summary> /// Return number as a bit collection. /// Collection starts from top order bit. /// </summary> /// <param name="num"></param> /// <returns></returns> public static IEnumerable <bool> GetNextBit(this ulong num) => BitwiseOperation.GetBitsReversed(num).Reverse();
