Designar Namespace Reference

Classes
struct	AllAreConvertible
struct	AllAreConvertible< To, From >
class	ArcHeap
class	ArcHeapCmp
class	ArrayIterator
class	ArrayMap
class	ArraySet
class	Astar
class	BaseBinTreeNode
class	BaseGraph
class	BaseGraphArc
class	BaseGraphNode
class	BasicIterator
class	BellmanFord
class	BidirectionalIterator
class	BruteForceConvexHull
class	Byte
class	CmpWrapper
class	CommonNodeArc
class	ConcurrentQueue
class	ContainerAlgorithms
class	DefaultDistance
class	DefaultHeuristic
class	DftArcInit
class	DftArcInput
class	DftArcOutput
class	DftDotArcAttr
class	DftDotGraphAttr
class	DftDotNodeAttr
class	DftGraphInput
class	DftGraphOutput
class	DftGridArcInit
class	DftGridNodeInit
class	DftNodeInit
class	DftNodeInput
class	DftNodeOutput
class	Digraph
class	DigraphArc
class	DigraphNode
class	Dijkstra
class	DistanceCmp
class	DL
class	DLList
class	DLNode
class	DotGraph
class	DynArray
class	DynBitSet
class	DynHeap
class	DynQueue
class	DynStack
class	EmptyClass
struct	EqualKey
class	EquivalenceRelation
struct	FastIntegralPow
class	FixedArray
class	FixedHeap
class	FixedQueue
class	FixedStack
class	ForwardIterator
class	GenArraySet
class	GenMap
class	GenPoint2D
class	GenPolygon
class	GenSegment
class	GenTriangle
class	GetPot
class	Graph
class	GraphArc
class	GraphNode
class	HashMap
class	HashSet
class	HeapNode
class	InputGraph
class	IntRange
class	KargerMinCut
struct	KeyCmp
class	Kruskal
class	LHashTable
class	LHeap
class	ListQueue
class	ListStack
class	MinPathArcInfo
class	MinPathNodeInfo
class	MTreeNode
class	MultiDimArray
class	NodeSLList
struct	NotEqualKey
class	Now
class	OutputGraph
class	Path
class	Point2D
class	PointInt2D
class	Polygon
class	PolygonInt
class	Prim
struct	PtrCmp
class	QuickHull
class	RandomAccessIterator
class	Range
class	RankedTreap
class	RealRange
class	Segment
class	SegmentInt
class	SetAlgorithms
class	Singleton
class	SLList
class	SLNode
class	SortedArraySet
class	SortedArraySetOp
struct	StdPow
class	TArrayIterator
class	TreapRkNode
class	TreeMap
class	TreeSet
class	TRelation
class	Triangle
class	TriangleInt
class	UIntRange
class	UnsortedArraySet
class	UnsortedArraySetOp
class	Vector2D

Typedefs
template<class GT >
using	Node = typename GT::Node
template<class GT >
using	Arc = typename GT::Arc
template<class GT >
using	NodeIt = typename GT::NodeIterator
template<class GT >
using	ArcIt = typename GT::ArcIterator
template<class GT >
using	AdArcIt = typename GT::AdjacentArcIterator
template<bool B, typename T , typename F >
using	RetType = typename std::conditional< B, T, F >::type
template<typename Key , typename Value >
using	MapKey = std::pair< Key, Value >
template<typename Key , typename Value >
using	MapItem = MapKey< Key, Value >
using	lint_t = long long
using	nat_t = unsigned long int
using	real_t = double
using	rng_t = std::mt19937_64
using	rng_seed_t = rng_t::result_type
using	clock_t = std::chrono::high_resolution_clock
using	time_point_t = clock_t::time_point
using	duration_t = clock_t::duration

Enumerations
enum	GraphTag : nat_t {   GraphTag::DEPTH_FIRST = 1, GraphTag::BREADTH_FIRST = 2, GraphTag::KRUSKAL = 4, GraphTag::PRIM = 8,   GraphTag::DIJKSTRA = 16, GraphTag::ASTAR = 32, GraphTag::SPANNING_TREE = 64, GraphTag::MIN_SPANNING_TREE = 128,   GraphTag::COMPONENT = 256, GraphTag::CUT = 512, GraphTag::PATH = 1024, GraphTag::MIN_PATH = 2048,   GraphTag::MIN_PATH_TREE = 4096 }
enum	Sign { Sign::NEGATIVE, Sign::POSITIVE, Sign::ZERO }
enum	BinTreeNodeCtor { BinTreeNodeCtor::SENTINEL_CTOR }
enum	BinTreeNodeNullValue { BinTreeNodeNullValue::NULLPTR, BinTreeNodeNullValue::SENTINEL }

Functions
template<class GT , class NodeInit , class ArcInit >
GT	full_graph (nat_t, NodeInit &, ArcInit &)
template<class GT , class NodeInit = DftNodeInit<GT>, class ArcInit = DftArcInit<GT>>
GT	full_graph (nat_t, NodeInit &&node_init=NodeInit(), ArcInit &&arc_init=ArcInit())
template<class GT , class NodeInit , class ArcInit >
GT	build_grid (nat_t width, nat_t height, NodeInit &node_init, ArcInit &arc_init, bool with_diagonal=true)
template<class GT , class NodeInit = DftGridNodeInit<GT>, class ArcInit = DftGridArcInit<GT>>
GT	build_grid (nat_t width, nat_t height, NodeInit &&node_init=NodeInit(), ArcInit &&arc_init=ArcInit(), bool with_diagonal=true)
template<class GT , class NodeInit , class ArcInit >
GT	random_graph (nat_t, nat_t, rng_seed_t, NodeInit &, ArcInit &)
template<class GT , class NodeInit = DftNodeInit<GT>, class ArcInit = DftArcInit<GT>>
GT	random_graph (nat_t, nat_t, rng_seed_t, NodeInit &&node_init=NodeInit(), ArcInit &&arc_init=ArcInit())
template<class GT , class NodeInit = DftNodeInit<GT>, class ArcInit = DftArcInit<GT>>
GT	random_graph (nat_t, nat_t, NodeInit &&node_init=NodeInit(), ArcInit &&arc_init=ArcInit())
template<class GT , class NodeInit , class ArcInit >
GT	ps_random_graph (nat_t, real_t, rng_seed_t, bool, NodeInit &, ArcInit &)
template<class GT , class NodeInit = DftNodeInit<GT>, class ArcInit = DftArcInit<GT>>
GT	ps_random_graph (nat_t, real_t, rng_seed_t, bool grant_connectivity=false, NodeInit &&node_init=NodeInit(), ArcInit &&arc_init=ArcInit())
template<class GT , class NodeInit , class ArcInit >
GT	p_random_graph (nat_t, real_t, bool, NodeInit &, ArcInit &)
template<class GT , class NodeInit = DftNodeInit<GT>, class ArcInit = DftArcInit<GT>>
GT	p_random_graph (nat_t, real_t, bool grant_connectivity=false, NodeInit &&node_init=NodeInit(), ArcInit &&arc_init=ArcInit())
template<class GT , class Op >
void	depth_first_traverse_prefix_rec (const GT &, Node< GT > *, Op &)
template<class GT , class Op >
void	depth_first_traverse_prefix (const GT &, Op &op)
template<class GT , class Op >
void	depth_first_traverse_prefix (const GT &g, Op &&op=Op())
template<class GT , class Op >
void	depth_first_traverse_sufix_rec (const GT &, Node< GT > *, Op &)
template<class GT , class Op >
void	depth_first_traverse_sufix (const GT &, Op &op)
template<class GT , class Op >
void	depth_first_traverse_sufix (const GT &g, Op &&op=Op())
template<class GT , class Op >
void	depth_first_traverse (const GT &g, Op &op)
template<class GT , class Op >
void	depth_first_traverse (const GT &g, Op &&op=Op())
template<class GT >
bool	depth_first_search_path_rec (const GT &, Node< GT > *, Node< GT > *, Path< GT > &)
template<class GT >
Path< GT >	depth_first_search_path (const GT &, Node< GT > *, Node< GT > *)
template<class GT >
bool	test_cycle_rec (const GT &, Node< GT > *, bool)
template<class GT >
bool	has_cycle (const GT &, Node< GT > *)
template<class GT >
bool	has_cycle (const GT &)
template<class GT >
bool	is_graph_acyclique (const GT &, Node< GT > *)
template<class GT >
bool	is_graph_acyclique (const GT &)
template<class GT >
GT	invert_digraph (const GT &, bool)
template<class GT >
void	build_subgraph_rec (const GT &, Node< GT > *, const GT &)
template<class GT >
SLList< GT >	compute_connected_components (const GT &)
template<class GT >
void	add_nodes_to_component_rec (const GT &, Node< GT > *, SLList< Node< GT > * > &)
template<class GT >
SLList< SLList< Node< GT > * > >	connected_components_node_list (const GT &)
template<class GT >
void	compute_cut_nodes_rec (const GT &, Node< GT > *, Arc< GT > &, SLList< Node< GT > * > &, lint_t &)
template<class GT >
SLList< Node< GT > * >	compute_cut_nodes (const GT &)
template<class GT >
void	paint_cut_nodes_connected_components_rec (const GT &, Node< GT > *, lint_t)
template<class GT >
void	paint_from_cut_node (const GT &, Node< GT > *, lint_t &)
template<class GT >
lint_t	paint_cut_nodes_subgraphs (const GT &, const SLList< Node< GT > * > &)
template<class GT >
void	build_cut_nodes_subgraph_rec (const GT &, Node< GT > *, const GT &, lint_t)
template<class GT >
SLList< GT >	build_cut_nodes_subgraphs (const GT &)
template<class GT >
std::tuple< GT, SLList< Arc< GT > * > >	build_cut_graph (const GT &, const SLList< Node< GT > * > &)
template<class GT >
std::tuple< SLList< GT >, GT, SLList< Arc< GT > * > >	compute_cut_nodes_connected_components (const GT &, const SLList< Node< GT > * > &)
template<class GT >
void	Kosaraju_build_subgraph_rec (const GT &, Node< GT > *, const GT &, nat_t)
template<class GT >
SLList< GT >	Kosaraju_compute_strong_connected_components (const GT &)
template<class GT >
SLList< Node< GT > * >	df_topological_sort (const GT &)
template<class GT , class Op >
void	breadth_first_traverse (const GT &, Node< GT > *, Op &)
template<class GT , class Op >
void	breadth_first_traverse (const GT &g, Node< GT > *p, Op &&op=Op())
template<class GT , class Op >
void	breadth_first_traverse (const GT &g, Op &op)
template<class GT , class Op >
void	breadth_first_traverse (const GT &g, Op &&op=Op())
template<class GT >
Path< GT >	breadth_first_search_path (const GT &g, Node< GT > *, Node< GT > *)
template<class GT >
SLList< Node< GT > * >	bf_topological_sort (const GT &)
template<class GT >
SLList< SLList< Node< GT > * > >	topological_ranks (const GT &)
template<class GT >
bool	is_acyclique (const GT &g, Node< GT > *start)
template<class GT >
bool	is_acyclique (const GT &g)
template<class GT >
GT	invert_digraph (const GT &g)
template<class GT >
void	build_subgraph_rec (const GT &g, Node< GT > *p, GT &t)
template<class GT >
void	compute_cut_nodes_rec (const GT &g, Node< GT > *p, Arc< GT > *a, SLList< Node< GT > * > &l, lint_t &cdf)
template<class GT >
void	build_cut_nodes_subgraph_rec (const GT &g, Node< GT > *p, GT &t, lint_t color)
template<class GT >
void	Kosaraju_build_subgraph_rec (const GT &inv_g, Node< GT > *p, GT &sg, nat_t num)
void	map_graph_item (CommonNodeArc *x, CommonNodeArc *y)
template<class SG , class TG = SG>
void	map_nodes (Node< SG > *p, Node< TG > *q)
template<class SG , class TG = SG>
void	map_arcs (Arc< SG > *a, Arc< TG > *b)
template<class SG , class TG = SG>
TG::Node *	mapped_node (Node< SG > *p)
template<class SG , class TG = SG>
TG::Arc *	mapped_arc (Arc< SG > *a)
template<class GT >
lint_t &	df (Node< GT > *p)
template<class GT >
lint_t &	low (Node< GT > *p)
template<class GT , class Distance >
MinPathNodeInfo< GT, Distance > *&	NI (Node< GT > *p)
template<class GT , class Distance >
Node< GT > *&	TREE_NODE (Node< GT > *p)
template<class GT , class Distance >
Distance::Type &	ACC (Node< GT > *p)
template<class GT , class Distance >
MinPathArcInfo< GT, Distance > *&	AI (Arc< GT > *a)
template<class GT , class Distance >
Arc< GT > *&	TREE_ARC (Arc< GT > *a)
template<class GT , class Distance >
Distance::Type &	POT (Arc< GT > *a)
template<class GT , class Distance >
bool &	IS_IN_QUEUE (Arc< GT > *a)
template<class GT , class Distance >
void	allocate_node_info (const GT &g)
template<class GT , class Distance >
void	allocate_arc_info (const GT &g)
template<class GT , class Distance >
void	destroy_node_info (const GT &g)
template<class GT , class Distance >
void	destroy_arc_info (const GT &g)
template<class GT , class Distance , class Heap >
void	put_in_heap (Arc< GT > *a, Node< GT > *t, Heap &h)
template<class GT , class Distance , class Heap >
Arc< GT > *	get_from_heap (Heap &h)
nat_t	super_fast_hash (void *, nat_t)
nat_t	super_fast_hash (const char *key)
nat_t	super_fast_hash (const std::string &key)
template<typename Key >
nat_t	super_fast_hash (const Key &key)
template<typename First , typename Second >
nat_t	super_fast_hash (const std::pair< First, Second > &p)
template<class HeapNode >
HeapNode *&	U (HeapNode *p)
template<typename T >
T	forward_prod (T, T)
template<typename T >
T	backward_prod (T, T)
template<typename T >
T	factorial (T)
template<typename T >
T	count_permutations (T, T)
template<typename T >
T	count_combinations (T, T)
template<typename RetT , class It >
RetT *	nth_ptr_it (const It &, const It &, nat_t)
template<typename RetT , class It >
RetT &	nth_it (const It &, const It &, nat_t)
template<class It , class Op >
void	for_each_it (const It &, const It &, Op &)
template<class It , class Op >
void	for_each_it (const It &, const It &, Op &&op=Op())
template<class It , class ContainerRet , class Pred >
ContainerRet	filter_it (const It &, const It &, Pred &)
template<class ContainerRet , class It , class Pred >
ContainerRet	filter_it (const It &, const It &, Pred &&pred=Pred())
template<class ContainerRet , class It , class Op >
ContainerRet	map_it (const It &, const It &, Op &)
template<class ContainerRet , class It , class Op >
ContainerRet	map_it (const It &, const It &, Op &&op=Op())
template<class ContainerRet , class It , class Op , class Pred >
ContainerRet	map_if_it (const It &, const It &, Op &, Pred &)
template<class ContainerRet , class It , class Op , class Pred >
ContainerRet	map_if_it (const It &, const It &, Op &, Pred &&pred=Pred())
template<class ContainerRet , class It , class Op , class Pred >
ContainerRet	map_if_it (const It &, const It &, Op &&, Pred &)
template<class ContainerRet , class It , class Op , class Pred >
ContainerRet	map_if_it (const It &, const It &, Op &&op=Op(), Pred &&pred=Pred())
template<typename RetT , class It , class Pred >
RetT *	search_ptr_it (const It &, const It &, Pred &)
template<typename RetT , class It , class Pred >
RetT *	search_ptr_it (const It &, const It &, Pred &&pred=Pred())
template<class It , class Pred >
bool	all_it (const It &, const It &, Pred &)
template<class It , class Pred >
bool	all_it (const It &, const It &, Pred &&pred=Pred())
template<class It , class Pred >
bool	exists_it (const It &, const It &, Pred &)
template<class It , class Pred >
bool	exists_it (const It &, const It &, Pred &&pred=Pred())
template<class It , class Pred >
bool	none_it (const It &, const It &, Pred &)
template<class It , class Pred >
bool	none_it (const It &, const It &, Pred &&pred=Pred())
template<typename RetT , class It , class Op >
RetT	fold_it (const It &, const It &, const RetT &, Op &)
template<typename RetT , class It , class Op >
RetT	fold_it (const It &, const It &, const RetT &, Op &&op=Op())
template<typename RetT , class It , class Op >
RetT	fold_it (const It &, const It &, RetT &&, Op &)
template<typename RetT , class It , class Op >
RetT	fold_it (const It &, const It &, RetT &&, Op &&op=Op())
template<class It , class Pred >
bool	remove_first_if_it (const It &, const It &, Pred &)
template<class It , class Pred >
bool	remove_first_if_it (const It &, const It &, Pred &&pred=Pred())
template<class It , class Pred >
void	remove_if_it (const It &, const It &, Pred &)
template<class It , class Pred >
void	remove_if_it (const It &, const It &, Pred &&pred=Pred())
template<class It1 , class It2 , class Eq >
bool	equal_it (const It1 &, const It1 &, const It2 &, const It2 &, Eq &)
template<class It1 , class It2 , class Eq >
bool	equal_it (const It1 &, const It1 &, const It2 &, const It2 &, Eq &&eq=Eq())
template<class It , class Cmp >
bool	is_sorted_it (const It &, const It &, Cmp &)
template<class It , class Cmp >
bool	is_sorted_it (const It &, const It &, Cmp &&cmp=Cmp())
template<typename T1 , typename T2 , class It1 , class It2 >
SLList< std::pair< T1, T2 > >	zip_it (const It1 &, const It1 &, const It2 &, const It2 &)
template<typename T1 , typename T2 , class It1 , class It2 >
SLList< std::pair< T1, T2 > >	zip_eq_it (const It1 &, const It1 &, const It2 &, const It2 &)
template<typename T1 , typename T2 , class It1 , class It2 >
SLList< std::pair< T1, T2 > >	zip_left_it (const It1 &, const It1 &, const It2 &, const It2 &)
template<typename T1 , typename T2 , class It1 , class It2 >
SLList< std::pair< T1, T2 > >	zip_right_it (const It1 &, const It1 &, const It2 &, const It2 &)
template<class ContainerType , class It >
ContainerType	to_container (const It &, const It &)
template<typename T , class It >
SLList< T >	to_list_it (const It &, const It &)
template<typename T , class It >
DynArray< T >	to_array_it (const It &, const It &)
template<typename... Args>
auto	map_key (Args &&...args) -> decltype(std::make_pair(std::forward< Args >(args)...))
template<typename... Args>
auto	map_item (Args &&...args) -> decltype(std::make_pair(std::forward< Args >(args)...))
template<typename Key , typename Value >
Key &	key (MapKey< Key, Value > &item)
template<typename Key , typename Value >
const Key &	key (const MapKey< Key, Value > &item)
template<typename Key , typename Value >
Key	key (MapKey< Key, Value > &&item)
template<typename Key , typename Value >
Key &	key (MapKey< Key, Value > *item_ptr)
template<typename Key , typename Value >
Value &	value (MapKey< Key, Value > &item)
template<typename Key , typename Value >
const Value &	value (const MapKey< Key, Value > &item)
template<typename Key , typename Value >
Value	value (MapKey< Key, Value > &&item)
template<typename Key , typename Value >
Value &	value (MapKey< Key, Value > *item_ptr)
template<typename Key , typename Value , typename Fct >
nat_t	hash_fct_wrapper (Fct fct, const MapKey< Key, Value > &p)
template<typename T >
Sign	sign (T)
template<typename T >
bool	is_positive (T)
template<typename T >
bool	is_negative (T)
template<typename T >
T	abs (T)
template<typename T >
bool	real_equal (T, T)
template<typename T >
bool	num_equal (T, T)
template<>
bool	num_equal< float > (float, float)
template<>
bool	num_equal< double > (double, double)
template<>
bool	num_equal< long double > (long double, long double)
template<typename NumberType >
real_t	area_of_parallelogram (const GenPoint2D< NumberType > &, const GenPoint2D< NumberType > &, const GenPoint2D< NumberType > &)
template<typename BT , typename ET >
BT	fast_integral_pow (BT, ET)
template<typename BT , typename ET >
BT	pow (BT, ET)
template<class BinTreeNode >
BinTreeNode::KeyType &	KEY (BinTreeNode *p)
template<class BinTreeNode >
BinTreeNode *&	L (BinTreeNode *p)
template<class BinTreeNode >
BinTreeNode *&	R (BinTreeNode *p)
rng_seed_t	get_random_seed ()
real_t	random (rng_t &)
template<typename T >
T	random_uniform (rng_t &, T)
template<typename T >
T	random_uniform (rng_t &, T, T)
bool	random_Bernoulli (rng_t &, real_t p=DEFAULT_P)
nat_t	random_binomial (rng_t &, nat_t, real_t p=DEFAULT_P)
nat_t	throw_dice (rng_t &, nat_t num_faces=DEFAULT_DICE_NUM_FACES)
template<typename T >
Range< T >	range (T f, T l, T s=T(1))
template<typename T >
Range< T >	range (T l)
template<typename T , template< typename > class ArrayType, class Cmp = std::less<T>>
lint_t	binary_search (const ArrayType< T > &, const T &, lint_t, lint_t, Cmp &)
template<typename T , template< typename > class ArrayType, class Cmp = std::less<T>>
lint_t	sequential_search (const ArrayType< T > &, const T &, lint_t, lint_t, Cmp &)
template<class ArrayType , class Cmp >
void	insertion_sort (ArrayType &, lint_t, lint_t, Cmp &)
template<typename ArrayType , class Cmp >
lint_t	partition (ArrayType &, lint_t, lint_t, Cmp &)
template<typename ArrayType , class Cmp >
void	quicksort (ArrayType &, lint_t, lint_t, Cmp &)
template<typename T , class Cmp >
void	sift_up (T *, nat_t, nat_t, Cmp &)
template<typename T , class Cmp >
void	sift_down (T *, nat_t, nat_t, Cmp &)
template<typename T , class Cmp >
std::tuple< NodeSLList< T >, typename NodeSLList< T >::Node *, NodeSLList< T > >	partition (NodeSLList< T > &, Cmp &)
template<typename T , class Cmp >
void	quicksort (NodeSLList< T > &, Cmp &)
template<class Cmp >
std::tuple< DL, DL *, DL >	partition (DL &, Cmp &)
template<class Cmp >
void	quicksort (DL &, Cmp &)
template<class ArrayType >
ArrayType	reverse (const ArrayType &)
template<class SRCL , class TGTL >
TGTL	reverse (const SRCL &)
template<typename T , template< typename > class ArrayType, class Cmp = std::less<T>>
lint_t	binary_search (const ArrayType< T > &a, T &k, lint_t l, lint_t r, Cmp &&cmp=Cmp())
template<typename T , template< typename > class ArrayType, class Cmp = std::less<T>>
lint_t	binary_search (const ArrayType< T > &a, const T &k, Cmp &cmp)
template<typename T , template< typename > class ArrayType, class Cmp = std::less<T>>
lint_t	binary_search (const ArrayType< T > &a, const T &k, Cmp &&cmp=Cmp())
template<typename T , template< typename > class ArrayType, class Cmp = std::less<T>>
lint_t	sequential_search (const ArrayType< T > &a, const T &k, lint_t l, lint_t r, Cmp &&cmp=Cmp())
template<typename T , template< typename > class ArrayType, class Cmp = std::less<T>>
lint_t	sequential_search (const ArrayType< T > &a, const T &k, Cmp &cmp)
template<typename T , template< typename > class ArrayType, class Cmp = std::less<T>>
lint_t	sequential_search (const ArrayType< T > &a, const T &k, Cmp &&cmp=Cmp())
template<class ArrayType , class Cmp = std::less<typename ArrayType::DataType>>
void	insertion_sort (ArrayType &a, lint_t l, lint_t r, Cmp &&cmp=Cmp())
template<class ArrayType , class Cmp >
void	insertion_sort (ArrayType &a, lint_t size, Cmp &cmp)
template<class ArrayType , class Cmp = std::less<typename ArrayType::DataType>>
void	insertion_sort (ArrayType &a, lint_t size, Cmp &&cmp=Cmp())
template<class ArrayType , class Cmp >
void	insertion_sort (ArrayType &a, Cmp &cmp)
template<class ArrayType , class Cmp = std::less<typename ArrayType::DataType>>
void	insertion_sort (ArrayType &a, Cmp &&cmp=Cmp())
template<typename ArrayType , class Cmp >
lint_t	select_pivot (ArrayType &a, lint_t l, lint_t r, Cmp &cmp)
template<class ArrayType , class Cmp = std::less<typename ArrayType::DataType>>
void	quicksort (ArrayType &a, lint_t l, lint_t r, Cmp &&cmp=Cmp())
template<class ArrayType , class Cmp >
void	quicksort (ArrayType &a, lint_t size, Cmp &cmp)
template<class ArrayType , class Cmp = std::less<typename ArrayType::DataType>>
void	quicksort (ArrayType &a, lint_t size, Cmp &&cmp=Cmp())
template<class ArrayType , class Cmp >
void	quicksort (ArrayType &a, Cmp &cmp)
template<class ArrayType , class Cmp = std::less<typename ArrayType::DataType>>
void	quicksort (ArrayType &a, Cmp &&cmp=Cmp())
template<typename T , class Cmp = std::less<T>>
void	quicksort (FixedArray< T > &a, Cmp &cmp)
template<typename T , class Cmp = std::less<T>>
void	quicksort (FixedArray< T > &a, Cmp &&cmp=Cmp())
template<typename T , class Cmp = std::less<T>>
void	quicksort (DynArray< T > &a, Cmp &cmp)
template<typename T , class Cmp = std::less<T>>
void	quicksort (DynArray< T > &a, Cmp &&cmp=Cmp())
template<typename T , class Cmp >
void	sift_up (T *a, nat_t l, nat_t r, Cmp &&cmp=Cmp())
template<typename T , class Cmp >
void	sift_down (T *a, nat_t l, nat_t r, Cmp &&cmp=Cmp())
template<typename T , class Cmp = std::less<T>>
void	quicksort (NodeSLList< T > &l, Cmp &&cmp=Cmp())
template<class Cmp >
void	quicksort (DL &l, Cmp &&cmp=Cmp())
template<typename T , class Cmp >
void	quicksort (DLNode< T > &l, Cmp &cmp)
template<typename T , class Cmp = std::less<T>>
void	quicksort (DLNode< T > &l, Cmp &&cmp=Cmp())
template<typename T , class Cmp >
void	quicksort (DLList< T > &l, Cmp &cmp)
template<typename T , class Cmp = std::less<T>>
void	quicksort (DLList< T > &l, Cmp &&cmp=Cmp())
template<typename SeqType , class Cmp = std::less<typename SeqType::ItemType>>
SeqType	sort (const SeqType &s, Cmp &cmp)
template<typename SeqType , class Cmp = std::less<typename SeqType::ItemType>>
SeqType	sort (const SeqType &s, Cmp &&cmp=Cmp())
template<typename SeqType , class Cmp = std::less<typename SeqType::ItemType>>
void	inline_sort (SeqType &s, Cmp &cmp)
template<typename SeqType , class Cmp = std::less<typename SeqType::ItemType>>
void	inline_sort (SeqType &s, Cmp &&cmp=Cmp())
template<typename T >
FixedArray< T >	reverse (const FixedArray< T > &a)
template<typename T >
DynArray< T >	reverse (const DynArray< T > &a)
template<typename T >
SLList< T >	reverse (const SLList< T > &l)
template<typename T >
DLList< T >	reverse (const DLList< T > &l)
template<typename ContainerType = DynArray<std::string>>
ContainerType	split_string (const std::string &, const std::string &)
template<class RkNode >
nat_t &	COUNT (RkNode *p)
template<class TreapNode >
rng_seed_t &	PRIOR (TreapNode *p)

Variables
constexpr real_t	PI = 3.1415926535897932384626433832795028841971693993751
constexpr real_t	PI_2 = PI/2.
constexpr real_t	PI_4 = PI/4.
constexpr real_t	PI3_2 = 3.*PI/2.
constexpr real_t	EPSILON = 1e-9
constexpr real_t	INF = std::numeric_limits<real_t>::infinity()
constexpr lint_t	NUM_BITS = 64
constexpr real_t	DEFAULT_P = 0.5
constexpr nat_t	DEFAULT_DICE_NUM_FACES = 6
constexpr lint_t	QuicksortThreshold = 40

Typedef Documentation

template<class GT >

using Designar::AdArcIt = typedef typename GT::AdjacentArcIterator

template<class GT >

using Designar::Arc = typedef typename GT::Arc

template<class GT >

using Designar::ArcIt = typedef typename GT::ArcIterator

using Designar::clock_t = typedef std::chrono::high_resolution_clock

using Designar::duration_t = typedef clock_t::duration

using Designar::lint_t = typedef long long

template<typename Key , typename Value >

using Designar::MapItem = typedef MapKey<Key, Value>

template<typename Key , typename Value >

using Designar::MapKey = typedef std::pair<Key, Value>

using Designar::nat_t = typedef unsigned long int

template<class GT >

using Designar::Node = typedef typename GT::Node

template<class GT >

using Designar::NodeIt = typedef typename GT::NodeIterator

using Designar::real_t = typedef double

template<bool B, typename T , typename F >

using Designar::RetType = typedef typename std::conditional<B, T, F>::type

using Designar::rng_seed_t = typedef rng_t::result_type

using Designar::rng_t = typedef std::mt19937_64

using Designar::time_point_t = typedef clock_t::time_point

Enumeration Type Documentation

enum Designar::BinTreeNodeCtor

strong

Enumerator
SENTINEL_CTOR

enum Designar::BinTreeNodeNullValue

strong

Enumerator
NULLPTR
SENTINEL

enum Designar::GraphTag : nat_t

strong

Enumerator
DEPTH_FIRST
BREADTH_FIRST
KRUSKAL
PRIM
DIJKSTRA
ASTAR
SPANNING_TREE
MIN_SPANNING_TREE
COMPONENT
CUT
PATH
MIN_PATH
MIN_PATH_TREE

enum Designar::Sign

strong

Enumerator
NEGATIVE
POSITIVE
ZERO

Function Documentation

template<typename T >

T Designar::abs

(

T

x

)

template<class GT , class Distance >

Distance::Type& Designar::ACC ( Node< GT > *  p )

inline

template<class GT >

void Designar::add_nodes_to_component_rec	(	const GT &	g,
		Node< GT > *	p,
		SLList< Node< GT > * > &	list
	)

template<class GT , class Distance >

MinPathArcInfo<GT, Distance>*& Designar::AI ( Arc< GT > *  a )

inline

template<class It , class Pred >

bool Designar::all_it	(	const It &	a,
		const It &	b,
		Pred &	pred
	)

template<class It , class Pred >

bool Designar::all_it	(	const It &	a,
		const It &	b,
		Pred &&	pred = Pred()
	)

template<class GT , class Distance >

void Designar::allocate_arc_info ( const GT &  g )

inline

template<class GT , class Distance >

void Designar::allocate_node_info ( const GT &  g )

inline

template<typename NumberType >

real_t Designar::area_of_parallelogram	(	const GenPoint2D< NumberType > &	a,
		const GenPoint2D< NumberType > &	b,
		const GenPoint2D< NumberType > &	c
	)

template<typename T >

T Designar::backward_prod	(	T	a,
		T	b
	)

template<class GT >

SLList< Node< GT > * > Designar::bf_topological_sort

(

const GT &

g

)

template<typename T , template< typename > class ArrayType, class Cmp = std::less<T>>

lint_t Designar::binary_search	(	const ArrayType< T > &	a,
		const T &	k,
		lint_t	l,
		lint_t	r,
		Cmp &	cmp
	)

template<typename T , template< typename > class ArrayType, class Cmp = std::less<T>>

lint_t Designar::binary_search ( const ArrayType< T > &  a, T &  k, lint_t  l, lint_t  r, Cmp &&  cmp = Cmp()  )

inline

template<typename T , template< typename > class ArrayType, class Cmp = std::less<T>>

lint_t Designar::binary_search ( const ArrayType< T > &  a, const T &  k, Cmp &  cmp  )

inline

template<typename T , template< typename > class ArrayType, class Cmp = std::less<T>>

lint_t Designar::binary_search ( const ArrayType< T > &  a, const T &  k, Cmp &&  cmp = Cmp()  )

inline

template<class GT >

Path< GT > Designar::breadth_first_search_path	(	const GT &	g,
		Node< GT > *	begin,
		Node< GT > *	end
	)

template<class GT , class Op >

void Designar::breadth_first_traverse	(	const GT &	g,
		Node< GT > *	begin,
		Op &	op
	)

template<class GT , class Op >

void Designar::breadth_first_traverse	(	const GT &	g,
		Node< GT > *	p,
		Op &&	op = Op()
	)

template<class GT , class Op >

void Designar::breadth_first_traverse	(	const GT &	g,
		Op &	op
	)

template<class GT , class Op >

void Designar::breadth_first_traverse	(	const GT &	g,
		Op &&	op = Op()
	)

template<class GT >

std::tuple< GT, SLList< Arc< GT > * > > Designar::build_cut_graph	(	const GT &	g,
		const SLList< Node< GT > * > &	cut_nodes
	)

template<class GT >

void Designar::build_cut_nodes_subgraph_rec	(	const GT &	,
		Node< GT > *	,
		const GT &	,
		lint_t
	)

template<class GT >

void Designar::build_cut_nodes_subgraph_rec	(	const GT &	g,
		Node< GT > *	p,
		GT &	t,
		lint_t	color
	)

template<class GT >

SLList< GT > Designar::build_cut_nodes_subgraphs

(

const GT &

g

)

template<class GT , class NodeInit , class ArcInit >

GT Designar::build_grid	(	nat_t	width,
		nat_t	height,
		NodeInit &	node_init,
		ArcInit &	arc_init,
		bool	with_diagonal = true
	)

template<class GT , class NodeInit = DftGridNodeInit<GT>, class ArcInit = DftGridArcInit<GT>>

GT Designar::build_grid	(	nat_t	width,
		nat_t	height,
		NodeInit &&	node_init = NodeInit(),
		ArcInit &&	arc_init = ArcInit(),
		bool	with_diagonal = true
	)

template<class GT >

void Designar::build_subgraph_rec	(	const GT &	,
		Node< GT > *	,
		const GT &
	)

template<class GT >

void Designar::build_subgraph_rec	(	const GT &	g,
		Node< GT > *	p,
		GT &	t
	)

template<class GT >

SLList< GT > Designar::compute_connected_components

(

const GT &

g

)

template<class GT >

SLList< Node< GT > * > Designar::compute_cut_nodes

(

const GT &

g

)

template<class GT >

std::tuple< SLList< GT >, GT, SLList< Arc< GT > * > > Designar::compute_cut_nodes_connected_components	(	const GT &	g,
		const SLList< Node< GT > * > &	cut_nodes
	)

template<class GT >

void Designar::compute_cut_nodes_rec	(	const GT &	,
		Node< GT > *	,
		Arc< GT > &	,
		SLList< Node< GT > * > &	,
		lint_t &
	)

template<class GT >

void Designar::compute_cut_nodes_rec	(	const GT &	g,
		Node< GT > *	p,
		Arc< GT > *	a,
		SLList< Node< GT > * > &	l,
		lint_t &	cdf
	)

template<class GT >

SLList< SLList< Node< GT > * > > Designar::connected_components_node_list

(

const GT &

g

)

template<class RkNode >

nat_t& Designar::COUNT ( RkNode *  p )

inline

template<typename T >

T Designar::count_combinations	(	T	n,
		T	r
	)

template<typename T >

T Designar::count_permutations	(	T	n,
		T	r
	)

template<class GT >

Path< GT > Designar::depth_first_search_path	(	const GT &	g,
		Node< GT > *	begin,
		Node< GT > *	end
	)

template<class GT >

bool Designar::depth_first_search_path_rec	(	const GT &	g,
		Node< GT > *	p,
		Node< GT > *	end,
		Path< GT > &	path
	)

template<class GT , class Op >

void Designar::depth_first_traverse	(	const GT &	g,
		Op &	op
	)

template<class GT , class Op >

void Designar::depth_first_traverse	(	const GT &	g,
		Op &&	op = Op()
	)

template<class GT , class Op >

void Designar::depth_first_traverse_prefix	(	const GT &	g,
		Op &	op
	)

template<class GT , class Op >

void Designar::depth_first_traverse_prefix	(	const GT &	g,
		Op &&	op = Op()
	)

template<class GT , class Op >

void Designar::depth_first_traverse_prefix_rec	(	const GT &	g,
		Node< GT > *	p,
		Op &	op
	)

template<class GT , class Op >

void Designar::depth_first_traverse_sufix	(	const GT &	g,
		Op &	op
	)

template<class GT , class Op >

void Designar::depth_first_traverse_sufix	(	const GT &	g,
		Op &&	op = Op()
	)

template<class GT , class Op >

void Designar::depth_first_traverse_sufix_rec	(	const GT &	g,
		Node< GT > *	p,
		Op &	op
	)

template<class GT , class Distance >

void Designar::destroy_arc_info

(

const GT &

g

)

template<class GT , class Distance >

void Designar::destroy_node_info

(

const GT &

g

)

template<class GT >

lint_t& Designar::df ( Node< GT > *  p )

inline

template<class GT >

SLList< Node< GT > * > Designar::df_topological_sort

(

const GT &

g

)

template<class It1 , class It2 , class Eq >

bool Designar::equal_it	(	const It1 &	a1,
		const It1 &	b1,
		const It2 &	a2,
		const It2 &	b2,
		Eq &	eq
	)

template<class It1 , class It2 , class Eq >

bool Designar::equal_it	(	const It1 &	a1,
		const It1 &	b1,
		const It2 &	a2,
		const It2 &	b2,
		Eq &&	eq = Eq()
	)

template<class It , class Pred >

bool Designar::exists_it	(	const It &	a,
		const It &	b,
		Pred &	pred
	)

template<class It , class Pred >

bool Designar::exists_it	(	const It &	a,
		const It &	b,
		Pred &&	pred = Pred()
	)

template<typename T >

T Designar::factorial

(

T

n

)

template<typename BT , typename ET >

BT Designar::fast_integral_pow	(	BT	base,
		ET	exp
	)

template<class It , class ContainerRet , class Pred >

ContainerRet Designar::filter_it	(	const It &	a,
		const It &	b,
		Pred &	pred
	)

template<class ContainerRet , class It , class Pred >

ContainerRet Designar::filter_it	(	const It &	a,
		const It &	b,
		Pred &&	pred = Pred()
	)

template<typename RetT , class It , class Op >

RetT Designar::fold_it	(	const It &	a,
		const It &	b,
		const RetT &	init_value,
		Op &	op
	)

template<typename RetT , class It , class Op >

RetT Designar::fold_it	(	const It &	a,
		const It &	b,
		const RetT &	init_value,
		Op &&	op = Op()
	)

template<typename RetT , class It , class Op >

RetT Designar::fold_it	(	const It &	a,
		const It &	b,
		RetT &&	init_value,
		Op &	op
	)

template<typename RetT , class It , class Op >

RetT Designar::fold_it	(	const It &	a,
		const It &	b,
		RetT &&	init_value,
		Op &&	op = Op()
	)

template<class It , class Op >

void Designar::for_each_it	(	const It &	a,
		const It &	b,
		Op &	op
	)

template<class It , class Op >

void Designar::for_each_it	(	const It &	a,
		const It &	b,
		Op &&	op = Op()
	)

template<typename T >

T Designar::forward_prod	(	T	a,
		T	b
	)

template<class GT , class NodeInit , class ArcInit >

GT Designar::full_graph	(	nat_t	num_nodes,
		NodeInit &	node_init,
		ArcInit &	arc_init
	)

template<class GT , class NodeInit = DftNodeInit<GT>, class ArcInit = DftArcInit<GT>>

GT Designar::full_graph	(	nat_t	num_nodes,
		NodeInit &&	node_init = NodeInit(),
		ArcInit &&	arc_init = ArcInit()
	)

template<class GT , class Distance , class Heap >

Arc<GT>* Designar::get_from_heap

(

Heap &

h

)

rng_seed_t Designar::get_random_seed

(

)

template<class GT >

bool Designar::has_cycle	(	const GT &	g,
		Node< GT > *	start
	)

template<class GT >

bool Designar::has_cycle

(

const GT &

g

)

template<typename Key , typename Value , typename Fct >

nat_t Designar::hash_fct_wrapper ( Fct  fct, const MapKey< Key, Value > &  p  )

inline

template<typename SeqType , class Cmp = std::less<typename SeqType::ItemType>>

void Designar::inline_sort ( SeqType &  s, Cmp &  cmp  )

inline

template<typename SeqType , class Cmp = std::less<typename SeqType::ItemType>>

void Designar::inline_sort ( SeqType &  s, Cmp &&  cmp = Cmp()  )

inline

template<class ArrayType , class Cmp >

void Designar::insertion_sort	(	ArrayType &	a,
		lint_t	l,
		lint_t	r,
		Cmp &	cmp
	)

template<class ArrayType , class Cmp = std::less<typename ArrayType::DataType>>

void Designar::insertion_sort ( ArrayType &  a, lint_t  l, lint_t  r, Cmp &&  cmp = Cmp()  )

inline

template<class ArrayType , class Cmp >

void Designar::insertion_sort ( ArrayType &  a, lint_t  size, Cmp &  cmp  )

inline

template<class ArrayType , class Cmp = std::less<typename ArrayType::DataType>>

void Designar::insertion_sort ( ArrayType &  a, lint_t  size, Cmp &&  cmp = Cmp()  )

inline

template<class ArrayType , class Cmp >

void Designar::insertion_sort ( ArrayType &  a, Cmp &  cmp  )

inline

template<class ArrayType , class Cmp = std::less<typename ArrayType::DataType>>

void Designar::insertion_sort ( ArrayType &  a, Cmp &&  cmp = Cmp()  )

inline

template<class GT >

GT Designar::invert_digraph	(	const GT &	,
		bool
	)

template<class GT >

GT Designar::invert_digraph

(

const GT &

g

)

template<class GT >

bool Designar::is_acyclique	(	const GT &	g,
		Node< GT > *	start
	)

template<class GT >

bool Designar::is_acyclique

(

const GT &

g

)

template<class GT >

bool Designar::is_graph_acyclique	(	const GT &	,
		Node< GT > *
	)

template<class GT >

bool Designar::is_graph_acyclique

(

const GT &

)

template<class GT , class Distance >

bool& Designar::IS_IN_QUEUE ( Arc< GT > *  a )

inline

template<typename T >

bool Designar::is_negative

(

T

n

)

template<typename T >

bool Designar::is_positive

(

T

n

)

template<class It , class Cmp >

bool Designar::is_sorted_it	(	const It &	a,
		const It &	b,
		Cmp &	cmp
	)

template<class It , class Cmp >

bool Designar::is_sorted_it	(	const It &	a,
		const It &	b,
		Cmp &&	cmp = Cmp()
	)

template<typename Key , typename Value >

Key& Designar::key

(

MapKey< Key, Value > &

item

)

template<typename Key , typename Value >

const Key& Designar::key

(

const MapKey< Key, Value > &

item

)

template<typename Key , typename Value >

Key Designar::key

(

MapKey< Key, Value > &&

item

)

template<typename Key , typename Value >

Key& Designar::key

(

MapKey< Key, Value > *

item_ptr

)

template<class BinTreeNode >

BinTreeNode::KeyType& Designar::KEY ( BinTreeNode *  p )

inline

template<class GT >

void Designar::Kosaraju_build_subgraph_rec	(	const GT &	,
		Node< GT > *	,
		const GT &	,
		nat_t
	)

template<class GT >

void Designar::Kosaraju_build_subgraph_rec	(	const GT &	inv_g,
		Node< GT > *	p,
		GT &	sg,
		nat_t	num
	)

template<class GT >

SLList< GT > Designar::Kosaraju_compute_strong_connected_components

(

const GT &

g

)

template<class BinTreeNode >

BinTreeNode*& Designar::L ( BinTreeNode *  p )

inline

template<class GT >

lint_t& Designar::low ( Node< GT > *  p )

inline

template<class SG , class TG = SG>

void Designar::map_arcs	(	Arc< SG > *	a,
		Arc< TG > *	b
	)

void Designar::map_graph_item ( CommonNodeArc *  x, CommonNodeArc *  y  )

inline

template<class ContainerRet , class It , class Op , class Pred >

ContainerRet Designar::map_if_it	(	const It &	a,
		const It &	b,
		Op &	op,
		Pred &	pred
	)

template<class ContainerRet , class It , class Op , class Pred >

ContainerRet Designar::map_if_it	(	const It &	a,
		const It &	b,
		Op &	op,
		Pred &&	pred = Pred()
	)

template<class ContainerRet , class It , class Op , class Pred >

ContainerRet Designar::map_if_it	(	const It &	a,
		const It &	b,
		Op &&	op,
		Pred &	pred
	)

template<class ContainerRet , class It , class Op , class Pred >

ContainerRet Designar::map_if_it	(	const It &	a,
		const It &	b,
		Op &&	op = Op(),
		Pred &&	pred = Pred()
	)

template<class ContainerRet , class It , class Op >

ContainerRet Designar::map_it	(	const It &	a,
		const It &	b,
		Op &	op
	)

template<class ContainerRet , class It , class Op >

ContainerRet Designar::map_it	(	const It &	a,
		const It &	b,
		Op &&	op = Op()
	)

template<typename... Args>

auto Designar::map_item

(

Args &&...

args

)

-> decltype(std::make_pair(std::forward<Args>(args)...))

template<typename... Args>

auto Designar::map_key

(

Args &&...

args

)

-> decltype(std::make_pair(std::forward<Args>(args)...))

template<class SG , class TG = SG>

void Designar::map_nodes	(	Node< SG > *	p,
		Node< TG > *	q
	)

template<class SG , class TG = SG>

TG::Arc* Designar::mapped_arc

(

Arc< SG > *

a

)

template<class SG , class TG = SG>

TG::Node* Designar::mapped_node

(

Node< SG > *

p

)

template<class GT , class Distance >

MinPathNodeInfo<GT, Distance>*& Designar::NI ( Node< GT > *  p )

inline

template<class It , class Pred >

bool Designar::none_it	(	const It &	a,
		const It &	b,
		Pred &	pred
	)

template<class It , class Pred >

bool Designar::none_it	(	const It &	a,
		const It &	b,
		Pred &&	pred = Pred()
	)

template<typename RetT , class It >

RetT & Designar::nth_it	(	const It &	a,
		const It &	b,
		nat_t	pos
	)

template<typename RetT , class It >

RetT * Designar::nth_ptr_it	(	const It &	a,
		const It &	b,
		nat_t	pos
	)

template<typename T >

bool Designar::num_equal	(	T	a,
		T	b
	)

template<>

bool Designar::num_equal< double >	(	double	,
		double
	)

template<>

bool Designar::num_equal< float >	(	float	,
		float
	)

template<>

bool Designar::num_equal< long double >	(	long	double,
		long	double
	)

template<class GT , class NodeInit , class ArcInit >

GT Designar::p_random_graph	(	nat_t	num_nodes,
		real_t	prob_arc,
		bool	grant_connectivity,
		NodeInit &	node_init,
		ArcInit &	arc_init
	)

template<class GT , class NodeInit = DftNodeInit<GT>, class ArcInit = DftArcInit<GT>>

GT Designar::p_random_graph	(	nat_t	num_nodes,
		real_t	prob_arc,
		bool	grant_connectivity = false,
		NodeInit &&	node_init = NodeInit(),
		ArcInit &&	arc_init = ArcInit()
	)

template<class GT >

void Designar::paint_cut_nodes_connected_components_rec	(	const GT &	g,
		Node< GT > *	p,
		lint_t	c
	)

template<class GT >

lint_t Designar::paint_cut_nodes_subgraphs	(	const GT &	g,
		const SLList< Node< GT > * > &	l
	)

template<class GT >

void Designar::paint_from_cut_node	(	const GT &	g,
		Node< GT > *	p,
		lint_t &	color
	)

template<typename ArrayType , class Cmp >

lint_t Designar::partition	(	ArrayType &	a,
		lint_t	l,
		lint_t	r,
		Cmp &	cmp
	)

template<typename T , class Cmp >

std::tuple< NodeSLList< T >, typename NodeSLList< T >::Node *, NodeSLList< T > > Designar::partition	(	NodeSLList< T > &	l,
		Cmp &	cmp
	)

template<class Cmp >

std::tuple< DL, DL *, DL > Designar::partition	(	DL &	l,
		Cmp &	cmp
	)

template<class GT , class Distance >

Distance::Type& Designar::POT ( Arc< GT > *  a )

inline

template<typename BT , typename ET >

BT Designar::pow	(	BT	base,
		ET	exp
	)

template<class TreapNode >

rng_seed_t& Designar::PRIOR ( TreapNode *  p )

inline

template<class GT , class NodeInit , class ArcInit >

GT Designar::ps_random_graph	(	nat_t	num_nodes,
		real_t	prob_arc,
		rng_seed_t	seed,
		bool	grant_connectivity,
		NodeInit &	node_init,
		ArcInit &	arc_init
	)

template<class GT , class NodeInit = DftNodeInit<GT>, class ArcInit = DftArcInit<GT>>

GT Designar::ps_random_graph	(	nat_t	num_nodes,
		real_t	prob_arc,
		rng_seed_t	seed,
		bool	grant_connectivity = false,
		NodeInit &&	node_init = NodeInit(),
		ArcInit &&	arc_init = ArcInit()
	)

template<class GT , class Distance , class Heap >

void Designar::put_in_heap	(	Arc< GT > *	a,
		Node< GT > *	t,
		Heap &	h
	)

template<typename ArrayType , class Cmp >

void Designar::quicksort	(	ArrayType &	a,
		lint_t	l,
		lint_t	r,
		Cmp &	cmp
	)

template<typename T , class Cmp >

void Designar::quicksort	(	NodeSLList< T > &	l,
		Cmp &	cmp
	)

template<class Cmp >

void Designar::quicksort	(	DL &	l,
		Cmp &	cmp
	)

template<class ArrayType , class Cmp = std::less<typename ArrayType::DataType>>

void Designar::quicksort ( ArrayType &  a, lint_t  l, lint_t  r, Cmp &&  cmp = Cmp()  )

inline

template<class ArrayType , class Cmp >

void Designar::quicksort ( ArrayType &  a, lint_t  size, Cmp &  cmp  )

inline

template<class ArrayType , class Cmp = std::less<typename ArrayType::DataType>>

void Designar::quicksort ( ArrayType &  a, lint_t  size, Cmp &&  cmp = Cmp()  )

inline

template<class ArrayType , class Cmp >

void Designar::quicksort ( ArrayType &  a, Cmp &  cmp  )

inline

template<class ArrayType , class Cmp = std::less<typename ArrayType::DataType>>

void Designar::quicksort ( ArrayType &  a, Cmp &&  cmp = Cmp()  )

inline

template<typename T , class Cmp = std::less<T>>

void Designar::quicksort ( FixedArray< T > &  a, Cmp &  cmp  )

inline

template<typename T , class Cmp = std::less<T>>

void Designar::quicksort ( FixedArray< T > &  a, Cmp &&  cmp = Cmp()  )

inline

template<typename T , class Cmp = std::less<T>>

void Designar::quicksort ( DynArray< T > &  a, Cmp &  cmp  )

inline

template<typename T , class Cmp = std::less<T>>

void Designar::quicksort ( DynArray< T > &  a, Cmp &&  cmp = Cmp()  )

inline

template<typename T , class Cmp = std::less<T>>

void Designar::quicksort ( NodeSLList< T > &  l, Cmp &&  cmp = Cmp()  )

inline

template<class Cmp >

void Designar::quicksort ( DL &  l, Cmp &&  cmp = Cmp()  )

inline

template<typename T , class Cmp >

void Designar::quicksort ( DLNode< T > &  l, Cmp &  cmp  )

inline

template<typename T , class Cmp = std::less<T>>

void Designar::quicksort ( DLNode< T > &  l, Cmp &&  cmp = Cmp()  )

inline

template<typename T , class Cmp >

void Designar::quicksort ( DLList< T > &  l, Cmp &  cmp  )

inline

template<typename T , class Cmp = std::less<T>>

void Designar::quicksort ( DLList< T > &  l, Cmp &&  cmp = Cmp()  )

inline

template<class BinTreeNode >

BinTreeNode*& Designar::R ( BinTreeNode *  p )

inline

real_t Designar::random

(

rng_t &

)

bool Designar::random_Bernoulli	(	rng_t &	,
		real_t	p = DEFAULT_P
	)

nat_t Designar::random_binomial	(	rng_t &	,
		nat_t	,
		real_t	p = DEFAULT_P
	)

template<class GT , class NodeInit , class ArcInit >

GT Designar::random_graph	(	nat_t	num_nodes,
		nat_t	num_arcs,
		rng_seed_t	seed,
		NodeInit &	node_init,
		ArcInit &	arc_init
	)

template<class GT , class NodeInit = DftNodeInit<GT>, class ArcInit = DftArcInit<GT>>

GT Designar::random_graph	(	nat_t	num_nodes,
		nat_t	num_arcs,
		rng_seed_t	seed,
		NodeInit &&	node_init = NodeInit(),
		ArcInit &&	arc_init = ArcInit()
	)

template<class GT , class NodeInit = DftNodeInit<GT>, class ArcInit = DftArcInit<GT>>

GT Designar::random_graph	(	nat_t	num_nodes,
		nat_t	num_arcs,
		NodeInit &&	node_init = NodeInit(),
		ArcInit &&	arc_init = ArcInit()
	)

template<typename T >

T Designar::random_uniform	(	rng_t &	rng,
		T	max
	)

template<typename T >

T Designar::random_uniform	(	rng_t &	rng,
		T	l,
		T	r
	)

template<typename T >

Range<T> Designar::range	(	T	f,
		T	l,
		T	s = T(1)
	)

template<typename T >

Range<T> Designar::range

(

T

l

)

template<typename T >

bool Designar::real_equal	(	T	a,
		T	b
	)

template<class It , class Pred >

bool Designar::remove_first_if_it	(	const It &	a,
		const It &	b,
		Pred &	pred
	)

template<class It , class Pred >

bool Designar::remove_first_if_it	(	const It &	a,
		const It &	b,
		Pred &&	pred = Pred()
	)

template<class It , class Pred >

void Designar::remove_if_it	(	const It &	a,
		const It &	b,
		Pred &	pred
	)

template<class It , class Pred >

void Designar::remove_if_it	(	const It &	a,
		const It &	b,
		Pred &&	pred = Pred()
	)

template<class ArrayType >

ArrayType Designar::reverse

(

const ArrayType &

a

)

template<class SRCL , class TGTL >

TGTL Designar::reverse

(

const SRCL &

l

)

template<typename T >

FixedArray<T> Designar::reverse ( const FixedArray< T > &  a )

inline

template<typename T >

DynArray<T> Designar::reverse ( const DynArray< T > &  a )

inline

template<typename T >

SLList<T> Designar::reverse ( const SLList< T > &  l )

inline

template<typename T >

DLList<T> Designar::reverse ( const DLList< T > &  l )

inline

template<typename RetT , class It , class Pred >

RetT * Designar::search_ptr_it	(	const It &	a,
		const It &	b,
		Pred &	pred
	)

template<typename RetT , class It , class Pred >

RetT * Designar::search_ptr_it	(	const It &	a,
		const It &	b,
		Pred &&	pred = Pred()
	)

template<typename ArrayType , class Cmp >

lint_t Designar::select_pivot ( ArrayType &  a, lint_t  l, lint_t  r, Cmp &  cmp  )

inline

template<typename T , template< typename > class ArrayType, class Cmp = std::less<T>>

lint_t Designar::sequential_search	(	const ArrayType< T > &	a,
		const T &	k,
		lint_t	l,
		lint_t	r,
		Cmp &	cmp
	)

template<typename T , template< typename > class ArrayType, class Cmp = std::less<T>>

lint_t Designar::sequential_search	(	const ArrayType< T > &	a,
		const T &	k,
		lint_t	l,
		lint_t	r,
		Cmp &&	cmp = Cmp()
	)

template<typename T , template< typename > class ArrayType, class Cmp = std::less<T>>

lint_t Designar::sequential_search	(	const ArrayType< T > &	a,
		const T &	k,
		Cmp &	cmp
	)

template<typename T , template< typename > class ArrayType, class Cmp = std::less<T>>

lint_t Designar::sequential_search	(	const ArrayType< T > &	a,
		const T &	k,
		Cmp &&	cmp = Cmp()
	)

template<typename T , class Cmp >

void Designar::sift_down	(	T *	a,
		nat_t	l,
		nat_t	r,
		Cmp &	cmp
	)

template<typename T , class Cmp >

void Designar::sift_down ( T *  a, nat_t  l, nat_t  r, Cmp &&  cmp = Cmp()  )

inline

template<typename T , class Cmp >

void Designar::sift_up	(	T *	a,
		nat_t	l,
		nat_t	r,
		Cmp &	cmp
	)

template<typename T , class Cmp >

void Designar::sift_up ( T *  a, nat_t  l, nat_t  r, Cmp &&  cmp = Cmp()  )

inline

template<typename T >

Sign Designar::sign

(

T

n

)

template<typename SeqType , class Cmp = std::less<typename SeqType::ItemType>>

SeqType Designar::sort ( const SeqType &  s, Cmp &  cmp  )

inline

template<typename SeqType , class Cmp = std::less<typename SeqType::ItemType>>

SeqType Designar::sort ( const SeqType &  s, Cmp &&  cmp = Cmp()  )

inline

template<typename ContainerType = DynArray<std::string>>

ContainerType Designar::split_string	(	const std::string &	str,
		const std::string &	sep
	)

nat_t Designar::super_fast_hash	(	void *	,
		nat_t
	)

nat_t Designar::super_fast_hash ( const char *  key )

inline

nat_t Designar::super_fast_hash ( const std::string &  key )

inline

template<typename Key >

nat_t Designar::super_fast_hash ( const Key &  key )

inline

template<typename First , typename Second >

nat_t Designar::super_fast_hash ( const std::pair< First, Second > &  p )

inline

template<class GT >

bool Designar::test_cycle_rec	(	const GT &	g,
		Node< GT > *	p,
		bool	has
	)

nat_t Designar::throw_dice	(	rng_t &	,
		nat_t	num_faces = DEFAULT_DICE_NUM_FACES
	)

template<typename T , class It >

DynArray< T > Designar::to_array_it	(	const It &	a,
		const It &	b
	)

template<class ContainerType , class It >

ContainerType Designar::to_container	(	const It &	a,
		const It &	b
	)

template<typename T , class It >

SLList< T > Designar::to_list_it	(	const It &	a,
		const It &	b
	)

template<class GT >

SLList< SLList< Node< GT > * > > Designar::topological_ranks

(

const GT &

g

)

template<class GT , class Distance >

Arc<GT>*& Designar::TREE_ARC ( Arc< GT > *  a )

inline

template<class GT , class Distance >

Node<GT>*& Designar::TREE_NODE ( Node< GT > *  p )

inline

template<class HeapNode >

HeapNode*& Designar::U ( HeapNode *  p )

inline

template<typename Key , typename Value >

Value& Designar::value

(

MapKey< Key, Value > &

item

)

template<typename Key , typename Value >

const Value& Designar::value

(

const MapKey< Key, Value > &

item

)

template<typename Key , typename Value >

Value Designar::value

(

MapKey< Key, Value > &&

item

)

template<typename Key , typename Value >

Value& Designar::value

(

MapKey< Key, Value > *

item_ptr

)

template<typename T1 , typename T2 , class It1 , class It2 >

SLList< std::pair< T1, T2 > > Designar::zip_eq_it	(	const It1 &	a1,
		const It1 &	b1,
		const It2 &	a2,
		const It2 &	b2
	)

template<typename T1 , typename T2 , class It1 , class It2 >

SLList< std::pair< T1, T2 > > Designar::zip_it	(	const It1 &	a1,
		const It1 &	b1,
		const It2 &	a2,
		const It2 &	b2
	)

template<typename T1 , typename T2 , class It1 , class It2 >

SLList< std::pair< T1, T2 > > Designar::zip_left_it	(	const It1 &	a1,
		const It1 &	b1,
		const It2 &	a2,
		const It2 &	b2
	)

template<typename T1 , typename T2 , class It1 , class It2 >

SLList< std::pair< T1, T2 > > Designar::zip_right_it	(	const It1 &	a1,
		const It1 &	b1,
		const It2 &	a2,
		const It2 &	b2
	)

Variable Documentation

constexpr nat_t Designar::DEFAULT_DICE_NUM_FACES = 6

constexpr real_t Designar::DEFAULT_P = 0.5

constexpr real_t Designar::EPSILON = 1e-9

constexpr real_t Designar::INF = std::numeric_limits<real_t>::infinity()

constexpr lint_t Designar::NUM_BITS = 64

constexpr real_t Designar::PI = 3.1415926535897932384626433832795028841971693993751

constexpr real_t Designar::PI3_2 = 3.*PI/2.

constexpr real_t Designar::PI_2 = PI/2.

constexpr real_t Designar::PI_4 = PI/4.

constexpr lint_t Designar::QuicksortThreshold = 40