There are specializations of the atomic
class template for all cv-unqualified floating-point types.

For each such type *floating-point-type*,
the specialization atomic<*floating-point-type*>
provides additional atomic operations appropriate to floating-point types.

namespace std {
template<> struct atomic<*floating-point-type*> {
using value_type = *floating-point-type*;
using difference_type = value_type;
static constexpr bool is_always_lock_free = *implementation-defined*;
bool is_lock_free() const volatile noexcept;
bool is_lock_free() const noexcept;
constexpr atomic() noexcept;
constexpr atomic(*floating-point-type*) noexcept;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
void store(*floating-point-type*, memory_order = memory_order::seq_cst) volatile noexcept;
void store(*floating-point-type*, memory_order = memory_order::seq_cst) noexcept;
*floating-point-type* operator=(*floating-point-type*) volatile noexcept;
*floating-point-type* operator=(*floating-point-type*) noexcept;
*floating-point-type* load(memory_order = memory_order::seq_cst) volatile noexcept;
*floating-point-type* load(memory_order = memory_order::seq_cst) noexcept;
operator *floating-point-type*() volatile noexcept;
operator *floating-point-type*() noexcept;
*floating-point-type* exchange(*floating-point-type*,
memory_order = memory_order::seq_cst) volatile noexcept;
*floating-point-type* exchange(*floating-point-type*,
memory_order = memory_order::seq_cst) noexcept;
bool compare_exchange_weak(*floating-point-type*&, *floating-point-type*,
memory_order, memory_order) volatile noexcept;
bool compare_exchange_weak(*floating-point-type*&, *floating-point-type*,
memory_order, memory_order) noexcept;
bool compare_exchange_strong(*floating-point-type*&, *floating-point-type*,
memory_order, memory_order) volatile noexcept;
bool compare_exchange_strong(*floating-point-type*&, *floating-point-type*,
memory_order, memory_order) noexcept;
bool compare_exchange_weak(*floating-point-type*&, *floating-point-type*,
memory_order = memory_order::seq_cst) volatile noexcept;
bool compare_exchange_weak(*floating-point-type*&, *floating-point-type*,
memory_order = memory_order::seq_cst) noexcept;
bool compare_exchange_strong(*floating-point-type*&, *floating-point-type*,
memory_order = memory_order::seq_cst) volatile noexcept;
bool compare_exchange_strong(*floating-point-type*&, *floating-point-type*,
memory_order = memory_order::seq_cst) noexcept;
*floating-point-type* fetch_add(*floating-point-type*,
memory_order = memory_order::seq_cst) volatile noexcept;
*floating-point-type* fetch_add(*floating-point-type*,
memory_order = memory_order::seq_cst) noexcept;
*floating-point-type* fetch_sub(*floating-point-type*,
memory_order = memory_order::seq_cst) volatile noexcept;
*floating-point-type* fetch_sub(*floating-point-type*,
memory_order = memory_order::seq_cst) noexcept;
*floating-point-type* operator+=(*floating-point-type*) volatile noexcept;
*floating-point-type* operator+=(*floating-point-type*) noexcept;
*floating-point-type* operator-=(*floating-point-type*) volatile noexcept;
*floating-point-type* operator-=(*floating-point-type*) noexcept;
void wait(*floating-point-type*, memory_order = memory_order::seq_cst) const volatile noexcept;
void wait(*floating-point-type*, memory_order = memory_order::seq_cst) const noexcept;
void notify_one() volatile noexcept;
void notify_one() noexcept;
void notify_all() volatile noexcept;
void notify_all() noexcept;
};
}

`T fetch_`*key*(T operand, memory_order order = memory_order::seq_cst) volatile noexcept;
T fetch_*key*(T operand, memory_order order = memory_order::seq_cst) noexcept;

Memory is affected according to the value of order.

These operations are atomic read-modify-write operations ([intro.multithread]).

Atomic arithmetic operations on *floating-point-type*
should conform to the std::numeric_limits<*floating-point-type*>
traits associated with the floating-point type ([limits.syn]).

`T operator `*op*=(T operand) volatile noexcept;
T operator *op*=(T operand) noexcept;

Atomic arithmetic operations on *floating-point-type*
should conform to the std::numeric_limits<*floating-point-type*>
traits associated with the floating-point type ([limits.syn]).