public static Vector4UInt32 Subtract_Software(Vector4UInt32Param1_3 vector, uint scalar)
{
return(Vector128.Create(
X(vector) - scalar,
Y(vector) - scalar,
Z(vector) - scalar,
W(vector) - scalar
));
}
public static Vector4UInt32 AndNot(Vector4UInt32Param1_3 left, Vector4UInt32Param1_3 right)
{
if (Sse2.IsSupported)
{
return(Sse2.AndNot(left, right));
}
return(SoftwareFallbacks.AndNot_Software(left, right));
}
public static Vector4UInt32 Add(Vector4UInt32Param1_3 left, Vector4UInt32Param1_3 right)
{
if (Sse2.IsSupported)
{
return(Sse2.Add(left, right));
}
return(Add_Software(left, right));
}
public static Vector4UInt32 Min(Vector4UInt32Param1_3 left, Vector4UInt32Param1_3 right)
{
if (Sse41.IsSupported)
{
return(Sse41.Min(left, right));
}
return(Min_Software(left, right));
}
public static Vector4UInt32 Subtract(Vector4UInt32Param1_3 left, Vector4UInt32Param1_3 right)
{
if (Sse2.IsSupported)
{
return(Sse2.Subtract(left, right));
}
return(Subtract_Software(left, right));
}
public static Vector4UInt32 LessThan(Vector4UInt32Param1_3 left, Vector4UInt32Param1_3 right)
{
if (Sse2.IsSupported)
{
return(Sse2.CompareLessThan(Sse2.Xor(left, ComparisonMask).AsInt32(), Sse2.Xor(right, ComparisonMask).AsInt32()).AsUInt32());
}
return(LessThan_Software(left, right));
}
public static Vector4UInt32 HorizontalAdd_Software(Vector4UInt32Param1_3 left, Vector4UInt32Param1_3 right)
{
return(Vector128.Create(
X(left) + Y(left),
Z(left) + W(left),
X(right) + Y(right),
Z(right) + W(right)
));
}
public static Vector4UInt32 Xor_Software(Vector4UInt32Param1_3 left, Vector4UInt32Param1_3 right)
{
return(Vector128.Create(
X(left) ^ X(right),
Y(left) ^ Y(right),
Z(left) ^ Z(right),
W(left) ^ W(right)
));
}
public static Vector4UInt32 And_Software(Vector4UInt32Param1_3 left, Vector4UInt32Param1_3 right)
{
return(Vector128.Create(
X(left) & X(right),
Y(left) & Y(right),
Z(left) & Z(right),
W(left) & W(right)
));
}
public static Vector4UInt32 Multiply_Software(Vector4UInt32Param1_3 left, Vector4UInt32Param1_3 right)
{
return(Vector128.Create(
X(left) * X(right),
Y(left) * Y(right),
Z(left) * Z(right),
W(left) * W(right)
));
}
public static Vector4UInt32 LessThanOrEqual_Software(Vector4UInt32Param1_3 left, Vector4UInt32Param1_3 right)
{
return(Vector128.Create(
Helpers.BoolToSimdBoolUInt32(Helpers.X(left) <= Helpers.X(right)),
Helpers.BoolToSimdBoolUInt32(Helpers.Y(left) <= Helpers.Y(right)),
Helpers.BoolToSimdBoolUInt32(Helpers.Z(left) <= Helpers.Z(right)),
Helpers.BoolToSimdBoolUInt32(Helpers.W(left) <= Helpers.W(right))
));
}
public static Vector4UInt32 Or_Software(Vector4UInt32Param1_3 left, Vector4UInt32Param1_3 right)
{
return(Vector128.Create(
X(left) | X(right),
Y(left) | Y(right),
Z(left) | Z(right),
W(left) | W(right)
));
}
public static Vector4UInt32 Multiply_Software(Vector4UInt32Param1_3 left, uint scalar)
{
return(Vector128.Create(
X(left) * scalar,
Y(left) * scalar,
Z(left) * scalar,
W(left) * scalar
));
}
public static Vector4UInt32 Divide_Software(Vector4UInt32Param1_3 dividend, Vector4UInt32Param1_3 divisor)
{
return(Vector128.Create(
X(dividend) / X(divisor),
Y(dividend) / Y(divisor),
Z(dividend) / Z(divisor),
W(dividend) / W(divisor)
));
}
public static Vector4UInt32 Equality(Vector4UInt32Param1_3 left, Vector4UInt32Param1_3 right)
{
if (Sse2.IsSupported)
{
return(Sse2.CompareEqual(left, right));
}
return(Equality_Software(left, right));
}
public static Vector4UInt32 Min_Software(Vector4UInt32Param1_3 left, Vector4UInt32Param1_3 right)
{
return(Vector128.Create(
Math.Min(X(left), X(right)),
Math.Min(Y(left), Y(right)),
Math.Min(Z(left), Z(right)),
Math.Min(W(left), W(right))
));
}
public static Vector4UInt32 Subtract_Software(Vector4UInt32Param1_3 left, Vector4UInt32Param1_3 right)
{
return(Vector128.Create(
X(left) - X(right),
Y(left) - Y(right),
Z(left) - Z(right),
W(left) - W(right)
));
}
public static Vector4UInt32 Not_Software(Vector4UInt32Param1_3 vector)
{
return(Vector128.Create(
~X(vector),
~Y(vector),
~Z(vector),
~W(vector)
));
}
public static Vector4UInt32 Sqrt_Software(Vector4UInt32Param1_3 vector)
{
return(Vector128.Create(
(uint)MathF.Sqrt(X(vector)),
(uint)MathF.Sqrt(Y(vector)),
(uint)MathF.Sqrt(Z(vector)),
(uint)MathF.Sqrt(W(vector))
));
}
public static Vector4UInt32 Clamp_Software(Vector4UInt32Param1_3 vector, Vector4UInt32Param1_3 low, Vector4UInt32Param1_3 high)
{
return(Vector128.Create(
Math.Clamp(X(vector), X(low), X(high)),
Math.Clamp(Y(vector), Y(low), Y(high)),
Math.Clamp(Z(vector), Z(low), Z(high)),
Math.Clamp(W(vector), W(low), W(high))
));
}
public static Vector4UInt32 Divide_Software(Vector4UInt32Param1_3 dividend, uint scalarDivisor)
{
return(Vector128.Create(
X(dividend) / scalarDivisor,
Y(dividend) / scalarDivisor,
Z(dividend) / scalarDivisor,
W(dividend) / scalarDivisor
));
}
public static Vector4UInt32 Sqrt(Vector4UInt32Param1_3 vector)
{
#warning No direct hardware acceleration for integer sqrt; research acceleration techniques
//if (Sse.IsSupported)
//{
// return Sse42.Sqrt(vector);
//}
return(Sqrt_Software(vector));
}
public static Vector4UInt32 Subtract(Vector4UInt32Param1_3 vector, uint scalar)
{
if (Sse2.IsSupported)
{
Vector4UInt32 expand = Vector128.Create(scalar);
return(Sse2.Add(vector, expand));
}
return(Subtract_Software(vector, scalar));
}
public static Vector4UInt32 Divide(Vector4UInt32Param1_3 dividend, Vector4UInt32Param1_3 divisor)
{
#warning No direct hardware acceleration for integer divison; research acceleration techniques
//if (Sse2.IsSupported)
//{
// return Ssse3.Divide(dividend, divisor);
//}
return(Divide_Software(dividend, divisor));
}
public static Vector4UInt32 Clamp(Vector4UInt32Param1_3 vector, Vector4UInt32Param1_3 low, Vector4UInt32Param1_3 high)
{
if (Sse41.IsSupported)
{
Vector4UInt32 temp = Sse41.Min(vector, high);
return(Sse41.Max(temp, low));
}
return(Clamp_Software(vector, low, high));
}
public static Vector4UInt32 Not(Vector4UInt32Param1_3 vector)
{
if (Sse2.IsSupported)
{
Vector4UInt32 mask = Vector128.Create(-1, -1, -1, -1).AsUInt32();
return(Sse2.AndNot(vector, mask));
}
return(SoftwareFallbacks.Not_Software(vector));
}
public static Vector4UInt32 Inequality(Vector4UInt32Param1_3 left, Vector4UInt32Param1_3 right)
{
if (Sse2.IsSupported)
{
Vector128 <uint> mask = Vector128.Create(-1).AsUInt32();
return(Sse2.Xor(Sse2.CompareEqual(left, right), mask));
}
return(Inequality_Software(left, right));
}
public static Vector4UInt32 LessThanOrEqual(Vector4UInt32Param1_3 left, Vector4UInt32Param1_3 right)
{
if (Sse2.IsSupported)
{
Vector128 <uint> mask = Vector128.Create(-1).AsUInt32();
Vector4UInt32 temp = Sse2.CompareGreaterThan(Sse2.Xor(left, ComparisonMask).AsInt32(), Sse2.Xor(right, ComparisonMask).AsInt32()).AsUInt32();
return(Sse2.Xor(mask, mask));
}
return(LessThanOrEqual_Software(left, right));
}
public static Vector4UInt32 HorizontalAdd(Vector4UInt32Param1_3 left, Vector4UInt32Param1_3 right)
{
if (Ssse3.IsSupported)
{
return(Ssse3.HorizontalAdd(left.AsInt32(), right.AsInt32()).AsUInt32());
}
// TODO can Sse be used over the software fallback?
return(HorizontalAdd_Software(left, right));
}
public static Vector4UInt32 Divide(Vector4UInt32Param1_3 dividend, uint scalarDivisor)
{
#warning No direct hardware acceleration for integer divison; research acceleration techniques
//if (Sse.IsSupported)
//{
// Vector4Int expand = Vector128.Create(scalarDivisor);
// return Sse.Divide(dividend, expand);
//}
return(Divide_Software(dividend, scalarDivisor));
}
