dev0/IACore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

TestSuite
Some checks failed
CI / build-linux-and-wasm (x64-linux) (push) Has been cancelled
Details

Browse Source
This commit is contained in:
dev0
2026-01-23 05:52:26 +05:30
parent fc18c8667a
commit cfa0759133
37 changed files with 5631 additions and 1083 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
Tests/Unit/SIMD/FloatVec4.cpp
View File

@ -13,92 +13,88 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#include <IACore/SIMD.hpp>
#include <IACore/IATest.hpp>
#include <IACore/SIMD.hpp>
using namespace IACore;
IAT_BEGIN_BLOCK(Core, FloatVec4)
bool TestFloatArithmetic()
{
FloatVec4 v1(10.0f, 20.0f, 30.0f, 40.0f);
FloatVec4 v2(2.0f, 4.0f, 5.0f, 8.0f);
auto test_float_arithmetic() -> bool {
FloatVec4 v1(10.0f, 20.0f, 30.0f, 40.0f);
FloatVec4 v2(2.0f, 4.0f, 5.0f, 8.0f);
alignas(16) f32 res[4];
alignas(16) f32 res[4];
(v1 / v2).Store(res);
IAT_CHECK_APPROX(res[0], 5.0f);
IAT_CHECK_APPROX(res[3], 5.0f);
(v1 / v2).store(res);
IAT_CHECK_APPROX(res[0], 5.0f);
IAT_CHECK_APPROX(res[3], 5.0f);
(v1 * v2).Store(res);
IAT_CHECK_APPROX(res[0], 20.0f);
(v1 * v2).store(res);
IAT_CHECK_APPROX(res[0], 20.0f);
(v1 + v2).Store(res);
IAT_CHECK_APPROX(res[0], 12.0f);
(v1 + v2).store(res);
IAT_CHECK_APPROX(res[0], 12.0f);
return TRUE;
return true;
}
bool TestMathHelpers()
{
alignas(16) f32 res[4];
auto test_math_helpers() -> bool {
alignas(16) f32 res[4];
FloatVec4 vSq(4.0f, 9.0f, 16.0f, 25.0f);
vSq.Sqrt().Store(res);
IAT_CHECK_APPROX(res[0], 2.0f);
IAT_CHECK_APPROX(res[3], 5.0f);
FloatVec4 v_sq(4.0f, 9.0f, 16.0f, 25.0f);
v_sq.sqrt().store(res);
IAT_CHECK_APPROX(res[0], 2.0f);
IAT_CHECK_APPROX(res[3], 5.0f);
FloatVec4 vNeg(-1.0f, -5.0f, 10.0f, -0.0f);
vNeg.Abs().Store(res);
IAT_CHECK_APPROX(res[0], 1.0f);
IAT_CHECK_APPROX(res[2], 10.0f);
FloatVec4 v_neg(-1.0f, -5.0f, 10.0f, -0.0f);
v_neg.abs().store(res);
IAT_CHECK_APPROX(res[0], 1.0f);
IAT_CHECK_APPROX(res[2], 10.0f);
FloatVec4 vClamp(-100.0f, 0.0f, 50.0f, 200.0f);
vClamp.Clamp(0.0f, 100.0f).Store(res);
IAT_CHECK_APPROX(res[0], 0.0f);
IAT_CHECK_APPROX(res[2], 50.0f);
IAT_CHECK_APPROX(res[3], 100.0f);
FloatVec4 v_clamp(-100.0f, 0.0f, 50.0f, 200.0f);
v_clamp.clamp(0.0f, 100.0f).store(res);
IAT_CHECK_APPROX(res[0], 0.0f);
IAT_CHECK_APPROX(res[2], 50.0f);
IAT_CHECK_APPROX(res[3], 100.0f);
return TRUE;
return true;
}
bool TestApproxMath()
{
alignas(16) f32 res[4];
FloatVec4 v(16.0f, 25.0f, 100.0f, 1.0f);
auto test_approx_math() -> bool {
alignas(16) f32 res[4];
FloatVec4 v(16.0f, 25.0f, 100.0f, 1.0f);
v.Rsqrt().Store(res);
v.rsqrt().store(res);
IAT_CHECK_APPROX(res[0], 0.25f);
IAT_CHECK_APPROX(res[2], 0.1f);
IAT_CHECK_APPROX(res[0], 0.25f);
IAT_CHECK_APPROX(res[2], 0.1f);
return TRUE;
return true;
}
bool TestLinearAlgebra()
{
FloatVec4 v1(1.0f, 2.0f, 3.0f, 4.0f);
FloatVec4 v2(1.0f, 0.0f, 1.0f, 0.0f);
auto test_linear_algebra() -> bool {
FloatVec4 v1(1.0f, 2.0f, 3.0f, 4.0f);
FloatVec4 v2(1.0f, 0.0f, 1.0f, 0.0f);
f32 dot = v1.Dot(v2);
IAT_CHECK_APPROX(dot, 4.0f);
f32 dot = v1.dot(v2);
IAT_CHECK_APPROX(dot, 4.0f);
FloatVec4 vNorm(10.0f, 0.0f, 0.0f, 0.0f);
alignas(16) f32 res[4];
FloatVec4 v_norm(10.0f, 0.0f, 0.0f, 0.0f);
alignas(16) f32 res[4];
vNorm.Normalize().Store(res);
IAT_CHECK_APPROX(res[0], 1.0f);
IAT_CHECK_APPROX(res[1], 0.0f);
v_norm.normalize().store(res);
IAT_CHECK_APPROX(res[0], 1.0f);
IAT_CHECK_APPROX(res[1], 0.0f);
return TRUE;
return true;
}
IAT_BEGIN_TEST_LIST()
IAT_ADD_TEST(TestFloatArithmetic);
IAT_ADD_TEST(TestMathHelpers);
IAT_ADD_TEST(TestApproxMath);
IAT_ADD_TEST(TestLinearAlgebra);
IAT_ADD_TEST(test_float_arithmetic);
IAT_ADD_TEST(test_math_helpers);
IAT_ADD_TEST(test_approx_math);
IAT_ADD_TEST(test_linear_algebra);
IAT_END_TEST_LIST()
IAT_END_BLOCK()

176
Tests/Unit/SIMD/IntVec4.cpp
View File

@ -13,138 +13,130 @@
// See the License for the specific language governing permissions and
// limitations under the License.
// IACore-OSS; The Core Library for All IA Open Source Projects
// Copyright (C) 2026 IAS (ias@iasoft.dev)
#include <IACore/SIMD.hpp>
#include <IACore/IATest.hpp>
#include <IACore/SIMD.hpp>
using namespace IACore;
IAT_BEGIN_BLOCK(Core, IntVec4)
bool TestConstructors()
{
IntVec4 vBroadcast(10);
alignas(16) u32 storeBuf[4];
vBroadcast.Store(storeBuf);
auto test_constructors() -> bool {
IntVec4 v_broadcast(10);
alignas(16) u32 store_buf[4];
v_broadcast.store(store_buf);
IAT_CHECK_EQ(storeBuf[0], 10U);
IAT_CHECK_EQ(storeBuf[3], 10U);
IAT_CHECK_EQ(store_buf[0], 10U);
IAT_CHECK_EQ(store_buf[3], 10U);
IntVec4 vComp(1, 2, 3, 4);
vComp.Store(storeBuf);
IAT_CHECK_EQ(storeBuf[0], 1U);
IAT_CHECK_EQ(storeBuf[3], 4U);
IntVec4 v_comp(1, 2, 3, 4);
v_comp.store(store_buf);
IAT_CHECK_EQ(store_buf[0], 1U);
IAT_CHECK_EQ(store_buf[3], 4U);
alignas(16) u32 srcBuf[4] = {100, 200, 300, 400};
IntVec4 vLoad = IntVec4::Load(srcBuf);
vLoad.Store(storeBuf);
IAT_CHECK_EQ(storeBuf[1], 200U);
alignas(16) u32 src_buf[4] = {100, 200, 300, 400};
IntVec4 v_load = IntVec4::load(src_buf);
v_load.store(store_buf);
IAT_CHECK_EQ(store_buf[1], 200U);
return TRUE;
return true;
}
bool TestArithmetic()
{
IntVec4 v1(10, 20, 30, 40);
IntVec4 v2(1, 2, 3, 4);
auto test_arithmetic() -> bool {
const IntVec4 v1(10, 20, 30, 40);
const IntVec4 v2(1, 2, 3, 4);
IntVec4 vAdd = v1 + v2;
alignas(16) u32 res[4];
vAdd.Store(res);
IAT_CHECK_EQ(res[0], 11U);
IAT_CHECK_EQ(res[3], 44U);
IntVec4 v_add = v1 + v2;
alignas(16) u32 res[4];
v_add.store(res);
IAT_CHECK_EQ(res[0], 11U);
IAT_CHECK_EQ(res[3], 44U);
IntVec4 vSub = v1 - v2;
vSub.Store(res);
IAT_CHECK_EQ(res[0], 9U);
IntVec4 v_sub = v1 - v2;
v_sub.store(res);
IAT_CHECK_EQ(res[0], 9U);
IntVec4 vMul = v1 * v2;
vMul.Store(res);
IAT_CHECK_EQ(res[0], 10U);
IAT_CHECK_EQ(res[2], 90U);
IAT_CHECK_EQ(res[3], 160U);
IntVec4 v_mul = v1 * v2;
v_mul.store(res);
IAT_CHECK_EQ(res[0], 10U);
IAT_CHECK_EQ(res[2], 90U);
IAT_CHECK_EQ(res[3], 160U);
return TRUE;
return true;
}
bool TestBitwise()
{
IntVec4 vAllOnes(0xFFFFFFFF);
IntVec4 vZero((u32) 0);
IntVec4 vPattern(0xAAAAAAAA);
auto test_bitwise() -> bool {
const IntVec4 v_all_ones(0xFFFFFFFF);
const IntVec4 v_zero((u32)0);
const IntVec4 v_pattern(0xAAAAAAAA);
alignas(16) u32 res[4];
alignas(16) u32 res[4];
(vAllOnes & vPattern).Store(res);
IAT_CHECK_EQ(res[0], 0xAAAAAAAAU);
(v_all_ones & v_pattern).store(res);
IAT_CHECK_EQ(res[0], 0xAAAAAAAAU);
(vZero | vPattern).Store(res);
IAT_CHECK_EQ(res[0], 0xAAAAAAAAU);
(v_zero | v_pattern).store(res);
IAT_CHECK_EQ(res[0], 0xAAAAAAAAU);
(vAllOnes ^ vPattern).Store(res);
IAT_CHECK_EQ(res[0], 0x55555555U);
(v_all_ones ^ v_pattern).store(res);
IAT_CHECK_EQ(res[0], 0x55555555U);
(~vPattern).Store(res);
IAT_CHECK_EQ(res[0], 0x55555555U);
(~v_pattern).store(res);
IAT_CHECK_EQ(res[0], 0x55555555U);
IntVec4 vShift(1);
(vShift << 1).Store(res);
IAT_CHECK_EQ(res[0], 2U);
const IntVec4 v_shift(1);
(v_shift << 1).store(res);
IAT_CHECK_EQ(res[0], 2U);
IntVec4 vShiftRight(4);
(vShiftRight >> 1).Store(res);
IAT_CHECK_EQ(res[0], 2U);
const IntVec4 v_shift_right(4);
(v_shift_right >> 1).store(res);
IAT_CHECK_EQ(res[0], 2U);
return TRUE;
return true;
}
bool TestSaturation()
{
u32 max = 0xFFFFFFFF;
IntVec4 vHigh(max - 10);
IntVec4 vAdd(20);
auto test_saturation() -> bool {
const u32 max = 0xFFFFFFFF;
const IntVec4 v_high(max - 10);
const IntVec4 v_add(20);
alignas(16) u32 res[4];
alignas(16) u32 res[4];
vHigh.SatAdd(vAdd).Store(res);
IAT_CHECK_EQ(res[0], max);
v_high.sat_add(v_add).store(res);
IAT_CHECK_EQ(res[0], max);
IntVec4 vLow(10);
IntVec4 vSub(20);
vLow.SatSub(vSub).Store(res);
IAT_CHECK_EQ(res[0], 0U);
const IntVec4 v_low(10);
const IntVec4 v_sub(20);
v_low.sat_sub(v_sub).store(res);
IAT_CHECK_EQ(res[0], 0U);
return TRUE;
return true;
}
bool TestAdvancedOps()
{
IntVec4 v(0, 50, 100, 150);
alignas(16) u32 res[4];
auto test_advanced_ops() -> bool {
const IntVec4 v(0, 50, 100, 150);
alignas(16) u32 res[4];
v.Clamp(40, 110).Store(res);
IAT_CHECK_EQ(res[0], 40U);
IAT_CHECK_EQ(res[1], 50U);
IAT_CHECK_EQ(res[2], 100U);
IAT_CHECK_EQ(res[3], 110U);
v.clamp(40, 110).store(res);
IAT_CHECK_EQ(res[0], 40U);
IAT_CHECK_EQ(res[1], 50U);
IAT_CHECK_EQ(res[2], 100U);
IAT_CHECK_EQ(res[3], 110U);
IntVec4 A(2);
IntVec4 B(10);
IntVec4 C(5);
A.MultAdd(B, C).Store(res);
IAT_CHECK_EQ(res[0], 25U);
const IntVec4 a(2);
const IntVec4 b(10);
const IntVec4 c(5);
a.mult_add(b, c).store(res);
IAT_CHECK_EQ(res[0], 25U);
return TRUE;
return true;
}
IAT_BEGIN_TEST_LIST()
IAT_ADD_TEST(TestConstructors);
IAT_ADD_TEST(TestArithmetic);
IAT_ADD_TEST(TestBitwise);
IAT_ADD_TEST(TestSaturation);
IAT_ADD_TEST(TestAdvancedOps);
IAT_ADD_TEST(test_constructors);
IAT_ADD_TEST(test_arithmetic);
IAT_ADD_TEST(test_bitwise);
IAT_ADD_TEST(test_saturation);
IAT_ADD_TEST(test_advanced_ops);
IAT_END_TEST_LIST()
IAT_END_BLOCK()