Пример #1
0
 public static Vector4UInt64 Clamp_Software(Vector4UInt64Param1_3 vector, Vector4UInt64Param1_3 low, Vector4UInt64Param1_3 high)
 {
     return(Vector256.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))
                ));
 }
Пример #2
0
 public static Vector4UInt64 LessThanOrEqual_Software(Vector4UInt64Param1_3 left, Vector4UInt64Param1_3 right)
 {
     return(Vector256.Create(
                Helpers.BoolToSimdBoolUInt64(Helpers.X(left) <= Helpers.X(right)),
                Helpers.BoolToSimdBoolUInt64(Helpers.Y(left) <= Helpers.Y(right)),
                Helpers.BoolToSimdBoolUInt64(Helpers.Z(left) <= Helpers.Z(right)),
                Helpers.BoolToSimdBoolUInt64(Helpers.W(left) <= Helpers.W(right))
                ));
 }
Пример #3
0
 public static Vector4UInt64 Multiply_Software(Vector4UInt64Param1_3 left, Vector4UInt64Param1_3 right)
 {
     return(Vector256.Create(
                X(left) * X(right),
                Y(left) * Y(right),
                Z(left) * Z(right),
                W(left) * W(right)
                ));
 }
Пример #4
0
 public static Vector4UInt64 Multiply_Software(Vector4UInt64Param1_3 left, ulong scalar)
 {
     return(Vector256.Create(
                X(left) * scalar,
                Y(left) * scalar,
                Z(left) * scalar,
                W(left) * scalar
                ));
 }
Пример #5
0
 public static Vector4UInt64 Subtract_Software(Vector4UInt64Param1_3 left, Vector4UInt64Param1_3 right)
 {
     return(Vector256.Create(
                X(left) - X(right),
                Y(left) - Y(right),
                Z(left) - Z(right),
                W(left) - W(right)
                ));
 }
Пример #6
0
 public static Vector4UInt64 Subtract_Software(Vector4UInt64Param1_3 vector, ulong scalar)
 {
     return(Vector256.Create(
                X(vector) - scalar,
                Y(vector) - scalar,
                Z(vector) - scalar,
                W(vector) - scalar
                ));
 }
Пример #7
0
 public static Vector4UInt64 Min_Software(Vector4UInt64Param1_3 left, Vector4UInt64Param1_3 right)
 {
     return(Vector256.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))
                ));
 }
Пример #8
0
 public static Vector4UInt64 HorizontalAdd_Software(Vector4UInt64Param1_3 left, Vector4UInt64Param1_3 right)
 {
     return(Vector256.Create(
                X(left) + Y(left),
                Z(left) + W(left),
                X(right) + Y(right),
                Z(right) + W(right)
                ));
 }
Пример #9
0
 public static Vector4UInt64 Sqrt_Software(Vector4UInt64Param1_3 vector)
 {
     return(Vector256.Create(
                (ulong)MathF.Sqrt(X(vector)),
                (ulong)MathF.Sqrt(Y(vector)),
                (ulong)MathF.Sqrt(Z(vector)),
                (ulong)MathF.Sqrt(W(vector))
                ));
 }
 public static Vector4UInt64 Not_Software(Vector4UInt64Param1_3 vector)
 {
     return(Vector256.Create(
                ~X(vector),
                ~Y(vector),
                ~Z(vector),
                ~W(vector)
                ));
 }
Пример #11
0
 public static Vector4UInt64 Divide_Software(Vector4UInt64Param1_3 dividend, Vector4UInt64Param1_3 divisor)
 {
     return(Vector256.Create(
                X(dividend) / X(divisor),
                Y(dividend) / Y(divisor),
                Z(dividend) / Z(divisor),
                W(dividend) / W(divisor)
                ));
 }
Пример #12
0
        public static Vector4UInt64 Or(Vector4UInt64Param1_3 left, Vector4UInt64Param1_3 right)
        {
            if (Avx2.IsSupported)
            {
                return(Avx2.Or(left, right));
            }

            return(SoftwareFallbacks.Or_Software(left, right));
        }
Пример #13
0
 public static Vector4UInt64 Divide_Software(Vector4UInt64Param1_3 dividend, ulong scalarDivisor)
 {
     return(Vector256.Create(
                X(dividend) / scalarDivisor,
                Y(dividend) / scalarDivisor,
                Z(dividend) / scalarDivisor,
                W(dividend) / scalarDivisor
                ));
 }
 public static Vector4UInt64 Xor_Software(Vector4UInt64Param1_3 left, Vector4UInt64Param1_3 right)
 {
     return(Vector256.Create(
                X(left) ^ X(right),
                Y(left) ^ Y(right),
                Z(left) ^ Z(right),
                W(left) ^ W(right)
                ));
 }
 public static Vector4UInt64 And_Software(Vector4UInt64Param1_3 left, Vector4UInt64Param1_3 right)
 {
     return(Vector256.Create(
                X(left) & X(right),
                Y(left) & Y(right),
                Z(left) & Z(right),
                W(left) & W(right)
                ));
 }
 public static Vector4UInt64 Or_Software(Vector4UInt64Param1_3 left, Vector4UInt64Param1_3 right)
 {
     return(Vector256.Create(
                X(left) | X(right),
                Y(left) | Y(right),
                Z(left) | Z(right),
                W(left) | W(right)
                ));
 }
Пример #17
0
        public static Vector4UInt64 Not(Vector4UInt64Param1_3 vector)
        {
            if (Avx2.IsSupported)
            {
                Vector4UInt64 mask = Vector256.Create(-1, -1, -1, -1).AsUInt64();
                return(Avx2.AndNot(vector, mask));
            }

            return(SoftwareFallbacks.Not_Software(vector));
        }
 public static Vector4UInt64 AndNot_Software(Vector4UInt64Param1_3 left, Vector4UInt64Param1_3 right)
 {
     return(And_Software(Not_Software(left), right));
 }