| /* |
| * Copyright 2019 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "include/core/SkPoint.h" |
| #include "include/private/base/SkVx.h" |
| #include "include/utils/SkRandom.h" |
| #include "tests/Test.h" |
| |
| #include <numeric> |
| |
| namespace skvx { |
| |
| DEF_TEST(SkVx, r) { |
| static_assert(sizeof(float2) == 8, ""); |
| static_assert(sizeof(float4) == 16, ""); |
| static_assert(sizeof(float8) == 32, ""); |
| |
| static_assert(sizeof(byte2) == 2, ""); |
| static_assert(sizeof(byte4) == 4, ""); |
| static_assert(sizeof(byte8) == 8, ""); |
| |
| { |
| int4 mask = float4{1,2,3,4} < float4{1,2,4,8}; |
| REPORTER_ASSERT(r, mask[0] == int32_t( 0)); |
| REPORTER_ASSERT(r, mask[1] == int32_t( 0)); |
| REPORTER_ASSERT(r, mask[2] == int32_t(-1)); |
| REPORTER_ASSERT(r, mask[3] == int32_t(-1)); |
| |
| REPORTER_ASSERT(r, any(mask)); |
| REPORTER_ASSERT(r, !all(mask)); |
| } |
| |
| { |
| long4 mask = double4{1,2,3,4} < double4{1,2,4,8}; |
| REPORTER_ASSERT(r, mask[0] == int64_t( 0)); |
| REPORTER_ASSERT(r, mask[1] == int64_t( 0)); |
| REPORTER_ASSERT(r, mask[2] == int64_t(-1)); |
| REPORTER_ASSERT(r, mask[3] == int64_t(-1)); |
| |
| REPORTER_ASSERT(r, any(mask)); |
| REPORTER_ASSERT(r, !all(mask)); |
| } |
| |
| { |
| // Tests that any/all work with non-zero values, not just full bit lanes. |
| REPORTER_ASSERT(r, all(int4{1,2,3,4})); |
| REPORTER_ASSERT(r, !all(int4{1,2,3})); |
| REPORTER_ASSERT(r, any(int4{1,2})); |
| REPORTER_ASSERT(r, !any(int4{})); |
| } |
| |
| REPORTER_ASSERT(r, min(float4{1,2,3,4}) == 1); |
| REPORTER_ASSERT(r, max(float4{1,2,3,4}) == 4); |
| |
| REPORTER_ASSERT(r, all(int4{1,2,3,4,5} == int4{1,2,3,4})); |
| REPORTER_ASSERT(r, all(int4{1,2,3,4} == int4{1,2,3,4})); |
| REPORTER_ASSERT(r, all(int4{1,2,3} == int4{1,2,3,0})); |
| REPORTER_ASSERT(r, all(int4{1,2} == int4{1,2,0,0})); |
| REPORTER_ASSERT(r, all(int4{1} == int4{1,0,0,0})); |
| REPORTER_ASSERT(r, all(int4(1) == int4{1,1,1,1})); |
| REPORTER_ASSERT(r, all(int4{} == int4{0,0,0,0})); |
| REPORTER_ASSERT(r, all(int4() == int4{0,0,0,0})); |
| |
| REPORTER_ASSERT(r, all(int4{1,2,2,1} == min(int4{1,2,3,4}, int4{4,3,2,1}))); |
| REPORTER_ASSERT(r, all(int4{4,3,3,4} == max(int4{1,2,3,4}, int4{4,3,2,1}))); |
| |
| REPORTER_ASSERT(r, all(if_then_else(float4{1,2,3,2} <= float4{2,2,2,2}, float4(42), float4(47)) |
| == float4{42,42,47,42})); |
| |
| REPORTER_ASSERT(r, all(floor(float4{-1.5f,1.5f,1.0f,-1.0f}) == float4{-2.0f,1.0f,1.0f,-1.0f})); |
| REPORTER_ASSERT(r, all( ceil(float4{-1.5f,1.5f,1.0f,-1.0f}) == float4{-1.0f,2.0f,1.0f,-1.0f})); |
| REPORTER_ASSERT(r, all(trunc(float4{-1.5f,1.5f,1.0f,-1.0f}) == float4{-1.0f,1.0f,1.0f,-1.0f})); |
| REPORTER_ASSERT(r, all(round(float4{-1.5f,1.5f,1.0f,-1.0f}) == float4{-2.0f,2.0f,1.0f,-1.0f})); |
| |
| |
| REPORTER_ASSERT(r, all(abs(float4{-2,-1,0,1}) == float4{2,1,0,1})); |
| |
| // TODO(mtklein): these tests could be made less loose. |
| REPORTER_ASSERT(r, all( sqrt(float4{2,3,4,5}) < float4{2,2,3,3})); |
| REPORTER_ASSERT(r, all( sqrt(float2{2,3}) < float2{2,2})); |
| |
| REPORTER_ASSERT(r, all(cast<int>(float4{-1.5f,0.5f,1.0f,1.5f}) == int4{-1,0,1,1})); |
| |
| float buf[] = {1,2,3,4,5,6}; |
| REPORTER_ASSERT(r, all(float4::Load(buf) == float4{1,2,3,4})); |
| float4{2,3,4,5}.store(buf); |
| REPORTER_ASSERT(r, buf[0] == 2 |
| && buf[1] == 3 |
| && buf[2] == 4 |
| && buf[3] == 5 |
| && buf[4] == 5 |
| && buf[5] == 6); |
| REPORTER_ASSERT(r, all(float4::Load(buf+0) == float4{2,3,4,5})); |
| REPORTER_ASSERT(r, all(float4::Load(buf+2) == float4{4,5,5,6})); |
| |
| REPORTER_ASSERT(r, all(shuffle<2,1,0,3> (float4{1,2,3,4}) == float4{3,2,1,4})); |
| REPORTER_ASSERT(r, all(shuffle<2,1> (float4{1,2,3,4}) == float2{3,2})); |
| REPORTER_ASSERT(r, all(shuffle<3,3,3,3> (float4{1,2,3,4}) == float4{4,4,4,4})); |
| REPORTER_ASSERT(r, all(shuffle<2,1,2,1,2,1,2,1>(float4{1,2,3,4}) |
| == float8{3,2,3,2,3,2,3,2})); |
| |
| // Test that mixed types can be used where they make sense. Mostly about ergonomics. |
| REPORTER_ASSERT(r, all(float4{1,2,3,4} < 5)); |
| REPORTER_ASSERT(r, all( byte4{1,2,3,4} < 5)); |
| REPORTER_ASSERT(r, all( int4{1,2,3,4} < 5.0f)); |
| float4 five = 5; |
| REPORTER_ASSERT(r, all(five == 5.0f)); |
| REPORTER_ASSERT(r, all(five == 5)); |
| |
| REPORTER_ASSERT(r, all(max(2, min(float4{1,2,3,4}, 3)) == float4{2,2,3,3})); |
| |
| for (int x = 0; x < 256; x++) |
| for (int y = 0; y < 256; y++) { |
| uint8_t want = (uint8_t)( 255*(x/255.0 * y/255.0) + 0.5 ); |
| |
| { |
| uint8_t got = div255(Vec<8, uint16_t>(x) * Vec<8, uint16_t>(y) )[0]; |
| REPORTER_ASSERT(r, got == want); |
| } |
| |
| { |
| uint8_t got = approx_scale(Vec<8,uint8_t>(x), Vec<8,uint8_t>(y))[0]; |
| |
| REPORTER_ASSERT(r, got == want-1 || |
| got == want || |
| got == want+1); |
| if (x == 0 || y == 0 || x == 255 || y == 255) { |
| REPORTER_ASSERT(r, got == want); |
| } |
| } |
| } |
| |
| for (int x = 0; x < 256; x++) |
| for (int y = 0; y < 256; y++) { |
| uint16_t xy = x*y; |
| |
| // Make sure to cover implementation cases N=8, N<8, and N>8. |
| REPORTER_ASSERT(r, all(mull(byte2 (x), byte2 (y)) == xy)); |
| REPORTER_ASSERT(r, all(mull(byte4 (x), byte4 (y)) == xy)); |
| REPORTER_ASSERT(r, all(mull(byte8 (x), byte8 (y)) == xy)); |
| REPORTER_ASSERT(r, all(mull(byte16(x), byte16(y)) == xy)); |
| } |
| |
| { |
| // Intentionally not testing -0, as we don't care if it's 0x0000 or 0x8000. |
| float8 fs = {+0.0f,+0.5f,+1.0f,+2.0f, |
| -4.0f,-0.5f,-1.0f,-2.0f}; |
| Vec<8,uint16_t> hs = {0x0000,0x3800,0x3c00,0x4000, |
| 0xc400,0xb800,0xbc00,0xc000}; |
| REPORTER_ASSERT(r, all( to_half(fs) == hs)); |
| REPORTER_ASSERT(r, all(from_half(hs) == fs)); |
| } |
| } |
| |
| DEF_TEST(SkVx_xy, r) { |
| float2 f = float2(1,2); |
| REPORTER_ASSERT(r, all(f == float2{1,2})); |
| REPORTER_ASSERT(r, f.x() == 1); |
| REPORTER_ASSERT(r, f.y() == 2); |
| f.y() = 9; |
| REPORTER_ASSERT(r, all(f == float2{1,9})); |
| f.x() = 0; |
| REPORTER_ASSERT(r, all(f == float2(0,9))); |
| f[0] = 8; |
| REPORTER_ASSERT(r, f.x() == 8); |
| f[1] = 6; |
| REPORTER_ASSERT(r, f.y() == 6); |
| REPORTER_ASSERT(r, all(f == float2(8,6))); |
| f = f.yx(); |
| REPORTER_ASSERT(r, all(f == float2(6,8))); |
| REPORTER_ASSERT(r, bit_pun<SkPoint>(f) == SkPoint::Make(6,8)); |
| SkPoint p; |
| f.store(&p); |
| REPORTER_ASSERT(r, p == SkPoint::Make(6,8)); |
| f.yx().store(&p); |
| REPORTER_ASSERT(r, p == SkPoint::Make(8,6)); |
| REPORTER_ASSERT(r, all(f.xyxy() == float4(6,8,6,8))); |
| REPORTER_ASSERT(r, all(f.xyxy() == float4(f,f))); |
| REPORTER_ASSERT(r, all(join(f,f) == f.xyxy())); |
| REPORTER_ASSERT(r, all(join(f.yx(),f) == float4(f.y(),f.x(),f))); |
| REPORTER_ASSERT(r, all(join(f.yx(),f) == float4(f.yx(),f.x(),f.y()))); |
| REPORTER_ASSERT(r, all(join(f,f.yx()) == float4(f.x(),f.y(),f.yx()))); |
| REPORTER_ASSERT(r, all(join(f.yx(),f.yx()) == float4(f.yx(),f.yx()))); |
| } |
| |
| DEF_TEST(SkVx_xyzw, r) { |
| float4 f = float4{1,2,3,4}; |
| REPORTER_ASSERT(r, all(f == float4(1,2,3,4))); |
| REPORTER_ASSERT(r, all(f == float4(1,2,float2(3,4)))); |
| REPORTER_ASSERT(r, all(f == float4(float2(1,2),3,4))); |
| REPORTER_ASSERT(r, all(f == float4(float2(1,2),float2(3,4)))); |
| f.xy() = float2(9,8); |
| REPORTER_ASSERT(r, all(f == float4(9,8,3,4))); |
| f.zw().x() = 7; |
| f.zw().y() = 6; |
| REPORTER_ASSERT(r, all(f == float4(9,8,7,6))); |
| f.x() = 5; |
| f.y() = 4; |
| f.z() = 3; |
| f.w() = 2; |
| REPORTER_ASSERT(r, all(f == float4(5,4,3,2))); |
| f[0] = 0; |
| REPORTER_ASSERT(r, f.x() == 0); |
| f[1] = 1; |
| REPORTER_ASSERT(r, f.y() == 1); |
| f[2] = 2; |
| REPORTER_ASSERT(r, f.z() == 2); |
| f[3] = 3; |
| REPORTER_ASSERT(r, f.w() == 3); |
| REPORTER_ASSERT(r, all(f.xy() == float2(0,1))); |
| REPORTER_ASSERT(r, all(f.zw() == float2{2,3})); |
| REPORTER_ASSERT(r, all(f == float4(0,1,2,3))); |
| REPORTER_ASSERT(r, all(f.yxwz().lo == shuffle<1,0>(f))); |
| REPORTER_ASSERT(r, all(f.yxwz().hi == shuffle<3,2>(f))); |
| REPORTER_ASSERT(r, all(f.zwxy().lo.lo == f.z())); |
| REPORTER_ASSERT(r, all(f.zwxy().lo.hi == f.w())); |
| REPORTER_ASSERT(r, all(f.zwxy().hi.lo == f.x())); |
| REPORTER_ASSERT(r, all(f.zwxy().hi.hi == f.y())); |
| REPORTER_ASSERT(r, f.yxwz().lo.lo.val == f.y()); |
| REPORTER_ASSERT(r, f.yxwz().lo.hi.val == f.x()); |
| REPORTER_ASSERT(r, f.yxwz().hi.lo.val == f.w()); |
| REPORTER_ASSERT(r, f.yxwz().hi.hi.val == f.z()); |
| |
| REPORTER_ASSERT(r, all(naive_if_then_else(int2(0,~0), |
| shuffle<3,2>(float4(0,1,2,3)), |
| float4(4,5,6,7).xy()) == float2(4,2))); |
| REPORTER_ASSERT(r, all(if_then_else(int2(0,~0), |
| shuffle<3,2>(float4(0,1,2,3)), |
| float4(4,5,6,7).xy()) == float2(4,2))); |
| REPORTER_ASSERT(r, all(naive_if_then_else(int2(0,~0).xyxy(), |
| float4(0,1,2,3).zwxy(), |
| float4(4,5,6,7)) == float4(4,3,6,1))); |
| REPORTER_ASSERT(r, all(if_then_else(int2(0,~0).xyxy(), |
| float4(0,1,2,3).zwxy(), |
| float4(4,5,6,7)) == float4(4,3,6,1))); |
| |
| REPORTER_ASSERT(r, all(pin(float4(0,1,2,3).yxwz(), |
| float2(1).xyxy(), |
| float2(2).xyxy()) == float4(1,1,2,2))); |
| } |
| |
| DEF_TEST(SkVx_cross_dot, r) { |
| REPORTER_ASSERT(r, cross(int2{0,1}, int2{0,1}) == 0); |
| REPORTER_ASSERT(r, cross(int2{1,0}, int2{1,0}) == 0); |
| REPORTER_ASSERT(r, cross(int2{1,1}, int2{1,1}) == 0); |
| REPORTER_ASSERT(r, cross(int2{1,1}, int2{1,-1}) == -2); |
| REPORTER_ASSERT(r, cross(int2{1,1}, int2{-1,1}) == 2); |
| |
| REPORTER_ASSERT(r, dot(int2{0,1}, int2{1,0}) == 0); |
| REPORTER_ASSERT(r, dot(int2{1,0}, int2{0,1}) == 0); |
| REPORTER_ASSERT(r, dot(int2{1,1}, int2{1,-1}) == 0); |
| REPORTER_ASSERT(r, dot(int2{1,1}, int2{1,1}) == 2); |
| REPORTER_ASSERT(r, dot(int2{1,1}, int2{-1,-1}) == -2); |
| |
| SkRandom rand; |
| for (int i = 0; i < 100; ++i) { |
| float a=rand.nextRangeF(-1,1), b=rand.nextRangeF(-1,1), c=rand.nextRangeF(-1,1), |
| d=rand.nextRangeF(-1,1); |
| constexpr static float kTolerance = 1.f / (1 << 20); |
| REPORTER_ASSERT(r, SkScalarNearlyEqual( |
| cross(float2{a,b}, float2{c,d}), SkPoint::CrossProduct({a,b}, {c,d}), kTolerance)); |
| REPORTER_ASSERT(r, SkScalarNearlyEqual( |
| dot(float2{a,b}, float2{c,d}), SkPoint::DotProduct({a,b}, {c,d}), kTolerance)); |
| } |
| |
| auto assertDoublesEqual = [&](double left, double right) { |
| REPORTER_ASSERT(r, SkScalarNearlyEqual(left, right), "%f != %f", left, right); |
| }; |
| assertDoublesEqual(cross(double2{1.2, 3.4}, double2{3.4, -1.2}), -13.000000); |
| assertDoublesEqual(cross(double2{12.34, 5.6}, double2{7.8, -9.0}), -154.740000); |
| assertDoublesEqual(cross(double2{12.34, 5.6}, double2{7.8, 9.012345678}), 67.532346); |
| } |
| |
| template<int N, typename T> void check_strided_loads(skiatest::Reporter* r) { |
| using Vec = Vec<N,T>; |
| T values[N*4]; |
| std::iota(values, values + N*4, 0); |
| Vec a, b, c, d; |
| strided_load2(values, a, b); |
| for (int i = 0; i < N; ++i) { |
| REPORTER_ASSERT(r, a[i] == values[i*2]); |
| REPORTER_ASSERT(r, b[i] == values[i*2 + 1]); |
| } |
| strided_load4(values, a, b, c, d); |
| for (int i = 0; i < N; ++i) { |
| REPORTER_ASSERT(r, a[i] == values[i*4]); |
| REPORTER_ASSERT(r, b[i] == values[i*4 + 1]); |
| REPORTER_ASSERT(r, c[i] == values[i*4 + 2]); |
| REPORTER_ASSERT(r, d[i] == values[i*4 + 3]); |
| } |
| } |
| |
| template<typename T> void check_strided_loads(skiatest::Reporter* r) { |
| check_strided_loads<1,T>(r); |
| check_strided_loads<2,T>(r); |
| check_strided_loads<4,T>(r); |
| check_strided_loads<8,T>(r); |
| check_strided_loads<16,T>(r); |
| check_strided_loads<32,T>(r); |
| } |
| |
| DEF_TEST(SkVx_strided_loads, r) { |
| check_strided_loads<uint32_t>(r); |
| check_strided_loads<uint16_t>(r); |
| check_strided_loads<uint8_t>(r); |
| check_strided_loads<int32_t>(r); |
| check_strided_loads<int16_t>(r); |
| check_strided_loads<int8_t>(r); |
| check_strided_loads<float>(r); |
| } |
| |
| DEF_TEST(SkVx_ScaledDividerU32, r) { |
| static constexpr uint32_t kMax = std::numeric_limits<uint32_t>::max(); |
| |
| auto errorBounds = [&](uint32_t actual, uint32_t expected) { |
| uint32_t lowerLimit = expected == 0 ? 0 : expected - 1, |
| upperLimit = expected == kMax ? kMax : expected + 1; |
| return lowerLimit <= actual && actual <= upperLimit; |
| }; |
| |
| auto test = [&](uint32_t denom) { |
| // half == 1 so, the max to check is kMax-1 |
| ScaledDividerU32 d(denom); |
| uint32_t maxCheck = static_cast<uint32_t>( |
| std::floor((double)(kMax - d.half()) / denom + 0.5)); |
| REPORTER_ASSERT(r, errorBounds(d.divide((kMax))[0], maxCheck)); |
| for (uint32_t i = 0; i < kMax - d.half(); i += 65535) { |
| uint32_t expected = static_cast<uint32_t>(std::floor((double)i / denom + 0.5)); |
| auto actual = d.divide(i + d.half()); |
| if (!errorBounds(actual[0], expected)) { |
| SkDebugf("i: %u expected: %u actual: %u\n", i, expected, actual[0]); |
| } |
| // Make sure all the lanes are the same. |
| for (int e = 1; e < 4; e++) { |
| SkASSERT(actual[0] == actual[e]); |
| } |
| } |
| }; |
| |
| test(2); |
| test(3); |
| test(5); |
| test(7); |
| test(27); |
| test(65'535); |
| test(15'485'863); |
| test(512'927'377); |
| } |
| |
| DEF_TEST(SkVx_saturated_add, r) { |
| for (int a = 0; a < (1<<8); a++) { |
| for (int b = 0; b < (1<<8); b++) { |
| int exact = a+b; |
| if (exact > 255) { exact = 255; } |
| if (exact < 0) { exact = 0; } |
| |
| REPORTER_ASSERT(r, saturated_add(skvx::byte16(a), skvx::byte16(b))[0] == exact); |
| } |
| } |
| } |
| |
| DEF_TEST(SkVx_length, r) { |
| auto assertFloatsEqual = [&](float left, float right) { |
| REPORTER_ASSERT(r, SkScalarNearlyEqual(left, right), "%f != %f", left, right); |
| }; |
| auto assertDoublesEqual = [&](double left, double right) { |
| REPORTER_ASSERT(r, SkScalarNearlyEqual(left, right), "%f != %f", left, right); |
| }; |
| |
| assertFloatsEqual(length(float2{0, 1}), 1.000000f); |
| assertFloatsEqual(length(float2{2, 0}), 2.000000f); |
| assertFloatsEqual(length(float2{3, 4}), 5.000000f); |
| assertFloatsEqual(length(float2{1, 1}), 1.414214f); |
| assertFloatsEqual(length(float2{2.5f, 2.5f}), 3.535534f); |
| assertFloatsEqual(length(float4{1, 2, 3, 4}), 5.477226f); |
| |
| assertDoublesEqual(length(double2{2.5, 2.5}), 3.535534); |
| assertDoublesEqual(length(double4{1.5, 2.5, 3.5, 4.5}), 6.403124); |
| } |
| |
| DEF_TEST(SkVx_normalize, r) { |
| auto assertFloatsEqual = [&](float left, float right) { |
| REPORTER_ASSERT(r, SkScalarNearlyEqual(left, right), "%f != %f", left, right); |
| }; |
| auto assertDoublesEqual = [&](double left, double right) { |
| REPORTER_ASSERT(r, SkScalarNearlyEqual(left, right), "%f != %f", left, right); |
| }; |
| |
| skvx::float2 twoFloats = normalize(skvx::float2{1.2f, 3.4f}); |
| assertFloatsEqual(twoFloats[0], 0.332820f); |
| assertFloatsEqual(twoFloats[1], 0.942990f); |
| |
| skvx::double2 twoDoubles = normalize(skvx::double2{2.3, -4.5}); |
| assertDoublesEqual(twoDoubles[0], 0.455111); |
| assertDoublesEqual(twoDoubles[1], -0.890435); |
| |
| skvx::double4 fourDoubles = normalize(skvx::double4{1.2, 3.4, 5.6, 7.8}); |
| assertDoublesEqual(fourDoubles[0], 0.116997); |
| assertDoublesEqual(fourDoubles[1], 0.331490); |
| assertDoublesEqual(fourDoubles[2], 0.545984); |
| assertDoublesEqual(fourDoubles[3], 0.760478); |
| } |
| |
| DEF_TEST(SkVx_normalize_infinity_and_nan, r) { |
| skvx::float2 zeroLenVec = normalize(skvx::float2{0, 0}); |
| REPORTER_ASSERT(r, std::isnan(zeroLenVec[0]), "%f is not nan", zeroLenVec[0]); |
| REPORTER_ASSERT(r, std::isnan(zeroLenVec[1]), "%f is not nan", zeroLenVec[1]); |
| REPORTER_ASSERT(r, !isfinite(zeroLenVec)); |
| |
| skvx::float2 tooBigVec = normalize(skvx::float2{std::numeric_limits<float>::max(), |
| std::numeric_limits<float>::max()}); |
| REPORTER_ASSERT(r, tooBigVec[0] == 0, "%f != 0", tooBigVec[0]); |
| REPORTER_ASSERT(r, tooBigVec[1] == 0, "%f != 0", tooBigVec[1]); |
| |
| skvx::double2 tooBigVecD = normalize(skvx::double2{std::numeric_limits<double>::max(), |
| std::numeric_limits<double>::max()}); |
| REPORTER_ASSERT(r, tooBigVecD[0] == 0, "%f != 0", tooBigVecD[0]); |
| REPORTER_ASSERT(r, tooBigVecD[1] == 0, "%f != 0", tooBigVecD[1]); |
| } |
| |
| DEF_TEST(SkVx_isfinite, r) { |
| REPORTER_ASSERT(r, isfinite(skvx::float2{0, 0})); |
| REPORTER_ASSERT(r, isfinite(skvx::double4{1.2, 3.4, 5.6, 7.8})); |
| REPORTER_ASSERT(r, isfinite(skvx::float8{8, 7, 6, 5, 4, 3, 2, 1})); |
| |
| REPORTER_ASSERT(r, !isfinite(skvx::float2{0, NAN})); |
| REPORTER_ASSERT(r, !isfinite(skvx::float2{INFINITY, 10})); |
| REPORTER_ASSERT(r, !isfinite(skvx::float2{NAN, INFINITY})); |
| |
| for (int i = 0; i < 4; i++) { |
| auto v = skvx::double4{4, 3, 2, 1}; |
| v[i] = INFINITY; |
| REPORTER_ASSERT(r, !isfinite(v), "index %d INFINITY", i); |
| v[i] = NAN; |
| REPORTER_ASSERT(r, !isfinite(v), "index %d NAN", i); |
| } |
| |
| for (int i = 0; i < 8; i++) { |
| auto v = skvx::float8{8, 7, 6, 5, 4, 3, 2, 1}; |
| v[i] = INFINITY; |
| REPORTER_ASSERT(r, !isfinite(v), "index %d INFINITY", i); |
| v[i] = NAN; |
| REPORTER_ASSERT(r, !isfinite(v), "index %d NAN", i); |
| } |
| } |
| |
| } // namespace skvx |