// SPDX-License-Identifier: Apache-2.0

// ----------------------------------------------------------------------------

// Copyright 2020-2025 Arm Limited

//

// Licensed under the Apache License, Version 2.0 (the "License"); you may not

// use this file except in compliance with the License. You may obtain a copy

// of the License at:

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

// License for the specific language governing permissions and limitations

// under the License.

// ----------------------------------------------------------------------------

/**

* @brief Unit tests for the vectorized SIMD functionality.

*/

#include <limits>

#include "gtest/gtest.h"

#include "../astcenc_internal.h"

#include "../astcenc_vecmathlib.h"

namespace astcenc

{

// Misc utility tests - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

#if ASTCENC_SIMD_WIDTH == 8

/**

* @brief Construct from 8 scalar values.

*

* The value of @c a is stored to lane 0 (LSB) in the SIMD register.

*/

static vfloat8 vfloat8_lit(

float a, float b, float c, float d,

float e, float f, float g, float h

) {

alignas(32) float data[8] {

a, b, c, d, e, f, g, h

};

return vfloat8(data);

}

/**

* @brief Construct from 8 scalar values.

*

* The value of @c a is stored to lane 0 (LSB) in the SIMD register.

*/

static vint8 vint8_lit(

int a, int b, int c, int d,

int e, int f, int g, int h

) {

alignas(32) int data[8] {

a, b, c, d, e, f, g, h

};

return vint8(data);

}

#endif

static unsigned int round_down(unsigned int x)

{

unsigned int remainder = x % ASTCENC_SIMD_WIDTH;

return x - remainder;

}

static unsigned int round_up(unsigned int x)

{

unsigned int remainder = x % ASTCENC_SIMD_WIDTH;

if (!remainder)

{

return x;

}

return x - remainder + ASTCENC_SIMD_WIDTH;

}

/** @brief Test VLA loop limit round down. */

TEST(SuiteMisc, RoundDownVLA)

{

// Static ones which are valid for all VLA widths

EXPECT_EQ(round_down_to_simd_multiple_vla(0), 0u);

EXPECT_EQ(round_down_to_simd_multiple_vla(8), 8u);

EXPECT_EQ(round_down_to_simd_multiple_vla(16), 16u);

// Variable ones which depend on VLA width

EXPECT_EQ(round_down_to_simd_multiple_vla(3), round_down(3));

EXPECT_EQ(round_down_to_simd_multiple_vla(5), round_down(5));

EXPECT_EQ(round_down_to_simd_multiple_vla(7), round_down(7));

EXPECT_EQ(round_down_to_simd_multiple_vla(231), round_down(231));

}

/** @brief Test VLA loop limit round up. */

TEST(SuiteMisc, RoundUpVLA)

{

// Static ones which are valid for all VLA widths

EXPECT_EQ(round_up_to_simd_multiple_vla(0), 0u);

EXPECT_EQ(round_up_to_simd_multiple_vla(8), 8u);

EXPECT_EQ(round_up_to_simd_multiple_vla(16), 16u);

// Variable ones which depend on VLA width

EXPECT_EQ(round_up_to_simd_multiple_vla(3), round_up(3));

EXPECT_EQ(round_up_to_simd_multiple_vla(5), round_up(5));

EXPECT_EQ(round_up_to_simd_multiple_vla(7), round_up(7));

EXPECT_EQ(round_up_to_simd_multiple_vla(231), round_up(231));

}

#if ASTCENC_SIMD_WIDTH == 1

// VLA (1-wide) tests - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

/** @brief Test VLA change_sign. */

TEST(SuiteVfloat, ChangeSign)

{

vfloat a0(-1.0f);

vfloat b0(-1.0f);

vfloat r0 = change_sign(a0, b0);

EXPECT_EQ(r0.lane<0>(), 1.0f);

vfloat a1( 1.0f);

vfloat b1(-1.0f);

vfloat r1 = change_sign(a1, b1);

EXPECT_EQ(r1.lane<0>(), -1.0f);

vfloat a2(-3.12f);

vfloat b2( 3.12f);

vfloat r2 = change_sign(a2, b2);

EXPECT_EQ(r2.lane<0>(), -3.12f);

vfloat a3( 3.12f);

vfloat b3( 3.12f);

vfloat r3 = change_sign(a3, b3);

EXPECT_EQ(r3.lane<0>(), 3.12f);

}

/** @brief Test VLA atan. */

TEST(SuiteVfloat, Atan)

{

vfloat a0(-0.15f);

vfloat r0 = atan(a0);

EXPECT_NEAR(r0.lane<0>(), -0.149061f, 0.005f);

vfloat a1(0.0f);

vfloat r1 = atan(a1);

EXPECT_NEAR(r1.lane<0>(), 0.000000f, 0.005f);

vfloat a2(0.9f);

vfloat r2 = atan(a2);

EXPECT_NEAR(r2.lane<0>(), 0.733616f, 0.005f);

vfloat a3(2.1f);

vfloat r3 = atan(a3);

EXPECT_NEAR(r3.lane<0>(), 1.123040f, 0.005f);

}

/** @brief Test VLA atan2. */

TEST(SuiteVfloat, Atan2)

{

vfloat a0(-0.15f);

vfloat b0( 1.15f);

vfloat r0 = atan2(a0, b0);

EXPECT_NEAR(r0.lane<0>(), -0.129816f, 0.005f);

vfloat a1( 0.0f);

vfloat b1(-3.0f);

vfloat r1 = atan2(a1, b1);

EXPECT_NEAR(r1.lane<0>(), 3.141592f, 0.005f);

vfloat a2( 0.9f);

vfloat b2(-0.9f);

vfloat r2 = atan2(a2, b2);

EXPECT_NEAR(r2.lane<0>(), 2.360342f, 0.005f);

vfloat a3( 2.1f);

vfloat b3( 1.1f);

vfloat r3 = atan2(a3, b3);

EXPECT_NEAR(r3.lane<0>(), 1.084357f, 0.005f);

}

#elif ASTCENC_SIMD_WIDTH == 4

// VLA (4-wide) tests - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

/** @brief Test VLA change_sign. */

TEST(SuiteVfloat, ChangeSign)

{

vfloat4 a(-1.0f, 1.0f, -3.12f, 3.12f);

vfloat4 b(-1.0f, -1.0f, 3.12f, 3.12f);

vfloat4 r = change_sign(a, b);

EXPECT_EQ(r.lane<0>(), 1.0f);

EXPECT_EQ(r.lane<1>(), -1.0f);

EXPECT_EQ(r.lane<2>(), -3.12f);

EXPECT_EQ(r.lane<3>(), 3.12f);

}

/** @brief Test VLA atan. */

TEST(SuiteVfloat, Atan)

{

vfloat4 a(-0.15f, 0.0f, 0.9f, 2.1f);

vfloat4 r = atan(a);

EXPECT_NEAR(r.lane<0>(), -0.149061f, 0.005f);

EXPECT_NEAR(r.lane<1>(), 0.000000f, 0.005f);

EXPECT_NEAR(r.lane<2>(), 0.733616f, 0.005f);

EXPECT_NEAR(r.lane<3>(), 1.123040f, 0.005f);

}

/** @brief Test VLA atan2. */

TEST(SuiteVfloat, Atan2)

{

vfloat4 a(-0.15f, 0.0f, 0.9f, 2.1f);

vfloat4 b(1.15f, -3.0f, -0.9f, 1.1f);

vfloat4 r = atan2(a, b);

EXPECT_NEAR(r.lane<0>(), -0.129816f, 0.005f);

EXPECT_NEAR(r.lane<1>(), 3.141592f, 0.005f);

EXPECT_NEAR(r.lane<2>(), 2.360342f, 0.005f);

EXPECT_NEAR(r.lane<3>(), 1.084357f, 0.005f);

}

#elif ASTCENC_SIMD_WIDTH == 8

// VLA (8-wide) tests - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

/** @brief Test VLA change_sign. */

TEST(SuiteVfloat, ChangeSign)

{

vfloat8 a = vfloat8_lit(-1.0f, 1.0f, -3.12f, 3.12f, -1.0f, 1.0f, -3.12f, 3.12f);

vfloat8 b = vfloat8_lit(-1.0f, -1.0f, 3.12f, 3.12f, -1.0f, -1.0f, 3.12f, 3.12f);

vfloat8 r = change_sign(a, b);

alignas(32) float ra[8];

storea(r, ra);

EXPECT_EQ(ra[0], 1.0f);

EXPECT_EQ(ra[1], -1.0f);

EXPECT_EQ(ra[2], -3.12f);

EXPECT_EQ(ra[3], 3.12f);

EXPECT_EQ(ra[4], 1.0f);

EXPECT_EQ(ra[5], -1.0f);

EXPECT_EQ(ra[6], -3.12f);

EXPECT_EQ(ra[7], 3.12f);

}

/** @brief Test VLA atan. */

TEST(SuiteVfloat, Atan)

{

vfloat8 a = vfloat8_lit(-0.15f, 0.0f, 0.9f, 2.1f, -0.15f, 0.0f, 0.9f, 2.1f);

vfloat8 r = atan(a);

alignas(32) float ra[8];

storea(r, ra);

EXPECT_NEAR(ra[0], -0.149061f, 0.005f);

EXPECT_NEAR(ra[1], 0.000000f, 0.005f);

EXPECT_NEAR(ra[2], 0.733616f, 0.005f);

EXPECT_NEAR(ra[3], 1.123040f, 0.005f);

EXPECT_NEAR(ra[4], -0.149061f, 0.005f);

EXPECT_NEAR(ra[5], 0.000000f, 0.005f);

EXPECT_NEAR(ra[6], 0.733616f, 0.005f);

EXPECT_NEAR(ra[7], 1.123040f, 0.005f);

}

/** @brief Test VLA atan2. */

TEST(SuiteVfloat, Atan2)

{

vfloat8 a = vfloat8_lit(-0.15f, 0.0f, 0.9f, 2.1f, -0.15f, 0.0f, 0.9f, 2.1f);

vfloat8 b = vfloat8_lit(1.15f, -3.0f, -0.9f, 1.1f, 1.15f, -3.0f, -0.9f, 1.1f);

vfloat8 r = atan2(a, b);

alignas(32) float ra[8];

storea(r, ra);

EXPECT_NEAR(ra[0], -0.129816f, 0.005f);

EXPECT_NEAR(ra[1], 3.141592f, 0.005f);

EXPECT_NEAR(ra[2], 2.360342f, 0.005f);

EXPECT_NEAR(ra[3], 1.084357f, 0.005f);

EXPECT_NEAR(ra[4], -0.129816f, 0.005f);

EXPECT_NEAR(ra[5], 3.141592f, 0.005f);

EXPECT_NEAR(ra[6], 2.360342f, 0.005f);

EXPECT_NEAR(ra[7], 1.084357f, 0.005f);

}

#endif

static const float qnan = std::numeric_limits<float>::quiet_NaN();

alignas(32) static const float f32_data[9] {

0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f

};

alignas(32) static const int s32_data[9] {

0, 1, 2, 3, 4, 5 , 6, 7, 8

};

alignas(32) static const uint8_t u8_data[9] {

0, 1, 2, 3, 4, 5 , 6, 7, 8

};

// VFLOAT4 tests - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

/** @brief Test unaligned vfloat4 data load. */

TEST(SuiteVfloat4, UnalignedLoad)

{

vfloat4 a(&(f32_data[1]));

EXPECT_EQ(a.lane<0>(), 1.0f);

EXPECT_EQ(a.lane<1>(), 2.0f);

EXPECT_EQ(a.lane<2>(), 3.0f);

EXPECT_EQ(a.lane<3>(), 4.0f);

}

/** @brief Test scalar duplicated vfloat4 load. */

TEST(SuiteVfloat4, ScalarDupLoad)

{

vfloat4 a(1.1f);

EXPECT_EQ(a.lane<0>(), 1.1f);

EXPECT_EQ(a.lane<1>(), 1.1f);

EXPECT_EQ(a.lane<2>(), 1.1f);

EXPECT_EQ(a.lane<3>(), 1.1f);

}

/** @brief Test scalar vfloat4 load. */

TEST(SuiteVfloat4, ScalarLoad)

{

vfloat4 a(1.1f, 2.2f, 3.3f, 4.4f);

EXPECT_EQ(a.lane<0>(), 1.1f);

EXPECT_EQ(a.lane<1>(), 2.2f);

EXPECT_EQ(a.lane<2>(), 3.3f);

EXPECT_EQ(a.lane<3>(), 4.4f);

}

/** @brief Test copy vfloat4 load. */

TEST(SuiteVfloat4, CopyLoad)

{

vfloat4 s(1.1f, 2.2f, 3.3f, 4.4f);

vfloat4 a(s.m);

EXPECT_EQ(a.lane<0>(), 1.1f);

EXPECT_EQ(a.lane<1>(), 2.2f);

EXPECT_EQ(a.lane<2>(), 3.3f);

EXPECT_EQ(a.lane<3>(), 4.4f);

}

/** @brief Test vfloat4 scalar lane set. */

TEST(SuiteVfloat4, SetLane)

{

vfloat4 a(0.0f);

a.set_lane<0>(1.0f);

EXPECT_EQ(a.lane<0>(), 1.0f);

EXPECT_EQ(a.lane<1>(), 0.0f);

EXPECT_EQ(a.lane<2>(), 0.0f);

EXPECT_EQ(a.lane<3>(), 0.0f);

a.set_lane<1>(2.0f);

EXPECT_EQ(a.lane<0>(), 1.0f);

EXPECT_EQ(a.lane<1>(), 2.0f);

EXPECT_EQ(a.lane<2>(), 0.0f);

EXPECT_EQ(a.lane<3>(), 0.0f);

a.set_lane<2>(3.0f);

EXPECT_EQ(a.lane<0>(), 1.0f);

EXPECT_EQ(a.lane<1>(), 2.0f);

EXPECT_EQ(a.lane<2>(), 3.0f);

EXPECT_EQ(a.lane<3>(), 0.0f);

a.set_lane<3>(4.0f);

EXPECT_EQ(a.lane<0>(), 1.0f);

EXPECT_EQ(a.lane<1>(), 2.0f);

EXPECT_EQ(a.lane<2>(), 3.0f);

EXPECT_EQ(a.lane<3>(), 4.0f);

}

/** @brief Test vfloat4 zero. */

TEST(SuiteVfloat4, Zero)

{

vfloat4 a = vfloat4::zero();

EXPECT_EQ(a.lane<0>(), 0.0f);

EXPECT_EQ(a.lane<1>(), 0.0f);

EXPECT_EQ(a.lane<2>(), 0.0f);

EXPECT_EQ(a.lane<3>(), 0.0f);

}

/** @brief Test vfloat4 load1. */

TEST(SuiteVfloat4, Load1)

{

float s = 3.14f;

vfloat4 a = vfloat4::load1(&s);

EXPECT_EQ(a.lane<0>(), 3.14f);

EXPECT_EQ(a.lane<1>(), 3.14f);

EXPECT_EQ(a.lane<2>(), 3.14f);

EXPECT_EQ(a.lane<3>(), 3.14f);

}

/** @brief Test vfloat4 loada. */

TEST(SuiteVfloat4, Loada)

{

vfloat4 a = vfloat4::loada(&(f32_data[0]));

EXPECT_EQ(a.lane<0>(), 0.0f);

EXPECT_EQ(a.lane<1>(), 1.0f);

EXPECT_EQ(a.lane<2>(), 2.0f);

EXPECT_EQ(a.lane<3>(), 3.0f);

}

/** @brief Test vfloat4 swz to float4. */

TEST(SuiteVfloat4, swz4)

{

vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 r = a.swz<0, 3, 2, 1>();

EXPECT_EQ(r.lane<0>(), 1.0f);

EXPECT_EQ(r.lane<1>(), 4.0f);

EXPECT_EQ(r.lane<2>(), 3.0f);

EXPECT_EQ(r.lane<3>(), 2.0f);

r = a.swz<3, 1, 1, 0>();

EXPECT_EQ(r.lane<0>(), 4.0f);

EXPECT_EQ(r.lane<1>(), 2.0f);

EXPECT_EQ(r.lane<2>(), 2.0f);

EXPECT_EQ(r.lane<3>(), 1.0f);

}

/** @brief Test vfloat4 swz to float3. */

TEST(SuiteVfloat4, swz3)

{

vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 r = a.swz<0, 3, 2>();

EXPECT_EQ(r.lane<0>(), 1.0f);

EXPECT_EQ(r.lane<1>(), 4.0f);

EXPECT_EQ(r.lane<2>(), 3.0f);

EXPECT_EQ(r.lane<3>(), 0.0f);

r = a.swz<3, 1, 1>();

EXPECT_EQ(r.lane<0>(), 4.0f);

EXPECT_EQ(r.lane<1>(), 2.0f);

EXPECT_EQ(r.lane<2>(), 2.0f);

EXPECT_EQ(r.lane<3>(), 0.0f);

}

/** @brief Test vfloat4 swz to float2. */

TEST(SuiteVfloat4, swz2)

{

vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 r = a.swz<0, 3>();

EXPECT_EQ(r.lane<0>(), 1.0f);

EXPECT_EQ(r.lane<1>(), 4.0f);

r = a.swz<2, 1>();

EXPECT_EQ(r.lane<0>(), 3.0f);

EXPECT_EQ(r.lane<1>(), 2.0f);

}

/** @brief Test vfloat4 add. */

TEST(SuiteVfloat4, vadd)

{

vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 b(0.1f, 0.2f, 0.3f, 0.4f);

a = a + b;

EXPECT_EQ(a.lane<0>(), 1.0f + 0.1f);

EXPECT_EQ(a.lane<1>(), 2.0f + 0.2f);

EXPECT_EQ(a.lane<2>(), 3.0f + 0.3f);

EXPECT_EQ(a.lane<3>(), 4.0f + 0.4f);

}

/** @brief Test vfloat4 self-add. */

TEST(SuiteVfloat4, vselfadd1)

{

vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 b(0.1f, 0.2f, 0.3f, 0.4f);

// Test increment by another variable

a += b;

EXPECT_EQ(a.lane<0>(), 1.0f + 0.1f);

EXPECT_EQ(a.lane<1>(), 2.0f + 0.2f);

EXPECT_EQ(a.lane<2>(), 3.0f + 0.3f);

EXPECT_EQ(a.lane<3>(), 4.0f + 0.4f);

// Test increment by an expression

a += b + b;

EXPECT_NEAR(a.lane<0>(), 1.0f + 0.3f, 0.001f);

EXPECT_NEAR(a.lane<1>(), 2.0f + 0.6f, 0.001f);

EXPECT_NEAR(a.lane<2>(), 3.0f + 0.9f, 0.001f);

EXPECT_NEAR(a.lane<3>(), 4.0f + 1.2f, 0.001f);

}

/** @brief Test vfloat4 sub. */

TEST(SuiteVfloat4, vsub)

{

vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 b(0.1f, 0.2f, 0.3f, 0.4f);

a = a - b;

EXPECT_EQ(a.lane<0>(), 1.0f - 0.1f);

EXPECT_EQ(a.lane<1>(), 2.0f - 0.2f);

EXPECT_EQ(a.lane<2>(), 3.0f - 0.3f);

EXPECT_EQ(a.lane<3>(), 4.0f - 0.4f);

}

/** @brief Test vfloat4 mul. */

TEST(SuiteVfloat4, vmul)

{

vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 b(0.1f, 0.2f, 0.3f, 0.4f);

a = a * b;

EXPECT_EQ(a.lane<0>(), 1.0f * 0.1f);

EXPECT_EQ(a.lane<1>(), 2.0f * 0.2f);

EXPECT_EQ(a.lane<2>(), 3.0f * 0.3f);

EXPECT_EQ(a.lane<3>(), 4.0f * 0.4f);

}

/** @brief Test vfloat4 mul. */

TEST(SuiteVfloat4, vsmul)

{

vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);

float b = 3.14f;

a = a * b;

EXPECT_EQ(a.lane<0>(), 1.0f * 3.14f);

EXPECT_EQ(a.lane<1>(), 2.0f * 3.14f);

EXPECT_EQ(a.lane<2>(), 3.0f * 3.14f);

EXPECT_EQ(a.lane<3>(), 4.0f * 3.14f);

}

/** @brief Test vfloat4 mul. */

TEST(SuiteVfloat4, svmul)

{

float a = 3.14f;

vfloat4 b(1.0f, 2.0f, 3.0f, 4.0f);

b = a * b;

EXPECT_EQ(b.lane<0>(), 3.14f * 1.0f);

EXPECT_EQ(b.lane<1>(), 3.14f * 2.0f);

EXPECT_EQ(b.lane<2>(), 3.14f * 3.0f);

EXPECT_EQ(b.lane<3>(), 3.14f * 4.0f);

}

/** @brief Test vfloat4 div. */

TEST(SuiteVfloat4, vdiv)

{

vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 b(0.1f, 0.2f, 0.3f, 0.4f);

a = a / b;

EXPECT_EQ(a.lane<0>(), 1.0f / 0.1f);

EXPECT_EQ(a.lane<1>(), 2.0f / 0.2f);

EXPECT_EQ(a.lane<2>(), 3.0f / 0.3f);

EXPECT_EQ(a.lane<3>(), 4.0f / 0.4f);

}

/** @brief Test vfloat4 div. */

TEST(SuiteVfloat4, vsdiv)

{

vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);

float b = 0.3f;

a = a / b;

EXPECT_EQ(a.lane<0>(), 1.0f / 0.3f);

EXPECT_EQ(a.lane<1>(), 2.0f / 0.3f);

EXPECT_EQ(a.lane<2>(), 3.0f / 0.3f);

EXPECT_EQ(a.lane<3>(), 4.0f / 0.3f);

}

/** @brief Test vfloat4 div. */

TEST(SuiteVfloat4, svdiv)

{

float a = 3.0f;

vfloat4 b(0.1f, 0.2f, 0.3f, 0.4f);

b = a / b;

EXPECT_EQ(b.lane<0>(), 3.0f / 0.1f);

EXPECT_EQ(b.lane<1>(), 3.0f / 0.2f);

EXPECT_EQ(b.lane<2>(), 3.0f / 0.3f);

EXPECT_EQ(b.lane<3>(), 3.0f / 0.4f);

}

/** @brief Test vfloat4 ceq. */

TEST(SuiteVfloat4, ceq)

{

vfloat4 a1(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 b1(0.1f, 0.2f, 0.3f, 0.4f);

vmask4 r1 = a1 == b1;

EXPECT_EQ(0u, mask(r1));

EXPECT_EQ(false, any(r1));

EXPECT_EQ(false, all(r1));

vfloat4 a2(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 b2(1.0f, 0.2f, 0.3f, 0.4f);

vmask4 r2 = a2 == b2;

EXPECT_EQ(0x1u, mask(r2));

EXPECT_EQ(true, any(r2));

EXPECT_EQ(false, all(r2));

vfloat4 a3(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 b3(1.0f, 0.2f, 3.0f, 0.4f);

vmask4 r3 = a3 == b3;

EXPECT_EQ(0x5u, mask(r3));

EXPECT_EQ(true, any(r3));

EXPECT_EQ(false, all(r3));

vfloat4 a4(1.0f, 2.0f, 3.0f, 4.0f);

vmask4 r4 = a4 == a4;

EXPECT_EQ(0xFu, mask(r4));

EXPECT_EQ(true, any(r4));

EXPECT_EQ(true, all(r4));

}

/** @brief Test vfloat4 cne. */

TEST(SuiteVfloat4, cne)

{

vfloat4 a1(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 b1(0.1f, 0.2f, 0.3f, 0.4f);

vmask4 r1 = a1 != b1;

EXPECT_EQ(0xFu, mask(r1));

EXPECT_EQ(true, any(r1));

EXPECT_EQ(true, all(r1));

vfloat4 a2(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 b2(1.0f, 0.2f, 0.3f, 0.4f);

vmask4 r2 = a2 != b2;

EXPECT_EQ(0xEu, mask(r2));

EXPECT_EQ(true, any(r2));

EXPECT_EQ(false, all(r2));

vfloat4 a3(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 b3(1.0f, 0.2f, 3.0f, 0.4f);

vmask4 r3 = a3 != b3;

EXPECT_EQ(0xAu, mask(r3));

EXPECT_EQ(true, any(r3));

EXPECT_EQ(false, all(r3));

vfloat4 a4(1.0f, 2.0f, 3.0f, 4.0f);

vmask4 r4 = a4 != a4;

EXPECT_EQ(0u, mask(r4));

EXPECT_EQ(false, any(r4));

EXPECT_EQ(false, all(r4));

}

/** @brief Test vfloat4 clt. */

TEST(SuiteVfloat4, clt)

{

vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 b(0.9f, 2.1f, 3.0f, 4.1f);

vmask4 r = a < b;

EXPECT_EQ(0xAu, mask(r));

}

/** @brief Test vfloat4 cle. */

TEST(SuiteVfloat4, cle)

{

vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 b(0.9f, 2.1f, 3.0f, 4.1f);

vmask4 r = a <= b;

EXPECT_EQ(0xEu, mask(r));

}

/** @brief Test vfloat4 cgt. */

TEST(SuiteVfloat4, cgt)

{

vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 b(0.9f, 2.1f, 3.0f, 4.1f);

vmask4 r = a > b;

EXPECT_EQ(0x1u, mask(r));

}

/** @brief Test vfloat4 cge. */

TEST(SuiteVfloat4, cge)

{

vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 b(0.9f, 2.1f, 3.0f, 4.1f);

vmask4 r = a >= b;

EXPECT_EQ(0x5u, mask(r));

}

/** @brief Test vfloat4 min. */

TEST(SuiteVfloat4, min)

{

vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 b(0.9f, 2.1f, 3.0f, 4.1f);

vfloat4 r = min(a, b);

EXPECT_EQ(r.lane<0>(), 0.9f);

EXPECT_EQ(r.lane<1>(), 2.0f);

EXPECT_EQ(r.lane<2>(), 3.0f);

EXPECT_EQ(r.lane<3>(), 4.0f);

float c = 0.3f;

r = min(a, c);

EXPECT_EQ(r.lane<0>(), 0.3f);

EXPECT_EQ(r.lane<1>(), 0.3f);

EXPECT_EQ(r.lane<2>(), 0.3f);

EXPECT_EQ(r.lane<3>(), 0.3f);

float d = 1.5f;

r = min(a, d);

EXPECT_EQ(r.lane<0>(), 1.0f);

EXPECT_EQ(r.lane<1>(), 1.5f);

EXPECT_EQ(r.lane<2>(), 1.5f);

EXPECT_EQ(r.lane<3>(), 1.5f);

}

/** @brief Test vfloat4 max. */

TEST(SuiteVfloat4, max)

{

vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 b(0.9f, 2.1f, 3.0f, 4.1f);

vfloat4 r = max(a, b);

EXPECT_EQ(r.lane<0>(), 1.0f);

EXPECT_EQ(r.lane<1>(), 2.1f);

EXPECT_EQ(r.lane<2>(), 3.0f);

EXPECT_EQ(r.lane<3>(), 4.1f);

float c = 4.3f;

r = max(a, c);

EXPECT_EQ(r.lane<0>(), 4.3f);

EXPECT_EQ(r.lane<1>(), 4.3f);

EXPECT_EQ(r.lane<2>(), 4.3f);

EXPECT_EQ(r.lane<3>(), 4.3f);

float d = 1.5f;

r = max(a, d);

EXPECT_EQ(r.lane<0>(), 1.5f);

EXPECT_EQ(r.lane<1>(), 2.0f);

EXPECT_EQ(r.lane<2>(), 3.0f);

EXPECT_EQ(r.lane<3>(), 4.0f);

}

/** @brief Test vfloat4 clamp. */

TEST(SuiteVfloat4, clamp)

{

vfloat4 a1(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 r1 = clamp(2.1f, 3.0f, a1);

EXPECT_EQ(r1.lane<0>(), 2.1f);

EXPECT_EQ(r1.lane<1>(), 2.1f);

EXPECT_EQ(r1.lane<2>(), 3.0f);

EXPECT_EQ(r1.lane<3>(), 3.0f);

vfloat4 a2(1.0f, 2.0f, qnan, 4.0f);

vfloat4 r2 = clamp(2.1f, 3.0f, a2);

EXPECT_EQ(r2.lane<0>(), 2.1f);

EXPECT_EQ(r2.lane<1>(), 2.1f);

EXPECT_EQ(r2.lane<2>(), 2.1f);

EXPECT_EQ(r2.lane<3>(), 3.0f);

}

/** @brief Test vfloat4 clampz. */

TEST(SuiteVfloat4, clampzo)

{

vfloat4 a1(-1.0f, 0.0f, 0.1f, 4.0f);

vfloat4 r1 = clampzo(a1);

EXPECT_EQ(r1.lane<0>(), 0.0f);

EXPECT_EQ(r1.lane<1>(), 0.0f);

EXPECT_EQ(r1.lane<2>(), 0.1f);

EXPECT_EQ(r1.lane<3>(), 1.0f);

vfloat4 a2(-1.0f, 0.0f, qnan, 4.0f);

vfloat4 r2 = clampzo(a2);

EXPECT_EQ(r2.lane<0>(), 0.0f);

EXPECT_EQ(r2.lane<1>(), 0.0f);

EXPECT_EQ(r2.lane<2>(), 0.0f);

EXPECT_EQ(r2.lane<3>(), 1.0f);

}

/** @brief Test vfloat4 abs. */

TEST(SuiteVfloat4, abs)

{

vfloat4 a(-1.0f, 0.0f, 0.1f, 4.0f);

vfloat4 r = abs(a);

EXPECT_EQ(r.lane<0>(), 1.0f);

EXPECT_EQ(r.lane<1>(), 0.0f);

EXPECT_EQ(r.lane<2>(), 0.1f);

EXPECT_EQ(r.lane<3>(), 4.0f);

}

/** @brief Test vfloat4 round. */

TEST(SuiteVfloat4, round)

{

vfloat4 a1(1.1f, 1.5f, 1.6f, 4.0f);

vfloat4 r1 = round(a1);

EXPECT_EQ(r1.lane<0>(), 1.0f);

EXPECT_EQ(r1.lane<1>(), 2.0f);

EXPECT_EQ(r1.lane<2>(), 2.0f);

EXPECT_EQ(r1.lane<3>(), 4.0f);

vfloat4 a2(-2.5f, -2.5f, -3.5f, -3.5f);

vfloat4 r2 = round(a2);

EXPECT_EQ(r2.lane<0>(), -2.0f);

EXPECT_EQ(r2.lane<2>(), -4.0f);

}

/** @brief Test vfloat4 hmin. */

TEST(SuiteVfloat4, hmin)

{

vfloat4 a1(1.1f, 1.5f, 1.6f, 4.0f);

vfloat4 r1 = hmin(a1);

EXPECT_EQ(r1.lane<0>(), 1.1f);

EXPECT_EQ(r1.lane<1>(), 1.1f);

EXPECT_EQ(r1.lane<2>(), 1.1f);

EXPECT_EQ(r1.lane<3>(), 1.1f);

vfloat4 a2(1.1f, 1.5f, 1.6f, 0.2f);

vfloat4 r2 = hmin(a2);

EXPECT_EQ(r2.lane<0>(), 0.2f);

EXPECT_EQ(r2.lane<1>(), 0.2f);

EXPECT_EQ(r2.lane<2>(), 0.2f);

EXPECT_EQ(r2.lane<3>(), 0.2f);

}

/** @brief Test vfloat4 hmin_s. */

TEST(SuiteVfloat4, hmin_s)

{

vfloat4 a1(1.1f, 1.5f, 1.6f, 4.0f);

float r1 = hmin_s(a1);

EXPECT_EQ(r1, 1.1f);

vfloat4 a2(1.1f, 1.5f, 1.6f, 0.2f);

float r2 = hmin_s(a2);

EXPECT_EQ(r2, 0.2f);

}

/** @brief Test vfloat4 hmin_rgb_s. */

TEST(SuiteVfloat4, hmin_rgb_s)

{

vfloat4 a1(1.1f, 1.5f, 1.6f, 0.2f);

float r1 = hmin_rgb_s(a1);

EXPECT_EQ(r1, 1.1f);

vfloat4 a2(1.5f, 0.9f, 1.6f, 1.2f);

float r2 = hmin_rgb_s(a2);

EXPECT_EQ(r2, 0.9f);

}

/** @brief Test vfloat4 hmax. */

TEST(SuiteVfloat4, hmax)

{

vfloat4 a1(1.1f, 1.5f, 1.6f, 4.0f);

vfloat4 r1 = hmax(a1);

EXPECT_EQ(r1.lane<0>(), 4.0f);

EXPECT_EQ(r1.lane<1>(), 4.0f);

EXPECT_EQ(r1.lane<2>(), 4.0f);

EXPECT_EQ(r1.lane<3>(), 4.0f);

vfloat4 a2(1.1f, 1.5f, 1.6f, 0.2f);

vfloat4 r2 = hmax(a2);

EXPECT_EQ(r2.lane<0>(), 1.6f);

EXPECT_EQ(r2.lane<1>(), 1.6f);

EXPECT_EQ(r2.lane<2>(), 1.6f);

EXPECT_EQ(r2.lane<3>(), 1.6f);

}

/** @brief Test vfloat4 hmax_s. */

TEST(SuiteVfloat4, hmax_s)

{

vfloat4 a1(1.1f, 1.5f, 1.6f, 4.0f);

float r1 = hmax_s(a1);

EXPECT_EQ(r1, 4.0f);

vfloat4 a2(1.1f, 1.5f, 1.6f, 0.2f);

float r2 = hmax_s(a2);

EXPECT_EQ(r2, 1.6f);

}

/** @brief Test vfloat4 hadd_s. */

TEST(SuiteVfloat4, hadd_s)

{

vfloat4 a1(1.1f, 1.5f, 1.6f, 4.0f);

float sum = 1.1f + 1.5f + 1.6f + 4.0f;

float r = hadd_s(a1);

EXPECT_NEAR(r, sum, 0.005f);

}

/** @brief Test vfloat4 hadd_rgb_s. */

TEST(SuiteVfloat4, hadd_rgb_s)

{

vfloat4 a1(1.1f, 1.5f, 1.6f, 4.0f);

float sum = 1.1f + 1.5f + 1.6f;

float r = hadd_rgb_s(a1);

EXPECT_NEAR(r, sum, 0.005f);

}

/** @brief Test vfloat4 sqrt. */

TEST(SuiteVfloat4, sqrt)

{

vfloat4 a(1.0f, 2.0f, 3.0f, 4.0f);

vfloat4 r = sqrt(a);

EXPECT_EQ(r.lane<0>(), std::sqrt(1.0f));

EXPECT_EQ(r.lane<1>(), std::sqrt(2.0f));

EXPECT_EQ(r.lane<2>(), std::sqrt(3.0f));

EXPECT_EQ(r.lane<3>(), std::sqrt(4.0f));

}

/** @brief Test vfloat4 select. */

TEST(SuiteVfloat4, select)

{

vfloat4 m1(1.0f, 1.0f, 1.0f, 1.0f);

vfloat4 m2(1.0f, 2.0f, 1.0f, 2.0f);

vmask4 cond = m1 == m2;

vfloat4 a(1.0f, 3.0f, 3.0f, 1.0f);

vfloat4 b(4.0f, 2.0f, 2.0f, 4.0f);

// Select in one direction

vfloat4 r1 = select(a, b, cond);

EXPECT_EQ(r1.lane<0>(), 4.0f);

EXPECT_EQ(r1.lane<1>(), 3.0f);

EXPECT_EQ(r1.lane<2>(), 2.0f);

EXPECT_EQ(r1.lane<3>(), 1.0f);

// Select in the other

vfloat4 r2 = select(b, a, cond);

EXPECT_EQ(r2.lane<0>(), 1.0f);

EXPECT_EQ(r2.lane<1>(), 2.0f);

EXPECT_EQ(r2.lane<2>(), 3.0f);

EXPECT_EQ(r2.lane<3>(), 4.0f);

}

/** @brief Test vfloat4 gatherf. */

TEST(SuiteVfloat4, gatherf)

{

vint4 indices(0, 4, 3, 2);

vfloat4 r = gatherf(f32_data, indices);

EXPECT_EQ(r.lane<0>(), 0.0f);

EXPECT_EQ(r.lane<1>(), 4.0f);

EXPECT_EQ(r.lane<2>(), 3.0f);

EXPECT_EQ(r.lane<3>(), 2.0f);

}

/** @brief Test vfloat4 storea. */

TEST(SuiteVfloat4, storea)

{

ASTCENC_ALIGNAS float out[4];

vfloat4 a(f32_data);

storea(a, out);

EXPECT_EQ(out[0], 0.0f);

EXPECT_EQ(out[1], 1.0f);

EXPECT_EQ(out[2], 2.0f);

EXPECT_EQ(out[3], 3.0f);

}

/** @brief Test vfloat4 store. */

TEST(SuiteVfloat4, store)

{

ASTCENC_ALIGNAS float out[5];

vfloat4 a(f32_data);

store(a, &(out[1]));

EXPECT_EQ(out[1], 0.0f);

EXPECT_EQ(out[2], 1.0f);

EXPECT_EQ(out[3], 2.0f);

EXPECT_EQ(out[4], 3.0f);

}

/** @brief Test vfloat4 dot. */

TEST(SuiteVfloat4, dot)

{

vfloat4 a1(1.0f, 2.0f, 4.0f, 8.0f);

vfloat4 b1(1.0f, 0.5f, 0.25f, 0.125f);

vfloat4 r1 = dot(a1, b1);

EXPECT_EQ(r1.lane<0>(), 4.0f);

EXPECT_EQ(r1.lane<1>(), 4.0f);

EXPECT_EQ(r1.lane<2>(), 4.0f);

EXPECT_EQ(r1.lane<3>(), 4.0f);

// These values will fail to add to the same value if reassociated

float l0 = 141.2540435791015625f;

float l1 = 5345345.5000000000000000f;

float l2 = 234234.7031250000000000f;

float l3 = 124353454080.0000000000000000f;

vfloat4 a2(1.0f, 1.0f, 1.0f, 1.0f);

vfloat4 b2(l0, l1, l2, l3);

vfloat4 r2 = dot(a2, b2);

// Test that reassociation causes a failure with the numbers we chose

EXPECT_FALSE(any(r2 == vfloat4(l0 + l1 + l2 + l3)));

// Test that the sum works, for the association pattern we want used

EXPECT_TRUE(all(r2 == vfloat4((l0 + l2) + (l1 + l3))));

}

/** @brief Test vfloat4 dot_s. */

TEST(SuiteVfloat4, dot_s)

{

vfloat4 a1(1.0f, 2.0f, 4.0f, 8.0f);

vfloat4 b1(1.0f, 0.5f, 0.25f, 0.125f);

float r1 = dot_s(a1, b1);

EXPECT_EQ(r1, 4.0f);

// These values will fail to add to the same value if reassociated

float l0 = 141.2540435791015625f;

float l1 = 5345345.5000000000000000f;

float l2 = 234234.7031250000000000f;

float l3 = 124353454080.0000000000000000f;

vfloat4 a2(1.0f, 1.0f, 1.0f, 1.0f);

vfloat4 b2(l0, l1, l2, l3);

float r2 = dot_s(a2, b2);

// Test that reassociation causes a failure with the numbers we chose

EXPECT_NE(r2, l0 + l1 + l2 + l3);

// Test that the sum works, for the association pattern we want used

EXPECT_EQ(r2, (l0 + l2) + (l1 + l3));