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

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

using	space_type = ValueSpace

using	units_type = Unit

using	convention_type = Convention

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 Types inherited from sequoia::maths::coordinates_base< ConvexSpace, Basis, Origin, Validator, DisplacementCoordinates >
using	convex_space_type = ConvexSpace

using	basis_type = Basis

using	validator_type = Validator

using	origin_type = Origin

using	set_type = ConvexSpace::set_type

using	free_module_type = free_module_type_of_t< ConvexSpace >

using	commutative_ring_type = commutative_ring_type_of_t< ConvexSpace >

using	value_type = commutative_ring_type

using	displacement_coordinates_type = DisplacementCoordinates

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 =delete

constexpr physical_value	operator+ () const

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

constexpr physical_value	operator- () const noexcept(has_identity_validator)

template<class LoweredValueSpace , class OtherUnit > requires std::same_as<to_base_space_t<ValueSpace>, to_base_space_t<LoweredValueSpace>>
constexpr	operator physical_value< LoweredValueSpace, OtherUnit, convention_type, 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)

Public Member Functions inherited from sequoia::maths::coordinates_base< ConvexSpace, Basis, Origin, Validator, DisplacementCoordinates >
constexpr	coordinates_base (std::span< const value_type, D > vals) noexcept(has_identity_validator)

template<class... Ts> requires (D > 1) && (sizeof...(Ts) == D) && (std::convertible_to<Ts, value_type> && ...)
constexpr	coordinates_base (Ts... ts) noexcept(has_identity_validator)

template<class T > requires (D == 1) && (std::convertible_to<T, value_type>)
constexpr	coordinates_base (T val) noexcept(has_identity_validator)

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)

template<class Self > requires has_distinguished_origin
constexpr Self &	*operator=** (this Self &self, value_type u) noexcept(has_identity_validator)

template<class Self > requires has_distinguished_origin
constexpr Self &	operator/= (this Self &self, value_type u)

constexpr const validator_type &	validator () const noexcept

constexpr std::span< const value_type, D >	values () const noexcept

constexpr std::span< value_type, D >	values () noexcept

constexpr const value_type &	value () const noexcept

constexpr value_type &	value () noexcept

constexpr	operator bool () const noexcept
	This is explicit since otherwise, given two vectors a,b, a/b is well-formed due to implicit boolean conversion.

constexpr value_type	operator[] (std::size_t i) const

constexpr value_type &	operator[] (std::size_t i)

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 RHSConvention , class RHSOrigin , class RHSValidator >
static constexpr bool	is_composable_with

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

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

Static Public Attributes inherited from sequoia::maths::coordinates_base< ConvexSpace, Basis, Origin, Validator, DisplacementCoordinates >
static constexpr bool	has_distinguished_origin {std::is_same_v<Origin, distinguished_origin>}

static constexpr bool	has_identity_validator {is_identity_validator_v<Validator>}

static constexpr std::size_t	dimension {free_module_type::dimension}

static constexpr std::size_t	D {dimension}

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

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

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

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

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

Additional Inherited Members
Protected Member Functions inherited from sequoia::maths::coordinates_base< ConvexSpace, Basis, Origin, Validator, DisplacementCoordinates >
	coordinates_base (const coordinates_base &)=default

	coordinates_base (coordinates_base &&) noexcept=default

coordinates_base &	operator= (const coordinates_base &)=default

coordinates_base &	operator= (coordinates_base &&) noexcept=default

template<class Self , class Fn > requires std::invocable<Fn, value_type&, value_type>
constexpr void	apply_to_each_element (this Self &self, std::span< const value_type, D > rhs, Fn f)

template<class Self , class Fn > requires std::invocable<Fn, value_type&>
constexpr void	for_each_element (this Self &self, Fn f)

Member Data Documentation

◆ is_composable_with

template<convex_space ValueSpace, physical_unit Unit, class Convention = canonical_convention<free_module_type_of_t<ValueSpace>::dimension>, class Origin = to_origin_type_t<ValueSpace, Unit>, validator_for< ValueSpace > Validator = typename Unit::validator_type>

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

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

staticconstexpr

Initial value:

{
          std::common_with<convention_type, RHSConvention>
      && (is_intrinsically_absolute || vector_space<space_type>)
      && (physical_value<RHSValueSpace, RHSUnit, RHSConvention, RHSOrigin, RHSValidator>::is_intrinsically_absolute || vector_space<RHSValueSpace>)
    }

◆ is_divisible_with

template<convex_space ValueSpace, physical_unit Unit, class Convention = canonical_convention<free_module_type_of_t<ValueSpace>::dimension>, class Origin = to_origin_type_t<ValueSpace, Unit>, validator_for< ValueSpace > Validator = typename Unit::validator_type>

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

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

staticconstexpr

Initial value:

{
         weak_field<ring_type>
      && weak_field<commutative_ring_type_of_t<RHSValueSpace>>
      && std::common_with<convention_type, RHSConvention>
      && is_composable_with<RHSValueSpace, RHSUnit, RHSConvention, RHSOrigin, RHSValidator>
      && (physical_value<RHSValueSpace, RHSUnit, RHSConvention, RHSOrigin, RHSValidator>::D == 1)
    }

◆ is_intrinsically_absolute

template<convex_space ValueSpace, physical_unit Unit, class Convention = canonical_convention<free_module_type_of_t<ValueSpace>::dimension>, class Origin = to_origin_type_t<ValueSpace, Unit>, validator_for< ValueSpace > Validator = typename Unit::validator_type>

constexpr bool sequoia::physics::physical_value< ValueSpace, Unit, Convention, 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, class Convention = canonical_convention<free_module_type_of_t<ValueSpace>::dimension>, class Origin = to_origin_type_t<ValueSpace, Unit>, validator_for< ValueSpace > Validator = typename Unit::validator_type>

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

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

staticconstexpr

Initial value:

{
         std::common_with<convention_type, RHSConvention>
      && is_composable_with<RHSValueSpace, RHSUnit, RHSConvention, RHSOrigin, RHSValidator>
      && ((D == 1) || (physical_value<RHSValueSpace, RHSUnit, RHSConvention, 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

Additional Inherited Members

Member Data Documentation

◆ is_composable_with

◆ is_divisible_with

◆ is_intrinsically_absolute

◆ is_multipicable_with