2091 lines
68 KiB
C
2091 lines
68 KiB
C
/* SPDX-License-Identifier: MIT
|
|
*
|
|
* 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.
|
|
*
|
|
* Copyright:
|
|
* 2020 Sean Maher <seanptmaher@gmail.com>
|
|
* 2020-2021 Evan Nemerson <evan@nemerson.com>
|
|
* 2023 Yi-Yen Chung <eric681@andestech.com> (Copyright owned by Andes Technology)
|
|
*/
|
|
|
|
#if !defined(SIMDE_ARM_NEON_CVT_H)
|
|
#define SIMDE_ARM_NEON_CVT_H
|
|
|
|
#include "types.h"
|
|
|
|
HEDLEY_DIAGNOSTIC_PUSH
|
|
SIMDE_DISABLE_UNWANTED_DIAGNOSTICS
|
|
SIMDE_BEGIN_DECLS_
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float16x4_t
|
|
simde_vcvt_f16_f32(simde_float32x4_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvt_f16_f32(a);
|
|
#else
|
|
simde_float32x4_private a_ = simde_float32x4_to_private(a);
|
|
simde_float16x4_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_FLOAT16_VECTOR)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_float16_from_float32(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_float16x4_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_f16_f32
|
|
#define vcvt_f16_f32(a) simde_vcvt_f16_f32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float32x4_t
|
|
simde_vcvt_f32_f16(simde_float16x4_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvt_f32_f16(a);
|
|
#else
|
|
simde_float16x4_private a_ = simde_float16x4_to_private(a);
|
|
simde_float32x4_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_FLOAT16_VECTOR)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_float16_to_float32(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_float32x4_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_f32_f16
|
|
#define vcvt_f32_f16(a) simde_vcvt_f32_f16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float32x2_t
|
|
simde_vcvt_f32_f64(simde_float64x2_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvt_f32_f64(a);
|
|
#else
|
|
simde_float64x2_private a_ = simde_float64x2_to_private(a);
|
|
simde_float32x2_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = HEDLEY_STATIC_CAST(simde_float32, a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_float32x2_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_f32_f64
|
|
#define vcvt_f32_f64(a) simde_vcvt_f32_f64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float64x2_t
|
|
simde_vcvt_f64_f32(simde_float32x2_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvt_f64_f32(a);
|
|
#else
|
|
simde_float32x2_private a_ = simde_float32x2_to_private(a);
|
|
simde_float64x2_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = HEDLEY_STATIC_CAST(simde_float64, a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_float64x2_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_f64_f32
|
|
#define vcvt_f64_f32(a) simde_vcvt_f64_f32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
uint16_t
|
|
simde_vcvth_u16_f16(simde_float16_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvth_u16_f16(a);
|
|
#elif defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
return HEDLEY_STATIC_CAST(uint16_t,
|
|
simde_float16_to_float32(a));
|
|
#else
|
|
simde_float32 af = simde_float16_to_float32(a);
|
|
if (HEDLEY_UNLIKELY(af <= SIMDE_FLOAT32_C(0.0))) {
|
|
return 0;
|
|
} else if (HEDLEY_UNLIKELY(af >= HEDLEY_STATIC_CAST(simde_float32, UINT16_MAX))) {
|
|
return UINT16_MAX;
|
|
} else if (simde_isnanhf(a)) {
|
|
return 0;
|
|
} else {
|
|
return HEDLEY_STATIC_CAST(uint16_t, af);
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvth_u16_f16
|
|
#define vcvth_u16_f16(a) simde_vcvth_u16_f16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
int32_t
|
|
simde_vcvth_s32_f16(simde_float16_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvth_s32_f16(a);
|
|
#elif defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
return HEDLEY_STATIC_CAST(int32_t,
|
|
simde_float16_to_float32(a));
|
|
#else
|
|
simde_float32 af = simde_float16_to_float32(a);
|
|
if (HEDLEY_UNLIKELY(af <= HEDLEY_STATIC_CAST(simde_float32, INT32_MIN))) {
|
|
return INT32_MIN;
|
|
} else if (HEDLEY_UNLIKELY(af >= HEDLEY_STATIC_CAST(simde_float32, INT32_MAX))) {
|
|
return INT32_MAX;
|
|
} else if (HEDLEY_UNLIKELY(simde_isnanhf(a))) {
|
|
return 0;
|
|
} else {
|
|
return HEDLEY_STATIC_CAST(int32_t, af);
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvth_s32_f16
|
|
#define vcvth_s32_f16(a) simde_vcvth_s32_f16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
uint32_t
|
|
simde_vcvth_u32_f16(simde_float16_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvth_u32_f16(a);
|
|
#elif defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
return HEDLEY_STATIC_CAST(uint32_t,
|
|
simde_float16_to_float32(a));
|
|
#else
|
|
simde_float32 af = simde_float16_to_float32(a);
|
|
if (HEDLEY_UNLIKELY(af <= SIMDE_FLOAT32_C(0.0))) {
|
|
return 0;
|
|
} else if (HEDLEY_UNLIKELY(af >= HEDLEY_STATIC_CAST(simde_float32, UINT32_MAX))) {
|
|
return UINT32_MAX;
|
|
} else if (HEDLEY_UNLIKELY(simde_isnanhf(a))) {
|
|
return 0;
|
|
} else {
|
|
return HEDLEY_STATIC_CAST(uint32_t, af);
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvth_u32_f16
|
|
#define vcvth_u32_f16(a) simde_vcvth_u32_f16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
int64_t
|
|
simde_vcvth_s64_f16(simde_float16_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvth_s64_f16(a);
|
|
#elif defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
return HEDLEY_STATIC_CAST(int64_t,
|
|
simde_float16_to_float32(a));
|
|
#else
|
|
simde_float32 af = simde_float16_to_float32(a);
|
|
if (HEDLEY_UNLIKELY(af <= HEDLEY_STATIC_CAST(simde_float32, INT64_MIN))) {
|
|
return INT64_MIN;
|
|
} else if (HEDLEY_UNLIKELY(af >= HEDLEY_STATIC_CAST(simde_float32, INT64_MAX))) {
|
|
return INT64_MAX;
|
|
} else if (HEDLEY_UNLIKELY(simde_isnanhf(a))) {
|
|
return 0;
|
|
} else {
|
|
return HEDLEY_STATIC_CAST(int64_t, af);
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvth_s64_f16
|
|
#define vcvth_s64_f16(a) simde_vcvth_s64_f16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
uint64_t
|
|
simde_vcvth_u64_f16(simde_float16_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvth_u64_f16(a);
|
|
#elif defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
return HEDLEY_STATIC_CAST(uint64_t,
|
|
simde_float16_to_float32(a));
|
|
#else
|
|
simde_float32 af = simde_float16_to_float32(a);
|
|
if (HEDLEY_UNLIKELY(af <= SIMDE_FLOAT32_C(0.0))) {
|
|
return 0;
|
|
} else if (HEDLEY_UNLIKELY(af >= HEDLEY_STATIC_CAST(simde_float32, UINT64_MAX))) {
|
|
return UINT64_MAX;
|
|
} else if (HEDLEY_UNLIKELY(simde_isnanhf(a))) {
|
|
return 0;
|
|
} else {
|
|
return HEDLEY_STATIC_CAST(uint64_t, af);
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvth_u64_f16
|
|
#define vcvth_u64_f16(a) simde_vcvth_u64_f16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
int32_t
|
|
simde_vcvts_s32_f32(simde_float32 a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvts_s32_f32(a);
|
|
#elif defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
return HEDLEY_STATIC_CAST(int32_t, a);
|
|
#else
|
|
if (HEDLEY_UNLIKELY(a < HEDLEY_STATIC_CAST(simde_float32, INT32_MIN))) {
|
|
return INT32_MIN;
|
|
} else if (HEDLEY_UNLIKELY(a > HEDLEY_STATIC_CAST(simde_float32, INT32_MAX))) {
|
|
return INT32_MAX;
|
|
} else if (HEDLEY_UNLIKELY(simde_math_isnanf(a))) {
|
|
return 0;
|
|
} else {
|
|
return HEDLEY_STATIC_CAST(int32_t, a);
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvts_s32_f32
|
|
#define vcvts_s32_f32(a) simde_vcvts_s32_f32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
uint32_t
|
|
simde_vcvts_u32_f32(simde_float32 a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && !defined(SIMDE_BUG_CLANG_46844)
|
|
return vcvts_u32_f32(a);
|
|
#elif defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
return HEDLEY_STATIC_CAST(uint32_t, a);
|
|
#else
|
|
if (HEDLEY_UNLIKELY(a < SIMDE_FLOAT32_C(0.0))) {
|
|
return 0;
|
|
} else if (HEDLEY_UNLIKELY(a > HEDLEY_STATIC_CAST(simde_float32, UINT32_MAX))) {
|
|
return UINT32_MAX;
|
|
} else if (simde_math_isnanf(a)) {
|
|
return 0;
|
|
} else {
|
|
return HEDLEY_STATIC_CAST(uint32_t, a);
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvts_u32_f32
|
|
#define vcvts_u32_f32(a) simde_vcvts_u32_f32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float32
|
|
simde_vcvts_f32_s32(int32_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvts_f32_s32(a);
|
|
#else
|
|
return HEDLEY_STATIC_CAST(simde_float32, a);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvts_f32_s32
|
|
#define vcvts_f32_s32(a) simde_vcvts_f32_s32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float32
|
|
simde_vcvts_f32_u32 (uint32_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && !defined(SIMDE_BUG_CLANG_46844)
|
|
return vcvts_f32_u32(a);
|
|
#else
|
|
return HEDLEY_STATIC_CAST(simde_float32, a);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvts_f32_u32
|
|
#define vcvts_f32_u32(a) simde_vcvts_f32_u32(a)
|
|
#endif
|
|
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
int64_t
|
|
simde_vcvtd_s64_f64(simde_float64 a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvtd_s64_f64(a);
|
|
#elif defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
return HEDLEY_STATIC_CAST(int64_t, a);
|
|
#else
|
|
if (HEDLEY_UNLIKELY(a < HEDLEY_STATIC_CAST(simde_float64, INT64_MIN))) {
|
|
return INT64_MIN;
|
|
} else if (HEDLEY_UNLIKELY(a > HEDLEY_STATIC_CAST(simde_float64, INT64_MAX))) {
|
|
return INT64_MAX;
|
|
} else if (simde_math_isnan(a)) {
|
|
return 0;
|
|
} else {
|
|
return HEDLEY_STATIC_CAST(int64_t, a);
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtd_s64_f64
|
|
#define vcvtd_s64_f64(a) simde_vcvtd_s64_f64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
uint64_t
|
|
simde_vcvtd_u64_f64(simde_float64 a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && !defined(SIMDE_BUG_CLANG_46844)
|
|
return vcvtd_u64_f64(a);
|
|
#elif defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
return HEDLEY_STATIC_CAST(uint64_t, a);
|
|
#else
|
|
if (HEDLEY_UNLIKELY(a < SIMDE_FLOAT64_C(0.0))) {
|
|
return 0;
|
|
} else if (HEDLEY_UNLIKELY(a > HEDLEY_STATIC_CAST(simde_float64, UINT64_MAX))) {
|
|
return UINT64_MAX;
|
|
} else if (simde_math_isnan(a)) {
|
|
return 0;
|
|
} else {
|
|
return HEDLEY_STATIC_CAST(uint64_t, a);
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtd_u64_f64
|
|
#define vcvtd_u64_f64(a) simde_vcvtd_u64_f64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float64
|
|
simde_vcvtd_f64_s64(int64_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvtd_f64_s64(a);
|
|
#else
|
|
return HEDLEY_STATIC_CAST(simde_float64, a);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtd_f64_s64
|
|
#define vcvtd_f64_s64(a) simde_vcvtd_f64_s64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float64
|
|
simde_vcvtd_f64_u64(uint64_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && !defined(SIMDE_BUG_CLANG_46844)
|
|
return vcvtd_f64_u64(a);
|
|
#else
|
|
return HEDLEY_STATIC_CAST(simde_float64, a);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtd_f64_u64
|
|
#define vcvtd_f64_u64(a) simde_vcvtd_f64_u64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float16_t
|
|
simde_vcvth_f16_u32(uint32_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvth_f16_u32(a);
|
|
#elif SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_PORTABLE && SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_FP16_NO_ABI
|
|
return HEDLEY_STATIC_CAST(simde_float16_t, a);
|
|
#else
|
|
return simde_float16_from_float32(HEDLEY_STATIC_CAST(simde_float32_t, a));
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvth_f16_u32
|
|
#define vcvth_f16_u32(a) simde_vcvth_f16_u32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float16_t
|
|
simde_vcvth_f16_u64(uint64_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvth_f16_u64(a);
|
|
#elif SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_PORTABLE && SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_FP16_NO_ABI
|
|
return HEDLEY_STATIC_CAST(simde_float16_t, a);
|
|
#else
|
|
return simde_float16_from_float32(HEDLEY_STATIC_CAST(simde_float32_t, a));
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvth_f16_u64
|
|
#define vcvth_f16_u64(a) simde_vcvth_f16_u64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float16_t
|
|
simde_vcvth_f16_s32(int32_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvth_f16_s32(a);
|
|
#elif SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_PORTABLE && SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_FP16_NO_ABI
|
|
return HEDLEY_STATIC_CAST(simde_float16_t, a);
|
|
#else
|
|
return simde_float16_from_float32(HEDLEY_STATIC_CAST(simde_float32_t, a));
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvth_f16_s32
|
|
#define vcvth_f16_s32(a) simde_vcvth_f16_s32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float16_t
|
|
simde_vcvth_f16_s64(int64_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvth_f16_s64(a);
|
|
#elif SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_PORTABLE && SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_FP16_NO_ABI
|
|
return HEDLEY_STATIC_CAST(simde_float16_t, a);
|
|
#else
|
|
return simde_float16_from_float32(HEDLEY_STATIC_CAST(simde_float32_t, a));
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvth_f16_s64
|
|
#define vcvth_f16_s64(a) simde_vcvth_f16_s64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float16_t
|
|
simde_vcvth_f16_s16(int16_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvth_f16_s16(a);
|
|
#elif SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_PORTABLE && SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_FP16_NO_ABI
|
|
return HEDLEY_STATIC_CAST(simde_float16_t, a);
|
|
#else
|
|
return simde_float16_from_float32(HEDLEY_STATIC_CAST(simde_float32_t, a));
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvth_f16_s16
|
|
#define vcvth_f16_s16(a) simde_vcvth_f16_s16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float16_t
|
|
simde_vcvth_f16_u16(uint16_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvth_f16_u16(a);
|
|
#elif SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_PORTABLE && SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_FP16_NO_ABI
|
|
return HEDLEY_STATIC_CAST(simde_float16_t, a);
|
|
#else
|
|
return simde_float16_from_float32(HEDLEY_STATIC_CAST(simde_float32_t, a));
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvth_f16_u16
|
|
#define vcvth_f16_u16(a) simde_vcvth_f16_u16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_int32x2_t
|
|
simde_vcvt_s32_f32(simde_float32x2_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
|
|
return vcvt_s32_f32(a);
|
|
#else
|
|
simde_float32x2_private a_ = simde_float32x2_to_private(a);
|
|
simde_int32x2_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvts_s32_f32(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_int32x2_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_s32_f32
|
|
#define vcvt_s32_f32(a) simde_vcvt_s32_f32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_uint16x4_t
|
|
simde_vcvt_u16_f16(simde_float16x4_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvt_u16_f16(a);
|
|
#else
|
|
simde_float16x4_private a_ = simde_float16x4_to_private(a);
|
|
simde_uint16x4_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_FAST_CONVERSION_RANGE) && defined(SIMDE_FLOAT16_VECTOR)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvth_u16_f16(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_uint16x4_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_u16_f16
|
|
#define vcvt_u16_f16(a) simde_vcvt_u16_f16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_uint32x2_t
|
|
simde_vcvt_u32_f32(simde_float32x2_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE) && !defined(SIMDE_BUG_CLANG_46844)
|
|
return vcvt_u32_f32(a);
|
|
#else
|
|
simde_float32x2_private a_ = simde_float32x2_to_private(a);
|
|
simde_uint32x2_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvts_u32_f32(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_uint32x2_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_u32_f32
|
|
#define vcvt_u32_f32(a) simde_vcvt_u32_f32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_int64x1_t
|
|
simde_vcvt_s64_f64(simde_float64x1_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvt_s64_f64(a);
|
|
#else
|
|
simde_float64x1_private a_ = simde_float64x1_to_private(a);
|
|
simde_int64x1_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtd_s64_f64(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_int64x1_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_s64_f64
|
|
#define vcvt_s64_f64(a) simde_vcvt_s64_f64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_uint64x1_t
|
|
simde_vcvt_u64_f64(simde_float64x1_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && !defined(SIMDE_BUG_CLANG_46844)
|
|
return vcvt_u64_f64(a);
|
|
#else
|
|
simde_float64x1_private a_ = simde_float64x1_to_private(a);
|
|
simde_uint64x1_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
r_.values &= HEDLEY_REINTERPRET_CAST(__typeof__(r_.values), (a_.values >= SIMDE_FLOAT64_C(0.0)));
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtd_u64_f64(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_uint64x1_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_u64_f64
|
|
#define vcvt_u64_f64(a) simde_vcvt_u64_f64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_int32x4_t
|
|
simde_vcvtq_s32_f32(simde_float32x4_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
|
|
return vcvtq_s32_f32(a);
|
|
#elif defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) && defined(SIMDE_FAST_NANS)
|
|
return vec_signed(a);
|
|
#elif defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) && !defined(SIMDE_BUG_GCC_101614)
|
|
return (a == a) & vec_signed(a);
|
|
#else
|
|
simde_float32x4_private a_ = simde_float32x4_to_private(a);
|
|
simde_int32x4_private r_;
|
|
|
|
#if defined(SIMDE_WASM_SIMD128_NATIVE)
|
|
r_.v128 = wasm_i32x4_trunc_sat_f32x4(a_.v128);
|
|
#elif defined(SIMDE_X86_SSE2_NATIVE)
|
|
#if !defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
const __m128i i32_max_mask = _mm_castps_si128(_mm_cmpgt_ps(a_.m128, _mm_set1_ps(SIMDE_FLOAT32_C(2147483520.0))));
|
|
const __m128 clamped = _mm_max_ps(a_.m128, _mm_set1_ps(HEDLEY_STATIC_CAST(simde_float32, INT32_MIN)));
|
|
#else
|
|
const __m128 clamped = a_.m128;
|
|
#endif
|
|
|
|
r_.m128i = _mm_cvttps_epi32(clamped);
|
|
|
|
#if !defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
#if defined(SIMDE_X86_SSE4_1_NATIVE)
|
|
r_.m128i =
|
|
_mm_castps_si128(
|
|
_mm_blendv_ps(
|
|
_mm_castsi128_ps(r_.m128i),
|
|
_mm_castsi128_ps(_mm_set1_epi32(INT32_MAX)),
|
|
_mm_castsi128_ps(i32_max_mask)
|
|
)
|
|
);
|
|
#else
|
|
r_.m128i =
|
|
_mm_or_si128(
|
|
_mm_and_si128(i32_max_mask, _mm_set1_epi32(INT32_MAX)),
|
|
_mm_andnot_si128(i32_max_mask, r_.m128i)
|
|
);
|
|
#endif
|
|
#endif
|
|
|
|
#if !defined(SIMDE_FAST_NANS)
|
|
r_.m128i = _mm_and_si128(r_.m128i, _mm_castps_si128(_mm_cmpord_ps(a_.m128, a_.m128)));
|
|
#endif
|
|
#elif defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_FAST_CONVERSION_RANGE) && !defined(SIMDE_FAST_NANS)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#elif defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_IEEE754_STORAGE)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
|
|
static const float SIMDE_VECTOR(16) max_representable = { SIMDE_FLOAT32_C(2147483520.0), SIMDE_FLOAT32_C(2147483520.0), SIMDE_FLOAT32_C(2147483520.0), SIMDE_FLOAT32_C(2147483520.0) };
|
|
int32_t SIMDE_VECTOR(16) max_mask = HEDLEY_REINTERPRET_CAST(__typeof__(max_mask), a_.values > max_representable);
|
|
int32_t SIMDE_VECTOR(16) max_i32 = { INT32_MAX, INT32_MAX, INT32_MAX, INT32_MAX };
|
|
r_.values = (max_i32 & max_mask) | (r_.values & ~max_mask);
|
|
|
|
static const float SIMDE_VECTOR(16) min_representable = { HEDLEY_STATIC_CAST(simde_float32, INT32_MIN), HEDLEY_STATIC_CAST(simde_float32, INT32_MIN), HEDLEY_STATIC_CAST(simde_float32, INT32_MIN), HEDLEY_STATIC_CAST(simde_float32, INT32_MIN) };
|
|
int32_t SIMDE_VECTOR(16) min_mask = HEDLEY_REINTERPRET_CAST(__typeof__(min_mask), a_.values < min_representable);
|
|
int32_t SIMDE_VECTOR(16) min_i32 = { INT32_MIN, INT32_MIN, INT32_MIN, INT32_MIN };
|
|
r_.values = (min_i32 & min_mask) | (r_.values & ~min_mask);
|
|
|
|
r_.values &= HEDLEY_REINTERPRET_CAST(__typeof__(r_.values), a_.values == a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvts_s32_f32(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_int32x4_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtq_s32_f32
|
|
#define vcvtq_s32_f32(a) simde_vcvtq_s32_f32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_uint16x8_t
|
|
simde_vcvtq_u16_f16(simde_float16x8_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvtq_u16_f16(a);
|
|
#else
|
|
simde_float16x8_private a_ = simde_float16x8_to_private(a);
|
|
simde_uint16x8_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_FAST_CONVERSION_RANGE) && defined(SIMDE_FLOAT16_VECTOR)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvth_u16_f16(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_uint16x8_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtq_u16_f16
|
|
#define vcvtq_u16_f16(a) simde_vcvtq_u16_f16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_uint32x4_t
|
|
simde_vcvtq_u32_f32(simde_float32x4_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE) && !defined(SIMDE_BUG_CLANG_46844)
|
|
return vcvtq_u32_f32(a);
|
|
#else
|
|
simde_float32x4_private a_ = simde_float32x4_to_private(a);
|
|
simde_uint32x4_private r_;
|
|
|
|
#if defined(SIMDE_WASM_SIMD128_NATIVE)
|
|
r_.v128 = wasm_u32x4_trunc_sat_f32x4(a_.v128);
|
|
#elif defined(SIMDE_X86_SSE2_NATIVE)
|
|
#if defined(SIMDE_X86_AVX512VL_NATIVE)
|
|
r_.m128i = _mm_cvttps_epu32(a_.m128);
|
|
#else
|
|
__m128 first_oob_high = _mm_set1_ps(SIMDE_FLOAT32_C(4294967296.0));
|
|
__m128 neg_zero_if_too_high =
|
|
_mm_castsi128_ps(
|
|
_mm_slli_epi32(
|
|
_mm_castps_si128(_mm_cmple_ps(first_oob_high, a_.m128)),
|
|
31
|
|
)
|
|
);
|
|
r_.m128i =
|
|
_mm_xor_si128(
|
|
_mm_cvttps_epi32(
|
|
_mm_sub_ps(a_.m128, _mm_and_ps(neg_zero_if_too_high, first_oob_high))
|
|
),
|
|
_mm_castps_si128(neg_zero_if_too_high)
|
|
);
|
|
#endif
|
|
|
|
#if !defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
r_.m128i = _mm_and_si128(r_.m128i, _mm_castps_si128(_mm_cmpgt_ps(a_.m128, _mm_set1_ps(SIMDE_FLOAT32_C(0.0)))));
|
|
r_.m128i = _mm_or_si128 (r_.m128i, _mm_castps_si128(_mm_cmpge_ps(a_.m128, _mm_set1_ps(SIMDE_FLOAT32_C(4294967296.0)))));
|
|
#endif
|
|
|
|
#if !defined(SIMDE_FAST_NANS)
|
|
r_.m128i = _mm_and_si128(r_.m128i, _mm_castps_si128(_mm_cmpord_ps(a_.m128, a_.m128)));
|
|
#endif
|
|
#elif defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#elif defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_IEEE754_STORAGE)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
|
|
const __typeof__(a_.values) max_representable = { SIMDE_FLOAT32_C(4294967040.0), SIMDE_FLOAT32_C(4294967040.0), SIMDE_FLOAT32_C(4294967040.0), SIMDE_FLOAT32_C(4294967040.0) };
|
|
r_.values |= HEDLEY_REINTERPRET_CAST(__typeof__(r_.values), a_.values > max_representable);
|
|
|
|
const __typeof__(a_.values) min_representable = { SIMDE_FLOAT32_C(0.0), };
|
|
r_.values &= HEDLEY_REINTERPRET_CAST(__typeof__(r_.values), a_.values > min_representable);
|
|
|
|
r_.values &= HEDLEY_REINTERPRET_CAST(__typeof__(r_.values), a_.values == a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvts_u32_f32(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_uint32x4_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtq_u32_f32
|
|
#define vcvtq_u32_f32(a) simde_vcvtq_u32_f32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_int64x2_t
|
|
simde_vcvtq_s64_f64(simde_float64x2_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvtq_s64_f64(a);
|
|
#elif defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) && defined(SIMDE_FAST_NANS)
|
|
return vec_signed(a);
|
|
#elif defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE)
|
|
return (a == a) & vec_signed(a);
|
|
#else
|
|
simde_float64x2_private a_ = simde_float64x2_to_private(a);
|
|
simde_int64x2_private r_;
|
|
|
|
#if defined(SIMDE_X86_SSE2_NATIVE) && (defined(SIMDE_ARCH_AMD64) || (defined(SIMDE_X86_AVX512DQ_NATIVE) && defined(SIMDE_X86_AVX512VL_NATIVE)))
|
|
#if !defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
const __m128i i64_max_mask = _mm_castpd_si128(_mm_cmpge_pd(a_.m128d, _mm_set1_pd(HEDLEY_STATIC_CAST(simde_float64, INT64_MAX))));
|
|
const __m128d clamped_low = _mm_max_pd(a_.m128d, _mm_set1_pd(HEDLEY_STATIC_CAST(simde_float64, INT64_MIN)));
|
|
#else
|
|
const __m128d clamped_low = a_.m128d;
|
|
#endif
|
|
|
|
#if defined(SIMDE_X86_AVX512VL_NATIVE) && defined(SIMDE_X86_AVX512DQ_NATIVE)
|
|
r_.m128i = _mm_cvttpd_epi64(clamped_low);
|
|
#else
|
|
r_.m128i =
|
|
_mm_set_epi64x(
|
|
_mm_cvttsd_si64(_mm_unpackhi_pd(clamped_low, clamped_low)),
|
|
_mm_cvttsd_si64(clamped_low)
|
|
);
|
|
#endif
|
|
|
|
#if !defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
#if defined(SIMDE_X86_SSE4_1_NATIVE)
|
|
r_.m128i =
|
|
_mm_castpd_si128(
|
|
_mm_blendv_pd(
|
|
_mm_castsi128_pd(r_.m128i),
|
|
_mm_castsi128_pd(_mm_set1_epi64x(INT64_MAX)),
|
|
_mm_castsi128_pd(i64_max_mask)
|
|
)
|
|
);
|
|
#else
|
|
r_.m128i =
|
|
_mm_or_si128(
|
|
_mm_and_si128(i64_max_mask, _mm_set1_epi64x(INT64_MAX)),
|
|
_mm_andnot_si128(i64_max_mask, r_.m128i)
|
|
);
|
|
#endif
|
|
#endif
|
|
|
|
#if !defined(SIMDE_FAST_NANS)
|
|
r_.m128i = _mm_and_si128(r_.m128i, _mm_castpd_si128(_mm_cmpord_pd(a_.m128d, a_.m128d)));
|
|
#endif
|
|
#elif defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#elif defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_IEEE754_STORAGE)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
|
|
const __typeof__((a_.values)) max_representable = { SIMDE_FLOAT64_C(9223372036854774784.0), SIMDE_FLOAT64_C(9223372036854774784.0) };
|
|
__typeof__(r_.values) max_mask = HEDLEY_REINTERPRET_CAST(__typeof__(max_mask), a_.values > max_representable);
|
|
__typeof__(r_.values) max_i64 = { INT64_MAX, INT64_MAX };
|
|
r_.values = (max_i64 & max_mask) | (r_.values & ~max_mask);
|
|
|
|
const __typeof__((a_.values)) min_representable = { HEDLEY_STATIC_CAST(simde_float64, INT64_MIN), HEDLEY_STATIC_CAST(simde_float64, INT64_MIN) };
|
|
__typeof__(r_.values) min_mask = HEDLEY_REINTERPRET_CAST(__typeof__(min_mask), a_.values < min_representable);
|
|
__typeof__(r_.values) min_i64 = { INT64_MIN, INT64_MIN };
|
|
r_.values = (min_i64 & min_mask) | (r_.values & ~min_mask);
|
|
|
|
#if !defined(SIMDE_FAST_NANS)
|
|
r_.values &= HEDLEY_REINTERPRET_CAST(__typeof__(r_.values), a_.values == a_.values);
|
|
#endif
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtd_s64_f64(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_int64x2_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtq_s64_f64
|
|
#define vcvtq_s64_f64(a) simde_vcvtq_s64_f64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_uint64x2_t
|
|
simde_vcvtq_u64_f64(simde_float64x2_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && !defined(SIMDE_BUG_CLANG_46844)
|
|
return vcvtq_u64_f64(a);
|
|
#elif defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE) && defined(SIMDE_FAST_NANS)
|
|
return vec_unsigned(a);
|
|
#elif defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE)
|
|
return HEDLEY_REINTERPRET_CAST(simde_uint64x2_t, (a == a)) & vec_unsigned(a);
|
|
#else
|
|
simde_float64x2_private a_ = simde_float64x2_to_private(a);
|
|
simde_uint64x2_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#elif defined(SIMDE_X86_SSE2_NATIVE) && (defined(SIMDE_ARCH_AMD64) || (defined(SIMDE_X86_AVX512DQ_NATIVE) && defined(SIMDE_X86_AVX512VL_NATIVE)))
|
|
#if defined(SIMDE_X86_AVX512DQ_NATIVE) && defined(SIMDE_X86_AVX512VL_NATIVE)
|
|
r_.m128i = _mm_cvttpd_epu64(a_.m128d);
|
|
#else
|
|
__m128d first_oob_high = _mm_set1_pd(SIMDE_FLOAT64_C(18446744073709551616.0));
|
|
__m128d neg_zero_if_too_high =
|
|
_mm_castsi128_pd(
|
|
_mm_slli_epi64(
|
|
_mm_castpd_si128(_mm_cmple_pd(first_oob_high, a_.m128d)),
|
|
63
|
|
)
|
|
);
|
|
__m128d tmp = _mm_sub_pd(a_.m128d, _mm_and_pd(neg_zero_if_too_high, first_oob_high));
|
|
r_.m128i =
|
|
_mm_xor_si128(
|
|
_mm_set_epi64x(
|
|
_mm_cvttsd_si64(_mm_unpackhi_pd(tmp, tmp)),
|
|
_mm_cvttsd_si64(tmp)
|
|
),
|
|
_mm_castpd_si128(neg_zero_if_too_high)
|
|
);
|
|
#endif
|
|
|
|
#if !defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
r_.m128i = _mm_and_si128(r_.m128i, _mm_castpd_si128(_mm_cmpgt_pd(a_.m128d, _mm_set1_pd(SIMDE_FLOAT64_C(0.0)))));
|
|
r_.m128i = _mm_or_si128 (r_.m128i, _mm_castpd_si128(_mm_cmpge_pd(a_.m128d, _mm_set1_pd(SIMDE_FLOAT64_C(18446744073709551616.0)))));
|
|
#endif
|
|
|
|
#if !defined(SIMDE_FAST_NANS)
|
|
r_.m128i = _mm_and_si128(r_.m128i, _mm_castpd_si128(_mm_cmpord_pd(a_.m128d, a_.m128d)));
|
|
#endif
|
|
#elif defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_IEEE754_STORAGE)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
|
|
const __typeof__(a_.values) max_representable = { SIMDE_FLOAT64_C(18446744073709549568.0), SIMDE_FLOAT64_C(18446744073709549568.0) };
|
|
r_.values |= HEDLEY_REINTERPRET_CAST(__typeof__(r_.values), a_.values > max_representable);
|
|
|
|
const __typeof__(a_.values) min_representable = { SIMDE_FLOAT64_C(0.0), };
|
|
r_.values &= HEDLEY_REINTERPRET_CAST(__typeof__(r_.values), a_.values > min_representable);
|
|
|
|
r_.values &= HEDLEY_REINTERPRET_CAST(__typeof__(r_.values), (a_.values == a_.values));
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtd_u64_f64(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_uint64x2_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtq_u64_f64
|
|
#define vcvtq_u64_f64(a) simde_vcvtq_u64_f64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float16x4_t
|
|
simde_vcvt_f16_s16(simde_int16x4_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvt_f16_s16(a);
|
|
#else
|
|
simde_int16x4_private a_ = simde_int16x4_to_private(a);
|
|
simde_float16x4_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_FLOAT16_VECTOR)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
#if SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_PORTABLE && SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_FP16_NO_ABI
|
|
r_.values[i] = HEDLEY_STATIC_CAST(simde_float16_t, a_.values[i]);
|
|
#else
|
|
r_.values[i] = simde_float16_from_float32(HEDLEY_STATIC_CAST(simde_float32_t, a_.values[i]));
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
return simde_float16x4_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_f16_s16
|
|
#define vcvt_f16_s16(a) simde_vcvt_f16_s16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float32x2_t
|
|
simde_vcvt_f32_s32(simde_int32x2_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
|
|
return vcvt_f32_s32(a);
|
|
#else
|
|
simde_int32x2_private a_ = simde_int32x2_to_private(a);
|
|
simde_float32x2_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvts_f32_s32(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_float32x2_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_f32_s32
|
|
#define vcvt_f32_s32(a) simde_vcvt_f32_s32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float16x4_t
|
|
simde_vcvt_f16_u16(simde_uint16x4_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvt_f16_u16(a);
|
|
#else
|
|
simde_uint16x4_private a_ = simde_uint16x4_to_private(a);
|
|
simde_float16x4_private r_;
|
|
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
#if SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_PORTABLE && SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_FP16_NO_ABI
|
|
r_.values[i] = HEDLEY_STATIC_CAST(simde_float16_t, a_.values[i]);
|
|
#else
|
|
r_.values[i] = simde_float16_from_float32(HEDLEY_STATIC_CAST(simde_float32_t, a_.values[i]));
|
|
#endif
|
|
}
|
|
|
|
return simde_float16x4_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_f16_u16
|
|
#define vcvt_f16_u16(a) simde_vcvt_f16_u16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float32x2_t
|
|
simde_vcvt_f32_u32(simde_uint32x2_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE) && !defined(SIMDE_BUG_CLANG_46844)
|
|
return vcvt_f32_u32(a);
|
|
#else
|
|
simde_uint32x2_private a_ = simde_uint32x2_to_private(a);
|
|
simde_float32x2_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvts_f32_u32(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_float32x2_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_f32_u32
|
|
#define vcvt_f32_u32(a) simde_vcvt_f32_u32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float64x1_t
|
|
simde_vcvt_f64_s64(simde_int64x1_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvt_f64_s64(a);
|
|
#else
|
|
simde_int64x1_private a_ = simde_int64x1_to_private(a);
|
|
simde_float64x1_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtd_f64_s64(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_float64x1_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_f64_s64
|
|
#define vcvt_f64_s64(a) simde_vcvt_f64_s64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float64x1_t
|
|
simde_vcvt_f64_u64(simde_uint64x1_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && !defined(SIMDE_BUG_CLANG_46844)
|
|
return vcvt_f64_u64(a);
|
|
#else
|
|
simde_uint64x1_private a_ = simde_uint64x1_to_private(a);
|
|
simde_float64x1_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtd_f64_u64(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_float64x1_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_f64_u64
|
|
#define vcvt_f64_u64(a) simde_vcvt_f64_u64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float16x8_t
|
|
simde_vcvtq_f16_s16(simde_int16x8_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvtq_f16_s16(a);
|
|
#else
|
|
simde_int16x8_private a_ = simde_int16x8_to_private(a);
|
|
simde_float16x8_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_FLOAT16_VECTOR)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
#if SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_PORTABLE && SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_FP16_NO_ABI
|
|
r_.values[i] = HEDLEY_STATIC_CAST(simde_float16_t, a_.values[i]);
|
|
#else
|
|
r_.values[i] = simde_float16_from_float32(HEDLEY_STATIC_CAST(simde_float32_t, a_.values[i]));
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
return simde_float16x8_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtq_f16_s16
|
|
#define vcvtq_f16_s16(a) simde_vcvtq_f16_s16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float32x4_t
|
|
simde_vcvtq_f32_s32(simde_int32x4_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
|
|
return vcvtq_f32_s32(a);
|
|
#else
|
|
simde_int32x4_private a_ = simde_int32x4_to_private(a);
|
|
simde_float32x4_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvts_f32_s32(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_float32x4_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtq_f32_s32
|
|
#define vcvtq_f32_s32(a) simde_vcvtq_f32_s32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float16x8_t
|
|
simde_vcvtq_f16_u16(simde_uint16x8_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && !defined(SIMDE_BUG_CLANG_46844) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvtq_f16_u16(a);
|
|
#else
|
|
simde_uint16x8_private a_ = simde_uint16x8_to_private(a);
|
|
simde_float16x8_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_) && defined(SIMDE_FLOAT16_VECTOR)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
#if SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_PORTABLE && SIMDE_FLOAT16_API != SIMDE_FLOAT16_API_FP16_NO_ABI
|
|
r_.values[i] = HEDLEY_STATIC_CAST(simde_float16_t, a_.values[i]);
|
|
#else
|
|
r_.values[i] = simde_float16_from_float32(HEDLEY_STATIC_CAST(simde_float32_t, a_.values[i]));
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
return simde_float16x8_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtq_f16_u16
|
|
#define vcvtq_f16_u16(a) simde_vcvtq_f16_u16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float32x4_t
|
|
simde_vcvtq_f32_u32(simde_uint32x4_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V7_NATIVE) && !defined(SIMDE_BUG_CLANG_46844)
|
|
return vcvtq_f32_u32(a);
|
|
#else
|
|
simde_uint32x4_private a_ = simde_uint32x4_to_private(a);
|
|
simde_float32x4_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvts_f32_u32(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_float32x4_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtq_f32_u32
|
|
#define vcvtq_f32_u32(a) simde_vcvtq_f32_u32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float64x2_t
|
|
simde_vcvtq_f64_s64(simde_int64x2_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvtq_f64_s64(a);
|
|
#elif defined(SIMDE_ZARCH_ZVECTOR_13_NATIVE)
|
|
return vec_ctd(a, 0);
|
|
#else
|
|
simde_int64x2_private a_ = simde_int64x2_to_private(a);
|
|
simde_float64x2_private r_;
|
|
|
|
#if defined(SIMDE_X86_AVX512VL_NATIVE) && defined(SIMDE_X86_AVX512DQ_NATIVE)
|
|
r_.m128d = _mm_cvtepi64_pd(a_.m128i);
|
|
#elif defined(SIMDE_CONVERT_VECTOR_)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtd_f64_s64(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_float64x2_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtq_f64_s64
|
|
#define vcvtq_f64_s64(a) simde_vcvtq_f64_s64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float64x2_t
|
|
simde_vcvtq_f64_u64(simde_uint64x2_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && !defined(SIMDE_BUG_CLANG_46844)
|
|
return vcvtq_f64_u64(a);
|
|
#else
|
|
simde_uint64x2_private a_ = simde_uint64x2_to_private(a);
|
|
simde_float64x2_private r_;
|
|
|
|
#if defined(SIMDE_CONVERT_VECTOR_)
|
|
SIMDE_CONVERT_VECTOR_(r_.values, a_.values);
|
|
#else
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtd_f64_u64(a_.values[i]);
|
|
}
|
|
#endif
|
|
|
|
return simde_float64x2_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtq_f64_u64
|
|
#define vcvtq_f64_u64(a) simde_vcvtq_f64_u64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
uint16_t
|
|
simde_vcvtah_u16_f16(simde_float16_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && !defined(SIMDE_BUG_CLANG_46844) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvtah_u16_f16(a);
|
|
#elif defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
return HEDLEY_STATIC_CAST(uint16_t,
|
|
simde_math_roundf(simde_float16_to_float32(a)));
|
|
#else
|
|
simde_float32 af = simde_float16_to_float32(a);
|
|
if (HEDLEY_UNLIKELY(af <= SIMDE_FLOAT32_C(0.0))) {
|
|
return 0;
|
|
} else if (HEDLEY_UNLIKELY(af >= HEDLEY_STATIC_CAST(simde_float32, UINT16_MAX))) {
|
|
return UINT16_MAX;
|
|
} else if (HEDLEY_UNLIKELY(simde_isnanhf(a))) {
|
|
return 0;
|
|
} else {
|
|
return HEDLEY_STATIC_CAST(uint16_t, simde_math_roundf(af));
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtah_u16_f16
|
|
#define vcvtah_u16_f16(a) simde_vcvtah_u16_f16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
int32_t
|
|
simde_vcvtah_s32_f16(simde_float16_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvtah_s32_f16(a);
|
|
#elif defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
return HEDLEY_STATIC_CAST(int32_t,
|
|
simde_math_roundf(simde_float16_to_float32(a)));
|
|
#else
|
|
simde_float32 af = simde_float16_to_float32(a);
|
|
if (HEDLEY_UNLIKELY(af <= HEDLEY_STATIC_CAST(simde_float32, INT32_MIN))) {
|
|
return INT32_MIN;
|
|
} else if (HEDLEY_UNLIKELY(af >= HEDLEY_STATIC_CAST(simde_float32, INT32_MAX))) {
|
|
return INT32_MAX;
|
|
} else if (HEDLEY_UNLIKELY(simde_isnanhf(a))) {
|
|
return 0;
|
|
} else {
|
|
return HEDLEY_STATIC_CAST(int32_t, simde_math_roundf(af));
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtah_s32_f16
|
|
#define vcvtah_s32_f16(a) simde_vcvtah_s32_f16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
uint32_t
|
|
simde_vcvtah_u32_f16(simde_float16_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && !defined(SIMDE_BUG_CLANG_46844) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvtah_u32_f16(a);
|
|
#elif defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
return HEDLEY_STATIC_CAST(uint32_t,
|
|
simde_math_roundf(simde_float16_to_float32(a)));
|
|
#else
|
|
simde_float32 af = simde_float16_to_float32(a);
|
|
if (HEDLEY_UNLIKELY(af <= SIMDE_FLOAT32_C(0.0))) {
|
|
return 0;
|
|
} else if (HEDLEY_UNLIKELY(af >= HEDLEY_STATIC_CAST(simde_float32, UINT32_MAX))) {
|
|
return UINT32_MAX;
|
|
} else if (HEDLEY_UNLIKELY(simde_isnanhf(a))) {
|
|
return 0;
|
|
} else {
|
|
return HEDLEY_STATIC_CAST(uint32_t, simde_math_roundf(af));
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtah_u32_f16
|
|
#define vcvtah_u32_f16(a) simde_vcvtah_u32_f16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
int64_t
|
|
simde_vcvtah_s64_f16(simde_float16_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvtah_s64_f16(a);
|
|
#elif defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
return HEDLEY_STATIC_CAST(int64_t,
|
|
simde_math_roundf(simde_float16_to_float32(a)));
|
|
#else
|
|
simde_float32 af = simde_float16_to_float32(a);
|
|
if (HEDLEY_UNLIKELY(af <= HEDLEY_STATIC_CAST(simde_float32, INT64_MIN))) {
|
|
return INT64_MIN;
|
|
} else if (HEDLEY_UNLIKELY(af >= HEDLEY_STATIC_CAST(simde_float32, INT64_MAX))) {
|
|
return INT64_MAX;
|
|
} else if (HEDLEY_UNLIKELY(simde_isnanhf(a))) {
|
|
return 0;
|
|
} else {
|
|
return HEDLEY_STATIC_CAST(int64_t, simde_math_roundf(af));
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtah_s64_f16
|
|
#define vcvtah_s64_f16(a) simde_vcvtah_s64_f16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
uint64_t
|
|
simde_vcvtah_u64_f16(simde_float16_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && !defined(SIMDE_BUG_CLANG_46844) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvtah_u64_f16(a);
|
|
#elif defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
return HEDLEY_STATIC_CAST(uint64_t,
|
|
simde_math_roundf(simde_float16_to_float32(a)));
|
|
#else
|
|
simde_float32 af = simde_float16_to_float32(a);
|
|
if (HEDLEY_UNLIKELY(af <= SIMDE_FLOAT32_C(0.0))) {
|
|
return 0;
|
|
} else if (HEDLEY_UNLIKELY(af >= HEDLEY_STATIC_CAST(simde_float32, UINT64_MAX))) {
|
|
return UINT64_MAX;
|
|
} else if (HEDLEY_UNLIKELY(simde_isnanhf(a))) {
|
|
return 0;
|
|
} else {
|
|
return HEDLEY_STATIC_CAST(uint64_t, simde_math_roundf(af));
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtah_u64_f16
|
|
#define vcvtah_u64_f16(a) simde_vcvtah_u64_f16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
int64_t
|
|
simde_vcvtad_s64_f64(simde_float64 a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvtad_s64_f64(a);
|
|
#elif defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
return HEDLEY_STATIC_CAST(int64_t, simde_math_round(a));
|
|
#else
|
|
if (HEDLEY_UNLIKELY(a <= HEDLEY_STATIC_CAST(simde_float64, INT64_MIN))) {
|
|
return INT64_MIN;
|
|
} else if (HEDLEY_UNLIKELY(a >= HEDLEY_STATIC_CAST(simde_float64, INT64_MAX))) {
|
|
return INT64_MAX;
|
|
} else if (HEDLEY_UNLIKELY(simde_math_isnan(a))) {
|
|
return 0;
|
|
} else {
|
|
return HEDLEY_STATIC_CAST(int64_t, simde_math_round(a));
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtad_s64_f64
|
|
#define vcvtad_s64_f64(a) simde_vcvtad_s64_f64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
uint64_t
|
|
simde_vcvtad_u64_f64(simde_float64 a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && !defined(SIMDE_BUG_CLANG_46844)
|
|
return vcvtad_u64_f64(a);
|
|
#elif defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
return HEDLEY_STATIC_CAST(uint64_t, simde_math_round(a));
|
|
#else
|
|
if (HEDLEY_UNLIKELY(a <= SIMDE_FLOAT64_C(0.0))) {
|
|
return 0;
|
|
} else if (HEDLEY_UNLIKELY(a >= HEDLEY_STATIC_CAST(simde_float64, UINT64_MAX))) {
|
|
return UINT64_MAX;
|
|
} else if (simde_math_isnan(a)) {
|
|
return 0;
|
|
} else {
|
|
return HEDLEY_STATIC_CAST(uint64_t, simde_math_round(a));
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtad_u64_f64
|
|
#define vcvtad_u64_f64(a) simde_vcvtad_u64_f64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
int32_t
|
|
simde_vcvtas_s32_f32(simde_float32 a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvtas_s32_f32(a);
|
|
#elif defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
return HEDLEY_STATIC_CAST(int32_t, simde_math_roundf(a));
|
|
#else
|
|
if (HEDLEY_UNLIKELY(a <= HEDLEY_STATIC_CAST(simde_float32, INT32_MIN))) {
|
|
return INT32_MIN;
|
|
} else if (HEDLEY_UNLIKELY(a >= HEDLEY_STATIC_CAST(simde_float32, INT32_MAX))) {
|
|
return INT32_MAX;
|
|
} else if (HEDLEY_UNLIKELY(simde_math_isnanf(a))) {
|
|
return 0;
|
|
} else {
|
|
return HEDLEY_STATIC_CAST(int32_t, simde_math_roundf(a));
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtas_s32_f32
|
|
#define vcvtas_s32_f32(a) simde_vcvtas_s32_f32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
uint32_t
|
|
simde_vcvtas_u32_f32(simde_float32 a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvtas_u32_f32(a);
|
|
#elif defined(SIMDE_FAST_CONVERSION_RANGE)
|
|
return HEDLEY_STATIC_CAST(uint32_t, simde_math_roundf(a));
|
|
#else
|
|
if (HEDLEY_UNLIKELY(a < SIMDE_FLOAT32_C(0.0))) {
|
|
return 0;
|
|
} else if (HEDLEY_UNLIKELY(a >= HEDLEY_STATIC_CAST(simde_float32, UINT32_MAX))) {
|
|
return UINT32_MAX;
|
|
} else if (HEDLEY_UNLIKELY(simde_math_isnanf(a))) {
|
|
return 0;
|
|
} else {
|
|
if (a < 0) return 0;
|
|
return HEDLEY_STATIC_CAST(uint32_t, simde_math_roundf(a));
|
|
}
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtas_u32_f32
|
|
#define vcvtas_u32_f32(a) simde_vcvtas_u32_f32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_uint16x4_t
|
|
simde_vcvta_u16_f16(simde_float16x4_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvta_u16_f16(a);
|
|
#else
|
|
simde_float16x4_private a_ = simde_float16x4_to_private(a);
|
|
simde_uint16x4_private r_;
|
|
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtah_u16_f16(a_.values[i]);
|
|
}
|
|
|
|
return simde_uint16x4_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvta_u16_f16
|
|
#define vcvta_u16_f16(a) simde_vcvta_u16_f16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_int64x1_t
|
|
simde_vcvta_s64_f64(simde_float64x1_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvta_s64_f64(a);
|
|
#else
|
|
simde_float64x1_private a_ = simde_float64x1_to_private(a);
|
|
simde_int64x1_private r_;
|
|
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtad_s64_f64(a_.values[i]);
|
|
}
|
|
|
|
return simde_int64x1_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvta_s64_f64
|
|
#define vcvta_s64_f64(a) simde_vcvta_s64_f64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_uint64x1_t
|
|
simde_vcvta_u64_f64(simde_float64x1_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvta_u64_f64(a);
|
|
#else
|
|
simde_float64x1_private a_ = simde_float64x1_to_private(a);
|
|
simde_uint64x1_private r_;
|
|
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtad_u64_f64(a_.values[i]);
|
|
}
|
|
|
|
return simde_uint64x1_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvta_u64_f64
|
|
#define vcvta_u64_f64(a) simde_vcvta_u64_f64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_int32x2_t
|
|
simde_vcvta_s32_f32(simde_float32x2_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvta_s32_f32(a);
|
|
#else
|
|
simde_float32x2_private a_ = simde_float32x2_to_private(a);
|
|
simde_int32x2_private r_;
|
|
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtas_s32_f32(a_.values[i]);
|
|
}
|
|
|
|
return simde_int32x2_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvta_s32_f32
|
|
#define vcvta_s32_f32(a) simde_vcvta_s32_f32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_uint16x8_t
|
|
simde_vcvtaq_u16_f16(simde_float16x8_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvtaq_u16_f16(a);
|
|
#else
|
|
simde_float16x8_private a_ = simde_float16x8_to_private(a);
|
|
simde_uint16x8_private r_;
|
|
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtah_u16_f16(a_.values[i]);
|
|
}
|
|
|
|
return simde_uint16x8_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtaq_u16_f16
|
|
#define vcvtaq_u16_f16(a) simde_vcvtaq_u16_f16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_int32x4_t
|
|
simde_vcvtaq_s32_f32(simde_float32x4_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvtaq_s32_f32(a);
|
|
#else
|
|
simde_float32x4_private a_ = simde_float32x4_to_private(a);
|
|
simde_int32x4_private r_;
|
|
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtas_s32_f32(a_.values[i]);
|
|
}
|
|
|
|
return simde_int32x4_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtaq_s32_f32
|
|
#define vcvtaq_s32_f32(a) simde_vcvtaq_s32_f32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_int64x2_t
|
|
simde_vcvtaq_s64_f64(simde_float64x2_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvtaq_s64_f64(a);
|
|
#else
|
|
simde_float64x2_private a_ = simde_float64x2_to_private(a);
|
|
simde_int64x2_private r_;
|
|
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtad_s64_f64(a_.values[i]);
|
|
}
|
|
|
|
return simde_int64x2_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtaq_s64_f64
|
|
#define vcvtaq_s64_f64(a) simde_vcvtaq_s64_f64(a)
|
|
#endif
|
|
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_uint64x2_t
|
|
simde_vcvtaq_u64_f64(simde_float64x2_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvtaq_u64_f64(a);
|
|
#else
|
|
simde_float64x2_private a_ = simde_float64x2_to_private(a);
|
|
simde_uint64x2_private r_;
|
|
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtad_u64_f64(a_.values[i]);
|
|
}
|
|
|
|
return simde_uint64x2_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtaq_u64_f64
|
|
#define vcvtaq_u64_f64(a) simde_vcvtaq_u64_f64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_uint32x2_t
|
|
simde_vcvta_u32_f32(simde_float32x2_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvta_u32_f32(a);
|
|
#else
|
|
simde_float32x2_private a_ = simde_float32x2_to_private(a);
|
|
simde_uint32x2_private r_;
|
|
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtas_u32_f32(a_.values[i]);
|
|
}
|
|
|
|
return simde_uint32x2_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvta_u32_f32
|
|
#define vcvta_u32_f32(a) simde_vcvta_u32_f32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_uint32x4_t
|
|
simde_vcvtaq_u32_f32(simde_float32x4_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvtaq_u32_f32(a);
|
|
#else
|
|
simde_float32x4_private a_ = simde_float32x4_to_private(a);
|
|
simde_uint32x4_private r_;
|
|
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtas_u32_f32(a_.values[i]);
|
|
}
|
|
|
|
return simde_uint32x4_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtaq_u32_f32
|
|
#define vcvtaq_u32_f32(a) simde_vcvtaq_u32_f32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float16x8_t
|
|
simde_vcvt_high_f16_f32(simde_float16x4_t r, simde_float32x4_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvt_high_f16_f32(r, a);
|
|
#else
|
|
simde_float32x4_private a_ = simde_float32x4_to_private(a);
|
|
simde_float16x4_private b_ = simde_float16x4_to_private(r);
|
|
simde_float16x8_private r_;
|
|
|
|
size_t half_pos = (sizeof(r_.values) / sizeof(r_.values[0]) / 2);
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < half_pos; i++) {
|
|
r_.values[i] = b_.values[i];
|
|
}
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = half_pos; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_float16_from_float32(a_.values[i-half_pos]);
|
|
}
|
|
|
|
return simde_float16x8_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_high_f16_f32
|
|
#define vcvt_high_f16_f32(r, a) simde_vcvt_high_f16_f32((r), (a))
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float32x4_t
|
|
simde_vcvt_high_f32_f64(simde_float32x2_t r, simde_float64x2_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvt_high_f32_f64(r, a);
|
|
#else
|
|
simde_float64x2_private a_ = simde_float64x2_to_private(a);
|
|
simde_float32x2_private b_ = simde_float32x2_to_private(r);
|
|
simde_float32x4_private r_;
|
|
|
|
size_t half_pos = (sizeof(r_.values) / sizeof(r_.values[0]) / 2);
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < half_pos; i++) {
|
|
r_.values[i] = b_.values[i];
|
|
}
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = half_pos; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = HEDLEY_STATIC_CAST(simde_float32, a_.values[i-half_pos]);
|
|
}
|
|
|
|
return simde_float32x4_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_high_f32_f64
|
|
#define vcvt_high_f32_f64(r, a) simde_vcvt_high_f32_f64((r), (a))
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float32x4_t
|
|
simde_vcvt_high_f32_f16(simde_float16x8_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE) && defined(SIMDE_ARM_NEON_FP16)
|
|
return vcvt_high_f32_f16(a);
|
|
#else
|
|
simde_float16x8_private a_ = simde_float16x8_to_private(a);
|
|
simde_float32x4_private r_;
|
|
|
|
size_t rsize = (sizeof(r_.values) / sizeof(r_.values[0]));
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < rsize; i++) {
|
|
r_.values[i] = simde_float16_to_float32(a_.values[i+rsize]);
|
|
}
|
|
|
|
return simde_float32x4_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_high_f32_f16
|
|
#define vcvt_high_f32_f16(a) simde_vcvt_high_f32_f16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float64x2_t
|
|
simde_vcvt_high_f64_f32(simde_float32x4_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvt_high_f64_f32(a);
|
|
#else
|
|
simde_float32x4_private a_ = simde_float32x4_to_private(a);
|
|
simde_float64x2_private r_;
|
|
|
|
size_t rsize = (sizeof(r_.values) / sizeof(r_.values[0]));
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = HEDLEY_STATIC_CAST(simde_float64, a_.values[i+rsize]);
|
|
}
|
|
|
|
return simde_float64x2_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_high_f64_f32
|
|
#define vcvt_high_f64_f32(a) simde_vcvt_high_f64_f32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float32_t
|
|
simde_vcvtxd_f32_f64(simde_float64_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvtxd_f32_f64(a);
|
|
#else
|
|
return HEDLEY_STATIC_CAST(simde_float32_t, a);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtxd_f32_f64
|
|
#define vcvtxd_f32_f64(a) simde_vcvtxd_f32_f64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float32x2_t
|
|
simde_vcvtx_f32_f64(simde_float64x2_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvtx_f32_f64(a);
|
|
#else
|
|
simde_float64x2_private a_ = simde_float64x2_to_private(a);
|
|
simde_float32x2_private r_;
|
|
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_vcvtxd_f32_f64(a_.values[i]);
|
|
}
|
|
|
|
return simde_float32x2_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtx_f32_f64
|
|
#define vcvtx_f32_f64(a) simde_vcvtx_f32_f64(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float32x4_t
|
|
simde_vcvtx_high_f32_f64(simde_float32x2_t r, simde_float64x2_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
|
|
return vcvtx_high_f32_f64(r, a);
|
|
#else
|
|
simde_float64x2_private a_ = simde_float64x2_to_private(a);
|
|
simde_float32x2_private r_ = simde_float32x2_to_private(r);
|
|
simde_float32x4_private ret;
|
|
|
|
size_t half_pos = (sizeof(ret.values) / sizeof(ret.values[0]) / 2);
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < half_pos; i++) {
|
|
ret.values[i] = r_.values[i];
|
|
}
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = half_pos; i < (sizeof(ret.values) / sizeof(ret.values[0])) ; i++) {
|
|
ret.values[i] = simde_vcvtxd_f32_f64(a_.values[i-half_pos]);
|
|
}
|
|
|
|
return simde_float32x4_from_private(ret);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtx_high_f32_f64
|
|
#define vcvtx_high_f32_f64(r, a) simde_vcvtx_high_f32_f64((r), (a))
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_bfloat16x4_t
|
|
simde_vcvt_bf16_f32(simde_float32x4_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_BF16)
|
|
return vcvt_bf16_f32(a);
|
|
#else
|
|
simde_float32x4_private a_ = simde_float32x4_to_private(a);
|
|
simde_bfloat16x4_private r_;
|
|
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_bfloat16_from_float32(a_.values[i]);
|
|
}
|
|
|
|
return simde_bfloat16x4_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_bf16_f32
|
|
#define vcvt_bf16_f32(a) simde_vcvt_bf16_f32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float32x4_t
|
|
simde_vcvt_f32_bf16(simde_bfloat16x4_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_BF16)
|
|
return vcvt_f32_bf16(a);
|
|
#else
|
|
simde_bfloat16x4_private a_ = simde_bfloat16x4_to_private(a);
|
|
simde_float32x4_private r_;
|
|
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_bfloat16_to_float32(a_.values[i]);
|
|
}
|
|
|
|
return simde_float32x4_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvt_f32_bf16
|
|
#define vcvt_f32_bf16(a) simde_vcvt_f32_bf16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float32_t
|
|
simde_vcvtah_f32_bf16(simde_bfloat16_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_BF16)
|
|
return vcvtah_f32_bf16(a);
|
|
#else
|
|
return simde_bfloat16_to_float32(a);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtah_f32_bf16
|
|
#define vcvtah_f32_bf16(a) simde_vcvtah_f32_bf16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_bfloat16_t
|
|
simde_vcvth_bf16_f32(float a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_BF16)
|
|
return vcvth_bf16_f32(a);
|
|
#else
|
|
return simde_bfloat16_from_float32(a);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvth_bf16_f32
|
|
#define vcvth_bf16_f32(a) simde_vcvth_bf16_f32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float32x4_t
|
|
simde_vcvtq_low_f32_bf16(simde_bfloat16x8_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_BF16)
|
|
return vcvtq_low_f32_bf16(a);
|
|
#else
|
|
simde_bfloat16x8_private a_ = simde_bfloat16x8_to_private(a);
|
|
simde_float32x4_private r_;
|
|
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_bfloat16_to_float32(a_.values[i]);
|
|
}
|
|
|
|
return simde_float32x4_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtq_low_f32_bf16
|
|
#define vcvtq_low_f32_bf16(a) simde_vcvtq_low_f32_bf16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_float32x4_t
|
|
simde_vcvtq_high_f32_bf16(simde_bfloat16x8_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_BF16)
|
|
return vcvtq_high_f32_bf16(a);
|
|
#else
|
|
simde_bfloat16x8_private a_ = simde_bfloat16x8_to_private(a);
|
|
simde_float32x4_private r_;
|
|
|
|
size_t rsize = (sizeof(r_.values) / sizeof(r_.values[0]));
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(r_.values) / sizeof(r_.values[0])) ; i++) {
|
|
r_.values[i] = simde_bfloat16_to_float32(a_.values[i + rsize]);
|
|
}
|
|
|
|
return simde_float32x4_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtq_high_f32_bf16
|
|
#define vcvtq_high_f32_bf16(a) simde_vcvtq_high_f32_bf16(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_bfloat16x8_t
|
|
simde_vcvtq_low_bf16_f32(simde_float32x4_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_BF16)
|
|
return vcvtq_low_bf16_f32(a);
|
|
#else
|
|
simde_float32x4_private a_ = simde_float32x4_to_private(a);
|
|
simde_bfloat16x8_private r_;
|
|
|
|
size_t asize = (sizeof(a_.values) / sizeof(a_.values[0]));
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < asize; i++) {
|
|
r_.values[i] = simde_bfloat16_from_float32(a_.values[i]);
|
|
r_.values[i + asize] = SIMDE_BFLOAT16_VALUE(0.0);
|
|
}
|
|
|
|
return simde_bfloat16x8_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtq_low_bf16_f32
|
|
#define vcvtq_low_bf16_f32(a) simde_vcvtq_low_bf16_f32(a)
|
|
#endif
|
|
|
|
SIMDE_FUNCTION_ATTRIBUTES
|
|
simde_bfloat16x8_t
|
|
simde_vcvtq_high_bf16_f32(simde_bfloat16x8_t inactive, simde_float32x4_t a) {
|
|
#if defined(SIMDE_ARM_NEON_A32V8_NATIVE) && defined(SIMDE_ARM_NEON_BF16)
|
|
return vcvtq_high_bf16_f32(inactive, a);
|
|
#else
|
|
simde_bfloat16x8_private inactive_ = simde_bfloat16x8_to_private(inactive);
|
|
simde_float32x4_private a_ = simde_float32x4_to_private(a);
|
|
simde_bfloat16x8_private r_;
|
|
|
|
size_t asize = (sizeof(a_.values) / sizeof(a_.values[0]));
|
|
SIMDE_VECTORIZE
|
|
for (size_t i = 0 ; i < (sizeof(a_.values) / sizeof(a_.values[0])) ; i++) {
|
|
r_.values[i] = inactive_.values[i];
|
|
r_.values[i + asize] = simde_bfloat16_from_float32(a_.values[i]);
|
|
}
|
|
return simde_bfloat16x8_from_private(r_);
|
|
#endif
|
|
}
|
|
#if defined(SIMDE_ARM_NEON_A32V8_ENABLE_NATIVE_ALIASES)
|
|
#undef vcvtq_high_bf16_f32
|
|
#define vcvtq_high_bf16_f32(inactive, a) simde_vcvtq_high_bf16_f32((inactive), (a))
|
|
#endif
|
|
|
|
SIMDE_END_DECLS_
|
|
HEDLEY_DIAGNOSTIC_POP
|
|
|
|
#endif /* SIMDE_ARM_NEON_CVT_H */
|