martin
/
AnimTestbed
1
0
Fork 0
Code Issues 11 Pull Requests Projects 1 Releases Wiki Activity
AnimTestbed/3rdparty/ozz-animation/test/base/maths/simd_int_math_tests.cc

525 lines
21 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------//
// //
// ozz-animation is hosted at http://github.com/guillaumeblanc/ozz-animation //
// and distributed under the MIT License (MIT). //
// //
// Copyright (c) Guillaume Blanc //
// //
// Permission is hereby granted, free of charge, to any person obtaining a //
// copy of this software and associated documentation files (the "Software"), //
// to deal in the Software without restriction, including without limitation //
// the rights to use, copy, modify, merge, publish, distribute, sublicense, //
// and/or sell copies of the Software, and to permit persons to whom the //
// Software is furnished to do so, subject to the following conditions: //
// //
// The above copyright notice and this permission notice shall be included in //
// all copies or substantial portions of the Software. //
// //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR //
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, //
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL //
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER //
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING //
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER //
// DEALINGS IN THE SOFTWARE. //
// //
//----------------------------------------------------------------------------//
#include "ozz/base/maths/simd_math.h"
#include <stdint.h>
#include "gtest/gtest.h"
#include "ozz/base/gtest_helper.h"
#include "ozz/base/maths/gtest_math_helper.h"
#include "ozz/base/maths/math_constant.h"
#include "ozz/base/maths/math_ex.h"
using ozz::math::SimdInt4;
static_assert(sizeof(SimdInt4) == 4 * sizeof(int32_t),
"Expects SimdInt4 to be the size of 4 int32_t.");
static_assert(alignof(SimdInt4) == 16,
"Expects SimdInt4 to be the size of 16 bytes.");
TEST(LoadInt, ozz_simd_math) {
const SimdInt4 iX = ozz::math::simd_int4::LoadX(15);
EXPECT_SIMDINT_EQ(iX, 15, 0, 0, 0);
const SimdInt4 i1 = ozz::math::simd_int4::Load1(15);
EXPECT_SIMDINT_EQ(i1, 15, 15, 15, 15);
const SimdInt4 i4 = ozz::math::simd_int4::Load(1, -1, 2, -3);
EXPECT_SIMDINT_EQ(i4, 1, -1, 2, -3);
const SimdInt4 itX = ozz::math::simd_int4::LoadX(true);
EXPECT_SIMDINT_EQ(itX, 0xffffffff, 0, 0, 0);
const SimdInt4 ifX = ozz::math::simd_int4::LoadX(false);
EXPECT_SIMDINT_EQ(ifX, 0, 0, 0, 0);
const SimdInt4 it1 = ozz::math::simd_int4::Load1(true);
EXPECT_SIMDINT_EQ(it1, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff);
const SimdInt4 if1 = ozz::math::simd_int4::Load1(false);
EXPECT_SIMDINT_EQ(if1, 0, 0, 0, 0);
const SimdInt4 ibttff = ozz::math::simd_int4::Load(true, true, false, false);
EXPECT_SIMDINT_EQ(ibttff, 0xffffffff, 0xffffffff, 0, 0);
const SimdInt4 ibftft = ozz::math::simd_int4::Load(false, true, false, true);
EXPECT_SIMDINT_EQ(ibftft, 0, 0xffffffff, 0, 0xffffffff);
}
TEST(LoadIntPtr, ozz_simd_math) {
union Data {
int i[4 + 5];
char c[(4 + 5) * sizeof(int)]; // The 2nd char isn't aligned to an integer.
};
const Data d_in = {{-1, 1, 2, 3, 4, 5, 6, 7, 8}};
const int aligned_offset =
(16 - (reinterpret_cast<intptr_t>(d_in.i) & 0xf)) / sizeof(float);
assert(aligned_offset > 0 && aligned_offset <= 4);
EXPECT_SIMDINT_EQ(ozz::math::simd_int4::LoadPtrU(d_in.i + aligned_offset + 1),
d_in.i[aligned_offset + 1], d_in.i[aligned_offset + 2],
d_in.i[aligned_offset + 3], d_in.i[aligned_offset + 4]);
EXPECT_ASSERTION(
ozz::math::simd_int4::LoadPtrU(reinterpret_cast<const int*>(d_in.c + 1)),
"alignment");
EXPECT_SIMDINT_EQ(ozz::math::simd_int4::LoadPtr(d_in.i + aligned_offset),
d_in.i[aligned_offset], d_in.i[aligned_offset + 1],
d_in.i[aligned_offset + 2], d_in.i[aligned_offset + 3]);
EXPECT_ASSERTION(ozz::math::simd_int4::LoadPtr(d_in.i + aligned_offset + 1),
"alignment");
EXPECT_SIMDINT_EQ(ozz::math::simd_int4::LoadXPtrU(d_in.i + aligned_offset),
d_in.i[aligned_offset], 0, 0, 0);
EXPECT_ASSERTION(
ozz::math::simd_int4::LoadXPtrU(reinterpret_cast<const int*>(d_in.c + 1)),
"alignment");
EXPECT_SIMDINT_EQ(ozz::math::simd_int4::Load1PtrU(d_in.i + aligned_offset),
d_in.i[aligned_offset], d_in.i[aligned_offset],
d_in.i[aligned_offset], d_in.i[aligned_offset]);
EXPECT_ASSERTION(
ozz::math::simd_int4::Load1PtrU(reinterpret_cast<const int*>(d_in.c + 1)),
"alignment");
EXPECT_SIMDINT_EQ(ozz::math::simd_int4::LoadXPtr(d_in.i + aligned_offset),
d_in.i[aligned_offset], 0, 0, 0);
EXPECT_ASSERTION(ozz::math::simd_int4::LoadXPtr(d_in.i + aligned_offset + 1),
"alignment");
EXPECT_SIMDINT_EQ(ozz::math::simd_int4::Load1Ptr(d_in.i + aligned_offset),
d_in.i[aligned_offset], d_in.i[aligned_offset],
d_in.i[aligned_offset], d_in.i[aligned_offset]);
EXPECT_ASSERTION(ozz::math::simd_int4::Load1Ptr(d_in.i + aligned_offset + 1),
"alignment");
EXPECT_SIMDINT_EQ(ozz::math::simd_int4::Load2Ptr(d_in.i + aligned_offset),
d_in.i[aligned_offset], d_in.i[aligned_offset + 1], 0, 0);
EXPECT_ASSERTION(ozz::math::simd_int4::Load2Ptr(d_in.i + aligned_offset + 1),
"alignment");
EXPECT_SIMDINT_EQ(
ozz::math::simd_int4::Load2PtrU(d_in.i + aligned_offset + 1),
d_in.i[aligned_offset + 1], d_in.i[aligned_offset + 2], 0, 0);
EXPECT_ASSERTION(
ozz::math::simd_int4::Load2PtrU(reinterpret_cast<const int*>(d_in.c + 1)),
"alignment");
EXPECT_SIMDINT_EQ(ozz::math::simd_int4::Load3Ptr(d_in.i + aligned_offset),
d_in.i[aligned_offset], d_in.i[aligned_offset + 1],
d_in.i[aligned_offset + 2], 0);
EXPECT_ASSERTION(ozz::math::simd_int4::Load3Ptr(d_in.i + aligned_offset + 1),
"alignment");
EXPECT_SIMDINT_EQ(
ozz::math::simd_int4::Load3PtrU(d_in.i + aligned_offset + 1),
d_in.i[aligned_offset + 1], d_in.i[aligned_offset + 2],
d_in.i[aligned_offset + 3], 0);
EXPECT_ASSERTION(
ozz::math::simd_int4::Load3PtrU(reinterpret_cast<const int*>(d_in.c + 1)),
"alignment");
}
TEST(GetInt, ozz_simd_math) {
const SimdInt4 i = ozz::math::simd_int4::Load(1, 2, 3, 4);
EXPECT_EQ(ozz::math::GetX(i), 1);
EXPECT_EQ(ozz::math::GetY(i), 2);
EXPECT_EQ(ozz::math::GetZ(i), 3);
EXPECT_EQ(ozz::math::GetW(i), 4);
}
TEST(SetInt, ozz_simd_math) {
const SimdInt4 a = ozz::math::simd_int4::Load(1, 2, 3, 4);
const SimdInt4 b = ozz::math::simd_int4::Load(5, 6, 7, 8);
EXPECT_SIMDINT_EQ(ozz::math::SetX(a, b), 5, 2, 3, 4);
EXPECT_SIMDINT_EQ(ozz::math::SetY(a, b), 1, 5, 3, 4);
EXPECT_SIMDINT_EQ(ozz::math::SetZ(a, b), 1, 2, 5, 4);
EXPECT_SIMDINT_EQ(ozz::math::SetW(a, b), 1, 2, 3, 5);
EXPECT_ASSERTION(ozz::math::SetI(a, b, 4), "Invalid index, out of range.");
EXPECT_SIMDINT_EQ(ozz::math::SetI(a, b, 0), 5, 2, 3, 4);
EXPECT_SIMDINT_EQ(ozz::math::SetI(a, b, 1), 1, 5, 3, 4);
EXPECT_SIMDINT_EQ(ozz::math::SetI(a, b, 2), 1, 2, 5, 4);
EXPECT_SIMDINT_EQ(ozz::math::SetI(a, b, 3), 1, 2, 3, 5);
}
TEST(StoreIntPtr, ozz_simd_math) {
const SimdInt4 i4 = ozz::math::simd_int4::Load(-1, 1, 2, 3);
union Data {
int i[4 + 4]; // The 2nd float isn't aligned to a SimdInt4.
SimdInt4 i4[2]; // Forces alignment.
char c[(4 + 4) * sizeof(int)]; // The 2nd char isn't aligned to an integer.
};
{
Data d_out = {};
ozz::math::StorePtrU(i4, d_out.i + 1);
EXPECT_EQ(d_out.i[0], 0);
EXPECT_EQ(d_out.i[1], -1);
EXPECT_EQ(d_out.i[2], 1);
EXPECT_EQ(d_out.i[3], 2);
EXPECT_EQ(d_out.i[4], 3);
EXPECT_ASSERTION(
ozz::math::StorePtrU(i4, reinterpret_cast<int*>(d_out.c + 1)),
"alignment");
}
{
Data d_out = {};
ozz::math::Store1PtrU(i4, d_out.i + 1);
EXPECT_EQ(d_out.i[0], 0);
EXPECT_EQ(d_out.i[1], -1);
EXPECT_EQ(d_out.i[2], 0);
EXPECT_EQ(d_out.i[3], 0);
EXPECT_EQ(d_out.i[4], 0);
EXPECT_ASSERTION(
ozz::math::Store1PtrU(i4, reinterpret_cast<int*>(d_out.c + 1)),
"alignment");
}
{
Data d_out = {};
ozz::math::Store2PtrU(i4, d_out.i + 1);
EXPECT_EQ(d_out.i[0], 0);
EXPECT_EQ(d_out.i[1], -1);
EXPECT_EQ(d_out.i[2], 1);
EXPECT_EQ(d_out.i[3], 0);
EXPECT_EQ(d_out.i[4], 0);
EXPECT_ASSERTION(
ozz::math::Store2Ptr(i4, reinterpret_cast<int*>(d_out.c + 1)),
"alignment");
}
{
Data d_out = {};
ozz::math::Store3PtrU(i4, d_out.i + 1);
EXPECT_EQ(d_out.i[0], 0);
EXPECT_EQ(d_out.i[1], -1);
EXPECT_EQ(d_out.i[2], 1);
EXPECT_EQ(d_out.i[3], 2);
EXPECT_EQ(d_out.i[4], 0);
EXPECT_ASSERTION(
ozz::math::Store3Ptr(i4, reinterpret_cast<int*>(d_out.c + 1)),
"alignment");
}
{
Data d_out = {};
ozz::math::StorePtr(i4, d_out.i);
EXPECT_EQ(d_out.i[0], -1);
EXPECT_EQ(d_out.i[1], 1);
EXPECT_EQ(d_out.i[2], 2);
EXPECT_EQ(d_out.i[3], 3);
EXPECT_EQ(d_out.i[4], 0);
EXPECT_ASSERTION(ozz::math::StorePtr(i4, d_out.i + 1), "alignment");
}
{
Data d_out = {};
ozz::math::Store1Ptr(i4, d_out.i);
EXPECT_EQ(d_out.i[0], -1);
EXPECT_EQ(d_out.i[1], 0);
EXPECT_EQ(d_out.i[2], 0);
EXPECT_EQ(d_out.i[3], 0);
EXPECT_EQ(d_out.i[4], 0);
EXPECT_ASSERTION(ozz::math::Store1Ptr(i4, d_out.i + 1), "alignment");
}
{
Data d_out = {};
ozz::math::Store2Ptr(i4, d_out.i);
EXPECT_EQ(d_out.i[0], -1);
EXPECT_EQ(d_out.i[1], 1);
EXPECT_EQ(d_out.i[2], 0);
EXPECT_EQ(d_out.i[3], 0);
EXPECT_EQ(d_out.i[4], 0);
EXPECT_ASSERTION(ozz::math::Store2Ptr(i4, d_out.i + 1), "alignment");
}
{
Data d_out = {};
ozz::math::Store3Ptr(i4, d_out.i);
EXPECT_EQ(d_out.i[0], -1);
EXPECT_EQ(d_out.i[1], 1);
EXPECT_EQ(d_out.i[2], 2);
EXPECT_EQ(d_out.i[3], 0);
EXPECT_EQ(d_out.i[4], 0);
EXPECT_ASSERTION(ozz::math::Store3Ptr(i4, d_out.i + 1), "alignment");
}
}
TEST(ConstantInt, ozz_simd_math) {
const SimdInt4 zero = ozz::math::simd_int4::zero();
EXPECT_SIMDINT_EQ(zero, 0, 0, 0, 0);
const SimdInt4 one = ozz::math::simd_int4::one();
EXPECT_SIMDINT_EQ(one, 1, 1, 1, 1);
const SimdInt4 x_axis = ozz::math::simd_int4::x_axis();
EXPECT_SIMDINT_EQ(x_axis, 1, 0, 0, 0);
const SimdInt4 y_axis = ozz::math::simd_int4::y_axis();
EXPECT_SIMDINT_EQ(y_axis, 0, 1, 0, 0);
const SimdInt4 z_axis = ozz::math::simd_int4::z_axis();
EXPECT_SIMDINT_EQ(z_axis, 0, 0, 1, 0);
const SimdInt4 w_axis = ozz::math::simd_int4::w_axis();
EXPECT_SIMDINT_EQ(w_axis, 0, 0, 0, 1);
const SimdInt4 all_true = ozz::math::simd_int4::all_true();
EXPECT_SIMDINT_EQ(all_true, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff);
const SimdInt4 all_false = ozz::math::simd_int4::all_false();
EXPECT_SIMDINT_EQ(all_false, 0, 0, 0, 0);
const SimdInt4 mask_sign = ozz::math::simd_int4::mask_sign();
EXPECT_SIMDINT_EQ(mask_sign, 0x80000000, 0x80000000, 0x80000000, 0x80000000);
const SimdInt4 mask_sign_xyz = ozz::math::simd_int4::mask_sign_xyz();
EXPECT_SIMDINT_EQ(mask_sign_xyz, 0x80000000, 0x80000000, 0x80000000,
0x00000000);
const SimdInt4 mask_sign_w = ozz::math::simd_int4::mask_sign_w();
EXPECT_SIMDINT_EQ(mask_sign_w, 0x00000000, 0x00000000, 0x00000000,
0x80000000);
const SimdInt4 mask_not_sign = ozz::math::simd_int4::mask_not_sign();
EXPECT_SIMDINT_EQ(mask_not_sign, 0x7fffffff, 0x7fffffff, 0x7fffffff,
0x7fffffff);
const SimdInt4 mask_ffff = ozz::math::simd_int4::mask_ffff();
EXPECT_SIMDINT_EQ(mask_ffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff);
const SimdInt4 mask_0000 = ozz::math::simd_int4::mask_0000();
EXPECT_SIMDINT_EQ(mask_0000, 0, 0, 0, 0);
const SimdInt4 mask_fff0 = ozz::math::simd_int4::mask_fff0();
EXPECT_SIMDINT_EQ(mask_fff0, 0xffffffff, 0xffffffff, 0xffffffff, 0);
const SimdInt4 mask_f000 = ozz::math::simd_int4::mask_f000();
EXPECT_SIMDINT_EQ(mask_f000, 0xffffffff, 0, 0, 0);
const SimdInt4 mask_0f00 = ozz::math::simd_int4::mask_0f00();
EXPECT_SIMDINT_EQ(mask_0f00, 0, 0xffffffff, 0, 0);
const SimdInt4 mask_00f0 = ozz::math::simd_int4::mask_00f0();
EXPECT_SIMDINT_EQ(mask_00f0, 0, 0, 0xffffffff, 0);
const SimdInt4 mask_000f = ozz::math::simd_int4::mask_000f();
EXPECT_SIMDINT_EQ(mask_000f, 0, 0, 0, 0xffffffff);
}
TEST(SplatInt, ozz_simd_math) {
const SimdInt4 i = ozz::math::simd_int4::Load(1, -1, 2, -3);
const SimdInt4 x = ozz::math::SplatX(i);
EXPECT_SIMDINT_EQ(x, 1, 1, 1, 1);
const SimdInt4 y = ozz::math::SplatY(i);
EXPECT_SIMDINT_EQ(y, -1, -1, -1, -1);
const SimdInt4 z = ozz::math::SplatZ(i);
EXPECT_SIMDINT_EQ(z, 2, 2, 2, 2);
const SimdInt4 w = ozz::math::SplatW(i);
EXPECT_SIMDINT_EQ(w, -3, -3, -3, -3);
const SimdInt4 s3210 = ozz::math::Swizzle<3, 2, 1, 0>(i);
EXPECT_SIMDINT_EQ(s3210, -3, 2, -1, 1);
const SimdInt4 s0123 = ozz::math::Swizzle<0, 1, 2, 3>(i);
EXPECT_SIMDINT_EQ(s0123, 1, -1, 2, -3);
const SimdInt4 s0011 = ozz::math::Swizzle<0, 0, 1, 1>(i);
EXPECT_SIMDINT_EQ(s0011, 1, 1, -1, -1);
const SimdInt4 s2233 = ozz::math::Swizzle<2, 2, 3, 3>(i);
EXPECT_SIMDINT_EQ(s2233, 2, 2, -3, -3);
const SimdInt4 s0101 = ozz::math::Swizzle<0, 1, 0, 1>(i);
EXPECT_SIMDINT_EQ(s0101, 1, -1, 1, -1);
const SimdInt4 s2323 = ozz::math::Swizzle<2, 3, 2, 3>(i);
EXPECT_SIMDINT_EQ(s2323, 2, -3, 2, -3);
}
TEST(FromFloat, ozz_simd_math) {
const ozz::math::SimdFloat4 f =
ozz::math::simd_float4::Load(0.f, 46.93f, 46.26f, -93.99f);
EXPECT_SIMDINT_EQ(ozz::math::simd_int4::FromFloatRound(f), 0, 47, 46, -94);
EXPECT_SIMDINT_EQ(ozz::math::simd_int4::FromFloatTrunc(f), 0, 46, 46, -93);
}
TEST(ArithmeticInt, ozz_simd_math) {
const SimdInt4 a = ozz::math::simd_int4::Load(0, 1, 2, 3);
const SimdInt4 b = ozz::math::simd_int4::Load(4, 5, -6, 7);
const SimdInt4 hadd2 = ozz::math::HAdd2(a);
EXPECT_SIMDINT_EQ(hadd2, 1, 1, 2, 3);
const SimdInt4 hadd3 = ozz::math::HAdd3(a);
EXPECT_SIMDINT_EQ(hadd3, 3, 1, 2, 3);
const SimdInt4 hadd4 = ozz::math::HAdd4(a);
EXPECT_SIMDINT_EQ(hadd4, 6, 1, 2, 3);
const SimdInt4 abs = ozz::math::Abs(b);
EXPECT_SIMDINT_EQ(abs, 4, 5, 6, 7);
const SimdInt4 sign = ozz::math::Sign(b);
EXPECT_SIMDINT_EQ(sign, 0, 0, 0x80000000, 0);
}
TEST(CompareInt, ozz_simd_math) {
const SimdInt4 a = ozz::math::simd_int4::Load(0, 1, 2, 3);
const SimdInt4 b = ozz::math::simd_int4::Load(4, 1, -6, 7);
const SimdInt4 c = ozz::math::simd_int4::Load(4, 5, 6, 7);
const SimdInt4 min = ozz::math::Min(a, b);
EXPECT_SIMDINT_EQ(min, 0, 1, -6, 3);
const SimdInt4 max = ozz::math::Max(a, b);
EXPECT_SIMDINT_EQ(max, 4, 1, 2, 7);
const SimdInt4 min0 = ozz::math::Min0(b);
EXPECT_SIMDINT_EQ(min0, 0, 0, -6, 0);
const SimdInt4 max0 = ozz::math::Max0(b);
EXPECT_SIMDINT_EQ(max0, 4, 1, 0, 7);
EXPECT_SIMDINT_EQ(
ozz::math::Clamp(a, ozz::math::simd_int4::Load(-12, 2, 9, 3), c), 0, 2, 6,
3);
const SimdInt4 eq1 = ozz::math::CmpEq(a, b);
EXPECT_SIMDINT_EQ(eq1, 0, 0xffffffff, 0, 0);
const SimdInt4 eq2 = ozz::math::CmpEq(a, a);
EXPECT_SIMDINT_EQ(eq2, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff);
const SimdInt4 neq1 = ozz::math::CmpNe(a, b);
EXPECT_SIMDINT_EQ(neq1, 0xffffffff, 0, 0xffffffff, 0xffffffff);
const SimdInt4 neq2 = ozz::math::CmpNe(a, a);
EXPECT_SIMDINT_EQ(neq2, 0, 0, 0, 0);
const SimdInt4 lt = ozz::math::CmpLt(a, b);
EXPECT_SIMDINT_EQ(lt, 0xffffffff, 0, 0, 0xffffffff);
const SimdInt4 le = ozz::math::CmpLe(a, b);
EXPECT_SIMDINT_EQ(le, 0xffffffff, 0xffffffff, 0, 0xffffffff);
const SimdInt4 gt = ozz::math::CmpGt(a, b);
EXPECT_SIMDINT_EQ(gt, 0, 0, 0xffffffff, 0);
const SimdInt4 ge = ozz::math::CmpGe(a, b);
EXPECT_SIMDINT_EQ(ge, 0, 0xffffffff, 0xffffffff, 0);
}
TEST(MaskInt, ozz_simd_math) {
EXPECT_EQ(ozz::math::MoveMask(ozz::math::simd_int4::all_false()), 0x00000000);
EXPECT_EQ(ozz::math::MoveMask(ozz::math::simd_int4::all_true()), 0x0000000f);
EXPECT_EQ(ozz::math::MoveMask(ozz::math::simd_int4::mask_f000()), 0x00000001);
EXPECT_EQ(ozz::math::MoveMask(ozz::math::simd_int4::mask_0f00()), 0x00000002);
EXPECT_EQ(ozz::math::MoveMask(ozz::math::simd_int4::mask_00f0()), 0x00000004);
EXPECT_EQ(ozz::math::MoveMask(ozz::math::simd_int4::mask_000f()), 0x00000008);
EXPECT_EQ(ozz::math::MoveMask(ozz::math::simd_int4::Load(
0xffffffff, 0x00000000, 0x80000001, 0x7fffffff)),
0x00000005);
EXPECT_EQ(ozz::math::MoveMask(ozz::math::simd_int4::Load(
0xffffffff, 0x1000000f, 0x80000001, 0x8ffffffe)),
0x0000000d);
EXPECT_TRUE(ozz::math::AreAllFalse(ozz::math::simd_int4::all_false()));
EXPECT_FALSE(ozz::math::AreAllFalse(ozz::math::simd_int4::all_true()));
EXPECT_FALSE(ozz::math::AreAllFalse(ozz::math::simd_int4::mask_000f()));
EXPECT_TRUE(ozz::math::AreAllTrue(ozz::math::simd_int4::all_true()));
EXPECT_FALSE(ozz::math::AreAllTrue(ozz::math::simd_int4::all_false()));
EXPECT_FALSE(ozz::math::AreAllTrue(ozz::math::simd_int4::mask_000f()));
EXPECT_TRUE(ozz::math::AreAllFalse3(ozz::math::simd_int4::all_false()));
EXPECT_TRUE(ozz::math::AreAllFalse3(ozz::math::simd_int4::mask_000f()));
EXPECT_FALSE(ozz::math::AreAllFalse3(ozz::math::simd_int4::all_true()));
EXPECT_FALSE(ozz::math::AreAllFalse3(ozz::math::simd_int4::mask_f000()));
EXPECT_TRUE(ozz::math::AreAllTrue3(ozz::math::simd_int4::all_true()));
EXPECT_FALSE(ozz::math::AreAllTrue3(ozz::math::simd_int4::all_false()));
EXPECT_FALSE(ozz::math::AreAllTrue3(ozz::math::simd_int4::mask_f000()));
EXPECT_TRUE(ozz::math::AreAllFalse2(ozz::math::simd_int4::all_false()));
EXPECT_TRUE(ozz::math::AreAllFalse2(ozz::math::simd_int4::mask_000f()));
EXPECT_FALSE(ozz::math::AreAllFalse2(ozz::math::simd_int4::all_true()));
EXPECT_FALSE(ozz::math::AreAllFalse2(ozz::math::simd_int4::mask_f000()));
EXPECT_TRUE(ozz::math::AreAllTrue2(ozz::math::simd_int4::all_true()));
EXPECT_FALSE(ozz::math::AreAllTrue2(ozz::math::simd_int4::all_false()));
EXPECT_FALSE(ozz::math::AreAllTrue2(ozz::math::simd_int4::mask_f000()));
EXPECT_TRUE(ozz::math::AreAllFalse1(ozz::math::simd_int4::all_false()));
EXPECT_TRUE(ozz::math::AreAllFalse1(ozz::math::simd_int4::mask_000f()));
EXPECT_FALSE(ozz::math::AreAllFalse1(ozz::math::simd_int4::all_true()));
EXPECT_FALSE(ozz::math::AreAllFalse1(ozz::math::simd_int4::mask_f000()));
EXPECT_TRUE(ozz::math::AreAllTrue1(ozz::math::simd_int4::all_true()));
EXPECT_FALSE(ozz::math::AreAllTrue1(ozz::math::simd_int4::all_false()));
EXPECT_TRUE(ozz::math::AreAllTrue1(ozz::math::simd_int4::mask_f000()));
}
TEST(LogicalInt, ozz_simd_math) {
const SimdInt4 a = ozz::math::simd_int4::Load(0xffffffff, 0x00000000,
0x80000001, 0x7fffffff);
const SimdInt4 b = ozz::math::simd_int4::Load(0x80000001, 0xffffffff,
0x7fffffff, 0x00000000);
const SimdInt4 c = ozz::math::simd_int4::Load(0x01234567, 0x89abcdef,
0x01234567, 0x89abcdef);
const SimdInt4 cond = ozz::math::simd_int4::Load(0xffffffff, 0x00000000,
0xffffffff, 0x00000000);
const SimdInt4 andm = ozz::math::And(a, b);
EXPECT_SIMDINT_EQ(andm, 0x80000001, 0x00000000, 0x00000001, 0x00000000);
const SimdInt4 andnm = ozz::math::AndNot(a, b);
EXPECT_SIMDINT_EQ(andnm, 0x7ffffffe, 0x00000000, 0x80000000, 0x7fffffff);
const SimdInt4 orm = ozz::math::Or(a, b);
EXPECT_SIMDINT_EQ(orm, 0xffffffff, 0xffffffff, 0xffffffff, 0x7fffffff);
const SimdInt4 xorm = ozz::math::Xor(a, b);
EXPECT_SIMDINT_EQ(xorm, 0x7ffffffe, 0xffffffff, 0xfffffffe, 0x7fffffff);
const SimdInt4 select = ozz::math::Select(cond, b, c);
EXPECT_SIMDINT_EQ(select, 0x80000001, 0x89abcdef, 0x7fffffff, 0x89abcdef);
}
TEST(ShiftInt, ozz_simd_math) {
const SimdInt4 a = ozz::math::simd_int4::Load(0xffffffff, 0x00000000,
0x80000001, 0x7fffffff);
const SimdInt4 shift_l = ozz::math::ShiftL(a, 3);
EXPECT_SIMDINT_EQ(shift_l, 0xfffffff8, 0x00000000, 0x00000008, 0xfffffff8);
const SimdInt4 shift_r = ozz::math::ShiftR(a, 3);
EXPECT_SIMDINT_EQ(shift_r, 0xffffffff, 0x00000000, 0xf0000000, 0x0fffffff);
const SimdInt4 shift_ru = ozz::math::ShiftRu(a, 3);
EXPECT_SIMDINT_EQ(shift_ru, 0x1fffffff, 0x00000000, 0x10000000, 0x0fffffff);
}
Reference in New Issue View Git Blame Copy Permalink