示例#1
0
            public static m128 mul_epi32(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.SLong0 = a.SInt0 * (long)b.SInt0;
                dst.SLong1 = a.SInt2 * (long)b.SInt2;
                return(dst);
            }
示例#2
0
            public static m128 round_sd(m128 a, m128 b, int rounding)
            {
                m128 dst = default(m128);

                dst.Double0 = RoundDImpl(b.Double0, rounding);
                dst.Double1 = a.Double1;
                return(dst);
            }
            public static m128 addsub_pd(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.Double0 = a.Double0 - b.Double0;
                dst.Double1 = a.Double1 + b.Double1;
                return(dst);
            }
示例#4
0
            public static m128 round_pd(m128 a, int rounding)
            {
                m128 dst = default(m128);

                dst.Double0 = RoundDImpl(a.Double0, rounding);
                dst.Double1 = RoundDImpl(a.Double1, rounding);
                return(dst);
            }
示例#5
0
            public static m128 cmpeq_epi64(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.SLong0 = a.SLong0 == b.SLong0 ? -1L : 0L;
                dst.SLong1 = a.SLong1 == b.SLong1 ? -1L : 0L;
                return(dst);
            }
            public static m128 movedup_pd(m128 a)
            {
                // Burst IR is fine
                m128 dst = default(m128);

                dst.Double0 = a.Double0;
                dst.Double1 = a.Double0;
                return(dst);
            }
            public static m128 andnot_ps(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.UInt0 = (~a.UInt0) & b.UInt0;
                dst.UInt1 = (~a.UInt1) & b.UInt1;
                dst.UInt2 = (~a.UInt2) & b.UInt2;
                dst.UInt3 = (~a.UInt3) & b.UInt3;
                return(dst);
            }
            public static m128 max_ps(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.Float0 = Math.Max(a.Float0, b.Float0);
                dst.Float1 = Math.Max(a.Float1, b.Float1);
                dst.Float2 = Math.Max(a.Float2, b.Float2);
                dst.Float3 = Math.Max(a.Float3, b.Float3);
                return(dst);
            }
            public static m128 and_ps(m128 a, m128 b)
            {
                m128 dst = a;

                dst.UInt0 &= b.UInt0;
                dst.UInt1 &= b.UInt1;
                dst.UInt2 &= b.UInt2;
                dst.UInt3 &= b.UInt3;
                return(dst);
            }
            public static m128 hadd_epi32(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.SInt0 = a.SInt1 + a.SInt0;
                dst.SInt1 = a.SInt3 + a.SInt2;
                dst.SInt2 = b.SInt1 + b.SInt0;
                dst.SInt3 = b.SInt3 + b.SInt2;
                return(dst);
            }
            public static m128 rsqrt_ps(m128 a)
            {
                m128 dst = default(m128);

                dst.Float0 = 1.0f / (float)Math.Sqrt(a.Float0);
                dst.Float1 = 1.0f / (float)Math.Sqrt(a.Float1);
                dst.Float2 = 1.0f / (float)Math.Sqrt(a.Float2);
                dst.Float3 = 1.0f / (float)Math.Sqrt(a.Float3);
                return(dst);
            }
            public static m128 cmpunord_ps(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.UInt0 = IsNaN(a.UInt0) || IsNaN(b.UInt0) ? ~0u : 0;
                dst.UInt1 = IsNaN(a.UInt1) || IsNaN(b.UInt1) ? ~0u : 0;
                dst.UInt2 = IsNaN(a.UInt2) || IsNaN(b.UInt2) ? ~0u : 0;
                dst.UInt3 = IsNaN(a.UInt3) || IsNaN(b.UInt3) ? ~0u : 0;
                return(dst);
            }
            public static m128 movehl_ps(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.Float0 = b.Float2;
                dst.Float1 = b.Float3;
                dst.Float2 = a.Float2;
                dst.Float3 = a.Float3;
                return(dst);
            }
            public static m128 cmpeq_ps(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.UInt0 = a.Float0 == b.Float0 ? ~0u : 0;
                dst.UInt1 = a.Float1 == b.Float1 ? ~0u : 0;
                dst.UInt2 = a.Float2 == b.Float2 ? ~0u : 0;
                dst.UInt3 = a.Float3 == b.Float3 ? ~0u : 0;
                return(dst);
            }
            public static m128 cmpneq_ps(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.UInt0 = a.Float0 != b.Float0 ? ~0u : 0u;
                dst.UInt1 = a.Float1 != b.Float1 ? ~0u : 0u;
                dst.UInt2 = a.Float2 != b.Float2 ? ~0u : 0u;
                dst.UInt3 = a.Float3 != b.Float3 ? ~0u : 0u;
                return(dst);
            }
            public static m128 or_ps(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.UInt0 = a.UInt0 | b.UInt0;
                dst.UInt1 = a.UInt1 | b.UInt1;
                dst.UInt2 = a.UInt2 | b.UInt2;
                dst.UInt3 = a.UInt3 | b.UInt3;
                return(dst);
            }
            public static m128 hsub_ps(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.Float0 = a.Float0 - a.Float1;
                dst.Float1 = a.Float2 - a.Float3;
                dst.Float2 = b.Float0 - b.Float1;
                dst.Float3 = b.Float2 - b.Float3;
                return(dst);
            }
            public static m128 hadd_ps(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.Float0 = a.Float0 + a.Float1;
                dst.Float1 = a.Float2 + a.Float3;
                dst.Float2 = b.Float0 + b.Float1;
                dst.Float3 = b.Float2 + b.Float3;
                return(dst);
            }
            public static m128 hsub_epi32(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.SInt0 = a.SInt0 - a.SInt1;
                dst.SInt1 = a.SInt2 - a.SInt3;
                dst.SInt2 = b.SInt0 - b.SInt1;
                dst.SInt3 = b.SInt2 - b.SInt3;
                return(dst);
            }
            public static m128 addsub_ps(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.Float0 = a.Float0 - b.Float0;
                dst.Float1 = a.Float1 + b.Float1;
                dst.Float2 = a.Float2 - b.Float2;
                dst.Float3 = a.Float3 + b.Float3;
                return(dst);
            }
            public static m128 xor_ps(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.UInt0 = a.UInt0 ^ b.UInt0;
                dst.UInt1 = a.UInt1 ^ b.UInt1;
                dst.UInt2 = a.UInt2 ^ b.UInt2;
                dst.UInt3 = a.UInt3 ^ b.UInt3;
                return(dst);
            }
            public static m128 add_ps(m128 a, m128 b)
            {
                m128 dst = a;

                dst.Float0 += b.Float0;
                dst.Float1 += b.Float1;
                dst.Float2 += b.Float2;
                dst.Float3 += b.Float3;
                return(dst);
            }
            public static m128 cmple_ps(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.UInt0 = a.Float0 <= b.Float0 ? ~0u : 0u;
                dst.UInt1 = a.Float1 <= b.Float1 ? ~0u : 0u;
                dst.UInt2 = a.Float2 <= b.Float2 ? ~0u : 0u;
                dst.UInt3 = a.Float3 <= b.Float3 ? ~0u : 0u;
                return(dst);
            }
            public static m128 sub_ps(m128 a, m128 b)
            {
                m128 dst = a;

                dst.Float0 -= b.Float0;
                dst.Float1 -= b.Float1;
                dst.Float2 -= b.Float2;
                dst.Float3 -= b.Float3;
                return(dst);
            }
            public static m128 cmpnle_ps(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.UInt0 = !(a.Float0 <= b.Float0) ? ~0u : 0u;
                dst.UInt1 = !(a.Float1 <= b.Float1) ? ~0u : 0u;
                dst.UInt2 = !(a.Float2 <= b.Float2) ? ~0u : 0u;
                dst.UInt3 = !(a.Float3 <= b.Float3) ? ~0u : 0u;
                return(dst);
            }
            public static m128 mul_ps(m128 a, m128 b)
            {
                m128 dst = a;

                dst.Float0 *= b.Float0;
                dst.Float1 *= b.Float1;
                dst.Float2 *= b.Float2;
                dst.Float3 *= b.Float3;
                return(dst);
            }
            public static m128 unpacklo_ps(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.Float0 = a.Float0;
                dst.Float1 = b.Float0;
                dst.Float2 = a.Float1;
                dst.Float3 = b.Float1;
                return(dst);
            }
            public static m128 div_ps(m128 a, m128 b)
            {
                m128 dst = a;

                dst.Float0 /= b.Float0;
                dst.Float1 /= b.Float1;
                dst.Float2 /= b.Float2;
                dst.Float3 /= b.Float3;
                return(dst);
            }
            public static m128 movelh_ps(m128 a, m128 b)
            {
                m128 dst = default(m128);

                dst.Float0 = a.Float0;
                dst.Float1 = a.Float1;
                dst.Float2 = b.Float0;
                dst.Float3 = b.Float1;
                return(dst);
            }
            public static m128 rcp_ps(m128 a)
            {
                m128 dst = default(m128);

                dst.Float0 = 1.0f / a.Float0;
                dst.Float1 = 1.0f / a.Float1;
                dst.Float2 = 1.0f / a.Float2;
                dst.Float3 = 1.0f / a.Float3;
                return(dst);
            }