tatooine Namespace Reference

Namespaces
namespace	algorithm
namespace	amira
namespace	analytical
namespace	blas
namespace	cgal
namespace	color_scales
namespace	constants
namespace	delaunator
namespace	detail
namespace	einstein_notation
namespace	execution_policy
namespace	flowexplorer
namespace	geometry
namespace	gl
namespace	gpu
namespace	hdf5
namespace	interpolation
namespace	lapack
namespace	marchingcubes_lookup
namespace	netcdf
namespace	numerical
namespace	ode
namespace	polymorphic
namespace	random
namespace	reflection
namespace	rendering
namespace	symbolic
namespace	tag
namespace	template_helper
namespace	variadic
namespace	vtk

Classes
class	aligned
struct	are_arithmetic_complex_or_symbolic
struct	are_arithmetic_or_symbolic
struct	are_equality_comparable_impl
struct	are_equality_comparable_impl< T, S, void_t< decltype(std::declval< T >()==std::declval< S >())> >
struct	are_symbolic
struct	are_symbolic< T >
struct	are_symbolic< T0, T1, Ts... >
struct	are_symbolic<>
struct	arrow_proxy
	from https://quuxplusone.github.io/blog/2019/02/06/arrow-proxy/ More...
struct	autonomous_particle
struct	autonomous_particle_flowmap_discretization
struct	axis_aligned_bounding_box
struct	backward_tag
struct	base_holder
struct	base_tensor
struct	base_uniform_tree_hierarchy
	For octrees and quadtrees. More...
struct	binary_operation_field
struct	c_str_assembler
class	cache
struct	cartesian_axis_label_impl
struct	cartesian_axis_label_impl< 0 >
struct	cartesian_axis_label_impl< 1 >
struct	cartesian_axis_label_impl< 2 >
struct	cast_tensor_real
struct	celltree
struct	chunked_multidim_array
struct	clonable
struct	common_type_impl
struct	common_type_impl< T >
struct	common_type_impl< T1, T2, R... >
struct	const_imag_complex_tensor
struct	const_real_complex_tensor
struct	constant_vectorfield
	constant vectorfield More...
struct	count_types_impl
struct	count_types_impl< type_list_impl< UniqueTypes... >, Ts... >
struct	count_types_impl< type_set_impl< UniqueTypes... >, Ts... >
struct	crtp
class	curvature_field
class	curvature_field< V, 2 >
class	curvature_field< V, 3 >
struct	curve_to_streamline
struct	deque_property
struct	diag_dynamic_tensor
struct	diag_static_tensor
struct	differentiated_field
struct	differentiated_field< analytical::numerical::autonomous_particles_test< Real >, 2, 2 >
struct	differentiated_field< analytical::numerical::center< Real > >
struct	differentiated_field< analytical::numerical::frankes_test< Real > >
struct	differentiated_field< analytical::numerical::saddle< Real, 2 > >
struct	differentiated_flowmap
struct	differentiated_flowmap< analytical::numerical::center< Real > >
struct	differentiated_flowmap< analytical::numerical::saddle_flowmap< Real > >
struct	dynamic_multidim
class	dynamic_multidim_array
class	dynamic_multidim_size
struct	edgeset
struct	field
struct	forward_tag
struct	front_evolving_streamsurface_discretization
struct	ftle_field
struct	get_impl
class	grid
struct	grid_edge
class	grid_edge_container
class	grid_edge_iterator
struct	grid_vertex_edges
struct	grid_vertex_neighbors
struct	handle
struct	has_face_at_method_impl
struct	has_face_at_method_impl< T, std::void_t< decltype(std::declval< T >().face_at(size_t{}))> >
struct	has_fields_available_method_impl
struct	has_fields_available_method_impl< T, decltype(std::declval< T >().fields_available)>
struct	has_tetrahedron_at_method_impl
struct	has_tetrahedron_at_method_impl< T, std::void_t< decltype(std::declval< T >().tetrahedron_at(size_t{}))> >
struct	heap
class	helicity_field
struct	holder
struct	hultquist_discretization
struct	imag_complex_tensor
struct	indicator_msg
struct	infer_difference_type_impl
	Base case. More...
struct	infer_difference_type_impl< Iter >
	Case when Iter provides a distance_to More...
struct	infer_value_type_impl
	Just use the return type of derefence operator. More...
struct	infer_value_type_impl< T >
	If value_type is explicitly given use this typedef. More...
struct	internal_data_type
struct	intersection
struct	is_array_impl
struct	is_array_impl< std::array< T, N > >
struct	is_cacheable_impl
struct	is_cacheable_impl< T, std::void_t< decltype(&T::use_caching)> >
struct	is_celltree_impl
struct	is_celltree_impl< celltree< Mesh > >
struct	is_complex_impl
struct	is_complex_impl< std::complex< T > >
struct	is_dereferencable_impl
struct	is_dereferencable_impl< T * >
struct	is_dereferencable_impl< T, void_t< decltype(*std::declval< T >())> >
struct	is_differentiated_flowmap_impl
struct	is_differentiated_flowmap_impl< differentiated_flowmap< Flowmap > >
struct	is_differentiated_flowmap_impl< numerically_differentiated_flowmap< Flowmap > >
struct	is_edgeset_impl
struct	is_edgeset_impl< edgeset< Real, NumDimensions > >
struct	is_field< symbolic::doublegyre< Real > >
struct	is_indexable_impl
struct	is_indexable_impl< T, void_t< decltype(std::declval< T >().at(size_t{})), decltype(std::declval< T >()[size_t{}])> >
struct	is_invocable_with_n_floating_points_impl
struct	is_invocable_with_n_integrals_impl
struct	is_invocable_with_n_types_impl
struct	is_kdtree_impl
struct	is_kdtree_impl< kdtree< Mesh > >
struct	is_line_impl
	All types that are no lines. More...
struct	is_line_impl< line< Real, N > >
	All types are no lines. More...
struct	is_linspace_impl
struct	is_linspace_impl< linspace< Real > >
struct	is_matrixfield_impl
struct	is_matrixfield_impl< T >
struct	is_numerical_flowmap_impl
struct	is_numerical_flowmap_impl< numerical_flowmap< V, ODESolver, InterpolationKernel > >
struct	is_pair_impl
struct	is_pair_impl< std::pair< First, Second > >
struct	is_polynomial_impl
struct	is_polynomial_impl< polynomial< Real, Degree > >
struct	is_post_decrementable_impl
struct	is_post_decrementable_impl< T * >
struct	is_post_decrementable_impl< T const * >
struct	is_post_decrementable_impl< T, void_t< decltype(std::declval< T >() --)> >
struct	is_post_incrementable_impl
struct	is_post_incrementable_impl< T * >
struct	is_post_incrementable_impl< T const * >
struct	is_post_incrementable_impl< T, void_t< decltype(std::declval< T >()++)> >
struct	is_pre_decrementable_impl
struct	is_pre_decrementable_impl< T * >
struct	is_pre_decrementable_impl< T const * >
struct	is_pre_decrementable_impl< T, void_t< decltype(--std::declval< T >())> >
struct	is_pre_incrementable_impl
struct	is_pre_incrementable_impl< T * >
struct	is_pre_incrementable_impl< T const * >
struct	is_pre_incrementable_impl< T, void_t< decltype(++std::declval< T >())> >
struct	is_random_number_generator_impl
struct	is_random_number_generator_impl< random::normal< ValueType, Engine > >
struct	is_random_number_generator_impl< random::uniform< ValueType, Engine > >
struct	is_range_impl
struct	is_range_impl< T, void_t< decltype(std::declval< T >().begin()), decltype(std::declval< T >().end())> >
struct	is_same_impl
struct	is_same_impl< T0 >
struct	is_same_impl< T0, T1 >
struct	is_same_impl< T0, T1, T2, Ts... >
struct	is_scalarfield_impl
struct	is_scalarfield_impl< T >
struct	is_square_impl
struct	is_square_impl< Tensor, 0 >
struct	is_square_impl< Tensor, 1 >
struct	is_symbolic
struct	is_symbolic_field_impl
struct	is_symbolic_field_impl< field< symbolic::field< Real, N, TensorDims... >, Real, N, TensorDims... > >
struct	is_symbolic_field_impl< symbolic::field< Real, N, TensorDims... > >
struct	is_uniform_tree_hierarchy_impl
struct	is_uniform_tree_hierarchy_impl< uniform_tree_hierarchy< Mesh > >
struct	is_unstructured_triangular_grid_impl
struct	is_unstructured_triangular_grid_impl< unstructured_triangular_grid< Real, NumDimensions > >
struct	is_vectorfield_impl
struct	is_vectorfield_impl< T >
class	iterator_facade
	C++20 implementation of an iterator facade. More...
struct	iterator_sentinel
struct	kdtree
class	lagrangian_Q_field
class	lambda2_field
struct	lambda_field
struct	lazy_reader
struct	line
struct	linspace
struct	mat
class	mesh
struct	multi_front_evolving_streamsurface_discretization
struct	naive_discretization
struct	nan_impl
struct	nan_impl< double >
struct	nan_impl< float >
struct	nan_impl< long double >
class	non_owning_multidim_array
struct	numerical_flowmap
struct	numerically_differentiated_field
struct	numerically_differentiated_flowmap
	Default differentiated flowmap uses central differences for differentiating. More...
struct	out_of_domain_error
struct	particle
struct	plane
struct	pointset
struct	polynomial
class	polynomial_line
struct	progress_indicator_wrapper
class	Q_field
struct	ray
struct	ray_intersectable
struct	rbc
struct	real_complex_tensor
class	rectilinear_grid
struct	regular_flowmap_discretization
	Samples a flow map by advecting particles from a uniform rectilinear grid. More...
struct	simulated_annealing_listener
struct	spacetime_splitted_vectorfield
struct	spacetime_vectorfield
struct	spacetime_vectorfield< symbolic::field< Real, N - 1 >, Real, N >
struct	stack
struct	staggered_flowmap_discretization
class	static_multidim_array
struct	static_multidim_iterator
struct	static_multidim_size
struct	steady_field
struct	streamsurface
struct	structured_grid
struct	subgrid
struct	tensor
struct	tensor< T >
struct	tensor_add_dimension_left_impl
struct	tensor_add_dimension_left_impl< NewLeftDim, double >
struct	tensor_add_dimension_left_impl< NewLeftDim, float >
struct	tensor_add_dimension_left_impl< NewLeftDim, long double >
struct	tensor_add_dimension_left_impl< NewLeftDim, mat< Real, M, N > >
struct	tensor_add_dimension_left_impl< NewLeftDim, tensor< Real, Dims... > >
struct	tensor_add_dimension_left_impl< NewLeftDim, vec< Real, N > >
struct	tensor_add_dimension_right_impl
struct	tensor_add_dimension_right_impl< NewRightDim, double >
struct	tensor_add_dimension_right_impl< NewRightDim, float >
struct	tensor_add_dimension_right_impl< NewRightDim, long double >
struct	tensor_add_dimension_right_impl< NewRightDim, mat< Real, M, N > >
struct	tensor_add_dimension_right_impl< NewRightDim, tensor< Real, Dims... > >
struct	tensor_add_dimension_right_impl< NewRightDim, vec< Real, N > >
struct	tensor_dimension_impl
struct	tensor_dimension_impl< std::array< T, N >, 0 >
struct	tensor_dimension_impl< T, I >
struct	tensor_dimension_impl< Tensor, I >
struct	tensor_dimensions_impl
struct	tensor_dimensions_impl< std::array< T, N > >
struct	tensor_dimensions_impl< Tensor >
struct	tensor_num_components_impl
struct	tensor_num_components_impl< std::array< T, N > >
struct	tensor_num_components_impl< T >
struct	tensor_num_components_impl< Tensor >
struct	tensor_rank_impl
struct	tensor_rank_impl< std::array< T, N > >
struct	tensor_rank_impl< Tensor >
struct	tensor_slice
struct	time_differentiated_field
class	time_stamp_queue
class	time_stamp_queue_components_type
struct	topological_skeleton
struct	topological_skeleton< Real, 2, Interpolator >
struct	transposed_dynamic_tensor
struct	transposed_static_tensor
struct	tuple
struct	tuple< Head >
struct	tuple< Head, Tail... >
struct	tuple_concat_types_impl
struct	tuple_concat_types_impl< tuple< TsTuple1... >, tuple< TsTuple2... > >
struct	type_counter_get_count_impl
struct	type_counter_get_count_impl< type_list_impl< HeadCounter, Counters... >, T >
struct	type_counter_get_count_impl< type_list_impl< type_number_pair< T, N >, Counters... >, T >
struct	type_counter_get_count_impl< type_list_impl<>, T >
struct	type_counter_get_count_impl< type_set_impl< HeadCounter, Counters... >, T >
struct	type_counter_get_count_impl< type_set_impl< type_number_pair< T, N >, Counters... >, T >
struct	type_counter_get_count_impl< type_set_impl<>, T >
struct	type_counter_increase_if_equal_impl
struct	type_counter_increase_if_equal_impl< type_number_pair< T, N >, OtherT >
struct	type_counter_increase_if_equal_impl< type_number_pair< T, N >, T >
struct	type_counter_insert_impl
struct	type_counter_insert_impl< type_list_impl< Counters... > >
struct	type_counter_insert_impl< type_list_impl< Counters... >, Head, Rest... >
struct	type_counter_insert_impl< type_set_impl< Counters... > >
struct	type_counter_insert_impl< type_set_impl< Counters... >, Head, Rest... >
struct	type_list_at_impl
	Access to the Ith element of TypeList. More...
struct	type_list_at_impl< type_list_impl< Front, Rest... >, 0 >
	Returns the front of a tatooine::type_list_impl with I = 0. More...
struct	type_list_at_impl< type_list_impl< Front, Rest... >, I >
	Recursive Stepping through all types of a list. More...
struct	type_list_at_impl< type_list_impl<>, I >
	Recursive Stepping through all types of a list. More...
struct	type_list_at_impl< type_set_impl< Types... >, I >
	Access to the Ith element of TypeList. More...
struct	type_list_back_impl
struct	type_list_back_impl< type_list_impl< Types... > >
struct	type_list_back_impl< type_list_impl<> >
struct	type_list_contains_impl
struct	type_list_contains_impl< type_list_impl< SetHead, SetRest... >, SetHead >
struct	type_list_contains_impl< type_list_impl< SetHead, SetRest... >, T >
struct	type_list_contains_impl< type_list_impl<>, T >
struct	type_list_contains_impl< type_set_impl< Ts... >, T >
struct	type_list_front_impl
struct	type_list_front_impl< type_list_impl< Types... > >
struct	type_list_front_impl< type_list_impl<> >
struct	type_list_impl
	An empty struct that holds types. More...
struct	type_list_impl<>
	An empty struct that holds types. More...
struct	type_list_out_of_bounds
struct	type_list_pop_back_impl
struct	type_list_pop_back_impl< type_list_impl< T >, TypesAccumulator... >
struct	type_list_pop_back_impl< type_list_impl< T0, T1, Rest... >, TypesAccumulator... >
struct	type_list_pop_back_impl< type_list_impl<>, TypesAccumulator... >
struct	type_list_pop_front_impl
struct	type_list_pop_front_impl< type_list_impl< Front, Back... > >
struct	type_list_pop_front_impl< type_list_impl<> >
struct	type_list_push_back_impl
struct	type_list_push_back_impl< type_list_impl< Types... >, NewBack >
struct	type_list_push_front_impl
struct	type_list_push_front_impl< type_list_impl< Types... >, NewFront >
struct	type_list_size_impl
	Size of a tatooine::type_list_impl. More...
struct	type_list_size_impl< type_list_impl< Types... > >
	Size of a tatooine::type_list_impl. More...
struct	type_list_size_impl< type_set_impl< Types... > >
	Size of a tatooine::type_set_impl. More...
struct	type_number_pair
struct	type_set_constructor
struct	type_set_constructor< type_list< Ts... > >
struct	type_set_constructor< TypeList, T, Ts... >
struct	type_set_impl
	Inherits from a type_list with only unique types. More...
struct	type_set_insert_impl
struct	type_set_insert_impl< type_list< SetHead, SetRest... >, NewType, TypesAccumulator... >
	Head and NewType are not equal -> continue iterating. More...
struct	type_set_insert_impl< type_list< SetHead, SetRest... >, SetHead, TypesAccumulator... >
	Head and NewType are equal -> do not insert and stop. More...
struct	type_set_insert_impl< type_list<>, NewType, TypesAccumulator... >
	type_set is empty -> insert new type into set More...
struct	type_set_insert_impl< type_set_impl< SetHead, SetRest... >, NewType, TypesAccumulator... >
	Head and NewType are not equal -> continue iterating. More...
struct	type_set_insert_impl< type_set_impl< SetHead, SetRest... >, SetHead, TypesAccumulator... >
	Head and NewType are equal -> do not insert and stop. More...
struct	type_set_insert_impl< type_set_impl<>, NewType, TypesAccumulator... >
struct	type_to_str_false_type
struct	typed_deque_property
struct	typed_vector_property
struct	unary_operation_field
struct	uniform_tree_hierarchy
	For octrees and quadtrees. More...
struct	uniform_tree_hierarchy< unstructured_simplicial_grid< Real, NumDims, SimplexDim > >
struct	unpack
struct	unpack< base_tensor< Tensor, Real, N > >
struct	unpack< const base_tensor< Tensor, Real, N > >
struct	unpack< const std::array< T, N > >
struct	unpack< const std::pair< A, B > >
struct	unpack< const std::tuple< Ts... > >
struct	unpack< const tensor< Real, N > >
struct	unpack< std::array< T, N > >
struct	unpack< std::pair< A, B > >
struct	unpack< std::tuple< Ts... > >
struct	unpack< tensor< Real, N > >
struct	unstructured_grid
struct	unstructured_simplicial_grid
struct	unstructured_triangular_grid
struct	value_type_impl
struct	value_type_impl< T >
struct	vec
struct	vector_property
class	vorticity_field
struct	x_fastest
struct	x_slowest

Concepts
concept	same_as
concept	either_of
concept	integral
concept	signed_integral
concept	unsigned_integral
concept	floating_point
concept	arithmetic
concept	arithmetic_or_complex
concept	convertible_to
concept	convertible_to_floating_point
concept	convertible_to_integral
concept	has_defined_real_type
concept	has_defined_iterator
concept	has_defined_this_type
concept	has_defined_parent_type
concept	has_defined_tensor_type
concept	has_defined_pos_type
concept	forward_iterator
concept	bidirectional_iterator
concept	range
concept	arithmetic_range
concept	integral_range
concept	floating_point_range
concept	range_of
concept	integral_pair
concept	integral_pair_range
concept	range_of_either
concept	indexable
concept	invocable
concept	regular_invocable
concept	has_static_num_dimensions_method
concept	has_static_rank_method
concept	invocable_with_integrals
concept	can_read
concept	has_real_type
concept	has_pos_type
concept	has_tensor_type
concept	has_num_dimensions
concept	for_loop_range_iteration
concept	for_loop_nested_index_iteration
concept	invocable_with_n_integrals
concept	invocable_with_n_floating_points
concept	implements_distance_to
concept	implements_decrement
concept	implements_dereference
concept	implements_increment
concept	implements_advance
concept	difference_type_arg
concept	implements_equal
concept	meets_random_access
concept	meets_bidirectional
	We meet bidirectional if we are random_access, OR we have .decrement()
concept	declares_single_pass
	Detect if the iterator declares itself to be a single-pass iterator.
concept	implements_sentinel_type
concept	iter_sentinel_arg
concept	implements_basic_iterator_facade
concept	derived_from_iterator_facade
concept	indicator_with_progress
concept	random_number_generator
concept	forward_or_backward_tag
concept	is_forward
concept	is_backward
concept	execution_policy_tag
concept	memory_location
concept	index_order
concept	general_tensor
concept	dynamic_tensor
concept	static_tensor
concept	static_vec
concept	static_mat
concept	fixed_size_tensor
concept	fixed_size_vec
concept	fixed_size_real_vec
concept	fixed_size_mat
concept	fixed_num_cols_mat
concept	fixed_num_rows_mat
concept	static_quadratic_tensor
concept	static_quadratic_mat
concept	fixed_size_quadratic_tensor
concept	fixed_size_quadratic_mat
concept	transposed_tensor
concept	diag_tensor
concept	range_of_lines
concept	split_behavior
concept	is_field
concept	weak_field_concept
concept	field_concept
concept	weak_flowmap_concept
concept	flowmap_concept

Typedefs
template<typename... Ts>
using	common_type = typename common_type_impl< Ts... >::type
template<typename F , typename... Args>
using	invoke_result = std::invoke_result_t< F, Args... >
template<typename Container , std::size_t I>
using	get = typename get_impl< Container, I >::type
template<typename T >
using	infer_value_type = typename infer_value_type_impl< T >::type
template<typename Iter >
using	infer_difference_type = typename infer_difference_type_impl< Iter >::type
template<size_t N>
using	Plane = plane< real_type, N >
using	plane2 = Plane< 2 >
using	plane3 = Plane< 3 >
using	plane4 = Plane< 4 >
using	plane5 = Plane< 5 >
using	plane6 = Plane< 6 >
using	plane7 = Plane< 7 >
using	plane8 = Plane< 8 >
using	plane9 = Plane< 9 >
using	plane10 = Plane< 10 >
template<typename Tuple1 , typename Tuple2 >
using	tuple_concat_types = typename tuple_concat_types_impl< Tuple1, Tuple2 >::type
template<typename Counter , typename T >
using	type_counter_increase_if_equal = typename type_counter_increase_if_equal_impl< Counter, T >::type
template<typename Counter , typename... Ts>
using	type_counter_insert = typename type_counter_insert_impl< Counter, Ts... >::type
template<typename... Ts>
using	count_types = typename count_types_impl< type_list< Ts... >, Ts... >::type
template<typename TypeList , std::size_t I>
using	type_list_at = typename type_list_at_impl< TypeList, I >::type
	Access to the Ith element of TypeList. More...
template<typename TypeList >
using	type_list_back = typename type_list_back_impl< TypeList >::type
template<typename TypeList >
using	type_list_front = typename type_list_front_impl< TypeList >::type
template<typename TypeList , typename NewBack >
using	type_list_push_back = typename type_list_push_back_impl< TypeList, NewBack >::type
template<typename TypeList , typename NewFront >
using	type_list_push_front = typename type_list_push_front_impl< TypeList, NewFront >::type
template<typename TypeList >
using	type_list_pop_back = typename type_list_pop_back_impl< TypeList >::type
template<typename TypeList >
using	type_list_pop_front = typename type_list_pop_front_impl< TypeList >::type
template<typename... Ts>
using	type_list = type_list_impl< Ts... >
	Constructor for tatooine::type_list_impl. More...
template<typename TypeList , typename NewType >
using	type_set_insert = typename type_set_insert_impl< TypeList, NewType >::type
template<typename... Ts>
using	type_set = typename type_set_constructor< type_list<>, Ts... >::type
template<typename T >
using	value_type = typename value_type_impl< T >::type
template<typename T >
using	internal_data_type_t = typename internal_data_type< T >::type
template<typename T , typename Ret , typename ... Args>
using	const_method_ptr = Ret(T::*)(Args...) const
template<typename T , typename Ret , typename ... Args>
using	non_const_method_ptr = Ret(T::*)(Args...)
template<typename... >
using	void_t = void
template<std::size_t M, std::size_t N>
using	Mat = mat< real_number, M, N >
template<std::size_t M, std::size_t N>
using	MatD = mat< double, M, N >
template<std::size_t M, std::size_t N>
using	MatF = mat< float, M, N >
template<typename T >
using	Mat22 = mat< T, 2, 2 >
template<typename T >
using	Mat23 = mat< T, 2, 3 >
template<typename T >
using	Mat24 = mat< T, 2, 4 >
template<typename T >
using	Mat25 = mat< T, 2, 5 >
template<typename T >
using	Mat26 = mat< T, 2, 6 >
template<typename T >
using	Mat27 = mat< T, 2, 7 >
template<typename T >
using	Mat28 = mat< T, 2, 8 >
template<typename T >
using	Mat29 = mat< T, 2, 9 >
template<typename T >
using	Mat32 = mat< T, 3, 2 >
template<typename T >
using	Mat33 = mat< T, 3, 3 >
template<typename T >
using	Mat34 = mat< T, 3, 4 >
template<typename T >
using	Mat35 = mat< T, 3, 5 >
template<typename T >
using	Mat36 = mat< T, 3, 6 >
template<typename T >
using	Mat37 = mat< T, 3, 7 >
template<typename T >
using	Mat38 = mat< T, 3, 8 >
template<typename T >
using	Mat39 = mat< T, 3, 9 >
template<typename T >
using	Mat42 = mat< T, 4, 2 >
template<typename T >
using	Mat43 = mat< T, 4, 3 >
template<typename T >
using	Mat44 = mat< T, 4, 4 >
template<typename T >
using	Mat45 = mat< T, 4, 5 >
template<typename T >
using	Mat46 = mat< T, 4, 6 >
template<typename T >
using	Mat47 = mat< T, 4, 7 >
template<typename T >
using	Mat48 = mat< T, 4, 8 >
template<typename T >
using	Mat49 = mat< T, 4, 9 >
template<typename T >
using	Mat52 = mat< T, 5, 2 >
template<typename T >
using	Mat53 = mat< T, 5, 3 >
template<typename T >
using	Mat54 = mat< T, 5, 4 >
template<typename T >
using	Mat55 = mat< T, 5, 5 >
template<typename T >
using	Mat56 = mat< T, 5, 6 >
template<typename T >
using	Mat57 = mat< T, 5, 7 >
template<typename T >
using	Mat58 = mat< T, 5, 8 >
template<typename T >
using	Mat59 = mat< T, 5, 9 >
template<typename T >
using	Mat62 = mat< T, 6, 2 >
template<typename T >
using	Mat63 = mat< T, 6, 3 >
template<typename T >
using	Mat64 = mat< T, 6, 4 >
template<typename T >
using	Mat65 = mat< T, 6, 5 >
template<typename T >
using	Mat66 = mat< T, 6, 6 >
template<typename T >
using	Mat67 = mat< T, 6, 7 >
template<typename T >
using	Mat68 = mat< T, 6, 8 >
template<typename T >
using	Mat69 = mat< T, 6, 9 >
template<typename T >
using	Mat72 = mat< T, 7, 2 >
template<typename T >
using	Mat73 = mat< T, 7, 3 >
template<typename T >
using	Mat74 = mat< T, 7, 4 >
template<typename T >
using	Mat75 = mat< T, 7, 5 >
template<typename T >
using	Mat76 = mat< T, 7, 6 >
template<typename T >
using	Mat77 = mat< T, 7, 7 >
template<typename T >
using	Mat78 = mat< T, 7, 8 >
template<typename T >
using	Mat79 = mat< T, 7, 9 >
template<typename T >
using	Mat82 = mat< T, 8, 2 >
template<typename T >
using	Mat83 = mat< T, 8, 3 >
template<typename T >
using	Mat84 = mat< T, 8, 4 >
template<typename T >
using	Mat85 = mat< T, 8, 5 >
template<typename T >
using	Mat86 = mat< T, 8, 6 >
template<typename T >
using	Mat87 = mat< T, 8, 7 >
template<typename T >
using	Mat88 = mat< T, 8, 8 >
template<typename T >
using	Mat89 = mat< T, 8, 9 >
template<typename T >
using	Mat92 = mat< T, 9, 2 >
template<typename T >
using	Mat93 = mat< T, 9, 3 >
template<typename T >
using	Mat94 = mat< T, 9, 4 >
template<typename T >
using	Mat95 = mat< T, 9, 5 >
template<typename T >
using	Mat96 = mat< T, 9, 6 >
template<typename T >
using	Mat97 = mat< T, 9, 7 >
template<typename T >
using	Mat98 = mat< T, 9, 8 >
template<typename T >
using	Mat99 = mat< T, 9, 9 >
template<typename T >
using	Mat2 = Mat22< T >
template<typename T >
using	Mat3 = Mat33< T >
template<typename T >
using	Mat4 = Mat44< T >
template<typename T >
using	Mat5 = Mat55< T >
template<typename T >
using	Mat6 = Mat66< T >
template<typename T >
using	Mat7 = Mat77< T >
template<typename T >
using	Mat8 = Mat88< T >
template<typename T >
using	Mat9 = Mat99< T >
using	mat22 = Mat< 2, 2 >
using	mat23 = Mat< 2, 3 >
using	mat24 = Mat< 2, 4 >
using	mat25 = Mat< 2, 5 >
using	mat26 = Mat< 2, 6 >
using	mat27 = Mat< 2, 7 >
using	mat28 = Mat< 2, 8 >
using	mat29 = Mat< 2, 9 >
using	mat32 = Mat< 3, 2 >
using	mat33 = Mat< 3, 3 >
using	mat34 = Mat< 3, 4 >
using	mat35 = Mat< 3, 5 >
using	mat36 = Mat< 3, 6 >
using	mat37 = Mat< 3, 7 >
using	mat38 = Mat< 3, 8 >
using	mat39 = Mat< 3, 9 >
using	mat42 = Mat< 4, 2 >
using	mat43 = Mat< 4, 3 >
using	mat44 = Mat< 4, 4 >
using	mat45 = Mat< 4, 5 >
using	mat46 = Mat< 4, 6 >
using	mat47 = Mat< 4, 7 >
using	mat48 = Mat< 4, 8 >
using	mat49 = Mat< 4, 9 >
using	mat52 = Mat< 5, 2 >
using	mat53 = Mat< 5, 3 >
using	mat54 = Mat< 5, 4 >
using	mat55 = Mat< 5, 5 >
using	mat56 = Mat< 5, 6 >
using	mat57 = Mat< 5, 7 >
using	mat58 = Mat< 5, 8 >
using	mat59 = Mat< 5, 9 >
using	mat62 = Mat< 6, 2 >
using	mat63 = Mat< 6, 3 >
using	mat64 = Mat< 6, 4 >
using	mat65 = Mat< 6, 5 >
using	mat66 = Mat< 6, 6 >
using	mat67 = Mat< 6, 7 >
using	mat68 = Mat< 6, 8 >
using	mat69 = Mat< 6, 9 >
using	mat72 = Mat< 7, 2 >
using	mat73 = Mat< 7, 3 >
using	mat74 = Mat< 7, 4 >
using	mat75 = Mat< 7, 5 >
using	mat76 = Mat< 7, 6 >
using	mat77 = Mat< 7, 7 >
using	mat78 = Mat< 7, 8 >
using	mat79 = Mat< 7, 9 >
using	mat82 = Mat< 8, 2 >
using	mat83 = Mat< 8, 3 >
using	mat84 = Mat< 8, 4 >
using	mat85 = Mat< 8, 5 >
using	mat86 = Mat< 8, 6 >
using	mat87 = Mat< 8, 7 >
using	mat88 = Mat< 8, 8 >
using	mat89 = Mat< 8, 9 >
using	mat92 = Mat< 9, 2 >
using	mat93 = Mat< 9, 3 >
using	mat94 = Mat< 9, 4 >
using	mat95 = Mat< 9, 5 >
using	mat96 = Mat< 9, 6 >
using	mat97 = Mat< 9, 7 >
using	mat98 = Mat< 9, 8 >
using	mat99 = Mat< 9, 9 >
using	mat2 = mat22
using	mat3 = mat33
using	mat4 = mat44
using	mat5 = mat55
using	mat6 = mat66
using	mat7 = mat77
using	mat8 = mat88
using	mat9 = mat99
using	mat22f = MatF< 2, 2 >
using	mat23f = MatF< 2, 3 >
using	mat24f = MatF< 2, 4 >
using	mat25f = MatF< 2, 5 >
using	mat26f = MatF< 2, 6 >
using	mat27f = MatF< 2, 7 >
using	mat28f = MatF< 2, 8 >
using	mat29f = MatF< 2, 9 >
using	mat32f = MatF< 3, 2 >
using	mat33f = MatF< 3, 3 >
using	mat34f = MatF< 3, 4 >
using	mat35f = MatF< 3, 5 >
using	mat36f = MatF< 3, 6 >
using	mat37f = MatF< 3, 7 >
using	mat38f = MatF< 3, 8 >
using	mat39f = MatF< 3, 9 >
using	mat42f = MatF< 4, 2 >
using	mat43f = MatF< 4, 3 >
using	mat44f = MatF< 4, 4 >
using	mat45f = MatF< 4, 5 >
using	mat46f = MatF< 4, 6 >
using	mat47f = MatF< 4, 7 >
using	mat48f = MatF< 4, 8 >
using	mat49f = MatF< 4, 9 >
using	mat52f = MatF< 5, 2 >
using	mat53f = MatF< 5, 3 >
using	mat54f = MatF< 5, 4 >
using	mat55f = MatF< 5, 5 >
using	mat56f = MatF< 5, 6 >
using	mat57f = MatF< 5, 7 >
using	mat58f = MatF< 5, 8 >
using	mat59f = MatF< 5, 9 >
using	mat62f = MatF< 6, 2 >
using	mat63f = MatF< 6, 3 >
using	mat64f = MatF< 6, 4 >
using	mat65f = MatF< 6, 5 >
using	mat66f = MatF< 6, 6 >
using	mat67f = MatF< 6, 7 >
using	mat68f = MatF< 6, 8 >
using	mat69f = MatF< 6, 9 >
using	mat72f = MatF< 7, 2 >
using	mat73f = MatF< 7, 3 >
using	mat74f = MatF< 7, 4 >
using	mat75f = MatF< 7, 5 >
using	mat76f = MatF< 7, 6 >
using	mat77f = MatF< 7, 7 >
using	mat78f = MatF< 7, 8 >
using	mat79f = MatF< 7, 9 >
using	mat82f = MatF< 8, 2 >
using	mat83f = MatF< 8, 3 >
using	mat84f = MatF< 8, 4 >
using	mat85f = MatF< 8, 5 >
using	mat86f = MatF< 8, 6 >
using	mat87f = MatF< 8, 7 >
using	mat88f = MatF< 8, 8 >
using	mat89f = MatF< 8, 9 >
using	mat92f = MatF< 9, 2 >
using	mat93f = MatF< 9, 3 >
using	mat94f = MatF< 9, 4 >
using	mat95f = MatF< 9, 5 >
using	mat96f = MatF< 9, 6 >
using	mat97f = MatF< 9, 7 >
using	mat98f = MatF< 9, 8 >
using	mat99f = MatF< 9, 9 >
using	mat2f = mat22f
using	mat3f = mat33f
using	mat4f = mat44f
using	mat5f = mat55f
using	mat6f = mat66f
using	mat7f = mat77f
using	mat8f = mat88f
using	mat9f = mat99f
using	mat22d = MatD< 2, 2 >
using	mat23d = MatD< 2, 3 >
using	mat24d = MatD< 2, 4 >
using	mat25d = MatD< 2, 5 >
using	mat26d = MatD< 2, 6 >
using	mat27d = MatD< 2, 7 >
using	mat28d = MatD< 2, 8 >
using	mat29d = MatD< 2, 9 >
using	mat32d = MatD< 3, 2 >
using	mat33d = MatD< 3, 3 >
using	mat34d = MatD< 3, 4 >
using	mat35d = MatD< 3, 5 >
using	mat36d = MatD< 3, 6 >
using	mat37d = MatD< 3, 7 >
using	mat38d = MatD< 3, 8 >
using	mat39d = MatD< 3, 9 >
using	mat42d = MatD< 4, 2 >
using	mat43d = MatD< 4, 3 >
using	mat44d = MatD< 4, 4 >
using	mat45d = MatD< 4, 5 >
using	mat46d = MatD< 4, 6 >
using	mat47d = MatD< 4, 7 >
using	mat48d = MatD< 4, 8 >
using	mat49d = MatD< 4, 9 >
using	mat52d = MatD< 5, 2 >
using	mat53d = MatD< 5, 3 >
using	mat54d = MatD< 5, 4 >
using	mat55d = MatD< 5, 5 >
using	mat56d = MatD< 5, 6 >
using	mat57d = MatD< 5, 7 >
using	mat58d = MatD< 5, 8 >
using	mat59d = MatD< 5, 9 >
using	mat62d = MatD< 6, 2 >
using	mat63d = MatD< 6, 3 >
using	mat64d = MatD< 6, 4 >
using	mat65d = MatD< 6, 5 >
using	mat66d = MatD< 6, 6 >
using	mat67d = MatD< 6, 7 >
using	mat68d = MatD< 6, 8 >
using	mat69d = MatD< 6, 9 >
using	mat72d = MatD< 7, 2 >
using	mat73d = MatD< 7, 3 >
using	mat74d = MatD< 7, 4 >
using	mat75d = MatD< 7, 5 >
using	mat76d = MatD< 7, 6 >
using	mat77d = MatD< 7, 7 >
using	mat78d = MatD< 7, 8 >
using	mat79d = MatD< 7, 9 >
using	mat82d = MatD< 8, 2 >
using	mat83d = MatD< 8, 3 >
using	mat84d = MatD< 8, 4 >
using	mat85d = MatD< 8, 5 >
using	mat86d = MatD< 8, 6 >
using	mat87d = MatD< 8, 7 >
using	mat88d = MatD< 8, 8 >
using	mat89d = MatD< 8, 9 >
using	mat92d = MatD< 9, 2 >
using	mat93d = MatD< 9, 3 >
using	mat94d = MatD< 9, 4 >
using	mat95d = MatD< 9, 5 >
using	mat96d = MatD< 9, 6 >
using	mat97d = MatD< 9, 7 >
using	mat98d = MatD< 9, 8 >
using	mat99d = MatD< 9, 9 >
using	mat2d = mat22d
using	mat3d = mat33d
using	mat4d = mat44d
using	mat5d = mat55d
using	mat6d = mat66d
using	mat7d = mat77d
using	mat8d = mat88d
using	mat9d = mat99d
template<typename T , std::size_t M, std::size_t N>
using	complex_mat = mat< std::complex< T >, M, N >
template<std::size_t M, std::size_t N>
using	ComplexMat = complex_mat< real_number, M, N >
template<std::size_t M, std::size_t N>
using	ComplexMatD = complex_mat< double, M, N >
template<std::size_t M, std::size_t N>
using	ComplexMatF = complex_mat< float, M, N >
using	complex_mat22 = ComplexMat< 2, 2 >
using	complex_mat23 = ComplexMat< 2, 3 >
using	complex_mat24 = ComplexMat< 2, 4 >
using	complex_mat25 = ComplexMat< 2, 5 >
using	complex_mat26 = ComplexMat< 2, 6 >
using	complex_mat27 = ComplexMat< 2, 7 >
using	complex_mat28 = ComplexMat< 2, 8 >
using	complex_mat29 = ComplexMat< 2, 9 >
using	complex_mat32 = ComplexMat< 3, 2 >
using	complex_mat33 = ComplexMat< 3, 3 >
using	complex_mat34 = ComplexMat< 3, 4 >
using	complex_mat35 = ComplexMat< 3, 5 >
using	complex_mat36 = ComplexMat< 3, 6 >
using	complex_mat37 = ComplexMat< 3, 7 >
using	complex_mat38 = ComplexMat< 3, 8 >
using	complex_mat39 = ComplexMat< 3, 9 >
using	complex_mat42 = ComplexMat< 4, 2 >
using	complex_mat43 = ComplexMat< 4, 3 >
using	complex_mat44 = ComplexMat< 4, 4 >
using	complex_mat45 = ComplexMat< 4, 5 >
using	complex_mat46 = ComplexMat< 4, 6 >
using	complex_mat47 = ComplexMat< 4, 7 >
using	complex_mat48 = ComplexMat< 4, 8 >
using	complex_mat49 = ComplexMat< 4, 9 >
using	complex_mat52 = ComplexMat< 5, 2 >
using	complex_mat53 = ComplexMat< 5, 3 >
using	complex_mat54 = ComplexMat< 5, 4 >
using	complex_mat55 = ComplexMat< 5, 5 >
using	complex_mat56 = ComplexMat< 5, 6 >
using	complex_mat57 = ComplexMat< 5, 7 >
using	complex_mat58 = ComplexMat< 5, 8 >
using	complex_mat59 = ComplexMat< 5, 9 >
using	complex_mat62 = ComplexMat< 6, 2 >
using	complex_mat63 = ComplexMat< 6, 3 >
using	complex_mat64 = ComplexMat< 6, 4 >
using	complex_mat65 = ComplexMat< 6, 5 >
using	complex_mat66 = ComplexMat< 6, 6 >
using	complex_mat67 = ComplexMat< 6, 7 >
using	complex_mat68 = ComplexMat< 6, 8 >
using	complex_mat69 = ComplexMat< 6, 9 >
using	complex_mat72 = ComplexMat< 7, 2 >
using	complex_mat73 = ComplexMat< 7, 3 >
using	complex_mat74 = ComplexMat< 7, 4 >
using	complex_mat75 = ComplexMat< 7, 5 >
using	complex_mat76 = ComplexMat< 7, 6 >
using	complex_mat77 = ComplexMat< 7, 7 >
using	complex_mat78 = ComplexMat< 7, 8 >
using	complex_mat79 = ComplexMat< 7, 9 >
using	complex_mat82 = ComplexMat< 8, 2 >
using	complex_mat83 = ComplexMat< 8, 3 >
using	complex_mat84 = ComplexMat< 8, 4 >
using	complex_mat85 = ComplexMat< 8, 5 >
using	complex_mat86 = ComplexMat< 8, 6 >
using	complex_mat87 = ComplexMat< 8, 7 >
using	complex_mat88 = ComplexMat< 8, 8 >
using	complex_mat89 = ComplexMat< 8, 9 >
using	complex_mat92 = ComplexMat< 9, 2 >
using	complex_mat93 = ComplexMat< 9, 3 >
using	complex_mat94 = ComplexMat< 9, 4 >
using	complex_mat95 = ComplexMat< 9, 5 >
using	complex_mat96 = ComplexMat< 9, 6 >
using	complex_mat97 = ComplexMat< 9, 7 >
using	complex_mat98 = ComplexMat< 9, 8 >
using	complex_mat99 = ComplexMat< 9, 9 >
using	complex_mat2 = complex_mat22
using	complex_mat3 = complex_mat33
using	complex_mat4 = complex_mat44
using	complex_mat5 = complex_mat55
using	complex_mat6 = complex_mat66
using	complex_mat7 = complex_mat77
using	complex_mat8 = complex_mat88
using	complex_mat9 = complex_mat99
using	complex_mat22f = ComplexMatF< 2, 2 >
using	complex_mat23f = ComplexMatF< 2, 3 >
using	complex_mat24f = ComplexMatF< 2, 4 >
using	complex_mat25f = ComplexMatF< 2, 5 >
using	complex_mat26f = ComplexMatF< 2, 6 >
using	complex_mat27f = ComplexMatF< 2, 7 >
using	complex_mat28f = ComplexMatF< 2, 8 >
using	complex_mat29f = ComplexMatF< 2, 9 >
using	complex_mat32f = ComplexMatF< 3, 2 >
using	complex_mat33f = ComplexMatF< 3, 3 >
using	complex_mat34f = ComplexMatF< 3, 4 >
using	complex_mat35f = ComplexMatF< 3, 5 >
using	complex_mat36f = ComplexMatF< 3, 6 >
using	complex_mat37f = ComplexMatF< 3, 7 >
using	complex_mat38f = ComplexMatF< 3, 8 >
using	complex_mat39f = ComplexMatF< 3, 9 >
using	complex_mat42f = ComplexMatF< 4, 2 >
using	complex_mat43f = ComplexMatF< 4, 3 >
using	complex_mat44f = ComplexMatF< 4, 4 >
using	complex_mat45f = ComplexMatF< 4, 5 >
using	complex_mat46f = ComplexMatF< 4, 6 >
using	complex_mat47f = ComplexMatF< 4, 7 >
using	complex_mat48f = ComplexMatF< 4, 8 >
using	complex_mat49f = ComplexMatF< 4, 9 >
using	complex_mat52f = ComplexMatF< 5, 2 >
using	complex_mat53f = ComplexMatF< 5, 3 >
using	complex_mat54f = ComplexMatF< 5, 4 >
using	complex_mat55f = ComplexMatF< 5, 5 >
using	complex_mat56f = ComplexMatF< 5, 6 >
using	complex_mat57f = ComplexMatF< 5, 7 >
using	complex_mat58f = ComplexMatF< 5, 8 >
using	complex_mat59f = ComplexMatF< 5, 9 >
using	complex_mat62f = ComplexMatF< 6, 2 >
using	complex_mat63f = ComplexMatF< 6, 3 >
using	complex_mat64f = ComplexMatF< 6, 4 >
using	complex_mat65f = ComplexMatF< 6, 5 >
using	complex_mat66f = ComplexMatF< 6, 6 >
using	complex_mat67f = ComplexMatF< 6, 7 >
using	complex_mat68f = ComplexMatF< 6, 8 >
using	complex_mat69f = ComplexMatF< 6, 9 >
using	complex_mat72f = ComplexMatF< 7, 2 >
using	complex_mat73f = ComplexMatF< 7, 3 >
using	complex_mat74f = ComplexMatF< 7, 4 >
using	complex_mat75f = ComplexMatF< 7, 5 >
using	complex_mat76f = ComplexMatF< 7, 6 >
using	complex_mat77f = ComplexMatF< 7, 7 >
using	complex_mat78f = ComplexMatF< 7, 8 >
using	complex_mat79f = ComplexMatF< 7, 9 >
using	complex_mat82f = ComplexMatF< 8, 2 >
using	complex_mat83f = ComplexMatF< 8, 3 >
using	complex_mat84f = ComplexMatF< 8, 4 >
using	complex_mat85f = ComplexMatF< 8, 5 >
using	complex_mat86f = ComplexMatF< 8, 6 >
using	complex_mat87f = ComplexMatF< 8, 7 >
using	complex_mat88f = ComplexMatF< 8, 8 >
using	complex_mat89f = ComplexMatF< 8, 9 >
using	complex_mat92f = ComplexMatF< 9, 2 >
using	complex_mat93f = ComplexMatF< 9, 3 >
using	complex_mat94f = ComplexMatF< 9, 4 >
using	complex_mat95f = ComplexMatF< 9, 5 >
using	complex_mat96f = ComplexMatF< 9, 6 >
using	complex_mat97f = ComplexMatF< 9, 7 >
using	complex_mat98f = ComplexMatF< 9, 8 >
using	complex_mat99f = ComplexMatF< 9, 9 >
using	complex_mat2f = complex_mat22f
using	complex_mat3f = complex_mat33f
using	complex_mat4f = complex_mat44f
using	complex_mat5f = complex_mat55f
using	complex_mat6f = complex_mat66f
using	complex_mat7f = complex_mat77f
using	complex_mat8f = complex_mat88f
using	complex_mat9f = complex_mat99f
using	complex_mat22d = ComplexMatD< 2, 2 >
using	complex_mat23d = ComplexMatD< 2, 3 >
using	complex_mat24d = ComplexMatD< 2, 4 >
using	complex_mat25d = ComplexMatD< 2, 5 >
using	complex_mat26d = ComplexMatD< 2, 6 >
using	complex_mat27d = ComplexMatD< 2, 7 >
using	complex_mat28d = ComplexMatD< 2, 8 >
using	complex_mat29d = ComplexMatD< 2, 9 >
using	complex_mat32d = ComplexMatD< 3, 2 >
using	complex_mat33d = ComplexMatD< 3, 3 >
using	complex_mat34d = ComplexMatD< 3, 4 >
using	complex_mat35d = ComplexMatD< 3, 5 >
using	complex_mat36d = ComplexMatD< 3, 6 >
using	complex_mat37d = ComplexMatD< 3, 7 >
using	complex_mat38d = ComplexMatD< 3, 8 >
using	complex_mat39d = ComplexMatD< 3, 9 >
using	complex_mat42d = ComplexMatD< 4, 2 >
using	complex_mat43d = ComplexMatD< 4, 3 >
using	complex_mat44d = ComplexMatD< 4, 4 >
using	complex_mat45d = ComplexMatD< 4, 5 >
using	complex_mat46d = ComplexMatD< 4, 6 >
using	complex_mat47d = ComplexMatD< 4, 7 >
using	complex_mat48d = ComplexMatD< 4, 8 >
using	complex_mat49d = ComplexMatD< 4, 9 >
using	complex_mat52d = ComplexMatD< 5, 2 >
using	complex_mat53d = ComplexMatD< 5, 3 >
using	complex_mat54d = ComplexMatD< 5, 4 >
using	complex_mat55d = ComplexMatD< 5, 5 >
using	complex_mat56d = ComplexMatD< 5, 6 >
using	complex_mat57d = ComplexMatD< 5, 7 >
using	complex_mat58d = ComplexMatD< 5, 8 >
using	complex_mat59d = ComplexMatD< 5, 9 >
using	complex_mat62d = ComplexMatD< 6, 2 >
using	complex_mat63d = ComplexMatD< 6, 3 >
using	complex_mat64d = ComplexMatD< 6, 4 >
using	complex_mat65d = ComplexMatD< 6, 5 >
using	complex_mat66d = ComplexMatD< 6, 6 >
using	complex_mat67d = ComplexMatD< 6, 7 >
using	complex_mat68d = ComplexMatD< 6, 8 >
using	complex_mat69d = ComplexMatD< 6, 9 >
using	complex_mat72d = ComplexMatD< 7, 2 >
using	complex_mat73d = ComplexMatD< 7, 3 >
using	complex_mat74d = ComplexMatD< 7, 4 >
using	complex_mat75d = ComplexMatD< 7, 5 >
using	complex_mat76d = ComplexMatD< 7, 6 >
using	complex_mat77d = ComplexMatD< 7, 7 >
using	complex_mat78d = ComplexMatD< 7, 8 >
using	complex_mat79d = ComplexMatD< 7, 9 >
using	complex_mat82d = ComplexMatD< 8, 2 >
using	complex_mat83d = ComplexMatD< 8, 3 >
using	complex_mat84d = ComplexMatD< 8, 4 >
using	complex_mat85d = ComplexMatD< 8, 5 >
using	complex_mat86d = ComplexMatD< 8, 6 >
using	complex_mat87d = ComplexMatD< 8, 7 >
using	complex_mat88d = ComplexMatD< 8, 8 >
using	complex_mat89d = ComplexMatD< 8, 9 >
using	complex_mat92d = ComplexMatD< 9, 2 >
using	complex_mat93d = ComplexMatD< 9, 3 >
using	complex_mat94d = ComplexMatD< 9, 4 >
using	complex_mat95d = ComplexMatD< 9, 5 >
using	complex_mat96d = ComplexMatD< 9, 6 >
using	complex_mat97d = ComplexMatD< 9, 7 >
using	complex_mat98d = ComplexMatD< 9, 8 >
using	complex_mat99d = ComplexMatD< 9, 9 >
using	complex_mat2d = complex_mat22d
using	complex_mat3d = complex_mat33d
using	complex_mat4d = complex_mat44d
using	complex_mat5d = complex_mat55d
using	complex_mat6d = complex_mat66d
using	complex_mat7d = complex_mat77d
using	complex_mat8d = complex_mat88d
using	complex_mat9d = complex_mat99d
template<std::size_t... Dimensions>
using	Tensor = tensor< real_number, Dimensions... >
using	tensor222 = Tensor< 2, 2, 2 >
using	tensor333 = Tensor< 3, 3, 3 >
using	tensor444 = Tensor< 4, 4, 4 >
using	tensor2222 = Tensor< 2, 2, 2, 2 >
using	tensor3333 = Tensor< 3, 3, 3, 3 >
using	tensor4444 = Tensor< 4, 4, 4, 4 >
using	tensor22222 = Tensor< 2, 2, 2, 2, 2 >
using	tensor33333 = Tensor< 3, 3, 3, 3, 3 >
using	tensor44444 = Tensor< 4, 4, 4, 4, 4 >
using	tensor222222 = Tensor< 2, 2, 2, 2, 2, 2 >
using	tensor333333 = Tensor< 3, 3, 3, 3, 3, 3 >
using	tensor444444 = Tensor< 4, 4, 4, 4, 4, 4 >
template<typename CastedReal , typename Tensor >
using	cast_tensor_real_type = typename cast_tensor_real< CastedReal, Tensor >::type
template<std::size_t NewRightDim, typename Tensor >
using	tensor_add_dimension_right = typename tensor_add_dimension_right_impl< NewRightDim, Tensor >::type
template<std::size_t NewLeftDim, typename Tensor >
using	tensor_add_dimension_left = typename tensor_add_dimension_left_impl< NewLeftDim, Tensor >::type
template<std::size_t... Dims>
using	TensorF = tensor< float, Dims... >
template<std::size_t... Dims>
using	TensorD = tensor< double, Dims... >
template<std::size_t... Dims>
using	TensorI64 = tensor< std::int64_t, Dims... >
template<typename T , std::size_t... Dims>
using	complex_tensor = tensor< std::complex< T >, Dims... >
template<std::size_t ... Dims>
using	ComplexTensor = tensor< std::complex< real_number >, Dims... >
template<std::size_t ... Dims>
using	ComplexTensorD = tensor< std::complex< double >, Dims... >
template<std::size_t ... Dims>
using	ComplexTensorF = tensor< std::complex< float >, Dims... >
template<std::size_t N>
using	Vec = vec< real_number, N >
template<typename T >
using	Vec2 = vec< T, 2 >
template<typename T >
using	Vec3 = vec< T, 3 >
template<typename T >
using	Vec4 = vec< T, 4 >
template<typename T >
using	Vec5 = vec< T, 5 >
template<typename T >
using	Vec6 = vec< T, 6 >
template<typename T >
using	Vec7 = vec< T, 7 >
template<typename T >
using	Vec8 = vec< T, 8 >
template<typename T >
using	Vec9 = vec< T, 9 >
using	vec2 = Vec< 2 >
using	vec3 = Vec< 3 >
using	vec4 = Vec< 4 >
using	vec5 = Vec< 5 >
using	vec6 = Vec< 6 >
using	vec7 = Vec< 7 >
using	vec8 = Vec< 8 >
using	vec9 = Vec< 9 >
template<std::size_t N>
using	VecF = vec< float, N >
using	vec2f = VecF< 2 >
using	vec3f = VecF< 3 >
using	vec4f = VecF< 4 >
using	vec5f = VecF< 5 >
using	vec6f = VecF< 6 >
using	vec7f = VecF< 7 >
using	vec8f = VecF< 8 >
using	vec9f = VecF< 9 >
template<std::size_t N>
using	VecD = vec< double, N >
using	vec2d = VecD< 2 >
using	vec3d = VecD< 3 >
using	vec4d = VecD< 4 >
using	vec5d = VecD< 5 >
using	vec6d = VecD< 6 >
using	vec7d = VecD< 7 >
using	vec8d = VecD< 8 >
using	vec9d = VecD< 9 >
template<std::size_t N>
using	VecI = vec< int, N >
using	vec2i = VecI< 2 >
using	vec3i = VecI< 3 >
using	vec4i = VecI< 4 >
using	vec5i = VecI< 5 >
using	vec6i = VecI< 6 >
using	vec7i = VecI< 7 >
using	vec8i = VecI< 8 >
using	vec9i = VecI< 9 >
template<std::size_t N>
using	VecSizeT = vec< std::size_t, N >
using	vec2size_t = VecSizeT< 2 >
using	vec3size_t = VecSizeT< 3 >
using	vec4size_t = VecSizeT< 4 >
using	vec5size_t = VecSizeT< 5 >
using	vec6size_t = VecSizeT< 6 >
using	vec7size_t = VecSizeT< 7 >
using	vec8size_t = VecSizeT< 8 >
using	vec9size_t = VecSizeT< 9 >
template<std::size_t N>
using	VecUI16 = vec< std::uint16_t, N >
using	vec2ui16 = VecUI16< 2 >
using	vec3ui16 = VecUI16< 3 >
using	vec4ui16 = VecUI16< 4 >
using	vec5ui16 = VecUI16< 5 >
using	vec6ui16 = VecUI16< 6 >
using	vec7ui16 = VecUI16< 7 >
using	vec8ui16 = VecUI16< 8 >
using	vec9ui16 = VecUI16< 9 >
template<std::size_t N>
using	VecI16 = vec< std::int16_t, N >
using	vec2i16 = VecI16< 2 >
using	vec3i16 = VecI16< 3 >
using	vec4i16 = VecI16< 4 >
using	vec5i16 = VecI16< 5 >
using	vec6i16 = VecI16< 6 >
using	vec7i16 = VecI16< 7 >
using	vec8i16 = VecI16< 8 >
using	vec9i16 = VecI16< 9 >
template<std::size_t N>
using	VecUI32 = vec< std::uint32_t, N >
using	vec2ui32 = VecUI32< 2 >
using	vec3ui32 = VecUI32< 3 >
using	vec4ui32 = VecUI32< 4 >
using	vec5ui32 = VecUI32< 5 >
using	vec6ui32 = VecUI32< 6 >
using	vec7ui32 = VecUI32< 7 >
using	vec8ui32 = VecUI32< 8 >
using	vec9ui32 = VecUI32< 9 >
template<std::size_t N>
using	VecI32 = vec< std::int32_t, N >
using	vec2i32 = VecI32< 2 >
using	vec3i32 = VecI32< 3 >
using	vec4i32 = VecI32< 4 >
using	vec5i32 = VecI32< 5 >
using	vec6i32 = VecI32< 6 >
using	vec7i32 = VecI32< 7 >
using	vec8i32 = VecI32< 8 >
using	vec9i32 = VecI32< 9 >
template<std::size_t N>
using	VecUI64 = vec< std::uint64_t, N >
using	vec2ui64 = VecUI64< 2 >
using	vec3ui64 = VecUI64< 3 >
using	vec4ui64 = VecUI64< 4 >
using	vec5ui64 = VecUI64< 5 >
using	vec6ui64 = VecUI64< 6 >
using	vec7ui64 = VecUI64< 7 >
using	vec8ui64 = VecUI64< 8 >
using	vec9ui64 = VecUI64< 9 >
template<std::size_t N>
using	VecI64 = vec< std::int64_t, N >
using	vec2i64 = VecI64< 2 >
using	vec3i64 = VecI64< 3 >
using	vec4i64 = VecI64< 4 >
using	vec5i64 = VecI64< 5 >
using	vec6i64 = VecI64< 6 >
using	vec7i64 = VecI64< 7 >
using	vec8i64 = VecI64< 8 >
using	vec9i64 = VecI64< 9 >
template<typename T , std::size_t N>
using	complex_vec = vec< std::complex< T >, N >
template<std::size_t N>
using	ComplexVec = vec< std::complex< real_number >, N >
template<typename T >
using	ComplexVec2 = vec< std::complex< T >, 2 >
template<typename T >
using	ComplexVec3 = vec< std::complex< T >, 3 >
template<typename T >
using	ComplexVec4 = vec< std::complex< T >, 4 >
template<typename T >
using	ComplexVec5 = vec< std::complex< T >, 5 >
template<typename T >
using	ComplexVec6 = vec< std::complex< T >, 6 >
template<typename T >
using	ComplexVec7 = vec< std::complex< T >, 7 >
template<typename T >
using	ComplexVec8 = vec< std::complex< T >, 8 >
template<typename T >
using	ComplexVec9 = vec< std::complex< T >, 9 >
using	complex_vec2 = ComplexVec< 2 >
using	complex_vec3 = ComplexVec< 3 >
using	complex_vec4 = ComplexVec< 4 >
using	complex_vec5 = ComplexVec< 5 >
using	complex_vec6 = ComplexVec< 6 >
using	complex_vec7 = ComplexVec< 7 >
using	complex_vec8 = ComplexVec< 8 >
using	complex_vec9 = ComplexVec< 9 >
template<std::size_t N>
using	ComplexVecD = vec< std::complex< double >, N >
using	complex_vec2d = ComplexVecD< 2 >
using	complex_vec3d = ComplexVecD< 3 >
using	complex_vec4d = ComplexVecD< 4 >
using	complex_vec5d = ComplexVecD< 5 >
using	complex_vec6d = ComplexVecD< 6 >
using	complex_vec7d = ComplexVecD< 7 >
using	complex_vec8d = ComplexVecD< 8 >
using	complex_vec9d = ComplexVecD< 9 >
template<std::size_t N>
using	ComplexVecF = vec< std::complex< float >, N >
using	complex_vec2f = ComplexVecF< 2 >
using	complex_vec3f = ComplexVecF< 3 >
using	complex_vec4f = ComplexVecF< 4 >
using	complex_vec5f = ComplexVecF< 5 >
using	complex_vec6f = ComplexVecF< 6 >
using	complex_vec7f = ComplexVecF< 7 >
using	complex_vec8f = ComplexVecF< 8 >
using	complex_vec9f = ComplexVecF< 9 >
template<std::size_t NumDimensions>
using	AABB = axis_aligned_bounding_box< real_number, NumDimensions >
template<typename Real >
using	AABB2 = axis_aligned_bounding_box< Real, 2 >
template<typename Real >
using	AABB3 = axis_aligned_bounding_box< Real, 3 >
template<typename Real , std::size_t NumDimensions>
using	aabb = axis_aligned_bounding_box< Real, NumDimensions >
using	aabb2d = aabb< double, 2 >
using	aabb2f = aabb< float, 2 >
using	aabb2 = aabb< real_number, 2 >
using	aabb3d = aabb< double, 3 >
using	aabb3f = aabb< float, 3 >
using	aabb3 = aabb< real_number, 3 >
template<std::size_t NumDimensions>
using	Edgeset = edgeset< real_number, NumDimensions >
template<floating_point Real>
using	Edgeset2 = edgeset< Real, 2 >
template<floating_point Real>
using	Edgeset3 = edgeset< Real, 3 >
template<floating_point Real>
using	Edgeset4 = edgeset< Real, 4 >
template<floating_point Real>
using	Edgeset5 = edgeset< Real, 5 >
using	edgeset2 = Edgeset< 2 >
using	edgeset3 = Edgeset< 3 >
using	edgeset4 = Edgeset< 4 >
using	edgeset5 = Edgeset< 5 >
template<typename T >
using	Line2 = line< T, 2 >
template<typename T >
using	Line3 = line< T, 3 >
template<typename T >
using	Line4 = line< T, 4 >
template<typename T >
using	Line5 = line< T, 5 >
template<std::size_t NumDimensions>
using	Line = line< real_number, NumDimensions >
using	line2 = Line< 2 >
using	line3 = Line< 3 >
using	line4 = Line< 4 >
using	line5 = Line< 5 >
template<std::size_t NumDimensions>
using	Pointset = pointset< real_number, NumDimensions >
using	pointset2 = Pointset< 2 >
using	pointset3 = Pointset< 3 >
using	pointset4 = Pointset< 4 >
using	pointset5 = Pointset< 5 >
template<floating_point Real, std::size_t N>
using	uniform_rectilinear_grid = detail::rectilinear_grid::creator_t< linspace< Real >, N >
template<std::size_t N>
using	UniformRectilinearGrid = uniform_rectilinear_grid< real_number, N >
using	uniform_rectilinear_grid2 = UniformRectilinearGrid< 2 >
using	uniform_rectilinear_grid3 = UniformRectilinearGrid< 3 >
using	uniform_rectilinear_grid4 = UniformRectilinearGrid< 4 >
using	uniform_rectilinear_grid5 = UniformRectilinearGrid< 5 >
template<floating_point Real>
using	UniformRectilinearGrid2 = uniform_rectilinear_grid< Real, 2 >
template<floating_point Real>
using	UniformRectilinearGrid3 = uniform_rectilinear_grid< Real, 3 >
template<floating_point Real>
using	UniformRectilinearGrid4 = uniform_rectilinear_grid< Real, 4 >
template<floating_point Real>
using	UniformRectilinearGrid5 = uniform_rectilinear_grid< Real, 5 >
template<arithmetic Real, std::size_t N>
using	nonuniform_rectilinear_grid = detail::rectilinear_grid::creator_t< std::vector< Real >, N >
template<std::size_t N>
using	NonuniformRectilinearGrid = nonuniform_rectilinear_grid< real_number, N >
using	nonuniform_rectilinear_grid2 = NonuniformRectilinearGrid< 2 >
using	nonuniform_rectilinear_grid3 = NonuniformRectilinearGrid< 3 >
using	nonuniform_rectilinear_grid4 = NonuniformRectilinearGrid< 4 >
using	nonuniform_rectilinear_grid5 = NonuniformRectilinearGrid< 5 >
template<arithmetic Real, std::size_t... N>
using	static_nonuniform_rectilinear_grid = rectilinear_grid< std::array< Real, N >... >
template<std::size_t N>
using	StaticNonUniformGrid = static_nonuniform_rectilinear_grid< real_number, N >
using	static_nonuniform_rectilinear_grid2 = NonuniformRectilinearGrid< 2 >
using	static_nonuniform_rectilinear_grid3 = NonuniformRectilinearGrid< 3 >
using	static_nonuniform_rectilinear_grid4 = NonuniformRectilinearGrid< 4 >
using	static_nonuniform_rectilinear_grid5 = NonuniformRectilinearGrid< 5 >
template<std::size_t NumDimensions>
using	StructuredGrid = structured_grid< real_number, NumDimensions >
using	structured_grid2 = StructuredGrid< 2 >
using	structured_grid3 = StructuredGrid< 3 >
template<std::size_t NumDimensions>
using	UnstructuredGrid = unstructured_grid< real_type, NumDimensions >
template<std::size_t NumDimensions>
using	UnstructuredGridF = unstructured_grid< float, NumDimensions >
template<std::size_t NumDimensions>
using	UnstructuredGridD = unstructured_grid< double, NumDimensions >
using	unstructured_grid2 = UnstructuredGrid< 2 >
using	unstructured_grid2f = UnstructuredGridF< 2 >
using	unstructured_grid2d = UnstructuredGridD< 2 >
using	unstructured_grid3 = UnstructuredGrid< 3 >
using	unstructured_grid3f = UnstructuredGridF< 3 >
using	unstructured_grid3d = UnstructuredGridD< 3 >
template<typename Real , std::size_t N>
using	unstructured_tetrahedral_grid = unstructured_simplicial_grid< Real, N, 3 >
using	unstructured_tetrahedral_grid3 = unstructured_tetrahedral_grid< real_number, 3 >
using	unstructured_tetrahedral_grid4 = unstructured_tetrahedral_grid< real_number, 4 >
using	unstructured_tetrahedral_grid5 = unstructured_tetrahedral_grid< real_number, 5 >
using	unstructured_tetrahedral_grid6 = unstructured_tetrahedral_grid< real_number, 6 >
using	unstructured_tetrahedral_grid7 = unstructured_tetrahedral_grid< real_number, 7 >
template<std::size_t NumDimensions>
using	UnstructuredTriangularGrid = unstructured_triangular_grid< real_number, NumDimensions >
template<typename Real >
using	UnstructuredTriangularGrid2 = unstructured_triangular_grid< Real, 2 >
template<typename Real >
using	UnstructuredTriangularGrid3 = unstructured_triangular_grid< Real, 3 >
template<typename Real >
using	UnstructuredTriangularGrid4 = unstructured_triangular_grid< Real, 4 >
template<typename Real >
using	UnstructuredTriangularGrid5 = unstructured_triangular_grid< Real, 5 >
using	unstructured_triangular_grid2 = UnstructuredTriangularGrid< 2 >
using	unstructured_triangular_grid3 = UnstructuredTriangularGrid< 3 >
using	unstructured_triangular_grid4 = UnstructuredTriangularGrid< 4 >
using	unstructured_triangular_grid5 = UnstructuredTriangularGrid< 5 >
template<typename Real , std::size_t NumDimensions>
using	agranovsky_flowmap_discretization = staggered_flowmap_discretization< regular_flowmap_discretization< Real, NumDimensions > >
template<typename Real >
using	AgranovskyFlowmapDiscretization2 = agranovsky_flowmap_discretization< Real, 2 >
template<typename Real >
using	AgranovskyFlowmapDiscretization3 = agranovsky_flowmap_discretization< Real, 3 >
template<std::size_t NumDimensions>
using	AgranovskyFlowmapDiscretization = agranovsky_flowmap_discretization< real_number, NumDimensions >
using	agranovsky_flowmap_discretization2 = AgranovskyFlowmapDiscretization< 2 >
using	agranovsky_flowmap_discretization3 = AgranovskyFlowmapDiscretization< 3 >
template<std::size_t NumDimensions>
using	AutonomousParticle = autonomous_particle< real_number, NumDimensions >
template<floating_point Real>
using	AutonomousParticle2 = autonomous_particle< Real, 2 >
template<floating_point Real>
using	AutonomousParticle3 = autonomous_particle< Real, 3 >
using	autonomous_particle2 = AutonomousParticle< 2 >
using	autonomous_particle3 = AutonomousParticle< 3 >
template<std::size_t NumDimensions, typename SplitBehavior = typename autonomous_particle< real_number, NumDimensions>::split_behaviors::three_splits>
using	AutonomousParticleFlowmapDiscretization = autonomous_particle_flowmap_discretization< real_number, NumDimensions >
template<typename SplitBehavior = typename autonomous_particle< real_number, 2>::split_behaviors::three_splits>
using	autonomous_particle_flowmap_discretization2 = AutonomousParticleFlowmapDiscretization< 2, SplitBehavior >
template<typename SplitBehavior = typename autonomous_particle< real_number, 3>::split_behaviors::three_splits>
using	autonomous_particle_flowmap_discretization3 = AutonomousParticleFlowmapDiscretization< 3, SplitBehavior >
template<typename Real , std::size_t NumDimensions, typename SplitBehavior = typename autonomous_particle< real_number, NumDimensions>::split_behaviors::three_splits>
using	staggered_autonomous_particle_flowmap_discretization = staggered_flowmap_discretization< autonomous_particle_flowmap_discretization< Real, NumDimensions, SplitBehavior > >
template<std::size_t NumDimensions, typename SplitBehavior = typename autonomous_particle< real_number, NumDimensions>::split_behaviors::three_splits>
using	StaggeredAutonomousParticleFlowmapDiscretization = staggered_autonomous_particle_flowmap_discretization< real_number, NumDimensions, SplitBehavior >
template<typename SplitBehavior = typename autonomous_particle< real_number, 2>::split_behaviors::three_splits>
using	staggered_autonomous_particle_flowmap_discretization2 = StaggeredAutonomousParticleFlowmapDiscretization< 2, SplitBehavior >
template<typename SplitBehavior = typename autonomous_particle< real_number, 3>::split_behaviors::three_splits>
using	staggered_autonomous_particle_flowmap_discretization3 = StaggeredAutonomousParticleFlowmapDiscretization< 3, SplitBehavior >
template<typename Real , std::size_t NumDimensions, typename Tensor >
using	field_list = std::vector< std::unique_ptr< polymorphic::field< Real, NumDimensions, Tensor > > >
template<typename Real , std::size_t NumDimensions, std::size_t C = NumDimensions>
using	vectorfield_list = field_list< Real, NumDimensions, vec< Real, C > >
template<typename V , typename Real , std::size_t NumDimensions, std::size_t R = NumDimensions, std::size_t C = NumDimensions>
using	matrixfield = field< V, Real, NumDimensions, mat< Real, R, C > >
template<typename V , typename Real , std::size_t NumDimensions, std::size_t C = NumDimensions>
using	vectorfield = field< V, Real, NumDimensions, vec< Real, NumDimensions > >
template<typename V , typename Real , std::size_t NumDimensions>
using	scalarfield = field< V, Real, NumDimensions, Real >
template<typename Field >
using	field_real_type = typename std::decay_t< std::remove_pointer_t< std::decay_t< Field > > >::real_type
template<typename Field >
using	field_tensor_type = typename std::decay_t< std::remove_pointer_t< std::decay_t< Field > > >::tensor_type
template<typename Field >
using	field_pos_type = typename std::decay_t< std::remove_pointer_t< std::decay_t< Field > > >::pos_type
template<arithmetic Real, std::size_t NumDimensions, template< typename, std::size_t > typename ODESolver, template< typename > typename InterpolationKernel>
using	numerical_flowmap_field_pointer = numerical_flowmap< polymorphic::vectorfield< Real, NumDimensions > *, ODESolver, InterpolationKernel >
template<std::size_t NumDimensions>
using	Particle = particle< real_number, NumDimensions >
using	particle2 = Particle< 2 >
using	particle3 = Particle< 3 >
using	regular_flowmap_discretization2 = regular_flowmap_discretization< real_number, 2 >

Functions
template<typename Range , typename RangeIt >
decltype(auto)	resize_prev_list (Range &range, RangeIt pos, std::size_t new_prev_size)
template<typename Range , typename RangeIt >
decltype(auto)	resize_next_list (Range &range, RangeIt pos, std::size_t new_next_size)
template<typename T >
constexpr auto	clamp (const T &v, const T &lo, const T &hi) -> const T &
template<typename T , typename Compare >
constexpr auto	clamp (const T &v, const T &lo, const T &hi, Compare comp) -> const T &
template<typename T >
bool	bdsvu (int _n, int _nrhs, const T *_d, const T *_du, T *_b, int _ldb)
template<typename T >
bool	bdsvl (int _n, int _nrhs, const T *_dl, const T *_d, T *_b, int _ldb)
template<typename T >
bool	solve_blockwise (int _n, const T *_d, const T *_du, T *_b)
template<typename T >
void	_planerot (T _c, T _s, T *_x)
template<typename T >
bool	solve_qr (int _n, T *_d, T *_du, T *_b, T *_null)
template<typename F , typename... Args>
constexpr auto	bind (F &&f, Args &&... args)
	Binds first arguments of f (either all or only partially). More...
template<std::size_t I>
static auto constexpr	cartesian_axis_label ()
static auto constexpr	cartesian_axis_label (std::size_t const i) -> std::string_view
template<typename F , typename GridReal >
auto	cell_partition (F &&f, const grid< GridReal, 3 > &g)
	iterates over all cells of the grid in parallel More...
template<typename F , typename... Param>
auto	measure (F &&f, Param &&... param)
template<typename... Durations, typename DurationIn >
auto	break_down_durations (DurationIn d)
template<std::string_view const & S0, std::string_view const & S1, std::size_t... I0s, std::size_t... I1s>
constexpr std::string_view const &	concat (std::index_sequence< I0s... >, std::index_sequence< I1s... >)
template<std::string_view const & S>
constexpr std::string_view const &	concat ()
template<std::string_view const & S0, std::string_view const & S1>
constexpr std::string_view const &	concat ()
template<std::string_view const & S0, std::string_view const & S1, std::string_view const & S2, std::string_view const &... Ss>
constexpr std::string_view const &	concat ()
template<typename T , size_t N, integral P = int>
auto	condition_number (tensor< T, N, N > const &A, P const p=2)
	compute condition number More...
template<typename Tensor , typename T , size_t N, typename PReal >
auto	condition_number (base_tensor< Tensor, T, N, N > const &A, PReal p)
auto	type_name (std::type_info const &t) -> std::string
template<typename T >
auto	type_name (T &&) -> std::string
	returns demangled typename More...
template<typename T >
auto	type_name () -> std::string
	returns demangled typename More...
template<typename T >
auto	type_name (std::string const &name) -> std::string
	returns demangled typename More...
auto	finite_differences_coefficients (std::size_t const derivative_order, floating_point auto const ... xs)
	See What is this? for an explanation. More...
template<typename Tensor , floating_point Real, std::size_t N>
auto	finite_differences_coefficients (std::size_t const derivative_order, base_tensor< Tensor, Real, N > const &v)
	See What is this? for an explanation. More...
template<typename Tensor , floating_point Real, std::size_t N>
auto	finite_differences_coefficients (std::size_t const derivative_order, vec< Real, N > const &v)
	See What is this? for an explanation. More...
template<floating_point_range R> requires (!static_tensor<R>)
auto	finite_differences_coefficients (std::size_t const derivative_order, R const &v)
	See What is this? for an explanation. More...
auto	for_loop_num_parallel_threads ()
template<typename T >
auto	create_aligned_data_for_parallel ()
template<typename Int = std::size_t, typename Iteration , integral... Ranges>
constexpr auto	for_loop (Iteration &&iteration, execution_policy::sequential_t, Ranges(&&... ranges)[2]) -> void
	Use this function for creating a sequential nested loop. More...
template<typename Int = std::size_t, typename Iteration , integral... Ranges>
constexpr auto	for_loop (Iteration &&iteration, execution_policy::sequential_t, std::pair< Ranges, Ranges > const &... ranges) -> void
	Use this function for creating a sequential nested loop. More...
template<typename Int = std::size_t, typename Iteration , integral... Ends>
constexpr auto	for_loop (Iteration &&iteration, execution_policy::sequential_t, Ends const ... ends) -> void
	Use this function for creating a sequential nested loop. More...
template<typename Int = std::size_t, typename Iteration , integral... Ranges> requires parallel_for_loop_support
constexpr auto	for_loop (Iteration &&iteration, execution_policy::parallel_t, Ranges(&&... ranges)[2]) -> void
	Use this function for creating a parallel nested loop. More...
template<typename Int = std::size_t, typename Iteration , integral... Ranges> requires parallel_for_loop_support
constexpr auto	for_loop (Iteration &&iteration, execution_policy::parallel_t, std::pair< Ranges, Ranges > const &... ranges) -> void
	Use this function for creating a parallel nested loop. More...
template<typename Int = std::size_t, typename Iteration , integral... Ends> requires parallel_for_loop_support
constexpr auto	for_loop (Iteration &&iteration, execution_policy::parallel_t, Ends const ... ends) -> void
	Use this function for creating a parallel nested loop. More...
template<typename Int = std::size_t, typename Iteration , integral... Ranges>
constexpr auto	for_loop (Iteration &&iteration, Ranges(&&... ranges)[2]) -> void
	Use this function for creating a sequential nested loop. More...
template<typename Int = std::size_t, typename Iteration , integral... Ranges>
constexpr auto	for_loop (Iteration &&iteration, std::pair< Ranges, Ranges > const &... ranges) -> void
	Use this function for creating a sequential nested loop. More...
template<typename Int = std::size_t, typename Iteration , integral... Ends>
constexpr auto	for_loop (Iteration &&iteration, Ends const ... ends) -> void
	Use this function for creating a sequential nested loop. More...
template<typename Iteration , integral Int, std::size_t N>
auto	for_loop_unpacked (Iteration &&iteration, execution_policy_tag auto policy, std::array< Int, N > const &sizes)
template<typename Iteration , integral Int, std::size_t N>
auto	for_loop_unpacked (Iteration &&iteration, std::array< Int, N > const &sizes)
template<typename Int = std::size_t, integral... Ends>
constexpr auto	chunked_for_loop (invocable< decltype(((void) std::declval< Ends >(), std::declval< Int >()))... > auto &&iteration, execution_policy_tag auto policy, integral auto const chunk_size, Ends const ... ends) -> void
template<typename Int = std::size_t, typename Iteration , integral... Ends> requires invocable<Iteration, decltype((std::declval<Ends>(), std::declval<Int>()))...>
constexpr auto	chunked_for_loop (Iteration &&iteration, integral auto const chunk_size, Ends const ... ends) -> void
template<integral_pair_range IntPairRange, for_loop_nested_index_iteration< std::vector< common_type< typename std::ranges::range_value_t< IntPairRange >::first_type, typename std::ranges::range_value_t< IntPairRange >::second_type > > > Iteration>
auto	for_loop (Iteration &&iteration, IntPairRange const &ranges, execution_policy::sequential_t)
template<integral_pair_range IntPairRange, for_loop_nested_index_iteration< std::vector< common_type< typename std::ranges::range_value_t< IntPairRange >::first_type, typename std::ranges::range_value_t< IntPairRange >::second_type > > > Iteration>
auto	for_loop (Iteration &&iteration, IntPairRange const &ranges, execution_policy_tag auto policy)
template<integral_pair_range IntPairRange, for_loop_nested_index_iteration< std::vector< common_type< typename std::ranges::range_value_t< IntPairRange >::first_type, typename std::ranges::range_value_t< IntPairRange >::second_type > > > Iteration>
auto	for_loop (Iteration &&iteration, IntPairRange const &ranges)
template<integral_range IntRange, for_loop_nested_index_iteration< IntRange > Iteration>
auto	for_loop (Iteration &&iteration, IntRange const &begin, IntRange const &ends, execution_policy::sequential_t)
template<integral_range IntRange, for_loop_nested_index_iteration< IntRange > Iteration>
auto	for_loop (Iteration &&iteration, IntRange const &begin, IntRange const &ends)
template<integral_range IntRange, for_loop_nested_index_iteration< IntRange > Iteration>
auto	for_loop (Iteration &&iteration, IntRange const &ends, execution_policy_tag auto policy)
template<integral_range IntRange, for_loop_nested_index_iteration< IntRange > Iteration>
auto	for_loop (Iteration &&iteration, IntRange const &ends)
template<range Range, for_loop_range_iteration< Range > Iteration> requires (!integral<std::ranges::range_value_t<Range>>) && (!integral_pair<std::ranges::range_value_t<Range>>)
auto	for_loop (Iteration &&iteration, Range &&r, execution_policy::parallel_t) parallel_for_loop_support
	Sequential nested loop over a generic range. More...
template<range Range, for_loop_range_iteration< Range > Iteration> requires (!integral<std::ranges::range_value_t<Range>>) && (!integral_pair<std::ranges::range_value_t<Range>>)
auto	for_loop (Iteration &&iteration, Range &&r, execution_policy::sequential_t)
	Sequential nested loop over a generic range. More...
template<range Range, for_loop_range_iteration< Range > Iteration> requires (!integral<std::ranges::range_value_t<Range>>) && (!integral_pair<std::ranges::range_value_t<Range>>)
auto	for_loop (Iteration &&iteration, Range const &r)
	Sequential loop over a generic range. More...
constexpr auto	invoke (invocable auto &&...funcs)
template<typename T >
	holder (T &&) -> holder< T >
template<typename T >
	holder (const T &) -> holder< const T & >
template<typename T >
auto	hold (T &&t)
template<arithmetic Delta = int>
auto constexpr	huber_loss (floating_point auto const a, Delta const delta=1)
	See Wikipedia More...
template<typename F , typename... Params>
constexpr decltype(auto)	invoke_omitted (F &&f, Params &&... params)
template<size_t i, size_t... is, typename F , typename Param , typename... Params>
constexpr decltype(auto)	invoke_omitted (F &&f, Param &&param, Params &&... params)
auto constexpr	invoke_reversed (auto &&f, auto &&param0) -> decltype(auto)
auto constexpr	invoke_reversed (auto &&f, auto &&param0, auto &&param1, auto &&... params) -> decltype(auto)
template<typename F >
constexpr decltype(auto)	invoke_unpacked (F &&f)
	All arguments are bound -> just call f. More...
template<typename F , typename T , typename... Ts>
constexpr decltype(auto)	invoke_unpacked (F &&f, T &&t, Ts &&... ts)
	Recursive currying. Curry first non-unpacked type to f. More...
template<std::size_t... Is, typename F , typename T , typename... Ts>
constexpr decltype(auto)	invoke_unpacked (std::index_sequence< Is... >, F &&f, unpack< T > t, Ts &&... ts)
	Curries unpacked parameters by calling invoke_unpacked(F&&, T&&, Ts&&...). More...
template<typename F , typename T , typename... Ts>
constexpr decltype(auto)	invoke_unpacked (F &&f, unpack< T > t, Ts &&... ts)
template<typename T , size_t N>
	unpack (std::array< T, N > &c) -> unpack< std::array< T, N > >
template<typename T , size_t N>
	unpack (const std::array< T, N > &c) -> unpack< const std::array< T, N > >
template<typename... Ts>
	unpack (std::tuple< Ts... > &&c) -> unpack< std::tuple< Ts... > >
template<typename... Ts>
	unpack (const std::tuple< Ts... > &c) -> unpack< const std::tuple< Ts... > >
template<typename A , typename B >
	unpack (std::pair< A, B > &c) -> unpack< std::pair< A, B > >
template<typename A , typename B >
	unpack (const std::pair< A, B > &c) -> unpack< const std::pair< A, B > >
template<typename T >
constexpr auto	is_cacheable ()
template<typename T >
constexpr auto	is_cacheable (T &&)
template<typename Range > requires requires(Range &&range) { range.begin(); }
auto	begin (Range &&range)
template<typename Range > requires requires(Range &&range) { range.end(); }
auto	end (Range &&range)
template<derived_from_iterator_facade Iter>
auto	next (Iter iter)
template<derived_from_iterator_facade Iter>
auto	next (Iter iter, difference_type_arg< Iter > auto off)
template<derived_from_iterator_facade Iter> requires implements_decrement<Iter>
auto	prev (Iter iter)
template<derived_from_iterator_facade Iter> requires implements_decrement<Iter>
auto	prev (Iter iter, difference_type_arg< Iter > auto off)
template<derived_from_iterator_facade Iter> requires implements_advance<Iter>
auto	advance (Iter &iter)
template<derived_from_iterator_facade Iter> requires implements_advance<Iter>
auto	advance (Iter &iter, difference_type_arg< Iter > auto off)
template<derived_from_iterator_facade Iter> requires implements_distance_to<Iter>
constexpr auto	distance (Iter const &it0, Iter const &it1)
template<derived_from_iterator_facade Iter> requires implements_distance_to<Iter>
constexpr auto	distance (Iter const &it0, iter_sentinel_arg< Iter > auto const &it1)
template<derived_from_iterator_facade Iter> requires implements_distance_to<Iter>
constexpr auto	distance (iter_sentinel_arg< Iter > auto const &it0, Iter const &it1)
template<floating_point Real>
auto	front (linspace< Real > const &l)
template<floating_point Real>
auto	front (linspace< Real > &l) -> auto &
template<floating_point Real>
auto	back (linspace< Real > const &l)
template<floating_point Real>
auto	back (linspace< Real > &l) -> auto &
template<arithmetic Real0, arithmetic Real1>
	linspace (Real0 const, Real1 const, std::size_t const) -> linspace< common_type< Real0, Real1 > >
template<floating_point Real>
auto	operator<< (std::ostream &out, linspace< Real > const &l) -> auto &
template<typename T , size_t... Is>
constexpr auto	make_array (T &&default_data, std::index_sequence< Is... >)
template<typename T , typename... Data>
constexpr auto	make_array (Data &&... data)
template<typename T , size_t N>
constexpr auto	make_array ()
template<size_t N, typename T >
constexpr auto	make_array (T &&default_data)
template<typename T , size_t N>
constexpr auto	make_array (std::array< T, N > const &data)
template<typename... Ts, typename F >
auto constexpr	map (F &&f, Ts &&... ts)
	maps unary function f to all single parameters of parameter pack ts More...
template<typename A , typename B > requires same_as<std::decay_t<A>, std::decay_t<B>>
constexpr auto	min (A &&a, B &&b)
template<typename A , typename B > requires same_as<std::decay_t<A>, std::decay_t<B>>
constexpr auto	max (A &&a, B &&b)
constexpr auto	log (arithmetic auto const x)
constexpr auto	log2 (arithmetic auto const x)
constexpr auto	abs (arithmetic auto const x)
constexpr auto	sin (arithmetic auto const x)
constexpr auto	cos (arithmetic auto const x)
constexpr auto	sqrt (arithmetic auto const x)
constexpr auto	pow (arithmetic auto const x)
template<template< typename > typename Comparator, typename T0 , typename T1 , typename... TRest> requires requires(T0 a, T1 b, Comparator<std::decay_t<T0>> comp) { { comp(a, b) } -> std::convertible_to<bool>; } && same_as<std::decay_t<T0>, std::decay_t<T1>> && (same_as<std::decay_t<T0>, std::decay_t<TRest>> && ...)
constexpr auto	compare_variadic (T0 &&a, T1 &&b, TRest &&... rest)
template<typename T0 >
constexpr auto	max (T0 &&a) -> decltype(auto)
template<typename T0 , typename T1 , typename T2 , typename... TRest> requires requires(T0&& a, T1&& b) { { a > b } -> std::convertible_to<bool>; }
constexpr auto	max (T0 &&a, T1 &&b, T2 &&c, TRest &&... rest) -> decltype(auto)
template<typename T0 , typename T1 , typename T2 , typename... TRest> requires requires(T0&& a, T1&& b) { { a > b } -> std::convertible_to<bool>; }
constexpr auto	min (T0 &&a, T1 &&b, T2 &&c, TRest &&... rest) -> decltype(auto)
template<typename T , std::size_t N, std::size_t... Is>
constexpr auto	min (std::array< T, N > const &arr, std::index_sequence< Is... >)
template<typename T , std::size_t N>
constexpr auto	min (std::array< T, N > const &arr)
template<typename T , std::size_t N, std::size_t... Is>
constexpr auto	max (std::array< T, N > const &arr, std::index_sequence< Is... >)
template<typename T , std::size_t N>
constexpr auto	max (std::array< T, N > const &arr)
constexpr auto	ipow (integral auto const base, integral auto const exp)
template<integral Int>
constexpr auto	factorial (Int const i) -> std::decay_t< Int >
size_t	total_memory ()
	Total amount of RAM in kB. More...
auto	memory_usage ()
template<typename Real >
auto	delaunay (const pointset< 2, Real > &ps)
template<typename Real >
auto	delaunay (const pointset< 2, Real > &ps, const std::vector< typename pointset< 2, Real >::vertex > &vertices)
template<typename Real >
auto	constrained_delaunay (const edgeset< 2, Real > &es)
template<typename Real >
auto	constrained_delaunay (const pointset< 2, Real > &ps, const std::vector< typename pointset< 2, Real >::vertex > &polygon)
template<typename Real >
auto	conforming_delaunay (const edgeset< 2, Real > &es, triangle::real_type minangle=0, triangle::real_type maxarea=0)
template<floating_point Float = real_number>
auto	nan (const char *arg="")
template<typename Real , size_t N, size_t... Is>
auto	newton_raphson (const symbolic::field< Real, N, N > &v, typename symbolic::field< Real, N, N >::pos_type x, Real t, size_t n, double precision, std::index_sequence< Is... >)
template<typename Real , size_t N>
auto	newton_raphson (const symbolic::field< Real, N, N > &v, typename symbolic::field< Real, N, N >::pos_type x, Real t, size_t n, double precision=1e-10)
template<typename Real >
auto	parse (std::string const &) -> Real
template<typename... Coeffs>
	polynomial (Coeffs... coeffs) -> polynomial< common_type< Coeffs... >, sizeof...(Coeffs) - 1 >
template<typename Real , std::size_t N>
	polynomial (tensor< Real, N > const &) -> polynomial< Real, N - 1 >
template<typename Real , std::size_t Degree>
constexpr auto	diff (polynomial< Real, Degree > const &f)
template<typename Real >
auto	solve (polynomial< Real, 1 > const &p) -> std::vector< Real >
	solve a + b*x More...
template<typename Real >
auto	solve (polynomial< Real, 2 > const &p) -> std::vector< Real >
	solve a + b*x + c*x^2 More...
template<typename Real >
auto	solve (polynomial< Real, 3 > const &f)
template<typename Real >
auto	solve (polynomial< Real, 4 > const &f) -> std::vector< Real >
template<typename Real , std::size_t Degree>
auto &	operator<< (std::ostream &out, polynomial< Real, Degree > const &f)
template<typename... Polynomials>
	polynomial_line (Polynomials &&...) -> polynomial_line< common_type< typename Polynomials::real_type... >, sizeof...(Polynomials), max(Polynomials::degree()...)>
template<typename Real , std::size_t N, std::size_t Degree>
auto	operator<< (std::ostream &out, const polynomial_line< Real, N, Degree > &line) -> std::ostream &
template<std::integral Int>
constexpr auto	pow (Int x, std::unsigned_integral auto const p) -> Int
auto	make_default_indeterminate_progress_bar ()
auto	make_indeterminate_completion_thread (auto &indicator)
template<typename F , typename... Args> requires is_invocable<F, Args...>
auto	indeterminate_progress_bar (F &&f, Args &&...args) -> decltype(auto)
template<typename F , typename... Args> requires is_invocable<F, indicator_msg<indicators::IndeterminateProgressBar>, Args...> && is_void<invoke_result< F, indicator_msg<indicators::IndeterminateProgressBar>, Args...>>
auto	indeterminate_progress_bar (F &&f, Args &&...args)
template<typename F , typename... Args> requires is_invocable<F, indicator_msg<indicators::IndeterminateProgressBar>, Args...> && (!is_void<invoke_result< F, indicator_msg<indicators::IndeterminateProgressBar>, Args...>>)
auto	indeterminate_progress_bar (F &&f, Args &&...args) -> decltype(auto)
template<typename F , typename... Args> requires std::invocable< F, progress_indicator_wrapper<indicators::BlockProgressBar>, Args...>
auto	progress_bar (F &&f, Args &&...args) -> decltype(auto)
template<arithmetic_or_complex Scalar>
constexpr auto	rank ()
template<arithmetic_or_complex Scalar>
constexpr auto	rank (Scalar &&)
template<static_tensor Tensor>
constexpr auto	rank (Tensor &&)
template<template< typename > typename Comparator = std::less, typename InitialStatus , typename EnergyFunction , typename TemperaturFunction , typename NeighborFunction , typename RandomEngine >
auto	simulated_annealing (InitialStatus &&initial_status, size_t const num_iterations, EnergyFunction &&energy_fun, TemperaturFunction &&temperature_fun, NeighborFunction &&neighbor_fun, RandomEngine &&random_engine, std::vector< simulated_annealing_listener< std::decay_t< decltype(energy_fun(std::declval< InitialStatus >()))>, std::decay_t< InitialStatus > > * > const &listeners={})
template<typename Data >
constexpr Data	swap_endianess (Data data)
template<typename Data >
constexpr void	swap_endianess (Data *data, size_t n)
template<typename Data >
void	swap_endianess (std::vector< Data > &data)
constexpr auto	opposite (forward_tag const)
constexpr auto	opposite (backward_tag const)
auto constexpr	operator== (forward_tag const, backward_tag const)
auto constexpr	operator== (backward_tag const, forward_tag const)
auto constexpr	operator== (forward_tag const, forward_tag const)
auto constexpr	operator== (backward_tag const, backward_tag const)
auto	operator!= (forward_or_backward_tag auto const lhs, forward_or_backward_tag auto const rhs)
template<std::size_t N = 1>
auto constexpr	diff (decltype(thin_plate_spline) const &)
template<std::size_t N = 1>
auto constexpr	diff (decltype(thin_plate_spline_diff1) const &)
template<std::size_t N = 1>
auto constexpr	diff (decltype(thin_plate_spline_diff2) const &)
template<typename Head , typename... Tail>
	tuple (Head &&, Tail &&...) -> tuple< std::decay_t< Head >, std::decay_t< Tail >... >
template<typename Head >
	tuple (Head &&) -> tuple< std::decay_t< Head > >
template<std::size_t Idx, typename... Ts>
constexpr auto	get (tuple< Ts... > const &t) -> auto const &
template<std::size_t Idx, typename... Ts>
constexpr auto	get (tuple< Ts... > &t) -> auto &
template<typename Data >
constexpr auto	type_to_str () -> std::string_view
template<>
constexpr auto	type_to_str< double > () -> std::string_view
template<>
constexpr auto	type_to_str< long double > () -> std::string_view
template<>
constexpr auto	type_to_str< float > () -> std::string_view
template<>
constexpr auto	type_to_str< int > () -> std::string_view
template<>
constexpr auto	type_to_str< unsigned int > () -> std::string_view
template<>
constexpr auto	type_to_str< long > () -> std::string_view
template<>
constexpr auto	type_to_str< unsigned long > () -> std::string_view
template<>
constexpr auto	type_to_str< long long > () -> std::string_view
template<>
constexpr auto	type_to_str< unsigned long long > () -> std::string_view
template<>
constexpr auto	type_to_str< char > () -> std::string_view
template<>
constexpr auto	type_to_str< unsigned char > () -> std::string_view
template<typename T , std::size_t = sizeof(T)>
auto	type_exists_impl (T *) -> std::true_type
auto	type_exists_impl (...) -> std::false_type
template<size_t Omit, size_t... Is, size_t... Js>
constexpr auto	sliced_indices (std::index_sequence< Is... >, std::index_sequence< Js... >)
	creates an index_sequence and removes an element from it More...
template<size_t N, size_t Omit>
constexpr auto	sliced_indices ()
	creates an index sequence and removes an element from it More...
template<typename F , typename... Ts>
constexpr void	for_each (F &&f, Ts &&... ts)
template<size_t N>
auto	partition_resolution (const std::array< size_t, N > &resolution, const std::array< size_t, N > &max_chunk_resolution)
constexpr auto	debug_mode ()
constexpr auto	release_mode ()
template<typename T >
constexpr void	tat_swap (T &t0, T &t1)
template<typename F , typename... Args>
auto	repeat (size_t const n, F &&f, Args &&... args)
auto	copy_or_keep_if_rvalue (auto &&x) -> decltype(auto)
auto	reorder (std::ranges::range auto &data, std::ranges::range auto &order) -> void
	reorders a range data with another range order More...
template<typename Visitor , typename Variant0 , typename Variant1 , typename... Variants>
constexpr auto	visit (Visitor &&visitor, Variant0 &&variant0, Variant1 &&variant1, Variants &&... variants) -> void
template<arithmetic T>
void	write_png (filesystem::path const &path, std::vector< T > const &data, std::size_t width, std::size_t height)
template<typename ValueType , typename IndexOrder >
	dynamic_multidim_array (dynamic_multidim_array< ValueType, IndexOrder > const &) -> dynamic_multidim_array< ValueType, IndexOrder >
template<typename ValueType , typename IndexOrder >
	dynamic_multidim_array (dynamic_multidim_array< ValueType, IndexOrder > &&) -> dynamic_multidim_array< ValueType, IndexOrder >
template<typename ValueType , typename UInt >
	dynamic_multidim_array (std::vector< UInt > const &, ValueType const &initial) -> dynamic_multidim_array< ValueType, x_fastest >
template<typename ValueType , typename UInt >
	dynamic_multidim_array (std::vector< UInt > const &, std::vector< ValueType > const &) -> dynamic_multidim_array< ValueType, x_fastest >
template<typename ValueType , typename UInt >
	dynamic_multidim_array (std::vector< UInt > const &, std::vector< ValueType > &&) -> dynamic_multidim_array< ValueType, x_fastest >
template<typename ValueType , typename UInt , std::size_t N>
	dynamic_multidim_array (std::array< UInt, N > const &, ValueType const &initial) -> dynamic_multidim_array< ValueType, x_fastest >
template<typename ValueType , typename UInt , std::size_t N>
	dynamic_multidim_array (std::array< UInt, N > const &, std::vector< ValueType > const &) -> dynamic_multidim_array< ValueType, x_fastest >
template<typename ValueType , typename UInt , std::size_t N>
	dynamic_multidim_array (std::array< UInt, N > const &, std::vector< ValueType > &&) -> dynamic_multidim_array< ValueType, x_fastest >
template<typename IndexingOut = x_fastest, typename T0 , typename T1 , typename Indexing0 , typename Indexing1 , typename FReal >
auto	interpolate (dynamic_multidim_array< T0, Indexing0 > const &arr0, dynamic_multidim_array< T1, Indexing1 > const &arr1, FReal factor)
template<typename IndexingOut = x_fastest, typename T0 , typename T1 , typename Indexing0 , typename Indexing1 , typename LinReal , typename TReal >
auto	interpolate (dynamic_multidim_array< T0, Indexing0 > const &arr0, dynamic_multidim_array< T1, Indexing1 > const &arr1, linspace< LinReal > const &ts, TReal t)
template<arithmetic Real>
void	write_png (dynamic_multidim_array< Real > const &arr, std::string const &filepath)
	dynamic_multidim_size () -> dynamic_multidim_size< x_fastest >
template<typename IndexOrder >
	dynamic_multidim_size (dynamic_multidim_size< IndexOrder > const &) -> dynamic_multidim_size< IndexOrder >
template<typename IndexOrder >
	dynamic_multidim_size (dynamic_multidim_size< IndexOrder > &&) -> dynamic_multidim_size< IndexOrder >
template<typename... Resolution>
	dynamic_multidim_size (Resolution...) -> dynamic_multidim_size< x_fastest >
template<typename MemLocOut = stack, typename IndexingOut = x_fastest, typename T0 , typename T1 , typename Indexing0 , typename Indexing1 , typename MemLoc0 , typename MemLoc1 , typename FReal , std::size_t... Resolution>
auto	interpolate (static_multidim_array< T0, Indexing0, MemLoc0, Resolution... > const &arr0, static_multidim_array< T1, Indexing1, MemLoc1, Resolution... > const &arr1, FReal factor)
template<typename MemLocOut = stack, typename IndexingOut = x_fastest, typename T0 , typename T1 , typename Indexing0 , typename Indexing1 , typename MemLoc0 , typename MemLoc1 , typename LinReal , typename TReal , std::size_t... Resolution>
auto	interpolate (static_multidim_array< T0, Indexing0, MemLoc0, Resolution... > const &arr0, static_multidim_array< T1, Indexing1, MemLoc1, Resolution... > const &arr1, linspace< LinReal > const &ts, TReal t)
template<typename Tensor , typename T , size_t... Dims>
auto	imag (base_tensor< Tensor, std::complex< T >, Dims... > const &tensor)
template<typename Tensor , typename T , size_t... Dims>
auto	imag (base_tensor< Tensor, std::complex< T >, Dims... > &tensor)
template<typename Tensor , typename T , size_t... Dims>
auto	real (base_tensor< Tensor, std::complex< T >, Dims... > const &t)
template<typename Tensor , typename T , size_t... Dims>
auto	real (base_tensor< Tensor, std::complex< T >, Dims... > &t)
template<static_vec Tensor>
	diag_static_tensor (Tensor const &t) -> diag_static_tensor< Tensor const &, Tensor::dimension(0), Tensor::dimension(0)>
template<static_vec Tensor>
	diag_static_tensor (Tensor &t) -> diag_static_tensor< Tensor &, Tensor::dimension(0), Tensor::dimension(0)>
template<static_vec Tensor>
	diag_static_tensor (Tensor &&t) -> diag_static_tensor< std::decay_t< Tensor >, Tensor::dimension(0), Tensor::dimension(0)>
constexpr auto	diag (static_vec auto &&t)
template<std::size_t M, std::size_t N>
constexpr auto	diag_rect (static_vec auto &&t)
template<typename Tensor , std::size_t N>
constexpr auto	inv (diag_static_tensor< Tensor, N, N > const &A) -> std::optional< diag_static_tensor< vec< tatooine::value_type< Tensor >, N >, N, N > >
template<typename TensorA , static_vec TensorB, std::size_t N> requires (tensor_dimensions<TensorB>[0] == N)
constexpr auto	solve (diag_static_tensor< TensorA, N, N > const &A, TensorB &&b) -> std::optional< vec< common_type< tatooine::value_type< TensorA >, tatooine::value_type< TensorB > >, N > >
template<typename TensorA , static_vec TensorB, std::size_t N> requires (tensor_dimensions<TensorB>[0] == N)
constexpr auto	solve (diag_static_tensor< TensorA, N, N > &&A, TensorB &&b) -> std::optional< vec< common_type< tatooine::value_type< TensorA >, tatooine::value_type< TensorB > >, N > >
template<typename TensorA , std::size_t M, std::size_t N>
constexpr auto	operator* (diag_static_tensor< TensorA, M, N > const &A, static_vec auto const &b) -> vec< common_type< tatooine::value_type< TensorA >, tatooine::value_type< decltype(b)> >, M > requires(N==decltype(b)::dimension(0))
template<typename TensorA , std::size_t M, std::size_t N> requires (N == std::decay_t<decltype(B)>::dimension( 0))
constexpr auto	operator* (diag_static_tensor< TensorA, M, N > const &A, static_mat auto const &B)
template<typename TensorA , std::size_t M, std::size_t N> requires (std::decay_t<decltype(B)>::dimension(1) == M)
constexpr auto	operator* (static_tensor auto const &B, diag_static_tensor< TensorA, M, N > const &A)
template<dynamic_tensor Tensor>
	diag_dynamic_tensor (Tensor const &t) -> diag_dynamic_tensor< Tensor const & >
template<dynamic_tensor Tensor>
	diag_dynamic_tensor (Tensor &t) -> diag_dynamic_tensor< Tensor & >
template<dynamic_tensor Tensor>
	diag_dynamic_tensor (Tensor &&t) -> diag_dynamic_tensor< std::decay_t< Tensor > >
auto	diag (dynamic_tensor auto &&A)
template<dynamic_tensor Lhs, dynamic_tensor Rhs> requires diag_tensor<Lhs>
auto	operator* (Lhs const &lhs, Rhs const &rhs) -> tensor< common_type< tatooine::value_type< Lhs >, tatooine::value_type< Rhs > > >
template<typename... Rows, std::size_t N>
	tensor (Rows(&&... rows)[N]) -> tensor< common_type< Rows... > >
template<typename... Ts>
	tensor (Ts...) -> tensor< common_type< Ts... > >
template<dynamic_tensor Tensor>
	tensor (Tensor &&) -> tensor< value_type< Tensor > >
template<std::size_t C, typename... Rows>
	mat (Rows const(&&... rows)[C]) -> mat< common_type< Rows... >, sizeof...(Rows), C >
template<typename Mat , typename ValueType , std::size_t M, std::size_t N>
	mat (base_tensor< Mat, ValueType, M, N >) -> mat< ValueType, M, N >
template<typename CastReal , typename Real , size_t N>
auto	cast_tensor_type_impl (const vec< Real, N > &)
template<typename CastReal , typename Real , size_t M, size_t N>
auto	cast_tensor_type_impl (const mat< Real, M, N > &)
template<typename CastReal , typename Real , size_t... Dims>
auto	cast_tensor_type_impl (const tensor< Real, Dims... > &)
template<typename NewReal , typename Tensor , typename Real , size_t... Dims>
auto	cast (const base_tensor< Tensor, Real, Dims... > &to_cast)
template<typename NewReal , typename Real , size_t M, size_t N>
auto	cast (const mat< Real, M, N > &to_cast)
template<typename NewReal , typename Real , size_t N>
auto	cast (const vec< Real, N > &to_cast)
template<typename Tensor , typename T , size_t N>
auto	operator<< (std::ostream &out, const base_tensor< Tensor, T, N > &v) -> auto &
	printing vector More...
template<typename Tensor , typename T , size_t M, size_t N>
auto	operator<< (std::ostream &out, const base_tensor< Tensor, T, M, N > &m) -> auto &
auto	operator<< (std::ostream &out, dynamic_tensor auto const &t) -> auto &
	printing dynamic tensors More...
template<typename Tensor0 , typename Tensor1 , typename T0 , typename T1 , std::size_t N>
constexpr auto	cos_angle (base_tensor< Tensor0, T0, N > const &v0, base_tensor< Tensor1, T1, N > const &v1)
	Returns the cosine of the angle of two normalized vectors. More...
template<typename Tensor , typename TensorT , std::size_t... Dims>
constexpr auto	abs (base_tensor< Tensor, TensorT, Dims... > const &t)
template<typename Tensor0 , typename Tensor1 , typename T0 , typename T1 , std::size_t N>
constexpr auto	angle (base_tensor< Tensor0, T0, N > const &v0, base_tensor< Tensor1, T1, N > const &v1)
	Returns the angle of two normalized vectors. More...
template<typename Tensor0 , typename Tensor1 , typename T0 , typename T1 , std::size_t N>
constexpr auto	min_angle (base_tensor< Tensor0, T0, N > const &v0, base_tensor< Tensor1, T1, N > const &v1)
	Returns the angle of two normalized vectors. More...
template<typename Tensor0 , typename Tensor1 , typename T0 , typename T1 , std::size_t N>
constexpr auto	max_angle (base_tensor< Tensor0, T0, N > const &v0, base_tensor< Tensor1, T1, N > const &v1)
	Returns the angle of two normalized vectors. More...
template<typename Tensor0 , typename Tensor1 , typename Tensor2 , typename T0 , typename T1 , typename T2 , std::size_t N>
constexpr auto	cos_angle (base_tensor< Tensor0, T0, N > const &v0, base_tensor< Tensor1, T1, N > const &v1, base_tensor< Tensor2, T2, N > const &v2)
	Returns the cosine of the angle three points. More...
template<typename Tensor0 , typename Tensor1 , typename Tensor2 , typename T0 , typename T1 , typename T2 , std::size_t N>
constexpr auto	angle (base_tensor< Tensor0, T0, N > const &v0, base_tensor< Tensor1, T1, N > const &v1, base_tensor< Tensor2, T2, N > const &v2)
	Returns the cosine of the angle three points. More...
template<typename Tensor , typename T , std::size_t... Dims>
constexpr auto	min (base_tensor< Tensor, T, Dims... > const &t)
template<typename Tensor , typename T , std::size_t... Dims>
constexpr auto	max (base_tensor< Tensor, T, Dims... > const &t)
template<typename Tensor , typename T , std::size_t N>
constexpr auto	normalize (base_tensor< Tensor, T, N > const &t_in) -> vec< T, N >
template<typename Tensor , typename T , std::size_t VecDim>
constexpr auto	sum (base_tensor< Tensor, T, VecDim > const &v)
	sum of all components of a vector More...
template<typename Tensor0 , typename T0 , typename Tensor1 , typename T1 , std::size_t N>
constexpr auto	dot (base_tensor< Tensor0, T0, N > const &lhs, base_tensor< Tensor1, T1, N > const &rhs)
template<typename T0 , typename T1 >
constexpr auto	reflect (vec< T0, 3 > const &incidentVec, vec< T1, 3 > const &normal)
template<typename Tensor , typename TensorT , std::size_t... Dims>
constexpr auto	sqrt (base_tensor< Tensor, TensorT, Dims... > const &t)
constexpr auto	sqrt (dynamic_tensor auto &&t)
template<typename F , static_tensor Lhs, static_tensor Rhs, std::size_t... Seq> requires (same_dimensions<Lhs, Rhs>())
constexpr auto	binary_operation (F &&f, Lhs const &lhs, Rhs const &rhs, std::index_sequence< Seq... >)
template<typename F , static_tensor Lhs, static_tensor Rhs> requires (same_dimensions<Lhs, Rhs>())
constexpr auto	binary_operation (F &&f, Lhs const &lhs, Rhs const &rhs)
template<typename Tensor0 , typename T0 , typename Tensor1 , typename T1 >
constexpr auto	cross (base_tensor< Tensor0, T0, 3 > const &lhs, base_tensor< Tensor1, T1, 3 > const &rhs)
template<typename T0 , typename T1 >
constexpr auto	cross (tensor< T0 > const &lhs, tensor< T1 > const &rhs)
template<typename Tensor , typename T >
constexpr auto	det (base_tensor< Tensor, T, 2, 2 > const &A) -> T
template<typename Tensor , typename T >
constexpr auto	detAtA (base_tensor< Tensor, T, 2, 2 > const &A) -> T
template<typename Tensor , typename T >
constexpr auto	det (base_tensor< Tensor, T, 3, 3 > const &A) -> T
template<typename Tensor0 , typename T0 , typename Tensor1 , typename T1 , std::size_t N>
constexpr auto	squared_euclidean_distance (base_tensor< Tensor0, T0, N > const &lhs, base_tensor< Tensor1, T1, N > const &rhs)
template<typename Tensor0 , typename T0 , typename Tensor1 , typename T1 , std::size_t N>
constexpr auto	euclidean_distance (base_tensor< Tensor0, T0, N > const &lhs, base_tensor< Tensor1, T1, N > const &rhs)
template<static_quadratic_mat Mat>
auto	eigenvectors_sym (Mat &&A)
template<fixed_size_quadratic_mat< 2 > Mat>
constexpr auto	eigenvalues_sym (Mat &&A)
template<static_quadratic_mat Mat>
constexpr auto	eigenvalues (Mat &&A)
template<static_quadratic_mat Mat>
auto	eigenvectors (Mat &&B)
template<fixed_size_quadratic_mat< 2 > Mat>
constexpr auto	inv_sym (Mat &&A) -> std::optional< mat< tatooine::value_type< Mat >, 2, 2 > >
template<fixed_size_quadratic_mat< 2 > Mat>
constexpr auto	inv (Mat &&A) -> std::optional< mat< tatooine::value_type< Mat >, 2, 2 > >
template<typename Tensor , typename T , size_t N>
constexpr auto	squared_euclidean_length (base_tensor< Tensor, T, N > const &t_in)
template<typename Tensor , typename T , size_t N>
constexpr auto	euclidean_length (base_tensor< Tensor, T, N > const &t_in) -> T
template<typename Tensor , typename T , std::size_t N>
constexpr auto	norm_inf (base_tensor< Tensor, T, N > const &t) -> T
template<typename Tensor , typename T , std::size_t N>
constexpr auto	norm1 (base_tensor< Tensor, T, N > const &t)
template<typename Tensor , typename T , std::size_t N>
constexpr auto	norm (base_tensor< Tensor, T, N > const &t, unsigned p=2) -> T
template<typename Tensor , typename T , std::size_t M, std::size_t N>
constexpr auto	squared_norm (base_tensor< Tensor, T, M, N > const &A, unsigned int const p)
	squared p-norm of a rank-2 tensor More...
template<typename Tensor , typename T , std::size_t M, std::size_t N>
constexpr auto	norm (base_tensor< Tensor, T, M, N > const &A, unsigned int const p)
	p-norm of a rank-2 tensor More...
template<typename Tensor , typename T , std::size_t M, std::size_t N>
constexpr auto	squared_norm (base_tensor< Tensor, T, M, N > const &mat, tag::frobenius_t)
	squared Frobenius norm of a rank-2 tensor More...
template<typename Tensor , typename T , std::size_t M, std::size_t N>
constexpr auto	norm (base_tensor< Tensor, T, M, N > const &mat, tag::frobenius_t)
	Frobenius norm of a rank-2 tensor. More...
template<typename Tensor , typename T , std::size_t M, std::size_t N>
constexpr auto	norm1 (base_tensor< Tensor, T, M, N > const &mat)
	1-norm of a MxN Tensor More...
template<typename Tensor , typename T , std::size_t M, std::size_t N>
constexpr auto	norm_inf (base_tensor< Tensor, T, M, N > const &mat)
	infinity-norm of a MxN tensor More...
template<typename Tensor , typename T , std::size_t M, std::size_t N>
constexpr auto	squared_norm (base_tensor< Tensor, T, M, N > const &mat)
	squared Frobenius norm of a rank-2 tensor More...
template<typename Tensor , typename T , std::size_t M, std::size_t N>
constexpr auto	norm (base_tensor< Tensor, T, M, N > const &mat)
	squared Frobenius norm of a rank-2 tensor More...
template<static_tensor Lhs, static_tensor Rhs> requires (same_dimensions<Lhs, Rhs>())
auto constexpr	operator== (Lhs const &lhs, Rhs const &rhs)
template<static_tensor Lhs, static_tensor Rhs> requires (same_dimensions<Lhs, Rhs>())
auto constexpr	operator!= (Lhs const &lhs, Rhs const &rhs)
auto constexpr	operator- (static_tensor auto const &t)
auto constexpr	operator+ (static_tensor auto const &lhs, arithmetic_or_complex auto const scalar)
template<static_mat Lhs, static_mat Rhs> requires (Lhs::dimension(1) == Rhs::dimension(0))
auto constexpr	operator* (Lhs const &lhs, Rhs const &rhs)
	matrix-matrix multiplication More...
template<static_vec Lhs, static_mat Rhs> requires (Lhs::dimension(0) == Rhs::dimension(0))
auto constexpr	operator* (Lhs const &lhs, Rhs const &rhs)
	vector-matrix-multiplication More...
template<static_tensor Lhs, static_tensor Rhs> requires (same_dimensions<Lhs, Rhs>() && Lhs::rank() != 2 && Rhs::rank() != 2)
auto constexpr	operator* (Lhs const &lhs, Rhs const &rhs)
	component-wise multiplication More...
template<static_tensor Lhs, static_tensor Rhs> requires (same_dimensions<Lhs, Rhs>())
auto constexpr	operator/ (Lhs const &lhs, Rhs const &rhs)
	component-wise division More...
template<static_tensor Lhs, static_tensor Rhs> requires (same_dimensions<Lhs, Rhs>())
auto constexpr	operator+ (Lhs const &lhs, Rhs const &rhs)
	component-wise addition More...
template<static_tensor Lhs, static_tensor Rhs> requires (same_dimensions<Lhs, Rhs>())
auto constexpr	operator- (Lhs const &lhs, Rhs const &rhs)
	component-wise subtraction More...
auto constexpr	operator* (static_tensor auto const &t, arithmetic_or_complex auto const scalar)
auto constexpr	operator* (arithmetic_or_complex auto const scalar, static_tensor auto const &t)
auto constexpr	operator/ (static_tensor auto const &t, arithmetic_or_complex auto const scalar)
auto constexpr	operator/ (arithmetic_or_complex auto const scalar, static_tensor auto const &t)
template<dynamic_tensor Lhs, dynamic_tensor Rhs>
auto	operator* (Lhs const &lhs, Rhs const &rhs)
template<static_tensor A, static_tensor B>
auto constexpr	same_dimensions ()
auto constexpr	same_dimensions (static_tensor auto const &A, static_tensor auto const &B)
template<typename Tensor , typename T , size_t M, size_t N>
auto	svd (base_tensor< Tensor, T, M, N > const &A_base, tag::full_t[> tag<])
template<typename Tensor , typename T , size_t M, size_t N>
auto	svd (base_tensor< Tensor, T, M, N > const &A_base, tag::economy_t[> tag<])
template<typename Tensor , typename T , size_t M, size_t N>
auto	svd (base_tensor< Tensor, T, M, N > const &A)
template<typename Tensor , typename T , size_t M, size_t N>
auto	svd_left (base_tensor< Tensor, T, M, N > const &A_base, tag::full_t[> tag<])
template<typename Tensor , typename T , size_t M, size_t N>
auto	svd_left (base_tensor< Tensor, T, M, N > const &A_base, tag::economy_t[> tag<])
template<typename Tensor , typename T , size_t M, size_t N>
auto	svd_left (base_tensor< Tensor, T, M, N > const &A)
template<typename Tensor , typename T , size_t M, size_t N>
auto	svd_right (base_tensor< Tensor, T, M, N > const &A_base, tag::full_t[> tag<])
template<typename Tensor , typename T , size_t M, size_t N>
auto	svd_right (base_tensor< Tensor, T, M, N > const &A_base, tag::economy_t[> tag<])
template<typename Tensor , typename T , size_t M, size_t N>
auto	svd_right (base_tensor< Tensor, T, M, N > const &A)
template<typename Tensor , typename T >
constexpr auto	singular_values22 (base_tensor< Tensor, T, 2, 2 > const &A)
template<typename T , size_t M, size_t N>
constexpr auto	singular_values (tensor< T, M, N > &&A)
template<typename Tensor , typename T , size_t M, size_t N>
constexpr auto	singular_values (base_tensor< Tensor, T, M, N > const &A_base)
auto	copy_or_keep_if_rvalue_tensor_solve (dynamic_tensor auto &&x) -> decltype(auto)
template<typename T >
auto	copy_or_keep_if_rvalue_tensor_solve (tensor< T > &&x) -> decltype(auto)
template<typename T , std::size_t... Dims>
auto	copy_or_keep_if_rvalue_tensor_solve (tensor< T, Dims... > &&x) -> decltype(auto)
template<typename T >
auto	copy_or_keep_if_rvalue_tensor_solve (tensor< T > const &x)
template<typename T , std::size_t... Dims>
auto	copy_or_keep_if_rvalue_tensor_solve (tensor< T, Dims... > const &x)
template<fixed_size_quadratic_mat< 2 > MatA, static_mat MatB> requires (tensor_dimension<MatB, 0> == 2)
auto constexpr	solve_direct (MatA &&A, MatB &&B)
template<fixed_size_mat< 2, 2 > MatA, fixed_size_vec< 2 > VecB>
auto	solve_direct (MatA &&A, VecB &&b) -> std::optional< vec< common_type< tatooine::value_type< MatA >, tatooine::value_type< VecB > >, 2 > >
template<static_quadratic_mat MatA, static_vec VecB> requires (tensor_dimension<MatA, 0> == tensor_dimension<VecB, 0>)
auto	solve_cramer (MatA const &A, VecB const &b) -> std::optional< vec< common_type< tatooine::value_type< MatA >, tatooine::value_type< VecB > >, tensor_dimension< MatA, 1 > > >
template<static_quadratic_mat MatA, static_vec VecB> requires (tensor_dimension<MatA, 1> == tensor_dimension<VecB, 0>)
auto	solve_lu_lapack (MatA &A_, VecB &&b_) -> std::optional< tensor< common_type< tatooine::value_type< MatA >, tatooine::value_type< VecB > > > >
template<static_quadratic_mat MatA, static_mat MatB> requires (tensor_dimension<MatA, 0> == tensor_dimension<MatB, 0>)
auto	solve_lu_lapack (MatA &A_, MatB &B_)
template<static_mat MatA, static_mat MatB> requires (tensor_dimension<MatA, 0> == tensor_dimension<MatB, 0>)
auto	solve_qr_lapack (MatA &&A_, MatB &&B_)
template<static_mat MatA, static_vec VecB> requires (tensor_dimension<MatA, 0> == tensor_dimension<VecB, 0>)
auto	solve_qr_lapack (MatA &&A_, VecB &&b_)
template<static_mat MatA, static_mat MatB> requires (tensor_dimension<MatA, 0> == tensor_dimension<MatB, 0>)
auto	solve (MatA &&A, MatB &&B)
template<dynamic_tensor TensorA, dynamic_tensor TensorB>
auto	solve_lu_lapack (TensorA &&A_, TensorB &&B_) -> std::optional< tensor< common_type< tatooine::value_type< TensorA >, tatooine::value_type< TensorB > > > >
template<dynamic_tensor TensorA, dynamic_tensor TensorB>
auto	solve_qr_lapack (TensorA &&A_, TensorB &&B_) -> std::optional< tensor< common_type< tatooine::value_type< TensorA >, tatooine::value_type< TensorB > > > >
template<static_mat MatA, static_vec VecB> requires (tensor_dimension<MatA, 0> == tensor_dimension<VecB, 0>)
auto	solve (MatA &&A, VecB &&b)
template<dynamic_tensor TensorA, dynamic_tensor TensorB>
auto	solve_symmetric_lapack (TensorA &&A_, TensorB &&B_, lapack::uplo uplo=lapack::uplo::lower) -> std::optional< tensor< common_type< tatooine::value_type< decltype(A_)>, tatooine::value_type< decltype(B_)> > > >
auto	solve_symmetric (dynamic_tensor auto &&A, dynamic_tensor auto &&B)
template<dynamic_tensor TensorA, dynamic_tensor TensorB>
auto	solve (TensorA &&A, TensorB &&B) -> std::optional< tensor< common_type< tatooine::value_type< TensorB >, tatooine::value_type< TensorB > > > >
template<typename Tensor , typename T , std::size_t N>
constexpr auto	trace (base_tensor< Tensor, T, N, N > const &A)
template<dynamic_tensor Tensor>
constexpr auto	unary_operation (invocable< tatooine::value_type< Tensor > > auto &&op, Tensor const &t)
template<typename Op , static_tensor Tensor, std::size_t... Seq>
constexpr auto	unary_operation (Op &&op, Tensor const &t, std::index_sequence< Seq... >)
template<typename Op , static_tensor Tensor>
constexpr auto	unary_operation (Op &&op, Tensor const &t)
template<typename RealOut = double, typename Tensor , size_t... Dims, typename... Relations>
auto	evtod (const base_tensor< Tensor, GiNaC::ex, Dims... > &t_in, Relations &&... relations)
template<typename RealOut = double, typename Tensor , size_t... Dims>
auto	diff (const base_tensor< Tensor, GiNaC::ex, Dims... > &t_in, const GiNaC::symbol &symbol, unsigned nth=1)
template<typename Tensor , size_t M, size_t N>
auto	to_ginac_matrix (const base_tensor< Tensor, GiNaC::ex, M, N > &m_in)
template<size_t M, size_t N>
auto	to_mat (const GiNaC::matrix &m_in)
template<typename Tensor , size_t... Dims>
void	eval (base_tensor< Tensor, GiNaC::ex, Dims... > &m)
template<typename Tensor , size_t... Dims>
void	evalf (base_tensor< Tensor, GiNaC::ex, Dims... > &m)
template<typename Tensor , size_t... Dims>
void	evalm (base_tensor< Tensor, GiNaC::ex, Dims... > &m)
template<typename Tensor , size_t... Dims>
void	expand (base_tensor< Tensor, GiNaC::ex, Dims... > &m)
template<typename Tensor , size_t... Dims>
void	normal (base_tensor< Tensor, GiNaC::ex, Dims... > &m)
template<typename Tensor , size_t M, size_t N>
auto	inverse (const base_tensor< Tensor, GiNaC::ex, M, N > &m_in)
template<typename Tensor , typename Real , size_t N>
	unpack (base_tensor< Tensor, Real, N > &c) -> unpack< base_tensor< Tensor, Real, N > >
template<typename Tensor , typename Real , size_t N>
	unpack (const base_tensor< Tensor, Real, N > &c) -> unpack< const base_tensor< Tensor, Real, N > >
template<typename Real , size_t N>
	unpack (tensor< Real, N > &c) -> unpack< tensor< Real, N > >
template<typename Real , size_t N>
	unpack (const tensor< Real, N > &c) -> unpack< const tensor< Real, N > >
template<static_tensor T0, static_tensor T1> requires (same_dimensions<T0, T1>())
constexpr auto	approx_equal (T0 const &lhs, T1 const &rhs, common_type< tatooine::value_type< T0 >, tatooine::value_type< T1 > > eps=1e-6)
	for comparison More...
template<typename Tensor , typename Real , size_t... Dims>
constexpr auto	isnan (base_tensor< Tensor, Real, Dims... > const &t) -> bool
template<static_tensor T>
	transposed_static_tensor (T &&) -> transposed_static_tensor< std::decay_t< T > >
template<static_tensor T>
	transposed_static_tensor (T &) -> transposed_static_tensor< T & >
template<static_tensor T>
	transposed_static_tensor (T const &) -> transposed_static_tensor< T const & >
template<dynamic_tensor T>
	transposed_dynamic_tensor (T &&) -> transposed_dynamic_tensor< std::decay_t< T > >
template<dynamic_tensor T>
	transposed_dynamic_tensor (T &) -> transposed_dynamic_tensor< T & >
template<dynamic_tensor T>
	transposed_dynamic_tensor (T const &) -> transposed_dynamic_tensor< T const & >
auto	transposed (dynamic_tensor auto &&t)
template<static_tensor T> requires (!transposed_tensor<T>)
auto constexpr	transposed (T &&t)
auto constexpr	transposed (transposed_tensor auto &&t) -> decltype(auto)
template<typename ValueType , std::size_t N>
auto	begin (vec< ValueType, N > const &v)
template<typename ValueType , std::size_t N>
auto	end (vec< ValueType, N > const &v)
template<typename ValueType , std::size_t N>
auto	size (vec< ValueType, N > const &v)
template<typename... Ts>
	vec (const Ts &...) -> vec< common_type< Ts... >, sizeof...(Ts)>
template<typename V , typename ValueType , std::size_t N>
	vec (base_tensor< V, ValueType, N > const &) -> vec< ValueType, N >
template<typename Real0 , typename Real1 , std::size_t NumDimensions>
	axis_aligned_bounding_box (vec< Real0, NumDimensions > const &, vec< Real1, NumDimensions > const &) -> axis_aligned_bounding_box< common_type< Real0, Real1 >, NumDimensions >
template<typename Real0 , typename Real1 , std::size_t NumDimensions>
	axis_aligned_bounding_box (vec< Real0, NumDimensions > &&, vec< Real1, NumDimensions > &&) -> axis_aligned_bounding_box< common_type< Real0, Real1 >, NumDimensions >
template<typename Tensor0 , typename Tensor1 , typename Real0 , typename Real1 , std::size_t NumDimensions>
	axis_aligned_bounding_box (base_tensor< Tensor0, Real0, NumDimensions > &&, base_tensor< Tensor1, Real1, NumDimensions > &&) -> axis_aligned_bounding_box< common_type< Real0, Real1 >, NumDimensions >
template<typename Real , std::size_t NumDimensions>
auto	operator<< (std::ostream &out, axis_aligned_bounding_box< Real, NumDimensions > const &bb) -> std::ostream &
template<typename Mesh >
	celltree (Mesh const &mesh) -> celltree< Mesh >
template<typename Mesh , typename Real , std::size_t NumDimensions>
	celltree (Mesh const &mesh, vec< Real, NumDimensions > const &min, vec< Real, NumDimensions > const &max) -> celltree< Mesh >
template<typename T >
constexpr auto	is_celltree ()
template<typename T >
constexpr auto	is_celltree (T &&)
template<range_of_lines Lines, floating_point Eps = real_number>
auto	merge (Lines const &unmerged_lines, Eps const eps=1e-13)
	Merges a set of lines and combines lines with equal vertex endings. More...
template<range_of_lines Lines, floating_point Eps = real_number, execution_policy_tag ExecutionPolicy>
auto	merge (Lines &lines, std::ranges::range_value_t< Lines > line_to_merge, ExecutionPolicy const tag, Eps const eps=1e-13) -> auto &
	Merges line_to_merge into lines. More...
template<range_of_lines Lines>
auto	write_vtp (Lines const &lines, filesystem::path const &path) -> void
template<range_of_lines Lines>
auto	write_vtk (Lines const &lines, filesystem::path const &path, std::string const &title="tatooine lines") -> void
template<range_of_lines Lines>
auto	write (Lines const &lines, filesystem::path const &path) -> void
template<typename Lines , typename MaxDist >
auto	merge (range_of_lines auto lines, MaxDist max_length)
auto	filter_length (range_of_lines auto const &lines, arithmetic auto const max_length)
template<typename Real >
auto	intersections (std::vector< line< Real, 2 > > const &lines0, std::vector< line< Real, 2 > > const &lines1)
template<typename Real , std::size_t NumDimensions>
auto	vertices (pointset< Real, NumDimensions > const &ps)
template<range Ellipsoids> requires (is_derived_from_hyper_ellipse< std::ranges::range_value_t<Ellipsoids>>) && (std::ranges::range_value_t<Ellipsoids>::num_dimensions() == 2)
auto	write_vtp (Ellipsoids const &ellipsoids, filesystem::path const &path)
template<range Ellipsoids> requires (is_derived_from_hyper_ellipse< std::ranges::range_value_t<Ellipsoids>>) && (std::ranges::range_value_t<Ellipsoids>::num_dimensions() == 3)
auto	write_vtp (Ellipsoids const &ellipsoids, filesystem::path const &path)
template<typename Real , size_t N>
auto	operator<< (std::ostream &out, const grid_edge< Real, N > &e) -> auto &
template<typename Child , unsigned_integral Int>
auto	operator+ (handle< Child, Int > const h, integral auto const i)
template<typename Child , unsigned_integral Int>
auto	operator+ (integral auto const i, handle< Child, Int > const h)
template<typename Child , unsigned_integral Int>
auto	operator- (handle< Child, Int > const h, integral auto const i)
template<typename Child , unsigned_integral Int>
auto	operator- (integral auto const i, handle< Child, Int > const h)
template<typename Child , unsigned_integral Int>
auto	operator* (handle< Child, Int > const h, integral auto const i)
template<typename Child , unsigned_integral Int>
auto	operator* (integral auto const i, handle< Child, Int > const h)
template<typename Child , unsigned_integral Int>
auto	operator/ (handle< Child, Int > const h, integral auto const i)
template<typename Child , unsigned_integral Int>
auto	operator/ (integral auto const i, handle< Child, Int > const h)
template<typename Child , unsigned_integral Int>
auto	operator<< (std::ostream &stream, handle< Child, Int > const h) -> auto &
template<typename Child , unsigned_integral Int>
auto constexpr	index (handle< Child, Int > const h)
template<typename T >
constexpr auto	has_face_at_method ()
template<typename T >
constexpr auto	has_face_at_method (T &&)
template<typename T >
constexpr auto	has_tetrahedron_at_method ()
template<typename T >
constexpr auto	has_tetrahedron_at_method (T &&)
template<typename T >
constexpr auto	is_kdtree ()
template<typename T >
constexpr auto	is_kdtree (T &&)
template<typename... Tensors, typename... Reals, std::size_t NumDimensions>
	line (base_tensor< Tensors, Reals, NumDimensions > &&... vertices) -> line< common_type< Reals... >, NumDimensions >
template<floating_point Real = real_number>
auto	read_lines (filesystem::path const &filepath)
template<typename... Dimensions>
auto	operator<< (std::ostream &out, rectilinear_grid< Dimensions... > const &g) -> auto &
template<floating_point_range... Dimensions>
auto	vertices (rectilinear_grid< Dimensions... > const &g)
template<floating_point_range... Dimensions>
	rectilinear_grid (Dimensions &&...) -> rectilinear_grid< std::decay_t< Dimensions >... >
template<typename Real , std::size_t N>
	rectilinear_grid (axis_aligned_bounding_box< Real, N > const &bb, integral auto const ... res) -> rectilinear_grid< linspace< std::conditional_t< true, Real, decltype(res)> >... >
template<integral... Ints>
	rectilinear_grid (Ints const ... res) -> rectilinear_grid< linspace< std::conditional_t< true, double, decltype(res)> >... >
template<floating_point_range... Dimensions, floating_point_range AdditionalDimension>
auto	operator+ (rectilinear_grid< Dimensions... > const &rectilinear_grid, AdditionalDimension &&additional_dimension)
template<floating_point_range... Dimensions, floating_point_range AdditionalDimension>
auto	operator+ (AdditionalDimension &&additional_dimension, rectilinear_grid< Dimensions... > const &rectilinear_grid)
template<typename Real >
auto	is_separating_axis (vec< Real, 2 > const &n, std::vector< vec< Real, 2 > > const &polygon0, std::vector< vec< Real, 2 > > const &polygon1)
	Return true if n is a separating axis of polygon0 and polygon1. More...
template<typename Real >
auto	has_separating_axis (std::vector< vec< Real, 2 > > const &polygon0, std::vector< vec< Real, 2 > > const &polygon1) -> bool
template<typename Real , std::size_t NumDimensions, std::size_t SimplexDim>
	uniform_tree_hierarchy (vec< Real, NumDimensions > const &, vec< Real, NumDimensions > const &, unstructured_simplicial_grid< Real, NumDimensions, SimplexDim > const &, std::size_t const) -> uniform_tree_hierarchy< unstructured_simplicial_grid< Real, NumDimensions, SimplexDim > >
template<typename T >
constexpr auto	is_uniform_tree_hierarchy ()
template<typename T >
constexpr auto	is_uniform_tree_hierarchy (T &&)
	unstructured_simplicial_grid (std::string const &) -> unstructured_simplicial_grid< double, 3 >
template<typename... Dims>
	unstructured_simplicial_grid (rectilinear_grid< Dims... > const &g) -> unstructured_simplicial_grid< typename rectilinear_grid< Dims... >::real_type, sizeof...(Dims)>
static constexpr auto	constrained_delaunay_available (std::size_t const NumDimensions) -> bool
auto	write_vtk (range auto const &grids, std::filesystem::path const &path, std::string const &title="tatooine grids")
auto	write_vtp (range auto const &grids, std::filesystem::path const &path)
auto	write (range auto const &grids, std::filesystem::path const &path)
template<typename Real , typename Integrator , template< typename > typename Interpolator>
auto	render_topological_skeleton (const sampled_field< grid_sampler< Real, 2, vec< Real, 2 >, interpolation::linear, interpolation::linear >, Real, 2, 2 > &v, const integration::integrator< Real, 2, Interpolator, Integrator > &integrator, const vec< size_t, 2 > &resolution, const Real tau=100, const Real eps=1e-7)
	you need a gl::context for this More...
template<std::floating_point Real>
constexpr auto	diff (analytical::numerical::autonomous_particles_test< Real > &)
template<std::floating_point Real>
constexpr auto	diff (vectorfield< analytical::numerical::autonomous_particles_test< Real >, Real, 2 > const &)
template<floating_point Real>
constexpr auto	diff (analytical::numerical::center< Real > &)
template<floating_point Real>
constexpr auto	diff (vectorfield< analytical::numerical::center< Real >, Real, 2 > const &)
template<floating_point Real>
auto	diff (analytical::numerical::frankes_test< Real > const &f)
template<floating_point Real>
auto	write_vtp (std::vector< autonomous_particle< Real, 2 > > const &particles, std::size_t const num_points, filesystem::path const &path, backward_tag const)
template<typename LHSInternalField , typename LHSReal , size_t N, typename LHSTensor , typename RHSInternalField , typename RHSReal , typename RHSTensor , typename Op >
constexpr auto	make_binary_operation_field (const field< LHSInternalField, LHSReal, N, LHSTensor > &lhs, const field< RHSInternalField, RHSReal, N, RHSTensor > &rhs, const Op &op)
template<typename LHSInternalField , typename LHSReal , size_t N, typename LHSTensor , typename RHSInternalField , typename RHSReal , typename RHSTensor , typename Op >
constexpr auto	make_binary_operation_field (field< LHSInternalField, LHSReal, N, LHSTensor > &&lhs, const field< RHSInternalField, RHSReal, N, RHSTensor > &rhs, const Op &op)
template<typename LHSInternalField , typename LHSReal , size_t N, typename LHSTensor , typename RHSInternalField , typename RHSReal , typename RHSTensor , typename Op >
constexpr auto	make_binary_operation_field (const field< LHSInternalField, LHSReal, N, LHSTensor > &lhs, field< RHSInternalField, RHSReal, N, RHSTensor > &&rhs, const Op &op)
template<typename LHSInternalField , typename LHSReal , size_t N, typename LHSTensor , typename RHSInternalField , typename RHSReal , typename RHSTensor , typename Op >
constexpr auto	make_binary_operation_field (field< LHSInternalField, LHSReal, N, LHSTensor > &&lhs, field< RHSInternalField, RHSReal, N, RHSTensor > &&rhs, const Op &op)
template<typename LHSInternalField , typename LHSReal , size_t N, typename LHSTensor , typename RHSInternalField , typename RHSReal , typename RHSTensor , typename Op >
constexpr auto	make_binary_operation_field (const field< LHSInternalField, LHSReal, N, LHSTensor > &lhs, const field< RHSInternalField, RHSReal, N, RHSTensor > &rhs, Op &&op)
template<typename LHSInternalField , typename LHSReal , size_t N, typename LHSTensor , typename RHSInternalField , typename RHSReal , typename RHSTensor , typename Op >
constexpr auto	make_binary_operation_field (field< LHSInternalField, LHSReal, N, LHSTensor > &&lhs, const field< RHSInternalField, RHSReal, N, RHSTensor > &rhs, Op &&op)
template<typename LHSInternalField , typename LHSReal , size_t N, typename LHSTensor , typename RHSInternalField , typename RHSReal , typename RHSTensor , typename Op >
constexpr auto	make_binary_operation_field (const field< LHSInternalField, LHSReal, N, LHSTensor > &lhs, field< RHSInternalField, RHSReal, N, RHSTensor > &&rhs, Op op)
template<typename LHSInternalField , typename LHSReal , size_t N, typename LHSTensor , typename RHSInternalField , typename RHSReal , typename RHSTensor , typename Op >
constexpr auto	make_binary_operation_field (field< LHSInternalField, LHSReal, N, LHSTensor > &&lhs, field< RHSInternalField, RHSReal, N, RHSTensor > &&rhs, Op op)
template<typename LHSReal , size_t N, typename LHSTensor , typename RHSReal , typename RHSTensor , typename Op >
constexpr auto	make_binary_operation_field (polymorphic::field< LHSReal, N, LHSTensor > const *lhs, polymorphic::field< RHSReal, N, RHSTensor > const *rhs, Op op)
template<typename RealOut , size_t NOut, size_t... TensorDimsOut, typename LHSReal , size_t N, typename LHSTensor , typename RHSReal , typename RHSTensor , typename Op >
constexpr auto	make_binary_operation_field (polymorphic::field< LHSReal, N, LHSTensor > const &lhs, polymorphic::field< RHSReal, N, RHSTensor > const &rhs, Op op)
template<typename Real >
auto	find_boundary_switch_points (const grid_sampler< Real, 2, vec< Real, 2 >, interpolation::linear, interpolation::linear > &sampler)
template<typename Real >
auto	find_boundary_switch_points (const sampled_field< grid_sampler< Real, 2, vec< Real, 2 >, interpolation::linear, interpolation::linear >, Real, 2, 2 > &v)
template<typename Grid , typename Real , bool HasNonConstReference>
auto	find_critical_points (detail::rectilinear_grid::vertex_property_sampler< detail::rectilinear_grid::typed_vertex_property_interface< Grid, vec< Real, 2 >, HasNonConstReference >, interpolation::linear, interpolation::linear > const &s)
template<typename V , typename Real >
auto	curvature (const field< V, Real, 2, 2 > &vf)
template<typename V , typename Real >
auto	curvature (const field< V, Real, 3, 3 > &vf)
	curve_to_streamline () -> curve_to_streamline< double >
template<typename Field , arithmetic Eps>
	numerically_differentiated_field (Field &&, Eps const) -> numerically_differentiated_field< Field >
template<typename Field , arithmetic Eps>
	numerically_differentiated_field (Field const &, Eps const) -> numerically_differentiated_field< Field const & >
template<typename Field , arithmetic Eps>
	numerically_differentiated_field (Field &, Eps const) -> numerically_differentiated_field< Field & >
template<typename Field , arithmetic Eps>
	numerically_differentiated_field (Field &&f, vec< Eps, field_num_dimensions< Field > > const &) -> numerically_differentiated_field< Field >
template<typename Field , arithmetic Eps>
	numerically_differentiated_field (Field const &f, vec< Eps, field_num_dimensions< Field > > const &) -> numerically_differentiated_field< Field const & >
template<typename Field , arithmetic Eps>
	numerically_differentiated_field (Field &f, vec< Eps, field_num_dimensions< Field > > const &) -> numerically_differentiated_field< Field & >
auto	diff (field_concept auto &&field, tag::numerical_t)
auto	diff (field_concept auto &&field, tag::numerical_t, arithmetic auto const epsilon)
auto	diff (field_concept auto &&field, arithmetic auto const epsilon)
auto	diff (field_concept auto &&field, tag::numerical_t, fixed_size_real_vec< std::decay_t< decltype(field)>::num_dimensions()> auto &&epsilon)
auto	diff (field_concept auto &&field, fixed_size_real_vec< std::decay_t< decltype(field)>::num_dimensions()> auto &&epsilon)
template<typename Field , arithmetic Eps>
	differentiated_field (Field &&, Eps const) -> differentiated_field< Field >
template<typename Field , arithmetic Eps>
	differentiated_field (Field const &, Eps const) -> differentiated_field< Field const & >
template<typename Field , arithmetic Eps>
	differentiated_field (Field &, Eps const) -> differentiated_field< Field & >
template<typename Field , arithmetic Eps>
	differentiated_field (Field &&f, vec< Eps, field_num_dimensions< Field > > const &) -> differentiated_field< Field >
template<typename Field , arithmetic Eps>
	differentiated_field (Field const &f, vec< Eps, field_num_dimensions< Field > > const &) -> differentiated_field< Field const & >
template<typename Field , arithmetic Eps>
	differentiated_field (Field &f, vec< Eps, field_num_dimensions< Field > > const &) -> differentiated_field< Field & >
auto	diff (field_concept auto &&field)
template<typename Field , typename Real , std::size_t NumDimensions, typename Tensor >
auto	diff_time (field< Field, Real, NumDimensions, Tensor > const &f, Real const eps)
template<typename Field , typename Real , std::size_t NumDimensions, typename Tensor >
auto	diff_time (field< Field, Real, NumDimensions, Tensor > &f, Real const eps)
template<typename Field , typename Real , std::size_t NumDimensions, typename Tensor >
auto	diff_time (field< Field, Real, NumDimensions, Tensor > &&f, Real const eps)
template<typename Real , std::size_t NumDimensions, typename Tensor >
auto	diff_time (polymorphic::field< Real, NumDimensions, Tensor > const *f, Real const eps)
template<flowmap_concept Flowmap>
	numerically_differentiated_flowmap (Flowmap &&) -> numerically_differentiated_flowmap< Flowmap >
template<flowmap_concept Flowmap>
	numerically_differentiated_flowmap (Flowmap &&, arithmetic auto) -> numerically_differentiated_flowmap< Flowmap >
template<flowmap_concept Flowmap>
	numerically_differentiated_flowmap (Flowmap &&, typename Flowmap::pos_type const &) -> numerically_differentiated_flowmap< Flowmap >
template<flowmap_concept Flowmap>
	numerically_differentiated_flowmap (Flowmap const &) -> numerically_differentiated_flowmap< Flowmap const & >
template<flowmap_concept Flowmap>
	numerically_differentiated_flowmap (Flowmap const &, arithmetic auto) -> numerically_differentiated_flowmap< Flowmap >
template<flowmap_concept Flowmap>
	numerically_differentiated_flowmap (Flowmap const &, typename Flowmap::pos_type const &) -> numerically_differentiated_flowmap< Flowmap >
auto	diff (flowmap_concept auto &&flowmap, tag::numerical_t)
auto	diff (flowmap_concept auto &&flowmap, tag::numerical_t, arithmetic auto const epsilon)
auto	diff (flowmap_concept auto &&flowmap, tag::numerical_t, fixed_size_real_vec< std::decay_t< decltype(flowmap)>::num_dimensions()> auto &&epsilon)
auto	diff (flowmap_concept auto &&flowmap, arithmetic auto const epsilon)
auto	diff (flowmap_concept auto &&flowmap, fixed_size_real_vec< std::decay_t< decltype(flowmap)>::num_dimensions()> auto &&epsilon)
template<typename Flowmap >
	differentiated_flowmap (Flowmap &&) -> differentiated_flowmap< Flowmap >
template<typename Flowmap >
	differentiated_flowmap (Flowmap const &) -> differentiated_flowmap< Flowmap const & >
auto	diff (flowmap_concept auto &&flowmap)
template<typename V , arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions, arithmetic T>
auto	sample_to_raw (field< V, VReal, NumDimensions, Tensor > const &f, rectilinear_grid< SpatialDimensions... > const &discretized_domain, T const t, std::size_t padding=0, VReal padval=0)
template<typename V , arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions, floating_point_range TemporalDimension>
auto	sample_to_raw (field< V, VReal, NumDimensions, Tensor > const &f, rectilinear_grid< SpatialDimensions... > const &discretized_domain, TemporalDimension const &temporal_domain, std::size_t padding=0, VReal padval=0)
template<arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions>
auto	sample_to_vector (polymorphic::field< VReal, NumDimensions, Tensor > const &f, rectilinear_grid< SpatialDimensions... > const &discretized_domain, arithmetic auto const t)
template<arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions>
auto	discretize (polymorphic::field< VReal, NumDimensions, Tensor > const &f, rectilinear_grid< SpatialDimensions... > const &discretized_domain, arithmetic auto const t, execution_policy_tag auto const pol) -> auto
template<arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions>
auto	discretize (polymorphic::field< VReal, NumDimensions, Tensor > const &f, rectilinear_grid< SpatialDimensions... > const &discretized_domain, arithmetic auto const t) -> auto
template<arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions>
auto	discretize (polymorphic::field< VReal, NumDimensions, Tensor > const &f, rectilinear_grid< SpatialDimensions... > const &discretized_domain) -> auto &
template<arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions>
auto	discretize (polymorphic::field< VReal, NumDimensions, Tensor > const &f, rectilinear_grid< SpatialDimensions... > const &discretized_domain, execution_policy_tag auto const pol) -> auto &
template<arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions>
auto	discretize (polymorphic::field< VReal, NumDimensions, Tensor > const &f, rectilinear_grid< SpatialDimensions... > &discretized_domain, std::string const &property_name, arithmetic auto const t, execution_policy_tag auto const pol) -> auto &
template<arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions>
auto	discretize (polymorphic::field< VReal, NumDimensions, Tensor > const &f, rectilinear_grid< SpatialDimensions... > &discretized_domain, std::string const &property_name, arithmetic auto const t) -> auto &
template<arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions>
auto	discretize (polymorphic::field< VReal, NumDimensions, Tensor > const &f, rectilinear_grid< SpatialDimensions... > &discretized_domain, std::string const &property_name) -> auto &
template<arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions>
auto	discretize (polymorphic::field< VReal, NumDimensions, Tensor > const &f, rectilinear_grid< SpatialDimensions... > &discretized_domain, std::string const &property_name, execution_policy_tag auto const pol) -> auto &
template<typename V , arithmetic VReal, std::size_t NumDimensions, typename Tensor , typename BasisReal , typename X0Real , typename X1Real >
auto	discretize (field< V, VReal, NumDimensions, Tensor > const &f, vec< X0Real, NumDimensions > const &x0, mat< BasisReal, NumDimensions, 2 > const &basis, vec< X1Real, 2 > const &spatial_size, std::size_t const res0, std::size_t const res1, std::string const &property_name, arithmetic auto const t)
template<typename V , arithmetic VReal, std::size_t NumDimensions, typename Tensor , typename BasisReal , typename X0Real >
auto	discretize (field< V, VReal, NumDimensions, Tensor > const &f, mat< BasisReal, NumDimensions, 2 > const &basis, vec< X0Real, NumDimensions > const &x0, std::size_t const res0, std::size_t const res1, std::string const &property_name, arithmetic auto const t)
template<typename V , arithmetic VReal, std::size_t NumDimensions, typename Tensor , typename BasisReal , typename X0Real >
auto	discretize (field< V, VReal, NumDimensions, Tensor > const &f, vec< BasisReal, NumDimensions > const &extent0, vec< BasisReal, NumDimensions > const &extent1, vec< X0Real, NumDimensions > const &, std::size_t const res0, std::size_t const res1, std::string const &property_name, arithmetic auto const t)
template<std::size_t NumDimensions, typename F >
constexpr auto	make_field (F &&f)
template<typename V0 , typename V1 , typename Real0 , typename Real1 , std::size_t NumDimensions> requires ( V0::num_tensor_components() == V1::num_tensor_components())
constexpr auto	dot (vectorfield< V0, Real0, NumDimensions > const &lhs, vectorfield< V1, Real1, NumDimensions > const &rhs)
template<typename V0 , typename Real0 , typename V1 , typename Real1 , std::size_t N, typename Tensor >
constexpr auto	operator+ (const field< V0, Real0, N, Tensor > &lhs, const field< V1, Real1, N, Tensor > &rhs)
template<typename Real0 , typename Real1 , std::size_t N, std::size_t TM, std::size_t TN>
constexpr auto	operator* (polymorphic::matrixfield< Real0, N, TM, TN > const &lhs, polymorphic::vectorfield< Real1, N, TN > const &rhs)
template<typename V0 , typename Real0 , typename V1 , typename Real1 , std::size_t N, std::size_t TM, std::size_t TN>
constexpr auto	operator* (const matrixfield< V0, Real0, N, TM, TN > &lhs, const vectorfield< V1, Real1, N, TN > &rhs)
template<typename V0 , typename Real0 , typename V1 , typename Real1 , std::size_t N, typename Tensor >
constexpr auto	operator* (const field< V0, Real0, N, Tensor > &lhs, const field< V1, Real1, N, Tensor > &rhs)
template<typename V , typename VReal , std::size_t N, typename Tensor >
constexpr auto	operator* (field< V, VReal, N, Tensor > const &f, arithmetic auto const scalar)
template<typename V , arithmetic VReal, std::size_t N, typename Tensor >
constexpr auto	operator* (arithmetic auto const scalar, field< V, VReal, N, Tensor > const &f)
template<typename V , typename VReal , std::size_t N, arithmetic_or_complex ScalarReal, typename Tensor >
constexpr auto	operator/ (field< V, VReal, N, Tensor > const &f, ScalarReal const scalar)
template<typename V , typename VReal , std::size_t N, arithmetic_or_complex ScalarReal, typename Tensor >
constexpr auto	operator/ (ScalarReal const scalar, field< V, VReal, N, Tensor > const &f)
template<typename V , typename VReal , std::size_t N>
constexpr auto	squared_euclidean_length (vectorfield< V, VReal, N > const &v)
template<typename V , typename VReal , std::size_t N>
constexpr auto	squared_euclidean_length (vectorfield< V, VReal, N > &&v)
template<typename V , typename VReal , std::size_t N>
constexpr auto	euclidean_length (vectorfield< V, VReal, N > const &v)
template<typename V , typename VReal , std::size_t N>
constexpr auto	euclidean_length (vectorfield< V, VReal, N > &&v)
template<typename V , typename Real , size_t N, template< typename, size_t > typename ODESolver>
	ftle_field (vectorfield< V, Real, N > const &v, arithmetic auto, ODESolver< Real, N >) -> ftle_field< numerically_differentiated_flowmap< decltype((flowmap< ODESolver >(v)))> >
template<typename V , typename Real , size_t N>
	ftle_field (vectorfield< V, Real, N > const &v, arithmetic auto) -> ftle_field< decltype(diff(flowmap(v)))>
template<typename V , typename Real , size_t N>
	ftle_field (vectorfield< V, Real, N > const &v, arithmetic auto, arithmetic auto) -> ftle_field< decltype(diff(flowmap(v)))>
template<typename V , typename Real , size_t N, typename EpsReal >
	ftle_field (vectorfield< V, Real, N > const &v, arithmetic auto, vec< EpsReal, N > const &) -> ftle_field< decltype(diff(flowmap(v)))>
template<typename... Domains, typename Flowmap >
auto	ftle (rectilinear_grid< Domains... > &grid, Flowmap &&flowmap, arithmetic auto const t0, arithmetic auto const tau, execution_policy_tag auto const exec) -> auto &
template<typename... Domains, typename Flowmap >
auto	ftle (rectilinear_grid< Domains... > &grid, Flowmap &&flowmap, arithmetic auto const t0, arithmetic auto const tau) -> decltype(auto)
template<typename T >
constexpr auto	has_fields_available_method ()
template<typename T >
constexpr auto	has_fields_available_method (T &&t)
template<typename V , typename Real >
auto	helicity (const field< V, Real, 3, 3 > &vf)
template<typename XDomain , typename YDomain >
auto	isolines (invocable< std::size_t, std::size_t, Vec2< typename rectilinear_grid< XDomain, YDomain >::real_type > > auto &&get_scalars, rectilinear_grid< XDomain, YDomain > const &g, arithmetic auto const isolevel)
	Indexing and lookup map from http://paulbourke.net/geometry/polygonise/. More...
template<typename Grid , arithmetic T, bool HasNonConstReference>
auto	isolines (detail::rectilinear_grid::typed_vertex_property_interface< Grid, T, HasNonConstReference > const &data, arithmetic auto const isolevel)
template<arithmetic Real, typename Indexing , arithmetic BBReal>
auto	isolines (dynamic_multidim_array< Real, Indexing > const &data, axis_aligned_bounding_box< BBReal, 2 > const &bb, arithmetic auto const isolevel)
template<arithmetic Real, arithmetic BBReal, typename Indexing , typename MemLoc , std::size_t XRes, std::size_t YRes>
auto	isolines (static_multidim_array< Real, Indexing, MemLoc, XRes, YRes > const &data, axis_aligned_bounding_box< BBReal, 2 > const &bb, arithmetic auto const isolevel)
template<typename Field , typename FieldReal , floating_point_range XDomain, floating_point_range YDomain, arithmetic TReal = FieldReal>
auto	isolines (scalarfield< Field, FieldReal, 2 > const &sf, rectilinear_grid< XDomain, YDomain > const &g, arithmetic auto const isolevel, TReal const t=0)
template<typename XDomain , typename YDomain , typename ZDomain , arithmetic Isolevel, invocable< std::size_t, std::size_t, std::size_t, vec< typename rectilinear_grid< XDomain, YDomain, ZDomain >::real_type, 3 > > GetScalars>
auto	isosurface (GetScalars &&get_scalars, rectilinear_grid< XDomain, YDomain, ZDomain > const &g, Isolevel const isolevel)
	Indexing and lookup map from http://paulbourke.net/geometry/polygonise/. More...
template<arithmetic Real, typename Indexing , arithmetic BBReal, arithmetic Isolevel>
auto	isosurface (dynamic_multidim_array< Real, Indexing > const &data, axis_aligned_bounding_box< BBReal, 3 > const &bb, Isolevel const isolevel)
template<arithmetic Real, typename Indexing , typename MemLoc , std::size_t XRes, std::size_t YRes, std::size_t ZRes, arithmetic BBReal, arithmetic Isolevel>
auto	isosurface (static_multidim_array< Real, Indexing, MemLoc, XRes, YRes, ZRes > const &data, axis_aligned_bounding_box< BBReal, 3 > const &bb, Isolevel const isolevel)
template<typename Field , arithmetic FieldReal, typename XDomain , typename YDomain , typename ZDomain , arithmetic Isolevel, arithmetic TReal = int>
auto	isosurface (scalarfield< Field, FieldReal, 3 > const &sf, rectilinear_grid< XDomain, YDomain, ZDomain > const &g, Isolevel const isolevel, TReal const t=0)
template<typename Grid , arithmetic T, bool HasNonConstReference>
auto	isosurface (detail::rectilinear_grid::typed_vertex_property_interface< Grid, T, HasNonConstReference > const &data, arithmetic auto const isolevel)
template<typename V , typename Real , size_t N>
auto	lagrangian_Q (const field< V, Real, N, N > &vf, arithmetic auto const btau, arithmetic auto const ftau)
template<typename V , typename Real , size_t N>
auto	lambda2 (const field< V, Real, N, N > &vf)
template<typename V , typename Real , std::size_t NumDimensions>
	numerical_flowmap (vectorfield< V, Real, NumDimensions > const &) -> numerical_flowmap< V const &, ode::boost::rungekuttafehlberg78, interpolation::cubic >
template<typename V , typename Real , std::size_t NumDimensions>
	numerical_flowmap (vectorfield< V, Real, NumDimensions > &&) -> numerical_flowmap< V, ode::boost::rungekuttafehlberg78, interpolation::cubic >
template<typename V , typename Real , std::size_t NumDimensions, template< typename, std::size_t > typename ODESolver>
	numerical_flowmap (vectorfield< V, Real, NumDimensions > const &, ODESolver< Real, NumDimensions > const &) -> numerical_flowmap< V const &, ODESolver, interpolation::cubic >
template<typename V , typename Real , std::size_t NumDimensions, template< typename, std::size_t > typename ODESolver>
	numerical_flowmap (vectorfield< V, Real, NumDimensions > &&, ODESolver< Real, NumDimensions > const &) -> numerical_flowmap< V, ODESolver, interpolation::cubic >
template<template< typename, std::size_t > typename ODESolver = ode::boost::rungekuttafehlberg78, template< typename > typename InterpolationKernel = interpolation::cubic, typename V , typename Real , std::size_t NumDimensions>
auto	flowmap (vectorfield< V, Real, NumDimensions > const &v, tag::numerical_t)
template<template< typename > typename InterpolationKernel = interpolation::cubic, template< typename, std::size_t > typename ODESolver, typename V , typename Real , std::size_t NumDimensions>
auto	flowmap (vectorfield< V, Real, NumDimensions > const &v, ODESolver< Real, NumDimensions > const &ode_solver, tag::numerical_t)
template<template< typename, std::size_t > typename ODESolver = ode::boost::rungekuttafehlberg78, template< typename > typename InterpolationKernel = interpolation::cubic, typename V , typename Real , std::size_t NumDimensions>
auto	flowmap (vectorfield< V, Real, NumDimensions > &&v, tag::numerical_t)
template<template< typename, std::size_t > typename ODESolver, template< typename > typename InterpolationKernel = interpolation::cubic, typename V , typename Real , std::size_t NumDimensions>
auto	flowmap (vectorfield< V, Real, NumDimensions > &&v, ODESolver< Real, NumDimensions > const &ode_solver, tag::numerical_t)
template<template< typename, std::size_t > typename ODESolver = ode::boost::rungekuttafehlberg78, template< typename > typename InterpolationKernel = interpolation::cubic, typename V , typename Real , std::size_t NumDimensions>
auto	flowmap (vectorfield< V, Real, NumDimensions > const &v)
template<template< typename, std::size_t > typename ODESolver, template< typename > typename InterpolationKernel = interpolation::cubic, typename V , typename Real , std::size_t NumDimensions>
auto	flowmap (vectorfield< V, Real, NumDimensions > const &v, ODESolver< Real, NumDimensions > const &ode_solver)
template<template< typename, std::size_t > typename ODESolver = ode::boost::rungekuttafehlberg78, template< typename > typename InterpolationKernel = interpolation::cubic, typename V , typename Real , std::size_t NumDimensions>
auto	flowmap (vectorfield< V, Real, NumDimensions > &&v, ODESolver< Real, NumDimensions > const &ode_solver)
template<template< typename, std::size_t > typename ODESolver = ode::boost::rungekuttafehlberg78, template< typename > typename InterpolationKernel = interpolation::cubic, typename V , typename Real , std::size_t NumDimensions>
auto	flowmap (vectorfield< V, Real, NumDimensions > &&v)
template<template< typename, std::size_t > typename ODESolver = ode::boost::rungekuttafehlberg78, template< typename > typename InterpolationKernel = interpolation::cubic, typename Real , std::size_t NumDimensions>
auto	flowmap (polymorphic::vectorfield< Real, NumDimensions > const &v)
template<template< typename, std::size_t > typename ODESolver = ode::boost::rungekuttafehlberg78, template< typename > typename InterpolationKernel = interpolation::cubic, typename Real , std::size_t NumDimensions>
auto	flowmap (polymorphic::vectorfield< Real, NumDimensions > const &v, ODESolver< Real, NumDimensions > const &ode_solver)
template<typename VReal , typename WReal , typename XDomain , typename YDomain , typename ZDomain , arithmetic TReal, invocable< vec< common_type< VReal, WReal >, 3 > >... Preds>
auto	parallel_vectors (polymorphic::vectorfield< VReal, 3 > const &vf, polymorphic::vectorfield< WReal, 3 > const &wf, rectilinear_grid< XDomain, YDomain, ZDomain > const &g, TReal const t, execution_policy_tag auto const policy, Preds &&... preds)
	This is an implementation of [5]. More...
template<typename VReal , typename WReal , typename XDomain , typename YDomain , typename ZDomain , arithmetic TReal, invocable< vec< common_type< VReal, WReal >, 3 > >... Preds>
auto	parallel_vectors (polymorphic::vectorfield< VReal, 3 > const &vf, polymorphic::vectorfield< WReal, 3 > const &wf, rectilinear_grid< XDomain, YDomain, ZDomain > const &g, TReal const t, Preds &&... preds)
	This is an implementation of [5]. More...
template<typename V , typename W , typename VReal , typename WReal , typename XDomain , typename YDomain , typename ZDomain , arithmetic TReal, invocable< vec< common_type< VReal, WReal >, 3 > >... Preds>
auto	parallel_vectors (vectorfield< V, VReal, 3 > const &vf, vectorfield< W, WReal, 3 > const &wf, rectilinear_grid< XDomain, YDomain, ZDomain > const &g, TReal const t, execution_policy_tag auto const policy, Preds &&... preds)
	This is an implementation of [5]. More...
template<typename V , typename W , typename VReal , typename WReal , typename XDomain , typename YDomain , typename ZDomain , arithmetic TReal, invocable< vec< common_type< VReal, WReal >, 3 > >... Preds>
auto	parallel_vectors (vectorfield< V, VReal, 3 > const &vf, vectorfield< W, WReal, 3 > const &wf, rectilinear_grid< XDomain, YDomain, ZDomain > const &g, TReal const t, Preds &&... preds)
	This is an implementation of [5]. More...
template<typename V , typename W , typename VReal , typename WReal , typename XDomain , typename YDomain , typename ZDomain , invocable< vec< common_type< VReal, WReal >, 3 > >... Preds>
auto	parallel_vectors (vectorfield< V, VReal, 3 > const &vf, vectorfield< W, WReal, 3 > const &wf, rectilinear_grid< XDomain, YDomain, ZDomain > const &g, execution_policy_tag auto const policy, Preds &&... preds)
	This is an implementation of [5]. More...
template<typename V , typename W , typename VReal , typename WReal , typename XDomain , typename YDomain , typename ZDomain , invocable< vec< common_type< VReal, WReal >, 3 > >... Preds>
auto	parallel_vectors (vectorfield< V, VReal, 3 > const &vf, vectorfield< W, WReal, 3 > const &wf, rectilinear_grid< XDomain, YDomain, ZDomain > const &g, Preds &&... preds)
	This is an implementation of [5]. More...
template<typename V , typename W , typename VReal , typename WReal , typename XReal , typename YReal , typename ZReal , arithmetic TReal, invocable< vec< common_type< VReal, WReal >, 3 > >... Preds>
auto	parallel_vectors (vectorfield< V, VReal, 3 > const &vf, vectorfield< W, WReal, 3 > const &wf, linspace< XReal > const &x, linspace< YReal > const &y, linspace< ZReal > const &z, TReal const t, execution_policy_tag auto const policy, Preds &&... preds)
	This is an implementation of [5]. More...
template<typename V , typename W , typename VReal , typename WReal , typename XReal , typename YReal , typename ZReal , arithmetic TReal, invocable< vec< common_type< VReal, WReal >, 3 > >... Preds>
auto	parallel_vectors (vectorfield< V, VReal, 3 > const &vf, vectorfield< W, WReal, 3 > const &wf, linspace< XReal > const &x, linspace< YReal > const &y, linspace< ZReal > const &z, TReal const t, Preds &&... preds)
	This is an implementation of [5]. More...
template<typename V , typename W , typename VReal , typename WReal , typename XReal , typename YReal , typename ZReal , invocable< vec< common_type< VReal, WReal >, 3 > >... Preds>
auto	parallel_vectors (vectorfield< V, VReal, 3 > const &vf, vectorfield< W, WReal, 3 > const &wf, linspace< XReal > const &x, linspace< YReal > const &y, linspace< ZReal > const &z, execution_policy_tag auto const policy, Preds &&... preds)
	This is an implementation of [5]. More...
template<typename V , typename W , typename VReal , typename WReal , typename XReal , typename YReal , typename ZReal , invocable< vec< common_type< VReal, WReal >, 3 > >... Preds>
auto	parallel_vectors (vectorfield< V, VReal, 3 > const &vf, vectorfield< W, WReal, 3 > const &wf, linspace< XReal > const &x, linspace< YReal > const &y, linspace< ZReal > const &z, Preds &&... preds)
	This is an implementation of [5]. More...
template<typename VReal , typename VIndexing , typename WReal , typename WIndexing , typename AABBReal , invocable< vec< common_type< VReal, WReal >, 3 > >... Preds>
auto	parallel_vectors (dynamic_multidim_array< vec< VReal, 3 >, VIndexing > const &vf, dynamic_multidim_array< vec< WReal, 3 >, WIndexing > const &wf, axis_aligned_bounding_box< AABBReal, 3 > const &bb, execution_policy_tag auto const policy, Preds &&... preds)
	This is an implementation of [5]. More...
template<typename VReal , typename VIndexing , typename WReal , typename WIndexing , typename AABBReal , invocable< vec< common_type< VReal, WReal >, 3 > >... Preds>
auto	parallel_vectors (dynamic_multidim_array< vec< VReal, 3 >, VIndexing > const &vf, dynamic_multidim_array< vec< WReal, 3 >, WIndexing > const &wf, axis_aligned_bounding_box< AABBReal, 3 > const &bb, Preds &&... preds)
	This is an implementation of [5]. More...
template<typename Real , std::size_t NumDimensions>
auto	x0_to_pointset (std::vector< particle< Real, NumDimensions > > const &particles)
template<typename Real , std::size_t NumDimensions>
auto	x1_to_pointset (std::vector< particle< Real, NumDimensions > > const &particles)
template<typename V > requires is_vectorfield<std::decay_t<std::remove_pointer_t<V>>>
auto	Q (V &&v)
template<typename V > requires is_vectorfield< std::decay_t<std::remove_pointer_t<V>>>
auto	Q (V const &v)
template<typename Grid , arithmetic T, bool HasNonConstReference, typename DomainX , typename DomainY > requires (Grid::num_dimensions() == 2)
auto	ridgelines (detail::rectilinear_grid::typed_vertex_property_interface< Grid, T, HasNonConstReference > const &data, rectilinear_grid< DomainX, DomainY > &working_grid, execution_policy_tag auto const exec)
template<typename Grid , arithmetic T, bool HasNonConstReference, typename DomainX , typename DomainY > requires (Grid::num_dimensions() == 2)
auto	ridgelines (detail::rectilinear_grid::typed_vertex_property_interface< Grid, T, HasNonConstReference > const &data, execution_policy_tag auto const exec)
	Implementation of [6] without filters. More...
template<typename Grid , arithmetic T, bool HasNonConstReference, typename DomainX , typename DomainY > requires (Grid::num_dimensions() == 2)
auto	ridgelines (detail::rectilinear_grid::typed_vertex_property_interface< Grid, T, HasNonConstReference > const &data, rectilinear_grid< DomainX, DomainY > &working_grid)
template<typename Grid , arithmetic T, bool HasNonConstReference> requires (Grid::num_dimensions() == 2)
auto	ridgelines (detail::rectilinear_grid::typed_vertex_property_interface< Grid, T, HasNonConstReference > const &data)
	Implementation of [6] without filters. More...
template<typename V >
	spacetime_splitted_vectorfield (V &&v) -> spacetime_splitted_vectorfield< V && >
template<typename V >
	spacetime_splitted_vectorfield (V const &v) -> spacetime_splitted_vectorfield< V const & >
template<typename V >
	spacetime_splitted_vectorfield (V &v) -> spacetime_splitted_vectorfield< V & >
template<typename V >
	spacetime_splitted_vectorfield (V *v) -> spacetime_splitted_vectorfield< V * >
template<typename V >
	spacetime_splitted_vectorfield (V const *v) -> spacetime_splitted_vectorfield< V const * >
template<typename V , typename VReal , std::size_t N, std::size_t NV>
auto	split_spacetime (vectorfield< V, VReal, N, NV > const &v)
template<typename V , typename VReal , std::size_t N, std::size_t NV>
auto	split_spacetime (vectorfield< V, VReal, N, NV > &v)
template<typename V , typename VReal , std::size_t N, std::size_t NV>
auto	split_spacetime (vectorfield< V, VReal, N, NV > &&v)
template<typename VReal , std::size_t N, std::size_t NV>
auto	split_spacetime (polymorphic::vectorfield< VReal, N, NV > *v)
template<typename VReal , std::size_t N, std::size_t NV>
auto	split_spacetime (polymorphic::vectorfield< VReal, N, NV > const *v)
template<typename V , typename Real , std::size_t N>
	spacetime_vectorfield (vectorfield< V, Real, N > const &) -> spacetime_vectorfield< V >
template<typename Real , std::size_t N>
	spacetime_vectorfield (polymorphic::vectorfield< Real, N > const *) -> spacetime_vectorfield< polymorphic::vectorfield< Real, N > const * >
template<typename Real , std::size_t N>
	spacetime_vectorfield (symbolic::field< Real, N > const &) -> spacetime_vectorfield< symbolic::field< Real, N > >
template<typename V , typename Real , std::size_t N>
auto	spacetime (vectorfield< V, Real, N > const &vf)
template<typename V , typename Real , std::size_t N>
auto	spacetime (polymorphic::vectorfield< Real, N > const *vf)
template<typename V , typename Real , std::size_t N>
auto	spacetime (polymorphic::vectorfield< Real, N > const &vf)
template<typename F , typename T >
auto	steady (F const &f, T const t)
template<typename F , typename T >
auto	steady (F &&f, T const t)
template<typename Flowmap >
	streamsurface (Flowmap const &, arithmetic auto u0t0, arithmetic auto u1t0, line< typename Flowmap::real_type, Flowmap::num_dimensions()> const &seedcurve) -> streamsurface< Flowmap const &, interpolation::linear >
template<typename Flowmap >
	streamsurface (Flowmap const &, arithmetic auto t0, line< typename Flowmap::real_type, Flowmap::num_dimensions()> const &seedcurve) -> streamsurface< Flowmap const &, interpolation::linear >
template<typename Flowmap >
	streamsurface (Flowmap const &, line< typename Flowmap::real_type, Flowmap::num_dimensions()> const &) -> streamsurface< Flowmap const &, interpolation::linear >
template<typename Flowmap >
	streamsurface (Flowmap &&, arithmetic auto u0t0, arithmetic auto u1t0, line< typename Flowmap::real_type, Flowmap::num_dimensions()> const &seedcurve) -> streamsurface< std::decay_t< Flowmap >, interpolation::linear >
template<typename Flowmap >
	streamsurface (Flowmap &&, arithmetic auto t0, line< typename Flowmap::real_type, Flowmap::num_dimensions()> const &seedcurve) -> streamsurface< std::decay_t< Flowmap >, interpolation::linear >
template<typename Flowmap >
	streamsurface (Flowmap &&, line< typename Flowmap::real_type, Flowmap::num_dimensions()> const &) -> streamsurface< std::decay_t< Flowmap >, interpolation::linear >
template<typename T >
constexpr auto	is_symbolic_field (T &&) noexcept
template<typename Real , size_t N, size_t... TensorDims>
constexpr auto	is_symbolic_field (const field< symbolic::field< Real, N, TensorDims... >, Real, N, TensorDims... > &) noexcept
template<typename Real , size_t N, size_t... TensorDims>
auto	diff (const symbolic::field< Real, N, TensorDims... > &f)
template<typename Real , typename Integrator , template< typename > typename Interpolator>
auto	compute_topological_skeleton (const sampled_field< grid_sampler< Real, 2, vec< Real, 2 >, interpolation::linear, interpolation::linear >, Real, 2, 2 > &v, const integration::integrator< Real, 2, Interpolator, Integrator > &integrator, const Real tau=100, const Real eps=1e-7)
template<typename V , typename Real , std::size_t N, typename T0Real , typename TauReal >
auto	trace_flow (vectorfield< V, Real, N > const &v, vec< Real, N > const &x0, T0Real const t0, TauReal const tau)
template<typename Field , typename Op > requires (!std::is_pointer_v<std::decay_t<Field>>)
	unary_operation_field (Field &&field, Op &&op) -> unary_operation_field< Field, Op >
template<typename Field , typename Op > requires (!std::is_pointer_v<Field>)
	unary_operation_field (Field const &field, Op &&op) -> unary_operation_field< Field const &, Op >
template<typename Field , typename Op > requires (!std::is_pointer_v<Field>)
	unary_operation_field (Field &field, Op &&op) -> unary_operation_field< Field &, Op >
template<typename Field , typename Op > requires (!std::is_pointer_v<std::decay_t<Field>>)
	unary_operation_field (Field &&field, Op const &op) -> unary_operation_field< Field, Op const & >
template<typename Field , typename Op > requires (!std::is_pointer_v<Field>)
	unary_operation_field (Field const &field, Op const &op) -> unary_operation_field< Field const &, Op const & >
template<typename Field , typename Op > requires (!std::is_pointer_v<Field>)
	unary_operation_field (Field &field, Op const &op) -> unary_operation_field< Field &, Op const & >
template<typename Field , typename Op > requires (!std::is_pointer_v<std::decay_t<Field>>)
	unary_operation_field (Field &&field, Op &op) -> unary_operation_field< Field, Op & >
template<typename Field , typename Op > requires (!std::is_pointer_v<Field>)
	unary_operation_field (Field const &field, Op &op) -> unary_operation_field< Field const &, Op & >
template<typename Field , typename Op > requires (!std::is_pointer_v<Field>)
	unary_operation_field (Field &field, Op &op) -> unary_operation_field< Field &, Op & >
template<typename Field , typename Op >
	unary_operation_field (Field *field, Op &&op) -> unary_operation_field< Field *, Op >
template<typename Field , typename Op >
	unary_operation_field (Field const *field, Op &&op) -> unary_operation_field< Field const *, Op >
template<typename Field , typename Op > requires (is_field<Field>) && (invocable<Op, field_tensor_type<Field>>)
constexpr auto	operator| (Field &&field, Op &&op)
template<typename Real , size_t N, typename Tensor , typename Op > requires (invocable<Op, Tensor>)
constexpr auto	operator| (polymorphic::field< Real, N, Tensor > *field, Op &&op)
template<typename Field , typename Real , typename DomainX , typename DomainY , typename DomainZ >
auto	extract_vortex_core_lines (vectorfield< Field, Real, 3 > const &v, integral auto const t, rectilinear_grid< DomainX, DomainY, DomainZ > const &g, algorithm::sujudi_haimes_tag const)
template<typename Field , typename Real , typename DomainX , typename DomainY , typename DomainZ >
auto	extract_vortex_core_lines (vectorfield< Field, Real, 3 > const &v, integral auto const t, rectilinear_grid< DomainX, DomainY, DomainZ > const &g)
template<typename Grid , typename Real , bool HasNonConstReference>
auto	extract_vortex_core_lines (detail::rectilinear_grid::typed_vertex_property_interface< Grid, vec< Real, 3 >, HasNonConstReference > const &v, algorithm::sujudi_haimes_tag const)
template<typename Grid , typename Real , bool HasNonConstReference>
auto	extract_vortex_core_lines (detail::rectilinear_grid::typed_vertex_property_interface< Grid, Vec3< Real >, HasNonConstReference > const &v, detail::rectilinear_grid::typed_vertex_property_interface< Grid, Mat3< Real >, HasNonConstReference > const &J, algorithm::sujudi_haimes_tag const)
template<typename Grid , typename Real , bool HasNonConstReference>
auto	extract_vortex_core_lines (detail::rectilinear_grid::typed_vertex_property_interface< Grid, vec< Real, 3 >, HasNonConstReference > const &v)
template<typename Grid , typename Real , bool HasNonConstReference>
auto	extract_vortex_core_lines (detail::rectilinear_grid::typed_vertex_property_interface< Grid, Vec3< Real >, HasNonConstReference > const &v, detail::rectilinear_grid::typed_vertex_property_interface< Grid, Mat3< Real >, HasNonConstReference > const &J)
template<typename V , typename Real >
auto	vorticity (const field< V, Real, 3, 3 > &vf)

Variables
static constexpr std::size_t	hardware_constructive_interference_size = 64
static constexpr std::size_t	hardware_destructive_interference_size = 64
template<const char... cs>
static constexpr std::string_view	c_str_assembler_v = c_str_assembler<cs...>::value
static constexpr bool	parallel_for_loop_support = true
template<typename F , std::size_t N>
static constexpr auto	is_invocable_with_n_integrals
template<typename F , std::size_t N>
static constexpr bool	is_invocable_with_n_floating_points
template<typename T >
static constexpr auto	is_cacheable_v = is_cacheable_impl<T>::value
template<typename T >
static constexpr auto	is_linspace = is_linspace_impl<T>::value
template<typename T >
static constexpr bool	is_polynomial = is_polynomial_impl<T>::value
template<typename ValueType >
static auto constexpr	is_random_number_generator
template<typename T >
static constexpr auto	is_symbolic_v = is_symbolic<T>::value
template<typename... Ts>
static constexpr auto	are_symbolic_v = are_symbolic<Ts...>::value
template<typename... Ts>
static constexpr auto	are_arithmetic_or_symbolic_v
template<typename... Ts>
static constexpr auto	are_arithmetic_complex_or_symbolic_v
static constexpr forward_tag	forward
static constexpr backward_tag	backward
auto constexpr	thin_plate_spline
auto constexpr	thin_plate_spline_from_squared
auto constexpr	thin_plate_spline_diff1
auto constexpr	thin_plate_spline_diff2
auto constexpr	thin_plate_spline_diff3
template<typename Counter , typename T >
static auto constexpr	type_counter_get_count
template<typename TypeList >
static auto constexpr	type_list_size = type_list_size_impl<TypeList>::value
	Size of a tatooine::type_list_impl. More...
template<typename TypeList , typename T >
static auto constexpr	type_list_contains
template<typename T >
static constexpr auto	type_exists
template<typename T >
static constexpr auto	is_pointer = std::is_pointer<T>::value
template<typename T >
static auto constexpr	is_array = is_array_impl<T>::value
template<typename... Ts>
static constexpr auto	is_same = is_same_impl<Ts...>::value
template<typename... Ts>
static constexpr auto	is_void = (is_same<Ts, void> && ...)
template<typename... Ts>
static constexpr auto	is_float = (is_same<Ts, float> && ...)
template<typename... Ts>
static constexpr auto	is_double = (is_same<Ts, double> && ...)
template<typename... Ts>
static constexpr auto	is_int = (is_same<Ts, int> && ...)
template<typename... Ts>
static constexpr auto	is_size_t = (is_same<Ts, size_t> && ...)
template<typename Query , typename... Others>
static constexpr auto	is_either_of = (is_same<Query, Others> || ...)
template<typename F , typename... Args>
static constexpr auto	is_invocable = std::is_invocable<F, Args...>::value
template<typename R , typename F , typename... Args>
static constexpr auto	is_invocable_r = std::is_invocable<R, F, Args...>::value
template<typename F , typename... Ts>
static constexpr auto	is_predicate
template<typename... Ts>
static constexpr auto	is_floating_point
template<typename... Ts>
static constexpr auto	is_arithmetic = (std::is_arithmetic<Ts>::value && ...)
template<typename... Ts>
static constexpr auto	is_integral = (std::is_integral<Ts>::value && ...)
template<typename... Ts>
static constexpr auto	is_const = (std::is_const<Ts>::value && ...)
template<typename... Ts>
static constexpr auto	is_non_const = (!std::is_const<Ts>::value && ...)
template<typename... Ts>
static constexpr auto	is_signed = (std::is_signed<Ts>::value && ...)
template<typename... Ts>
static constexpr auto	is_unsigned = (std::is_unsigned<Ts>::value && ...)
template<typename... Ts>
static constexpr auto	is_signed_integral
template<typename... Ts>
static constexpr auto	is_unsigned_integral
template<typename From , typename To >
static constexpr auto	is_convertible = std::is_convertible<From, To>::value
template<typename From >
static constexpr auto	is_convertible_to_integral
template<typename From >
static constexpr auto	is_convertible_to_floating_point
template<typename... Ts>
static constexpr auto	is_complex = (is_complex_impl<Ts>::value && ...)
template<typename... Ts>
static constexpr auto	is_arithmetic_or_complex
template<typename... Ts>
static constexpr auto	is_range = (is_range_impl<Ts>::value && ...)
template<typename... Ts>
static constexpr auto	is_indexable = (is_indexable_impl<Ts>::value && ...)
template<typename... Ts>
static constexpr auto	is_dereferencable
template<typename... Ts>
static constexpr auto	is_post_incrementable
template<typename T >
static constexpr auto	is_pre_incrementable
template<typename T >
static constexpr auto	is_post_decrementable
template<typename T >
static constexpr auto	is_pre_decrementable
template<typename T , typename S >
static constexpr auto	are_equality_comparable
template<typename T >
static constexpr auto	is_forward_iterator
template<typename T >
static constexpr auto	is_backward_iterator
template<typename T >
static constexpr auto	is_bidirectional_iterator
template<typename T >
static constexpr auto	is_pair = is_pair_impl<T>::value
template<static_tensor Tensor>
static auto constexpr	is_square = is_square_impl<Tensor>::value
template<typename T >
static constexpr auto	tensor_rank = tensor_rank_impl<T>::value
template<typename T >
static auto constexpr	tensor_num_components
template<typename T >
static auto constexpr	tensor_dimensions = tensor_dimensions_impl<T>::value
template<typename T , std::size_t I>
static auto constexpr	tensor_dimension = tensor_dimension_impl<T, I>::value
template<typename T >
static constexpr auto	is_edgeset = is_edgeset_impl<T>::value
template<typename T >
static auto constexpr	is_derived_from_hyper_ellipse
template<typename T >
static auto constexpr	is_line = is_line_impl<T>::value
template<typename T >
static constexpr auto	is_unstructured_triangular_grid
template<typename T >
static constexpr auto	is_differentiated_flowmap
template<typename T >
static constexpr bool	is_scalarfield = is_scalarfield_impl<T>::value
template<typename T >
static constexpr bool	is_vectorfield = is_vectorfield_impl<T>::value
template<typename T >
static constexpr auto	is_matrixfield = is_matrixfield_impl<T>::value
template<typename Field >
static constexpr auto	field_num_dimensions
template<typename T >
static constexpr auto	is_numerical_flowmap
template<typename T >
static constexpr auto	is_symbolic_field_v = is_symbolic<T>::value

Detailed Description

This wrapper is needed in case that std::filesystem is not available. This is the case for gcc 7.

Typedef Documentation

AABB

template<std::size_t NumDimensions>

using tatooine::AABB = typedef axis_aligned_bounding_box<real_number, NumDimensions>

aabb

template<typename Real , std::size_t NumDimensions>

using tatooine::aabb = typedef axis_aligned_bounding_box<Real, NumDimensions>

AABB2

template<typename Real >

using tatooine::AABB2 = typedef axis_aligned_bounding_box<Real, 2>

aabb2

using tatooine::aabb2 = typedef aabb<real_number, 2>

aabb2d

using tatooine::aabb2d = typedef aabb<double, 2>

aabb2f

using tatooine::aabb2f = typedef aabb<float, 2>

AABB3

template<typename Real >

using tatooine::AABB3 = typedef axis_aligned_bounding_box<Real, 3>

aabb3

using tatooine::aabb3 = typedef aabb<real_number, 3>

aabb3d

using tatooine::aabb3d = typedef aabb<double, 3>

aabb3f

using tatooine::aabb3f = typedef aabb<float, 3>

agranovsky_flowmap_discretization

template<typename Real , std::size_t NumDimensions>

using tatooine::agranovsky_flowmap_discretization = typedef staggered_flowmap_discretization< regular_flowmap_discretization<Real, NumDimensions> >

agranovsky_flowmap_discretization2

using tatooine::agranovsky_flowmap_discretization2 = typedef AgranovskyFlowmapDiscretization<2>

agranovsky_flowmap_discretization3

using tatooine::agranovsky_flowmap_discretization3 = typedef AgranovskyFlowmapDiscretization<3>

AgranovskyFlowmapDiscretization

template<std::size_t NumDimensions>

using tatooine::AgranovskyFlowmapDiscretization = typedef agranovsky_flowmap_discretization<real_number, NumDimensions>

AgranovskyFlowmapDiscretization2

template<typename Real >

using tatooine::AgranovskyFlowmapDiscretization2 = typedef agranovsky_flowmap_discretization<Real, 2>

AgranovskyFlowmapDiscretization3

template<typename Real >

using tatooine::AgranovskyFlowmapDiscretization3 = typedef agranovsky_flowmap_discretization<Real, 3>

autonomous_particle2

using tatooine::autonomous_particle2 = typedef AutonomousParticle<2>

autonomous_particle3

using tatooine::autonomous_particle3 = typedef AutonomousParticle<3>

autonomous_particle_flowmap_discretization2

template<typename SplitBehavior = typename autonomous_particle< real_number, 2>::split_behaviors::three_splits>

using tatooine::autonomous_particle_flowmap_discretization2 = typedef AutonomousParticleFlowmapDiscretization<2, SplitBehavior>

autonomous_particle_flowmap_discretization3

template<typename SplitBehavior = typename autonomous_particle< real_number, 3>::split_behaviors::three_splits>

using tatooine::autonomous_particle_flowmap_discretization3 = typedef AutonomousParticleFlowmapDiscretization<3, SplitBehavior>

AutonomousParticle

template<std::size_t NumDimensions>

using tatooine::AutonomousParticle = typedef autonomous_particle<real_number, NumDimensions>

AutonomousParticle2

template<floating_point Real>

using tatooine::AutonomousParticle2 = typedef autonomous_particle<Real, 2>

AutonomousParticle3

template<floating_point Real>

using tatooine::AutonomousParticle3 = typedef autonomous_particle<Real, 3>

AutonomousParticleFlowmapDiscretization

template<std::size_t NumDimensions, typename SplitBehavior = typename autonomous_particle< real_number, NumDimensions>::split_behaviors::three_splits>

using tatooine::AutonomousParticleFlowmapDiscretization = typedef autonomous_particle_flowmap_discretization<real_number, NumDimensions>

cast_tensor_real_type

template<typename CastedReal , typename Tensor >

using tatooine::cast_tensor_real_type = typedef typename cast_tensor_real<CastedReal, Tensor>::type

common_type

template<typename... Ts>

using tatooine::common_type = typedef typename common_type_impl<Ts...>::type

complex_mat

template<typename T , std::size_t M, std::size_t N>

using tatooine::complex_mat = typedef mat<std::complex<T>, M, N>

complex_mat2

using tatooine::complex_mat2 = typedef complex_mat22

complex_mat22

using tatooine::complex_mat22 = typedef ComplexMat<2, 2>

complex_mat22d

using tatooine::complex_mat22d = typedef ComplexMatD<2, 2>

complex_mat22f

using tatooine::complex_mat22f = typedef ComplexMatF<2, 2>

complex_mat23

using tatooine::complex_mat23 = typedef ComplexMat<2, 3>

complex_mat23d

using tatooine::complex_mat23d = typedef ComplexMatD<2, 3>

complex_mat23f

using tatooine::complex_mat23f = typedef ComplexMatF<2, 3>

complex_mat24

using tatooine::complex_mat24 = typedef ComplexMat<2, 4>

complex_mat24d

using tatooine::complex_mat24d = typedef ComplexMatD<2, 4>

complex_mat24f

using tatooine::complex_mat24f = typedef ComplexMatF<2, 4>

complex_mat25

using tatooine::complex_mat25 = typedef ComplexMat<2, 5>

complex_mat25d

using tatooine::complex_mat25d = typedef ComplexMatD<2, 5>

complex_mat25f

using tatooine::complex_mat25f = typedef ComplexMatF<2, 5>

complex_mat26

using tatooine::complex_mat26 = typedef ComplexMat<2, 6>

complex_mat26d

using tatooine::complex_mat26d = typedef ComplexMatD<2, 6>

complex_mat26f

using tatooine::complex_mat26f = typedef ComplexMatF<2, 6>

complex_mat27

using tatooine::complex_mat27 = typedef ComplexMat<2, 7>

complex_mat27d

using tatooine::complex_mat27d = typedef ComplexMatD<2, 7>

complex_mat27f

using tatooine::complex_mat27f = typedef ComplexMatF<2, 7>

complex_mat28

using tatooine::complex_mat28 = typedef ComplexMat<2, 8>

complex_mat28d

using tatooine::complex_mat28d = typedef ComplexMatD<2, 8>

complex_mat28f

using tatooine::complex_mat28f = typedef ComplexMatF<2, 8>

complex_mat29

using tatooine::complex_mat29 = typedef ComplexMat<2, 9>

complex_mat29d

using tatooine::complex_mat29d = typedef ComplexMatD<2, 9>

complex_mat29f

using tatooine::complex_mat29f = typedef ComplexMatF<2, 9>

complex_mat2d

using tatooine::complex_mat2d = typedef complex_mat22d

complex_mat2f

using tatooine::complex_mat2f = typedef complex_mat22f

complex_mat3

using tatooine::complex_mat3 = typedef complex_mat33

complex_mat32

using tatooine::complex_mat32 = typedef ComplexMat<3, 2>

complex_mat32d

using tatooine::complex_mat32d = typedef ComplexMatD<3, 2>

complex_mat32f

using tatooine::complex_mat32f = typedef ComplexMatF<3, 2>

complex_mat33

using tatooine::complex_mat33 = typedef ComplexMat<3, 3>

complex_mat33d

using tatooine::complex_mat33d = typedef ComplexMatD<3, 3>

complex_mat33f

using tatooine::complex_mat33f = typedef ComplexMatF<3, 3>

complex_mat34

using tatooine::complex_mat34 = typedef ComplexMat<3, 4>

complex_mat34d

using tatooine::complex_mat34d = typedef ComplexMatD<3, 4>

complex_mat34f

using tatooine::complex_mat34f = typedef ComplexMatF<3, 4>

complex_mat35

using tatooine::complex_mat35 = typedef ComplexMat<3, 5>

complex_mat35d

using tatooine::complex_mat35d = typedef ComplexMatD<3, 5>

complex_mat35f

using tatooine::complex_mat35f = typedef ComplexMatF<3, 5>

complex_mat36

using tatooine::complex_mat36 = typedef ComplexMat<3, 6>

complex_mat36d

using tatooine::complex_mat36d = typedef ComplexMatD<3, 6>

complex_mat36f

using tatooine::complex_mat36f = typedef ComplexMatF<3, 6>

complex_mat37

using tatooine::complex_mat37 = typedef ComplexMat<3, 7>

complex_mat37d

using tatooine::complex_mat37d = typedef ComplexMatD<3, 7>

complex_mat37f

using tatooine::complex_mat37f = typedef ComplexMatF<3, 7>

complex_mat38

using tatooine::complex_mat38 = typedef ComplexMat<3, 8>

complex_mat38d

using tatooine::complex_mat38d = typedef ComplexMatD<3, 8>

complex_mat38f

using tatooine::complex_mat38f = typedef ComplexMatF<3, 8>

complex_mat39

using tatooine::complex_mat39 = typedef ComplexMat<3, 9>

complex_mat39d

using tatooine::complex_mat39d = typedef ComplexMatD<3, 9>

complex_mat39f

using tatooine::complex_mat39f = typedef ComplexMatF<3, 9>

complex_mat3d

using tatooine::complex_mat3d = typedef complex_mat33d

complex_mat3f

using tatooine::complex_mat3f = typedef complex_mat33f

complex_mat4

using tatooine::complex_mat4 = typedef complex_mat44

complex_mat42

using tatooine::complex_mat42 = typedef ComplexMat<4, 2>

complex_mat42d

using tatooine::complex_mat42d = typedef ComplexMatD<4, 2>

complex_mat42f

using tatooine::complex_mat42f = typedef ComplexMatF<4, 2>

complex_mat43

using tatooine::complex_mat43 = typedef ComplexMat<4, 3>

complex_mat43d

using tatooine::complex_mat43d = typedef ComplexMatD<4, 3>

complex_mat43f

using tatooine::complex_mat43f = typedef ComplexMatF<4, 3>

complex_mat44

using tatooine::complex_mat44 = typedef ComplexMat<4, 4>

complex_mat44d

using tatooine::complex_mat44d = typedef ComplexMatD<4, 4>

complex_mat44f

using tatooine::complex_mat44f = typedef ComplexMatF<4, 4>

complex_mat45

using tatooine::complex_mat45 = typedef ComplexMat<4, 5>

complex_mat45d

using tatooine::complex_mat45d = typedef ComplexMatD<4, 5>

complex_mat45f

using tatooine::complex_mat45f = typedef ComplexMatF<4, 5>

complex_mat46

using tatooine::complex_mat46 = typedef ComplexMat<4, 6>

complex_mat46d

using tatooine::complex_mat46d = typedef ComplexMatD<4, 6>

complex_mat46f

using tatooine::complex_mat46f = typedef ComplexMatF<4, 6>

complex_mat47

using tatooine::complex_mat47 = typedef ComplexMat<4, 7>

complex_mat47d

using tatooine::complex_mat47d = typedef ComplexMatD<4, 7>

complex_mat47f

using tatooine::complex_mat47f = typedef ComplexMatF<4, 7>

complex_mat48

using tatooine::complex_mat48 = typedef ComplexMat<4, 8>

complex_mat48d

using tatooine::complex_mat48d = typedef ComplexMatD<4, 8>

complex_mat48f

using tatooine::complex_mat48f = typedef ComplexMatF<4, 8>

complex_mat49

using tatooine::complex_mat49 = typedef ComplexMat<4, 9>

complex_mat49d

using tatooine::complex_mat49d = typedef ComplexMatD<4, 9>

complex_mat49f

using tatooine::complex_mat49f = typedef ComplexMatF<4, 9>

complex_mat4d

using tatooine::complex_mat4d = typedef complex_mat44d

complex_mat4f

using tatooine::complex_mat4f = typedef complex_mat44f

complex_mat5

using tatooine::complex_mat5 = typedef complex_mat55

complex_mat52

using tatooine::complex_mat52 = typedef ComplexMat<5, 2>

complex_mat52d

using tatooine::complex_mat52d = typedef ComplexMatD<5, 2>

complex_mat52f

using tatooine::complex_mat52f = typedef ComplexMatF<5, 2>

complex_mat53

using tatooine::complex_mat53 = typedef ComplexMat<5, 3>

complex_mat53d

using tatooine::complex_mat53d = typedef ComplexMatD<5, 3>

complex_mat53f

using tatooine::complex_mat53f = typedef ComplexMatF<5, 3>

complex_mat54

using tatooine::complex_mat54 = typedef ComplexMat<5, 4>

complex_mat54d

using tatooine::complex_mat54d = typedef ComplexMatD<5, 4>

complex_mat54f

using tatooine::complex_mat54f = typedef ComplexMatF<5, 4>

complex_mat55

using tatooine::complex_mat55 = typedef ComplexMat<5, 5>

complex_mat55d

using tatooine::complex_mat55d = typedef ComplexMatD<5, 5>

complex_mat55f

using tatooine::complex_mat55f = typedef ComplexMatF<5, 5>

complex_mat56

using tatooine::complex_mat56 = typedef ComplexMat<5, 6>

complex_mat56d

using tatooine::complex_mat56d = typedef ComplexMatD<5, 6>

complex_mat56f

using tatooine::complex_mat56f = typedef ComplexMatF<5, 6>

complex_mat57

using tatooine::complex_mat57 = typedef ComplexMat<5, 7>

complex_mat57d

using tatooine::complex_mat57d = typedef ComplexMatD<5, 7>

complex_mat57f

using tatooine::complex_mat57f = typedef ComplexMatF<5, 7>

complex_mat58

using tatooine::complex_mat58 = typedef ComplexMat<5, 8>

complex_mat58d

using tatooine::complex_mat58d = typedef ComplexMatD<5, 8>

complex_mat58f

using tatooine::complex_mat58f = typedef ComplexMatF<5, 8>

complex_mat59

using tatooine::complex_mat59 = typedef ComplexMat<5, 9>

complex_mat59d

using tatooine::complex_mat59d = typedef ComplexMatD<5, 9>

complex_mat59f

using tatooine::complex_mat59f = typedef ComplexMatF<5, 9>

complex_mat5d

using tatooine::complex_mat5d = typedef complex_mat55d

complex_mat5f

using tatooine::complex_mat5f = typedef complex_mat55f

complex_mat6

using tatooine::complex_mat6 = typedef complex_mat66

complex_mat62

using tatooine::complex_mat62 = typedef ComplexMat<6, 2>

complex_mat62d

using tatooine::complex_mat62d = typedef ComplexMatD<6, 2>

complex_mat62f

using tatooine::complex_mat62f = typedef ComplexMatF<6, 2>

complex_mat63

using tatooine::complex_mat63 = typedef ComplexMat<6, 3>

complex_mat63d

using tatooine::complex_mat63d = typedef ComplexMatD<6, 3>

complex_mat63f

using tatooine::complex_mat63f = typedef ComplexMatF<6, 3>

complex_mat64

using tatooine::complex_mat64 = typedef ComplexMat<6, 4>

complex_mat64d

using tatooine::complex_mat64d = typedef ComplexMatD<6, 4>

complex_mat64f

using tatooine::complex_mat64f = typedef ComplexMatF<6, 4>

complex_mat65

using tatooine::complex_mat65 = typedef ComplexMat<6, 5>

complex_mat65d

using tatooine::complex_mat65d = typedef ComplexMatD<6, 5>

complex_mat65f

using tatooine::complex_mat65f = typedef ComplexMatF<6, 5>

complex_mat66

using tatooine::complex_mat66 = typedef ComplexMat<6, 6>

complex_mat66d

using tatooine::complex_mat66d = typedef ComplexMatD<6, 6>

complex_mat66f

using tatooine::complex_mat66f = typedef ComplexMatF<6, 6>

complex_mat67

using tatooine::complex_mat67 = typedef ComplexMat<6, 7>

complex_mat67d

using tatooine::complex_mat67d = typedef ComplexMatD<6, 7>

complex_mat67f

using tatooine::complex_mat67f = typedef ComplexMatF<6, 7>

complex_mat68

using tatooine::complex_mat68 = typedef ComplexMat<6, 8>

complex_mat68d

using tatooine::complex_mat68d = typedef ComplexMatD<6, 8>

complex_mat68f

using tatooine::complex_mat68f = typedef ComplexMatF<6, 8>

complex_mat69

using tatooine::complex_mat69 = typedef ComplexMat<6, 9>

complex_mat69d

using tatooine::complex_mat69d = typedef ComplexMatD<6, 9>

complex_mat69f

using tatooine::complex_mat69f = typedef ComplexMatF<6, 9>

complex_mat6d

using tatooine::complex_mat6d = typedef complex_mat66d

complex_mat6f

using tatooine::complex_mat6f = typedef complex_mat66f

complex_mat7

using tatooine::complex_mat7 = typedef complex_mat77

complex_mat72

using tatooine::complex_mat72 = typedef ComplexMat<7, 2>

complex_mat72d

using tatooine::complex_mat72d = typedef ComplexMatD<7, 2>

complex_mat72f

using tatooine::complex_mat72f = typedef ComplexMatF<7, 2>

complex_mat73

using tatooine::complex_mat73 = typedef ComplexMat<7, 3>

complex_mat73d

using tatooine::complex_mat73d = typedef ComplexMatD<7, 3>

complex_mat73f

using tatooine::complex_mat73f = typedef ComplexMatF<7, 3>

complex_mat74

using tatooine::complex_mat74 = typedef ComplexMat<7, 4>

complex_mat74d

using tatooine::complex_mat74d = typedef ComplexMatD<7, 4>

complex_mat74f

using tatooine::complex_mat74f = typedef ComplexMatF<7, 4>

complex_mat75

using tatooine::complex_mat75 = typedef ComplexMat<7, 5>

complex_mat75d

using tatooine::complex_mat75d = typedef ComplexMatD<7, 5>

complex_mat75f

using tatooine::complex_mat75f = typedef ComplexMatF<7, 5>

complex_mat76

using tatooine::complex_mat76 = typedef ComplexMat<7, 6>

complex_mat76d

using tatooine::complex_mat76d = typedef ComplexMatD<7, 6>

complex_mat76f

using tatooine::complex_mat76f = typedef ComplexMatF<7, 6>

complex_mat77

using tatooine::complex_mat77 = typedef ComplexMat<7, 7>

complex_mat77d

using tatooine::complex_mat77d = typedef ComplexMatD<7, 7>

complex_mat77f

using tatooine::complex_mat77f = typedef ComplexMatF<7, 7>

complex_mat78

using tatooine::complex_mat78 = typedef ComplexMat<7, 8>

complex_mat78d

using tatooine::complex_mat78d = typedef ComplexMatD<7, 8>

complex_mat78f

using tatooine::complex_mat78f = typedef ComplexMatF<7, 8>

complex_mat79

using tatooine::complex_mat79 = typedef ComplexMat<7, 9>

complex_mat79d

using tatooine::complex_mat79d = typedef ComplexMatD<7, 9>

complex_mat79f

using tatooine::complex_mat79f = typedef ComplexMatF<7, 9>

complex_mat7d

using tatooine::complex_mat7d = typedef complex_mat77d

complex_mat7f

using tatooine::complex_mat7f = typedef complex_mat77f

complex_mat8

using tatooine::complex_mat8 = typedef complex_mat88

complex_mat82

using tatooine::complex_mat82 = typedef ComplexMat<8, 2>

complex_mat82d

using tatooine::complex_mat82d = typedef ComplexMatD<8, 2>

complex_mat82f

using tatooine::complex_mat82f = typedef ComplexMatF<8, 2>

complex_mat83

using tatooine::complex_mat83 = typedef ComplexMat<8, 3>

complex_mat83d

using tatooine::complex_mat83d = typedef ComplexMatD<8, 3>

complex_mat83f

using tatooine::complex_mat83f = typedef ComplexMatF<8, 3>

complex_mat84

using tatooine::complex_mat84 = typedef ComplexMat<8, 4>

complex_mat84d

using tatooine::complex_mat84d = typedef ComplexMatD<8, 4>

complex_mat84f

using tatooine::complex_mat84f = typedef ComplexMatF<8, 4>

complex_mat85

using tatooine::complex_mat85 = typedef ComplexMat<8, 5>

complex_mat85d

using tatooine::complex_mat85d = typedef ComplexMatD<8, 5>

complex_mat85f

using tatooine::complex_mat85f = typedef ComplexMatF<8, 5>

complex_mat86

using tatooine::complex_mat86 = typedef ComplexMat<8, 6>

complex_mat86d

using tatooine::complex_mat86d = typedef ComplexMatD<8, 6>

complex_mat86f

using tatooine::complex_mat86f = typedef ComplexMatF<8, 6>

complex_mat87

using tatooine::complex_mat87 = typedef ComplexMat<8, 7>

complex_mat87d

using tatooine::complex_mat87d = typedef ComplexMatD<8, 7>

complex_mat87f

using tatooine::complex_mat87f = typedef ComplexMatF<8, 7>

complex_mat88

using tatooine::complex_mat88 = typedef ComplexMat<8, 8>

complex_mat88d

using tatooine::complex_mat88d = typedef ComplexMatD<8, 8>

complex_mat88f

using tatooine::complex_mat88f = typedef ComplexMatF<8, 8>

complex_mat89

using tatooine::complex_mat89 = typedef ComplexMat<8, 9>

complex_mat89d

using tatooine::complex_mat89d = typedef ComplexMatD<8, 9>

complex_mat89f

using tatooine::complex_mat89f = typedef ComplexMatF<8, 9>

complex_mat8d

using tatooine::complex_mat8d = typedef complex_mat88d

complex_mat8f

using tatooine::complex_mat8f = typedef complex_mat88f

complex_mat9

using tatooine::complex_mat9 = typedef complex_mat99

complex_mat92

using tatooine::complex_mat92 = typedef ComplexMat<9, 2>

complex_mat92d

using tatooine::complex_mat92d = typedef ComplexMatD<9, 2>

complex_mat92f

using tatooine::complex_mat92f = typedef ComplexMatF<9, 2>

complex_mat93

using tatooine::complex_mat93 = typedef ComplexMat<9, 3>

complex_mat93d

using tatooine::complex_mat93d = typedef ComplexMatD<9, 3>

complex_mat93f

using tatooine::complex_mat93f = typedef ComplexMatF<9, 3>

complex_mat94

using tatooine::complex_mat94 = typedef ComplexMat<9, 4>

complex_mat94d

using tatooine::complex_mat94d = typedef ComplexMatD<9, 4>

complex_mat94f

using tatooine::complex_mat94f = typedef ComplexMatF<9, 4>

complex_mat95

using tatooine::complex_mat95 = typedef ComplexMat<9, 5>

complex_mat95d

using tatooine::complex_mat95d = typedef ComplexMatD<9, 5>

complex_mat95f

using tatooine::complex_mat95f = typedef ComplexMatF<9, 5>

complex_mat96

using tatooine::complex_mat96 = typedef ComplexMat<9, 6>

complex_mat96d

using tatooine::complex_mat96d = typedef ComplexMatD<9, 6>

complex_mat96f

using tatooine::complex_mat96f = typedef ComplexMatF<9, 6>

complex_mat97

using tatooine::complex_mat97 = typedef ComplexMat<9, 7>

complex_mat97d

using tatooine::complex_mat97d = typedef ComplexMatD<9, 7>

complex_mat97f

using tatooine::complex_mat97f = typedef ComplexMatF<9, 7>

complex_mat98

using tatooine::complex_mat98 = typedef ComplexMat<9, 8>

complex_mat98d

using tatooine::complex_mat98d = typedef ComplexMatD<9, 8>

complex_mat98f

using tatooine::complex_mat98f = typedef ComplexMatF<9, 8>

complex_mat99

using tatooine::complex_mat99 = typedef ComplexMat<9, 9>

complex_mat99d

using tatooine::complex_mat99d = typedef ComplexMatD<9, 9>

complex_mat99f

using tatooine::complex_mat99f = typedef ComplexMatF<9, 9>

complex_mat9d

using tatooine::complex_mat9d = typedef complex_mat99d

complex_mat9f

using tatooine::complex_mat9f = typedef complex_mat99f

complex_tensor

template<typename T , std::size_t... Dims>

using tatooine::complex_tensor = typedef tensor<std::complex<T>, Dims...>

complex_vec

template<typename T , std::size_t N>

using tatooine::complex_vec = typedef vec<std::complex<T>, N>

complex_vec2

using tatooine::complex_vec2 = typedef ComplexVec<2>

complex_vec2d

using tatooine::complex_vec2d = typedef ComplexVecD<2>

complex_vec2f

using tatooine::complex_vec2f = typedef ComplexVecF<2>

complex_vec3

using tatooine::complex_vec3 = typedef ComplexVec<3>

complex_vec3d

using tatooine::complex_vec3d = typedef ComplexVecD<3>

complex_vec3f

using tatooine::complex_vec3f = typedef ComplexVecF<3>

complex_vec4

using tatooine::complex_vec4 = typedef ComplexVec<4>

complex_vec4d

using tatooine::complex_vec4d = typedef ComplexVecD<4>

complex_vec4f

using tatooine::complex_vec4f = typedef ComplexVecF<4>

complex_vec5

using tatooine::complex_vec5 = typedef ComplexVec<5>

complex_vec5d

using tatooine::complex_vec5d = typedef ComplexVecD<5>

complex_vec5f

using tatooine::complex_vec5f = typedef ComplexVecF<5>

complex_vec6

using tatooine::complex_vec6 = typedef ComplexVec<6>

complex_vec6d

using tatooine::complex_vec6d = typedef ComplexVecD<6>

complex_vec6f

using tatooine::complex_vec6f = typedef ComplexVecF<6>

complex_vec7

using tatooine::complex_vec7 = typedef ComplexVec<7>

complex_vec7d

using tatooine::complex_vec7d = typedef ComplexVecD<7>

complex_vec7f

using tatooine::complex_vec7f = typedef ComplexVecF<7>

complex_vec8

using tatooine::complex_vec8 = typedef ComplexVec<8>

complex_vec8d

using tatooine::complex_vec8d = typedef ComplexVecD<8>

complex_vec8f

using tatooine::complex_vec8f = typedef ComplexVecF<8>

complex_vec9

using tatooine::complex_vec9 = typedef ComplexVec<9>

complex_vec9d

using tatooine::complex_vec9d = typedef ComplexVecD<9>

complex_vec9f

using tatooine::complex_vec9f = typedef ComplexVecF<9>

ComplexMat

template<std::size_t M, std::size_t N>

using tatooine::ComplexMat = typedef complex_mat<real_number, M, N>

ComplexMatD

template<std::size_t M, std::size_t N>

using tatooine::ComplexMatD = typedef complex_mat<double, M, N>

ComplexMatF

template<std::size_t M, std::size_t N>

using tatooine::ComplexMatF = typedef complex_mat<float, M, N>

ComplexTensor

template<std::size_t ... Dims>

using tatooine::ComplexTensor = typedef tensor<std::complex<real_number>, Dims...>

ComplexTensorD

template<std::size_t ... Dims>

using tatooine::ComplexTensorD = typedef tensor<std::complex<double>, Dims...>

ComplexTensorF

template<std::size_t ... Dims>

using tatooine::ComplexTensorF = typedef tensor<std::complex<float>, Dims...>

ComplexVec

template<std::size_t N>

using tatooine::ComplexVec = typedef vec<std::complex<real_number>, N>

ComplexVec2

template<typename T >

using tatooine::ComplexVec2 = typedef vec<std::complex<T>, 2>

ComplexVec3

template<typename T >

using tatooine::ComplexVec3 = typedef vec<std::complex<T>, 3>

ComplexVec4

template<typename T >

using tatooine::ComplexVec4 = typedef vec<std::complex<T>, 4>

ComplexVec5

template<typename T >

using tatooine::ComplexVec5 = typedef vec<std::complex<T>, 5>

ComplexVec6

template<typename T >

using tatooine::ComplexVec6 = typedef vec<std::complex<T>, 6>

ComplexVec7

template<typename T >

using tatooine::ComplexVec7 = typedef vec<std::complex<T>, 7>

ComplexVec8

template<typename T >

using tatooine::ComplexVec8 = typedef vec<std::complex<T>, 8>

ComplexVec9

template<typename T >

using tatooine::ComplexVec9 = typedef vec<std::complex<T>, 9>

ComplexVecD

template<std::size_t N>

using tatooine::ComplexVecD = typedef vec<std::complex<double>, N>

ComplexVecF

template<std::size_t N>

using tatooine::ComplexVecF = typedef vec<std::complex<float>, N>

const_method_ptr

template<typename T , typename Ret , typename ... Args>

using tatooine::const_method_ptr = typedef Ret (T::*)(Args...) const

Edgeset

template<std::size_t NumDimensions>

using tatooine::Edgeset = typedef edgeset<real_number, NumDimensions>

Edgeset2

template<floating_point Real>

using tatooine::Edgeset2 = typedef edgeset<Real, 2>

edgeset2

using tatooine::edgeset2 = typedef Edgeset<2>

Edgeset3

template<floating_point Real>

using tatooine::Edgeset3 = typedef edgeset<Real, 3>

edgeset3

using tatooine::edgeset3 = typedef Edgeset<3>

Edgeset4

template<floating_point Real>

using tatooine::Edgeset4 = typedef edgeset<Real, 4>

edgeset4

using tatooine::edgeset4 = typedef Edgeset<4>

Edgeset5

template<floating_point Real>

using tatooine::Edgeset5 = typedef edgeset<Real, 5>

edgeset5

using tatooine::edgeset5 = typedef Edgeset<5>

field_list

template<typename Real , std::size_t NumDimensions, typename Tensor >

using tatooine::field_list = typedef std::vector< std::unique_ptr<polymorphic::field<Real, NumDimensions, Tensor> >>

field_pos_type

template<typename Field >

using tatooine::field_pos_type = typedef typename std::decay_t< std::remove_pointer_t<std::decay_t<Field> >>::pos_type

field_real_type

template<typename Field >

using tatooine::field_real_type = typedef typename std::decay_t< std::remove_pointer_t<std::decay_t<Field> >>::real_type

field_tensor_type

template<typename Field >

using tatooine::field_tensor_type = typedef typename std::decay_t< std::remove_pointer_t<std::decay_t<Field> >>::tensor_type

get

template<typename Container , std::size_t I>

using tatooine::get = typedef typename get_impl<Container, I>::type

infer_difference_type

template<typename Iter >

using tatooine::infer_difference_type = typedef typename infer_difference_type_impl<Iter>::type

infer_value_type

template<typename T >

using tatooine::infer_value_type = typedef typename infer_value_type_impl<T>::type

internal_data_type_t

template<typename T >

using tatooine::internal_data_type_t = typedef typename internal_data_type<T>::type

invoke_result

template<typename F , typename... Args>

using tatooine::invoke_result = typedef std::invoke_result_t<F, Args...>

Line

template<std::size_t NumDimensions>

using tatooine::Line = typedef line<real_number, NumDimensions>

Line2

template<typename T >

using tatooine::Line2 = typedef line<T, 2>

line2

using tatooine::line2 = typedef Line<2>

Line3

template<typename T >

using tatooine::Line3 = typedef line<T, 3>

line3

using tatooine::line3 = typedef Line<3>

Line4

template<typename T >

using tatooine::Line4 = typedef line<T, 4>

line4

using tatooine::line4 = typedef Line<4>

Line5

template<typename T >

using tatooine::Line5 = typedef line<T, 5>

line5

using tatooine::line5 = typedef Line<5>

Mat

template<std::size_t M, std::size_t N>

using tatooine::Mat = typedef mat<real_number, M, N>

Mat2

template<typename T >

using tatooine::Mat2 = typedef Mat22<T>

mat2

using tatooine::mat2 = typedef mat22

Mat22

template<typename T >

using tatooine::Mat22 = typedef mat<T, 2, 2>

mat22

using tatooine::mat22 = typedef Mat<2, 2>

mat22d

using tatooine::mat22d = typedef MatD<2, 2>

mat22f

using tatooine::mat22f = typedef MatF<2, 2>

Mat23

template<typename T >

using tatooine::Mat23 = typedef mat<T, 2, 3>

mat23

using tatooine::mat23 = typedef Mat<2, 3>

mat23d

using tatooine::mat23d = typedef MatD<2, 3>

mat23f

using tatooine::mat23f = typedef MatF<2, 3>

Mat24

template<typename T >

using tatooine::Mat24 = typedef mat<T, 2, 4>

mat24

using tatooine::mat24 = typedef Mat<2, 4>

mat24d

using tatooine::mat24d = typedef MatD<2, 4>

mat24f

using tatooine::mat24f = typedef MatF<2, 4>

Mat25

template<typename T >

using tatooine::Mat25 = typedef mat<T, 2, 5>

mat25

using tatooine::mat25 = typedef Mat<2, 5>

mat25d

using tatooine::mat25d = typedef MatD<2, 5>

mat25f

using tatooine::mat25f = typedef MatF<2, 5>

Mat26

template<typename T >

using tatooine::Mat26 = typedef mat<T, 2, 6>

mat26

using tatooine::mat26 = typedef Mat<2, 6>

mat26d

using tatooine::mat26d = typedef MatD<2, 6>

mat26f

using tatooine::mat26f = typedef MatF<2, 6>

Mat27

template<typename T >

using tatooine::Mat27 = typedef mat<T, 2, 7>

mat27

using tatooine::mat27 = typedef Mat<2, 7>

mat27d

using tatooine::mat27d = typedef MatD<2, 7>

mat27f

using tatooine::mat27f = typedef MatF<2, 7>

Mat28

template<typename T >

using tatooine::Mat28 = typedef mat<T, 2, 8>

mat28

using tatooine::mat28 = typedef Mat<2, 8>

mat28d

using tatooine::mat28d = typedef MatD<2, 8>

mat28f

using tatooine::mat28f = typedef MatF<2, 8>

Mat29

template<typename T >

using tatooine::Mat29 = typedef mat<T, 2, 9>

mat29

using tatooine::mat29 = typedef Mat<2, 9>

mat29d

using tatooine::mat29d = typedef MatD<2, 9>

mat29f

using tatooine::mat29f = typedef MatF<2, 9>

mat2d

using tatooine::mat2d = typedef mat22d

mat2f

using tatooine::mat2f = typedef mat22f

Mat3

template<typename T >

using tatooine::Mat3 = typedef Mat33<T>

mat3

using tatooine::mat3 = typedef mat33

Mat32

template<typename T >

using tatooine::Mat32 = typedef mat<T, 3, 2>

mat32

using tatooine::mat32 = typedef Mat<3, 2>

mat32d

using tatooine::mat32d = typedef MatD<3, 2>

mat32f

using tatooine::mat32f = typedef MatF<3, 2>

Mat33

template<typename T >

using tatooine::Mat33 = typedef mat<T, 3, 3>

mat33

using tatooine::mat33 = typedef Mat<3, 3>

mat33d

using tatooine::mat33d = typedef MatD<3, 3>

mat33f

using tatooine::mat33f = typedef MatF<3, 3>

Mat34

template<typename T >

using tatooine::Mat34 = typedef mat<T, 3, 4>

mat34

using tatooine::mat34 = typedef Mat<3, 4>

mat34d

using tatooine::mat34d = typedef MatD<3, 4>

mat34f

using tatooine::mat34f = typedef MatF<3, 4>

Mat35

template<typename T >

using tatooine::Mat35 = typedef mat<T, 3, 5>

mat35

using tatooine::mat35 = typedef Mat<3, 5>

mat35d

using tatooine::mat35d = typedef MatD<3, 5>

mat35f

using tatooine::mat35f = typedef MatF<3, 5>

Mat36

template<typename T >

using tatooine::Mat36 = typedef mat<T, 3, 6>

mat36

using tatooine::mat36 = typedef Mat<3, 6>

mat36d

using tatooine::mat36d = typedef MatD<3, 6>

mat36f

using tatooine::mat36f = typedef MatF<3, 6>

Mat37

template<typename T >

using tatooine::Mat37 = typedef mat<T, 3, 7>

mat37

using tatooine::mat37 = typedef Mat<3, 7>

mat37d

using tatooine::mat37d = typedef MatD<3, 7>

mat37f

using tatooine::mat37f = typedef MatF<3, 7>

Mat38

template<typename T >

using tatooine::Mat38 = typedef mat<T, 3, 8>

mat38

using tatooine::mat38 = typedef Mat<3, 8>

mat38d

using tatooine::mat38d = typedef MatD<3, 8>

mat38f

using tatooine::mat38f = typedef MatF<3, 8>

Mat39

template<typename T >

using tatooine::Mat39 = typedef mat<T, 3, 9>

mat39

using tatooine::mat39 = typedef Mat<3, 9>

mat39d

using tatooine::mat39d = typedef MatD<3, 9>

mat39f

using tatooine::mat39f = typedef MatF<3, 9>

mat3d

using tatooine::mat3d = typedef mat33d

mat3f

using tatooine::mat3f = typedef mat33f

Mat4

template<typename T >

using tatooine::Mat4 = typedef Mat44<T>

mat4

using tatooine::mat4 = typedef mat44

Mat42

template<typename T >

using tatooine::Mat42 = typedef mat<T, 4, 2>

mat42

using tatooine::mat42 = typedef Mat<4, 2>

mat42d

using tatooine::mat42d = typedef MatD<4, 2>

mat42f

using tatooine::mat42f = typedef MatF<4, 2>

Mat43

template<typename T >

using tatooine::Mat43 = typedef mat<T, 4, 3>

mat43

using tatooine::mat43 = typedef Mat<4, 3>

mat43d

using tatooine::mat43d = typedef MatD<4, 3>

mat43f

using tatooine::mat43f = typedef MatF<4, 3>

Mat44

template<typename T >

using tatooine::Mat44 = typedef mat<T, 4, 4>

mat44

using tatooine::mat44 = typedef Mat<4, 4>

mat44d

using tatooine::mat44d = typedef MatD<4, 4>

mat44f

using tatooine::mat44f = typedef MatF<4, 4>

Mat45

template<typename T >

using tatooine::Mat45 = typedef mat<T, 4, 5>

mat45

using tatooine::mat45 = typedef Mat<4, 5>

mat45d

using tatooine::mat45d = typedef MatD<4, 5>

mat45f

using tatooine::mat45f = typedef MatF<4, 5>

Mat46

template<typename T >

using tatooine::Mat46 = typedef mat<T, 4, 6>

mat46

using tatooine::mat46 = typedef Mat<4, 6>

mat46d

using tatooine::mat46d = typedef MatD<4, 6>

mat46f

using tatooine::mat46f = typedef MatF<4, 6>

Mat47

template<typename T >

using tatooine::Mat47 = typedef mat<T, 4, 7>

mat47

using tatooine::mat47 = typedef Mat<4, 7>

mat47d

using tatooine::mat47d = typedef MatD<4, 7>

mat47f

using tatooine::mat47f = typedef MatF<4, 7>

Mat48

template<typename T >

using tatooine::Mat48 = typedef mat<T, 4, 8>

mat48

using tatooine::mat48 = typedef Mat<4, 8>

mat48d

using tatooine::mat48d = typedef MatD<4, 8>

mat48f

using tatooine::mat48f = typedef MatF<4, 8>

Mat49

template<typename T >

using tatooine::Mat49 = typedef mat<T, 4, 9>

mat49

using tatooine::mat49 = typedef Mat<4, 9>

mat49d

using tatooine::mat49d = typedef MatD<4, 9>

mat49f

using tatooine::mat49f = typedef MatF<4, 9>

mat4d

using tatooine::mat4d = typedef mat44d

mat4f

using tatooine::mat4f = typedef mat44f

Mat5

template<typename T >

using tatooine::Mat5 = typedef Mat55<T>

mat5

using tatooine::mat5 = typedef mat55

Mat52

template<typename T >

using tatooine::Mat52 = typedef mat<T, 5, 2>

mat52

using tatooine::mat52 = typedef Mat<5, 2>

mat52d

using tatooine::mat52d = typedef MatD<5, 2>

mat52f

using tatooine::mat52f = typedef MatF<5, 2>

Mat53

template<typename T >

using tatooine::Mat53 = typedef mat<T, 5, 3>

mat53

using tatooine::mat53 = typedef Mat<5, 3>

mat53d

using tatooine::mat53d = typedef MatD<5, 3>

mat53f

using tatooine::mat53f = typedef MatF<5, 3>

Mat54

template<typename T >

using tatooine::Mat54 = typedef mat<T, 5, 4>

mat54

using tatooine::mat54 = typedef Mat<5, 4>

mat54d

using tatooine::mat54d = typedef MatD<5, 4>

mat54f

using tatooine::mat54f = typedef MatF<5, 4>

Mat55

template<typename T >

using tatooine::Mat55 = typedef mat<T, 5, 5>

mat55

using tatooine::mat55 = typedef Mat<5, 5>

mat55d

using tatooine::mat55d = typedef MatD<5, 5>

mat55f

using tatooine::mat55f = typedef MatF<5, 5>

Mat56

template<typename T >

using tatooine::Mat56 = typedef mat<T, 5, 6>

mat56

using tatooine::mat56 = typedef Mat<5, 6>

mat56d

using tatooine::mat56d = typedef MatD<5, 6>

mat56f

using tatooine::mat56f = typedef MatF<5, 6>

Mat57

template<typename T >

using tatooine::Mat57 = typedef mat<T, 5, 7>

mat57

using tatooine::mat57 = typedef Mat<5, 7>

mat57d

using tatooine::mat57d = typedef MatD<5, 7>

mat57f

using tatooine::mat57f = typedef MatF<5, 7>

Mat58

template<typename T >

using tatooine::Mat58 = typedef mat<T, 5, 8>

mat58

using tatooine::mat58 = typedef Mat<5, 8>

mat58d

using tatooine::mat58d = typedef MatD<5, 8>

mat58f

using tatooine::mat58f = typedef MatF<5, 8>

Mat59

template<typename T >

using tatooine::Mat59 = typedef mat<T, 5, 9>

mat59

using tatooine::mat59 = typedef Mat<5, 9>

mat59d

using tatooine::mat59d = typedef MatD<5, 9>

mat59f

using tatooine::mat59f = typedef MatF<5, 9>

mat5d

using tatooine::mat5d = typedef mat55d

mat5f

using tatooine::mat5f = typedef mat55f

Mat6

template<typename T >

using tatooine::Mat6 = typedef Mat66<T>

mat6

using tatooine::mat6 = typedef mat66

Mat62

template<typename T >

using tatooine::Mat62 = typedef mat<T, 6, 2>

mat62

using tatooine::mat62 = typedef Mat<6, 2>

mat62d

using tatooine::mat62d = typedef MatD<6, 2>

mat62f

using tatooine::mat62f = typedef MatF<6, 2>

Mat63

template<typename T >

using tatooine::Mat63 = typedef mat<T, 6, 3>

mat63

using tatooine::mat63 = typedef Mat<6, 3>

mat63d

using tatooine::mat63d = typedef MatD<6, 3>

mat63f

using tatooine::mat63f = typedef MatF<6, 3>

Mat64

template<typename T >

using tatooine::Mat64 = typedef mat<T, 6, 4>

mat64

using tatooine::mat64 = typedef Mat<6, 4>

mat64d

using tatooine::mat64d = typedef MatD<6, 4>

mat64f

using tatooine::mat64f = typedef MatF<6, 4>

Mat65

template<typename T >

using tatooine::Mat65 = typedef mat<T, 6, 5>

mat65

using tatooine::mat65 = typedef Mat<6, 5>

mat65d

using tatooine::mat65d = typedef MatD<6, 5>

mat65f

using tatooine::mat65f = typedef MatF<6, 5>

Mat66

template<typename T >

using tatooine::Mat66 = typedef mat<T, 6, 6>

mat66

using tatooine::mat66 = typedef Mat<6, 6>

mat66d

using tatooine::mat66d = typedef MatD<6, 6>

mat66f

using tatooine::mat66f = typedef MatF<6, 6>

Mat67

template<typename T >

using tatooine::Mat67 = typedef mat<T, 6, 7>

mat67

using tatooine::mat67 = typedef Mat<6, 7>

mat67d

using tatooine::mat67d = typedef MatD<6, 7>

mat67f

using tatooine::mat67f = typedef MatF<6, 7>

Mat68

template<typename T >

using tatooine::Mat68 = typedef mat<T, 6, 8>

mat68

using tatooine::mat68 = typedef Mat<6, 8>

mat68d

using tatooine::mat68d = typedef MatD<6, 8>

mat68f

using tatooine::mat68f = typedef MatF<6, 8>

Mat69

template<typename T >

using tatooine::Mat69 = typedef mat<T, 6, 9>

mat69

using tatooine::mat69 = typedef Mat<6, 9>

mat69d

using tatooine::mat69d = typedef MatD<6, 9>

mat69f

using tatooine::mat69f = typedef MatF<6, 9>

mat6d

using tatooine::mat6d = typedef mat66d

mat6f

using tatooine::mat6f = typedef mat66f

Mat7

template<typename T >

using tatooine::Mat7 = typedef Mat77<T>

mat7

using tatooine::mat7 = typedef mat77

Mat72

template<typename T >

using tatooine::Mat72 = typedef mat<T, 7, 2>

mat72

using tatooine::mat72 = typedef Mat<7, 2>

mat72d

using tatooine::mat72d = typedef MatD<7, 2>

mat72f

using tatooine::mat72f = typedef MatF<7, 2>

Mat73

template<typename T >

using tatooine::Mat73 = typedef mat<T, 7, 3>

mat73

using tatooine::mat73 = typedef Mat<7, 3>

mat73d

using tatooine::mat73d = typedef MatD<7, 3>

mat73f

using tatooine::mat73f = typedef MatF<7, 3>

Mat74

template<typename T >

using tatooine::Mat74 = typedef mat<T, 7, 4>

mat74

using tatooine::mat74 = typedef Mat<7, 4>

mat74d

using tatooine::mat74d = typedef MatD<7, 4>

mat74f

using tatooine::mat74f = typedef MatF<7, 4>

Mat75

template<typename T >

using tatooine::Mat75 = typedef mat<T, 7, 5>

mat75

using tatooine::mat75 = typedef Mat<7, 5>

mat75d

using tatooine::mat75d = typedef MatD<7, 5>

mat75f

using tatooine::mat75f = typedef MatF<7, 5>

Mat76

template<typename T >

using tatooine::Mat76 = typedef mat<T, 7, 6>

mat76

using tatooine::mat76 = typedef Mat<7, 6>

mat76d

using tatooine::mat76d = typedef MatD<7, 6>

mat76f

using tatooine::mat76f = typedef MatF<7, 6>

Mat77

template<typename T >

using tatooine::Mat77 = typedef mat<T, 7, 7>

mat77

using tatooine::mat77 = typedef Mat<7, 7>

mat77d

using tatooine::mat77d = typedef MatD<7, 7>

mat77f

using tatooine::mat77f = typedef MatF<7, 7>

Mat78

template<typename T >

using tatooine::Mat78 = typedef mat<T, 7, 8>

mat78

using tatooine::mat78 = typedef Mat<7, 8>

mat78d

using tatooine::mat78d = typedef MatD<7, 8>

mat78f

using tatooine::mat78f = typedef MatF<7, 8>

Mat79

template<typename T >

using tatooine::Mat79 = typedef mat<T, 7, 9>

mat79

using tatooine::mat79 = typedef Mat<7, 9>

mat79d

using tatooine::mat79d = typedef MatD<7, 9>

mat79f

using tatooine::mat79f = typedef MatF<7, 9>

mat7d

using tatooine::mat7d = typedef mat77d

mat7f

using tatooine::mat7f = typedef mat77f

Mat8

template<typename T >

using tatooine::Mat8 = typedef Mat88<T>

mat8

using tatooine::mat8 = typedef mat88

Mat82

template<typename T >

using tatooine::Mat82 = typedef mat<T, 8, 2>

mat82

using tatooine::mat82 = typedef Mat<8, 2>

mat82d

using tatooine::mat82d = typedef MatD<8, 2>

mat82f

using tatooine::mat82f = typedef MatF<8, 2>

Mat83

template<typename T >

using tatooine::Mat83 = typedef mat<T, 8, 3>

mat83

using tatooine::mat83 = typedef Mat<8, 3>

mat83d

using tatooine::mat83d = typedef MatD<8, 3>

mat83f

using tatooine::mat83f = typedef MatF<8, 3>

Mat84

template<typename T >

using tatooine::Mat84 = typedef mat<T, 8, 4>

mat84

using tatooine::mat84 = typedef Mat<8, 4>

mat84d

using tatooine::mat84d = typedef MatD<8, 4>

mat84f

using tatooine::mat84f = typedef MatF<8, 4>

Mat85

template<typename T >

using tatooine::Mat85 = typedef mat<T, 8, 5>

mat85

using tatooine::mat85 = typedef Mat<8, 5>

mat85d

using tatooine::mat85d = typedef MatD<8, 5>

mat85f

using tatooine::mat85f = typedef MatF<8, 5>

Mat86

template<typename T >

using tatooine::Mat86 = typedef mat<T, 8, 6>

mat86

using tatooine::mat86 = typedef Mat<8, 6>

mat86d

using tatooine::mat86d = typedef MatD<8, 6>

mat86f

using tatooine::mat86f = typedef MatF<8, 6>

Mat87

template<typename T >

using tatooine::Mat87 = typedef mat<T, 8, 7>

mat87

using tatooine::mat87 = typedef Mat<8, 7>

mat87d

using tatooine::mat87d = typedef MatD<8, 7>

mat87f

using tatooine::mat87f = typedef MatF<8, 7>

Mat88

template<typename T >

using tatooine::Mat88 = typedef mat<T, 8, 8>

mat88

using tatooine::mat88 = typedef Mat<8, 8>

mat88d

using tatooine::mat88d = typedef MatD<8, 8>

mat88f

using tatooine::mat88f = typedef MatF<8, 8>

Mat89

template<typename T >

using tatooine::Mat89 = typedef mat<T, 8, 9>

mat89

using tatooine::mat89 = typedef Mat<8, 9>

mat89d

using tatooine::mat89d = typedef MatD<8, 9>

mat89f

using tatooine::mat89f = typedef MatF<8, 9>

mat8d

using tatooine::mat8d = typedef mat88d

mat8f

using tatooine::mat8f = typedef mat88f

Mat9

template<typename T >

using tatooine::Mat9 = typedef Mat99<T>

mat9

using tatooine::mat9 = typedef mat99

Mat92

template<typename T >

using tatooine::Mat92 = typedef mat<T, 9, 2>

mat92

using tatooine::mat92 = typedef Mat<9, 2>

mat92d

using tatooine::mat92d = typedef MatD<9, 2>

mat92f

using tatooine::mat92f = typedef MatF<9, 2>

Mat93

template<typename T >

using tatooine::Mat93 = typedef mat<T, 9, 3>

mat93

using tatooine::mat93 = typedef Mat<9, 3>

mat93d

using tatooine::mat93d = typedef MatD<9, 3>

mat93f

using tatooine::mat93f = typedef MatF<9, 3>

Mat94

template<typename T >

using tatooine::Mat94 = typedef mat<T, 9, 4>

mat94

using tatooine::mat94 = typedef Mat<9, 4>

mat94d

using tatooine::mat94d = typedef MatD<9, 4>

mat94f

using tatooine::mat94f = typedef MatF<9, 4>

Mat95

template<typename T >

using tatooine::Mat95 = typedef mat<T, 9, 5>

mat95

using tatooine::mat95 = typedef Mat<9, 5>

mat95d

using tatooine::mat95d = typedef MatD<9, 5>

mat95f

using tatooine::mat95f = typedef MatF<9, 5>

Mat96

template<typename T >

using tatooine::Mat96 = typedef mat<T, 9, 6>

mat96

using tatooine::mat96 = typedef Mat<9, 6>

mat96d

using tatooine::mat96d = typedef MatD<9, 6>

mat96f

using tatooine::mat96f = typedef MatF<9, 6>

Mat97

template<typename T >

using tatooine::Mat97 = typedef mat<T, 9, 7>

mat97

using tatooine::mat97 = typedef Mat<9, 7>

mat97d

using tatooine::mat97d = typedef MatD<9, 7>

mat97f

using tatooine::mat97f = typedef MatF<9, 7>

Mat98

template<typename T >

using tatooine::Mat98 = typedef mat<T, 9, 8>

mat98

using tatooine::mat98 = typedef Mat<9, 8>

mat98d

using tatooine::mat98d = typedef MatD<9, 8>

mat98f

using tatooine::mat98f = typedef MatF<9, 8>

Mat99

template<typename T >

using tatooine::Mat99 = typedef mat<T, 9, 9>

mat99

using tatooine::mat99 = typedef Mat<9, 9>

mat99d

using tatooine::mat99d = typedef MatD<9, 9>

mat99f

using tatooine::mat99f = typedef MatF<9, 9>

mat9d

using tatooine::mat9d = typedef mat99d

mat9f

using tatooine::mat9f = typedef mat99f

MatD

template<std::size_t M, std::size_t N>

using tatooine::MatD = typedef mat<double, M, N>

MatF

template<std::size_t M, std::size_t N>

using tatooine::MatF = typedef mat<float, M, N>

matrixfield

template<typename V , typename Real , std::size_t NumDimensions, std::size_t R = NumDimensions, std::size_t C = NumDimensions>

using tatooine::matrixfield = typedef field<V, Real, NumDimensions, mat<Real, R, C> >

non_const_method_ptr

template<typename T , typename Ret , typename ... Args>

using tatooine::non_const_method_ptr = typedef Ret (T::*)(Args...)

nonuniform_rectilinear_grid

template<arithmetic Real, std::size_t N>

using tatooine::nonuniform_rectilinear_grid = typedef detail::rectilinear_grid::creator_t<std::vector<Real>, N>

nonuniform_rectilinear_grid2

using tatooine::nonuniform_rectilinear_grid2 = typedef NonuniformRectilinearGrid<2>

nonuniform_rectilinear_grid3

using tatooine::nonuniform_rectilinear_grid3 = typedef NonuniformRectilinearGrid<3>

nonuniform_rectilinear_grid4

using tatooine::nonuniform_rectilinear_grid4 = typedef NonuniformRectilinearGrid<4>

nonuniform_rectilinear_grid5

using tatooine::nonuniform_rectilinear_grid5 = typedef NonuniformRectilinearGrid<5>

NonuniformRectilinearGrid

template<std::size_t N>

using tatooine::NonuniformRectilinearGrid = typedef nonuniform_rectilinear_grid<real_number, N>

numerical_flowmap_field_pointer

template<arithmetic Real, std::size_t NumDimensions, template< typename, std::size_t > typename ODESolver, template< typename > typename InterpolationKernel>

using tatooine::numerical_flowmap_field_pointer = typedef numerical_flowmap<polymorphic::vectorfield<Real, NumDimensions>*, ODESolver, InterpolationKernel>

Particle

template<std::size_t NumDimensions>

using tatooine::Particle = typedef particle<real_number, NumDimensions>

particle2

using tatooine::particle2 = typedef Particle<2>

particle3

using tatooine::particle3 = typedef Particle<3>

Plane

template<size_t N>

using tatooine::Plane = typedef plane<real_type, N>

plane10

using tatooine::plane10 = typedef Plane<10>

plane2

using tatooine::plane2 = typedef Plane<2>

plane3

using tatooine::plane3 = typedef Plane<3>

plane4

using tatooine::plane4 = typedef Plane<4>

plane5

using tatooine::plane5 = typedef Plane<5>

plane6

using tatooine::plane6 = typedef Plane<6>

plane7

using tatooine::plane7 = typedef Plane<7>

plane8

using tatooine::plane8 = typedef Plane<8>

plane9

using tatooine::plane9 = typedef Plane<9>

Pointset

template<std::size_t NumDimensions>

using tatooine::Pointset = typedef pointset<real_number, NumDimensions>

pointset2

using tatooine::pointset2 = typedef Pointset<2>

pointset3

using tatooine::pointset3 = typedef Pointset<3>

pointset4

using tatooine::pointset4 = typedef Pointset<4>

pointset5

using tatooine::pointset5 = typedef Pointset<5>

regular_flowmap_discretization2

using tatooine::regular_flowmap_discretization2 = typedef regular_flowmap_discretization<real_number, 2>

scalarfield

template<typename V , typename Real , std::size_t NumDimensions>

using tatooine::scalarfield = typedef field<V, Real, NumDimensions, Real>

staggered_autonomous_particle_flowmap_discretization

template<typename Real , std::size_t NumDimensions, typename SplitBehavior = typename autonomous_particle< real_number, NumDimensions>::split_behaviors::three_splits>

using tatooine::staggered_autonomous_particle_flowmap_discretization = typedef staggered_flowmap_discretization<autonomous_particle_flowmap_discretization< Real, NumDimensions, SplitBehavior> >

staggered_autonomous_particle_flowmap_discretization2

template<typename SplitBehavior = typename autonomous_particle< real_number, 2>::split_behaviors::three_splits>

using tatooine::staggered_autonomous_particle_flowmap_discretization2 = typedef StaggeredAutonomousParticleFlowmapDiscretization<2, SplitBehavior>

staggered_autonomous_particle_flowmap_discretization3

template<typename SplitBehavior = typename autonomous_particle< real_number, 3>::split_behaviors::three_splits>

using tatooine::staggered_autonomous_particle_flowmap_discretization3 = typedef StaggeredAutonomousParticleFlowmapDiscretization<3, SplitBehavior>

StaggeredAutonomousParticleFlowmapDiscretization

template<std::size_t NumDimensions, typename SplitBehavior = typename autonomous_particle< real_number, NumDimensions>::split_behaviors::three_splits>

using tatooine::StaggeredAutonomousParticleFlowmapDiscretization = typedef staggered_autonomous_particle_flowmap_discretization< real_number, NumDimensions, SplitBehavior>

static_nonuniform_rectilinear_grid

template<arithmetic Real, std::size_t... N>

using tatooine::static_nonuniform_rectilinear_grid = typedef rectilinear_grid<std::array<Real, N>...>

static_nonuniform_rectilinear_grid2

using tatooine::static_nonuniform_rectilinear_grid2 = typedef NonuniformRectilinearGrid<2>

static_nonuniform_rectilinear_grid3

using tatooine::static_nonuniform_rectilinear_grid3 = typedef NonuniformRectilinearGrid<3>

static_nonuniform_rectilinear_grid4

using tatooine::static_nonuniform_rectilinear_grid4 = typedef NonuniformRectilinearGrid<4>

static_nonuniform_rectilinear_grid5

using tatooine::static_nonuniform_rectilinear_grid5 = typedef NonuniformRectilinearGrid<5>

StaticNonUniformGrid

template<std::size_t N>

using tatooine::StaticNonUniformGrid = typedef static_nonuniform_rectilinear_grid<real_number, N>

structured_grid2

using tatooine::structured_grid2 = typedef StructuredGrid<2>

structured_grid3

using tatooine::structured_grid3 = typedef StructuredGrid<3>

StructuredGrid

template<std::size_t NumDimensions>

using tatooine::StructuredGrid = typedef structured_grid<real_number, NumDimensions>

Tensor

template<std::size_t... Dimensions>

using tatooine::Tensor = typedef tensor<real_number, Dims...>

tensor222

typedef Tensor< 2, 2, 2 > tatooine::tensor222

tensor2222

typedef Tensor< 2, 2, 2, 2 > tatooine::tensor2222

tensor22222

typedef Tensor< 2, 2, 2, 2, 2 > tatooine::tensor22222

tensor222222

typedef Tensor< 2, 2, 2, 2, 2, 2 > tatooine::tensor222222

tensor333

using tatooine::tensor333 = typedef Tensor<3, 3, 3>

tensor3333

using tatooine::tensor3333 = typedef Tensor<3, 3, 3, 3>

tensor33333

using tatooine::tensor33333 = typedef Tensor<3, 3, 3, 3, 3>

tensor333333

using tatooine::tensor333333 = typedef Tensor<3, 3, 3, 3, 3, 3>

tensor444

using tatooine::tensor444 = typedef Tensor<4, 4, 4>

tensor4444

using tatooine::tensor4444 = typedef Tensor<4, 4, 4, 4>

tensor44444

using tatooine::tensor44444 = typedef Tensor<4, 4, 4, 4, 4>

tensor444444

using tatooine::tensor444444 = typedef Tensor<4, 4, 4, 4, 4, 4>

tensor_add_dimension_left

template<std::size_t NewLeftDim, typename Tensor >

using tatooine::tensor_add_dimension_left = typedef typename tensor_add_dimension_left_impl<NewLeftDim, Tensor>::type

tensor_add_dimension_right

template<std::size_t NewRightDim, typename Tensor >

using tatooine::tensor_add_dimension_right = typedef typename tensor_add_dimension_right_impl<NewRightDim, Tensor>::type

TensorD

template<std::size_t... Dims>

using tatooine::TensorD = typedef tensor<double, Dims...>

TensorF

template<std::size_t... Dims>

using tatooine::TensorF = typedef tensor<float, Dims...>

TensorI64

template<std::size_t... Dims>

using tatooine::TensorI64 = typedef tensor<std::int64_t, Dims...>

tuple_concat_types

template<typename Tuple1 , typename Tuple2 >

using tatooine::tuple_concat_types = typedef typename tuple_concat_types_impl<Tuple1, Tuple2>::type

uniform_rectilinear_grid

template<floating_point Real, std::size_t N>

using tatooine::uniform_rectilinear_grid = typedef detail::rectilinear_grid::creator_t<linspace<Real>, N>

uniform_rectilinear_grid2

using tatooine::uniform_rectilinear_grid2 = typedef UniformRectilinearGrid<2>

uniform_rectilinear_grid3

using tatooine::uniform_rectilinear_grid3 = typedef UniformRectilinearGrid<3>

uniform_rectilinear_grid4

using tatooine::uniform_rectilinear_grid4 = typedef UniformRectilinearGrid<4>

uniform_rectilinear_grid5

using tatooine::uniform_rectilinear_grid5 = typedef UniformRectilinearGrid<5>

UniformRectilinearGrid

template<std::size_t N>

using tatooine::UniformRectilinearGrid = typedef uniform_rectilinear_grid<real_number, N>

UniformRectilinearGrid2

template<floating_point Real>

using tatooine::UniformRectilinearGrid2 = typedef uniform_rectilinear_grid<Real, 2>

UniformRectilinearGrid3

template<floating_point Real>

using tatooine::UniformRectilinearGrid3 = typedef uniform_rectilinear_grid<Real, 3>

UniformRectilinearGrid4

template<floating_point Real>

using tatooine::UniformRectilinearGrid4 = typedef uniform_rectilinear_grid<Real, 4>

UniformRectilinearGrid5

template<floating_point Real>

using tatooine::UniformRectilinearGrid5 = typedef uniform_rectilinear_grid<Real, 5>

unstructured_grid2

using tatooine::unstructured_grid2 = typedef UnstructuredGrid<2>

unstructured_grid2d

using tatooine::unstructured_grid2d = typedef UnstructuredGridD<2>

unstructured_grid2f

using tatooine::unstructured_grid2f = typedef UnstructuredGridF<2>

unstructured_grid3

using tatooine::unstructured_grid3 = typedef UnstructuredGrid<3>

unstructured_grid3d

using tatooine::unstructured_grid3d = typedef UnstructuredGridD<3>

unstructured_grid3f

using tatooine::unstructured_grid3f = typedef UnstructuredGridF<3>

unstructured_tetrahedral_grid

template<typename Real , std::size_t N>

using tatooine::unstructured_tetrahedral_grid = typedef unstructured_simplicial_grid<Real, N, 3>

unstructured_tetrahedral_grid3

using tatooine::unstructured_tetrahedral_grid3 = typedef unstructured_tetrahedral_grid<real_number, 3>

unstructured_tetrahedral_grid4

using tatooine::unstructured_tetrahedral_grid4 = typedef unstructured_tetrahedral_grid<real_number, 4>

unstructured_tetrahedral_grid5

using tatooine::unstructured_tetrahedral_grid5 = typedef unstructured_tetrahedral_grid<real_number, 5>

unstructured_tetrahedral_grid6

using tatooine::unstructured_tetrahedral_grid6 = typedef unstructured_tetrahedral_grid<real_number, 6>

unstructured_tetrahedral_grid7

using tatooine::unstructured_tetrahedral_grid7 = typedef unstructured_tetrahedral_grid<real_number, 7>

unstructured_triangular_grid2

using tatooine::unstructured_triangular_grid2 = typedef UnstructuredTriangularGrid<2>

unstructured_triangular_grid3

using tatooine::unstructured_triangular_grid3 = typedef UnstructuredTriangularGrid<3>

unstructured_triangular_grid4

using tatooine::unstructured_triangular_grid4 = typedef UnstructuredTriangularGrid<4>

unstructured_triangular_grid5

using tatooine::unstructured_triangular_grid5 = typedef UnstructuredTriangularGrid<5>

UnstructuredGrid

template<std::size_t NumDimensions>

using tatooine::UnstructuredGrid = typedef unstructured_grid<real_type, NumDimensions>

UnstructuredGridD

template<std::size_t NumDimensions>

using tatooine::UnstructuredGridD = typedef unstructured_grid<double, NumDimensions>

UnstructuredGridF

template<std::size_t NumDimensions>

using tatooine::UnstructuredGridF = typedef unstructured_grid<float, NumDimensions>

UnstructuredTriangularGrid

template<std::size_t NumDimensions>

using tatooine::UnstructuredTriangularGrid = typedef unstructured_triangular_grid<real_number, NumDimensions>

UnstructuredTriangularGrid2

template<typename Real >

using tatooine::UnstructuredTriangularGrid2 = typedef unstructured_triangular_grid<Real, 2>

UnstructuredTriangularGrid3

template<typename Real >

using tatooine::UnstructuredTriangularGrid3 = typedef unstructured_triangular_grid<Real, 3>

UnstructuredTriangularGrid4

template<typename Real >

using tatooine::UnstructuredTriangularGrid4 = typedef unstructured_triangular_grid<Real, 4>

UnstructuredTriangularGrid5

template<typename Real >

using tatooine::UnstructuredTriangularGrid5 = typedef unstructured_triangular_grid<Real, 5>

value_type

template<typename T >

using tatooine::value_type = typedef typename value_type_impl<T>::type

Vec

template<std::size_t N>

using tatooine::Vec = typedef vec<real_number, N>

Vec2

template<typename T >

using tatooine::Vec2 = typedef vec<T, 2>

vec2

using tatooine::vec2 = typedef Vec<2>

vec2d

using tatooine::vec2d = typedef VecD<2>

vec2f

using tatooine::vec2f = typedef VecF<2>

vec2i

using tatooine::vec2i = typedef VecI<2>

vec2i16

using tatooine::vec2i16 = typedef VecI16<2>

vec2i32

using tatooine::vec2i32 = typedef VecI32<2>

vec2i64

using tatooine::vec2i64 = typedef VecI64<2>

vec2size_t

using tatooine::vec2size_t = typedef VecSizeT<2>

vec2ui16

using tatooine::vec2ui16 = typedef VecUI16<2>

vec2ui32

using tatooine::vec2ui32 = typedef VecUI32<2>

vec2ui64

using tatooine::vec2ui64 = typedef VecUI64<2>

Vec3

template<typename T >

using tatooine::Vec3 = typedef vec<T, 3>

vec3

using tatooine::vec3 = typedef Vec<3>

vec3d

using tatooine::vec3d = typedef VecD<3>

vec3f

using tatooine::vec3f = typedef VecF<3>

vec3i

using tatooine::vec3i = typedef VecI<3>

vec3i16

using tatooine::vec3i16 = typedef VecI16<3>

vec3i32

using tatooine::vec3i32 = typedef VecI32<3>

vec3i64

using tatooine::vec3i64 = typedef VecI64<3>

vec3size_t

using tatooine::vec3size_t = typedef VecSizeT<3>

vec3ui16

using tatooine::vec3ui16 = typedef VecUI16<3>

vec3ui32

using tatooine::vec3ui32 = typedef VecUI32<3>

vec3ui64

using tatooine::vec3ui64 = typedef VecUI64<3>

Vec4

template<typename T >

using tatooine::Vec4 = typedef vec<T, 4>

vec4

using tatooine::vec4 = typedef Vec<4>

vec4d

using tatooine::vec4d = typedef VecD<4>

vec4f

using tatooine::vec4f = typedef VecF<4>

vec4i

using tatooine::vec4i = typedef VecI<4>

vec4i16

using tatooine::vec4i16 = typedef VecI16<4>

vec4i32

using tatooine::vec4i32 = typedef VecI32<4>

vec4i64

using tatooine::vec4i64 = typedef VecI64<4>

vec4size_t

using tatooine::vec4size_t = typedef VecSizeT<4>

vec4ui16

using tatooine::vec4ui16 = typedef VecUI16<4>

vec4ui32

using tatooine::vec4ui32 = typedef VecUI32<4>

vec4ui64

using tatooine::vec4ui64 = typedef VecUI64<4>

Vec5

template<typename T >

using tatooine::Vec5 = typedef vec<T, 5>

vec5

using tatooine::vec5 = typedef Vec<5>

vec5d

using tatooine::vec5d = typedef VecD<5>

vec5f

using tatooine::vec5f = typedef VecF<5>

vec5i

using tatooine::vec5i = typedef VecI<5>

vec5i16

using tatooine::vec5i16 = typedef VecI16<5>

vec5i32

using tatooine::vec5i32 = typedef VecI32<5>

vec5i64

using tatooine::vec5i64 = typedef VecI64<5>

vec5size_t

using tatooine::vec5size_t = typedef VecSizeT<5>

vec5ui16

using tatooine::vec5ui16 = typedef VecUI16<5>

vec5ui32

using tatooine::vec5ui32 = typedef VecUI32<5>

vec5ui64

using tatooine::vec5ui64 = typedef VecUI64<5>

Vec6

template<typename T >

using tatooine::Vec6 = typedef vec<T, 6>

vec6

using tatooine::vec6 = typedef Vec<6>

vec6d

using tatooine::vec6d = typedef VecD<6>

vec6f

using tatooine::vec6f = typedef VecF<6>

vec6i

using tatooine::vec6i = typedef VecI<6>

vec6i16

using tatooine::vec6i16 = typedef VecI16<6>

vec6i32

using tatooine::vec6i32 = typedef VecI32<6>

vec6i64

using tatooine::vec6i64 = typedef VecI64<6>

vec6size_t

using tatooine::vec6size_t = typedef VecSizeT<6>

vec6ui16

using tatooine::vec6ui16 = typedef VecUI16<6>

vec6ui32

using tatooine::vec6ui32 = typedef VecUI32<6>

vec6ui64

using tatooine::vec6ui64 = typedef VecUI64<6>

Vec7

template<typename T >

using tatooine::Vec7 = typedef vec<T, 7>

vec7

using tatooine::vec7 = typedef Vec<7>

vec7d

using tatooine::vec7d = typedef VecD<7>

vec7f

using tatooine::vec7f = typedef VecF<7>

vec7i

using tatooine::vec7i = typedef VecI<7>

vec7i16

using tatooine::vec7i16 = typedef VecI16<7>

vec7i32

using tatooine::vec7i32 = typedef VecI32<7>

vec7i64

using tatooine::vec7i64 = typedef VecI64<7>

vec7size_t

using tatooine::vec7size_t = typedef VecSizeT<7>

vec7ui16

using tatooine::vec7ui16 = typedef VecUI16<7>

vec7ui32

using tatooine::vec7ui32 = typedef VecUI32<7>

vec7ui64

using tatooine::vec7ui64 = typedef VecUI64<7>

Vec8

template<typename T >

using tatooine::Vec8 = typedef vec<T, 8>

vec8

using tatooine::vec8 = typedef Vec<8>

vec8d

using tatooine::vec8d = typedef VecD<8>

vec8f

using tatooine::vec8f = typedef VecF<8>

vec8i

using tatooine::vec8i = typedef VecI<8>

vec8i16

using tatooine::vec8i16 = typedef VecI16<8>

vec8i32

using tatooine::vec8i32 = typedef VecI32<8>

vec8i64

using tatooine::vec8i64 = typedef VecI64<8>

vec8size_t

using tatooine::vec8size_t = typedef VecSizeT<8>

vec8ui16

using tatooine::vec8ui16 = typedef VecUI16<8>

vec8ui32

using tatooine::vec8ui32 = typedef VecUI32<8>

vec8ui64

using tatooine::vec8ui64 = typedef VecUI64<8>

Vec9

template<typename T >

using tatooine::Vec9 = typedef vec<T, 9>

vec9

using tatooine::vec9 = typedef Vec<9>

vec9d

using tatooine::vec9d = typedef VecD<9>

vec9f

using tatooine::vec9f = typedef VecF<9>

vec9i

using tatooine::vec9i = typedef VecI<9>

vec9i16

using tatooine::vec9i16 = typedef VecI16<9>

vec9i32

using tatooine::vec9i32 = typedef VecI32<9>

vec9i64

using tatooine::vec9i64 = typedef VecI64<9>

vec9size_t

using tatooine::vec9size_t = typedef VecSizeT<9>

vec9ui16

using tatooine::vec9ui16 = typedef VecUI16<9>

vec9ui32

using tatooine::vec9ui32 = typedef VecUI32<9>

vec9ui64

using tatooine::vec9ui64 = typedef VecUI64<9>

VecD

template<std::size_t N>

using tatooine::VecD = typedef vec<double, N>

VecF

template<std::size_t N>

using tatooine::VecF = typedef vec<float, N>

VecI

template<std::size_t N>

using tatooine::VecI = typedef vec<int, N>

VecI16

template<std::size_t N>

using tatooine::VecI16 = typedef vec<std::int16_t, N>

VecI32

template<std::size_t N>

using tatooine::VecI32 = typedef vec<std::int32_t, N>

VecI64

template<std::size_t N>

using tatooine::VecI64 = typedef vec<std::int64_t, N>

VecSizeT

template<std::size_t N>

using tatooine::VecSizeT = typedef vec<std::size_t, N>

vectorfield

template<typename V , typename Real , std::size_t NumDimensions, std::size_t C = NumDimensions>

using tatooine::vectorfield = typedef field<V, Real, NumDimensions, vec<Real, NumDimensions> >

vectorfield_list

template<typename Real , std::size_t NumDimensions, std::size_t C = NumDimensions>

using tatooine::vectorfield_list = typedef field_list<Real, NumDimensions, vec<Real, C> >

VecUI16

template<std::size_t N>

using tatooine::VecUI16 = typedef vec<std::uint16_t, N>

VecUI32

template<std::size_t N>

using tatooine::VecUI32 = typedef vec<std::uint32_t, N>

VecUI64

template<std::size_t N>

using tatooine::VecUI64 = typedef vec<std::uint64_t, N>

void_t

template<typename... >

using tatooine::void_t = typedef void

Function Documentation

_planerot()

template<typename T >

void tatooine::_planerot	(	T	_c,
		T	_s,
		T *	_x
	)

Apply rotation _x=[_c,-_s;_s,_c]*_x.

Parameters

_c	cosine
_s	sine
_x[in,out]	2-vector

See also

solve_qr()

abs() [1/2]

constexpr auto tatooine::abs ( arithmetic auto const  x )

constexpr

abs() [2/2]

template<typename Tensor , typename TensorT , std::size_t... Dims>

constexpr auto tatooine::abs ( base_tensor< Tensor, TensorT, Dims... > const &  t )

constexpr

advance() [1/2]

template<derived_from_iterator_facade Iter>
requires implements_advance<Iter>

auto tatooine::advance

(

Iter &

iter

)

advance() [2/2]

template<derived_from_iterator_facade Iter>
requires implements_advance<Iter>

auto tatooine::advance	(	Iter &	iter,
		difference_type_arg< Iter > auto	off
	)

angle() [1/2]

template<typename Tensor0 , typename Tensor1 , typename T0 , typename T1 , std::size_t N>

constexpr auto tatooine::angle ( base_tensor< Tensor0, T0, N > const &  v0, base_tensor< Tensor1, T1, N > const &  v1  )

constexpr

Returns the angle of two normalized vectors.

angle() [2/2]

template<typename Tensor0 , typename Tensor1 , typename Tensor2 , typename T0 , typename T1 , typename T2 , std::size_t N>

constexpr auto tatooine::angle ( base_tensor< Tensor0, T0, N > const &  v0, base_tensor< Tensor1, T1, N > const &  v1, base_tensor< Tensor2, T2, N > const &  v2  )

constexpr

Returns the cosine of the angle three points.

approx_equal()

template<static_tensor T0, static_tensor T1>
requires (same_dimensions<T0, T1>())

constexpr auto tatooine::approx_equal ( T0 const &  lhs, T1 const &  rhs, common_type< tatooine::value_type< T0 >, tatooine::value_type< T1 > >  eps = 1e-6  )

constexpr

for comparison

axis_aligned_bounding_box() [1/3]

template<typename Tensor0 , typename Tensor1 , typename Real0 , typename Real1 , std::size_t NumDimensions>

tatooine::axis_aligned_bounding_box	(	base_tensor< Tensor0, Real0, NumDimensions > &&	,
		base_tensor< Tensor1, Real1, NumDimensions > &&
	)		-> axis_aligned_bounding_box< common_type< Real0, Real1 >, NumDimensions >

axis_aligned_bounding_box() [2/3]

template<typename Real0 , typename Real1 , std::size_t NumDimensions>

tatooine::axis_aligned_bounding_box	(	vec< Real0, NumDimensions > &&	,
		vec< Real1, NumDimensions > &&
	)		-> axis_aligned_bounding_box< common_type< Real0, Real1 >, NumDimensions >

axis_aligned_bounding_box() [3/3]

template<typename Real0 , typename Real1 , std::size_t NumDimensions>

tatooine::axis_aligned_bounding_box	(	vec< Real0, NumDimensions > const &	,
		vec< Real1, NumDimensions > const &
	)		-> axis_aligned_bounding_box< common_type< Real0, Real1 >, NumDimensions >

back() [1/2]

template<floating_point Real>

auto tatooine::back

(

linspace< Real > &

l

)

-> auto&

back() [2/2]

template<floating_point Real>

auto tatooine::back

(

linspace< Real > const &

l

)

bdsvl()

template<typename T >

bool tatooine::bdsvl	(	int	_n,
		int	_nrhs,
		const T *	_dl,
		const T *	_d,
		T *	_b,
		int	_ldb
	)

Solve bidiagonal linear system A*x=b with subdiagonal. The _x x _n matrix A is bidiagonal with diagonal _d and subdiagonal _dl.

Parameters

	_n	dimension of A and number of rows of RHS _b
	_nrhs	number of RHS in _b
	_dl	subdiagonal of A (array of size _n-1)
	_d	main diagonal of A (array of size _n)
[in,out]	_b	RHS on input, solution x on output
	_ldb	leading dimension of _b

Returns

false if A is singular

bdsvu()

template<typename T >

bool tatooine::bdsvu	(	int	_n,
		int	_nrhs,
		const T *	_d,
		const T *	_du,
		T *	_b,
		int	_ldb
	)

Solve bidiagonal linear system A*x=b with superdiagonal. The _x x _n matrix A is bidiagonal with diagonal _d and superdiagonal _du.

Parameters

	_n	dimension of A and number of rows of RHS _b
	_nrhs	number of RHS in _b
	_d	main diagonal of A (array of size _n)
	_du	superdiagonal of A (array of size _n-1)
[in,out]	_b	RHS on input, solution x on output
	_ldb	leading dimension of _b

Returns

false if A is singular

begin() [1/2]

template<typename Range >
requires requires(Range &&range) { range.begin(); }

auto tatooine::begin

(

Range &&

range

)

begin() [2/2]

template<typename ValueType , std::size_t N>

auto tatooine::begin

(

vec< ValueType, N > const &

v

)

binary_operation() [1/2]

template<typename F , static_tensor Lhs, static_tensor Rhs>
requires (same_dimensions<Lhs, Rhs>())

constexpr auto tatooine::binary_operation ( F &&  f, Lhs const &  lhs, Rhs const &  rhs  )

constexpr

binary_operation() [2/2]

template<typename F , static_tensor Lhs, static_tensor Rhs, std::size_t... Seq>
requires (same_dimensions<Lhs, Rhs>())

constexpr auto tatooine::binary_operation ( F &&  f, Lhs const &  lhs, Rhs const &  rhs, std::index_sequence< Seq... >    )

constexpr

bind()

template<typename F , typename... Args>

constexpr auto tatooine::bind ( F &&  f, Args &&...  args  )

constexpr

Binds first arguments of f (either all or only partially).

break_down_durations()

template<typename... Durations, typename DurationIn >

auto tatooine::break_down_durations

(

DurationIn

d

)

cartesian_axis_label() [1/2]

template<std::size_t I>

static auto constexpr tatooine::cartesian_axis_label ( )

staticconstexpr

cartesian_axis_label() [2/2]

static auto constexpr tatooine::cartesian_axis_label ( std::size_t const  i ) -> std::string_view

staticconstexpr

cast() [1/3]

template<typename NewReal , typename Tensor , typename Real , size_t... Dims>

auto tatooine::cast

(

const base_tensor< Tensor, Real, Dims... > &

to_cast

)

cast() [2/3]

template<typename NewReal , typename Real , size_t M, size_t N>

auto tatooine::cast

(

const mat< Real, M, N > &

to_cast

)

cast() [3/3]

template<typename NewReal , typename Real , size_t N>

auto tatooine::cast

(

const vec< Real, N > &

to_cast

)

cast_tensor_type_impl() [1/3]

template<typename CastReal , typename Real , size_t M, size_t N>

auto tatooine::cast_tensor_type_impl

(

const mat< Real, M, N > &

)

cast_tensor_type_impl() [2/3]

template<typename CastReal , typename Real , size_t... Dims>

auto tatooine::cast_tensor_type_impl

(

const tensor< Real, Dims... > &

)

cast_tensor_type_impl() [3/3]

template<typename CastReal , typename Real , size_t N>

auto tatooine::cast_tensor_type_impl

(

const vec< Real, N > &

)

cell_partition()

template<typename F , typename GridReal >

auto tatooine::cell_partition	(	F &&	f,
		const grid< GridReal, 3 > &	g
	)

iterates over all cells of the grid in parallel

celltree() [1/2]

template<typename Mesh >

tatooine::celltree

(

Mesh const &

mesh

)

-> celltree< Mesh >

celltree() [2/2]

template<typename Mesh , typename Real , std::size_t NumDimensions>

tatooine::celltree	(	Mesh const &	mesh,
		vec< Real, NumDimensions > const &	min,
		vec< Real, NumDimensions > const &	max
	)		-> celltree< Mesh >

chunked_for_loop() [1/2]

template<typename Int = std::size_t, integral... Ends>

constexpr auto tatooine::chunked_for_loop ( invocable< decltype(((void) std::declval< Ends >(), std::declval< Int >()))... > auto &&  iteration, execution_policy_tag auto  policy, integral auto const  chunk_size, Ends const ...  ends  ) -> void

constexpr

chunked_for_loop() [2/2]

template<typename Int = std::size_t, typename Iteration , integral... Ends>
requires invocable<Iteration, decltype((std::declval<Ends>(), std::declval<Int>()))...>

constexpr auto tatooine::chunked_for_loop ( Iteration &&  iteration, integral auto const  chunk_size, Ends const ...  ends  ) -> void

constexpr

clamp() [1/2]

template<typename T >

constexpr auto tatooine::clamp ( const T &  v, const T &  lo, const T &  hi  ) -> const T&

constexpr

clamp() [2/2]

template<typename T , typename Compare >

constexpr auto tatooine::clamp ( const T &  v, const T &  lo, const T &  hi, Compare  comp  ) -> const T&

constexpr

compare_variadic()

template<template< typename > typename Comparator, typename T0 , typename T1 , typename... TRest>
requires requires(T0 a, T1 b, Comparator<std::decay_t<T0>> comp) { { comp(a, b) } -> std::convertible_to<bool>; } && same_as<std::decay_t<T0>, std::decay_t<T1>> && (same_as<std::decay_t<T0>, std::decay_t<TRest>> && ...)

constexpr auto tatooine::compare_variadic ( T0 &&  a, T1 &&  b, TRest &&...  rest  )

constexpr

compute_topological_skeleton()

template<typename Real , typename Integrator , template< typename > typename Interpolator>

auto tatooine::compute_topological_skeleton	(	const sampled_field< grid_sampler< Real, 2, vec< Real, 2 >, interpolation::linear, interpolation::linear >, Real, 2, 2 > &	v,
		const integration::integrator< Real, 2, Interpolator, Integrator > &	integrator,
		const Real	tau = 100,
		const Real	eps = 1e-7
	)

computes the topological skeleton of a two-dimensional piecewise bilinear vectorfield

concat() [1/4]

template<std::string_view const & S>

constexpr std::string_view const & tatooine::concat ( )

constexpr

concat() [2/4]

template<std::string_view const & S0, std::string_view const & S1>

constexpr std::string_view const & tatooine::concat ( )

constexpr

concat() [3/4]

template<std::string_view const & S0, std::string_view const & S1, std::string_view const & S2, std::string_view const &... Ss>

constexpr std::string_view const & tatooine::concat ( )

constexpr

concat() [4/4]

template<std::string_view const & S0, std::string_view const & S1, std::size_t... I0s, std::size_t... I1s>

constexpr std::string_view const & tatooine::concat ( std::index_sequence< I0s... >  , std::index_sequence< I1s... >    )

constexpr

condition_number() [1/2]

template<typename Tensor , typename T , size_t N, typename PReal >

auto tatooine::condition_number	(	base_tensor< Tensor, T, N, N > const &	A,
		PReal	p
	)

condition_number() [2/2]

template<typename T , size_t N, integral P = int>

auto tatooine::condition_number	(	tensor< T, N, N > const &	A,
		P const	p = 2
	)

compute condition number

conforming_delaunay()

template<typename Real >

auto tatooine::conforming_delaunay ( const edgeset< 2, Real > &  es, triangle::real_type  minangle = 0, triangle::real_type  maxarea = 0  )

inline

constrained_delaunay() [1/2]

template<typename Real >

auto tatooine::constrained_delaunay ( const edgeset< 2, Real > &  es )

inline

constrained_delaunay() [2/2]

template<typename Real >

auto tatooine::constrained_delaunay ( const pointset< 2, Real > &  ps, const std::vector< typename pointset< 2, Real >::vertex > &  polygon  )

inline

constrained_delaunay_available()

static constexpr auto tatooine::constrained_delaunay_available ( std::size_t const  NumDimensions ) -> bool

inlinestaticconstexpr

copy_or_keep_if_rvalue()

auto tatooine::copy_or_keep_if_rvalue

(

auto &&

x

)

-> decltype(auto)

copy_or_keep_if_rvalue_tensor_solve() [1/5]

auto tatooine::copy_or_keep_if_rvalue_tensor_solve

(

dynamic_tensor auto &&

x

)

-> decltype(auto)

copy_or_keep_if_rvalue_tensor_solve() [2/5]

template<typename T >

auto tatooine::copy_or_keep_if_rvalue_tensor_solve

(

tensor< T > &&

x

)

-> decltype(auto)

copy_or_keep_if_rvalue_tensor_solve() [3/5]

template<typename T >

auto tatooine::copy_or_keep_if_rvalue_tensor_solve

(

tensor< T > const &

x

)

copy_or_keep_if_rvalue_tensor_solve() [4/5]

template<typename T , std::size_t... Dims>

auto tatooine::copy_or_keep_if_rvalue_tensor_solve

(

tensor< T, Dims... > &&

x

)

-> decltype(auto)

copy_or_keep_if_rvalue_tensor_solve() [5/5]

template<typename T , std::size_t... Dims>

auto tatooine::copy_or_keep_if_rvalue_tensor_solve

(

tensor< T, Dims... > const &

x

)

cos()

constexpr auto tatooine::cos ( arithmetic auto const  x )

constexpr

cos_angle() [1/2]

template<typename Tensor0 , typename Tensor1 , typename T0 , typename T1 , std::size_t N>

constexpr auto tatooine::cos_angle ( base_tensor< Tensor0, T0, N > const &  v0, base_tensor< Tensor1, T1, N > const &  v1  )

constexpr

Returns the cosine of the angle of two normalized vectors.

cos_angle() [2/2]

template<typename Tensor0 , typename Tensor1 , typename Tensor2 , typename T0 , typename T1 , typename T2 , std::size_t N>

constexpr auto tatooine::cos_angle ( base_tensor< Tensor0, T0, N > const &  v0, base_tensor< Tensor1, T1, N > const &  v1, base_tensor< Tensor2, T2, N > const &  v2  )

constexpr

Returns the cosine of the angle three points.

create_aligned_data_for_parallel()

template<typename T >

auto tatooine::create_aligned_data_for_parallel

(

)

cross() [1/2]

template<typename Tensor0 , typename T0 , typename Tensor1 , typename T1 >

constexpr auto tatooine::cross ( base_tensor< Tensor0, T0, 3 > const &  lhs, base_tensor< Tensor1, T1, 3 > const &  rhs  )

constexpr

cross() [2/2]

template<typename T0 , typename T1 >

constexpr auto tatooine::cross ( tensor< T0 > const &  lhs, tensor< T1 > const &  rhs  )

constexpr

curvature() [1/2]

template<typename V , typename Real >

auto tatooine::curvature

(

const field< V, Real, 2, 2 > &

vf

)

curvature() [2/2]

template<typename V , typename Real >

auto tatooine::curvature

(

const field< V, Real, 3, 3 > &

vf

)

curve_to_streamline()

tatooine::curve_to_streamline

(

)

-> curve_to_streamline< double >

debug_mode()

constexpr auto tatooine::debug_mode ( )

inlineconstexpr

delaunay() [1/2]

template<typename Real >

auto tatooine::delaunay ( const pointset< 2, Real > &  ps )

inline

delaunay() [2/2]

template<typename Real >

auto tatooine::delaunay ( const pointset< 2, Real > &  ps, const std::vector< typename pointset< 2, Real >::vertex > &  vertices  )

inline

det() [1/2]

template<typename Tensor , typename T >

constexpr auto tatooine::det ( base_tensor< Tensor, T, 2, 2 > const &  A ) -> T

constexpr

det() [2/2]

template<typename Tensor , typename T >

constexpr auto tatooine::det ( base_tensor< Tensor, T, 3, 3 > const &  A ) -> T

constexpr

detAtA()

template<typename Tensor , typename T >

constexpr auto tatooine::detAtA ( base_tensor< Tensor, T, 2, 2 > const &  A ) -> T

constexpr

diag() [1/2]

auto tatooine::diag

(

dynamic_tensor auto &&

A

)

diag() [2/2]

constexpr auto tatooine::diag ( static_vec auto &&  t )

constexpr

diag_dynamic_tensor() [1/3]

template<dynamic_tensor Tensor>

tatooine::diag_dynamic_tensor

(

Tensor &&

t

)

-> diag_dynamic_tensor< std::decay_t< Tensor > >

diag_dynamic_tensor() [2/3]

template<dynamic_tensor Tensor>

tatooine::diag_dynamic_tensor

(

Tensor &

t

)

-> diag_dynamic_tensor< Tensor & >

diag_dynamic_tensor() [3/3]

template<dynamic_tensor Tensor>

tatooine::diag_dynamic_tensor

(

Tensor const &

t

)

-> diag_dynamic_tensor< Tensor const & >

diag_rect()

template<std::size_t M, std::size_t N>

constexpr auto tatooine::diag_rect ( static_vec auto &&  t )

constexpr

diag_static_tensor() [1/3]

template<static_vec Tensor>

tatooine::diag_static_tensor

(

Tensor &&

t

)

-> diag_static_tensor< std::decay_t< Tensor >, Tensor::dimension(0), Tensor::dimension(0)>

diag_static_tensor() [2/3]

template<static_vec Tensor>

tatooine::diag_static_tensor

(

Tensor &

t

)

-> diag_static_tensor< Tensor &, Tensor::dimension(0), Tensor::dimension(0)>

diag_static_tensor() [3/3]

template<static_vec Tensor>

tatooine::diag_static_tensor

(

Tensor const &

t

)

-> diag_static_tensor< Tensor const &, Tensor::dimension(0), Tensor::dimension(0)>

diff() [1/23]

template<std::floating_point Real>

constexpr auto tatooine::diff ( analytical::numerical::autonomous_particles_test< Real > &  )

constexpr

diff() [2/23]

template<floating_point Real>

constexpr auto tatooine::diff ( analytical::numerical::center< Real > &  )

constexpr

diff() [3/23]

template<floating_point Real>

auto tatooine::diff

(

analytical::numerical::frankes_test< Real > const &

f

)

diff() [4/23]

template<typename RealOut = double, typename Tensor , size_t... Dims>

auto tatooine::diff	(	const base_tensor< Tensor, GiNaC::ex, Dims... > &	t_in,
		const GiNaC::symbol &	symbol,
		unsigned	nth = 1
	)

diff() [5/23]

template<typename Real , size_t N, size_t... TensorDims>

auto tatooine::diff

(

const symbolic::field< Real, N, TensorDims... > &

f

)

diff() [6/23]

template<std::size_t N = 1>

auto constexpr tatooine::diff ( decltype(thin_plate_spline) const &  )

constexpr

diff() [7/23]

template<std::size_t N = 1>

auto constexpr tatooine::diff ( decltype(thin_plate_spline_diff1) const &  )

constexpr

diff() [8/23]

template<std::size_t N = 1>

auto constexpr tatooine::diff ( decltype(thin_plate_spline_diff2) const &  )

constexpr

diff() [9/23]

auto tatooine::diff

(

field_concept auto &&

field

)

diff() [10/23]

auto tatooine::diff	(	field_concept auto &&	field,
		arithmetic auto const	epsilon
	)

diff() [11/23]

auto tatooine::diff	(	field_concept auto &&	field,
		fixed_size_real_vec< std::decay_t< decltype(field)>::num_dimensions()> auto &&	epsilon
	)

diff() [12/23]

auto tatooine::diff	(	field_concept auto &&	field,
		tag::numerical_t
	)

diff() [13/23]

auto tatooine::diff	(	field_concept auto &&	field,
		tag::numerical_t	,
		arithmetic auto const	epsilon
	)

diff() [14/23]

auto tatooine::diff	(	field_concept auto &&	field,
		tag::numerical_t	,
		fixed_size_real_vec< std::decay_t< decltype(field)>::num_dimensions()> auto &&	epsilon
	)

diff() [15/23]

auto tatooine::diff

(

flowmap_concept auto &&

flowmap

)

diff() [16/23]

auto tatooine::diff	(	flowmap_concept auto &&	flowmap,
		arithmetic auto const	epsilon
	)

diff() [17/23]

auto tatooine::diff	(	flowmap_concept auto &&	flowmap,
		fixed_size_real_vec< std::decay_t< decltype(flowmap)>::num_dimensions()> auto &&	epsilon
	)

diff() [18/23]

auto tatooine::diff	(	flowmap_concept auto &&	flowmap,
		tag::numerical_t
	)

diff() [19/23]

auto tatooine::diff	(	flowmap_concept auto &&	flowmap,
		tag::numerical_t	,
		arithmetic auto const	epsilon
	)

diff() [20/23]

auto tatooine::diff	(	flowmap_concept auto &&	flowmap,
		tag::numerical_t	,
		fixed_size_real_vec< std::decay_t< decltype(flowmap)>::num_dimensions()> auto &&	epsilon
	)

diff() [21/23]

template<typename Real , std::size_t Degree>

constexpr auto tatooine::diff ( polynomial< Real, Degree > const &  f )

constexpr

diff() [22/23]

template<std::floating_point Real>

constexpr auto tatooine::diff ( vectorfield< analytical::numerical::autonomous_particles_test< Real >, Real, 2 > const &  )

constexpr

diff() [23/23]

template<floating_point Real>

constexpr auto tatooine::diff ( vectorfield< analytical::numerical::center< Real >, Real, 2 > const &  )

constexpr

diff_time() [1/4]

template<typename Field , typename Real , std::size_t NumDimensions, typename Tensor >

auto tatooine::diff_time	(	field< Field, Real, NumDimensions, Tensor > &&	f,
		Real const	eps
	)

diff_time() [2/4]

template<typename Field , typename Real , std::size_t NumDimensions, typename Tensor >

auto tatooine::diff_time	(	field< Field, Real, NumDimensions, Tensor > &	f,
		Real const	eps
	)

diff_time() [3/4]

template<typename Field , typename Real , std::size_t NumDimensions, typename Tensor >

auto tatooine::diff_time	(	field< Field, Real, NumDimensions, Tensor > const &	f,
		Real const	eps
	)

diff_time() [4/4]

template<typename Real , std::size_t NumDimensions, typename Tensor >

auto tatooine::diff_time	(	polymorphic::field< Real, NumDimensions, Tensor > const *	f,
		Real const	eps
	)

differentiated_field() [1/6]

template<typename Field , arithmetic Eps>

tatooine::differentiated_field	(	Field &&	,
		Eps const
	)		-> differentiated_field< Field >

differentiated_field() [2/6]

template<typename Field , arithmetic Eps>

tatooine::differentiated_field	(	Field &&	f,
		vec< Eps, field_num_dimensions< Field > > const &
	)		-> differentiated_field< Field >

differentiated_field() [3/6]

template<typename Field , arithmetic Eps>

tatooine::differentiated_field	(	Field &	,
		Eps const
	)		-> differentiated_field< Field & >

differentiated_field() [4/6]

template<typename Field , arithmetic Eps>

tatooine::differentiated_field	(	Field &	f,
		vec< Eps, field_num_dimensions< Field > > const &
	)		-> differentiated_field< Field & >

differentiated_field() [5/6]

template<typename Field , arithmetic Eps>

tatooine::differentiated_field	(	Field const &	,
		Eps const
	)		-> differentiated_field< Field const & >

differentiated_field() [6/6]

template<typename Field , arithmetic Eps>

tatooine::differentiated_field	(	Field const &	f,
		vec< Eps, field_num_dimensions< Field > > const &
	)		-> differentiated_field< Field const & >

differentiated_flowmap() [1/2]

template<typename Flowmap >

tatooine::differentiated_flowmap

(

Flowmap &&

)

-> differentiated_flowmap< Flowmap >

differentiated_flowmap() [2/2]

template<typename Flowmap >

tatooine::differentiated_flowmap

(

Flowmap const &

)

-> differentiated_flowmap< Flowmap const & >

discretize() [1/11]

template<typename V , arithmetic VReal, std::size_t NumDimensions, typename Tensor , typename BasisReal , typename X0Real >

auto tatooine::discretize	(	field< V, VReal, NumDimensions, Tensor > const &	f,
		mat< BasisReal, NumDimensions, 2 > const &	basis,
		vec< X0Real, NumDimensions > const &	x0,
		std::size_t const	res0,
		std::size_t const	res1,
		std::string const &	property_name,
		arithmetic auto const	t
	)

Discretizes to a cutting plane of a field.

Parameters

basis

spatial basis of cutting plane

discretize() [2/11]

template<typename V , arithmetic VReal, std::size_t NumDimensions, typename Tensor , typename BasisReal , typename X0Real >

auto tatooine::discretize	(	field< V, VReal, NumDimensions, Tensor > const &	f,
		vec< BasisReal, NumDimensions > const &	extent0,
		vec< BasisReal, NumDimensions > const &	extent1,
		vec< X0Real, NumDimensions > const &	,
		std::size_t const	res0,
		std::size_t const	res1,
		std::string const &	property_name,
		arithmetic auto const	t
	)

Discretizes to a cutting plane of a field.

Parameters

basis

spatial basis of cutting plane

discretize() [3/11]

template<typename V , arithmetic VReal, std::size_t NumDimensions, typename Tensor , typename BasisReal , typename X0Real , typename X1Real >

auto tatooine::discretize	(	field< V, VReal, NumDimensions, Tensor > const &	f,
		vec< X0Real, NumDimensions > const &	x0,
		mat< BasisReal, NumDimensions, 2 > const &	basis,
		vec< X1Real, 2 > const &	spatial_size,
		std::size_t const	res0,
		std::size_t const	res1,
		std::string const &	property_name,
		arithmetic auto const	t
	)

Discretizes to a cutting plane of a field.

Parameters

basis

spatial basis of cutting plane

discretize() [4/11]

template<arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions>

auto tatooine::discretize	(	polymorphic::field< VReal, NumDimensions, Tensor > const &	f,
		rectilinear_grid< SpatialDimensions... > &	discretized_domain,
		std::string const &	property_name
	)		-> auto&

discretize() [5/11]

template<arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions>

auto tatooine::discretize	(	polymorphic::field< VReal, NumDimensions, Tensor > const &	f,
		rectilinear_grid< SpatialDimensions... > &	discretized_domain,
		std::string const &	property_name,
		arithmetic auto const	t
	)		-> auto&

discretize() [6/11]

template<arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions>

auto tatooine::discretize	(	polymorphic::field< VReal, NumDimensions, Tensor > const &	f,
		rectilinear_grid< SpatialDimensions... > &	discretized_domain,
		std::string const &	property_name,
		arithmetic auto const	t,
		execution_policy_tag auto const	pol
	)		-> auto&

discretize() [7/11]

template<arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions>

auto tatooine::discretize	(	polymorphic::field< VReal, NumDimensions, Tensor > const &	f,
		rectilinear_grid< SpatialDimensions... > &	discretized_domain,
		std::string const &	property_name,
		execution_policy_tag auto const	pol
	)		-> auto&

discretize() [8/11]

template<arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions>

auto tatooine::discretize	(	polymorphic::field< VReal, NumDimensions, Tensor > const &	f,
		rectilinear_grid< SpatialDimensions... > const &	discretized_domain
	)		-> auto&

discretize() [9/11]

template<arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions>

auto tatooine::discretize	(	polymorphic::field< VReal, NumDimensions, Tensor > const &	f,
		rectilinear_grid< SpatialDimensions... > const &	discretized_domain,
		arithmetic auto const	t
	)		-> auto

discretize() [10/11]

template<arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions>

auto tatooine::discretize	(	polymorphic::field< VReal, NumDimensions, Tensor > const &	f,
		rectilinear_grid< SpatialDimensions... > const &	discretized_domain,
		arithmetic auto const	t,
		execution_policy_tag auto const	pol
	)		-> auto

discretize() [11/11]

template<arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions>

auto tatooine::discretize	(	polymorphic::field< VReal, NumDimensions, Tensor > const &	f,
		rectilinear_grid< SpatialDimensions... > const &	discretized_domain,
		execution_policy_tag auto const	pol
	)		-> auto&

distance() [1/3]

template<derived_from_iterator_facade Iter>
requires implements_distance_to<Iter>

constexpr auto tatooine::distance ( Iter const &  it0, Iter const &  it1  )

constexpr

distance() [2/3]

template<derived_from_iterator_facade Iter>
requires implements_distance_to<Iter>

constexpr auto tatooine::distance ( Iter const &  it0, iter_sentinel_arg< Iter > auto const &  it1  )

constexpr

distance() [3/3]

template<derived_from_iterator_facade Iter>
requires implements_distance_to<Iter>

constexpr auto tatooine::distance ( iter_sentinel_arg< Iter > auto const &  it0, Iter const &  it1  )

constexpr

dot() [1/2]

template<typename Tensor0 , typename T0 , typename Tensor1 , typename T1 , std::size_t N>

constexpr auto tatooine::dot ( base_tensor< Tensor0, T0, N > const &  lhs, base_tensor< Tensor1, T1, N > const &  rhs  )

constexpr

dot() [2/2]

template<typename V0 , typename V1 , typename Real0 , typename Real1 , std::size_t NumDimensions>
requires ( V0::num_tensor_components() == V1::num_tensor_components())

constexpr auto tatooine::dot ( vectorfield< V0, Real0, NumDimensions > const &  lhs, vectorfield< V1, Real1, NumDimensions > const &  rhs  )

constexpr

dynamic_multidim_array() [1/8]

template<typename ValueType , typename IndexOrder >

tatooine::dynamic_multidim_array

(

dynamic_multidim_array< ValueType, IndexOrder > &&

)

-> dynamic_multidim_array< ValueType, IndexOrder >

dynamic_multidim_array() [2/8]

template<typename ValueType , typename IndexOrder >

tatooine::dynamic_multidim_array

(

dynamic_multidim_array< ValueType, IndexOrder > const &

)

-> dynamic_multidim_array< ValueType, IndexOrder >

dynamic_multidim_array() [3/8]

template<typename ValueType , typename UInt , std::size_t N>

tatooine::dynamic_multidim_array	(	std::array< UInt, N > const &	,
		std::vector< ValueType > &&
	)		-> dynamic_multidim_array< ValueType, x_fastest >

dynamic_multidim_array() [4/8]

template<typename ValueType , typename UInt , std::size_t N>

tatooine::dynamic_multidim_array	(	std::array< UInt, N > const &	,
		std::vector< ValueType > const &
	)		-> dynamic_multidim_array< ValueType, x_fastest >

dynamic_multidim_array() [5/8]

template<typename ValueType , typename UInt , std::size_t N>

tatooine::dynamic_multidim_array	(	std::array< UInt, N > const &	,
		ValueType const &	initial
	)		-> dynamic_multidim_array< ValueType, x_fastest >

dynamic_multidim_array() [6/8]

template<typename ValueType , typename UInt >

tatooine::dynamic_multidim_array	(	std::vector< UInt > const &	,
		std::vector< ValueType > &&
	)		-> dynamic_multidim_array< ValueType, x_fastest >

dynamic_multidim_array() [7/8]

template<typename ValueType , typename UInt >

tatooine::dynamic_multidim_array	(	std::vector< UInt > const &	,
		std::vector< ValueType > const &
	)		-> dynamic_multidim_array< ValueType, x_fastest >

dynamic_multidim_array() [8/8]

template<typename ValueType , typename UInt >

tatooine::dynamic_multidim_array	(	std::vector< UInt > const &	,
		ValueType const &	initial
	)		-> dynamic_multidim_array< ValueType, x_fastest >

dynamic_multidim_size() [1/4]

tatooine::dynamic_multidim_size

(

)

-> dynamic_multidim_size< x_fastest >

dynamic_multidim_size() [2/4]

template<typename IndexOrder >

tatooine::dynamic_multidim_size

(

dynamic_multidim_size< IndexOrder > &&

)

-> dynamic_multidim_size< IndexOrder >

dynamic_multidim_size() [3/4]

template<typename IndexOrder >

tatooine::dynamic_multidim_size

(

dynamic_multidim_size< IndexOrder > const &

)

-> dynamic_multidim_size< IndexOrder >

dynamic_multidim_size() [4/4]

template<typename... Resolution>

tatooine::dynamic_multidim_size

(

Resolution...

)

-> dynamic_multidim_size< x_fastest >

eigenvalues()

template<static_quadratic_mat Mat>

constexpr auto tatooine::eigenvalues ( Mat &&  A )

constexpr

eigenvalues_sym()

template<fixed_size_quadratic_mat< 2 > Mat>

constexpr auto tatooine::eigenvalues_sym ( Mat &&  A )

constexpr

eigenvectors()

template<static_quadratic_mat Mat>

auto tatooine::eigenvectors

(

Mat &&

B

)

eigenvectors_sym()

template<static_quadratic_mat Mat>

auto tatooine::eigenvectors_sym

(

Mat &&

A

)

end() [1/2]

template<typename Range >
requires requires(Range &&range) { range.end(); }

auto tatooine::end

(

Range &&

range

)

end() [2/2]

template<typename ValueType , std::size_t N>

auto tatooine::end

(

vec< ValueType, N > const &

v

)

euclidean_distance()

template<typename Tensor0 , typename T0 , typename Tensor1 , typename T1 , std::size_t N>

constexpr auto tatooine::euclidean_distance ( base_tensor< Tensor0, T0, N > const &  lhs, base_tensor< Tensor1, T1, N > const &  rhs  )

constexpr

euclidean_length() [1/3]

template<typename Tensor , typename T , size_t N>

constexpr auto tatooine::euclidean_length ( base_tensor< Tensor, T, N > const &  t_in ) -> T

constexpr

euclidean_length() [2/3]

template<typename V , typename VReal , std::size_t N>

constexpr auto tatooine::euclidean_length ( vectorfield< V, VReal, N > &&  v )

constexpr

euclidean_length() [3/3]

template<typename V , typename VReal , std::size_t N>

constexpr auto tatooine::euclidean_length ( vectorfield< V, VReal, N > const &  v )

constexpr

eval()

template<typename Tensor , size_t... Dims>

void tatooine::eval

(

base_tensor< Tensor, GiNaC::ex, Dims... > &

m

)

evalf()

template<typename Tensor , size_t... Dims>

void tatooine::evalf

(

base_tensor< Tensor, GiNaC::ex, Dims... > &

m

)

evalm()

template<typename Tensor , size_t... Dims>

void tatooine::evalm

(

base_tensor< Tensor, GiNaC::ex, Dims... > &

m

)

evtod()

template<typename RealOut = double, typename Tensor , size_t... Dims, typename... Relations>

auto tatooine::evtod	(	const base_tensor< Tensor, GiNaC::ex, Dims... > &	t_in,
		Relations &&...	relations
	)

expand()

template<typename Tensor , size_t... Dims>

void tatooine::expand

(

base_tensor< Tensor, GiNaC::ex, Dims... > &

m

)

extract_vortex_core_lines() [1/6]

template<typename Grid , typename Real , bool HasNonConstReference>

auto tatooine::extract_vortex_core_lines	(	detail::rectilinear_grid::typed_vertex_property_interface< Grid, Vec3< Real >, HasNonConstReference > const &	v,
		detail::rectilinear_grid::typed_vertex_property_interface< Grid, Mat3< Real >, HasNonConstReference > const &	J
	)

extract_vortex_core_lines() [2/6]

template<typename Grid , typename Real , bool HasNonConstReference>

auto tatooine::extract_vortex_core_lines	(	detail::rectilinear_grid::typed_vertex_property_interface< Grid, Vec3< Real >, HasNonConstReference > const &	v,
		detail::rectilinear_grid::typed_vertex_property_interface< Grid, Mat3< Real >, HasNonConstReference > const &	J,
		algorithm::sujudi_haimes_tag const
	)

extract_vortex_core_lines() [3/6]

template<typename Grid , typename Real , bool HasNonConstReference>

auto tatooine::extract_vortex_core_lines

(

detail::rectilinear_grid::typed_vertex_property_interface< Grid, vec< Real, 3 >, HasNonConstReference > const &

v

)

extract_vortex_core_lines() [4/6]

template<typename Grid , typename Real , bool HasNonConstReference>

auto tatooine::extract_vortex_core_lines	(	detail::rectilinear_grid::typed_vertex_property_interface< Grid, vec< Real, 3 >, HasNonConstReference > const &	v,
		algorithm::sujudi_haimes_tag const
	)

extract_vortex_core_lines() [5/6]

template<typename Field , typename Real , typename DomainX , typename DomainY , typename DomainZ >

auto tatooine::extract_vortex_core_lines	(	vectorfield< Field, Real, 3 > const &	v,
		integral auto const	t,
		rectilinear_grid< DomainX, DomainY, DomainZ > const &	g
	)

extract_vortex_core_lines() [6/6]

template<typename Field , typename Real , typename DomainX , typename DomainY , typename DomainZ >

auto tatooine::extract_vortex_core_lines	(	vectorfield< Field, Real, 3 > const &	v,
		integral auto const	t,
		rectilinear_grid< DomainX, DomainY, DomainZ > const &	g,
		algorithm::sujudi_haimes_tag const
	)

factorial()

template<integral Int>

constexpr auto tatooine::factorial ( Int const  i ) -> std::decay_t<Int>

constexpr

filter_length()

auto tatooine::filter_length	(	range_of_lines auto const &	lines,
		arithmetic auto const	max_length
	)

find_boundary_switch_points() [1/2]

template<typename Real >

auto tatooine::find_boundary_switch_points

(

const grid_sampler< Real, 2, vec< Real, 2 >, interpolation::linear, interpolation::linear > &

sampler

)

find_boundary_switch_points() [2/2]

template<typename Real >

auto tatooine::find_boundary_switch_points

(

const sampled_field< grid_sampler< Real, 2, vec< Real, 2 >, interpolation::linear, interpolation::linear >, Real, 2, 2 > &

v

)

find_critical_points()

template<typename Grid , typename Real , bool HasNonConstReference>

auto tatooine::find_critical_points

(

detail::rectilinear_grid::vertex_property_sampler< detail::rectilinear_grid::typed_vertex_property_interface< Grid, vec< Real, 2 >, HasNonConstReference >, interpolation::linear, interpolation::linear > const &

s

)

flowmap() [1/10]

template<template< typename, std::size_t > typename ODESolver = ode::boost::rungekuttafehlberg78, template< typename > typename InterpolationKernel = interpolation::cubic, typename Real , std::size_t NumDimensions>

auto tatooine::flowmap

(

polymorphic::vectorfield< Real, NumDimensions > const &

v

)

flowmap() [2/10]

template<template< typename, std::size_t > typename ODESolver = ode::boost::rungekuttafehlberg78, template< typename > typename InterpolationKernel = interpolation::cubic, typename Real , std::size_t NumDimensions>

auto tatooine::flowmap	(	polymorphic::vectorfield< Real, NumDimensions > const &	v,
		ODESolver< Real, NumDimensions > const &	ode_solver
	)

flowmap() [3/10]

template<template< typename, std::size_t > typename ODESolver = ode::boost::rungekuttafehlberg78, template< typename > typename InterpolationKernel = interpolation::cubic, typename V , typename Real , std::size_t NumDimensions>

auto tatooine::flowmap

(

vectorfield< V, Real, NumDimensions > &&

v

)

flowmap() [4/10]

template<template< typename, std::size_t > typename ODESolver = ode::boost::rungekuttafehlberg78, template< typename > typename InterpolationKernel = interpolation::cubic, typename V , typename Real , std::size_t NumDimensions>

auto tatooine::flowmap	(	vectorfield< V, Real, NumDimensions > &&	v,
		ODESolver< Real, NumDimensions > const &	ode_solver
	)

flowmap() [5/10]

template<template< typename, std::size_t > typename ODESolver, template< typename > typename InterpolationKernel = interpolation::cubic, typename V , typename Real , std::size_t NumDimensions>

auto tatooine::flowmap	(	vectorfield< V, Real, NumDimensions > &&	v,
		ODESolver< Real, NumDimensions > const &	ode_solver,
		tag::numerical_t
	)

flowmap() [6/10]

template<template< typename, std::size_t > typename ODESolver = ode::boost::rungekuttafehlberg78, template< typename > typename InterpolationKernel = interpolation::cubic, typename V , typename Real , std::size_t NumDimensions>

auto tatooine::flowmap	(	vectorfield< V, Real, NumDimensions > &&	v,
		tag::numerical_t
	)

flowmap() [7/10]

template<template< typename, std::size_t > typename ODESolver = ode::boost::rungekuttafehlberg78, template< typename > typename InterpolationKernel = interpolation::cubic, typename V , typename Real , std::size_t NumDimensions>

auto tatooine::flowmap

(

vectorfield< V, Real, NumDimensions > const &

v

)

flowmap() [8/10]

template<template< typename, std::size_t > typename ODESolver, template< typename > typename InterpolationKernel = interpolation::cubic, typename V , typename Real , std::size_t NumDimensions>

auto tatooine::flowmap	(	vectorfield< V, Real, NumDimensions > const &	v,
		ODESolver< Real, NumDimensions > const &	ode_solver
	)

flowmap() [9/10]

template<template< typename > typename InterpolationKernel = interpolation::cubic, template< typename, std::size_t > typename ODESolver, typename V , typename Real , std::size_t NumDimensions>

auto tatooine::flowmap	(	vectorfield< V, Real, NumDimensions > const &	v,
		ODESolver< Real, NumDimensions > const &	ode_solver,
		tag::numerical_t
	)

flowmap() [10/10]

template<template< typename, std::size_t > typename ODESolver = ode::boost::rungekuttafehlberg78, template< typename > typename InterpolationKernel = interpolation::cubic, typename V , typename Real , std::size_t NumDimensions>

auto tatooine::flowmap	(	vectorfield< V, Real, NumDimensions > const &	v,
		tag::numerical_t
	)

for_each()

template<typename F , typename... Ts>

constexpr void tatooine::for_each ( F &&  f, Ts &&...  ts  )

constexpr

for_loop() [1/19]

template<typename Int = std::size_t, typename Iteration , integral... Ends>

constexpr auto tatooine::for_loop ( Iteration &&  iteration, Ends const ...  ends  ) -> void

constexpr

Use this function for creating a sequential nested loop.

First Index grows fastest, then the second and so on.

iteration must either return bool or nothing. If iteration returns false in any state the whole nested iteration will stop. iteration must return true to continue.

for_loop() [2/19]

template<typename Int = std::size_t, typename Iteration , integral... Ends>
requires parallel_for_loop_support

constexpr auto tatooine::for_loop ( Iteration &&  iteration, execution_policy::parallel_t  , Ends const ...  ends  ) -> void

constexpr

Use this function for creating a parallel nested loop.

First Index grows fastest, then the second and so on.

iteration must either return bool or nothing. If iteration returns false in any state the whole nested iteration will stop. iteration must return true to continue.

for_loop() [3/19]

template<typename Int = std::size_t, typename Iteration , integral... Ranges>
requires parallel_for_loop_support

constexpr auto tatooine::for_loop ( Iteration &&  iteration, execution_policy::parallel_t  , Ranges(&&... ranges)  [2]  ) -> void

constexpr

Use this function for creating a parallel nested loop.

First Index grows fastest, then the second and so on.

iteration must either return bool or nothing. If iteration returns false in any state the whole nested iteration will stop. iteration must return true to continue.

for_loop() [4/19]

template<typename Int = std::size_t, typename Iteration , integral... Ranges>
requires parallel_for_loop_support

constexpr auto tatooine::for_loop ( Iteration &&  iteration, execution_policy::parallel_t  , std::pair< Ranges, Ranges > const &...  ranges  ) -> void

constexpr

Use this function for creating a parallel nested loop.

First Index grows fastest, then the second and so on.

iteration must either return bool or nothing. If iteration returns false in any state the whole nested iteration will stop. iteration must return true to continue.

for_loop() [5/19]

template<typename Int = std::size_t, typename Iteration , integral... Ends>

constexpr auto tatooine::for_loop ( Iteration &&  iteration, execution_policy::sequential_t  , Ends const ...  ends  ) -> void

constexpr

Use this function for creating a sequential nested loop.

First Index grows fastest, then the second and so on.

iteration must either return bool or nothing. If iteration returns false in any state the whole nested iteration will stop. iteration must return true to continue.

for_loop() [6/19]

template<typename Int = std::size_t, typename Iteration , integral... Ranges>

constexpr auto tatooine::for_loop ( Iteration &&  iteration, execution_policy::sequential_t  , Ranges(&&... ranges)  [2]  ) -> void

constexpr

Use this function for creating a sequential nested loop.

First Index grows fastest, then the second and so on.

iteration must either return bool or nothing. If iteration returns false in any state the whole nested iteration will stop. iteration must return true to continue.

for_loop() [7/19]

template<typename Int = std::size_t, typename Iteration , integral... Ranges>

constexpr auto tatooine::for_loop ( Iteration &&  iteration, execution_policy::sequential_t  , std::pair< Ranges, Ranges > const &...  ranges  ) -> void

constexpr

Use this function for creating a sequential nested loop.

First Index grows fastest, then the second and so on.

iteration must either return bool or nothing. If iteration returns false in any state the whole nested iteration will stop. iteration must return true to continue.

for_loop() [8/19]

template<integral_pair_range IntPairRange, for_loop_nested_index_iteration< std::vector< common_type< typename std::ranges::range_value_t< IntPairRange >::first_type, typename std::ranges::range_value_t< IntPairRange >::second_type > > > Iteration>

auto tatooine::for_loop	(	Iteration &&	iteration,
		IntPairRange const &	ranges
	)

Sequential nested loop over index ranges. Pairs describe begin and ends of single ranges. Second element of pair is excluded.

for_loop() [9/19]

template<integral_pair_range IntPairRange, for_loop_nested_index_iteration< std::vector< common_type< typename std::ranges::range_value_t< IntPairRange >::first_type, typename std::ranges::range_value_t< IntPairRange >::second_type > > > Iteration>

auto tatooine::for_loop	(	Iteration &&	iteration,
		IntPairRange const &	ranges,
		execution_policy::sequential_t
	)

Sequential nested loop over index ranges. Pairs describe begin and ends of single ranges. Second element of pair is excluded.

for_loop() [10/19]

template<integral_pair_range IntPairRange, for_loop_nested_index_iteration< std::vector< common_type< typename std::ranges::range_value_t< IntPairRange >::first_type, typename std::ranges::range_value_t< IntPairRange >::second_type > > > Iteration>

auto tatooine::for_loop	(	Iteration &&	iteration,
		IntPairRange const &	ranges,
		execution_policy_tag auto	policy
	)

Either sequential or parallel nested loop over index ranges. Pairs describe begin and ends of single ranges. Second element of pair is excluded.

for_loop() [11/19]

template<integral_range IntRange, for_loop_nested_index_iteration< IntRange > Iteration>

auto tatooine::for_loop	(	Iteration &&	iteration,
		IntRange const &	begin,
		IntRange const &	ends
	)

Sequential nested loop over index ranges from [begins] to [ends], excluding indices that are equal to elements of ends.

for_loop() [12/19]

template<integral_range IntRange, for_loop_nested_index_iteration< IntRange > Iteration>

auto tatooine::for_loop	(	Iteration &&	iteration,
		IntRange const &	begin,
		IntRange const &	ends,
		execution_policy::sequential_t
	)

Sequential nested loop over index ranges from [begins] to [ends], excluding indices that are equal to elements of ends.

for_loop() [13/19]

template<integral_range IntRange, for_loop_nested_index_iteration< IntRange > Iteration>

auto tatooine::for_loop	(	Iteration &&	iteration,
		IntRange const &	ends
	)

Sequential nested loop over index ranges from [0,..,0] to [ends], excluding indices that are equal to elements of ends.

for_loop() [14/19]

template<integral_range IntRange, for_loop_nested_index_iteration< IntRange > Iteration>

auto tatooine::for_loop	(	Iteration &&	iteration,
		IntRange const &	ends,
		execution_policy_tag auto	policy
	)

Either sequential or parallel nested loop over index ranges from [0,..,0] to [ends], excluding indices that are equal to elements of ends.

for_loop() [15/19]

template<range Range, for_loop_range_iteration< Range > Iteration>
requires (!integral<std::ranges::range_value_t<Range>>) && (!integral_pair<std::ranges::range_value_t<Range>>)

auto tatooine::for_loop	(	Iteration &&	iteration,
		Range &&	r,
		execution_policy::parallel_t
	)

Sequential nested loop over a generic range.

for_loop() [16/19]

template<range Range, for_loop_range_iteration< Range > Iteration>
requires (!integral<std::ranges::range_value_t<Range>>) && (!integral_pair<std::ranges::range_value_t<Range>>)

auto tatooine::for_loop	(	Iteration &&	iteration,
		Range &&	r,
		execution_policy::sequential_t
	)

Sequential nested loop over a generic range.

for_loop() [17/19]

template<range Range, for_loop_range_iteration< Range > Iteration>
requires (!integral<std::ranges::range_value_t<Range>>) && (!integral_pair<std::ranges::range_value_t<Range>>)

auto tatooine::for_loop	(	Iteration &&	iteration,
		Range const &	r
	)

Sequential loop over a generic range.

for_loop() [18/19]

template<typename Int = std::size_t, typename Iteration , integral... Ranges>

constexpr auto tatooine::for_loop ( Iteration &&  iteration, Ranges(&&... ranges)  [2]  ) -> void

constexpr

Use this function for creating a sequential nested loop.

First Index grows fastest, then the second and so on.

iteration must either return bool or nothing. If iteration returns false in any state the whole nested iteration will stop. iteration must return true to continue.

for_loop() [19/19]

template<typename Int = std::size_t, typename Iteration , integral... Ranges>

constexpr auto tatooine::for_loop ( Iteration &&  iteration, std::pair< Ranges, Ranges > const &...  ranges  ) -> void

constexpr

Use this function for creating a sequential nested loop.

First Index grows fastest, then the second and so on.

iteration must either return bool or nothing. If iteration returns false in any state the whole nested iteration will stop. iteration must return true to continue.

for_loop_num_parallel_threads()

auto tatooine::for_loop_num_parallel_threads ( )

inline

for_loop_unpacked() [1/2]

template<typename Iteration , integral Int, std::size_t N>

auto tatooine::for_loop_unpacked	(	Iteration &&	iteration,
		execution_policy_tag auto	policy,
		std::array< Int, N > const &	sizes
	)

for_loop_unpacked() [2/2]

template<typename Iteration , integral Int, std::size_t N>

auto tatooine::for_loop_unpacked	(	Iteration &&	iteration,
		std::array< Int, N > const &	sizes
	)

front() [1/2]

template<floating_point Real>

auto tatooine::front

(

linspace< Real > &

l

)

-> auto&

front() [2/2]

template<floating_point Real>

auto tatooine::front

(

linspace< Real > const &

l

)

ftle() [1/2]

template<typename... Domains, typename Flowmap >

auto tatooine::ftle	(	rectilinear_grid< Domains... > &	grid,
		Flowmap &&	flowmap,
		arithmetic auto const	t0,
		arithmetic auto const	tau
	)		-> decltype(auto)

ftle() [2/2]

template<typename... Domains, typename Flowmap >

auto tatooine::ftle	(	rectilinear_grid< Domains... > &	grid,
		Flowmap &&	flowmap,
		arithmetic auto const	t0,
		arithmetic auto const	tau,
		execution_policy_tag auto const	exec
	)		-> auto&

ftle_field() [1/4]

template<typename V , typename Real , size_t N>

tatooine::ftle_field	(	vectorfield< V, Real, N > const &	v,
		arithmetic	auto
	)		-> ftle_field< decltype(diff(flowmap(v)))>

ftle_field() [2/4]

template<typename V , typename Real , size_t N>

tatooine::ftle_field	(	vectorfield< V, Real, N > const &	v,
		arithmetic	auto,
		arithmetic	auto
	)		-> ftle_field< decltype(diff(flowmap(v)))>

ftle_field() [3/4]

template<typename V , typename Real , size_t N, template< typename, size_t > typename ODESolver>

tatooine::ftle_field	(	vectorfield< V, Real, N > const &	v,
		arithmetic	auto,
		ODESolver< Real, N >
	)		-> ftle_field< numerically_differentiated_flowmap< decltype((flowmap< ODESolver >(v)))> >

ftle_field() [4/4]

template<typename V , typename Real , size_t N, typename EpsReal >

tatooine::ftle_field	(	vectorfield< V, Real, N > const &	v,
		arithmetic	auto,
		vec< EpsReal, N > const &
	)		-> ftle_field< decltype(diff(flowmap(v)))>

get() [1/2]

template<std::size_t Idx, typename... Ts>

constexpr auto tatooine::get ( tuple< Ts... > &  t ) -> auto&

constexpr

get() [2/2]

template<std::size_t Idx, typename... Ts>

constexpr auto tatooine::get ( tuple< Ts... > const &  t ) -> auto const&

constexpr

has_face_at_method() [1/2]

template<typename T >

constexpr auto tatooine::has_face_at_method ( )

constexpr

has_face_at_method() [2/2]

template<typename T >

constexpr auto tatooine::has_face_at_method ( T &&  )

constexpr

has_fields_available_method() [1/2]

template<typename T >

constexpr auto tatooine::has_fields_available_method ( )

constexpr

has_fields_available_method() [2/2]

template<typename T >

constexpr auto tatooine::has_fields_available_method ( T &&  t )

constexpr

has_separating_axis()

template<typename Real >

auto tatooine::has_separating_axis	(	std::vector< vec< Real, 2 > > const &	polygon0,
		std::vector< vec< Real, 2 > > const &	polygon1
	)		-> bool

from https://hackmd.io/@US4ofdv7Sq2GRdxti381_A/ryFmIZrsl?type=view#:~:text=Separating%20axis%20theorem%20(SAT)&text=In%20simple%20terms%2C%20the%20SAT,objects'%20projections%20do%20not%20overlap.

has_tetrahedron_at_method() [1/2]

template<typename T >

constexpr auto tatooine::has_tetrahedron_at_method ( )

constexpr

has_tetrahedron_at_method() [2/2]

template<typename T >

constexpr auto tatooine::has_tetrahedron_at_method ( T &&  )

constexpr

helicity()

template<typename V , typename Real >

auto tatooine::helicity

(

const field< V, Real, 3, 3 > &

vf

)

hold()

template<typename T >

auto tatooine::hold

(

T &&

t

)

holder() [1/2]

template<typename T >

tatooine::holder

(

const T &

)

-> holder< const T & >

holder() [2/2]

template<typename T >

tatooine::holder

(

T &&

)

-> holder< T >

huber_loss()

template<arithmetic Delta = int>

auto constexpr tatooine::huber_loss ( floating_point auto const  a, Delta const  delta = 1  )

constexpr

See Wikipedia

imag() [1/2]

template<typename Tensor , typename T , size_t... Dims>

auto tatooine::imag

(

base_tensor< Tensor, std::complex< T >, Dims... > &

tensor

)

imag() [2/2]

template<typename Tensor , typename T , size_t... Dims>

auto tatooine::imag

(

base_tensor< Tensor, std::complex< T >, Dims... > const &

tensor

)

indeterminate_progress_bar() [1/3]

template<typename F , typename... Args>
requires is_invocable<F, indicator_msg<indicators::IndeterminateProgressBar>, Args...> && is_void<invoke_result< F, indicator_msg<indicators::IndeterminateProgressBar>, Args...>>

auto tatooine::indeterminate_progress_bar	(	F &&	f,
		Args &&...	args
	)

indeterminate_progress_bar() [2/3]

template<typename F , typename... Args>
requires is_invocable<F, Args...>

auto tatooine::indeterminate_progress_bar	(	F &&	f,
		Args &&...	args
	)		-> decltype(auto)

indeterminate_progress_bar() [3/3]

template<typename F , typename... Args>
requires is_invocable<F, indicator_msg<indicators::IndeterminateProgressBar>, Args...> && (!is_void<invoke_result< F, indicator_msg<indicators::IndeterminateProgressBar>, Args...>>)

auto tatooine::indeterminate_progress_bar	(	F &&	f,
		Args &&...	args
	)		-> decltype(auto)

index()

template<typename Child , unsigned_integral Int>

auto constexpr tatooine::index ( handle< Child, Int > const  h )

constexpr

interpolate() [1/4]

template<typename IndexingOut = x_fastest, typename T0 , typename T1 , typename Indexing0 , typename Indexing1 , typename FReal >

auto tatooine::interpolate	(	dynamic_multidim_array< T0, Indexing0 > const &	arr0,
		dynamic_multidim_array< T1, Indexing1 > const &	arr1,
		FReal	factor
	)

interpolate() [2/4]

template<typename IndexingOut = x_fastest, typename T0 , typename T1 , typename Indexing0 , typename Indexing1 , typename LinReal , typename TReal >

auto tatooine::interpolate	(	dynamic_multidim_array< T0, Indexing0 > const &	arr0,
		dynamic_multidim_array< T1, Indexing1 > const &	arr1,
		linspace< LinReal > const &	ts,
		TReal	t
	)

interpolate() [3/4]

template<typename MemLocOut = stack, typename IndexingOut = x_fastest, typename T0 , typename T1 , typename Indexing0 , typename Indexing1 , typename MemLoc0 , typename MemLoc1 , typename FReal , std::size_t... Resolution>

auto tatooine::interpolate	(	static_multidim_array< T0, Indexing0, MemLoc0, Resolution... > const &	arr0,
		static_multidim_array< T1, Indexing1, MemLoc1, Resolution... > const &	arr1,
		FReal	factor
	)

interpolate() [4/4]

template<typename MemLocOut = stack, typename IndexingOut = x_fastest, typename T0 , typename T1 , typename Indexing0 , typename Indexing1 , typename MemLoc0 , typename MemLoc1 , typename LinReal , typename TReal , std::size_t... Resolution>

auto tatooine::interpolate	(	static_multidim_array< T0, Indexing0, MemLoc0, Resolution... > const &	arr0,
		static_multidim_array< T1, Indexing1, MemLoc1, Resolution... > const &	arr1,
		linspace< LinReal > const &	ts,
		TReal	t
	)

intersections()

template<typename Real >

auto tatooine::intersections	(	std::vector< line< Real, 2 > > const &	lines0,
		std::vector< line< Real, 2 > > const &	lines1
	)

inv() [1/2]

template<typename Tensor , std::size_t N>

constexpr auto tatooine::inv ( diag_static_tensor< Tensor, N, N > const &  A ) -> std::optional< diag_static_tensor<vec<tatooine::value_type<Tensor>, N>, N, N>>

constexpr

inv() [2/2]

template<fixed_size_quadratic_mat< 2 > Mat>

constexpr auto tatooine::inv ( Mat &&  A ) -> std::optional<mat<tatooine::value_type<Mat>, 2, 2>>

constexpr

invert matrix A = [a,b] [c,d]

invert matrix A = [a,b,c] [d,e,f] [g,h,i]

invert matrix A = [a,b,c,d] [e,f,g,h] [i,j,k,l] [m,n,o,p]

inv_sym()

template<fixed_size_quadratic_mat< 2 > Mat>

constexpr auto tatooine::inv_sym ( Mat &&  A ) -> std::optional<mat<tatooine::value_type<Mat>, 2, 2>>

constexpr

invert symmetric matrix A = [a,b] [b,c]

invert symmetric matrix A = [a,b,c] [b,d,e] [c,e,f]

invert symmetric matrix A = [a,b,c,d] [b,e,f,g] [c,f,h,i] [d,g,i,j]

inverse()

template<typename Tensor , size_t M, size_t N>

auto tatooine::inverse

(

const base_tensor< Tensor, GiNaC::ex, M, N > &

m_in

)

invoke()

constexpr auto tatooine::invoke ( invocable auto &&...  funcs )

constexpr

invoke_omitted() [1/2]

template<size_t i, size_t... is, typename F , typename Param , typename... Params>

constexpr decltype(auto) tatooine::invoke_omitted ( F &&  f, Param &&  param, Params &&...  params  )

constexpr

invoke_omitted() [2/2]

template<typename F , typename... Params>

constexpr decltype(auto) tatooine::invoke_omitted ( F &&  f, Params &&...  params  )

constexpr

invoke_reversed() [1/2]

auto constexpr tatooine::invoke_reversed ( auto &&  f, auto &&  param0  ) -> decltype(auto)

constexpr

invoke_reversed() [2/2]

auto constexpr tatooine::invoke_reversed ( auto &&  f, auto &&  param0, auto &&  param1, auto &&...  params  ) -> decltype(auto)

constexpr

invoke_unpacked() [1/4]

template<typename F >

constexpr decltype(auto) tatooine::invoke_unpacked ( F &&  f )

constexpr

All arguments are bound -> just call f.

invoke_unpacked() [2/4]

template<typename F , typename T , typename... Ts>

constexpr decltype(auto) tatooine::invoke_unpacked ( F &&  f, T &&  t, Ts &&...  ts  )

constexpr

Recursive currying. Curry first non-unpacked type to f.

Returns

Returns curried function.

invoke_unpacked() [3/4]

template<typename F , typename T , typename... Ts>

constexpr decltype(auto) tatooine::invoke_unpacked ( F &&  f, unpack< T >  t, Ts &&...  ts  )

constexpr

invoke_unpacked() [4/4]

template<std::size_t... Is, typename F , typename T , typename... Ts>

constexpr decltype(auto) tatooine::invoke_unpacked ( std::index_sequence< Is... >  , F &&  f, unpack< T >  t, Ts &&...  ts  )

constexpr

Curries unpacked parameters by calling invoke_unpacked(F&&, T&&, Ts&&...).

ipow()

constexpr auto tatooine::ipow ( integral auto const  base, integral auto const  exp  )

constexpr

is_cacheable() [1/2]

template<typename T >

constexpr auto tatooine::is_cacheable ( )

constexpr

is_cacheable() [2/2]

template<typename T >

constexpr auto tatooine::is_cacheable ( T &&  )

constexpr

is_celltree() [1/2]

template<typename T >

constexpr auto tatooine::is_celltree ( )

constexpr

is_celltree() [2/2]

template<typename T >

constexpr auto tatooine::is_celltree ( T &&  )

constexpr

is_kdtree() [1/2]

template<typename T >

constexpr auto tatooine::is_kdtree ( )

constexpr

is_kdtree() [2/2]

template<typename T >

constexpr auto tatooine::is_kdtree ( T &&  )

constexpr

is_separating_axis()

template<typename Real >

auto tatooine::is_separating_axis	(	vec< Real, 2 > const &	n,
		std::vector< vec< Real, 2 > > const &	polygon0,
		std::vector< vec< Real, 2 > > const &	polygon1
	)

Return true if n is a separating axis of polygon0 and polygon1.

is_symbolic_field() [1/2]

template<typename Real , size_t N, size_t... TensorDims>

constexpr auto tatooine::is_symbolic_field ( const field< symbolic::field< Real, N, TensorDims... >, Real, N, TensorDims... > &  )

constexprnoexcept

is_symbolic_field() [2/2]

template<typename T >

constexpr auto tatooine::is_symbolic_field ( T &&  )

constexprnoexcept

is_uniform_tree_hierarchy() [1/2]

template<typename T >

constexpr auto tatooine::is_uniform_tree_hierarchy ( )

constexpr

is_uniform_tree_hierarchy() [2/2]

template<typename T >

constexpr auto tatooine::is_uniform_tree_hierarchy ( T &&  )

constexpr

isnan()

template<typename Tensor , typename Real , size_t... Dims>

constexpr auto tatooine::isnan ( base_tensor< Tensor, Real, Dims... > const &  t ) -> bool

constexpr

isolines() [1/5]

template<typename Grid , arithmetic T, bool HasNonConstReference>

auto tatooine::isolines	(	detail::rectilinear_grid::typed_vertex_property_interface< Grid, T, HasNonConstReference > const &	data,
		arithmetic auto const	isolevel
	)

isolines() [2/5]

template<arithmetic Real, typename Indexing , arithmetic BBReal>

auto tatooine::isolines	(	dynamic_multidim_array< Real, Indexing > const &	data,
		axis_aligned_bounding_box< BBReal, 2 > const &	bb,
		arithmetic auto const	isolevel
	)

isolines() [3/5]

template<typename XDomain , typename YDomain >

auto tatooine::isolines	(	invocable< std::size_t, std::size_t, Vec2< typename rectilinear_grid< XDomain, YDomain >::real_type > > auto &&	get_scalars,
		rectilinear_grid< XDomain, YDomain > const &	g,
		arithmetic auto const	isolevel
	)

Indexing and lookup map from http://paulbourke.net/geometry/polygonise/.

isolines() [4/5]

template<typename Field , typename FieldReal , floating_point_range XDomain, floating_point_range YDomain, arithmetic TReal = FieldReal>

auto tatooine::isolines	(	scalarfield< Field, FieldReal, 2 > const &	sf,
		rectilinear_grid< XDomain, YDomain > const &	g,
		arithmetic auto const	isolevel,
		TReal const	t = 0
	)

isolines() [5/5]

template<arithmetic Real, arithmetic BBReal, typename Indexing , typename MemLoc , std::size_t XRes, std::size_t YRes>

auto tatooine::isolines	(	static_multidim_array< Real, Indexing, MemLoc, XRes, YRes > const &	data,
		axis_aligned_bounding_box< BBReal, 2 > const &	bb,
		arithmetic auto const	isolevel
	)

isosurface() [1/5]

template<typename Grid , arithmetic T, bool HasNonConstReference>

auto tatooine::isosurface	(	detail::rectilinear_grid::typed_vertex_property_interface< Grid, T, HasNonConstReference > const &	data,
		arithmetic auto const	isolevel
	)

isosurface() [2/5]

template<arithmetic Real, typename Indexing , arithmetic BBReal, arithmetic Isolevel>

auto tatooine::isosurface	(	dynamic_multidim_array< Real, Indexing > const &	data,
		axis_aligned_bounding_box< BBReal, 3 > const &	bb,
		Isolevel const	isolevel
	)

isosurface() [3/5]

template<typename XDomain , typename YDomain , typename ZDomain , arithmetic Isolevel, invocable< std::size_t, std::size_t, std::size_t, vec< typename rectilinear_grid< XDomain, YDomain, ZDomain >::real_type, 3 > > GetScalars>

auto tatooine::isosurface	(	GetScalars &&	get_scalars,
		rectilinear_grid< XDomain, YDomain, ZDomain > const &	g,
		Isolevel const	isolevel
	)

Indexing and lookup map from http://paulbourke.net/geometry/polygonise/.

isosurface() [4/5]

template<typename Field , arithmetic FieldReal, typename XDomain , typename YDomain , typename ZDomain , arithmetic Isolevel, arithmetic TReal = int>

auto tatooine::isosurface	(	scalarfield< Field, FieldReal, 3 > const &	sf,
		rectilinear_grid< XDomain, YDomain, ZDomain > const &	g,
		Isolevel const	isolevel,
		TReal const	t = 0
	)

isosurface() [5/5]

template<arithmetic Real, typename Indexing , typename MemLoc , std::size_t XRes, std::size_t YRes, std::size_t ZRes, arithmetic BBReal, arithmetic Isolevel>

auto tatooine::isosurface	(	static_multidim_array< Real, Indexing, MemLoc, XRes, YRes, ZRes > const &	data,
		axis_aligned_bounding_box< BBReal, 3 > const &	bb,
		Isolevel const	isolevel
	)

lagrangian_Q()

template<typename V , typename Real , size_t N>

auto tatooine::lagrangian_Q	(	const field< V, Real, N, N > &	vf,
		arithmetic auto const	btau,
		arithmetic auto const	ftau
	)

lambda2()

template<typename V , typename Real , size_t N>

auto tatooine::lambda2

(

const field< V, Real, N, N > &

vf

)

line()

template<typename... Tensors, typename... Reals, std::size_t NumDimensions>

tatooine::line

(

base_tensor< Tensors, Reals, NumDimensions > &&...

vertices

)

-> line< common_type< Reals... >, NumDimensions >

linspace()

template<arithmetic Real0, arithmetic Real1>

tatooine::linspace	(	Real0 const	,
		Real1 const	,
		std::size_t const
	)		-> linspace< common_type< Real0, Real1 > >

log()

constexpr auto tatooine::log ( arithmetic auto const  x )

constexpr

log2()

constexpr auto tatooine::log2 ( arithmetic auto const  x )

constexpr

make_array() [1/5]

template<typename T , size_t N>

constexpr auto tatooine::make_array ( )

constexpr

make_array() [2/5]

template<typename T , typename... Data>

constexpr auto tatooine::make_array ( Data &&...  data )

constexpr

make_array() [3/5]

template<typename T , size_t N>

constexpr auto tatooine::make_array ( std::array< T, N > const &  data )

constexpr

make_array() [4/5]

template<size_t N, typename T >

constexpr auto tatooine::make_array ( T &&  default_data )

constexpr

make_array() [5/5]

template<typename T , size_t... Is>

constexpr auto tatooine::make_array ( T &&  default_data, std::index_sequence< Is... >    )

constexpr

make_binary_operation_field() [1/10]

template<typename LHSInternalField , typename LHSReal , size_t N, typename LHSTensor , typename RHSInternalField , typename RHSReal , typename RHSTensor , typename Op >

constexpr auto tatooine::make_binary_operation_field ( const field< LHSInternalField, LHSReal, N, LHSTensor > &  lhs, const field< RHSInternalField, RHSReal, N, RHSTensor > &  rhs, const Op &  op  )

constexpr

make_binary_operation_field() [2/10]

template<typename LHSInternalField , typename LHSReal , size_t N, typename LHSTensor , typename RHSInternalField , typename RHSReal , typename RHSTensor , typename Op >

constexpr auto tatooine::make_binary_operation_field ( const field< LHSInternalField, LHSReal, N, LHSTensor > &  lhs, const field< RHSInternalField, RHSReal, N, RHSTensor > &  rhs, Op &&  op  )

constexpr

make_binary_operation_field() [3/10]

template<typename LHSInternalField , typename LHSReal , size_t N, typename LHSTensor , typename RHSInternalField , typename RHSReal , typename RHSTensor , typename Op >

constexpr auto tatooine::make_binary_operation_field ( const field< LHSInternalField, LHSReal, N, LHSTensor > &  lhs, field< RHSInternalField, RHSReal, N, RHSTensor > &&  rhs, const Op &  op  )

constexpr

make_binary_operation_field() [4/10]

template<typename LHSInternalField , typename LHSReal , size_t N, typename LHSTensor , typename RHSInternalField , typename RHSReal , typename RHSTensor , typename Op >

constexpr auto tatooine::make_binary_operation_field ( const field< LHSInternalField, LHSReal, N, LHSTensor > &  lhs, field< RHSInternalField, RHSReal, N, RHSTensor > &&  rhs, Op  op  )

constexpr

make_binary_operation_field() [5/10]

template<typename LHSInternalField , typename LHSReal , size_t N, typename LHSTensor , typename RHSInternalField , typename RHSReal , typename RHSTensor , typename Op >

constexpr auto tatooine::make_binary_operation_field ( field< LHSInternalField, LHSReal, N, LHSTensor > &&  lhs, const field< RHSInternalField, RHSReal, N, RHSTensor > &  rhs, const Op &  op  )

constexpr

make_binary_operation_field() [6/10]

template<typename LHSInternalField , typename LHSReal , size_t N, typename LHSTensor , typename RHSInternalField , typename RHSReal , typename RHSTensor , typename Op >

constexpr auto tatooine::make_binary_operation_field ( field< LHSInternalField, LHSReal, N, LHSTensor > &&  lhs, const field< RHSInternalField, RHSReal, N, RHSTensor > &  rhs, Op &&  op  )

constexpr

make_binary_operation_field() [7/10]

template<typename LHSInternalField , typename LHSReal , size_t N, typename LHSTensor , typename RHSInternalField , typename RHSReal , typename RHSTensor , typename Op >

constexpr auto tatooine::make_binary_operation_field ( field< LHSInternalField, LHSReal, N, LHSTensor > &&  lhs, field< RHSInternalField, RHSReal, N, RHSTensor > &&  rhs, const Op &  op  )

constexpr

make_binary_operation_field() [8/10]

template<typename LHSInternalField , typename LHSReal , size_t N, typename LHSTensor , typename RHSInternalField , typename RHSReal , typename RHSTensor , typename Op >

constexpr auto tatooine::make_binary_operation_field ( field< LHSInternalField, LHSReal, N, LHSTensor > &&  lhs, field< RHSInternalField, RHSReal, N, RHSTensor > &&  rhs, Op  op  )

constexpr

make_binary_operation_field() [9/10]

template<typename RealOut , size_t NOut, size_t... TensorDimsOut, typename LHSReal , size_t N, typename LHSTensor , typename RHSReal , typename RHSTensor , typename Op >

constexpr auto tatooine::make_binary_operation_field ( polymorphic::field< LHSReal, N, LHSTensor > const &  lhs, polymorphic::field< RHSReal, N, RHSTensor > const &  rhs, Op  op  )

constexpr

make_binary_operation_field() [10/10]

template<typename LHSReal , size_t N, typename LHSTensor , typename RHSReal , typename RHSTensor , typename Op >

constexpr auto tatooine::make_binary_operation_field ( polymorphic::field< LHSReal, N, LHSTensor > const *  lhs, polymorphic::field< RHSReal, N, RHSTensor > const *  rhs, Op  op  )

constexpr

make_default_indeterminate_progress_bar()

auto tatooine::make_default_indeterminate_progress_bar

(

)

make_field()

template<std::size_t NumDimensions, typename F >

constexpr auto tatooine::make_field ( F &&  f )

constexpr

make_indeterminate_completion_thread()

auto tatooine::make_indeterminate_completion_thread

(

auto &

indicator

)

map()

template<typename... Ts, typename F >

auto constexpr tatooine::map ( F &&  f, Ts &&...  ts  )

constexpr

maps unary function f to all single parameters of parameter pack ts

mat() [1/2]

template<typename Mat , typename ValueType , std::size_t M, std::size_t N>

tatooine::mat

(

base_tensor< Mat, ValueType, M, N >

)

-> mat< ValueType, M, N >

mat() [2/2]

template<std::size_t C, typename... Rows>

tatooine::mat

(

Rows const

(&&... rows)[C]

)

-> mat< common_type< Rows... >, sizeof...(Rows), C >

max() [1/6]

template<typename A , typename B >
requires same_as<std::decay_t<A>, std::decay_t<B>>

constexpr auto tatooine::max ( A &&  a, B &&  b  )

constexpr

max() [2/6]

template<typename Tensor , typename T , std::size_t... Dims>

constexpr auto tatooine::max ( base_tensor< Tensor, T, Dims... > const &  t )

constexpr

max() [3/6]

template<typename T , std::size_t N>

constexpr auto tatooine::max ( std::array< T, N > const &  arr )

constexpr

max() [4/6]

template<typename T , std::size_t N, std::size_t... Is>

constexpr auto tatooine::max ( std::array< T, N > const &  arr, std::index_sequence< Is... >    )

constexpr

max() [5/6]

template<typename T0 >

constexpr auto tatooine::max ( T0 &&  a ) -> decltype(auto)

constexpr

max() [6/6]

template<typename T0 , typename T1 , typename T2 , typename... TRest>
requires requires(T0&& a, T1&& b) { { a > b } -> std::convertible_to<bool>; }

constexpr auto tatooine::max ( T0 &&  a, T1 &&  b, T2 &&  c, TRest &&...  rest  ) -> decltype(auto)

constexpr

max_angle()

template<typename Tensor0 , typename Tensor1 , typename T0 , typename T1 , std::size_t N>

constexpr auto tatooine::max_angle ( base_tensor< Tensor0, T0, N > const &  v0, base_tensor< Tensor1, T1, N > const &  v1  )

constexpr

Returns the angle of two normalized vectors.

measure()

template<typename F , typename... Param>

auto tatooine::measure	(	F &&	f,
		Param &&...	param
	)

memory_usage()

auto tatooine::memory_usage ( )

inline

Attempts to read the system-dependent data for a process' virtual memory size and resident set size, and return the results in Byte.

merge() [1/3]

template<range_of_lines Lines, floating_point Eps = real_number, execution_policy_tag ExecutionPolicy>

auto tatooine::merge	(	Lines &	lines,
		std::ranges::range_value_t< Lines >	line_to_merge,
		ExecutionPolicy const	tag,
		Eps const	eps = 1e-13
	)		-> auto &

Merges line_to_merge into lines.

merge() [2/3]

template<range_of_lines Lines, floating_point Eps = real_number>

auto tatooine::merge	(	Lines const &	unmerged_lines,
		Eps const	eps = 1e-13
	)

Merges a set of lines and combines lines with equal vertex endings.

merge() [3/3]

template<typename Lines , typename MaxDist >

auto tatooine::merge	(	range_of_lines auto	lines,
		MaxDist	max_length
	)

min() [1/5]

template<typename A , typename B >
requires same_as<std::decay_t<A>, std::decay_t<B>>

constexpr auto tatooine::min ( A &&  a, B &&  b  )

constexpr

min() [2/5]

template<typename Tensor , typename T , std::size_t... Dims>

constexpr auto tatooine::min ( base_tensor< Tensor, T, Dims... > const &  t )

constexpr

min() [3/5]

template<typename T , std::size_t N>

constexpr auto tatooine::min ( std::array< T, N > const &  arr )

constexpr

min() [4/5]

template<typename T , std::size_t N, std::size_t... Is>

constexpr auto tatooine::min ( std::array< T, N > const &  arr, std::index_sequence< Is... >    )

constexpr

min() [5/5]

template<typename T0 , typename T1 , typename T2 , typename... TRest>
requires requires(T0&& a, T1&& b) { { a > b } -> std::convertible_to<bool>; }

constexpr auto tatooine::min ( T0 &&  a, T1 &&  b, T2 &&  c, TRest &&...  rest  ) -> decltype(auto)

constexpr

min_angle()

template<typename Tensor0 , typename Tensor1 , typename T0 , typename T1 , std::size_t N>

constexpr auto tatooine::min_angle ( base_tensor< Tensor0, T0, N > const &  v0, base_tensor< Tensor1, T1, N > const &  v1  )

constexpr

Returns the angle of two normalized vectors.

nan()

template<floating_point Float = real_number>

auto tatooine::nan

(

const char *

arg = ""

)

newton_raphson() [1/2]

template<typename Real , size_t N, size_t... Is>

auto tatooine::newton_raphson	(	const symbolic::field< Real, N, N > &	v,
		typename symbolic::field< Real, N, N >::pos_type	x,
		Real	t,
		size_t	n,
		double	precision,
		std::index_sequence< Is... >
	)

newton_raphson() [2/2]

template<typename Real , size_t N>

auto tatooine::newton_raphson	(	const symbolic::field< Real, N, N > &	v,
		typename symbolic::field< Real, N, N >::pos_type	x,
		Real	t,
		size_t	n,
		double	precision = 1e-10
	)

next() [1/2]

template<derived_from_iterator_facade Iter>

auto tatooine::next

(

Iter

iter

)

next() [2/2]

template<derived_from_iterator_facade Iter>

auto tatooine::next	(	Iter	iter,
		difference_type_arg< Iter > auto	off
	)

norm() [1/4]

template<typename Tensor , typename T , std::size_t M, std::size_t N>

constexpr auto tatooine::norm ( base_tensor< Tensor, T, M, N > const &  A, unsigned int const  p  )

constexpr

p-norm of a rank-2 tensor

norm() [2/4]

template<typename Tensor , typename T , std::size_t M, std::size_t N>

constexpr auto tatooine::norm ( base_tensor< Tensor, T, M, N > const &  mat )

constexpr

squared Frobenius norm of a rank-2 tensor

norm() [3/4]

template<typename Tensor , typename T , std::size_t M, std::size_t N>

constexpr auto tatooine::norm ( base_tensor< Tensor, T, M, N > const &  mat, tag::frobenius_t    )

constexpr

Frobenius norm of a rank-2 tensor.

norm() [4/4]

template<typename Tensor , typename T , std::size_t N>

constexpr auto tatooine::norm ( base_tensor< Tensor, T, N > const &  t, unsigned  p = 2  ) -> T

constexpr

norm1() [1/2]

template<typename Tensor , typename T , std::size_t M, std::size_t N>

constexpr auto tatooine::norm1 ( base_tensor< Tensor, T, M, N > const &  mat )

constexpr

1-norm of a MxN Tensor

norm1() [2/2]

template<typename Tensor , typename T , std::size_t N>

constexpr auto tatooine::norm1 ( base_tensor< Tensor, T, N > const &  t )

constexpr

norm_inf() [1/2]

template<typename Tensor , typename T , std::size_t M, std::size_t N>

constexpr auto tatooine::norm_inf ( base_tensor< Tensor, T, M, N > const &  mat )

constexpr

infinity-norm of a MxN tensor

norm_inf() [2/2]

template<typename Tensor , typename T , std::size_t N>

constexpr auto tatooine::norm_inf ( base_tensor< Tensor, T, N > const &  t ) -> T

constexpr

normal()

template<typename Tensor , size_t... Dims>

void tatooine::normal

(

base_tensor< Tensor, GiNaC::ex, Dims... > &

m

)

normalize()

template<typename Tensor , typename T , std::size_t N>

constexpr auto tatooine::normalize ( base_tensor< Tensor, T, N > const &  t_in ) -> vec<T, N>

constexpr

numerical_flowmap() [1/4]

template<typename V , typename Real , std::size_t NumDimensions>

tatooine::numerical_flowmap

(

vectorfield< V, Real, NumDimensions > &&

)

-> numerical_flowmap< V, ode::boost::rungekuttafehlberg78, interpolation::cubic >

numerical_flowmap() [2/4]

template<typename V , typename Real , std::size_t NumDimensions, template< typename, std::size_t > typename ODESolver>

tatooine::numerical_flowmap	(	vectorfield< V, Real, NumDimensions > &&	,
		ODESolver< Real, NumDimensions > const &
	)		-> numerical_flowmap< V, ODESolver, interpolation::cubic >

numerical_flowmap() [3/4]

template<typename V , typename Real , std::size_t NumDimensions>

tatooine::numerical_flowmap

(

vectorfield< V, Real, NumDimensions > const &

)

-> numerical_flowmap< V const &, ode::boost::rungekuttafehlberg78, interpolation::cubic >

numerical_flowmap() [4/4]

template<typename V , typename Real , std::size_t NumDimensions, template< typename, std::size_t > typename ODESolver>

tatooine::numerical_flowmap	(	vectorfield< V, Real, NumDimensions > const &	,
		ODESolver< Real, NumDimensions > const &
	)		-> numerical_flowmap< V const &, ODESolver, interpolation::cubic >

numerically_differentiated_field() [1/6]

template<typename Field , arithmetic Eps>

tatooine::numerically_differentiated_field	(	Field &&	,
		Eps const
	)		-> numerically_differentiated_field< Field >

numerically_differentiated_field() [2/6]

template<typename Field , arithmetic Eps>

tatooine::numerically_differentiated_field	(	Field &&	f,
		vec< Eps, field_num_dimensions< Field > > const &
	)		-> numerically_differentiated_field< Field >

numerically_differentiated_field() [3/6]

template<typename Field , arithmetic Eps>

tatooine::numerically_differentiated_field	(	Field &	,
		Eps const
	)		-> numerically_differentiated_field< Field & >

numerically_differentiated_field() [4/6]

template<typename Field , arithmetic Eps>

tatooine::numerically_differentiated_field	(	Field &	f,
		vec< Eps, field_num_dimensions< Field > > const &
	)		-> numerically_differentiated_field< Field & >

numerically_differentiated_field() [5/6]

template<typename Field , arithmetic Eps>

tatooine::numerically_differentiated_field	(	Field const &	,
		Eps const
	)		-> numerically_differentiated_field< Field const & >

numerically_differentiated_field() [6/6]

template<typename Field , arithmetic Eps>

tatooine::numerically_differentiated_field	(	Field const &	f,
		vec< Eps, field_num_dimensions< Field > > const &
	)		-> numerically_differentiated_field< Field const & >

numerically_differentiated_flowmap() [1/6]

template<flowmap_concept Flowmap>

tatooine::numerically_differentiated_flowmap

(

Flowmap &&

)

-> numerically_differentiated_flowmap< Flowmap >

numerically_differentiated_flowmap() [2/6]

template<flowmap_concept Flowmap>

tatooine::numerically_differentiated_flowmap	(	Flowmap &&	,
		arithmetic	auto
	)		-> numerically_differentiated_flowmap< Flowmap >

numerically_differentiated_flowmap() [3/6]

template<flowmap_concept Flowmap>

tatooine::numerically_differentiated_flowmap	(	Flowmap &&	,
		typename Flowmap::pos_type const &
	)		-> numerically_differentiated_flowmap< Flowmap >

numerically_differentiated_flowmap() [4/6]

template<flowmap_concept Flowmap>

tatooine::numerically_differentiated_flowmap

(

Flowmap const &

)

-> numerically_differentiated_flowmap< Flowmap const & >

numerically_differentiated_flowmap() [5/6]

template<flowmap_concept Flowmap>

tatooine::numerically_differentiated_flowmap	(	Flowmap const &	,
		arithmetic	auto
	)		-> numerically_differentiated_flowmap< Flowmap >

numerically_differentiated_flowmap() [6/6]

template<flowmap_concept Flowmap>

tatooine::numerically_differentiated_flowmap	(	Flowmap const &	,
		typename Flowmap::pos_type const &
	)		-> numerically_differentiated_flowmap< Flowmap >

operator!=() [1/2]

auto tatooine::operator!=	(	forward_or_backward_tag auto const	lhs,
		forward_or_backward_tag auto const	rhs
	)

operator!=() [2/2]

template<static_tensor Lhs, static_tensor Rhs>
requires (same_dimensions<Lhs, Rhs>())

auto constexpr tatooine::operator!= ( Lhs const &  lhs, Rhs const &  rhs  )

constexpr

operator*() [1/17]

template<typename V , arithmetic VReal, std::size_t N, typename Tensor >

constexpr auto tatooine::operator* ( arithmetic auto const  scalar, field< V, VReal, N, Tensor > const &  f  )

constexpr

operator*() [2/17]

auto constexpr tatooine::operator* ( arithmetic_or_complex auto const  scalar, static_tensor auto const &  t  )

constexpr

operator*() [3/17]

template<typename V0 , typename Real0 , typename V1 , typename Real1 , std::size_t N, typename Tensor >

constexpr auto tatooine::operator* ( const field< V0, Real0, N, Tensor > &  lhs, const field< V1, Real1, N, Tensor > &  rhs  )

constexpr

operator*() [4/17]

template<typename V0 , typename Real0 , typename V1 , typename Real1 , std::size_t N, std::size_t TM, std::size_t TN>

constexpr auto tatooine::operator* ( const matrixfield< V0, Real0, N, TM, TN > &  lhs, const vectorfield< V1, Real1, N, TN > &  rhs  )

constexpr

operator*() [5/17]

template<typename TensorA , std::size_t M, std::size_t N>
requires (N == std::decay_t<decltype(B)>::dimension( 0))

constexpr auto tatooine::operator* ( diag_static_tensor< TensorA, M, N > const &  A, static_mat auto const &  B  )

constexpr

operator*() [6/17]

template<typename TensorA , std::size_t M, std::size_t N>

constexpr auto tatooine::operator* ( diag_static_tensor< TensorA, M, N > const &  A, static_vec auto const &  b  ) -> vec< common_type<tatooine::value_type<TensorA>, tatooine::value_type<decltype(b)>>, M> requires(N == decltype(b)::dimension(0))

constexpr

operator*() [7/17]

template<typename V , typename VReal , std::size_t N, typename Tensor >

constexpr auto tatooine::operator* ( field< V, VReal, N, Tensor > const &  f, arithmetic auto const  scalar  )

constexpr

operator*() [8/17]

template<typename Child , unsigned_integral Int>

auto tatooine::operator*	(	handle< Child, Int > const	h,
		integral auto const	i
	)

operator*() [9/17]

template<typename Child , unsigned_integral Int>

auto tatooine::operator*	(	integral auto const	i,
		handle< Child, Int > const	h
	)

operator*() [10/17]

template<static_mat Lhs, static_mat Rhs>
requires (Lhs::dimension(1) == Rhs::dimension(0))

auto constexpr tatooine::operator* ( Lhs const &  lhs, Rhs const &  rhs  )

constexpr

matrix-matrix multiplication

matrix-vector-multiplication

operator*() [11/17]

template<static_vec Lhs, static_mat Rhs>
requires (Lhs::dimension(0) == Rhs::dimension(0))

auto constexpr tatooine::operator* ( Lhs const &  lhs, Rhs const &  rhs  )

constexpr

vector-matrix-multiplication

operator*() [12/17]

template<static_tensor Lhs, static_tensor Rhs>
requires (same_dimensions<Lhs, Rhs>() && Lhs::rank() != 2 && Rhs::rank() != 2)

auto constexpr tatooine::operator* ( Lhs const &  lhs, Rhs const &  rhs  )

constexpr

component-wise multiplication

operator*() [13/17]

template<dynamic_tensor Lhs, dynamic_tensor Rhs>

auto tatooine::operator*	(	Lhs const &	lhs,
		Rhs const &	rhs
	)

operator*() [14/17]

template<dynamic_tensor Lhs, dynamic_tensor Rhs>
requires diag_tensor<Lhs>

auto tatooine::operator*	(	Lhs const &	lhs,
		Rhs const &	rhs
	)		-> tensor<common_type<tatooine::value_type<Lhs>, tatooine::value_type<Rhs>>>

operator*() [15/17]

template<typename Real0 , typename Real1 , std::size_t N, std::size_t TM, std::size_t TN>

constexpr auto tatooine::operator* ( polymorphic::matrixfield< Real0, N, TM, TN > const &  lhs, polymorphic::vectorfield< Real1, N, TN > const &  rhs  )

constexpr

operator*() [16/17]

template<typename TensorA , std::size_t M, std::size_t N>
requires (std::decay_t<decltype(B)>::dimension(1) == M)

constexpr auto tatooine::operator* ( static_tensor auto const &  B, diag_static_tensor< TensorA, M, N > const &  A  )

constexpr

operator*() [17/17]

auto constexpr tatooine::operator* ( static_tensor auto const &  t, arithmetic_or_complex auto const  scalar  )

constexpr

operator+() [1/7]

template<floating_point_range... Dimensions, floating_point_range AdditionalDimension>

auto tatooine::operator+	(	AdditionalDimension &&	additional_dimension,
		rectilinear_grid< Dimensions... > const &	rectilinear_grid
	)

operator+() [2/7]

template<typename V0 , typename Real0 , typename V1 , typename Real1 , std::size_t N, typename Tensor >

constexpr auto tatooine::operator+ ( const field< V0, Real0, N, Tensor > &  lhs, const field< V1, Real1, N, Tensor > &  rhs  )

constexpr

operator+() [3/7]

template<typename Child , unsigned_integral Int>

auto tatooine::operator+	(	handle< Child, Int > const	h,
		integral auto const	i
	)

operator+() [4/7]

template<typename Child , unsigned_integral Int>

auto tatooine::operator+	(	integral auto const	i,
		handle< Child, Int > const	h
	)

operator+() [5/7]

template<static_tensor Lhs, static_tensor Rhs>
requires (same_dimensions<Lhs, Rhs>())

auto constexpr tatooine::operator+ ( Lhs const &  lhs, Rhs const &  rhs  )

constexpr

component-wise addition

operator+() [6/7]

template<floating_point_range... Dimensions, floating_point_range AdditionalDimension>

auto tatooine::operator+	(	rectilinear_grid< Dimensions... > const &	rectilinear_grid,
		AdditionalDimension &&	additional_dimension
	)

operator+() [7/7]

auto constexpr tatooine::operator+ ( static_tensor auto const &  lhs, arithmetic_or_complex auto const  scalar  )

constexpr

operator-() [1/4]

template<typename Child , unsigned_integral Int>

auto tatooine::operator-	(	handle< Child, Int > const	h,
		integral auto const	i
	)

operator-() [2/4]

template<typename Child , unsigned_integral Int>

auto tatooine::operator-	(	integral auto const	i,
		handle< Child, Int > const	h
	)

operator-() [3/4]

template<static_tensor Lhs, static_tensor Rhs>
requires (same_dimensions<Lhs, Rhs>())

auto constexpr tatooine::operator- ( Lhs const &  lhs, Rhs const &  rhs  )

constexpr

component-wise subtraction

operator-() [4/4]

auto constexpr tatooine::operator- ( static_tensor auto const &  t )

constexpr

operator/() [1/7]

auto constexpr tatooine::operator/ ( arithmetic_or_complex auto const  scalar, static_tensor auto const &  t  )

constexpr

operator/() [2/7]

template<typename V , typename VReal , std::size_t N, arithmetic_or_complex ScalarReal, typename Tensor >

constexpr auto tatooine::operator/ ( field< V, VReal, N, Tensor > const &  f, ScalarReal const  scalar  )

constexpr

operator/() [3/7]

template<typename Child , unsigned_integral Int>

auto tatooine::operator/	(	handle< Child, Int > const	h,
		integral auto const	i
	)

operator/() [4/7]

template<typename Child , unsigned_integral Int>

auto tatooine::operator/	(	integral auto const	i,
		handle< Child, Int > const	h
	)

operator/() [5/7]

template<static_tensor Lhs, static_tensor Rhs>
requires (same_dimensions<Lhs, Rhs>())

auto constexpr tatooine::operator/ ( Lhs const &  lhs, Rhs const &  rhs  )

constexpr

component-wise division

operator/() [6/7]

template<typename V , typename VReal , std::size_t N, arithmetic_or_complex ScalarReal, typename Tensor >

constexpr auto tatooine::operator/ ( ScalarReal const  scalar, field< V, VReal, N, Tensor > const &  f  )

constexpr

operator/() [7/7]

auto constexpr tatooine::operator/ ( static_tensor auto const &  t, arithmetic_or_complex auto const  scalar  )

constexpr

operator<<() [1/10]

template<typename Real , std::size_t NumDimensions>

auto tatooine::operator<<	(	std::ostream &	out,
		axis_aligned_bounding_box< Real, NumDimensions > const &	bb
	)		-> std::ostream&

operator<<() [2/10]

template<typename Tensor , typename T , size_t M, size_t N>

auto tatooine::operator<<	(	std::ostream &	out,
		const base_tensor< Tensor, T, M, N > &	m
	)		-> auto&

operator<<() [3/10]

template<typename Tensor , typename T , size_t N>

auto tatooine::operator<<	(	std::ostream &	out,
		const base_tensor< Tensor, T, N > &	v
	)		-> auto&

printing vector

operator<<() [4/10]

template<typename Real , size_t N>

auto tatooine::operator<< ( std::ostream &  out, const grid_edge< Real, N > &  e  ) -> auto&

inline

operator<<() [5/10]

template<typename Real , std::size_t N, std::size_t Degree>

auto tatooine::operator<<	(	std::ostream &	out,
		const polynomial_line< Real, N, Degree > &	line
	)		-> std::ostream&

operator<<() [6/10]

auto tatooine::operator<<	(	std::ostream &	out,
		dynamic_tensor auto const &	t
	)		-> auto&

printing dynamic tensors

operator<<() [7/10]

template<floating_point Real>

auto tatooine::operator<<	(	std::ostream &	out,
		linspace< Real > const &	l
	)		-> auto&

operator<<() [8/10]

template<typename Real , std::size_t Degree>

auto & tatooine::operator<<	(	std::ostream &	out,
		polynomial< Real, Degree > const &	f
	)

operator<<() [9/10]

template<typename... Dimensions>

auto tatooine::operator<<	(	std::ostream &	out,
		rectilinear_grid< Dimensions... > const &	g
	)		-> auto &

operator<<() [10/10]

template<typename Child , unsigned_integral Int>

auto tatooine::operator<<	(	std::ostream &	stream,
		handle< Child, Int > const	h
	)		-> auto&

operator==() [1/5]

auto constexpr tatooine::operator== ( backward_tag const  , backward_tag const    )

constexpr

operator==() [2/5]

auto constexpr tatooine::operator== ( backward_tag const  , forward_tag const    )

constexpr

operator==() [3/5]

auto constexpr tatooine::operator== ( forward_tag const  , backward_tag const    )

constexpr

operator==() [4/5]

auto constexpr tatooine::operator== ( forward_tag const  , forward_tag const    )

constexpr

operator==() [5/5]

template<static_tensor Lhs, static_tensor Rhs>
requires (same_dimensions<Lhs, Rhs>())

auto constexpr tatooine::operator== ( Lhs const &  lhs, Rhs const &  rhs  )

constexpr

operator|() [1/2]

template<typename Field , typename Op >
requires (is_field<Field>) && (invocable<Op, field_tensor_type<Field>>)

constexpr auto tatooine::operator| ( Field &&  field, Op &&  op  )

constexpr

operator|() [2/2]

template<typename Real , size_t N, typename Tensor , typename Op >
requires (invocable<Op, Tensor>)

constexpr auto tatooine::operator| ( polymorphic::field< Real, N, Tensor > *  field, Op &&  op  )

constexpr

opposite() [1/2]

constexpr auto tatooine::opposite ( backward_tag const  )

constexpr

opposite() [2/2]

constexpr auto tatooine::opposite ( forward_tag const  )

constexpr

parse()

template<typename Real >

auto tatooine::parse

(

std::string const &

)

-> Real

partition_resolution()

template<size_t N>

auto tatooine::partition_resolution	(	const std::array< size_t, N > &	resolution,
		const std::array< size_t, N > &	max_chunk_resolution
	)

partitions a resolution into chunked resolutions. borders of the partions are redundant.

polynomial() [1/2]

template<typename... Coeffs>

tatooine::polynomial

(

Coeffs...

coeffs

)

-> polynomial< common_type< Coeffs... >, sizeof...(Coeffs) - 1 >

polynomial() [2/2]

template<typename Real , std::size_t N>

tatooine::polynomial

(

tensor< Real, N > const &

)

-> polynomial< Real, N - 1 >

polynomial_line()

template<typename... Polynomials>

tatooine::polynomial_line

(

Polynomials &&

...

)

-> polynomial_line< common_type< typename Polynomials::real_type... >, sizeof...(Polynomials), max(Polynomials::degree()...)>

pow() [1/2]

constexpr auto tatooine::pow ( arithmetic auto const  x )

constexpr

pow() [2/2]

template<std::integral Int>

constexpr auto tatooine::pow ( Int  x, std::unsigned_integral auto const  p  ) -> Int

constexpr

prev() [1/2]

template<derived_from_iterator_facade Iter>
requires implements_decrement<Iter>

auto tatooine::prev

(

Iter

iter

)

prev() [2/2]

template<derived_from_iterator_facade Iter>
requires implements_decrement<Iter>

auto tatooine::prev	(	Iter	iter,
		difference_type_arg< Iter > auto	off
	)

progress_bar()

template<typename F , typename... Args>
requires std::invocable< F, progress_indicator_wrapper<indicators::BlockProgressBar>, Args...>

auto tatooine::progress_bar	(	F &&	f,
		Args &&...	args
	)		-> decltype(auto)

Q() [1/2]

template<typename V >
requires is_vectorfield<std::decay_t<std::remove_pointer_t<V>>>

auto tatooine::Q

(

V &&

v

)

Q() [2/2]

template<typename V >
requires is_vectorfield< std::decay_t<std::remove_pointer_t<V>>>

auto tatooine::Q

(

V const &

v

)

rank() [1/3]

template<arithmetic_or_complex Scalar>

constexpr auto tatooine::rank ( )

constexpr

rank() [2/3]

template<arithmetic_or_complex Scalar>

constexpr auto tatooine::rank ( Scalar &&  )

constexpr

rank() [3/3]

template<static_tensor Tensor>

constexpr auto tatooine::rank ( Tensor &&  t )

constexpr

read_lines()

template<floating_point Real = real_number>

auto tatooine::read_lines

(

filesystem::path const &

filepath

)

real() [1/2]

template<typename Tensor , typename T , size_t... Dims>

auto tatooine::real

(

base_tensor< Tensor, std::complex< T >, Dims... > &

t

)

real() [2/2]

template<typename Tensor , typename T , size_t... Dims>

auto tatooine::real

(

base_tensor< Tensor, std::complex< T >, Dims... > const &

t

)

rectilinear_grid() [1/3]

template<typename Real , std::size_t N>

tatooine::rectilinear_grid	(	axis_aligned_bounding_box< Real, N > const &	bb,
		integral auto const ...	res
	)		-> rectilinear_grid< linspace< std::conditional_t< true, Real, decltype(res)> >... >

rectilinear_grid() [2/3]

template<floating_point_range... Dimensions>

tatooine::rectilinear_grid

(

Dimensions &&

...

)

-> rectilinear_grid< std::decay_t< Dimensions >... >

rectilinear_grid() [3/3]

template<integral... Ints>

tatooine::rectilinear_grid

(

Ints const ...

res

)

-> rectilinear_grid< linspace< std::conditional_t< true, double, decltype(res)> >... >

reflect()

template<typename T0 , typename T1 >

constexpr auto tatooine::reflect ( vec< T0, 3 > const &  incidentVec, vec< T1, 3 > const &  normal  )

constexpr

release_mode()

constexpr auto tatooine::release_mode ( )

inlineconstexpr

render_topological_skeleton()

template<typename Real , typename Integrator , template< typename > typename Interpolator>

auto tatooine::render_topological_skeleton	(	const sampled_field< grid_sampler< Real, 2, vec< Real, 2 >, interpolation::linear, interpolation::linear >, Real, 2, 2 > &	v,
		const integration::integrator< Real, 2, Interpolator, Integrator > &	integrator,
		const vec< size_t, 2 > &	resolution,
		const Real	tau = 100,
		const Real	eps = 1e-7
	)

you need a gl::context for this

reorder()

auto tatooine::reorder	(	std::ranges::range auto &	data,
		std::ranges::range auto &	order
	)		-> void

reorders a range data with another range order

repeat()

template<typename F , typename... Args>

auto tatooine::repeat	(	size_t const	n,
		F &&	f,
		Args &&...	args
	)

resize_next_list()

template<typename Range , typename RangeIt >

decltype(auto) tatooine::resize_next_list	(	Range &	range,
		RangeIt	pos,
		std::size_t	new_next_size
	)

resize_prev_list()

template<typename Range , typename RangeIt >

decltype(auto) tatooine::resize_prev_list	(	Range &	range,
		RangeIt	pos,
		std::size_t	new_prev_size
	)

ridgelines() [1/4]

template<typename Grid , arithmetic T, bool HasNonConstReference>
requires (Grid::num_dimensions() == 2)

auto tatooine::ridgelines

(

detail::rectilinear_grid::typed_vertex_property_interface< Grid, T, HasNonConstReference > const &

data

)

Implementation of [6] without filters.

ridgelines() [2/4]

template<typename Grid , arithmetic T, bool HasNonConstReference, typename DomainX , typename DomainY >
requires (Grid::num_dimensions() == 2)

auto tatooine::ridgelines	(	detail::rectilinear_grid::typed_vertex_property_interface< Grid, T, HasNonConstReference > const &	data,
		execution_policy_tag auto const	exec
	)

Implementation of [6] without filters.

ridgelines() [3/4]

template<typename Grid , arithmetic T, bool HasNonConstReference, typename DomainX , typename DomainY >
requires (Grid::num_dimensions() == 2)

auto tatooine::ridgelines	(	detail::rectilinear_grid::typed_vertex_property_interface< Grid, T, HasNonConstReference > const &	data,
		rectilinear_grid< DomainX, DomainY > &	working_grid
	)

Implementation of [6] without filters.

working_grid needs to have the same dimensions as data.grid()

ridgelines() [4/4]

template<typename Grid , arithmetic T, bool HasNonConstReference, typename DomainX , typename DomainY >
requires (Grid::num_dimensions() == 2)

auto tatooine::ridgelines	(	detail::rectilinear_grid::typed_vertex_property_interface< Grid, T, HasNonConstReference > const &	data,
		rectilinear_grid< DomainX, DomainY > &	working_grid,
		execution_policy_tag auto const	exec
	)

Implementation of [6] without filters.

working_grid needs to have the same dimensions as data.grid()

same_dimensions() [1/2]

template<static_tensor A, static_tensor B>

auto constexpr tatooine::same_dimensions ( )

constexpr

same_dimensions() [2/2]

auto constexpr tatooine::same_dimensions ( static_tensor auto const &  A, static_tensor auto const &  B  )

constexpr

sample_to_raw() [1/2]

template<typename V , arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions, arithmetic T>

auto tatooine::sample_to_raw	(	field< V, VReal, NumDimensions, Tensor > const &	f,
		rectilinear_grid< SpatialDimensions... > const &	discretized_domain,
		T const	t,
		std::size_t	padding = 0,
		VReal	padval = 0
	)

sample_to_raw() [2/2]

template<typename V , arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions, floating_point_range TemporalDimension>

auto tatooine::sample_to_raw	(	field< V, VReal, NumDimensions, Tensor > const &	f,
		rectilinear_grid< SpatialDimensions... > const &	discretized_domain,
		TemporalDimension const &	temporal_domain,
		std::size_t	padding = 0,
		VReal	padval = 0
	)

sample_to_vector()

template<arithmetic VReal, std::size_t NumDimensions, typename Tensor , floating_point_range... SpatialDimensions>

auto tatooine::sample_to_vector	(	polymorphic::field< VReal, NumDimensions, Tensor > const &	f,
		rectilinear_grid< SpatialDimensions... > const &	discretized_domain,
		arithmetic auto const	t
	)

simulated_annealing()

template<template< typename > typename Comparator = std::less, typename InitialStatus , typename EnergyFunction , typename TemperaturFunction , typename NeighborFunction , typename RandomEngine >

auto tatooine::simulated_annealing	(	InitialStatus &&	initial_status,
		size_t const	num_iterations,
		EnergyFunction &&	energy_fun,
		TemperaturFunction &&	temperature_fun,
		NeighborFunction &&	neighbor_fun,
		RandomEngine &&	random_engine,
		std::vector< simulated_annealing_listener< std::decay_t< decltype(energy_fun(std::declval< InitialStatus >()))>, std::decay_t< InitialStatus > > *	,
		const &	listeners = {}
	)

sin()

constexpr auto tatooine::sin ( arithmetic auto const  x )

constexpr

singular_values() [1/2]

template<typename Tensor , typename T , size_t M, size_t N>

constexpr auto tatooine::singular_values ( base_tensor< Tensor, T, M, N > const &  A_base )

constexpr

singular_values() [2/2]

template<typename T , size_t M, size_t N>

constexpr auto tatooine::singular_values ( tensor< T, M, N > &&  A )

constexpr

singular_values22()

template<typename Tensor , typename T >

constexpr auto tatooine::singular_values22 ( base_tensor< Tensor, T, 2, 2 > const &  A )

constexpr

size()

template<typename ValueType , std::size_t N>

auto tatooine::size

(

vec< ValueType, N > const &

v

)

sliced_indices() [1/2]

template<size_t N, size_t Omit>

constexpr auto tatooine::sliced_indices ( )

constexpr

creates an index sequence and removes an element from it

sliced_indices() [2/2]

template<size_t Omit, size_t... Is, size_t... Js>

constexpr auto tatooine::sliced_indices ( std::index_sequence< Is... >  , std::index_sequence< Js... >    )

constexpr

creates an index_sequence and removes an element from it

solve() [1/9]

template<typename TensorA , static_vec TensorB, std::size_t N>
requires (tensor_dimensions<TensorB>[0] == N)

constexpr auto tatooine::solve ( diag_static_tensor< TensorA, N, N > &&  A, TensorB &&  b  ) -> std::optional< vec<common_type<tatooine::value_type<TensorA>, tatooine::value_type<TensorB>>, N>>

constexpr

solve() [2/9]

template<typename TensorA , static_vec TensorB, std::size_t N>
requires (tensor_dimensions<TensorB>[0] == N)

constexpr auto tatooine::solve ( diag_static_tensor< TensorA, N, N > const &  A, TensorB &&  b  ) -> std::optional< vec<common_type<tatooine::value_type<TensorA>, tatooine::value_type<TensorB>>, N>>

constexpr

solve() [3/9]

template<static_mat MatA, static_mat MatB>
requires (tensor_dimension<MatA, 0> == tensor_dimension<MatB, 0>)

auto tatooine::solve	(	MatA &&	A,
		MatB &&	B
	)

solve() [4/9]

template<static_mat MatA, static_vec VecB>
requires (tensor_dimension<MatA, 0> == tensor_dimension<VecB, 0>)

auto tatooine::solve	(	MatA &&	A,
		VecB &&	b
	)

solve() [5/9]

template<typename Real >

auto tatooine::solve

(

polynomial< Real, 1 > const &

p

)

-> std::vector<Real>

solve a + b*x

solve() [6/9]

template<typename Real >

auto tatooine::solve

(

polynomial< Real, 2 > const &

p

)

-> std::vector<Real>

solve a + b*x + c*x^2

solve() [7/9]

template<typename Real >

auto tatooine::solve

(

polynomial< Real, 3 > const &

f

)

Solves cubic polynomial. Code from here: https://github.com/erich666/GraphicsGems/blob/master/gems/Roots3And4.c

solve() [8/9]

template<typename Real >

auto tatooine::solve

(

polynomial< Real, 4 > const &

f

)

-> std::vector<Real>

Solves quartic polynomial. Code from here: https://github.com/erich666/GraphicsGems/blob/master/gems/Roots3And4.c

solve() [9/9]

template<dynamic_tensor TensorA, dynamic_tensor TensorB>

auto tatooine::solve	(	TensorA &&	A,
		TensorB &&	B
	)		-> std::optional<tensor< common_type<tatooine::value_type<TensorB>, tatooine::value_type<TensorB>>>>

solve_blockwise()

template<typename T >

bool tatooine::solve_blockwise	(	int	_n,
		const T *	_d,
		const T *	_du,
		T *	_b
	)

This function solves your problem A*x=b blockwise w/o LAPACK. Assume quadratic matrix A=[A11,A12;ONES,1] with bidiagonal matrix A11=A(1:end-1,,1:end-1) and A12=[0,...0,a12]

Parameters

	_n	dimension of matrix A
	_d	main diagonal of A11 (_n-1 entries)
	_du	superdiagonal of A11 (first _n-2 entries) and a12 as (at index _n-1)
[in,out]	_b	right hand side on input, solution x on output

Note: calls alloca!

solve_cramer()

template<static_quadratic_mat MatA, static_vec VecB>
requires (tensor_dimension<MatA, 0> == tensor_dimension<VecB, 0>)

auto tatooine::solve_cramer	(	MatA const &	A,
		VecB const &	b
	)		-> std::optional< vec<common_type<tatooine::value_type<MatA>, tatooine::value_type<VecB>>, tensor_dimension<MatA, 1>>>

solve_direct() [1/2]

template<fixed_size_quadratic_mat< 2 > MatA, static_mat MatB>
requires (tensor_dimension<MatB, 0> == 2)

auto constexpr tatooine::solve_direct ( MatA &&  A, MatB &&  B  )

constexpr

solve_direct() [2/2]

template<fixed_size_mat< 2, 2 > MatA, fixed_size_vec< 2 > VecB>

auto tatooine::solve_direct	(	MatA &&	A,
		VecB &&	b
	)		-> std::optional< vec<common_type<tatooine::value_type<MatA>, tatooine::value_type<VecB>>, 2>>

solve_lu_lapack() [1/3]

template<static_quadratic_mat MatA, static_mat MatB>
requires (tensor_dimension<MatA, 0> == tensor_dimension<MatB, 0>)

auto tatooine::solve_lu_lapack	(	MatA &	A_,
		MatB &	B_
	)

solve_lu_lapack() [2/3]

template<static_quadratic_mat MatA, static_vec VecB>
requires (tensor_dimension<MatA, 1> == tensor_dimension<VecB, 0>)

auto tatooine::solve_lu_lapack	(	MatA &	A_,
		VecB &&	b_
	)		-> std::optional< tensor<common_type<tatooine::value_type<MatA>, tatooine::value_type<VecB>>>>

solve_lu_lapack() [3/3]

template<dynamic_tensor TensorA, dynamic_tensor TensorB>

auto tatooine::solve_lu_lapack	(	TensorA &&	A_,
		TensorB &&	B_
	)		-> std::optional<tensor< common_type<tatooine::value_type<TensorA>, tatooine::value_type<TensorB>>>>

solve_qr()

template<typename T >

bool tatooine::solve_qr	(	int	_n,
		T *	_d,
		T *	_du,
		T *	_b,
		T *	_null
	)

Get least-norm solution xln and _null space by QR factorization.

• Input is the bidiagonal _n x (_n+_1) matrix A with diagonal _d and superdiagonal _du.
• We use the factorization A'=Q*R.
• Output is the least-norm xln solution to A*x=b in _b, the vector _null spanning the kernel of A, and the factor R in _d (diagonal) and _du (superdiagonal).

Parameters

	_n	number of rows in A
[in,out]	_d	on input _d diagonal of A (_n elements), on output diagonal of R
[in,out]	_du	on input _du superdiagonal of A (_n elements, because A is _n x (_n+1), on output superdiagonal of R
[in,out]	_b	on input right hand side vector of length _n, on output least-norm solution xln of size _n+1 (reserve _n+1 entries)
[out]	_null	(_n+1)-vector spanning nullspace of A

Returns

true on success, false if rank(A)<n

solve_qr_lapack() [1/3]

template<static_mat MatA, static_mat MatB>
requires (tensor_dimension<MatA, 0> == tensor_dimension<MatB, 0>)

auto tatooine::solve_qr_lapack	(	MatA &&	A_,
		MatB &&	B_
	)

solve_qr_lapack() [2/3]

template<static_mat MatA, static_vec VecB>
requires (tensor_dimension<MatA, 0> == tensor_dimension<VecB, 0>)

auto tatooine::solve_qr_lapack	(	MatA &&	A_,
		VecB &&	b_
	)

solve_qr_lapack() [3/3]

template<dynamic_tensor TensorA, dynamic_tensor TensorB>

auto tatooine::solve_qr_lapack	(	TensorA &&	A_,
		TensorB &&	B_
	)		-> std::optional<tensor< common_type<tatooine::value_type<TensorA>, tatooine::value_type<TensorB>>>>

solve_symmetric()

auto tatooine::solve_symmetric	(	dynamic_tensor auto &&	A,
		dynamic_tensor auto &&	B
	)

Computes the solution to a system of linear equations (A X = B), where A is an n-by-n symmetric matrix and X and B are n-by-nrhs matrices.

Aasen's algorithm is used to factor A as (A = U T U^T) if uplo = upper, or (A = L T L^T) if uplo = lower, where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and T is symmetric tridiagonal. The factored form of A is then used to solve the system of equations (A X = B). Computes the solution to a system of linear equations.

[ A X = B, ]

where A is an n-by-n symmetric matrix and X and B are n-by-nrhs matrices.

The bounded Bunch-Kaufman (rook) diagonal pivoting method is used to factor A as (A = P U D U^T P^T) if uplo = upper, or (A = P L D L^T P^T) if uplo = lower, where U (or L) is unit upper (or lower) triangular matrix, (U^T) (or (L^T)) is the transpose of U (or L), P is a permutation matrix, (P^T) is the transpose of P, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.

lapack::sytrf_rk is called to compute the factorization of a symmetric matrix. The factored form of A is then used to solve the system of equations (A X = B) by calling lapack::sytrs_rk.

solve_symmetric_lapack()

template<dynamic_tensor TensorA, dynamic_tensor TensorB>

auto tatooine::solve_symmetric_lapack	(	TensorA &&	A_,
		TensorB &&	B_,
		lapack::uplo	uplo = lapack::uplo::lower
	)		-> std::optional<tensor<common_type<tatooine::value_type<decltype(A_)>, tatooine::value_type<decltype(B_)>>>>

Computes the solution to a system of linear equations (A X = B), where A is an n-by-n symmetric matrix and X and B are n-by-nrhs matrices.

The diagonal pivoting method is used to factor A as (A = U D U^T) if uplo = upper, or (A = L D L^T) if uplo = lower, where U (or L) is a product of permutation and unit upper (lower) triangular matrices, and D is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks. The factored form of A is then used to solve the system of equations (A X = B).

spacetime() [1/3]

template<typename V , typename Real , std::size_t N>

auto tatooine::spacetime

(

polymorphic::vectorfield< Real, N > const &

vf

)

spacetime() [2/3]

template<typename V , typename Real , std::size_t N>

auto tatooine::spacetime

(

polymorphic::vectorfield< Real, N > const *

vf

)

spacetime() [3/3]

template<typename V , typename Real , std::size_t N>

auto tatooine::spacetime

(

vectorfield< V, Real, N > const &

vf

)

spacetime_splitted_vectorfield() [1/5]

template<typename V >

tatooine::spacetime_splitted_vectorfield

(

V &&

v

)

-> spacetime_splitted_vectorfield< V && >

spacetime_splitted_vectorfield() [2/5]

template<typename V >

tatooine::spacetime_splitted_vectorfield

(

V &

v

)

-> spacetime_splitted_vectorfield< V & >

spacetime_splitted_vectorfield() [3/5]

template<typename V >

tatooine::spacetime_splitted_vectorfield

(

V *

v

)

-> spacetime_splitted_vectorfield< V * >

spacetime_splitted_vectorfield() [4/5]

template<typename V >

tatooine::spacetime_splitted_vectorfield

(

V const &

v

)

-> spacetime_splitted_vectorfield< V const & >

spacetime_splitted_vectorfield() [5/5]

template<typename V >

tatooine::spacetime_splitted_vectorfield

(

V const *

v

)

-> spacetime_splitted_vectorfield< V const * >

spacetime_vectorfield() [1/3]

template<typename Real , std::size_t N>

tatooine::spacetime_vectorfield

(

polymorphic::vectorfield< Real, N > const *

)

-> spacetime_vectorfield< polymorphic::vectorfield< Real, N > const * >

spacetime_vectorfield() [2/3]

template<typename Real , std::size_t N>

tatooine::spacetime_vectorfield

(

symbolic::field< Real, N > const &

)

-> spacetime_vectorfield< symbolic::field< Real, N > >

spacetime_vectorfield() [3/3]

template<typename V , typename Real , std::size_t N>

tatooine::spacetime_vectorfield

(

vectorfield< V, Real, N > const &

)

-> spacetime_vectorfield< V >

split_spacetime() [1/5]

template<typename VReal , std::size_t N, std::size_t NV>

auto tatooine::split_spacetime

(

polymorphic::vectorfield< VReal, N, NV > *

v

)

split_spacetime() [2/5]

template<typename VReal , std::size_t N, std::size_t NV>

auto tatooine::split_spacetime

(

polymorphic::vectorfield< VReal, N, NV > const *

v

)

split_spacetime() [3/5]

template<typename V , typename VReal , std::size_t N, std::size_t NV>

auto tatooine::split_spacetime

(

vectorfield< V, VReal, N, NV > &&

v

)

split_spacetime() [4/5]

template<typename V , typename VReal , std::size_t N, std::size_t NV>

auto tatooine::split_spacetime

(

vectorfield< V, VReal, N, NV > &

v

)

split_spacetime() [5/5]

template<typename V , typename VReal , std::size_t N, std::size_t NV>

auto tatooine::split_spacetime

(

vectorfield< V, VReal, N, NV > const &

v

)

sqrt() [1/3]

constexpr auto tatooine::sqrt ( arithmetic auto const  x )

constexpr

sqrt() [2/3]

template<typename Tensor , typename TensorT , std::size_t... Dims>

constexpr auto tatooine::sqrt ( base_tensor< Tensor, TensorT, Dims... > const &  t )

constexpr

sqrt() [3/3]

constexpr auto tatooine::sqrt ( dynamic_tensor auto &&  t )

constexpr

squared_euclidean_distance()

template<typename Tensor0 , typename T0 , typename Tensor1 , typename T1 , std::size_t N>

constexpr auto tatooine::squared_euclidean_distance ( base_tensor< Tensor0, T0, N > const &  lhs, base_tensor< Tensor1, T1, N > const &  rhs  )

constexpr

squared_euclidean_length() [1/3]

template<typename Tensor , typename T , size_t N>

constexpr auto tatooine::squared_euclidean_length ( base_tensor< Tensor, T, N > const &  t_in )

constexpr

squared_euclidean_length() [2/3]

template<typename V , typename VReal , std::size_t N>

constexpr auto tatooine::squared_euclidean_length ( vectorfield< V, VReal, N > &&  v )

constexpr

squared_euclidean_length() [3/3]

template<typename V , typename VReal , std::size_t N>

constexpr auto tatooine::squared_euclidean_length ( vectorfield< V, VReal, N > const &  v )

constexpr

squared_norm() [1/3]

template<typename Tensor , typename T , std::size_t M, std::size_t N>

constexpr auto tatooine::squared_norm ( base_tensor< Tensor, T, M, N > const &  A, unsigned int const  p  )

constexpr

squared p-norm of a rank-2 tensor

squared_norm() [2/3]

template<typename Tensor , typename T , std::size_t M, std::size_t N>

constexpr auto tatooine::squared_norm ( base_tensor< Tensor, T, M, N > const &  mat )

constexpr

squared Frobenius norm of a rank-2 tensor

squared_norm() [3/3]

template<typename Tensor , typename T , std::size_t M, std::size_t N>

constexpr auto tatooine::squared_norm ( base_tensor< Tensor, T, M, N > const &  mat, tag::frobenius_t    )

constexpr

squared Frobenius norm of a rank-2 tensor

steady() [1/2]

template<typename F , typename T >

auto tatooine::steady	(	F &&	f,
		T const	t
	)

steady() [2/2]

template<typename F , typename T >

auto tatooine::steady	(	F const &	f,
		T const	t
	)

streamsurface() [1/6]

template<typename Flowmap >

tatooine::streamsurface	(	Flowmap &&	,
		arithmetic auto	t0,
		line< typename Flowmap::real_type, Flowmap::num_dimensions()> const &	seedcurve
	)		-> streamsurface< std::decay_t< Flowmap >, interpolation::linear >

streamsurface() [2/6]

template<typename Flowmap >

tatooine::streamsurface	(	Flowmap &&	,
		arithmetic auto	u0t0,
		arithmetic auto	u1t0,
		line< typename Flowmap::real_type, Flowmap::num_dimensions()> const &	seedcurve
	)		-> streamsurface< std::decay_t< Flowmap >, interpolation::linear >

streamsurface() [3/6]

template<typename Flowmap >

tatooine::streamsurface	(	Flowmap &&	,
		line< typename Flowmap::real_type, Flowmap::num_dimensions()> const &
	)		-> streamsurface< std::decay_t< Flowmap >, interpolation::linear >

streamsurface() [4/6]

template<typename Flowmap >

tatooine::streamsurface	(	Flowmap const &	,
		arithmetic auto	t0,
		line< typename Flowmap::real_type, Flowmap::num_dimensions()> const &	seedcurve
	)		-> streamsurface< Flowmap const &, interpolation::linear >

streamsurface() [5/6]

template<typename Flowmap >

tatooine::streamsurface	(	Flowmap const &	,
		arithmetic auto	u0t0,
		arithmetic auto	u1t0,
		line< typename Flowmap::real_type, Flowmap::num_dimensions()> const &	seedcurve
	)		-> streamsurface< Flowmap const &, interpolation::linear >

streamsurface() [6/6]

template<typename Flowmap >

tatooine::streamsurface	(	Flowmap const &	,
		line< typename Flowmap::real_type, Flowmap::num_dimensions()> const &
	)		-> streamsurface< Flowmap const &, interpolation::linear >

sum()

template<typename Tensor , typename T , std::size_t VecDim>

constexpr auto tatooine::sum ( base_tensor< Tensor, T, VecDim > const &  v )

constexpr

sum of all components of a vector

svd() [1/3]

template<typename Tensor , typename T , size_t M, size_t N>

auto tatooine::svd

(

base_tensor< Tensor, T, M, N > const &

A

)

svd() [2/3]

template<typename Tensor , typename T , size_t M, size_t N>

auto tatooine::svd	(	base_tensor< Tensor, T, M, N > const &	A_base,
		tag::economy_t	[> tag<]
	)

svd() [3/3]

template<typename Tensor , typename T , size_t M, size_t N>

auto tatooine::svd	(	base_tensor< Tensor, T, M, N > const &	A_base,
		tag::full_t	[> tag<]
	)

svd_left() [1/3]

template<typename Tensor , typename T , size_t M, size_t N>

auto tatooine::svd_left

(

base_tensor< Tensor, T, M, N > const &

A

)

svd_left() [2/3]

template<typename Tensor , typename T , size_t M, size_t N>

auto tatooine::svd_left	(	base_tensor< Tensor, T, M, N > const &	A_base,
		tag::economy_t	[> tag<]
	)

svd_left() [3/3]

template<typename Tensor , typename T , size_t M, size_t N>

auto tatooine::svd_left	(	base_tensor< Tensor, T, M, N > const &	A_base,
		tag::full_t	[> tag<]
	)

svd_right() [1/3]

template<typename Tensor , typename T , size_t M, size_t N>

auto tatooine::svd_right

(

base_tensor< Tensor, T, M, N > const &

A

)

svd_right() [2/3]

template<typename Tensor , typename T , size_t M, size_t N>

auto tatooine::svd_right	(	base_tensor< Tensor, T, M, N > const &	A_base,
		tag::economy_t	[> tag<]
	)

svd_right() [3/3]

template<typename Tensor , typename T , size_t M, size_t N>

auto tatooine::svd_right	(	base_tensor< Tensor, T, M, N > const &	A_base,
		tag::full_t	[> tag<]
	)

swap_endianess() [1/3]

template<typename Data >

constexpr void tatooine::swap_endianess ( Data *  data, size_t  n  )

constexpr

swap_endianess() [2/3]

template<typename Data >

constexpr Data tatooine::swap_endianess ( Data  data )

constexpr

swap_endianess() [3/3]

template<typename Data >

void tatooine::swap_endianess

(

std::vector< Data > &

data

)

tat_swap()

template<typename T >

constexpr void tatooine::tat_swap ( T &  t0, T &  t1  )

constexpr

tensor() [1/3]

template<typename... Rows, std::size_t N>

tatooine::tensor

(

Rows(&&... rows)

[N]

)

-> tensor< common_type< Rows... > >

tensor() [2/3]

template<dynamic_tensor Tensor>

tatooine::tensor

(

Tensor &&

)

-> tensor< value_type< Tensor > >

tensor() [3/3]

template<typename... Ts>

tatooine::tensor

(

Ts...

)

-> tensor< common_type< Ts... > >

to_ginac_matrix()

template<typename Tensor , size_t M, size_t N>

auto tatooine::to_ginac_matrix

(

const base_tensor< Tensor, GiNaC::ex, M, N > &

m_in

)

to_mat()

template<size_t M, size_t N>

auto tatooine::to_mat

(

const GiNaC::matrix &

m_in

)

total_memory()

size_t tatooine::total_memory ( )

inline

Total amount of RAM in kB.

trace()

template<typename Tensor , typename T , std::size_t N>

constexpr auto tatooine::trace ( base_tensor< Tensor, T, N, N > const &  A )

constexpr

trace_flow()

template<typename V , typename Real , std::size_t N, typename T0Real , typename TauReal >

auto tatooine::trace_flow	(	vectorfield< V, Real, N > const &	v,
		vec< Real, N > const &	x0,
		T0Real const	t0,
		TauReal const	tau
	)

transposed() [1/3]

auto tatooine::transposed

(

dynamic_tensor auto &&

t

)

transposed() [2/3]

template<static_tensor T>
requires (!transposed_tensor<T>)

auto constexpr tatooine::transposed ( T &&  t )

constexpr

transposed() [3/3]

auto constexpr tatooine::transposed ( transposed_tensor auto &&  t ) -> decltype(auto)

constexpr

transposed_dynamic_tensor() [1/3]

template<dynamic_tensor T>

tatooine::transposed_dynamic_tensor

(

T &&

)

-> transposed_dynamic_tensor< std::decay_t< T > >

transposed_dynamic_tensor() [2/3]

template<dynamic_tensor T>

tatooine::transposed_dynamic_tensor

(

T &

)

-> transposed_dynamic_tensor< T & >

transposed_dynamic_tensor() [3/3]

template<dynamic_tensor T>

tatooine::transposed_dynamic_tensor

(

T const &

)

-> transposed_dynamic_tensor< T const & >

transposed_static_tensor() [1/3]

template<static_tensor T>

tatooine::transposed_static_tensor

(

T &&

)

-> transposed_static_tensor< std::decay_t< T > >

transposed_static_tensor() [2/3]

template<static_tensor T>

tatooine::transposed_static_tensor

(

T &

)

-> transposed_static_tensor< T & >

transposed_static_tensor() [3/3]

template<static_tensor T>

tatooine::transposed_static_tensor

(

T const &

)

-> transposed_static_tensor< T const & >

tuple() [1/2]

template<typename Head >

tatooine::tuple

(

Head &&

)

-> tuple< std::decay_t< Head > >

tuple() [2/2]

template<typename Head , typename... Tail>

tatooine::tuple	(	Head &&	,
		Tail &&	...
	)		-> tuple< std::decay_t< Head >, std::decay_t< Tail >... >

type_exists_impl() [1/2]

auto tatooine::type_exists_impl

(

...

)

-> std::false_type

type_exists_impl() [2/2]

template<typename T , std::size_t = sizeof(T)>

auto tatooine::type_exists_impl

(

T *

)

-> std::true_type

type_name() [1/4]

template<typename T >

auto tatooine::type_name ( ) -> std::string

inline

returns demangled typename

type_name() [2/4]

template<typename T >

auto tatooine::type_name ( std::string const &  name ) -> std::string

inline

returns demangled typename

type_name() [3/4]

auto tatooine::type_name ( std::type_info const &  t ) -> std::string

inline

type_name() [4/4]

template<typename T >

auto tatooine::type_name ( T &&  ) -> std::string

inline

returns demangled typename

type_to_str()

template<typename Data >

constexpr auto tatooine::type_to_str ( ) -> std::string_view

constexpr

type_to_str< char >()

template<>

constexpr auto tatooine::type_to_str< char > ( ) -> std::string_view

constexpr

type_to_str< double >()

template<>

constexpr auto tatooine::type_to_str< double > ( ) -> std::string_view

constexpr

type_to_str< float >()

template<>

constexpr auto tatooine::type_to_str< float > ( ) -> std::string_view

constexpr

type_to_str< int >()

template<>

constexpr auto tatooine::type_to_str< int > ( ) -> std::string_view

constexpr

type_to_str< long >()

template<>

constexpr auto tatooine::type_to_str< long > ( ) -> std::string_view

constexpr

type_to_str< long double >()

template<>

constexpr auto tatooine::type_to_str< long double > ( ) -> std::string_view

constexpr

type_to_str< long long >()

template<>

constexpr auto tatooine::type_to_str< long long > ( ) -> std::string_view

constexpr

type_to_str< unsigned char >()

template<>

constexpr auto tatooine::type_to_str< unsigned char > ( ) -> std::string_view

constexpr

type_to_str< unsigned int >()

template<>

constexpr auto tatooine::type_to_str< unsigned int > ( ) -> std::string_view

constexpr

type_to_str< unsigned long >()

template<>

constexpr auto tatooine::type_to_str< unsigned long > ( ) -> std::string_view

constexpr

type_to_str< unsigned long long >()

template<>

constexpr auto tatooine::type_to_str< unsigned long long > ( ) -> std::string_view

constexpr

unary_operation() [1/3]

template<dynamic_tensor Tensor>

constexpr auto tatooine::unary_operation ( invocable< tatooine::value_type< Tensor > > auto &&  op, Tensor const &  t  )

constexpr

unary_operation() [2/3]

template<typename Op , static_tensor Tensor>

constexpr auto tatooine::unary_operation ( Op &&  op, Tensor const &  t  )

constexpr

unary_operation() [3/3]

template<typename Op , static_tensor Tensor, std::size_t... Seq>

constexpr auto tatooine::unary_operation ( Op &&  op, Tensor const &  t, std::index_sequence< Seq... >    )

constexpr

unary_operation_field() [1/11]

template<typename Field , typename Op >
requires (!std::is_pointer_v<std::decay_t<Field>>)

tatooine::unary_operation_field	(	Field &&	field,
		Op &&	op
	)		-> unary_operation_field< Field, Op >

unary_operation_field() [2/11]

template<typename Field , typename Op >
requires (!std::is_pointer_v<std::decay_t<Field>>)

tatooine::unary_operation_field	(	Field &&	field,
		Op &	op
	)		-> unary_operation_field< Field, Op & >

unary_operation_field() [3/11]

template<typename Field , typename Op >
requires (!std::is_pointer_v<std::decay_t<Field>>)

tatooine::unary_operation_field	(	Field &&	field,
		Op const &	op
	)		-> unary_operation_field< Field, Op const & >

unary_operation_field() [4/11]

template<typename Field , typename Op >
requires (!std::is_pointer_v<Field>)

tatooine::unary_operation_field	(	Field &	field,
		Op &&	op
	)		-> unary_operation_field< Field &, Op >

unary_operation_field() [5/11]

template<typename Field , typename Op >
requires (!std::is_pointer_v<Field>)

tatooine::unary_operation_field	(	Field &	field,
		Op &	op
	)		-> unary_operation_field< Field &, Op & >

unary_operation_field() [6/11]

template<typename Field , typename Op >
requires (!std::is_pointer_v<Field>)

tatooine::unary_operation_field	(	Field &	field,
		Op const &	op
	)		-> unary_operation_field< Field &, Op const & >

unary_operation_field() [7/11]

template<typename Field , typename Op >

tatooine::unary_operation_field	(	Field *	field,
		Op &&	op
	)		-> unary_operation_field< Field *, Op >

unary_operation_field() [8/11]

template<typename Field , typename Op >
requires (!std::is_pointer_v<Field>)

tatooine::unary_operation_field	(	Field const &	field,
		Op &&	op
	)		-> unary_operation_field< Field const &, Op >

unary_operation_field() [9/11]

template<typename Field , typename Op >
requires (!std::is_pointer_v<Field>)

tatooine::unary_operation_field	(	Field const &	field,
		Op &	op
	)		-> unary_operation_field< Field const &, Op & >

unary_operation_field() [10/11]

template<typename Field , typename Op >
requires (!std::is_pointer_v<Field>)

tatooine::unary_operation_field	(	Field const &	field,
		Op const &	op
	)		-> unary_operation_field< Field const &, Op const & >

unary_operation_field() [11/11]

template<typename Field , typename Op >

tatooine::unary_operation_field	(	Field const *	field,
		Op &&	op
	)		-> unary_operation_field< Field const *, Op >

uniform_tree_hierarchy()

template<typename Real , std::size_t NumDimensions, std::size_t SimplexDim>

tatooine::uniform_tree_hierarchy	(	vec< Real, NumDimensions > const &	,
		vec< Real, NumDimensions > const &	,
		unstructured_simplicial_grid< Real, NumDimensions, SimplexDim > const &	,
		std::size_t const
	)		-> uniform_tree_hierarchy< unstructured_simplicial_grid< Real, NumDimensions, SimplexDim > >

unpack() [1/10]

template<typename Tensor , typename Real , size_t N>

tatooine::unpack

(

base_tensor< Tensor, Real, N > &

c

)

-> unpack< base_tensor< Tensor, Real, N > >

unpack() [2/10]

template<typename Tensor , typename Real , size_t N>

tatooine::unpack

(

const base_tensor< Tensor, Real, N > &

c

)

-> unpack< const base_tensor< Tensor, Real, N > >

unpack() [3/10]

template<typename T , size_t N>

tatooine::unpack

(

const std::array< T, N > &

c

)

-> unpack< const std::array< T, N > >

unpack() [4/10]

template<typename A , typename B >

tatooine::unpack

(

const std::pair< A, B > &

c

)

-> unpack< const std::pair< A, B > >

unpack() [5/10]

template<typename... Ts>

tatooine::unpack

(

const std::tuple< Ts... > &

c

)

-> unpack< const std::tuple< Ts... > >

unpack() [6/10]

template<typename Real , size_t N>

tatooine::unpack

(

const tensor< Real, N > &

c

)

-> unpack< const tensor< Real, N > >

unpack() [7/10]

template<typename T , size_t N>

tatooine::unpack

(

std::array< T, N > &

c

)

-> unpack< std::array< T, N > >

unpack() [8/10]

template<typename A , typename B >

tatooine::unpack

(

std::pair< A, B > &

c

)

-> unpack< std::pair< A, B > >

unpack() [9/10]

template<typename... Ts>

tatooine::unpack

(

std::tuple< Ts... > &&

c

)

-> unpack< std::tuple< Ts... > >

unpack() [10/10]

template<typename Real , size_t N>

tatooine::unpack

(

tensor< Real, N > &

c

)

-> unpack< tensor< Real, N > >

unstructured_simplicial_grid() [1/2]

template<typename... Dims>

tatooine::unstructured_simplicial_grid

(

rectilinear_grid< Dims... > const &

g

)

-> unstructured_simplicial_grid< typename rectilinear_grid< Dims... >::real_type, sizeof...(Dims)>

unstructured_simplicial_grid() [2/2]

tatooine::unstructured_simplicial_grid

(

std::string const &

)

-> unstructured_simplicial_grid< double, 3 >

vec() [1/2]

template<typename V , typename ValueType , std::size_t N>

tatooine::vec

(

base_tensor< V, ValueType, N > const &

)

-> vec< ValueType, N >

vec() [2/2]

template<typename... Ts>

tatooine::vec

(

const Ts &

...

)

-> vec< common_type< Ts... >, sizeof...(Ts)>

vertices() [1/2]

template<typename Real , std::size_t NumDimensions>

auto tatooine::vertices

(

pointset< Real, NumDimensions > const &

ps

)

vertices() [2/2]

template<floating_point_range... Dimensions>

auto tatooine::vertices

(

rectilinear_grid< Dimensions... > const &

g

)

visit()

template<typename Visitor , typename Variant0 , typename Variant1 , typename... Variants>

constexpr auto tatooine::visit ( Visitor &&  visitor, Variant0 &&  variant0, Variant1 &&  variant1, Variants &&...  variants  ) -> void

constexpr

Visit implementation that wraps stored value of std::variants to function parameters.

vorticity()

template<typename V , typename Real >

auto tatooine::vorticity

(

const field< V, Real, 3, 3 > &

vf

)

write() [1/2]

template<range_of_lines Lines>

auto tatooine::write	(	Lines const &	lines,
		filesystem::path const &	path
	)		-> void

write() [2/2]

auto tatooine::write	(	range auto const &	grids,
		std::filesystem::path const &	path
	)

write_png() [1/2]

template<arithmetic Real>

void tatooine::write_png	(	dynamic_multidim_array< Real > const &	arr,
		std::string const &	filepath
	)

write_png() [2/2]

template<arithmetic T>

void tatooine::write_png	(	filesystem::path const &	path,
		std::vector< T > const &	data,
		std::size_t	width,
		std::size_t	height
	)

write_vtk() [1/2]

template<range_of_lines Lines>

auto tatooine::write_vtk	(	Lines const &	lines,
		filesystem::path const &	path,
		std::string const &	title = "tatooine lines"
	)		-> void

write_vtk() [2/2]

auto tatooine::write_vtk	(	range auto const &	grids,
		std::filesystem::path const &	path,
		std::string const &	title = "tatooine grids"
	)

write_vtp() [1/5]

template<range Ellipsoids>
requires (is_derived_from_hyper_ellipse< std::ranges::range_value_t<Ellipsoids>>) && (std::ranges::range_value_t<Ellipsoids>::num_dimensions() == 2)

auto tatooine::write_vtp	(	Ellipsoids const &	ellipsoids,
		filesystem::path const &	path
	)

write_vtp() [2/5]

template<range Ellipsoids>
requires (is_derived_from_hyper_ellipse< std::ranges::range_value_t<Ellipsoids>>) && (std::ranges::range_value_t<Ellipsoids>::num_dimensions() == 3)

auto tatooine::write_vtp	(	Ellipsoids const &	ellipsoids,
		filesystem::path const &	path
	)

write_vtp() [3/5]

template<range_of_lines Lines>

auto tatooine::write_vtp	(	Lines const &	lines,
		filesystem::path const &	path
	)		-> void

write_vtp() [4/5]

auto tatooine::write_vtp	(	range auto const &	grids,
		std::filesystem::path const &	path
	)

write_vtp() [5/5]

template<floating_point Real>

auto tatooine::write_vtp	(	std::vector< autonomous_particle< Real, 2 > > const &	particles,
		std::size_t const	num_points,
		filesystem::path const &	path,
		backward_tag const
	)

x0_to_pointset()

template<typename Real , std::size_t NumDimensions>

auto tatooine::x0_to_pointset

(

std::vector< particle< Real, NumDimensions > > const &

particles

)

x1_to_pointset()

template<typename Real , std::size_t NumDimensions>

auto tatooine::x1_to_pointset

(

std::vector< particle< Real, NumDimensions > > const &

particles

)

Variable Documentation

are_arithmetic_complex_or_symbolic_v

template<typename... Ts>

constexpr auto tatooine::are_arithmetic_complex_or_symbolic_v

staticconstexpr

Initial value:

=
    are_arithmetic_complex_or_symbolic<Ts...>::value

are_arithmetic_or_symbolic_v

template<typename... Ts>

constexpr auto tatooine::are_arithmetic_or_symbolic_v

staticconstexpr

Initial value:

=
    are_arithmetic_or_symbolic<Ts...>::value

are_equality_comparable

template<typename T , typename S >

constexpr auto tatooine::are_equality_comparable

staticconstexpr

Initial value:

=
    are_equality_comparable_impl<T, S>::value

are_symbolic_v

template<typename... Ts>

constexpr auto tatooine::are_symbolic_v = are_symbolic<Ts...>::value

staticconstexpr

backward

constexpr backward_tag tatooine::backward

staticconstexpr

c_str_assembler_v

template<const char... cs>

constexpr std::string_view tatooine::c_str_assembler_v = c_str_assembler<cs...>::value

staticconstexpr

field_num_dimensions

template<typename Field >

constexpr auto tatooine::field_num_dimensions

staticconstexpr

Initial value:

=
    std::decay_t<std::remove_pointer_t<std::decay_t<Field>>>::num_dimensions()

forward

constexpr forward_tag tatooine::forward

staticconstexpr

hardware_constructive_interference_size

constexpr std::size_t tatooine::hardware_constructive_interference_size = 64

staticconstexpr

hardware_destructive_interference_size

constexpr std::size_t tatooine::hardware_destructive_interference_size = 64

staticconstexpr

is_arithmetic

template<typename... Ts>

constexpr auto tatooine::is_arithmetic = (std::is_arithmetic<Ts>::value && ...)

staticconstexpr

is_arithmetic_or_complex

template<typename... Ts>

constexpr auto tatooine::is_arithmetic_or_complex

staticconstexpr

Initial value:

= ((is_arithmetic<Ts> ||
                                                   is_complex<Ts>)&&...)

is_array

template<typename T >

auto constexpr tatooine::is_array = is_array_impl<T>::value

staticconstexpr

is_backward_iterator

template<typename T >

constexpr auto tatooine::is_backward_iterator

staticconstexpr

Initial value:

= are_equality_comparable<T, T>&&
    is_pre_decrementable<T>&& is_dereferencable<T>

is_bidirectional_iterator

template<typename T >

constexpr auto tatooine::is_bidirectional_iterator

staticconstexpr

Initial value:

=
    are_equality_comparable<T, T>&& is_pre_incrementable<T>&&
        is_pre_decrementable<T>&& is_dereferencable<T>

is_cacheable_v

template<typename T >

constexpr auto tatooine::is_cacheable_v = is_cacheable_impl<T>::value

staticconstexpr

is_complex

template<typename... Ts>

constexpr auto tatooine::is_complex = (is_complex_impl<Ts>::value && ...)

staticconstexpr

is_const

template<typename... Ts>

constexpr auto tatooine::is_const = (std::is_const<Ts>::value && ...)

staticconstexpr

is_convertible

template<typename From , typename To >

constexpr auto tatooine::is_convertible = std::is_convertible<From, To>::value

staticconstexpr

is_convertible_to_floating_point

template<typename From >

constexpr auto tatooine::is_convertible_to_floating_point

staticconstexpr

Initial value:

=
    is_convertible<From, float> || is_convertible<From, double> ||
    is_convertible<From, long double>

is_convertible_to_integral

template<typename From >

constexpr auto tatooine::is_convertible_to_integral

staticconstexpr

Initial value:

=
    is_convertible<From, bool> || is_convertible<From, char> ||
    is_convertible<From, unsigned char> || is_convertible<From, char16_t> ||
    is_convertible<From, char32_t> || is_convertible<From, wchar_t> ||
    is_convertible<From, unsigned short> || is_convertible<From, short> ||
    is_convertible<From, int> || is_convertible<From, unsigned int> ||
    is_convertible<From, long> || is_convertible<From, unsigned long>

is_dereferencable

template<typename... Ts>

constexpr auto tatooine::is_dereferencable

staticconstexpr

Initial value:

= (is_dereferencable_impl<Ts>::value &&
                                           ...)

is_derived_from_hyper_ellipse

template<typename T >

auto constexpr tatooine::is_derived_from_hyper_ellipse

staticconstexpr

Initial value:

=
    detail::geometry::hyper_ellipse::is_derived_impl<T>::value

is_differentiated_flowmap

template<typename T >

constexpr auto tatooine::is_differentiated_flowmap

staticconstexpr

Initial value:

=
    is_differentiated_flowmap_impl<T>::value

is_double

template<typename... Ts>

constexpr auto tatooine::is_double = (is_same<Ts, double> && ...)

staticconstexpr

is_edgeset

template<typename T >

constexpr auto tatooine::is_edgeset = is_edgeset_impl<T>::value

staticconstexpr

is_either_of

template<typename Query , typename... Others>

constexpr auto tatooine::is_either_of = (is_same<Query, Others> || ...)

staticconstexpr

is_float

template<typename... Ts>

constexpr auto tatooine::is_float = (is_same<Ts, float> && ...)

staticconstexpr

is_floating_point

template<typename... Ts>

constexpr auto tatooine::is_floating_point

staticconstexpr

Initial value:

= (std::is_floating_point<Ts>::value &&
                                           ...)

is_forward_iterator

template<typename T >

constexpr auto tatooine::is_forward_iterator

staticconstexpr

Initial value:

= are_equality_comparable<T, T>&&
    is_pre_incrementable<T>&& is_dereferencable<T>

is_indexable

template<typename... Ts>

constexpr auto tatooine::is_indexable = (is_indexable_impl<Ts>::value && ...)

staticconstexpr

is_int

template<typename... Ts>

constexpr auto tatooine::is_int = (is_same<Ts, int> && ...)

staticconstexpr

is_integral

template<typename... Ts>

constexpr auto tatooine::is_integral = (std::is_integral<Ts>::value && ...)

staticconstexpr

is_invocable

template<typename F , typename... Args>

constexpr auto tatooine::is_invocable = std::is_invocable<F, Args...>::value

staticconstexpr

is_invocable_r

template<typename R , typename F , typename... Args>

constexpr auto tatooine::is_invocable_r = std::is_invocable<R, F, Args...>::value

staticconstexpr

is_invocable_with_n_floating_points

template<typename F , std::size_t N>

constexpr bool tatooine::is_invocable_with_n_floating_points

staticconstexpr

Initial value:

=
    is_invocable_with_n_floating_points_impl<F, N>::value

is_invocable_with_n_integrals

template<typename F , std::size_t N>

constexpr auto tatooine::is_invocable_with_n_integrals

staticconstexpr

Initial value:

=
    is_invocable_with_n_integrals_impl<F, N>::value

is_line

template<typename T >

auto constexpr tatooine::is_line = is_line_impl<T>::value

staticconstexpr

is_linspace

template<typename T >

constexpr auto tatooine::is_linspace = is_linspace_impl<T>::value

staticconstexpr

is_matrixfield

template<typename T >

constexpr auto tatooine::is_matrixfield = is_matrixfield_impl<T>::value

staticconstexpr

is_non_const

template<typename... Ts>

constexpr auto tatooine::is_non_const = (!std::is_const<Ts>::value && ...)

staticconstexpr

is_numerical_flowmap

template<typename T >

constexpr auto tatooine::is_numerical_flowmap

staticconstexpr

Initial value:

=
    is_numerical_flowmap_impl<T>::value

is_pair

template<typename T >

constexpr auto tatooine::is_pair = is_pair_impl<T>::value

staticconstexpr

is_pointer

template<typename T >

constexpr auto tatooine::is_pointer = std::is_pointer<T>::value

staticconstexpr

is_polynomial

template<typename T >

constexpr bool tatooine::is_polynomial = is_polynomial_impl<T>::value

staticconstexpr

is_post_decrementable

template<typename T >

constexpr auto tatooine::is_post_decrementable

staticconstexpr

Initial value:

=
    is_post_decrementable_impl<T>::value

is_post_incrementable

template<typename... Ts>

constexpr auto tatooine::is_post_incrementable

staticconstexpr

Initial value:

=
    (is_post_incrementable_impl<Ts>::value && ...)

is_pre_decrementable

template<typename T >

constexpr auto tatooine::is_pre_decrementable

staticconstexpr

Initial value:

=
    is_pre_decrementable_impl<T>::value

is_pre_incrementable

template<typename T >

constexpr auto tatooine::is_pre_incrementable

staticconstexpr

Initial value:

=
    is_pre_incrementable_impl<T>::value

is_predicate

template<typename F , typename... Ts>

constexpr auto tatooine::is_predicate

staticconstexpr

Initial value:

=
    is_same<bool, std::invoke_result_t<F, Ts...>>

is_random_number_generator

template<typename ValueType >

auto constexpr tatooine::is_random_number_generator

staticconstexpr

Initial value:

=
    is_random_number_generator_impl<ValueType>::value

is_range

template<typename... Ts>

constexpr auto tatooine::is_range = (is_range_impl<Ts>::value && ...)

staticconstexpr

is_same

template<typename... Ts>

constexpr auto tatooine::is_same = is_same_impl<Ts...>::value

staticconstexpr

is_scalarfield

template<typename T >

constexpr bool tatooine::is_scalarfield = is_scalarfield_impl<T>::value

staticconstexpr

is_signed

template<typename... Ts>

constexpr auto tatooine::is_signed = (std::is_signed<Ts>::value && ...)

staticconstexpr

is_signed_integral

template<typename... Ts>

constexpr auto tatooine::is_signed_integral

staticconstexpr

Initial value:

= ((is_signed<Ts> && ...) &&
                                            (is_integral<Ts> && ...))

is_size_t

template<typename... Ts>

constexpr auto tatooine::is_size_t = (is_same<Ts, size_t> && ...)

staticconstexpr

is_square

template<static_tensor Tensor>

auto constexpr tatooine::is_square = is_square_impl<Tensor>::value

staticconstexpr

is_symbolic_field_v

template<typename T >

constexpr auto tatooine::is_symbolic_field_v = is_symbolic<T>::value

staticconstexpr

is_symbolic_v

template<typename T >

constexpr auto tatooine::is_symbolic_v = is_symbolic<T>::value

staticconstexpr

is_unsigned

template<typename... Ts>

constexpr auto tatooine::is_unsigned = (std::is_unsigned<Ts>::value && ...)

staticconstexpr

is_unsigned_integral

template<typename... Ts>

constexpr auto tatooine::is_unsigned_integral

staticconstexpr

Initial value:

= ((is_unsigned<Ts> && ...) &&
                                              (is_integral<Ts> && ...))

is_unstructured_triangular_grid

template<typename T >

constexpr auto tatooine::is_unstructured_triangular_grid

staticconstexpr

Initial value:

=
    is_unstructured_triangular_grid_impl<T>::value

is_vectorfield

template<typename T >

constexpr bool tatooine::is_vectorfield = is_vectorfield_impl<T>::value

staticconstexpr

is_void

template<typename... Ts>

constexpr auto tatooine::is_void = (is_same<Ts, void> && ...)

staticconstexpr

parallel_for_loop_support

static constexpr bool tatooine::parallel_for_loop_support = true

staticconstexpr

tensor_dimension

template<typename T , std::size_t I>

auto constexpr tatooine::tensor_dimension = tensor_dimension_impl<T, I>::value

staticconstexpr

tensor_dimensions

template<typename T >

auto constexpr tatooine::tensor_dimensions = tensor_dimensions_impl<T>::value

staticconstexpr

tensor_num_components

template<typename T >

auto constexpr tatooine::tensor_num_components

staticconstexpr

Initial value:

=
    tensor_num_components_impl<T>::value

tensor_rank

template<typename T >

constexpr auto tatooine::tensor_rank = tensor_rank_impl<T>::value

staticconstexpr

thin_plate_spline

auto constexpr tatooine::thin_plate_spline

constexpr

Initial value:

= [](auto const x) -> decltype(x) {
  if (x == 0) {
    return 0;
  }
  return x * x * gcem::log(x);
}

thin_plate_spline_diff1

auto constexpr tatooine::thin_plate_spline_diff1

constexpr

Initial value:

= [](auto const x) -> decltype(x) {
  return 2 * x * gcem::log(x) + x;
}

thin_plate_spline_diff2

auto constexpr tatooine::thin_plate_spline_diff2

constexpr

Initial value:

= [](auto const x) -> decltype(x) {
  return 2 * gcem::log(x) + 3;
}

thin_plate_spline_diff3

auto constexpr tatooine::thin_plate_spline_diff3

constexpr

Initial value:

= [](auto const x) -> decltype(x) {
  return 2 / x;
}

thin_plate_spline_from_squared

auto constexpr tatooine::thin_plate_spline_from_squared

constexpr

Initial value:

=
    [](auto const xx) -> decltype(xx) {
  if (xx == 0) {
    return 0;
  }
  return xx * gcem::log(xx) / 2;
}

type_exists

template<typename T >

constexpr auto tatooine::type_exists

staticconstexpr

Initial value:

=
    decltype(type_exists_impl(std::declval<T*>()))::value