native/native_8math_8ccm_source.html

// SPDX-License-Identifier: BSD-2-Clause OR Apache-2.0

module;

#include "native/isa_import.h"

import native.simd;

#include <native/simd/math/exp.h>

#include <native/simd/math/bits.h>

#if NATIVE_HOST_X86

#include "native/exp_policies.h"

#endif

export module native.math;

export import native.simd;

// SPDX-FileCopyrightText: 2026 Edward Kmett <ekmett@gmail.com>

// SPDX-License-Identifier: BSD-2-Clause OR Apache-2.0

// Included in the hub purview after the separately owned wide module is imported.

#if NATIVE_HOST_X86

export namespace native {

#define NATIVE_EMIT_WIDE_EXP(i,name) \

  NATIVE_TARGET_PUSH(name) \

  template<bool Flush=false,unsigned Degree=6,std::size_t L,std::size_t N,isa<> Arch> \

    requires (Degree >= 1 && Degree <= 7) && (detail::exp_target<Arch> == i) && \

      requires(std::array<simd<float,L,Arch>,N> const & x) { ::native::exp<Flush,Degree>(x); } \

  native_nodiscard native_inline constexpr wide<simd<float,L,Arch>,N> \

  exp(wide<simd<float,L,Arch>,N> const & input) \

      noexcept(noexcept(wide<simd<float,L,Arch>,N>{::native::exp<Flush,Degree>(input.registers)})) { \

    return wide<simd<float,L,Arch>,N>{::native::exp<Flush,Degree>(input.registers)}; \

  } \

  NATIVE_TARGET_POP()

  NATIVE_EXP_TARGETS(NATIVE_EMIT_WIDE_EXP)

#undef NATIVE_EMIT_WIDE_EXP

}

#endif

// SPDX-License-Identifier: BSD-2-Clause OR Apache-2.0

export namespace math {

  using ::native::exp_width;

  using ::native::exp2_width;

  using ::native::expm1_width;

  using ::native::damping_gain_width;

  using ::native::log_width;

  using ::native::log2_width;

  using ::native::log1p_width;

  using ::native::tanh_width;

  using ::native::atan2_width;

  using ::native::sincos_width;

  using ::native::sin_width;

  using ::native::cos_width;

  using ::math::horner;

  using ::math::exp;

  using ::math::exp2;

  using ::math::expm1;

  using ::math::damping_gain;

  using ::math::log;

  using ::math::log2;

  using ::math::log1p;

  using ::math::tanh;

  using ::math::atan2;

  using ::math::sin;

  using ::math::cos;

  using ::math::sincos;

  using ::math::flush_to_zero;

  using ::math::abs;

  using ::math::sqrt;

  using ::math::floor;

  using ::math::ceil;

  using ::math::trunc;

  using ::math::round_even;

}

export namespace wide {

  using ::wide::horner;

  using ::wide::constant_like;

  using ::wide::add;

  using ::wide::sub;

  using ::wide::negate;

  using ::wide::mul;

  using ::wide::div;

  using ::wide::bit_and;

  using ::wide::bit_or;

  using ::wide::bit_xor;

  using ::wide::bit_not;

  using ::wide::cmp_eq;

  using ::wide::cmp_ne;

  using ::wide::cmp_lt;

  using ::wide::cmp_le;

  using ::wide::cmp_gt;

  using ::wide::cmp_ge;

  using ::wide::mask_not;

  using ::wide::min;

  using ::wide::max;

  using ::wide::abs;

  using ::wide::sqrt;

  using ::wide::floor;

  using ::wide::ceil;

  using ::wide::trunc;

  using ::wide::round_even;

  using ::wide::fma;

  using ::wide::select;

  using ::wide::scaleb;

  using ::wide::masked_scaleb;

  using ::wide::masked_scaleb_zero;

  using ::wide::bits;

  using ::wide::from_bits;

  using ::wide::mask_bits;

  using ::wide::left;

  using ::wide::right;

  using ::wide::exp;

  using ::wide::exp2;

  using ::wide::expm1;

  using ::wide::damping_gain;

  using ::wide::log;

  using ::wide::log2;

  using ::wide::log1p;

  using ::wide::tanh;

  using ::wide::atan2;

  using ::wide::sin;

  using ::wide::cos;

  using ::wide::sincos;

  using ::wide::flush_to_zero;

}


export namespace native {

  using ::native::exp_width;

  using ::native::exp2_width;

  using ::native::expm1_width;

  using ::native::damping_gain_width;

  using ::native::log_width;

  using ::native::log2_width;

  using ::native::log1p_width;

  using ::native::tanh_width;

  using ::native::atan2_width;

  using ::native::sincos_width;

  using ::native::sin_width;

  using ::native::cos_width;

  using ::native::sin;

  using ::native::cos;

  using ::native::sincos;

  using ::native::exp;

  using ::native::exp2;

  using ::native::expm1;

  using ::native::damping_gain;

  using ::native::log;

  using ::native::log2;

  using ::native::log1p;

  using ::native::tanh;

  using ::native::atan2;

  namespace math {

    using ::native::exp_width;

    using ::native::exp2_width;

    using ::native::expm1_width;

    using ::native::damping_gain_width;

    using ::native::log_width;

    using ::native::log2_width;

    using ::native::log1p_width;

    using ::native::tanh_width;

    using ::native::atan2_width;

    using ::native::sincos_width;

    using ::native::sin_width;

    using ::native::cos_width;

    using ::native::abs;

    using ::native::cos;

    using ::native::exp;

    using ::native::exp2;

    using ::native::expm1;

    using ::native::damping_gain;

    using ::native::fma;

    using ::native::log;

    using ::native::log2;

    using ::native::log1p;

    using ::native::sin;

    using ::native::sincos;

    using ::native::sqrt;

    using ::native::floor;

    using ::native::ceil;

    using ::native::trunc;

    using ::native::tanh;

    using ::native::atan2;

  }

}

native::atan2
constexpr simd< float, L, Arch > atan2(simd< float, L, Arch > y, simd< float, L, Arch > x) noexcept
Definition exp_body.h:91

native::ceil
constexpr simd< float, N, Arch > ceil(simd< float, N, Arch > x) noexcept
Definition simd_family.h:5158

native::exp2
constexpr simd< float, L, Arch > exp2(simd< float, L, Arch > input) noexcept
Definition exp_body.h:65

native::abs
constexpr auto abs(simd< float, N, Arch > a) noexcept
Definition simd_family.h:4475

native::trunc
constexpr simd< float, N, Arch > trunc(simd< float, N, Arch > x) noexcept
Definition simd_family.h:5174

native::exp
constexpr simd< float, L, Arch > exp(simd< float, L, Arch > input) noexcept
Evaluate the binary32 range-reduced exponential approximation. Degree selects a polynomial from one t...
Definition exp_body.h:109

native::floor
constexpr simd< float, N, Arch > floor(simd< float, N, Arch > x) noexcept
Definition simd_family.h:5142

native::sincos
constexpr auto sincos(wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &x) { detail::wide_generic_detail::adl_sincos(x);}) return noexcept(detail::wide_generic_detail::adl_sincos(std::declval< std::array< R, N > const & >())) &&std::is_nothrow_move_constructible_v< std::array< R, N > >;else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||(noexcept(detail::wide_generic_detail::adl_sincos(std::declval< R const & >())) &&noexcept(std::declval< R & >()=std::declval< decltype(detail::wide_generic_detail::adl_sincos(std::declval< R const & >())) & >().first) &&noexcept(std::declval< R & >()=std::declval< decltype(detail::wide_generic_detail::adl_sincos(std::declval< R const & >())) & >().second)));}())
Definition wide.h:1263

native::cos
constexpr wide< R, N > cos(wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_cos(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_cos(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_cos(std::declval< R const & >())));}())
Definition wide.h:1024

native::tanh
constexpr wide< R, N > tanh(wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_tanh(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_tanh(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_tanh(std::declval< R const & >())));}())
Definition wide.h:1193

native::sin
constexpr wide< R, N > sin(wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_sin(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_sin(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_sin(std::declval< R const & >())));}())
Definition wide.h:1003

native::log
constexpr wide< R, N > log(wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_log(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_log(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_log(std::declval< R const & >())));}())
Definition wide.h:1130

native::log2
constexpr wide< R, N > log2(wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_log2(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_log2(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_log2(std::declval< R const & >())));}())
Definition wide.h:1151

native::damping_gain
constexpr wide< R, N > damping_gain(wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_damping_gain(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_damping_gain(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_damping_gain(std::declval< R const & >())));}())
Definition wide.h:1109

native::expm1
constexpr wide< R, N > expm1(wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_expm1(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_expm1(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_expm1(std::declval< R const & >())));}())
Definition wide.h:1088

native::log1p
constexpr wide< R, N > log1p(wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_log1p(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_log1p(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_log1p(std::declval< R const & >())));}())
Definition wide.h:1172

native.math

native.simd

native
Architecture-tagged vectors, register packs and supporting value types. Native arithmetic follows its...
Definition native.arm.aes.ccm:10

native::sin_width
constexpr std::size_t sin_width
Suggested sine register count, matching the paired trigonometric kernel.
Definition wide_math.h:86

native::sqrt
constexpr simd< T, N, A > sqrt(simd< T, N, A > v) noexcept
Compute correctly rounded square roots; negative finite lanes produce NaN.
Definition simd_family.h:6577

native::log_width
constexpr std::size_t log_width
Conservative independent register count for the logarithm kernel.
Definition wide_math.h:59

native::cos_width
constexpr std::size_t cos_width
Suggested cosine register count, matching the paired trigonometric kernel.
Definition wide_math.h:90

native::fma
constexpr simd< fp16, 32, Arch > fma(simd< fp16, 32, Arch > a, simd< fp16, 32, Arch > b, simd< fp16, 32, Arch > c) noexcept
Definition native.simd.ccm:406

native::log1p_width
constexpr std::size_t log1p_width
Conservative independent register count for cancellation-safe log1p.
Definition wide_math.h:67

native::damping_gain_width
constexpr std::size_t damping_gain_width
Suggested damping_gain register count, matching its expm1 graph.
Definition wide_math.h:55

native::atan2_width
constexpr std::size_t atan2_width
Definition wide_math.h:76

native::log2_width
constexpr std::size_t log2_width
Suggested log2 register count, matching the logarithm recommendation.
Definition wide_math.h:63

native::exp2_width
constexpr std::size_t exp2_width
Recommended exp2 register count; its shorter reduction favors small batches.
Definition wide_math.h:47

native::expm1_width
constexpr std::size_t expm1_width
Conservative independent register count for cancellation-safe expm1.
Definition wide_math.h:51

native::tanh_width
constexpr std::size_t tanh_width
Conservative independent register count for tanh's table and polynomial.
Definition wide_math.h:71

native::exp_width
constexpr std::size_t exp_width
Definition wide_math.h:38

native::sincos_width
constexpr std::size_t sincos_width
Recommended independent register count for paired sine and cosine.
Definition wide_math.h:80