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

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

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

*floating-point-type* fetch_*key*(*floating-point-type* operand,
memory_order order = memory_order::seq_cst) const noexcept;

Memory is affected according to the value of order.

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

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]).

*floating-point-type* operator *op*=(*floating-point-type* operand) const noexcept;