libMesh
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | Friends | List of all members
libMesh::TypeVector< T > Class Template Reference

This class defines a vector in LIBMESH_DIM dimensional space of type T. More...

#include <type_vector.h>

Inheritance diagram for libMesh::TypeVector< T >:
[legend]

Public Types

typedef T value_type
 Helper typedef for C++98 generic programming.
 
typedef unsigned int index_type
 Helper typedef for generic index programming.
 

Public Member Functions

 TypeVector ()
 Empty constructor.
 
template<typename T2 >
 TypeVector (const TypeVector< T2 > &p)
 Copy-constructor.
 
 TypeVector (const TypeVector &p)=default
 Copy-constructor for the trivial case.
 
 ~TypeVector ()=default
 Destructor.
 
template<typename T2 >
LIBMESH_DEVICE_INLINE void assign (const TypeVector< T2 > &)
 Assign to this vector without creating a temporary.
 
template<typename Scalar >
LIBMESH_DEVICE_INLINE std::enable_if< ScalarTraits< Scalar >::value, TypeVector & >::type operator= (const Scalar &libmesh_dbg_var(p))
 Assignment-from-scalar operator.
 
const T & operator() (const unsigned int i) const
 
LIBMESH_DEVICE_INLINE const T & slice (const unsigned int i) const
 
T & operator() (const unsigned int i)
 
LIBMESH_DEVICE_INLINE T & slice (const unsigned int i)
 
template<typename T2 >
TypeVector< typename CompareTypes< T, T2 >::supertype > operator+ (const TypeVector< T2 > &) const
 Add two vectors.
 
template<typename T2 >
const TypeVector< T > & operator+= (const TypeVector< T2 > &)
 Add to this vector.
 
template<typename T2 >
void add (const TypeVector< T2 > &)
 Add to this vector without creating a temporary.
 
template<typename T2 >
LIBMESH_DEVICE_INLINE void add_scaled (const TypeVector< T2 > &, const T &)
 Add a scaled value to this vector without creating a temporary.
 
template<typename T2 >
TypeVector< typename CompareTypes< T, T2 >::supertype > operator- (const TypeVector< T2 > &) const
 Subtract from this vector.
 
template<typename T2 >
const TypeVector< T > & operator-= (const TypeVector< T2 > &)
 Subtract from this vector.
 
template<typename T2 >
void subtract (const TypeVector< T2 > &)
 Subtract from this vector without creating a temporary.
 
template<typename T2 >
LIBMESH_DEVICE_INLINE void subtract_scaled (const TypeVector< T2 > &, const T &)
 Subtract a scaled value from this vector without creating a temporary.
 
TypeVector< T > operator- () const
 
template<typename Scalar >
std::enable_if< ScalarTraits< Scalar >::value, TypeVector< typenameCompareTypes< T, Scalar >::supertype > >::type operator* (const Scalar &) const
 Multiply this vector by a scalar value.
 
const TypeVector< T > & operator*= (const T &)
 Multiply this vector by a scalar value.
 
template<typename Scalar >
std::enable_if< ScalarTraits< Scalar >::value, TypeVector< typenameCompareTypes< T, Scalar >::supertype > >::type operator/ (const Scalar &) const
 Divide each entry of this vector by scalar value.
 
const TypeVector< T > & operator/= (const T &)
 Divide each entry of this vector by scalar value.
 
template<typename T2 >
CompareTypes< T, T2 >::supertype operator* (const TypeVector< T2 > &) const
 
template<typename T2 >
LIBMESH_DEVICE_INLINE CompareTypes< T, T2 >::supertype contract (const TypeVector< T2 > &) const
 
template<typename T2 >
TypeVector< typename CompareTypes< T, T2 >::supertype > cross (const TypeVector< T2 > &v) const
 
LIBMESH_DEVICE_INLINE TypeVector< T > unit () const
 
auto norm () const
 
auto norm_sq () const
 
LIBMESH_DEVICE_INLINE auto l1_norm () const
 
LIBMESH_DEVICE_INLINE bool is_zero () const
 
LIBMESH_DEVICE_INLINE void zero ()
 Set all entries of the vector to 0.
 
bool relative_fuzzy_equals (const TypeVector< T > &rhs, Real tol=TOLERANCE) const
 
bool absolute_fuzzy_equals (const TypeVector< T > &rhs, Real tol=TOLERANCE) const
 
LIBMESH_DEVICE_INLINE bool operator== (const TypeVector< T > &rhs) const
 
LIBMESH_DEVICE_INLINE bool operator!= (const TypeVector< T > &rhs) const
 
bool operator< (const TypeVector< T > &rhs) const
 
bool operator<= (const TypeVector< T > &rhs) const
 
bool operator> (const TypeVector< T > &rhs) const
 
bool operator>= (const TypeVector< T > &rhs) const
 
void print (std::ostream &os=libMesh::out) const
 Formatted print, by default to libMesh::out.
 
void write_unformatted (std::ostream &out_stream, const bool newline=true) const
 Unformatted print to the stream out.
 
template<typename Scalar1 , typename Scalar2 , typename Scalar3 >
LIBMESH_DEVICE_INLINE TypeVector (typename std::enable_if< ScalarTraits< Scalar1 >::value, const Scalar1 >::type &x, typename std::enable_if< ScalarTraits< Scalar2 >::value, const Scalar2 >::type &y, typename std::enable_if< ScalarTraits< Scalar3 >::value, const Scalar3 >::type &z)
 
template<typename Scalar >
LIBMESH_DEVICE_INLINE TypeVector (const Scalar &x, typename std::enable_if< ScalarTraits< Scalar >::value, const Scalar >::type *)
 
template<typename T2 >
LIBMESH_DEVICE_INLINE TypeVector (const TypeVector< T2 > &p)
 
template<typename T2 >
LIBMESH_DEVICE_INLINE TypeVector< typename CompareTypes< T, T2 >::supertype > operator+ (const TypeVector< T2 > &p) const
 
template<typename T2 >
LIBMESH_DEVICE_INLINE const TypeVector< T > & operator+= (const TypeVector< T2 > &p)
 
template<typename T2 >
LIBMESH_DEVICE_INLINE void add (const TypeVector< T2 > &p)
 
template<typename T2 >
LIBMESH_DEVICE_INLINE TypeVector< typename CompareTypes< T, T2 >::supertype > operator- (const TypeVector< T2 > &p) const
 
template<typename T2 >
LIBMESH_DEVICE_INLINE const TypeVector< T > & operator-= (const TypeVector< T2 > &p)
 
template<typename T2 >
LIBMESH_DEVICE_INLINE void subtract (const TypeVector< T2 > &p)
 
template<typename Scalar >
LIBMESH_DEVICE_INLINE std::enable_if< ScalarTraits< Scalar >::value, TypeVector< typenameCompareTypes< T, Scalar >::supertype > >::type operator* (const Scalar &factor) const
 
template<typename Scalar >
LIBMESH_DEVICE_INLINE std::enable_if< ScalarTraits< Scalar >::value, TypeVector< typenameCompareTypes< T, Scalar >::supertype > >::type operator/ (const Scalar &factor) const
 
template<typename T2 >
LIBMESH_DEVICE_INLINE CompareTypes< T, T2 >::supertype operator* (const TypeVector< T2 > &p) const
 
template<typename T2 >
LIBMESH_DEVICE_INLINE TypeVector< typename CompareTypes< T, T2 >::supertype > cross (const TypeVector< T2 > &p) const
 
auto norm () const
 
auto norm () const
 
auto norm () const
 
auto norm () const
 
auto l1_norm () const
 
bool operator< (const TypeVector< Complex > &rhs) const
 
bool operator<= (const TypeVector< Complex > &rhs) const
 
bool operator> (const TypeVector< Complex > &rhs) const
 
bool operator>= (const TypeVector< Complex > &rhs) const
 
auto l1_norm () const
 

Protected Member Functions

 TypeVector (const T &x, const T &y=0, const T &z=0)
 Constructor-from-T.
 
template<typename Scalar1 , typename Scalar2 , typename Scalar3 >
 TypeVector (typename std::enable_if< ScalarTraits< Scalar1 >::value, const Scalar1 >::type &x, typename std::enable_if< ScalarTraits< Scalar2 >::value, const Scalar2 >::type &y=0, typename std::enable_if< ScalarTraits< Scalar3 >::value, const Scalar3 >::type &z=0)
 Constructor-from-scalars.
 
template<typename Scalar >
 TypeVector (const Scalar &x, typename std::enable_if< ScalarTraits< Scalar >::value, const Scalar >::type *sfinae=nullptr)
 Constructor-from-scalar.
 

Protected Attributes

T _coords [LIBMESH_DIM]
 The coordinates of the TypeVector.
 

Friends

template<typename T2 >
class TypeVector
 
class TypeTensor< T >
 
std::ostream & operator<< (std::ostream &os, const TypeVector< T > &t)
 Formatted print as above but supports the syntax:
 

Detailed Description

template<typename T>
class libMesh::TypeVector< T >

This class defines a vector in LIBMESH_DIM dimensional space of type T.

T may either be Real or Complex. Instead use one of the derived types such as Point or Node.

Author
Benjamin S. Kirk
Date
2003

Definition at line 63 of file type_vector.h.

Member Typedef Documentation

◆ index_type

template<typename T >
typedef unsigned int libMesh::TypeVector< T >::index_type

Helper typedef for generic index programming.

Definition at line 123 of file type_vector.h.

◆ value_type

template<typename T >
typedef T libMesh::TypeVector< T >::value_type

Helper typedef for C++98 generic programming.

Definition at line 118 of file type_vector.h.

Constructor & Destructor Documentation

◆ TypeVector() [1/9]

template<typename T >
LIBMESH_DEVICE_INLINE libMesh::TypeVector< T >::TypeVector ( )

Empty constructor.

Gives the vector 0 in LIBMESH_DIM dimensions.

Definition at line 443 of file type_vector.h.

444{
445 _coords[0] = {};
446
447#if LIBMESH_DIM > 1
448 _coords[1] = {};
449#endif
450
451#if LIBMESH_DIM > 2
452 _coords[2] = {};
453#endif
454}
libMesh::TypeVector::_coords
T _coords[LIBMESH_DIM]
The coordinates of the TypeVector.
Definition type_vector.h:431

◆ TypeVector() [2/9]

template<typename T >
LIBMESH_DEVICE_INLINE libMesh::TypeVector< T >::TypeVector ( const T &  x,
const T &  y = 0,
const T &  z = 0 
)
protected

Constructor-from-T.

By default sets higher dimensional entries to 0.

Definition at line 460 of file type_vector.h.

463{
464 _coords[0] = x;
465
466#if LIBMESH_DIM > 1
467 _coords[1] = y;
468#else
469 libmesh_ignore(y);
470 libmesh_assert_equal_to (y, 0);
471#endif
472
473#if LIBMESH_DIM > 2
474 _coords[2] = z;
475#else
476 libmesh_ignore(z);
477 libmesh_assert_equal_to (z, 0);
478#endif
479}
libMesh::libmesh_ignore
void libmesh_ignore(const Args &...)
Definition libmesh_common.h:598

References libMesh::libmesh_ignore().

◆ TypeVector() [3/9]

template<typename T >
template<typename Scalar1 , typename Scalar2 , typename Scalar3 >
libMesh::TypeVector< T >::TypeVector ( typename std::enable_if< ScalarTraits< Scalar1 >::value, const Scalar1 >::type &  x,
typename std::enable_if< ScalarTraits< Scalar2 >::value, const Scalar2 >::type &  y = 0,
typename std::enable_if< ScalarTraits< Scalar3 >::value, const Scalar3 >::type &  z = 0 
)
protected

Constructor-from-scalars.

By default sets higher dimensional entries to 0.

◆ TypeVector() [4/9]

template<typename T >
template<typename Scalar >
libMesh::TypeVector< T >::TypeVector ( const Scalar &  x,
typename std::enable_if< ScalarTraits< Scalar >::value, const Scalar >::type *  sfinae = nullptr 
)
protected

Constructor-from-scalar.

Sets higher dimensional entries to 0. Necessary because for some reason the constructor-from-scalars alone is insufficient to let the compiler figure out TypeVector<Complex> v = 0;

◆ TypeVector() [5/9]

template<typename T >
template<typename T2 >
libMesh::TypeVector< T >::TypeVector ( const TypeVector< T2 > &  p)

Copy-constructor.

◆ TypeVector() [6/9]

template<typename T >
libMesh::TypeVector< T >::TypeVector ( const TypeVector< T > &  p)
default

Copy-constructor for the trivial case.

◆ ~TypeVector()

template<typename T >
libMesh::TypeVector< T >::~TypeVector ( )
default

Destructor.

◆ TypeVector() [7/9]

template<typename T >
template<typename Scalar1 , typename Scalar2 , typename Scalar3 >
LIBMESH_DEVICE_INLINE libMesh::TypeVector< T >::TypeVector ( typename std::enable_if< ScalarTraits< Scalar1 >::value, const Scalar1 >::type &  x,
typename std::enable_if< ScalarTraits< Scalar2 >::value, const Scalar2 >::type &  y,
typename std::enable_if< ScalarTraits< Scalar3 >::value, const Scalar3 >::type &  z 
)

Definition at line 485 of file type_vector.h.

494{
495 _coords[0] = x;
496
497#if LIBMESH_DIM > 1
498 _coords[1] = y;
499#else
500 libmesh_assert_equal_to (y, 0);
501#endif
502
503#if LIBMESH_DIM > 2
504 _coords[2] = z;
505#else
506 libmesh_assert_equal_to (z, 0);
507#endif
508}

◆ TypeVector() [8/9]

template<typename T >
template<typename Scalar >
LIBMESH_DEVICE_INLINE libMesh::TypeVector< T >::TypeVector ( const Scalar &  x,
typename std::enable_if< ScalarTraits< Scalar >::value, const Scalar >::type *   
)

Definition at line 515 of file type_vector.h.

519{
520 _coords[0] = x;
521
522#if LIBMESH_DIM > 1
523 _coords[1] = 0;
524#endif
525
526#if LIBMESH_DIM > 2
527 _coords[2] = 0;
528#endif
529}

◆ TypeVector() [9/9]

template<typename T >
template<typename T2 >
LIBMESH_DEVICE_INLINE libMesh::TypeVector< T >::TypeVector ( const TypeVector< T2 > &  p)

Definition at line 536 of file type_vector.h.

537{
538 // copy the nodes from vector p to me
539 for (unsigned int i=0; i<LIBMESH_DIM; i++)
540 _coords[i] = p._coords[i];
541}

References libMesh::TypeVector< T >::_coords.

Member Function Documentation

◆ absolute_fuzzy_equals()

template<typename T >
bool libMesh::TypeVector< T >::absolute_fuzzy_equals ( const TypeVector< T > &  rhs,
Real  tol = TOLERANCE 
) const
inline
Returns
true if two vectors are equal to within an absolute tolerance of tol.

Definition at line 1043 of file type_vector.h.

1044{
1045 return libMesh::absolute_fuzzy_equals(*this, rhs, tol);
1046}
libMesh::absolute_fuzzy_equals
bool absolute_fuzzy_equals(const T &var1, const T2 &var2, const Real tol=TOLERANCE *TOLERANCE)
Function to check whether two variables are equal within an absolute tolerance.
Definition fuzzy_equals.h:64

References libMesh::absolute_fuzzy_equals().

Referenced by libMesh::FEGenericBase< OutputType >::compute_periodic_constraints(), libMesh::LocationMap< T >::find(), libMesh::LineConstraint::is_parallel(), libMesh::PlaneConstraint::is_parallel(), libMesh::Pyramid::local_singular_node(), libMesh::LineConstraint::operator<(), libMesh::PlaneConstraint::operator<(), libMesh::LineConstraint::operator==(), libMesh::PlaneConstraint::operator==(), libMesh::PointConstraint::operator==(), libMesh::Elem::parent_bracketing_nodes(), VolumeTest::test_true_centroid_and_volume(), MeshTriangulationTest::testFoundCenters(), and VolumeTest::testQuad4TrueCentroid().

◆ add() [1/2]

template<typename T >
template<typename T2 >
void libMesh::TypeVector< T >::add ( const TypeVector< T2 > &  )

Add to this vector without creating a temporary.

Referenced by libMesh::FEMap::inverse_map(), libMesh::Polyhedron::Polyhedron(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::MeshTools::Modification::smooth(), and libMesh::Elem::vertex_average().

◆ add() [2/2]

template<typename T >
template<typename T2 >
LIBMESH_DEVICE_INLINE void libMesh::TypeVector< T >::add ( const TypeVector< T2 > &  p)

Definition at line 619 of file type_vector.h.

620{
621#if LIBMESH_DIM == 1
622 _coords[0] += p._coords[0];
623#endif
624
625#if LIBMESH_DIM == 2
626 _coords[0] += p._coords[0];
627 _coords[1] += p._coords[1];
628#endif
629
630#if LIBMESH_DIM == 3
631 _coords[0] += p._coords[0];
632 _coords[1] += p._coords[1];
633 _coords[2] += p._coords[2];
634#endif
635
636}

References libMesh::TypeVector< T >::_coords.

◆ add_scaled()

template<typename T >
template<typename T2 >
LIBMESH_DEVICE_INLINE void libMesh::TypeVector< T >::add_scaled ( const TypeVector< T2 > &  p,
const T &  factor 
)

Add a scaled value to this vector without creating a temporary.

Definition at line 643 of file type_vector.h.

644{
645#if LIBMESH_DIM == 1
646 _coords[0] += factor*p(0);
647#endif
648
649#if LIBMESH_DIM == 2
650 _coords[0] += factor*p(0);
651 _coords[1] += factor*p(1);
652#endif
653
654#if LIBMESH_DIM == 3
655 _coords[0] += factor*p(0);
656 _coords[1] += factor*p(1);
657 _coords[2] += factor*p(2);
658#endif
659
660}

Referenced by libMesh::MeshFunction::_gradient_on_elem(), libMesh::MeshRefinement::add_node(), libMesh::HPCoarsenTest::add_projection(), assemble_cd(), assemble_cd(), assemble_stokes(), InfFERadialTest::base_point(), libMesh::Elem::coarsen(), libMesh::FEMap::compute_edge_map(), libMesh::FEMap::compute_face_map(), libMesh::FEMap::compute_single_point_map(), compute_stresses(), SolidSystem::element_time_derivative(), libMesh::InfFEMap::inverse_map(), libMesh::FEMap::map(), libMesh::InfFEMap::map(), libMesh::FEMap::map_deriv(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::Elem::parent_bracketing_nodes(), libMesh::ExodusII_IO::read(), libMesh::DynaIO::read_mesh(), libMesh::HPCoarsenTest::select_refinement(), libMesh::MeshTools::Modification::smooth(), and TypeVectorTestBase< DerivedClass >::testVectorAddScaledBase().

◆ assign()

template<typename T >
template<typename T2 >
LIBMESH_DEVICE_INLINE void libMesh::TypeVector< T >::assign ( const TypeVector< T2 > &  p)

Assign to this vector without creating a temporary.

Definition at line 548 of file type_vector.h.

549{
550 for (unsigned int i=0; i<LIBMESH_DIM; i++)
551 _coords[i] = p._coords[i];
552}

References libMesh::TypeVector< T >::_coords.

Referenced by libMesh::build_gll_basis_1D().

◆ contract()

template<typename T >
template<typename T2 >
LIBMESH_DEVICE_INLINE CompareTypes< T, T2 >::supertype libMesh::TypeVector< T >::contract ( const TypeVector< T2 > &  p) const
Returns
The result of TypeVector::operator*().

Definition at line 889 of file type_vector.h.

890{
891 return (*this)*(p);
892}

◆ cross() [1/2]

template<typename T >
template<typename T2 >
LIBMESH_DEVICE_INLINE TypeVector< typename CompareTypes< T, T2 >::supertype > libMesh::TypeVector< T >::cross ( const TypeVector< T2 > &  p) const

Definition at line 900 of file type_vector.h.

901{
902 typedef typename CompareTypes<T, T2>::supertype TS;
903 libmesh_assert_equal_to (LIBMESH_DIM, 3);
904
905 // | i j k |
906 // |(*this)(0) (*this)(1) (*this)(2)|
907 // | p(0) p(1) p(2) |
908
909#if LIBMESH_DIM == 3
910 return TypeVector<TS>( _coords[1]*p._coords[2] - _coords[2]*p._coords[1],
911 -_coords[0]*p._coords[2] + _coords[2]*p._coords[0],
912 _coords[0]*p._coords[1] - _coords[1]*p._coords[0]);
913#else
914 libmesh_ignore(p);
915 return TypeVector<TS>(0);
916#endif
917}

References libMesh::TypeVector< T >::_coords, and libMesh::libmesh_ignore().

◆ cross() [2/2]

template<typename T >
template<typename T2 >
TypeVector< typename CompareTypes< T, T2 >::supertype > libMesh::TypeVector< T >::cross ( const TypeVector< T2 > &  v) const
Returns
The cross product of this vector with v.

Referenced by libMesh::TriangulatorInterface::Hole::areavec(), assemble_shell(), InfFERadialTest::base_point(), libMesh::circumcenter(), libMesh::InfFE< Dim, T_radial, T_map >::compute_face_functions(), libMesh::FEMap::compute_face_map(), libMesh::InfFE< Dim, T_radial, T_map >::compute_shape_functions(), libMesh::LineConstraint::contains_point(), ContainsPointTest::containsPointTri3Helper(), libMesh::Plane::create_from_three_points(), libMesh::VariationalSmootherConstraint::determine_constraint(), libMesh::Quad4::has_invertible_map(), libMesh::MeshTetInterface::improve_hull_integrity(), libMesh::LineConstraint::intersect(), libMesh::PlaneConstraint::intersect(), libMesh::InfFEMap::inverse_map(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), libMesh::Quad::quality(), libMesh::Face::quasicircumcenter(), libMesh::C0Polygon::retriangulate(), libMesh::C0Polyhedron::side_vertex_average_normal(), libMesh::Hex8::side_vertex_average_normal(), libMesh::Prism6::side_vertex_average_normal(), libMesh::Pyramid5::side_vertex_average_normal(), libMesh::Tet4::side_vertex_average_normal(), libMesh::C0Polygon::side_vertex_average_normal(), libMesh::Quad4::side_vertex_average_normal(), libMesh::Tri3::side_vertex_average_normal(), InfFERadialTest::testInfQuants_numericDeriv(), and libMesh::Quad4::volume().

◆ is_zero()

template<typename T >
LIBMESH_DEVICE_INLINE bool libMesh::TypeVector< T >::is_zero ( ) const
Returns
True if all values in the vector are zero

Definition at line 1016 of file type_vector.h.

1017{
1018 for (const auto & val : _coords)
1019 if (val != T(0))
1020 return false;
1021 return true;
1022}

◆ l1_norm() [1/3]

template<typename T >
LIBMESH_DEVICE_INLINE auto libMesh::TypeVector< T >::l1_norm ( ) const
Returns
The L1 norm of the vector

Definition at line 1031 of file type_vector.h.

1032{
1033 using std::abs;
1034 decltype(abs(T())) ret{};
1035 for (const auto i : make_range(libmesh_dim))
1036 ret += abs(_coords[i]);
1037
1038 return ret;
1039}
libMesh::libmesh_dim
static constexpr std::size_t libmesh_dim
Definition libmesh_common.h:747
libMesh::make_range
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
Definition int_range.h:176

References libMesh::libmesh_dim, and libMesh::make_range().

Referenced by libMesh::l1_norm().

◆ l1_norm() [2/3]

auto libMesh::TypeVector< bool >::l1_norm ( ) const

◆ l1_norm() [3/3]

auto libMesh::TypeVector< bool >::l1_norm ( ) const

Definition at line 203 of file type_vector.C.

204{
205 bool ret{};
206 for (const auto i : make_range(libmesh_dim))
207 ret += _coords[i];
208
209 return ret;
210}

References libMesh::libmesh_dim, and libMesh::make_range().

◆ norm() [1/5]

template<typename T >
LIBMESH_DEVICE_INLINE auto libMesh::TypeVector< T >::norm ( ) const
Returns
The magnitude of the vector, i.e. the square-root of the sum of the elements squared.

Definition at line 923 of file type_vector.h.

924{
925 using std::sqrt;
926
927 // The norm is not differentiable at the origin: the directional
928 // derivative there depends on the direction of approach, so there is no
929 // well-defined gradient, and computing sqrt(norm_sq()) directly would
930 // divide by zero in the derivative terms of AD types. We return a zero
931 // derivative in this case, consistent with the MetaPhysicL convention for
932 // other functions with the same kind of non-differentiable point (e.g.
933 // abs()).
934 if (this->is_zero())
935 return decltype(sqrt(this->norm_sq())){};
936
937 return sqrt(this->norm_sq());
938}
libMesh::TypeVector::norm_sq
auto norm_sq() const
Definition type_vector.h:954
libMesh::TypeVector::is_zero
LIBMESH_DEVICE_INLINE bool is_zero() const
Definition type_vector.h:1016

Referenced by libMesh::Sphere::above_surface(), libMesh::TriangulatorInterface::Hole::area(), assemble_shell(), assemble_shell(), InfFERadialTest::base_point(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::InfFE< Dim, T_radial, T_map >::compute_data(), libMesh::InfFE< Dim, T_radial, T_map >::compute_shape_functions(), libMesh::VariationalSmootherConstraint::constrain_node_to_plane(), libMesh::InfHex::contains_point(), libMesh::InfPrism::contains_point(), libMesh::Polyhedron::convex(), libMesh::VariationalSmootherConstraint::determine_constraint(), libMesh::Edge4::has_invertible_map(), libMesh::Quad4::has_invertible_map(), libMesh::PlaneConstraint::intersect(), libMesh::InfFEMap::inverse_map(), libMesh::FEMap::inverse_map(), libMesh::LineConstraint::LineConstraint(), MeshPerElemTest< elem_type >::meshes_equal_enough(), libMesh::Tet4::min_and_max_angle(), libMesh::Tri3::min_and_max_angle(), libMesh::Polyhedron::on_reference_element(), libMesh::Sphere::on_surface(), libMesh::PlaneConstraint::PlaneConstraint(), libMesh::Polyhedron::Polyhedron(), libMesh::Hex::quality(), libMesh::Quad::quality(), libMesh::Tri::quality(), libMesh::MeshTools::Modification::smooth(), libMesh::solid_angle(), libMesh::Sphere::surface_coords(), AllRBBTest::test_circle(), AllRBBTest::test_cylinder(), AllRBBTest::test_disk(), AllRBBTest::test_sphere(), InfFERadialTest::testInfQuants(), InfFERadialTest::testInfQuants_numericDeriv(), ADVectorValueTest::testNormAtZeroDerivative(), ADVectorValueTest::testNormDerivative(), MeshTriangulationTest::testTriangulatorRoundHole(), libMesh::Edge2::volume(), and libMesh::Edge4::volume().

◆ norm() [2/5]

auto libMesh::TypeVector< float >::norm ( ) const
inline

Definition at line 978 of file type_vector.h.

979{
980 using std::sqrt;
981 return sqrt(this->norm_sq());
982}

◆ norm() [3/5]

auto libMesh::TypeVector< double >::norm ( ) const
inline

Definition at line 986 of file type_vector.h.

987{
988 using std::sqrt;
989 return sqrt(this->norm_sq());
990}

◆ norm() [4/5]

auto libMesh::TypeVector< longdouble >::norm ( ) const
inline

Definition at line 994 of file type_vector.h.

995{
996 using std::sqrt;
997 return sqrt(this->norm_sq());
998}

◆ norm() [5/5]

auto libMesh::TypeVector< Real >::norm ( ) const
inline

Definition at line 1006 of file type_vector.h.

1007{
1008 using std::sqrt;
1009 return sqrt(this->norm_sq());
1010}

◆ norm_sq()

template<typename T >
LIBMESH_DEVICE_INLINE auto libMesh::TypeVector< T >::norm_sq ( ) const
Returns
The magnitude of the vector squared, i.e. the sum of the element magnitudes squared.

Definition at line 954 of file type_vector.h.

955{
956#if LIBMESH_DIM == 1
957 return (TensorTools::norm_sq(_coords[0]));
958#endif
959
960#if LIBMESH_DIM == 2
961 return (TensorTools::norm_sq(_coords[0]) +
962 TensorTools::norm_sq(_coords[1]));
963#endif
964
965#if LIBMESH_DIM == 3
966 return (TensorTools::norm_sq(_coords[0]) +
967 TensorTools::norm_sq(_coords[1]) +
968 TensorTools::norm_sq(_coords[2]));
969#endif
970}
libMesh::TensorTools::norm_sq
LIBMESH_DEVICE_INLINE auto norm_sq(const T &a)
Definition tensor_tools.h:104

References libMesh::TensorTools::norm_sq().

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::MeshTools::Modification::all_rbb(), libMesh::circumcenter(), libMesh::InfHex::contains_point(), libMesh::InfPrism::contains_point(), libMesh::InfQuad4::contains_point(), libMesh::ExactErrorEstimator::find_squared_element_error(), forcing(), libMesh::Edge3::has_invertible_map(), libMesh::LineConstraint::intersect(), libMesh::PointLocatorNanoflann::kdtree_distance(), main(), libMesh::TensorTools::norm_sq(), libMesh::TensorTools::norm_sq(), libMesh::Face::quasicircumcenter(), libMesh::HPCoarsenTest::select_refinement(), libMesh::C0Polyhedron::side_vertex_average_normal(), libMesh::C0Polygon::side_vertex_average_normal(), libMesh::Sphere::Sphere(), InfFERadialTest::testInfQuants(), InfFERadialTest::testInfQuants_numericDeriv(), MeshTriangulationTest::testTriangulatorRoundHole(), and libMesh::Edge3::volume().

◆ operator!=()

template<typename T >
LIBMESH_DEVICE_INLINE bool libMesh::TypeVector< T >::operator!= ( const TypeVector< T > &  rhs) const
Returns
!(*this == rhs)

Definition at line 1083 of file type_vector.h.

1084{
1085 return (!(*this == rhs));
1086}

◆ operator()() [1/2]

template<typename T >
LIBMESH_DEVICE_INLINE T & libMesh::TypeVector< T >::operator() ( const unsigned int  i)
Returns
A writable reference to the \( i^{th} \) entry of the vector.

Definition at line 569 of file type_vector.h.

570{
571 libmesh_assert_less (i, LIBMESH_DIM);
572
573 return _coords[i];
574}

◆ operator()() [2/2]

template<typename T >
LIBMESH_DEVICE_INLINE const T & libMesh::TypeVector< T >::operator() ( const unsigned int  i) const
Returns
A const reference to the \( i^{th} \) entry of the vector.

Definition at line 558 of file type_vector.h.

559{
560 libmesh_assert_less (i, LIBMESH_DIM);
561
562 return _coords[i];
563}

◆ operator*() [1/4]

template<typename T >
template<typename Scalar >
std::enable_if< ScalarTraits< Scalar >::value, TypeVector< typenameCompareTypes< T, Scalar >::supertype > >::type libMesh::TypeVector< T >::operator* ( const Scalar &  ) const

Multiply this vector by a scalar value.

Returns
A copy of the result, this vector is unchanged.

◆ operator*() [2/4]

template<typename T >
template<typename Scalar >
LIBMESH_DEVICE_INLINE std::enable_if< ScalarTraits< Scalar >::value, TypeVector< typenameCompareTypes< T, Scalar >::supertype > >::type libMesh::TypeVector< T >::operator* ( const Scalar &  factor) const

Definition at line 755 of file type_vector.h.

756{
757 typedef typename CompareTypes<T, Scalar>::supertype SuperType;
758
759#if LIBMESH_DIM == 1
760 return TypeVector<SuperType>(_coords[0]*factor);
761#endif
762
763#if LIBMESH_DIM == 2
764 return TypeVector<SuperType>(_coords[0]*factor,
765 _coords[1]*factor);
766#endif
767
768#if LIBMESH_DIM == 3
769 return TypeVector<SuperType>(_coords[0]*factor,
770 _coords[1]*factor,
771 _coords[2]*factor);
772#endif
773}

◆ operator*() [3/4]

template<typename T >
template<typename T2 >
CompareTypes< T, T2 >::supertype libMesh::TypeVector< T >::operator* ( const TypeVector< T2 > &  ) const
Returns
The dot-product of this vector with another vector.
Note
The complex conjugate is not taken in the complex-valued case.
The vectors may contain different numeric types.

◆ operator*() [4/4]

template<typename T >
template<typename T2 >
LIBMESH_DEVICE_INLINE CompareTypes< T, T2 >::supertype libMesh::TypeVector< T >::operator* ( const TypeVector< T2 > &  p) const

Definition at line 867 of file type_vector.h.

868{
869#if LIBMESH_DIM == 1
870 return _coords[0]*p._coords[0];
871#endif
872
873#if LIBMESH_DIM == 2
874 return (_coords[0]*p._coords[0] +
875 _coords[1]*p._coords[1]);
876#endif
877
878#if LIBMESH_DIM == 3
879 return (_coords[0]*p(0) +
880 _coords[1]*p(1) +
881 _coords[2]*p(2));
882#endif
883}

References libMesh::TypeVector< T >::_coords.

◆ operator*=()

template<typename T >
LIBMESH_DEVICE_INLINE const TypeVector< T > & libMesh::TypeVector< T >::operator*= ( const T &  factor)

Multiply this vector by a scalar value.

Returns
A reference to *this.

Definition at line 792 of file type_vector.h.

793{
794#if LIBMESH_DIM == 1
795 _coords[0] *= factor;
796#endif
797
798#if LIBMESH_DIM == 2
799 _coords[0] *= factor;
800 _coords[1] *= factor;
801#endif
802
803#if LIBMESH_DIM == 3
804 _coords[0] *= factor;
805 _coords[1] *= factor;
806 _coords[2] *= factor;
807#endif
808
809 return *this;
810}

◆ operator+() [1/2]

template<typename T >
template<typename T2 >
TypeVector< typename CompareTypes< T, T2 >::supertype > libMesh::TypeVector< T >::operator+ ( const TypeVector< T2 > &  ) const

Add two vectors.

Returns
A copy of the result, this vector is unchanged.

◆ operator+() [2/2]

template<typename T >
template<typename T2 >
LIBMESH_DEVICE_INLINE TypeVector< typename CompareTypes< T, T2 >::supertype > libMesh::TypeVector< T >::operator+ ( const TypeVector< T2 > &  p) const

Definition at line 582 of file type_vector.h.

583{
584 typedef typename CompareTypes<T, T2>::supertype TS;
585#if LIBMESH_DIM == 1
586 return TypeVector<TS> (_coords[0] + p._coords[0]);
587#endif
588
589#if LIBMESH_DIM == 2
590 return TypeVector<TS> (_coords[0] + p._coords[0],
591 _coords[1] + p._coords[1]);
592#endif
593
594#if LIBMESH_DIM == 3
595 return TypeVector<TS> (_coords[0] + p._coords[0],
596 _coords[1] + p._coords[1],
597 _coords[2] + p._coords[2]);
598#endif
599
600}

References libMesh::TypeVector< T >::_coords.

◆ operator+=() [1/2]

template<typename T >
template<typename T2 >
const TypeVector< T > & libMesh::TypeVector< T >::operator+= ( const TypeVector< T2 > &  )

Add to this vector.

Returns
A reference to *this.

◆ operator+=() [2/2]

template<typename T >
template<typename T2 >
LIBMESH_DEVICE_INLINE const TypeVector< T > & libMesh::TypeVector< T >::operator+= ( const TypeVector< T2 > &  p)

Definition at line 607 of file type_vector.h.

608{
609 this->add (p);
610
611 return *this;
612}
libMesh::TypeVector::add
void add(const TypeVector< T2 > &)
Add to this vector without creating a temporary.

◆ operator-() [1/3]

template<typename T >
LIBMESH_DEVICE_INLINE TypeVector< T > libMesh::TypeVector< T >::operator- ( ) const
Returns
The negative of this vector in a separate copy.

Definition at line 727 of file type_vector.h.

728{
729
730#if LIBMESH_DIM == 1
731 return TypeVector(-_coords[0]);
732#endif
733
734#if LIBMESH_DIM == 2
735 return TypeVector(-_coords[0],
736 -_coords[1]);
737#endif
738
739#if LIBMESH_DIM == 3
740 return TypeVector(-_coords[0],
741 -_coords[1],
742 -_coords[2]);
743#endif
744
745}
libMesh::TypeVector::TypeVector
friend class TypeVector
Definition type_vector.h:66

◆ operator-() [2/3]

template<typename T >
template<typename T2 >
TypeVector< typename CompareTypes< T, T2 >::supertype > libMesh::TypeVector< T >::operator- ( const TypeVector< T2 > &  ) const

Subtract from this vector.

Returns
A copy of the result, this vector is unchanged.

◆ operator-() [3/3]

template<typename T >
template<typename T2 >
LIBMESH_DEVICE_INLINE TypeVector< typename CompareTypes< T, T2 >::supertype > libMesh::TypeVector< T >::operator- ( const TypeVector< T2 > &  p) const

Definition at line 668 of file type_vector.h.

669{
670 typedef typename CompareTypes<T, T2>::supertype TS;
671
672#if LIBMESH_DIM == 1
673 return TypeVector<TS>(_coords[0] - p._coords[0]);
674#endif
675
676#if LIBMESH_DIM == 2
677 return TypeVector<TS>(_coords[0] - p._coords[0],
678 _coords[1] - p._coords[1]);
679#endif
680
681#if LIBMESH_DIM == 3
682 return TypeVector<TS>(_coords[0] - p._coords[0],
683 _coords[1] - p._coords[1],
684 _coords[2] - p._coords[2]);
685#endif
686
687}

References libMesh::TypeVector< T >::_coords.

◆ operator-=() [1/2]

template<typename T >
template<typename T2 >
const TypeVector< T > & libMesh::TypeVector< T >::operator-= ( const TypeVector< T2 > &  )

Subtract from this vector.

Returns
A reference to *this.

◆ operator-=() [2/2]

template<typename T >
template<typename T2 >
LIBMESH_DEVICE_INLINE const TypeVector< T > & libMesh::TypeVector< T >::operator-= ( const TypeVector< T2 > &  p)

Definition at line 694 of file type_vector.h.

695{
696 this->subtract (p);
697
698 return *this;
699}
libMesh::TypeVector::subtract
void subtract(const TypeVector< T2 > &)
Subtract from this vector without creating a temporary.

◆ operator/() [1/2]

template<typename T >
template<typename Scalar >
std::enable_if< ScalarTraits< Scalar >::value, TypeVector< typenameCompareTypes< T, Scalar >::supertype > >::type libMesh::TypeVector< T >::operator/ ( const Scalar &  ) const

Divide each entry of this vector by scalar value.

Returns
A copy of the result, this vector is unchanged.

◆ operator/() [2/2]

template<typename T >
template<typename Scalar >
LIBMESH_DEVICE_INLINE std::enable_if< ScalarTraits< Scalar >::value, TypeVector< typenameCompareTypes< T, Scalar >::supertype > >::type libMesh::TypeVector< T >::operator/ ( const Scalar &  factor) const

Definition at line 820 of file type_vector.h.

821{
822 typedef typename CompareTypes<T, Scalar>::supertype TS;
823
824 libmesh_assert_not_equal_to (static_cast<TS>(factor),
825 static_cast<TS>(0.));
826
827#if LIBMESH_DIM == 1
828 return TypeVector<TS>(_coords[0]/factor);
829#endif
830
831#if LIBMESH_DIM == 2
832 return TypeVector<TS>(_coords[0]/factor,
833 _coords[1]/factor);
834#endif
835
836#if LIBMESH_DIM == 3
837 return TypeVector<TS>(_coords[0]/factor,
838 _coords[1]/factor,
839 _coords[2]/factor);
840#endif
841
842}

◆ operator/=()

template<typename T >
LIBMESH_DEVICE_INLINE const TypeVector< T > & libMesh::TypeVector< T >::operator/= ( const T &  factor)

Divide each entry of this vector by scalar value.

Returns
A reference to *this.

Definition at line 850 of file type_vector.h.

851{
852 libmesh_assert_not_equal_to (factor, static_cast<T>(0.));
853
854 for (unsigned int i=0; i<LIBMESH_DIM; i++)
855 _coords[i] /= factor;
856
857 return *this;
858}

◆ operator<() [1/2]

bool libMesh::TypeVector< Complex >::operator< ( const TypeVector< Complex > &  rhs) const

Definition at line 124 of file type_vector.C.

125{
126 for (unsigned int i=0; i<LIBMESH_DIM; i++)
127 {
128 if ((*this)(i).real() < rhs(i).real())
129 return true;
130 if ((*this)(i).real() > rhs(i).real())
131 return false;
132 if ((*this)(i).imag() < rhs(i).imag())
133 return true;
134 if ((*this)(i).imag() > rhs(i).imag())
135 return false;
136 }
137 return false;
138}
std::real
boost::multiprecision::float128 real(const boost::multiprecision::float128 in)
Definition float128_shims.h:82
std::imag
boost::multiprecision::float128 imag(const boost::multiprecision::float128)
Definition float128_shims.h:88

◆ operator<() [2/2]

template<typename T >
bool libMesh::TypeVector< T >::operator< ( const TypeVector< T > &  rhs) const
Returns
true if this vector is "less" than rhs.

Useful for sorting. Also used for choosing some arbitrary basis function orientations.

Definition at line 66 of file type_vector.C.

67{
68 for (unsigned int i=0; i<LIBMESH_DIM; i++)
69 {
70 if ((*this)(i) < rhs(i))
71 return true;
72 if ((*this)(i) > rhs(i))
73 return false;
74 }
75 return false;
76}

◆ operator<=() [1/2]

bool libMesh::TypeVector< Complex >::operator<= ( const TypeVector< Complex > &  rhs) const

Definition at line 143 of file type_vector.C.

144{
145 for (unsigned int i=0; i<LIBMESH_DIM; i++)
146 {
147 if ((*this)(i).real() < rhs(i).real())
148 return true;
149 if ((*this)(i).real() > rhs(i).real())
150 return false;
151 if ((*this)(i).imag() < rhs(i).imag())
152 return true;
153 if ((*this)(i).imag() > rhs(i).imag())
154 return false;
155 }
156 return true;
157}

◆ operator<=() [2/2]

template<typename T >
bool libMesh::TypeVector< T >::operator<= ( const TypeVector< T > &  rhs) const
Returns
true if this vector is <= to rhs.

Useful for sorting. Also used for choosing some arbitrary constraint equation directions.

Definition at line 80 of file type_vector.C.

81{
82 for (unsigned int i=0; i<LIBMESH_DIM; i++)
83 {
84 if ((*this)(i) < rhs(i))
85 return true;
86 if ((*this)(i) > rhs(i))
87 return false;
88 }
89 return true;
90}

◆ operator=()

template<typename T >
template<typename Scalar >
LIBMESH_DEVICE_INLINE std::enable_if< ScalarTraits< Scalar >::value, TypeVector & >::type libMesh::TypeVector< T >::operator= ( const Scalar &  libmesh_dbg_varp)
inline

Assignment-from-scalar operator.

Used only to zero out vectors.

Definition at line 156 of file type_vector.h.

157 { libmesh_assert_equal_to (p, Scalar(0)); this->zero(); return *this; }
libMesh::TypeVector::zero
LIBMESH_DEVICE_INLINE void zero()
Set all entries of the vector to 0.
Definition type_vector.h:944

References libMesh::TypeVector< T >::zero().

◆ operator==()

template<typename T >
LIBMESH_DEVICE_INLINE bool libMesh::TypeVector< T >::operator== ( const TypeVector< T > &  rhs) const
Returns
true if this(i)==rhs(i) for each component of the vector.
Note
For floating point types T, the function absolute_fuzzy_equals() may be a more appropriate choice.

Definition at line 1061 of file type_vector.h.

1062{
1063#if LIBMESH_DIM == 1
1064 return (_coords[0] == rhs._coords[0]);
1065#endif
1066
1067#if LIBMESH_DIM == 2
1068 return (_coords[0] == rhs._coords[0] &&
1069 _coords[1] == rhs._coords[1]);
1070#endif
1071
1072#if LIBMESH_DIM == 3
1073 return (_coords[0] == rhs._coords[0] &&
1074 _coords[1] == rhs._coords[1] &&
1075 _coords[2] == rhs._coords[2]);
1076#endif
1077}

References libMesh::TypeVector< T >::_coords.

◆ operator>() [1/2]

bool libMesh::TypeVector< Complex >::operator> ( const TypeVector< Complex > &  rhs) const

Definition at line 162 of file type_vector.C.

163{
164 for (unsigned int i=0; i<LIBMESH_DIM; i++)
165 {
166 if ((*this)(i).real() > rhs(i).real())
167 return true;
168 if ((*this)(i).real() < rhs(i).real())
169 return false;
170 if ((*this)(i).imag() > rhs(i).imag())
171 return true;
172 if ((*this)(i).imag() < rhs(i).imag())
173 return false;
174 }
175 return false;
176}

◆ operator>() [2/2]

template<typename T >
bool libMesh::TypeVector< T >::operator> ( const TypeVector< T > &  rhs) const
Returns
true if this vector is "greater" than rhs.

Useful for sorting. Also used for choosing some arbitrary basis function orientations.

Definition at line 95 of file type_vector.C.

96{
97 for (unsigned int i=0; i<LIBMESH_DIM; i++)
98 {
99 if ((*this)(i) > rhs(i))
100 return true;
101 if ((*this)(i) < rhs(i))
102 return false;
103 }
104 return false;
105}

◆ operator>=() [1/2]

bool libMesh::TypeVector< Complex >::operator>= ( const TypeVector< Complex > &  rhs) const

Definition at line 181 of file type_vector.C.

182{
183 for (unsigned int i=0; i<LIBMESH_DIM; i++)
184 {
185 if ((*this)(i).real() > rhs(i).real())
186 return true;
187 if ((*this)(i).real() < rhs(i).real())
188 return false;
189 if ((*this)(i).imag() > rhs(i).imag())
190 return true;
191 if ((*this)(i).imag() < rhs(i).imag())
192 return false;
193 }
194 return true;
195}

◆ operator>=() [2/2]

template<typename T >
bool libMesh::TypeVector< T >::operator>= ( const TypeVector< T > &  rhs) const
Returns
true if this vector is >= rhs.

Useful for sorting. Also used for choosing some arbitrary constraint equation directions.

Definition at line 109 of file type_vector.C.

110{
111 for (unsigned int i=0; i<LIBMESH_DIM; i++)
112 {
113 if ((*this)(i) > rhs(i))
114 return true;
115 if ((*this)(i) < rhs(i))
116 return false;
117 }
118 return true;
119}

◆ print()

template<typename T >
void libMesh::TypeVector< T >::print ( std::ostream &  os = libMesh::out) const

Formatted print, by default to libMesh::out.

Definition at line 1234 of file type_vector.h.

1235{
1236#if LIBMESH_DIM == 1
1237
1238 os << "x=" << (*this)(0);
1239
1240#endif
1241#if LIBMESH_DIM == 2
1242
1243 os << "(x,y)=("
1244 << std::setw(8) << (*this)(0) << ", "
1245 << std::setw(8) << (*this)(1) << ")";
1246
1247#endif
1248#if LIBMESH_DIM == 3
1249
1250 os << "(x,y,z)=("
1251 << std::setw(8) << (*this)(0) << ", "
1252 << std::setw(8) << (*this)(1) << ", "
1253 << std::setw(8) << (*this)(2) << ")";
1254#endif
1255}

◆ relative_fuzzy_equals()

template<typename T >
bool libMesh::TypeVector< T >::relative_fuzzy_equals ( const TypeVector< T > &  rhs,
Real  tol = TOLERANCE 
) const
inline
Returns
true if two vectors are equal to within a relative tolerance of tol.

Definition at line 1052 of file type_vector.h.

1053{
1054 return libMesh::relative_fuzzy_equals(*this, rhs, tol);
1055}
libMesh::relative_fuzzy_equals
bool relative_fuzzy_equals(const T &var1, const T2 &var2, const Real tol=TOLERANCE *TOLERANCE)
Function to check whether two variables are equal within a relative tolerance.
Definition fuzzy_equals.h:78

References libMesh::relative_fuzzy_equals().

Referenced by libMesh::VariationalSmootherConstraint::determine_constraint(), libMesh::Hex20::has_affine_map(), libMesh::Hex27::has_affine_map(), libMesh::Hex8::has_affine_map(), libMesh::Prism15::has_affine_map(), libMesh::Prism18::has_affine_map(), libMesh::Prism20::has_affine_map(), libMesh::Prism21::has_affine_map(), libMesh::Prism6::has_affine_map(), libMesh::Tet10::has_affine_map(), libMesh::Tet14::has_affine_map(), libMesh::Edge3::has_affine_map(), libMesh::Edge4::has_affine_map(), libMesh::Quad4::has_affine_map(), libMesh::Quad8::has_affine_map(), libMesh::Quad9::has_affine_map(), libMesh::Tri6::has_affine_map(), libMesh::Tri7::has_affine_map(), FEGLLLagrangeAgreementTest< elem_type, order >::node_at(), MeshTriangulationTest::testPoly2TriEdge3ToTri7CenterFixup(), libMesh::Quad4::volume(), and libMesh::Tri6::volume().

◆ slice() [1/2]

template<typename T >
LIBMESH_DEVICE_INLINE T & libMesh::TypeVector< T >::slice ( const unsigned int  i)
inline

Definition at line 171 of file type_vector.h.

171{ return (*this)(i); }

◆ slice() [2/2]

template<typename T >
LIBMESH_DEVICE_INLINE const T & libMesh::TypeVector< T >::slice ( const unsigned int  i) const
inline

Definition at line 164 of file type_vector.h.

164{ return (*this)(i); }

◆ subtract() [1/2]

template<typename T >
template<typename T2 >
void libMesh::TypeVector< T >::subtract ( const TypeVector< T2 > &  )

Subtract from this vector without creating a temporary.

◆ subtract() [2/2]

template<typename T >
template<typename T2 >
LIBMESH_DEVICE_INLINE void libMesh::TypeVector< T >::subtract ( const TypeVector< T2 > &  p)

Definition at line 706 of file type_vector.h.

707{
708 for (unsigned int i=0; i<LIBMESH_DIM; i++)
709 _coords[i] -= p._coords[i];
710}

References libMesh::TypeVector< T >::_coords.

◆ subtract_scaled()

template<typename T >
template<typename T2 >
LIBMESH_DEVICE_INLINE void libMesh::TypeVector< T >::subtract_scaled ( const TypeVector< T2 > &  p,
const T &  factor 
)

Subtract a scaled value from this vector without creating a temporary.

Definition at line 717 of file type_vector.h.

718{
719 for (unsigned int i=0; i<LIBMESH_DIM; i++)
720 _coords[i] -= factor*p(i);
721}

Referenced by libMesh::HPCoarsenTest::select_refinement().

◆ unit()

template<typename T >
LIBMESH_DEVICE_INLINE TypeVector< T > libMesh::TypeVector< T >::unit ( ) const
Returns
A unit vector in the direction of *this.

Definition at line 1209 of file type_vector.h.

1210{
1211
1212 auto && length = norm();
1213
1214 libmesh_assert_not_equal_to (length, static_cast<Real>(0.));
1215
1216#if LIBMESH_DIM == 1
1217 return TypeVector<T>(_coords[0]/length);
1218#endif
1219
1220#if LIBMESH_DIM == 2
1221 return TypeVector<T>(_coords[0]/length,
1222 _coords[1]/length);
1223#endif
1224
1225#if LIBMESH_DIM == 3
1226 return TypeVector<T>(_coords[0]/length,
1227 _coords[1]/length,
1228 _coords[2]/length);
1229#endif
1230
1231}
libMesh::TypeVector::norm
auto norm() const
Definition type_vector.h:923
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
Definition libmesh_common.h:148

References libMesh::Real.

Referenced by libMesh::InfFE< Dim, T_radial, T_map >::compute_face_functions(), libMesh::FEMap::compute_face_map(), ContainsPointTest::containsPointTri3Helper(), libMesh::Plane::create_from_point_normal(), libMesh::Plane::create_from_three_points(), libMesh::VariationalSmootherConstraint::determine_constraint(), libMesh::MeshTools::Modification::distort(), libMesh::Polyhedron::Polyhedron(), libMesh::Elem::quality(), libMesh::C0Polygon::retriangulate(), AzimuthalPeriodicBoundary::set_up_rotation_matrix(), libMesh::C0Polyhedron::side_vertex_average_normal(), libMesh::Hex8::side_vertex_average_normal(), libMesh::Prism6::side_vertex_average_normal(), libMesh::Pyramid5::side_vertex_average_normal(), libMesh::Tet4::side_vertex_average_normal(), libMesh::C0Polygon::side_vertex_average_normal(), libMesh::Quad4::side_vertex_average_normal(), libMesh::Tri3::side_vertex_average_normal(), MeshTetTest::testNetGenQuadraticCurved(), MeshTetTest::testNetGenTet14Curved(), and libMesh::Sphere::unit_normal().

◆ write_unformatted()

template<typename T >
void libMesh::TypeVector< T >::write_unformatted ( std::ostream &  out_stream,
const bool  newline = true 
) const

Unformatted print to the stream out.

Simply prints the elements of the vector separated by spaces. Also prints a newline by default, however, this behavior can be controlled with the newline parameter.

Definition at line 51 of file type_vector.C.

53{
54 os << std::setiosflags(std::ios::showpoint)
55 << (*this)(0) << " "
56 << (*this)(1) << " "
57 << (*this)(2) << " ";
58
59 if (newline)
60 os << '\n';
61}

Referenced by libMesh::InfElemBuilder::build_inf_elem(), libMesh::InfElemBuilder::build_inf_elem(), and libMesh::TecplotIO::write_ascii().

◆ zero()

template<typename T >
LIBMESH_DEVICE_INLINE void libMesh::TypeVector< T >::zero ( )

Set all entries of the vector to 0.

Definition at line 944 of file type_vector.h.

945{
946 for (unsigned int i=0; i<LIBMESH_DIM; i++)
947 _coords[i] = 0.;
948}

Referenced by libMeshTest::KokkosTensorOracle::make_host_vector(), libMesh::TypeVector< T >::operator=(), libMesh::VectorValue< T >::operator=(), and TypeVectorTestBase< DerivedClass >::testZeroBase().

Friends And Related Symbol Documentation

◆ operator<<

template<typename T >
std::ostream & operator<< ( std::ostream &  os,
const TypeVector< T > &  t 
)
friend

Formatted print as above but supports the syntax:

Point p(1,2,3);
std::cout << p << std::endl;
libMesh::Point
A Point defines a location in LIBMESH_DIM dimensional Real space.
Definition point.h:41

Definition at line 411 of file type_vector.h.

412 {
413 t.print(os);
414 return os;
415 }

◆ TypeTensor< T >

template<typename T >
friend class TypeTensor< T >
friend

Definition at line 66 of file type_vector.h.

◆ TypeVector

template<typename T >
template<typename T2 >
friend class TypeVector
friend

Definition at line 66 of file type_vector.h.

Member Data Documentation

◆ _coords

template<typename T >
T libMesh::TypeVector< T >::_coords[LIBMESH_DIM]
protected

The coordinates of the TypeVector.

Definition at line 431 of file type_vector.h.

Referenced by libMesh::TypeVector< T >::add(), libMesh::TypeVector< T >::assign(), libMesh::TypeTensor< T >::column(), libMesh::TypeVector< T >::cross(), libMesh::TypeVector< T >::operator*(), libMesh::TypeVector< T >::operator+(), libMesh::TypeVector< T >::operator-(), libMesh::TypeVector< T >::operator==(), libMesh::TypeTensor< T >::row(), libMesh::TypeVector< T >::subtract(), and libMesh::TypeVector< T >::TypeVector().

The documentation for this class was generated from the following files:
Generated on Wed Nov 11 2026 20:16:34 for libMesh by doxygen 1.9.8