Inheritance diagram for sequoia::physics::physical_value< ValueSpace, Unit, Basis, Origin, Validator >:

Public Types
using	coordinates_type = to_coordinates_base_type< ValueSpace, Unit, Basis, Origin, Validator >

using	space_type = ValueSpace

using	units_type = Unit

using	basis_type = Basis

using	origin_type = Origin

using	displacement_space_type = free_module_type_of_t< ValueSpace >

using	intrinsic_validator_type = Unit::validator_type

using	validator_type = Validator

using	ring_type = commutative_ring_type_of_t< ValueSpace >

using	value_type = ring_type

using	displacement_type = coordinates_type::displacement_coordinates_type

Public Member Functions
constexpr	physical_value (value_type val, units_type)

constexpr	physical_value (std::span< const value_type, D > val, units_type)

constexpr physical_value	operator- () const noexcept(has_identity_validator)

template<convex_space OtherValueSpace, basis_for< free_module_type_of_t< OtherValueSpace > > OtherBasis> requires is_intrinsically_absolute
&&std::is_base_of_v< ValueSpace, OtherValueSpace > &&consistent_bases_v< basis_type, OtherBasis > constexpr physical_value &	operator+= (const physical_value< OtherValueSpace, Unit, OtherBasis, Origin, Validator > &other) noexcept(has_identity_validator)

template<convex_space OtherValueSpace, basis_for< free_module_type_of_t< OtherValueSpace > > OtherBasis> requires is_intrinsically_absolute
&&std::is_base_of_v< ValueSpace, OtherValueSpace > &&consistent_bases_v< basis_type, OtherBasis > constexpr physical_value &	operator-= (const physical_value< OtherValueSpace, Unit, OtherBasis, Origin, Validator > &other) noexcept(has_identity_validator)

template<class LoweredValueSpace , class OtherUnit , basis_for< free_module_type_of_t< LoweredValueSpace > > OtherBasis> requires std::same_as<to_base_space_t<space_type>, to_base_space_t<LoweredValueSpace>> && consistent_bases_v<basis_type, OtherBasis>
constexpr	operator physical_value< LoweredValueSpace, OtherUnit, OtherBasis, origin_type, validator_type > () const noexcept

template<class Self >
constexpr Self &	operator+= (this Self &self, const displacement_coordinates_type &v) noexcept(has_identity_validator)

template<class Self > requires has_distinguished_origin
&&!std ::is_same_v< coordinates_base, displacement_coordinates_type > constexpr Self &	operator+= (this Self &self, const coordinates_base &v) noexcept(has_identity_validator)

template<class Self >
constexpr Self &	operator-= (this Self &self, const displacement_coordinates_type &v) noexcept(has_identity_validator)

Static Public Attributes
static constexpr std::size_t	dimension {displacement_space_type::dimension}

static constexpr std::size_t	D {dimension}

static constexpr bool	is_intrinsically_absolute

static constexpr bool	is_effectively_absolute {is_intrinsically_absolute && std::is_same_v<Validator, intrinsic_validator_type>}

static constexpr bool	has_identity_validator {coordinates_type::has_identity_validator}

template<convex_space RHSValueSpace, class RHSUnit , class RHSBasis , class RHSOrigin , class RHSValidator >
static constexpr bool	is_composable_with

template<convex_space RHSValueSpace, class RHSUnit , class RHSBasis , class RHSOrigin , class RHSValidator >
static constexpr bool	is_multipicable_with

template<convex_space RHSValueSpace, class RHSUnit , class RHSBasis , class RHSOrigin , class RHSValidator >
static constexpr bool	is_divisible_with

Friends
template<convex_space OtherValueSpace, basis_for< free_module_type_of_t< OtherValueSpace > > OtherBasis> requires (!std::is_same_v<ValueSpace, OtherValueSpace>) && have_compatible_base_spaces_v<ValueSpace, OtherValueSpace> && consistent_bases_v<basis_type, OtherBasis>
constexpr auto	operator+ (const physical_value &lhs, const physical_value< OtherValueSpace, Unit, OtherBasis, Origin, Validator > &rhs)

template<class OtherValueSpace , basis_for< free_module_type_of_t< OtherValueSpace > > OtherBasis> requires (!std::is_same_v<OtherValueSpace, displacement_space_type>) && (std::is_same_v<ValueSpace, OtherValueSpace> \|\| have_compatible_base_spaces_v<ValueSpace, OtherValueSpace>) && consistent_bases_v<basis_type, OtherBasis>
constexpr auto	operator- (const physical_value &lhs, const physical_value< OtherValueSpace, Unit, OtherBasis, Origin, Validator > &rhs) noexcept(has_identity_validator)

template<convex_space RHSValueSpace, physical_unit RHSUnit, basis_for< free_module_type_of_t< RHSValueSpace > > RHSBasis, class RHSOrigin , class RHSValidator > requires is_multipicable_with<RHSValueSpace, RHSUnit, RHSBasis, RHSOrigin, RHSValidator>
constexpr auto	operator* (const physical_value &lhs, const physical_value< RHSValueSpace, RHSUnit, RHSBasis, RHSOrigin, RHSValidator > &rhs)

template<convex_space RHSValueSpace, class RHSUnit , basis_for< free_module_type_of_t< RHSValueSpace > > RHSBasis, class RHSOrigin , class RHSValidator > requires is_divisible_with<RHSValueSpace, RHSUnit, RHSBasis, RHSOrigin, RHSValidator>
constexpr auto	operator/ (const physical_value &lhs, const physical_value< RHSValueSpace, RHSUnit, RHSBasis, RHSOrigin, RHSValidator > &rhs)

constexpr auto	operator/ (value_type value, const physical_value &rhs)

Member Data Documentation

◆ is_composable_with

template<convex_space ValueSpace, physical_unit Unit, basis_for< free_module_type_of_t< ValueSpace > > Basis = canonical_right_handed_basis<free_module_type_of_t<ValueSpace>>, class Origin = to_origin_type_t<ValueSpace, Unit>, validator_for< ValueSpace > Validator = typename Unit::validator_type>

template<convex_space RHSValueSpace, class RHSUnit , class RHSBasis , class RHSOrigin , class RHSValidator >

constexpr bool sequoia::physics::physical_value< ValueSpace, Unit, Basis, Origin, Validator >::is_composable_with

staticconstexpr

Initial value:

{
         consistent_bases_v<basis_type, RHSBasis>
      && (is_intrinsically_absolute || vector_space<space_type>)
      && (physical_value<RHSValueSpace, RHSUnit, RHSBasis, RHSOrigin, RHSValidator>::is_intrinsically_absolute || vector_space<RHSValueSpace>)
    }

◆ is_divisible_with

template<convex_space ValueSpace, physical_unit Unit, basis_for< free_module_type_of_t< ValueSpace > > Basis = canonical_right_handed_basis<free_module_type_of_t<ValueSpace>>, class Origin = to_origin_type_t<ValueSpace, Unit>, validator_for< ValueSpace > Validator = typename Unit::validator_type>

template<convex_space RHSValueSpace, class RHSUnit , class RHSBasis , class RHSOrigin , class RHSValidator >

constexpr bool sequoia::physics::physical_value< ValueSpace, Unit, Basis, Origin, Validator >::is_divisible_with

staticconstexpr

Initial value:

{
         weak_field<ring_type>
      && weak_field<commutative_ring_type_of_t<RHSValueSpace>>
      && consistent_bases_v<basis_type, RHSBasis>
      && is_composable_with<RHSValueSpace, RHSUnit, RHSBasis, RHSOrigin, RHSValidator>
      && (physical_value<RHSValueSpace, RHSUnit, RHSBasis, RHSOrigin, RHSValidator>::D == 1)
    }

◆ is_intrinsically_absolute

template<convex_space ValueSpace, physical_unit Unit, basis_for< free_module_type_of_t< ValueSpace > > Basis = canonical_right_handed_basis<free_module_type_of_t<ValueSpace>>, class Origin = to_origin_type_t<ValueSpace, Unit>, validator_for< ValueSpace > Validator = typename Unit::validator_type>

constexpr bool sequoia::physics::physical_value< ValueSpace, Unit, Basis, Origin, Validator >::is_intrinsically_absolute

staticconstexpr

Initial value:

{
      (D == 1) && !affine_space<space_type> && defines_half_line_v<intrinsic_validator_type>
    }

◆ is_multipicable_with

template<convex_space ValueSpace, physical_unit Unit, basis_for< free_module_type_of_t< ValueSpace > > Basis = canonical_right_handed_basis<free_module_type_of_t<ValueSpace>>, class Origin = to_origin_type_t<ValueSpace, Unit>, validator_for< ValueSpace > Validator = typename Unit::validator_type>

template<convex_space RHSValueSpace, class RHSUnit , class RHSBasis , class RHSOrigin , class RHSValidator >

constexpr bool sequoia::physics::physical_value< ValueSpace, Unit, Basis, Origin, Validator >::is_multipicable_with

staticconstexpr

Initial value:

{
         consistent_bases_v<basis_type, RHSBasis>
      && is_composable_with<RHSValueSpace, RHSUnit, RHSBasis, RHSOrigin, RHSValidator>
      && ((D == 1) || (physical_value<RHSValueSpace, RHSUnit, RHSBasis, RHSOrigin, RHSValidator>::D == 1))
    }

The documentation for this class was generated from the following file:

C:/Users/olive/sequoia/Source/sequoia/Physics/PhysicalValues.hpp

Public Types

Public Member Functions

Static Public Attributes

Friends

Member Data Documentation

◆ is_composable_with

◆ is_divisible_with

◆ is_intrinsically_absolute

◆ is_multipicable_with