#include <deal.II/base/point.h>

Inheritance diagram for Point< dim, Number >:

Public Types
using	value_type = typename Tensor< rank_ - 1, dim, Number >::tensor_type

using	array_type = typename Tensor< rank_ - 1, dim, Number >::array_type[(dim !=0) ? dim :1]

using	tensor_type = Tensor< rank_, dim, Number >

Public Member Functions
	Point ()

	Point (const Tensor< 1, dim, Number > &)

	Point (const Number x)

	Point (const Number x, const Number y)

	Point (const Number x, const Number y, const Number z)

template<std::size_t dummy_dim, std::enable_if_t<(dim==dummy_dim) &&(dummy_dim !=0), int > = 0>
	Point (const boost::geometry::model::point< Number, dummy_dim, boost::geometry::cs::cartesian > &boost_pt)

Number	operator() (const unsigned int index) const

Number &	operator() (const unsigned int index)

template<typename OtherNumber >
Point< dim, Number > &	operator= (const Tensor< 1, dim, OtherNumber > &p)

template<class Archive >
void	serialize (Archive &ar, const unsigned int version)

template<typename OtherNumber >
constexpr	operator Tensor< 1, dim, Tensor< rank_ - 1, dim, OtherNumber > > () const

constexpr value_type &	operator[] (const unsigned int i)

constexpr const value_type &	operator[] (const unsigned int i) const

constexpr const Number &	operator[] (const TableIndices< rank_ > &indices) const

constexpr Number &	operator[] (const TableIndices< rank_ > &indices)

Number *	begin_raw ()

const Number *	begin_raw () const

Number *	end_raw ()

const Number *	end_raw () const

template<typename OtherNumber >
constexpr bool	operator== (const Tensor< rank_, dim, OtherNumber > &) const

template<typename OtherNumber >
constexpr bool	operator!= (const Tensor< rank_, dim, OtherNumber > &) const

template<typename OtherNumber >
constexpr Tensor &	operator+= (const Tensor< rank_, dim, OtherNumber > &)

template<typename OtherNumber >
constexpr Tensor &	operator-= (const Tensor< rank_, dim, OtherNumber > &)

template<typename OtherNumber >
constexpr Tensor &	operator*= (const OtherNumber &factor)

template<typename OtherNumber >
constexpr Tensor &	operator/= (const OtherNumber &factor)

constexpr void	clear ()

numbers::NumberTraits< Number >::real_type	norm () const

constexpr numbers::NumberTraits< Number >::real_type	norm_square () const

template<typename OtherNumber >
void	unroll (Vector< OtherNumber > &result) const

template<class Iterator >
void	unroll (const Iterator begin, const Iterator end) const

Addition and subtraction of points.
Point< dim, Number >	operator+ (const Tensor< 1, dim, Number > &) const

Tensor< 1, dim, Number >	operator- (const Point< dim, Number > &) const

Point< dim, Number >	operator- (const Tensor< 1, dim, Number > &) const

Point< dim, Number >	operator- () const

Static Public Member Functions
static Point< dim, Number >	unit_vector (const unsigned int i)

static constexpr unsigned int	component_to_unrolled_index (const TableIndices< rank_ > &indices)

static constexpr TableIndices< rank_ >	unrolled_to_component_indices (const unsigned int i)

static constexpr std::size_t	memory_consumption ()

Static Public Attributes
static constexpr unsigned int	dimension = dim

static constexpr unsigned int	rank = rank_

static constexpr unsigned int	n_independent_components

Private Member Functions
template<typename Iterator >
Iterator	unroll_recursion (const Iterator current, const Iterator end) const

Private Attributes
Tensor< rank_ - 1, dim, Number >	values [(dim !=0) ? dim :1]

Related Symbols
(Note that these are not member symbols.)
template<int dim, typename Number , typename OtherNumber >
Point< dim, typename ProductType< Number, typename EnableIfScalar< OtherNumber >::type >::type >	operator* (const OtherNumber factor, const Point< dim, Number > &p)

template<int dim, typename Number >
std::ostream &	operator<< (std::ostream &out, const Point< dim, Number > &p)

template<int dim, typename Number >
std::istream &	operator>> (std::istream &in, Point< dim, Number > &p)

template<int rank, int dim, typename Number >
Tensor< rank, dim, Number >	sum (const Tensor< rank, dim, Number > &local, const MPI_Comm mpi_communicator)

Vector space operations on Tensor objects:
template<int dim, typename Number , typename OtherNumber >
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE Tensor< 0, dim, typename ProductType< Number, OtherNumber >::type >	operator- (const Tensor< 0, dim, Number > &p, const Tensor< 0, dim, OtherNumber > &q)

template<int rank, int dim, typename Number , typename OtherNumber >
constexpr Tensor< rank, dim, typename ProductType< Number, OtherNumber >::type >	operator- (const Tensor< rank, dim, Number > &p, const Tensor< rank, dim, OtherNumber > &q)

template<int dim, typename Number , typename Other >
constexpr ProductType< Other, Number >::type	operator* (const Other &object, const Tensor< 0, dim, Number > &t)

template<int dim, typename Number , typename Other >
constexpr ProductType< Number, Other >::type	operator* (const Tensor< 0, dim, Number > &t, const Other &object)

template<int dim, typename Number , typename OtherNumber >
constexpr ProductType< Number, OtherNumber >::type	operator* (const Tensor< 0, dim, Number > &src1, const Tensor< 0, dim, OtherNumber > &src2)

template<int rank, int dim, typename Number , typename OtherNumber >
constexpr Tensor< rank, dim, typename ProductType< Number, typename EnableIfScalar< OtherNumber >::type >::type >	operator* (const Tensor< rank, dim, Number > &t, const OtherNumber &factor)

template<int rank, int dim, typename Number , typename OtherNumber >
constexpr Tensor< rank, dim, typename ProductType< typename EnableIfScalar< Number >::type, OtherNumber >::type >	operator* (const Number &factor, const Tensor< rank, dim, OtherNumber > &t)

template<int dim, typename Number , typename OtherNumber >
constexpr Tensor< 0, dim, typename ProductType< Number, typename EnableIfScalar< OtherNumber >::type >::type >	operator/ (const Tensor< 0, dim, Number > &t, const OtherNumber &factor)

template<int rank, int dim, typename Number , typename OtherNumber >
constexpr Tensor< rank, dim, typename ProductType< Number, typename EnableIfScalar< OtherNumber >::type >::type >	operator/ (const Tensor< rank, dim, Number > &t, const OtherNumber &factor)

template<int dim, typename Number , typename OtherNumber >
constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE Tensor< 0, dim, typename ProductType< Number, OtherNumber >::type >	operator+ (const Tensor< 0, dim, Number > &p, const Tensor< 0, dim, OtherNumber > &q)

template<int rank, int dim, typename Number , typename OtherNumber >
constexpr Tensor< rank, dim, typename ProductType< Number, OtherNumber >::type >	operator+ (const Tensor< rank, dim, Number > &p, const Tensor< rank, dim, OtherNumber > &q)

template<int dim, typename Number , typename OtherNumber >
constexpr Tensor< 0, dim, typename ProductType< Number, OtherNumber >::type >	schur_product (const Tensor< 0, dim, Number > &src1, const Tensor< 0, dim, OtherNumber > &src2)

template<int rank, int dim, typename Number , typename OtherNumber >
constexpr Tensor< rank, dim, typename ProductType< Number, OtherNumber >::type >	schur_product (const Tensor< rank, dim, Number > &src1, const Tensor< rank, dim, OtherNumber > &src2)

Output functions for Tensor objects
template<int rank_, int dim, typename Number >
std::ostream &	operator<< (std::ostream &out, const Tensor< rank_, dim, Number > &p)

template<int dim, typename Number >
std::ostream &	operator<< (std::ostream &out, const Tensor< 0, dim, Number > &p)

Contraction operations and the outer product for tensor objects
template<int dim, typename Number >
Number	l1_norm (const Tensor< 2, dim, Number > &t)

template<int dim, typename Number >
Number	linfty_norm (const Tensor< 2, dim, Number > &t)

Multiplication and scaling of points. Dot products. Norms.
template<typename OtherNumber >
Point< dim, typename ProductType< Number, typename EnableIfScalar< OtherNumber >::type >::type >	operator/ (const OtherNumber) const

Number	operator* (const Tensor< 1, dim, Number > &p) const

numbers::NumberTraits< Number >::real_type	square () const

numbers::NumberTraits< Number >::real_type	distance (const Point< dim, Number > &p) const

numbers::NumberTraits< Number >::real_type	distance_square (const Point< dim, Number > &p) const

template<typename OtherNumber >
Point< dim, typename ProductType< Number, typename EnableIfScalar< OtherNumber >::type >::type >	operator* (const OtherNumber) const

Detailed Description

template<int dim, typename Number = double>
class Point< dim, Number >

A class that represents a point in a Cartesian space of dimension dim .

Objects of this class are used to represent points (i.e., vectors anchored at the origin) of a vector space equipped with a Cartesian coordinate system. They are, among other uses, passed to functions that operate on points in spaces of a priori fixed dimension: rather than using functions like double f(const double x) and double f(const double x, const double y), you can use double f(const Point<dim> &p) instead as it allows writing dimension independent code.

deal.II specifically uses Point objects as indicating points that are represented by Cartesian coordinates, i.e., where a point in dim space dimensions is characterized by signed distances along the axes of a coordinate system spanned by dim mutually orthogonal unit vectors (called the "coordinate axes"). This choice of representing a vector makes addition and scaling of vectors particularly simple: one only has to add or multiply each coordinate value. On the other hand, adding or scaling vectors is not nearly as simple when a vector is represented in other kinds of coordinate systems (e.g., spherical coordinate systems).

What's a `Point<dim>` and what is a `Tensor<1,dim>`?

The Point class is derived from Tensor<1,dim> and consequently shares the latter's member functions and other attributes. In fact, it has relatively few additional functions itself (the most notable exception being the distance() function to compute the Euclidean distance between two points in space), and these two classes can therefore often be used interchangeably.

Nonetheless, there are semantic differences that make us use these classes in different and well-defined contexts. Within deal.II, we use the Point class to denote points in space, i.e., for vectors (rank-1 tensors) that are anchored at the origin. On the other hand, vectors that are anchored elsewhere (and consequently do not represent points in the common usage of the word) are represented by objects of type Tensor<1,dim>. In particular, this is the case for direction vectors, normal vectors, gradients, and the differences between two points (i.e., what you get when you subtract one point from another): all of these are represented by Tensor<1,dim> objects rather than Point<dim>.

Furthermore, the Point class is only used where the coordinates of an object can be thought to possess the dimension of a length. An object that represents the weight, height, and cost of an object is neither a point nor a tensor (because it lacks the transformation properties under rotation of the coordinate system) and should consequently not be represented by either of these classes. Use an array of size 3 in this case, or the std::array class. Alternatively, as in the case of vector-valued functions, you can use objects of type Vector or std::vector.

Template Parameters

dim An integer that denotes the dimension of the space in which a point lies. This of course equals the number of coordinates that identify a point.

Number The data type in which the coordinates values are to be stored. This will, in almost all cases, simply be the default double, but there are cases where one may want to store coordinates in a different (and always scalar) type. An example would be an interval type that can store the value of a coordinate as well as its uncertainty. Another example would be a type that allows for Automatic Differentiation (see, for example, the Sacado type used in step-33) and thereby can generate analytic (spatial) derivatives of a function when passed a Point object whose coordinates are stored in such a type.

Note: This class, function, or variable is a template, and it can only be instantiated if the following condition is true:
dim >= 0

If your compiler supports the C++20 standard, then this constraint will be enforced by a C++20 requires clause.

Definition at line 111 of file point.h.

Member Typedef Documentation

◆ value_type

template<int rank_, int dim, typename Number >

using Tensor< rank_, dim, Number >::value_type = typename Tensor<rank_ - 1, dim, Number>::tensor_type

inherited

Type of objects encapsulated by this container and returned by operator[](). This is a tensor of lower rank for a general tensor, and a scalar number type for Tensor<1,dim,Number>.

Definition at line 549 of file tensor.h.

◆ array_type

template<int rank_, int dim, typename Number >

using Tensor< rank_, dim, Number >::array_type = typename Tensor<rank_ - 1, dim, Number>::array_type[(dim != 0) ? dim : 1]

inherited

Declare an array type which can be used to initialize an object of this type statically. For dim == 0, its size is 1. Otherwise, it is dim.

Definition at line 555 of file tensor.h.

◆ tensor_type

template<int rank_, int dim, typename Number >

using Tensor< rank_, dim, Number >::tensor_type = Tensor<rank_, dim, Number>

inherited

Internal type declaration that is used to specialize the return type of operator[]() for Tensor<1,dim,Number>

Definition at line 878 of file tensor.h.

Constructor & Destructor Documentation

◆ Point() [1/6]

template<int dim, typename Number = double>

Point< dim, Number >::Point ( )

Standard constructor. Creates an object that corresponds to the origin, i.e., all coordinates are set to zero.

Note: This function can also be used in device code.

◆ Point() [2/6]

template<int dim, typename Number = double>

Point< dim, Number >::Point ( const Tensor< 1, dim, Number > & )

explicit

Convert a tensor to a point.

◆ Point() [3/6]

template<int dim, typename Number = double>

Point< dim, Number >::Point ( const Number x )

explicit

Constructor for one dimensional points. This function is only implemented for dim==1 since the usage is considered unsafe for points with dim!=1 as it would leave some components of the point coordinates uninitialized.

Note: This function can also be used in device code.

◆ Point() [4/6]

template<int dim, typename Number = double>

Point< dim, Number >::Point	(	const Number	x,
		const Number	y
	)

Constructor for two dimensional points. This function is only implemented for dim==2 since the usage is considered unsafe for points with dim!=2 as it would leave some components of the point coordinates uninitialized (if dim>2) or would not use some arguments (if dim<2).

Note: This function can also be used in device code.

◆ Point() [5/6]

template<int dim, typename Number = double>

Point< dim, Number >::Point	(	const Number	x,
		const Number	y,
		const Number	z
	)

Constructor for three dimensional points. This function is only implemented for dim==3 since the usage is considered unsafe for points with dim!=3 as it would leave some components of the point coordinates uninitialized (if dim>3) or would not use some arguments (if dim<3).

Note: This function can also be used in device code.

◆ Point() [6/6]

template<int dim, typename Number = double>

template<std::size_t dummy_dim, std::enable_if_t<(dim==dummy_dim) &&(dummy_dim !=0), int > = 0>

Point< dim, Number >::Point ( const boost::geometry::model::point< Number, dummy_dim, boost::geometry::cs::cartesian > & boost_pt )

Convert a boost::geometry::point to a Point.

Member Function Documentation

◆ unit_vector()

template<int dim, typename Number = double>

static Point< dim, Number > Point< dim, Number >::unit_vector ( const unsigned int i )

static

Return a unit vector in coordinate direction i, i.e., a vector that is zero in all coordinates except for a single 1 in the ith coordinate.

Note: This function can also be used in device code.

◆ operator()() [1/2]

template<int dim, typename Number = double>

Number Point< dim, Number >::operator() ( const unsigned int index ) const

Read access to the indexth coordinate.

Note: This function can also be used in device code.

◆ operator()() [2/2]

template<int dim, typename Number = double>

Number & Point< dim, Number >::operator() ( const unsigned int index )

Read and write access to the indexth coordinate.

Note: This function can also be used in device code.

◆ operator=()

template<int dim, typename Number = double>

template<typename OtherNumber >

Point< dim, Number > & Point< dim, Number >::operator= ( const Tensor< 1, dim, OtherNumber > & p )

Assignment operator from Tensor<1, dim, Number> with different underlying scalar type. This obviously requires that the OtherNumber type is convertible to Number.

◆ operator+()

template<int dim, typename Number = double>

Point< dim, Number > Point< dim, Number >::operator+ ( const Tensor< 1, dim, Number > & ) const

Add an offset given as Tensor<1,dim,Number> to a point.

Note: This function can also be used in device code.

◆ operator-() [1/3]

template<int dim, typename Number = double>

Tensor< 1, dim, Number > Point< dim, Number >::operator- ( const Point< dim, Number > & ) const

Subtract two points, i.e., obtain the vector that connects the two. As discussed in the documentation of this class, subtracting two points results in a vector anchored at one of the two points (rather than at the origin) and, consequently, the result is returned as a Tensor<1,dim> rather than as a Point<dim>.

Note: This function can also be used in device code.

◆ operator-() [2/3]

template<int dim, typename Number = double>

Point< dim, Number > Point< dim, Number >::operator- ( const Tensor< 1, dim, Number > & ) const

Subtract a difference vector (represented by a Tensor<1,dim>) from the current point. This results in another point and, as discussed in the documentation of this class, the result is then naturally returned as a Point<dim> object rather than as a Tensor<1,dim>.

Note: This function can also be used in device code.

◆ operator-() [3/3]

template<int dim, typename Number = double>

Point< dim, Number > Point< dim, Number >::operator- ( ) const

The opposite vector.

Note: This function can also be used in device code.

◆ operator/()

template<int dim, typename Number = double>

template<typename OtherNumber >

Point< dim, typename ProductType< Number, typename EnableIfScalar< OtherNumber >::type >::type > Point< dim, Number >::operator/ ( const OtherNumber ) const

Divide the current point by a factor.

Note: This function can also be used in device code.

◆ operator*()

template<int dim, typename Number = double>

Number Point< dim, Number >::operator* ( const Tensor< 1, dim, Number > & p ) const

Return the scalar product of the vectors representing two points.

Note: This function can also be used in device code.

◆ square()

template<int dim, typename Number = double>

numbers::NumberTraits< Number >::real_type Point< dim, Number >::square ( ) const

Return the scalar product of this point vector with itself, i.e. the square, or the square of the norm. In case of a complex number type it is equivalent to the contraction of this point vector with a complex conjugate of itself.

Note: This function is equivalent to Tensor<rank,dim,Number>::norm_square() which returns the square of the Frobenius norm.; This function can also be used in device code.

◆ distance()

template<int dim, typename Number = double>

numbers::NumberTraits< Number >::real_type Point< dim, Number >::distance ( const Point< dim, Number > & p ) const

Return the Euclidean distance of this point to the point p, i.e. the \(l_2\) norm of the difference between the vectors representing the two points.

Note: This function can also be used in device code.

◆ distance_square()

template<int dim, typename Number = double>

numbers::NumberTraits< Number >::real_type Point< dim, Number >::distance_square ( const Point< dim, Number > & p ) const

Return the squared Euclidean distance of this point to the point p.

Note: This function can also be used in device code.

◆ serialize()

template<int dim, typename Number = double>

template<class Archive >

void Point< dim, Number >::serialize	(	Archive &	ar,
		const unsigned int	version
	)

Read or write the data of this object to or from a stream for the purpose of serialization using the BOOST serialization library.

◆ operator Tensor< 1, dim, Tensor< rank_ - 1, dim, OtherNumber > >()

template<int rank_, int dim, typename Number >

template<typename OtherNumber >

constexpr Tensor< rank_, dim, Number >::operator Tensor< 1, dim, Tensor< rank_ - 1, dim, OtherNumber > > ( ) const

constexprinherited

Conversion operator to tensor of tensors.

◆ operator[]() [1/4]

template<int rank_, int dim, typename Number >

constexpr value_type & Tensor< rank_, dim, Number >::operator[] ( const unsigned int i )

constexprinherited

Read-Write access operator.

Note: This function can also be used in device code.

◆ operator[]() [2/4]

template<int rank_, int dim, typename Number >

constexpr const value_type & Tensor< rank_, dim, Number >::operator[] ( const unsigned int i ) const

constexprinherited

Read-only access operator.

Note: This function can also be used in device code.

◆ operator[]() [3/4]

template<int rank_, int dim, typename Number >

constexpr const Number & Tensor< rank_, dim, Number >::operator[] ( const TableIndices< rank_ > & indices ) const

constexprinherited

Read access using TableIndices indices

◆ operator[]() [4/4]

template<int rank_, int dim, typename Number >

constexpr Number & Tensor< rank_, dim, Number >::operator[] ( const TableIndices< rank_ > & indices )

constexprinherited

Read and write access using TableIndices indices

◆ begin_raw() [1/2]

template<int rank_, int dim, typename Number >

Number * Tensor< rank_, dim, Number >::begin_raw ( )

inherited

Return a pointer to the first element of the underlying storage.

◆ begin_raw() [2/2]

template<int rank_, int dim, typename Number >

const Number * Tensor< rank_, dim, Number >::begin_raw ( ) const

inherited

Return a const pointer to the first element of the underlying storage.

◆ end_raw() [1/2]

template<int rank_, int dim, typename Number >

Number * Tensor< rank_, dim, Number >::end_raw ( )

inherited

Return a pointer to the element past the end of the underlying storage.

◆ end_raw() [2/2]

template<int rank_, int dim, typename Number >

const Number * Tensor< rank_, dim, Number >::end_raw ( ) const

inherited

Return a pointer to the element past the end of the underlying storage.

◆ operator==()

template<int rank_, int dim, typename Number >

template<typename OtherNumber >

constexpr bool Tensor< rank_, dim, Number >::operator== ( const Tensor< rank_, dim, OtherNumber > & ) const

constexprinherited

Test for equality of two tensors.

◆ operator!=()

template<int rank_, int dim, typename Number >

template<typename OtherNumber >

constexpr bool Tensor< rank_, dim, Number >::operator!= ( const Tensor< rank_, dim, OtherNumber > & ) const

constexprinherited

Test for inequality of two tensors.

◆ operator+=()

template<int rank_, int dim, typename Number >

template<typename OtherNumber >

constexpr Tensor & Tensor< rank_, dim, Number >::operator+= ( const Tensor< rank_, dim, OtherNumber > & )

constexprinherited

Add another tensor.

Note: This function can also be used in device code.

◆ operator-=()

template<int rank_, int dim, typename Number >

template<typename OtherNumber >

constexpr Tensor & Tensor< rank_, dim, Number >::operator-= ( const Tensor< rank_, dim, OtherNumber > & )

constexprinherited

Subtract another tensor.

Note: This function can also be used in device code.

◆ operator*=()

template<int rank_, int dim, typename Number >

template<typename OtherNumber >

constexpr Tensor & Tensor< rank_, dim, Number >::operator*= ( const OtherNumber & factor )

constexprinherited

Scale the tensor by factor, i.e. multiply all components by factor.

Note: This function can also be used in device code.

◆ operator/=()

template<int rank_, int dim, typename Number >

template<typename OtherNumber >

constexpr Tensor & Tensor< rank_, dim, Number >::operator/= ( const OtherNumber & factor )

constexprinherited

Scale the vector by 1/factor.

Note: This function can also be used in device code.

◆ clear()

template<int rank_, int dim, typename Number >

constexpr void Tensor< rank_, dim, Number >::clear ( )

constexprinherited

Reset all values to zero.

Note that this is partly inconsistent with the semantics of the clear() member functions of the standard library containers and of several other classes within deal.II, which not only reset the values of stored elements to zero, but release all memory and return the object into a virginial state. However, since the size of objects of the present type is determined by its template parameters, resizing is not an option, and indeed the state where all elements have a zero value is the state right after construction of such an object.

◆ norm()

template<int rank_, int dim, typename Number >

numbers::NumberTraits< Number >::real_type Tensor< rank_, dim, Number >::norm ( ) const

inherited

Return the Frobenius-norm of a tensor, i.e. the square root of the sum of the absolute squares of all entries. For the present case of rank-1 tensors, this equals the usual l₂ norm of the vector.

Note: This function can also be used in device code.

◆ norm_square()

template<int rank_, int dim, typename Number >

constexpr numbers::NumberTraits< Number >::real_type Tensor< rank_, dim, Number >::norm_square ( ) const

constexprinherited

Return the square of the Frobenius-norm of a tensor, i.e. the sum of the absolute squares of all entries.

Note: This function can also be used in device code.

◆ unroll() [1/2]

template<int rank_, int dim, typename Number >

template<typename OtherNumber >

void Tensor< rank_, dim, Number >::unroll ( Vector< OtherNumber > & result ) const

inherited

Fill a vector with all tensor elements.

This function unrolls all tensor entries into a single, linearly numbered vector. As usual in C++, the rightmost index of the tensor marches fastest.

Deprecated:: Use the more general function that takes a pair of iterators instead.

◆ unroll() [2/2]

template<int rank_, int dim, typename Number >

template<class Iterator >

void Tensor< rank_, dim, Number >::unroll	(	const Iterator	begin,
		const Iterator	end
	)		const

inherited

Fill a range with all tensor elements.

This function unrolls all tensor entries into a single, linearly numbered sequence. The order of the elements is the one given by component_to_unrolled_index().

The template type Number must be convertible to the type of *begin.

◆ component_to_unrolled_index()

template<int rank_, int dim, typename Number >

static constexpr unsigned int Tensor< rank_, dim, Number >::component_to_unrolled_index ( const TableIndices< rank_ > & indices )

staticconstexprinherited

Return an unrolled index in the range \([0,\text{dim}^{\text{rank}}-1]\) for the element of the tensor indexed by the argument to the function.

◆ unrolled_to_component_indices()

template<int rank_, int dim, typename Number >

static constexpr TableIndices< rank_ > Tensor< rank_, dim, Number >::unrolled_to_component_indices ( const unsigned int i )

staticconstexprinherited

Opposite of component_to_unrolled_index: For an index in the range \([0, \text{dim}^{\text{rank}}-1]\), return which set of indices it would correspond to.

◆ memory_consumption()

template<int rank_, int dim, typename Number >

static constexpr std::size_t Tensor< rank_, dim, Number >::memory_consumption ( )

staticconstexprinherited

Determine an estimate for the memory consumption (in bytes) of this object.

◆ unroll_recursion()

template<int rank_, int dim, typename Number >

template<typename Iterator >

Iterator Tensor< rank_, dim, Number >::unroll_recursion	(	const Iterator	current,
		const Iterator	end
	)		const

privateinherited

Internal helper function for unroll.

Friends And Related Symbol Documentation

◆ operator*() [1/7]

template<int dim, typename Number = double>

template<typename OtherNumber >

Point< dim, typename ProductType< Number, typename EnableIfScalar< OtherNumber >::type >::type > operator* ( const OtherNumber ) const

Note: This function can also be used in device code.

◆ operator*() [2/7]

template<int dim, typename Number , typename OtherNumber >

Point< dim, typename ProductType< Number, typename EnableIfScalar< OtherNumber >::type >::type > operator*	(	const OtherNumber	factor,
		const Point< dim, Number > &	p
	)

Note: This function can also be used in device code.

Definition at line 662 of file point.h.

◆ operator<<() [1/3]

template<int dim, typename Number >

std::ostream & operator<<	(	std::ostream &	out,
		const Point< dim, Number > &	p
	)

Note: This class, function, or variable is a template, and it can only be instantiated if the following condition is true:
dim >= 0

If your compiler supports the C++20 standard, then this constraint will be enforced by a C++20 requires clause.

Definition at line 678 of file point.h.

◆ operator>>()

template<int dim, typename Number >

std::istream & operator>>	(	std::istream &	in,
		Point< dim, Number > &	p
	)

Note: This class, function, or variable is a template, and it can only be instantiated if the following condition is true:
dim >= 0

If your compiler supports the C++20 standard, then this constraint will be enforced by a C++20 requires clause.

Definition at line 699 of file point.h.

◆ operator-() [1/2]

template<int dim, typename Number , typename OtherNumber >

constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE Tensor< 0, dim, typename ProductType< Number, OtherNumber >::type > operator-	(	const Tensor< 0, dim, Number > &	p,
		const Tensor< 0, dim, OtherNumber > &	q
	)

Note: This function can also be used in device code.

Definition at line 2069 of file tensor.h.

◆ operator-() [2/2]

template<int rank, int dim, typename Number , typename OtherNumber >

constexpr Tensor< rank, dim, typename ProductType< Number, OtherNumber >::type > operator-	(	const Tensor< rank, dim, Number > &	p,
		const Tensor< rank, dim, OtherNumber > &	q
	)

Template Parameters

rank	The rank of both tensors.

Note: This function can also be used in device code.

Definition at line 2235 of file tensor.h.

◆ sum()

template<int rank, int dim, typename Number >

Tensor< rank, dim, Number > sum	(	const Tensor< rank, dim, Number > &	local,
		const MPI_Comm	mpi_communicator
	)

◆ operator<<() [2/3]

template<int rank_, int dim, typename Number >

std::ostream & operator<<	(	std::ostream &	out,
		const Tensor< rank_, dim, Number > &	p
	)

Definition at line 1925 of file tensor.h.

◆ operator<<() [3/3]

template<int dim, typename Number >

std::ostream & operator<<	(	std::ostream &	out,
		const Tensor< 0, dim, Number > &	p
	)

Definition at line 1946 of file tensor.h.

◆ operator*() [3/7]

template<int dim, typename Number , typename Other >

constexpr ProductType< Other, Number >::type operator*	(	const Other &	object,
		const Tensor< 0, dim, Number > &	t
	)

This function unwraps the underlying Number stored in the Tensor and multiplies object with it.

Note: This function can also be used in device code.

Definition at line 1975 of file tensor.h.

◆ operator*() [4/7]

template<int dim, typename Number , typename Other >

constexpr ProductType< Number, Other >::type operator*	(	const Tensor< 0, dim, Number > &	t,
		const Other &	object
	)

This function unwraps the underlying Number stored in the Tensor and multiplies object with it.

Note: This function can also be used in device code.

Definition at line 1995 of file tensor.h.

◆ operator*() [5/7]

template<int dim, typename Number , typename OtherNumber >

constexpr ProductType< Number, OtherNumber >::type operator*	(	const Tensor< 0, dim, Number > &	src1,
		const Tensor< 0, dim, OtherNumber > &	src2
	)

This function unwraps the underlying objects of type Number and OtherNumber that are stored within the Tensor and multiplies them. It returns an unwrapped number of product type.

Note: This function can also be used in device code.

Definition at line 2015 of file tensor.h.

◆ operator*() [6/7]

template<int rank, int dim, typename Number , typename OtherNumber >

constexpr Tensor< rank, dim, typename ProductType< Number, typename EnableIfScalar< OtherNumber >::type >::type > operator*	(	const Tensor< rank, dim, Number > &	t,
		const OtherNumber &	factor
	)

Only multiplication with a scalar number type (i.e., a floating point number, a complex floating point number, etc.) is allowed, see the documentation of EnableIfScalar for details.

Note: This function can also be used in device code.

Definition at line 2094 of file tensor.h.

◆ operator*() [7/7]

template<int rank, int dim, typename Number , typename OtherNumber >

constexpr Tensor< rank, dim, typename ProductType< typename EnableIfScalar< Number >::type, OtherNumber >::type > operator*	(	const Number &	factor,
		const Tensor< rank, dim, OtherNumber > &	t
	)

Only multiplication with a scalar number type (i.e., a floating point number, a complex floating point number, etc.) is allowed, see the documentation of EnableIfScalar for details.

Note: This function can also be used in device code.

Definition at line 2122 of file tensor.h.

◆ operator/() [1/2]

template<int dim, typename Number , typename OtherNumber >

constexpr Tensor< 0, dim, typename ProductType< Number, typename EnableIfScalar< OtherNumber >::type >::type > operator/	(	const Tensor< 0, dim, Number > &	t,
		const OtherNumber &	factor
	)

Note: This function can also be used in device code.

Definition at line 2036 of file tensor.h.

◆ operator/() [2/2]

template<int rank, int dim, typename Number , typename OtherNumber >

constexpr Tensor< rank, dim, typename ProductType< Number, typename EnableIfScalar< OtherNumber >::type >::type > operator/	(	const Tensor< rank, dim, Number > &	t,
		const OtherNumber &	factor
	)

Note: This function can also be used in device code.

Definition at line 2193 of file tensor.h.

◆ operator+() [1/2]

template<int dim, typename Number , typename OtherNumber >

constexpr DEAL_II_HOST_DEVICE_ALWAYS_INLINE Tensor< 0, dim, typename ProductType< Number, OtherNumber >::type > operator+	(	const Tensor< 0, dim, Number > &	p,
		const Tensor< 0, dim, OtherNumber > &	q
	)

Note: This function can also be used in device code.

Definition at line 2052 of file tensor.h.

◆ operator+() [2/2]

template<int rank, int dim, typename Number , typename OtherNumber >

constexpr Tensor< rank, dim, typename ProductType< Number, OtherNumber >::type > operator+	(	const Tensor< rank, dim, Number > &	p,
		const Tensor< rank, dim, OtherNumber > &	q
	)

Template Parameters

rank	The rank of both tensors.

Note: This function can also be used in device code.

Definition at line 2211 of file tensor.h.

◆ schur_product() [1/2]

template<int dim, typename Number , typename OtherNumber >

constexpr Tensor< 0, dim, typename ProductType< Number, OtherNumber >::type > schur_product	(	const Tensor< 0, dim, Number > &	src1,
		const Tensor< 0, dim, OtherNumber > &	src2
	)

Definition at line 2255 of file tensor.h.

◆ schur_product() [2/2]

template<int rank, int dim, typename Number , typename OtherNumber >

constexpr Tensor< rank, dim, typename ProductType< Number, OtherNumber >::type > schur_product	(	const Tensor< rank, dim, Number > &	src1,
		const Tensor< rank, dim, OtherNumber > &	src2
	)

This multiplication is also called "Hadamard-product" (c.f. https://en.wikipedia.org/wiki/Hadamard_product_(matrices)), and generates a new tensor of size <rank, dim>:

\[ \text{result}_{i, j} = \text{left}_{i, j}\circ \text{right}_{i, j} \]

Template Parameters

rank	The rank of both tensors.

Definition at line 2284 of file tensor.h.

◆ l1_norm()

template<int rank_1, int rank_2, int dim, typename Number , typename OtherNumber , typename = std::enable_if_t<rank_1 >= 1 && rank_2>

template<int dim, typename Number >

Number l1_norm ( const Tensor< 2, dim, Number > & t )

The dot product (single contraction) for tensors. This function return a tensor of rank \((\text{rank}_1 + \text{rank}_2 - 2)\) that is the contraction of the last index of a tensor src1 of rank rank_1 with the first index of a tensor src2 of rank rank_2:

\[ \text{result}_{i_1,\ldots,i_{r1},j_1,\ldots,j_{r2}} = \sum_{k} \text{left}_{i_1,\ldots,i_{r1}, k} \text{right}_{k, j_1,\ldots,j_{r2}} \]

Note: For the Tensor class, the multiplication operator only performs a contraction over a single pair of indices. This is in contrast to the multiplication operator for SymmetricTensor, for which the corresponding operator*() performs a double contraction. The origin of the difference in how operator*() is implemented between Tensor and SymmetricTensor is that for the former, the product between two Tensor objects of same rank and dimension results in another Tensor object – that it, operator*() corresponds to the multiplicative group action within the group of tensors. On the other hand, there is no corresponding multiplicative group action with the set of symmetric tensors because, in general, the product of two symmetric tensors is a nonsymmetric tensor. As a consequence, for a mathematician, it is clear that operator*() for symmetric tensors must have a different meaning: namely the dot or scalar product that maps two symmetric tensors of rank 2 to a scalar. This corresponds to the double-dot (colon) operator whose meaning is then extended to the product of any two even-ranked symmetric tensors.; In case the contraction yields a tensor of rank 0, that is, if rank_1==rank_2==1, then a scalar number is returned as an unwrapped number type. Return the \(l_1\) norm of the given rank-2 tensor, where \(\|\mathbf T\|_1 = \max_j \sum_i |T_{ij}|\) (maximum of the sums over columns).

Definition at line 3035 of file tensor.h.

◆ linfty_norm()

template<int dim, typename Number >

Number linfty_norm ( const Tensor< 2, dim, Number > & t )

Definition at line 3061 of file tensor.h.

Member Data Documentation

◆ dimension

template<int rank_, int dim, typename Number >

constexpr unsigned int Tensor< rank_, dim, Number >::dimension = dim

staticconstexprinherited

Provide a way to get the dimension of an object without explicit knowledge of it's data type. Implementation is this way instead of providing a function dimension() because now it is possible to get the dimension at compile time without the expansion and preevaluation of an inlined function; the compiler may therefore produce more efficient code and you may use this value to declare other data types.

Definition at line 530 of file tensor.h.

◆ rank

template<int rank_, int dim, typename Number >

constexpr unsigned int Tensor< rank_, dim, Number >::rank = rank_

staticconstexprinherited

Publish the rank of this tensor to the outside world.

Definition at line 535 of file tensor.h.

◆ n_independent_components

template<int rank_, int dim, typename Number >

constexpr unsigned int Tensor< rank_, dim, Number >::n_independent_components

staticconstexprinherited

Initial value:

=

Tensor<rank_ - 1, dim>::n_independent_components * dim

Tensor

Definition tensor.h:516

Tensor::n_independent_components

static constexpr unsigned int n_independent_components

Definition tensor.h:541

Number of independent components of a tensor of current rank. This is dim times the number of independent components of each sub-tensor.

Definition at line 541 of file tensor.h.

◆ values

template<int rank_, int dim, typename Number >

Tensor<rank_ - 1, dim, Number> Tensor< rank_, dim, Number >::values[(dim !=0) ? dim :1]

privateinherited

Array of tensors holding the subelements.

Definition at line 884 of file tensor.h.

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

include/deal.II/base/point.h

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Related Symbols

Multiplication and scaling of points. Dot products. Norms.

Detailed Description

What's a Point<dim> and what is a Tensor<1,dim>?

Member Typedef Documentation

◆ value_type

◆ array_type

◆ tensor_type

Constructor & Destructor Documentation

◆ Point() [1/6]

◆ Point() [2/6]

◆ Point() [3/6]

◆ Point() [4/6]

◆ Point() [5/6]

◆ Point() [6/6]

Member Function Documentation

◆ unit_vector()

◆ operator()() [1/2]

◆ operator()() [2/2]

◆ operator=()

◆ operator+()

◆ operator-() [1/3]

◆ operator-() [2/3]

◆ operator-() [3/3]

◆ operator/()

◆ operator*()

◆ square()

◆ distance()

◆ distance_square()

◆ serialize()

◆ operator Tensor< 1, dim, Tensor< rank_ - 1, dim, OtherNumber > >()

◆ operator[]() [1/4]

◆ operator[]() [2/4]

◆ operator[]() [3/4]

◆ operator[]() [4/4]

◆ begin_raw() [1/2]

◆ begin_raw() [2/2]

◆ end_raw() [1/2]

◆ end_raw() [2/2]

◆ operator==()

◆ operator!=()

◆ operator+=()

◆ operator-=()

◆ operator*=()

◆ operator/=()

◆ clear()

◆ norm()

◆ norm_square()

◆ unroll() [1/2]

◆ unroll() [2/2]

◆ component_to_unrolled_index()

◆ unrolled_to_component_indices()

◆ memory_consumption()

◆ unroll_recursion()

Friends And Related Symbol Documentation

◆ operator*() [1/7]

◆ operator*() [2/7]

◆ operator<<() [1/3]

◆ operator>>()

◆ operator-() [1/2]

◆ operator-() [2/2]

◆ sum()

◆ operator<<() [2/3]

◆ operator<<() [3/3]

◆ operator*() [3/7]

◆ operator*() [4/7]

◆ operator*() [5/7]

◆ operator*() [6/7]

◆ operator*() [7/7]

◆ operator/() [1/2]

◆ operator/() [2/2]

◆ operator+() [1/2]

◆ operator+() [2/2]

◆ schur_product() [1/2]

What's a `Point<dim>` and what is a `Tensor<1,dim>`?