TheRock/math-libs/libhipcxx/.upstream-tests/test/libcxx/numerics/floating.point/cast.pass.cpp

//===----------------------------------------------------------------------===//
//
// Part of libcu++, the C++ Standard Library for your entire system,
// under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES.
//
//===----------------------------------------------------------------------===//

// clang-format off
#include <disable_nvfp_conversions_and_operators.h>
// clang-format on

#include <cuda/std/__floating_point/fp.h>
#include <cuda/std/cassert>
#include <cuda/std/cstring>

#include "test_macros.h"

template <class To, class From>
__host__ __device__ void test_fp_cast()
{
  // 1.0 should be representable by all floating point types
  const From in     = cuda::std::__fp_cast<From>(1.f);
  const To expected = cuda::std::__fp_cast<To>(1.f);

  static_assert(cuda::std::is_same_v<To, decltype(cuda::std::__fp_cast<To>(From{}))>);
  const To out = cuda::std::__fp_cast<To>(in);
  assert(cuda::std::memcmp(&out, &expected, sizeof(To)) == 0);
}

template <class T>
__host__ __device__ void test_fp_cast()
{
  test_fp_cast<T, float>();
  test_fp_cast<T, double>();
#if _CCCL_HAS_LONG_DOUBLE()
  test_fp_cast<T, long double>();
#endif // _CCCL_HAS_LONG_DOUBLE()
#if _CCCL_HAS_NVFP16()
  test_fp_cast<T, __half>();
#endif // _CCCL_HAS_NVFP16()
#if _CCCL_HAS_NVBF16()
  test_fp_cast<T, __nv_bfloat16>();
#endif // _CCCL_HAS_NVBF16()
#if _CCCL_HAS_NVFP8_E4M3()
  test_fp_cast<T, __nv_fp8_e4m3>();
#endif // _CCCL_HAS_NVFP8_E4M3()
#if _CCCL_HAS_NVFP8_E5M2()
  test_fp_cast<T, __nv_fp8_e5m2>();
#endif // _CCCL_HAS_NVFP8_E5M2()
#if _CCCL_HAS_NVFP8_E8M0()
  test_fp_cast<T, __nv_fp8_e8m0>();
#endif // _CCCL_HAS_NVFP8_E8M0()
#if _CCCL_HAS_NVFP6_E2M3()
  test_fp_cast<T, __nv_fp6_e2m3>();
#endif // _CCCL_HAS_NVFP6_E2M3()
#if _CCCL_HAS_NVFP6_E3M2()
  test_fp_cast<T, __nv_fp6_e3m2>();
#endif // _CCCL_HAS_NVFP6_E3M2()
#if _CCCL_HAS_NVFP4_E2M1()
  test_fp_cast<T, __nv_fp4_e2m1>();
#endif // _CCCL_HAS_NVFP4_E2M1()
}

__host__ __device__ bool test()
{
  test_fp_cast<float>();
  test_fp_cast<double>();
#if _CCCL_HAS_LONG_DOUBLE()
  test_fp_cast<long double>();
#endif // _CCCL_HAS_LONG_DOUBLE()
#if _CCCL_HAS_NVFP16()
  test_fp_cast<__half>();
#endif // _CCCL_HAS_NVFP16()
#if _CCCL_HAS_NVBF16()
  test_fp_cast<__nv_bfloat16>();
#endif // _CCCL_HAS_NVBF16()
#if _CCCL_HAS_NVFP8_E4M3()
  test_fp_cast<__nv_fp8_e4m3>();
#endif // _CCCL_HAS_NVFP8_E4M3()
#if _CCCL_HAS_NVFP8_E5M2()
  test_fp_cast<__nv_fp8_e5m2>();
#endif // _CCCL_HAS_NVFP8_E5M2()
#if _CCCL_HAS_NVFP8_E8M0()
  test_fp_cast<__nv_fp8_e8m0>();
#endif // _CCCL_HAS_NVFP8_E8M0()
#if _CCCL_HAS_NVFP6_E2M3()
  test_fp_cast<__nv_fp6_e2m3>();
#endif // _CCCL_HAS_NVFP6_E2M3()
#if _CCCL_HAS_NVFP6_E3M2()
  test_fp_cast<__nv_fp6_e3m2>();
#endif // _CCCL_HAS_NVFP6_E3M2()
#if _CCCL_HAS_NVFP4_E2M1()
  test_fp_cast<__nv_fp4_e2m1>();
#endif // _CCCL_HAS_NVFP4_E2M1()

  return true;
}

int main(int, char**)
{
  test();
  return 0;
}