Graphs

Collaboration diagram for Graphs:

Modules
	C++20 Concepts for Graph Iterators
	These concepts define the interface contracts for Aleph-w graph iterators.

Files
file	ah-graph-concepts.H
	C++20 concepts for the protocol shared by graph algorithms.
file	aleph-graph.H
	Simplified graph interface for common use cases.
file	archeap.H
	Arc heap for graph algorithms.
file	AStar.H
	A* shortest path algorithm.
file	Bellman_Ford.H
	Bellman-Ford algorithm for single-source shortest paths.
file	Bidirectional_BFS.H
	Bidirectional BFS for shortest unweighted path.
file	Blossom_Weighted.H
	Maximum-weight matching in general undirected graphs.
file	cookie_guard.H
	RAII guards for graph node/arc cookies.
file	Dial.H
	Dial's algorithm for shortest paths with small integer weights.
file	Dijkstra.H
	Dijkstra's shortest path algorithm.
file	Dominators.H
	Dominator and post-dominator tree computation via the Lengauer-Tarjan algorithm.
file	euclidian-graph-common.H
	Common utilities for Euclidean graphs.
file	eulerian.H
	Eulerian graph detection and path/cycle finding.
file	Floyd_Warshall.H
	Floyd-Warshall algorithm for all-pairs shortest paths.
file	generate_df_tree.H
	Depth-first tree visualization with DFS numbering.
file	generate_graph.H
	Graph visualization and output generation utilities.
file	generate_spanning_tree_picture.H
	Spanning tree visualization with highlighted tree/non-tree edges.
file	graph-dry.H
	Graph base classes and common utilities via CRTP.
file	graph-traverse-generators.H
	Lazy (coroutine-based) graph traversal (DFS, BFS).
file	graph-traverse.H
	Graph traversal algorithms (DFS, BFS).
file	Graph_Coloring.H
	Graph coloring algorithms and heuristics.
file	graph_to_tree.H
	Convert spanning tree graphs to Tree_Node structures.
file	grid.H
	2D grid graph generation with 8-connectivity.
file	hamiltonian.H
	Hamiltonian sufficiency testing for graphs.
file	HLD.H
	Heavy-Light Decomposition for tree path queries on Aleph graphs.
file	IDA_Star.H
	IDA* (Iterative Deepening A*) shortest path algorithm.
file	io_graph.H
	Graph serialization and deserialization utilities.
file	Johnson.H
	Johnson's algorithm for all-pairs shortest paths.
file	K_Shortest_Paths.H
	K-shortest path algorithms (Yen and Eppstein-style API).
file	Karger.H
	Karger's randomized min-cut algorithm.
file	Karger_Stein.H
	Karger-Stein randomized min-cut algorithm (alias for Karger.H fast method).
file	kosaraju.H
	Kosaraju's algorithm for finding strongly connected components.
file	Kruskal.H
	Kruskal's minimum spanning tree algorithm.
file	latex_floyd.H
	Floyd-Warshall algorithm with LaTeX output generation.
file	LCA.H
	Lowest Common Ancestor (LCA) on rooted trees represented as Aleph graphs.
file	load_digraph.H
	Utilities for loading directed graphs from pipe-separated files.
file	mat_path.H
	Path reconstruction from Floyd-Warshall path matrices.
file	Min_Cost_Matching.H
	Minimum-cost matching in general undirected graphs.
file	Min_Mean_Cycle.H
	Minimum mean cycle in directed graphs (Karp algorithm).
file	net_apps.H
	Network flow applications.
file	net_utils.H
	Network flow utilities: generators, visualization, serialization.
file	Planarity_Test.H
	Planarity testing on Aleph graphs.
file	Prim.H
	Prim's algorithm for minimum spanning trees.
file	random_graph.H
	Random graph generation utilities.
file	random_net.H
	Random network flow graph generation.
file	shortest_path_common.H
	Common utilities and base class for shortest path algorithms.
file	single_graph.H
	Single graph utilities.
file	Stoer_Wagner.H
	Stoer-Wagner deterministic min-cut algorithm.
file	Tarjan.H
	Tarjan's algorithm for strongly connected components.
file	topological_sort.H
	Topological sorting algorithms for directed acyclic graphs (DAGs).
file	tpl_agraph.H
	Array-based graph implementation.
file	tpl_bipartite.H
	Bipartite graph detection and 2-coloring.
file	tpl_components.H
	Graph connectivity and connected components.
file	tpl_cut_nodes.H
	Articulation points (cut nodes), bridges, and biconnected components.
file	tpl_euclidian_graph.H
	Euclidean graph with 2D coordinates.
file	tpl_find_path.H
	Path finding algorithms in graphs.
file	tpl_graph.H
	Generic graph and digraph implementations.
file	tpl_graph_indexes.H
	Graph node and arc indexing.
file	tpl_graph_utils.H
	Utility algorithms and operations for graphs.
file	tpl_indexArc.H
	Arc indexing for fast lookup by endpoint nodes.
file	tpl_indexGraph.H
	Graph indexing utilities for O(log n) node/arc lookup.
file	tpl_indexNode.H
	Node indexing for fast O(log n) lookup by key.
file	tpl_kgraph.H
	K-connected graph structures and connectivity algorithms.
file	tpl_matgraph.H
	Adjacency matrix representations for graphs.
file	tpl_maxflow.H
	Advanced maximum flow algorithms.
file	tpl_mincost.H
	Advanced minimum cost flow algorithms.
file	tpl_mo_on_trees.H
	Mo's algorithm on trees: offline subtree and path queries.
file	tpl_net.H
	Network flow graph structures.
file	tpl_net_sup_dem.H
	Supply-demand network flow algorithms.
file	tpl_netcapgraph.H
	Network flow graph with capacities.
file	tpl_sgraph.H
	Simple graph implementation with adjacency lists.
file	tpl_spanning_tree.H
	Spanning tree generation algorithms.
file	tpl_test_acyclique.H
	DAG (acyclic) graph testing.
file	tpl_test_connectivity.H
	Graph connectivity testing.
file	tpl_test_cycle.H
	Cycle detection in graphs.
file	tpl_test_path.H
	Path existence testing.
file	Tree_Decomposition.H
	Heavy-Light and Centroid decomposition on rooted trees represented as Aleph graphs.
file	Two_Sat.H
	2-SAT solver based on Tarjan's SCC algorithm.
file	warshall.H
	Warshall's algorithm for transitive closure.
file	xml_graph.H
	XML serialization for graphs.
file	Zero_One_BFS.H
	0-1 BFS shortest path algorithm.

Concepts
concept	Aleph::MoTreeGraph
	Concept constraining a graph type usable for Mo on Trees.

Classes
class	Aleph::Bit_Fields
	Bit fields for nodes and arcs used for marking visit state during processing. More...
struct	Aleph::Graph_Attr
	General attributes for nodes and arc of graphs. More...
struct	Aleph::Zero_Heuristic< GT, Distance >
	Default heuristic for A* (zero heuristic, degrades to Dijkstra). More...
class	Aleph::AStar_Min_Path< GT, Distance, Heuristic, Itor, SA, HeapT >
	A* algorithm for finding the shortest path between two nodes. More...
struct	Aleph::Euclidean_Heuristic< GT, Distance >
	Euclidean distance heuristic for A* in 2D grids. More...
struct	Aleph::Manhattan_Heuristic< GT, Distance >
	Manhattan distance heuristic for A* in grid graphs. More...
class	Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >
	Bellman-Ford algorithm for shortest paths with negative weights. More...
struct	Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::Sni
struct	Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::Ni
struct	Aleph::Bellman_Ford_Negative_Cycle< GT, Distance, Ait, NAit, SA >
	Detects if a negative cycle exists and eventually computes it. More...
class	Aleph::Bidirectional_BFS< GT, Fwd_Itor, Bck_Itor, SA >
	Bidirectional BFS for finding shortest unweighted paths. More...
struct	Aleph::Bidirectional_BFS< GT, Fwd_Itor, Bck_Itor, SA >::BFS_Info
class	Aleph::Bidirectional_BFS< GT, Fwd_Itor, Bck_Itor, SA >::BiBFS_Init_Guard
	RAII guard for BiBFS initialization and cleanup. More...
class	Aleph::Compute_Maximum_Cardinality_General_Matching< GT, SA >
	Functor wrapper for maximum cardinality general matching. More...
struct	Aleph::Blossom_Weighted_Result< Weight_Type >
	Result of weighted matching. More...
class	Aleph::Compute_Maximum_Weight_General_Matching< GT, Weight, SA >
	Functor wrapper for weighted blossom matching. More...
class	Aleph::Cookie_Guard< GT >
	RAII guard that clears graph cookies on destruction. More...
class	Aleph::Cookie_Saver< GT >
	RAII guard that saves and restores graph cookies. More...
class	Aleph::Scope_Guard< GT, Cleanup >
	Generic RAII scope guard for cleanup operations on graphs. More...
class	Aleph::Dial_Min_Paths< GT, Distance, Itor, SA >
	Dial's algorithm for shortest paths with integer weights. More...
struct	Aleph::Dial_Min_Paths< GT, Distance, Itor, SA >::Node_Info
class	Aleph::Dial_Min_Paths< GT, Distance, Itor, SA >::Dial_Init_Guard
	RAII guard for Dial initialization and cleanup. More...
class	Aleph::Dijkstra_Min_Paths< GT, Distance, Itor, SA, HeapT >
	Spanning tree calculation of all shortest paths from a given node according to Dijkstra's algorithm. More...
class	Aleph::Test_Eulerian< GT, SN, SA >
	Tests whether a graph or digraph is Eulerian. More...
class	Aleph::Find_Eulerian_Path< GT, SN, SA >
	Finds and constructs an Eulerian path or cycle using Hierholzer's algorithm. More...
struct	Aleph::Find_Eulerian_Path< GT, SN, SA >::Result
	Result type: path and its classification. More...
class	Aleph::Floyd_All_Shortest_Paths< GT, Distance, SA >
	Compute the all-pairs shortest path distance matrix and the path reconstruction matrix for a graph g using the Floyd-Warshall algorithm. More...
struct	Aleph::To_Graphviz< GT, Node_Attr, Arc_Attr, SN, SA >
	Functor class for generating Graphviz DOT specifications. More...
struct	Aleph::Generate_Graphviz< GT, Write_Node, Write_Arc, Shade_Node, Shade_Arc, Dashed_Node, Dashed_Arc, SA, SN >
	Functor for generating Graphviz specifications. More...
struct	GTNodeIterator< GT >
	Common node iterator for graph having its node derived from Dlink class. More...
struct	GTArcIterator< GT >
	Common arc iterator for graph having its arcs derived from Dlink class. More...
struct	Cmp_Dlink_Node< GT, Cmp >
	Used internally for some graphs for compare their nodes. More...
struct	Cmp_Dlink_Arc< GT, Cmp >
	Used internally for some graphs for compare their arcs. More...
class	GTNodeCommon< NodeInfo >
	Common attributes and methods for nodes (vertexes) belonging to graphs. More...
class	GTArcCommon< ArcInfo >
	Common methods for the arc of a graph. More...
class	GraphCommon< GT, Node, Arc >
	Common methods to the Aleph-w ( \(\aleph_\omega\)) graph classes. More...
struct	GraphCommon< GT, Node, Arc >::In_Filt
	Filter for input arcs of a node. More...
struct	GraphCommon< GT, Node, Arc >::Out_Filt
	Filter for output arcs of a node. More...
class	GraphCommon< GT, Node, Arc >::Digraph_Iterator< Filter >
	Special iterator for distinguishing input arcs of output ones. More...
struct	GraphCommon< GT, Node, Arc >::In_Iterator
	Alias for Digraph_Iterator More...
struct	GraphCommon< GT, Node, Arc >::Out_Iterator
class	Aleph::Digraph< BaseGraph >
	Generic directed graph (digraph) wrapper template. More...
class	Aleph::Graph_Traverse_Generator< GT, Itor, Q, Show_Arc >
	Lazily traverse a graph depth-first or breadth-first. More...
class	Graph_Traverse< GT, Itor, Q, Show_Arc >
	Traverse a graph depth-first or breadth-first and execute a visit function. More...
class	Aleph::Greedy_Coloring< GT, SA >
	Functor wrapper for greedy_coloring. More...
class	Aleph::Welsh_Powell_Coloring< GT, SA >
	Functor wrapper for welsh_powell_coloring. More...
class	Aleph::DSatur_Coloring< GT, SA >
	Functor wrapper for dsatur_coloring. More...
class	Aleph::Graph_To_Tree_Node< GT, Key, Convert, SA >
	Functor class to convert a tree graph to Tree_Node structure. More...
class	Aleph::Build_Grid< GT, Operation_On_Node, Operation_On_Arc >
	Functor to build a 2D grid graph with 8-connectivity. More...
class	Aleph::Test_Hamiltonian_Sufficiency< GT, SN, SA >
	Tests Ore's sufficient condition for Hamiltonian graphs. More...
class	Aleph::Test_Dirac_Condition< GT, SN, SA >
	Tests Dirac's sufficient condition for Hamiltonian graphs. More...
class	Aleph::Gen_HLD< GT, T, Op, SA >
	Heavy-Light Decomposition with segment tree for path/subtree queries. More...
struct	Aleph::HLD_Sum< GT, T, SA >
	HLD with path/subtree sum queries. More...
struct	Aleph::HLD_Max< GT, T, SA >
	HLD with path/subtree max queries. More...
struct	Aleph::HLD_Min< GT, T, SA >
	HLD with path/subtree min queries. More...
struct	Aleph::Hungarian_Result< Cost_Type >
	Result of the Hungarian assignment algorithm. More...
struct	Aleph::Chebyshev_Heuristic< GT, Distance >
	Chebyshev (L-infinity) distance heuristic for 8-connected grids. More...
class	Aleph::IDA_Star< GT, Distance, Heuristic, Itor, SA >
	IDA* algorithm for memory-efficient shortest path search. More...
struct	Aleph::IDA_Star< GT, Distance, Heuristic, Itor, SA >::SearchResult
struct	Aleph::Dft_Store_Node< GT >
	Default node storage functor for binary and text modes. More...
struct	Aleph::Dft_Store_Arc< GT >
	Default arc storage functor for binary and text modes. More...
struct	Aleph::Dft_Load_Node< GT >
	Default node loading functor for binary and text modes. More...
struct	Aleph::Dft_Load_Arc< GT >
	Default arc loading functor for binary and text modes. More...
class	Aleph::IO_Graph< GT, Load_Node, Store_Node, Load_Arc, Store_Arc, NF, AF >
	Graph serialization and deserialization class. More...
class	Aleph::Johnson< GT, Distance, Ait, NAit, SA >
	Johnson's algorithm for all-pairs shortest paths. More...
struct	Aleph::Johnson< GT, Distance, Ait, NAit, SA >::Reweighted_Dist
struct	Aleph::K_Shortest_Path_Item< GT, Cost_Type >
	A shortest-path item returned by k-shortest algorithms. More...
class	Aleph::Yen_K_Shortest_Paths< GT, Distance, SA >
	Functor wrapper for Yen's k-shortest loopless paths algorithm. More...
class	Aleph::Eppstein_K_Shortest_Paths< GT, Distance, SA >
	Functor wrapper for Eppstein-style k-shortest paths API. More...
class	Aleph::Karger_Min_Cut< GT, SA >
	Karger's randomized minimum cut algorithm. More...
class	Aleph::Karger_Min_Cut< GT, SA >::ArcIndex
	Arc index with O(1) operations and deterministic ordering. More...
struct	Aleph::Kosaraju_Connected_Components< GT >
	Functor wrapper for Kosaraju's algorithm. More...
class	Aleph::Kruskal_Min_Spanning_Tree< GT, Distance, SA >
	Computes the minimum spanning tree of a graph using Kruskal's algorithm. More...
struct	Aleph::Kruskal_Min_Spanning_Tree< GT, Distance, SA >::Init_Node
	Helper struct for initializing node counters during DFS. More...
struct	Aleph::Kruskal_Min_Spanning_Tree< GT, Distance, SA >::Paint_Filt< G, GT_SA >
	Filter for arcs painted by Kruskal's algorithm. More...
class	Aleph::Gen_Binary_Lifting_LCA< GT, SA >
	LCA via binary lifting on a rooted tree. More...
class	Aleph::Gen_Euler_RMQ_LCA< GT, SA >
	LCA via Euler tour + RMQ on depth in a rooted tree. More...
struct	Aleph::Equal_Node
	Functor to compare nodes by their ID. More...
class	Aleph::Find_Min_Path< Mat >
	Functor wrapper for find_min_path. More...
struct	Aleph::Min_Cost_Matching_Result< Cost_Type >
	Result of minimum-cost matching. More...
struct	Aleph::Min_Cost_Perfect_Matching_Result< Cost_Type >
	Result of minimum-cost perfect matching. More...
class	Aleph::Compute_Minimum_Cost_General_Matching< GT, Cost, SA >
	Functor wrapper for minimum-cost general matching. More...
class	Aleph::Compute_Minimum_Cost_Perfect_General_Matching< GT, Cost, SA >
	Functor wrapper for minimum-cost perfect general matching. More...
struct	Aleph::Min_Mean_Cycle_Result< GT, Cost_Type >
	Result of minimum mean cycle computation. More...
struct	Aleph::Min_Mean_Cycle_Value_Result
	Lightweight minimum-mean-cycle value result. More...
class	Aleph::Karp_Minimum_Mean_Cycle< GT, Distance, SA >
	Functor wrapper for Karp minimum mean cycle. More...
class	Aleph::Karp_Minimum_Mean_Cycle_Value< GT, Distance, SA >
	Functor wrapper for value-only minimum mean cycle. More...
struct	Aleph::Planarity_Test_Options
	Configuration options for planarity testing and auxiliary outputs. More...
struct	Aleph::Planarity_Test_Result< GT >
	Complete result of a planarity test execution. More...
struct	Aleph::Planarity_Test_Result< GT >::Rotation_Entry
	Entry in a combinatorial rotation system. More...
struct	Aleph::Planarity_Test_Result< GT >::Edge_Witness
	Description of an edge participating in a witness. More...
struct	Aleph::Planarity_Test_Result< GT >::Path_Witness
	Description of a path participating in a Kuratowski witness. More...
struct	Aleph::Planar_Dual_Edge_Info< GT >
	Dual-edge payload linked to a primal simplified edge. More...
struct	Aleph::Planar_Dual_Metadata< GT >
	Metadata extracted from a planar embedding for face/dual analysis. More...
struct	Aleph::Planar_Dual_Metadata< GT >::Face_Dart
struct	Aleph::Planar_Dual_Metadata< GT >::Face_Boundary
struct	Aleph::Planar_Geometric_Drawing_Options
	Options for embedding-aware 2D drawing extraction. More...
struct	Aleph::Planar_Geometric_Drawing< GT >
	Embedding-aware geometric drawing result. More...
struct	Aleph::Planar_Geometric_Drawing< GT >::Node_Position
struct	Aleph::NonPlanar_Certificate_Export_Options
	Export options for non-planar certificate serializers. More...
struct	Aleph::NonPlanar_Certificate_Validation< GT >
	Structural validation report for non-planar certificates. More...
struct	Aleph::Dft_Certificate_Node_Label< GT >
	Default node labeler for certificate export. More...
class	Aleph::Planarity_Test< GT, SA >
	Functor wrapper for planarity_test(). More...
class	Aleph::Is_Planar_Graph< GT, SA >
	Functor wrapper for is_planar_graph(). More...
class	Aleph::Prim_Min_Spanning_Tree< GT, Distance, SA >
	Computes the minimum spanning tree of a graph using Prim's algorithm. More...
struct	Aleph::Dft_Init_Rand_Node< GT >
	Default node initializer for random graph generation. More...
struct	Aleph::Dft_Init_Rand_Arc< GT >
	Default arc initializer for random graph generation. More...
class	Aleph::Random_Graph< GT, Init_Node, Init_Arc >
	Random undirected graph generator. More...
class	Aleph::Random_Digraph< GT, Init_Node, Init_Arc >
	Random directed graph (digraph) generator. More...
class	Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >
	Base class providing common infrastructure for shortest path algorithms. More...
struct	Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::Arc_Info
	Information stored in arc cookies for painting version. More...
struct	Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::Tree_Arc_Info
	Extended arc info with tree arc mapping. More...
struct	Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::Node_Info
	Information stored in node cookies for painting version. More...
struct	Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::Tree_Node_Info
	Extended node info with tree node mapping. More...
struct	Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::Heap_Info
	Functor to access heap node handle from node cookie. More...
struct	Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::Get_Potential_Arc
	Functor to get arc potential for heap ordering. More...
struct	Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::Initialize_Node
	Node initialization for painting version. More...
struct	Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::Initialize_Arc
	Arc initialization for painting version. More...
struct	Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::Initialize_Tree_Node
	Node initialization for tree-building version. More...
struct	Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::Initialize_Tree_Arc
	Arc initialization for tree-building version. More...
struct	Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::Destroy_Node
	Node cleanup for painting version. More...
struct	Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::Destroy_Arc
	Arc cleanup for painting version. More...
struct	Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::Destroy_Tree_Node
	Node cleanup and mapping for tree-building version. More...
struct	Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::Destroy_Tree_Arc
	Arc cleanup and mapping for tree-building version. More...
struct	Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::Total
	Distance totalizer class for path copying. More...
class	Aleph::Test_Single_Graph< GT, SN, SA >
	Determines whether a graph or digraph is simple. More...
class	Aleph::Stoer_Wagner_Min_Cut< GT, Distance, SA >
	Stoer-Wagner deterministic minimum cut algorithm. More...
struct	Aleph::Stoer_Wagner_Min_Cut< GT, Distance, SA >::SWNode
struct	Aleph::Stoer_Wagner_Min_Cut< GT, Distance, SA >::PQEntry
class	Aleph::Compute_Cycle_In_Digraph< GT, Itor, SA >
	Determines if a digraph contains a cycle and constructs it. More...
class	Aleph::Topological_Sort< GT, Itor, SA >
	Computes topological ordering using depth-first search. More...
class	Aleph::Q_Topological_Sort< GT, Itor, SA >
	Computes topological ordering using breadth-first search (Kahn's algorithm). More...
class	Aleph::Graph_Anode< Node_Info >
	Node of Array_Graph More...
class	Aleph::Compute_Bipartite< GT, SA >
	Class that takes a bipartite graph and computes the partition sets. More...
class	Aleph::Compute_Maximum_Cardinality_Bipartite_Matching< GT, Max_Flow, SA >
	Class for computing the maximum cardinality matching of a bipartite graph. More...
class	Aleph::Hopcroft_Karp_Matching< GT, SA >
	Functor wrapper for hopcroft_karp_matching. More...
class	Aleph::Build_Subgraph< GT, SA >
	Build a mapped subgraph from a graph starting at a given node. More...
class	Aleph::Unconnected_Components< GT, SA >
	Compute the connected components of a graph. More...
class	Aleph::Compute_Bridges< GT, SA >
	Find bridge edges (isthmuses) of a connected undirected graph. More...
class	Aleph::Euclidian_Node< Node_Info >
class	Aleph::Find_Path_Depth_First< GT, Itor, SA >
	Performs a depth-first search for a path between a pair of nodes. More...
class	Aleph::Find_Path_Breadth_First< GT, Itor, SA >
	Performs a breadth-first search for a path between a pair of nodes. More...
class	Aleph::Directed_Find_Path< GT, Itor, SA >
	Path search on directed graphs defined through a graph class (not a digraph). More...
struct	Aleph::Graph_Node< __Node_Info >
	Node belonging to a graph implemented with a double linked adjacency list. More...
struct	Aleph::Graph_Arc< _Arc_Info >
	Arc of graph implemented with double-linked adjacency lists. More...
class	Aleph::List_Graph< _Graph_Node, _Graph_Arc >
	Graph implemented with double-linked adjacency lists. More...
struct	Aleph::List_Graph< _Graph_Node, _Graph_Arc >::Node_Iterator
	Node iterator. More...
class	Aleph::List_Graph< _Graph_Node, _Graph_Arc >::Node_Arc_Iterator
	Iterator on the arcs of a graph. More...
struct	Aleph::List_Graph< _Graph_Node, _Graph_Arc >::Arc_Iterator
	Iterator on all arcs of a graph. More...
struct	Aleph::Dft_Show_Arc< GT >
	Default filter for filtered iterators on arcs. More...
struct	Aleph::Node_Arc_Iterator< GT, Show_Arc >
	Filtered iterator of adjacent arcs of a node. More...
struct	Aleph::Arc_Iterator< GT, Show_Arc >
	Filtered iterator on all the arcs of a graph. More...
struct	Aleph::Dft_Show_Node< GT >
	Default filter for the graph nodes. More...
class	Aleph::Node_Iterator< GT, Show_Node >
	Filtered iterator on the nodes of a graph. More...
class	Aleph::__Out_Filt< GT >
	Filter the outcoming arcs. More...
class	Aleph::__In_Filt< GT >
	Filter the incoming arcs. More...
class	Aleph::Digraph_Iterator< GT, Filter >
	Filtered iterator on directed graphs. More...
class	Aleph::Out_Iterator< GT, Show_Arc >
	Filtered iterator for outcoming arcs of a node. More...
class	Aleph::In_Iterator< GT, SA >
	Filtered iterator for incoming arcs of a node. More...
class	Aleph::Operate_On_Nodes< GT, Operation, SN >
	Functor that traverses the nodes of a graph and performs an operation. More...
class	Aleph::Operate_On_Arcs< GT, Operation, SA >
	Functor that traverses the arcs of a graph and performs an operation. More...
class	Aleph::Path< GT >
	Path on a graph. More...
struct	Aleph::Path< GT >::Path_Desc
class	Aleph::Path< GT >::Iterator
	Iterator on nodes and arcs of a path. More...
struct	Aleph::Dft_Copy_Node< GTT, GTS >
	Default copy node functor. More...
struct	Aleph::Dft_Copy_Arc< GTT, GTS >
	Default copy arc functor. More...
class	Aleph::Copy_Graph< GT, SN, SA >
	Filtered copy of graphs. More...
struct	Aleph::Painted_Min_Spanning_Tree< GT, Distance >
	Filter of painter arcs with that are set the Spanning_Tree control bit. More...
class	Aleph::GraphCopyWithMapping< GT, Tree >
	Graph copy with explicit node mapping. More...
class	Aleph::Nodes_Index< GT, Compare, Tree, SN >
	Builds a node index for fast lookup and retrieval. More...
class	Aleph::Arcs_Index< GT, Compare, Tree, SA >
	Builds an arc index for fast lookup by source/target nodes. More...
struct	Aleph::Default_Visit_Op< GT >
	Default visit operation for traversals (never stops). More...
class	Aleph::Depth_First_Traversal< GT, Operation, SA >
	Stateful depth-first traversal functor. More...
class	Aleph::Breadth_First_Traversal< GT, Operation, SA >
	Stateful breadth-first traversal functor. More...
struct	Aleph::Distance_Compare< GT, Distance >
	Comparison functor for arc weights/distances. More...
class	Aleph::Invert_Digraph< GT, SA >
	Functor for computing the transposed digraph, filtering arcs. More...
class	Aleph::Dft_Dist< GT >
	Default distance accessor for arc weights. More...
class	Aleph::Total_Cost< GT, Distance, SA >
	Compute the total cost (sum of arc weights) of a graph. More...
class	Aleph::IndexArc< GT, Tree, SA >
	Index for fast arc lookup by its endpoint nodes. More...
struct	Aleph::IndexArc< GT, Tree, SA >::Cmp_Arc
class	Aleph::Index_Graph< GT, Compare, Tree >
	Builds node and arc indices for fast lookup and retrieval. More...
class	Aleph::Edge_Connectivity< GT, Max_Flow >
	Functor wrapper for edge_connectivity(). More...
class	Aleph::Compute_Min_Cut< GT, Max_Flow, SA >
	Functor wrapper for compute_min_cut(). More...
class	Aleph::Map_Matrix_Graph< GT, SA >
	Adjacency matrix mapped to an adjacency list graph. More...
struct	Aleph::Map_Matrix_Graph< GT, SA >::Mat_Entry
class	Aleph::Matrix_Graph< GT, SA >
	Adjacency matrix storing copies of graph attributes. More...
class	Aleph::Ady_Mat< GT, __Entry_Type, SA >
	Auxiliary adjacency matrix with custom entry type. More...
class	Aleph::Bit_Mat_Graph< GT, SA >
	Bit matrix for graph connectivity. More...
struct	Aleph::Bit_Mat_Graph< GT, SA >::Proxy
	Proxy for bit access. More...
class	Aleph::Gen_Mo_On_Trees< GT, Policy >
	Offline subtree and path queries on trees via Mo's algorithm. More...
class	Aleph::Net_Sup_Dem_Node< Node_Info, F_Type >
	Node with supply/demand flow value. More...
class	Aleph::Net_Sup_Dem_Graph< NodeT, ArcT >
	Network graph with supply and demand nodes. More...
struct	Aleph::Graph_Snode< Node_Info >
	Node for graphs implemented with simple adjacency lists. More...
class	Aleph::Graph_Sarc< Arc_Info >
	Arc for graphs implemented with simple adjacency lists. More...
class	Aleph::List_SGraph< __Graph_Node, __Graph_Arc >
	Graph class implemented with singly-linked adjacency lists. More...
class	Aleph::List_SGraph< __Graph_Node, __Graph_Arc >::Node_Iterator
	Node iterator for a graph. More...
class	Aleph::List_SGraph< __Graph_Node, __Graph_Arc >::Node_Arc_Iterator
	Arc iterator for a graph node. More...
class	Aleph::List_SGraph< __Graph_Node, __Graph_Arc >::Arc_Iterator
	Iterator over arcs of a graph. More...
class	Aleph::Find_Depth_First_Spanning_Tree< GT, SA >
	Compute a depth-first spanning tree of a graph. More...
class	Aleph::Find_Breadth_First_Spanning_Tree< GT, SA >
	Compute a breadth-first spanning tree of a graph. More...
class	Aleph::Build_Spanning_Tree< GT >
	Build a spanning tree from an array of arcs. More...
class	Aleph::Is_Graph_Acyclique< GT, SA >
	Determines whether a graph is acyclic (contains no cycles). More...
class	Aleph::Has_Cycle< GT, SA >
	Determines whether a graph contains cycles. More...
class	Test_Connectivity< GT, SA >
	Determines if a graph g is connected. More...
class	Aleph::Test_For_Cycle< GT, SA >
	Test whether a cycle is reachable from a given node. More...
class	Aleph::Test_For_Path< GT, SA >
	Checks whether a path exists between two nodes. More...
class	Fixed_Relation
	Binary relation between a set of integers. More...
class	Relation
	Binary relation between a set of integers. More...
class	Relation_T< T, Compare >
	Binary relation between a set of items. More...
struct	Relation_T< T, Compare >::Pair
struct	Relation_T< T, Compare >::Cmp
class	Aleph::Gen_Heavy_Light_Decomposition< GT, SA >
	Heavy-Light Decomposition over a rooted tree represented as an Aleph graph. More...
class	Aleph::Gen_HLD_Path_Query< GT, T, Op, SA >
	Segment-tree-powered path/subtree queries over an HLD layout. More...
class	Aleph::Gen_Centroid_Decomposition< GT, SA >
	Centroid decomposition over a rooted tree represented as an Aleph graph. More...
class	Aleph::Warshall_Compute_Transitive_Clausure< GT, SA >
	Computes the transitive closure of a graph using Warshall's algorithm. More...
class	Aleph::Zero_One_BFS< GT, Distance, Itor, SA >
	0-1 BFS algorithm for shortest paths in graphs with 0/1 weights. More...
struct	Aleph::Zero_One_BFS< GT, Distance, Itor, SA >::Node_Info
struct	Aleph::Zero_One_BFS< GT, Distance, Itor, SA >::Painted_Info
	Stores parent and distance after painting for O(1) access. More...
class	Aleph::Zero_One_BFS< GT, Distance, Itor, SA >::ZOB_Init_Guard
	RAII guard for Zero_One_BFS initialization and cleanup. More...
class	Aleph::Lengauer_Tarjan_Dominators< GT, SA >
	Computes dominator tree and dominance frontiers of a digraph using the Lengauer-Tarjan algorithm. More...
class	Aleph::Lengauer_Tarjan_Post_Dominators< GT, SA >
	Computes post-dominator tree and post-dominance frontiers of a digraph using the Lengauer-Tarjan algorithm on the reversed graph. More...
class	Aleph::Tarjan_Connected_Components< GT, Itor, SA >
	Computes strongly connected components (SCCs) in a directed graph using Tarjan's algorithm. More...
class	Aleph::IndexNode< GT, Compare, Tree, SN >
	Builds an index of nodes for fast search and retrieval. More...

Macros
#define	NODE_BITS(p)   ((p)->attrs.control_bits)
	Get the control bits of a node.
#define	NODE_COUNTER(p)   ((p)->attrs.counter)
	Get the counter of a node.
#define	NODE_COLOR(p)   ((p)->attrs.counter)
	Synonymous of NODE_COUNTER.
#define	IS_NODE_VISITED(p, bit)   (NODE_BITS(p).get_bit(bit))
	Determine whether the control bit is set or not to one.
#define	NODE_COOKIE(p)   ((p)->attrs.cookie)
	Return the node cookie
#define	ARC_COUNTER(p)   ((p)->attrs.counter)
	Return the counter of arc p.
#define	ARC_COLOR(p)   ((p)->attrs.counter)
	Return the color of arc p.
#define	ARC_BITS(p)   ((p)->attrs.control_bits)
	Return the control bits of arc p.
#define	IS_ARC_VISITED(p, bit)   (ARC_BITS(p).get_bit(bit))
	Determine whether the bit field is or not set to one.
#define	ARC_COOKIE(p)   ((p)->attrs.cookie)
	Return the arc cookie
#define	ALEPH_GRAPH_COPY_MOVE_CTORS(GraphClass)
	Macro to generate copy/move constructors and assignment operators.

Typedefs
template<typename __Graph_Node = Graph_Anode<int>, typename __Graph_Arc = Graph_Aarc<int>>
using	Aleph::Array_Digraph = Digraph< Array_Graph< __Graph_Node, __Graph_Arc > >
	Directed graph (digraph) implemented with array-based adjacency lists.
template<typename __Graph_Node = Graph_Node<int>, typename __Graph_Arc = Graph_Arc<int>>
using	Aleph::List_Digraph = Digraph< List_Graph< __Graph_Node, __Graph_Arc > >
	Directed graph (digraph) implemented with double-linked adjacency lists.
template<class GT >
using	Aleph::ArcPair = std::tuple< typename GT::Arc *, typename GT::Node * >
	Alias used for encapsulating a pair of arc and node (related between them).
template<class GT >
using	Aleph::_Out_Iterator = Digraph_Iterator< GT, __Out_Filt< GT > >
	Basic iterator for outcoming arcs of a node.
template<class GT >
using	Aleph::_In_Iterator = Digraph_Iterator< GT, __In_Filt< GT > >
	Basic iterator for incoming arcs of a node.
template<class GT >
using	Aleph::Distinct_Count_Mo_On_Trees = Gen_Mo_On_Trees< GT, Distinct_Count_Policy< typename GT::Node::Node_Type > >
	Mo on Trees specialised for counting distinct node values.
template<class GT >
using	Aleph::Powerful_Array_Mo_On_Trees = Gen_Mo_On_Trees< GT, Powerful_Array_Policy< typename GT::Node::Node_Type > >
	Mo on Trees specialised for the "powerful array" query.
template<class GT >
using	Aleph::Range_Mode_Mo_On_Trees = Gen_Mo_On_Trees< GT, Range_Mode_Policy< typename GT::Node::Node_Type > >
	Mo on Trees specialised for range mode queries.
template<typename __Graph_Node = Graph_Snode<int>, typename __Graph_Arc = Graph_Sarc<int>>
using	Aleph::List_SDigraph = Digraph< List_SGraph< __Graph_Node, __Graph_Arc > >
	Directed graph (digraph) implemented with simple adjacency lists.

Enumerations
enum	Aleph::Graph_Bits {   Aleph::Depth_First , Aleph::Breadth_First , Aleph::Test_Cycle , Aleph::Find_Path ,   Aleph::Euler , Aleph::Maximum_Flow , Aleph::Spanning_Tree , Aleph::Build_Subtree ,   Aleph::Convert_Tree , Aleph::Cut , Aleph::Min , Aleph::Num_Bits_Graph }
	Bit numbers of nodes or arcs. More...
enum class	Aleph::Planarity_Certificate_Type { Aleph::Planarity_Certificate_Type::None , Aleph::Planarity_Certificate_Type::K5_Subdivision , Aleph::Planarity_Certificate_Type::K33_Subdivision , Aleph::Planarity_Certificate_Type::Minimal_NonPlanar_Obstruction }
	Non-planarity witness classification. More...

Functions
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
size_t	Aleph::compute_maximum_cardinality_general_matching (const GT &g, DynDlist< typename GT::Arc * > &matching, SA sa=SA())
	Computes a maximum cardinality matching in a general graph.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
size_t	Aleph::blossom_maximum_cardinality_matching (const GT &g, DynDlist< typename GT::Arc * > &matching, SA sa=SA())
	Alias of compute_maximum_cardinality_general_matching().
template<AlephGraph GT, class Weight = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
Blossom_Weighted_Result< long long >	Aleph::compute_maximum_weight_general_matching (const GT &g, DynDlist< typename GT::Arc * > &matching, Weight weight=Weight(), SA sa=SA(), const bool max_cardinality=false)
	Compute maximum-weight matching in a general undirected graph.
template<AlephGraph GT, class Weight = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
Blossom_Weighted_Result< long long >	Aleph::blossom_maximum_weight_matching (const GT &g, DynDlist< typename GT::Arc * > &matching, Weight weight=Weight(), SA sa=SA(), const bool max_cardinality=false)
	Alias for compute_maximum_weight_general_matching().
template<class GT , class Func >
auto	Aleph::with_clean_cookies (GT &g, Func &&func) -> decltype(func())
	Convenience function to run an algorithm with automatic cookie cleanup.
template<class GT , class Func >
auto	Aleph::with_saved_cookies (GT &g, Func &&func) -> decltype(func())
	Convenience function to run an algorithm preserving existing cookies.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
DynList< std::pair< typename GT::Node *, typename GT::Node * > >	Aleph::compute_dominators (GT &g, typename GT::Node *root, SA sa=SA())
	Compute immediate dominators of a digraph from a root node.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
void	Aleph::build_dominator_tree (GT &g, typename GT::Node *root, GT &tree, SA sa=SA())
	Build the dominator tree of a digraph.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
DynMapTree< typename GT::Node *, DynSetTree< typename GT::Node * > >	Aleph::compute_dominance_frontiers (GT &g, typename GT::Node *root, SA sa=SA())
	Compute dominance frontiers of a digraph.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
DynList< std::pair< typename GT::Node *, typename GT::Node * > >	Aleph::compute_post_dominators (const GT &g, typename GT::Node *exit_node, SA sa=SA())
	Compute immediate post-dominators of a digraph from an exit node.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
void	Aleph::build_post_dominator_tree (const GT &g, typename GT::Node *exit_node, GT &tree, SA sa=SA())
	Build the post-dominator tree of a digraph.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
DynMapTree< typename GT::Node *, DynSetTree< typename GT::Node * > >	Aleph::compute_post_dominance_frontiers (const GT &g, typename GT::Node *exit_node, SA sa=SA())
	Compute post-dominance frontiers of a digraph.
template<AlephGraph GT, class Key >
void	write_df_low_tree (GT &g, typename GT::Node *src, std::ofstream &f)
	Generate a DFS tree picture with low-link values.
template<AlephGraph GT, class Write_Node , class Write_Arc , class Shade_Node , class Shade_Arc , ArcFilter< GT > SA>
void	Aleph::generate_graphpic (const GT &g, const double &xdist, const double &ydist, std::ostream &output)
	Generate a graphpic specification for graph visualization.
template<AlephGraph GT, class Write_Node , class Write_Arc , class Shade_Node , class Shade_Arc , class Dashed_Node , class Dashed_Arc , ArcFilter< GT > SA, NodeFilter< GT > SN>
void	Aleph::generate_graphviz (const GT &g, std::ostream &output, const std::string &rankdir="TB", float ranksep=0.2, float nodesep=0.2)
	Generate a Graphviz DOT specification for graph visualization.
template<AlephGraph GT, class Node_Attr , class Arc_Attr , NodeFilter< GT > SN, ArcFilter< GT > SA>
void	Aleph::generate_graphviz (const GT &g, std::ostream &out, Node_Attr node_attr=Node_Attr(), Arc_Attr arc_attr=Arc_Attr(), const std::string &rankdir="TB")
	Generate Graphviz DOT output with custom attribute functors.
template<AlephGraph GT, class Node_Attr , class Arc_Attr , NodeFilter< GT > SN, ArcFilter< GT > SA>
void	Aleph::digraph_graphviz (const GT &g, std::ostream &out, Node_Attr node_attr=Node_Attr(), Arc_Attr arc_attr=Arc_Attr(), const std::string &rankdir="LR")
	Generate Graphviz DOT output specifically for digraphs.
template<AlephGraph GT, class Node_Attr , class Arc_Attr , NodeFilter< GT > SN, ArcFilter< GT > SA>
size_t	Aleph::rank_graphviz (const GT &g, std::ostream &out, Node_Attr node_attr=Node_Attr(), Arc_Attr arc_attr=Arc_Attr(), const std::string &rankdir="LR")
	Generate Graphviz DOT output with topological ranking.
template<AlephGraph GT, class Write_Node , class Write_Arc , class Shade_Node , class Shade_Arc , ArcFilter< GT > SA>
void	Aleph::generate_cross_graph (GT &g, const size_t &nodes_by_level, const double &xdist, const double &ydist, std::ostream &out)
	Generate a cross-graph layout specification for graphpic.
template<AlephGraph GT, class Write_Node , class Write_Arc , class Shade_Node , class Shade_Arc , ArcFilter< GT > SA>
void	Aleph::generate_net_graph (GT &g, const size_t &nodes_by_level, const double &xdist, const double &ydist, std::ostream &out)
	Generate a net-graph layout specification for graphpic.
template<AlephGraph GT, class Write_Node , class Write_Arc , ArcFilter< GT > SA>
void	generate_cross_spanning_tree (GT &g, const size_t &nodes_by_level, const double &xdist, const double &ydist, std::ofstream &output)
	Generate a cross-layout visualization of a spanning tree.
template<AlephGraph GT, class Write_Node , class Write_Arc , ArcFilter< GT > SA>
void	generate_net_spanning_tree (GT &g, const size_t &nodes_by_level, const double &xdist, const double &ydist, std::ofstream &output)
	Generate a net-layout visualization of a spanning tree.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
size_t	Aleph::greedy_coloring (const GT &g, DynMapTree< typename GT::Node *, size_t > &colors)
	Greedy graph coloring in iteration order.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
size_t	Aleph::welsh_powell_coloring (const GT &g, DynMapTree< typename GT::Node *, size_t > &colors)
	Welsh-Powell graph coloring.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
size_t	Aleph::dsatur_coloring (const GT &g, DynMapTree< typename GT::Node *, size_t > &colors)
	DSatur graph coloring (saturation-degree heuristic).
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
bool	Aleph::is_valid_coloring (const GT &g, const DynMapTree< typename GT::Node *, size_t > &colors)
	Validates a graph coloring.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
size_t	Aleph::chromatic_number (const GT &g, DynMapTree< typename GT::Node *, size_t > &colors)
	Computes the exact chromatic number of a small graph.
template<AlephGraph GT, typename Key , class Convert , ArcFilter< GT > SA = Dft_Show_Arc<GT>>
Tree_Node< Key > *	Aleph::graph_to_tree_node (GT &g, typename GT::Node *groot)
	Convert a tree graph to a Tree_Node structure.
template<typename Cost_Type >
Hungarian_Result< Cost_Type >	Aleph::hungarian_assignment (const DynMatrix< Cost_Type > &cost)
	Compute minimum-cost assignment (free function).
template<typename Cost_Type >
Hungarian_Result< Cost_Type >	Aleph::hungarian_max_assignment (const DynMatrix< Cost_Type > &cost)
	Compute maximum-profit assignment (free function).
template<AlephGraph GT, ArcDistance< GT > Distance = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>> requires std::is_arithmetic_v<typename Distance::Distance_Type>
DynList< K_Shortest_Path_Item< GT, typename Distance::Distance_Type > >	Aleph::yen_k_shortest_paths (const GT &g, typename GT::Node *source, typename GT::Node *target, const size_t k, Distance distance=Distance(), SA sa=SA())
	Compute k shortest loopless paths using Yen's algorithm.
template<AlephGraph GT, ArcDistance< GT > Distance = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>> requires std::is_arithmetic_v<typename Distance::Distance_Type>
DynList< K_Shortest_Path_Item< GT, typename Distance::Distance_Type > >	Aleph::eppstein_k_shortest_paths (const GT &g, typename GT::Node *source, typename GT::Node *target, const size_t k, Distance distance=Distance(), SA sa=SA())
	Compute k shortest general (loopy) paths.
template<AlephGraph GT>
void	Aleph::kosaraju_connected_components (const GT &g, DynList< GT > &blk_list, DynList< typename GT::Arc * > &arc_list)
	Compute strongly connected components using Kosaraju's algorithm.
template<AlephGraph GT>
DynList< DynList< typename GT::Node * > >	Aleph::kosaraju_connected_components (const GT &g)
	Compute strongly connected components as lists of nodes.
template<AlephGraph GT>
size_t	Aleph::kosaraju_scc_count (const GT &g)
	Count the number of strongly connected components.
template<AlephGraph GT>
bool	Aleph::is_strongly_connected (const GT &g)
	Check if a directed graph is strongly connected.
template<AlephGraph GT, class Compare , class Plus >
void	Aleph::floyd_all_shortest_paths (GT &g, Ady_Mat< GT, typename GT::Arc_Type::Distance_Type > &dist, Ady_Mat< GT, long > &path)
	Compute all-pairs shortest paths using Floyd-Warshall algorithm.
template<class Mat >
void	Aleph::find_min_path (Mat &p, const long src_index, const long tgt_index, Path< typename Mat::Graph_Type > &path)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Variant that accepts const indices.
template<class Mat >
void	Aleph::find_min_path (Mat &p, typename Mat::Node *src_node, typename Mat::Node *tgt_node, Path< typename Mat::Graph_Type > &path)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Reconstruct shortest path from path matrix using node pointers.
template<AlephGraph GT, class Compare , class Plus , template< class > class P_i, template< class > class P_ij, template< class > class D_ij>
void	Aleph::floyd_all_shortest_paths_latex (GT &g, Ady_Mat< GT, typename GT::Arc_Type::Distance_Type > &dist, Ady_Mat< GT, long > &path, std::ofstream &output)
	Floyd-Warshall algorithm with LaTeX step-by-step output.
void	Aleph::split (const std::string &text, const std::string &separators, DynDlist< std::string > &words)
	Split a text into tokens using a separator set.
Digrafo::Node *	Aleph::search_node (Digrafo &g, const std::string &s)
	Find or create a node by ID.
void	Aleph::load_digraph (Digrafo &g, std::istream &nodes_input, std::istream &arcs_input)
	Load nodes and arcs from streams into the directed graph.
void	Aleph::generate_dot_file (Digrafo &g, std::ostream &output)
	Generate a DOT representation of the digraph.
template<AlephGraph GT, class Cost = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
Min_Cost_Matching_Result< long long >	Aleph::compute_minimum_cost_general_matching (const GT &g, DynDlist< typename GT::Arc * > &matching, Cost cost=Cost(), SA sa=SA(), const bool max_cardinality=false)
	Compute minimum-cost matching in a general undirected graph.
template<AlephGraph GT, class Cost = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
Min_Cost_Matching_Result< long long >	Aleph::blossom_minimum_cost_matching (const GT &g, DynDlist< typename GT::Arc * > &matching, Cost cost=Cost(), SA sa=SA(), const bool max_cardinality=false)
	Alias for compute_minimum_cost_general_matching().
template<AlephGraph GT, class Cost = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
Min_Cost_Perfect_Matching_Result< long long >	Aleph::compute_minimum_cost_perfect_general_matching (const GT &g, DynDlist< typename GT::Arc * > &matching, Cost cost=Cost(), SA sa=SA())
	Compute minimum-cost perfect matching in a general undirected graph.
template<AlephGraph GT, class Cost = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
Min_Cost_Perfect_Matching_Result< long long >	Aleph::blossom_minimum_cost_perfect_matching (const GT &g, DynDlist< typename GT::Arc * > &matching, Cost cost=Cost(), SA sa=SA())
	Alias for compute_minimum_cost_perfect_general_matching().
template<AlephGraph GT, ArcDistance< GT > Distance = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
Min_Mean_Cycle_Result< GT, typename Distance::Distance_Type >	Aleph::karp_minimum_mean_cycle (const GT &g, Distance distance=Distance(), SA sa=SA())
	Compute minimum mean cycle by Karp's algorithm.
template<AlephGraph GT, ArcDistance< GT > Distance = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
Min_Mean_Cycle_Value_Result	Aleph::karp_minimum_mean_cycle_value (const GT &g, Distance distance=Distance(), SA sa=SA())
	Compute only the minimum mean value (without witness walk).
template<AlephGraph GT, ArcDistance< GT > Distance = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
Min_Mean_Cycle_Value_Result	Aleph::minimum_mean_cycle_value (const GT &g, Distance distance=Distance(), SA sa=SA())
	Alias for karp_minimum_mean_cycle_value().
template<AlephGraph GT, ArcDistance< GT > Distance = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
Min_Mean_Cycle_Result< GT, typename Distance::Distance_Type >	Aleph::minimum_mean_cycle (const GT &g, Distance distance=Distance(), SA sa=SA())
	Alias for karp_minimum_mean_cycle().
const char *	Aleph::to_string (const Planarity_Certificate_Type type) noexcept
	Return readable name for certificate type.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
Planarity_Test_Result< GT >	Aleph::planarity_test (const GT &g, SA sa=SA(), const Planarity_Test_Options &options=Planarity_Test_Options())
	Execute a comprehensive planarity test on an Aleph graph.
template<AlephGraph GT>
Planarity_Test_Result< GT >	Aleph::planarity_test (const GT &g, const Planarity_Test_Options &options)
	Overload with default arc selector.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
bool	Aleph::is_planar_graph (const GT &g, SA sa=SA(), const Planarity_Test_Options &options=Planarity_Test_Options())
	High-level boolean check for graph planarity.
template<AlephGraph GT>
bool	Aleph::is_planar_graph (const GT &g, const Planarity_Test_Options &options)
	Overload with default arc selector.
template<AlephGraph GT>
Planar_Dual_Metadata< GT >	Aleph::planar_dual_metadata (const Planarity_Test_Result< GT > &result)
	Build face and dual-edge metadata from a planar embedding result.
template<AlephGraph GT, class DGT = Default_Planar_Dual_Graph<GT>>
DGT	Aleph::build_planar_dual_graph (const Planar_Dual_Metadata< GT > &md)
	Build an Aleph dual graph from face/dual metadata.
template<AlephGraph GT, class DGT = Default_Planar_Dual_Graph<GT>>
DGT	Aleph::build_planar_dual_graph (const Planarity_Test_Result< GT > &result)
	Build an Aleph dual graph directly from a planarity result.
template<AlephGraph GT>
Planar_Geometric_Drawing< GT >	Aleph::planar_geometric_drawing (const Planarity_Test_Result< GT > &result, const Planar_Geometric_Drawing_Options &options=Planar_Geometric_Drawing_Options())
	Build embedding-aware 2D node coordinates from a planar result.
template<AlephGraph GT, class Node_Label = Dft_Certificate_Node_Label<GT>>
std::string	Aleph::nonplanar_certificate_to_json (const Planarity_Test_Result< GT > &result, Node_Label node_label=Node_Label(), const NonPlanar_Certificate_Export_Options &options=NonPlanar_Certificate_Export_Options())
	Export non-planar certificate as JSON.
template<AlephGraph GT, class Node_Label = Dft_Certificate_Node_Label<GT>>
std::string	Aleph::nonplanar_certificate_to_dot (const Planarity_Test_Result< GT > &result, Node_Label node_label=Node_Label(), const NonPlanar_Certificate_Export_Options &options=NonPlanar_Certificate_Export_Options())
	Export non-planar certificate as GraphViz DOT.
template<AlephGraph GT>
NonPlanar_Certificate_Validation< GT >	Aleph::validate_nonplanar_certificate (const Planarity_Test_Result< GT > &result)
	Validate structural consistency of a non-planar certificate.
template<AlephGraph GT>
bool	Aleph::nonplanar_certificate_is_valid (const Planarity_Test_Result< GT > &result)
	Convenience predicate over validate_nonplanar_certificate().
template<AlephGraph GT, class Node_Label = Dft_Certificate_Node_Label<GT>>
std::string	Aleph::nonplanar_certificate_to_graphml (const Planarity_Test_Result< GT > &result, Node_Label node_label=Node_Label(), const NonPlanar_Certificate_Export_Options &options=NonPlanar_Certificate_Export_Options())
	Export non-planar certificate as GraphML.
template<AlephGraph GT, class Node_Label = Dft_Certificate_Node_Label<GT>>
std::string	Aleph::nonplanar_certificate_to_gexf (const Planarity_Test_Result< GT > &result, Node_Label node_label=Node_Label(), const NonPlanar_Certificate_Export_Options &options=NonPlanar_Certificate_Export_Options())
	Export non-planar certificate as GEXF.
GT	Aleph::Random_Graph_Base< GT, Init_Node, Init_Arc >::sufficient_hamiltonian (const size_t &__num_nodes, const double &p=0.5)
	Create a random Hamiltonian graph.
GT	Aleph::Random_Graph< GT, Init_Node, Init_Arc >::sufficient_hamiltonian (const size_t &__num_nodes, const double &p=0.5)
	Create a random Hamiltonian graph.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
void	Aleph::compute_bipartite (const GT &g, DynDlist< typename GT::Node * > &l, DynDlist< typename GT::Node * > &r)
	Computes the partition sets of a bipartite graph.
template<AlephGraph GT, template< class > class Max_Flow = Ford_Fulkerson_Maximum_Flow, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
void	Aleph::compute_maximum_cardinality_bipartite_matching (const GT &g, DynDlist< typename GT::Arc * > &matching)
	Computes the maximum cardinality matching of a bipartite graph.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
bool	Aleph::compute_bipartite_all_components (const GT &g, DynDlist< typename GT::Node * > &l, DynDlist< typename GT::Node * > &r)
	Computes the partition sets of a bipartite graph handling all connected components.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
void	Aleph::hopcroft_karp_matching (const GT &g, DynDlist< typename GT::Arc * > &matching)
	Computes a maximum cardinality matching on a bipartite graph using the Hopcroft-Karp algorithm.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
DynList< typename GT::Arc * >	Aleph::find_bridges (const GT &g, typename GT::Node *start, SA sa=SA())
	Find all bridge edges in a connected undirected graph.
template<AlephGraph GT, NodeFilter< GT > SN = Dft_Show_Node<GT>, class Op > requires std::is_invocable_r_v<void, Op &, typename GT::Node *>
void	Aleph::for_each_node (const GT &g, Op operation, SN sn=SN())
	Traverse all the nodes of graph filtering some ones according to a condition and executing an operation on them.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>, class Op > requires std::is_invocable_r_v<void, Op &, typename GT::Arc *>
void	Aleph::for_each_arc (const GT &g, Op operation, SA sa=SA())
	Traverse all the arcs of graph filtering some ones according to a condition and executing an operation on them.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>, class Op > requires std::is_invocable_r_v<void, Op &, typename GT::Arc *>
void	Aleph::for_each_arc (const GT &g, typename GT::Node *p, Op operation, SA sa=SA())
	Traverse all the arcs adjacent to a node filtering some ones according to a condition and executing an operation on them.
template<AlephGraph GT, NodeFilter< GT > SN = Dft_Show_Node<GT>, class Op > requires std::is_invocable_r_v<bool, Op &, typename GT::Node *>
bool	Aleph::forall_node (const GT &g, Op cond, SN sn=SN())
	Return true if condition cond is met on every filtered node of the graph.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>, class Op > requires std::is_invocable_r_v<bool, Op &, typename GT::Arc *>
bool	Aleph::forall_arc (const GT &g, Op cond, SA sa=SA())
	Return true if condition cond is met on every filtered arc of the graph.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>, class Op > requires std::is_invocable_r_v<bool, Op &, typename GT::Arc *>
bool	Aleph::forall_arc (typename GT::Node *p, Op cond, SA sa=SA())
	Return true if the condition cond is met on every filtered arc of a node.
template<AlephGraph GT, typename T , template< typename > class Container = DynList, NodeFilter< GT > SN = Dft_Show_Node<GT>, class Op > requires std::is_invocable_r_v<T, Op &, typename GT::Node *>
Container< T >	Aleph::nodes_map (GT &g, Op transformation, SN sn=SN())
	Map the filtered nodes of a graph to a transformed type.
template<AlephGraph GT, typename T , template< typename > class Container = DynList, NodeFilter< GT > SN = Dft_Show_Node<GT>>
Container< T >	Aleph::nodes_map (GT &g, std::function< T(typename GT::Node *)> transformation, SN sn=SN())
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Compatibility overload for callers that pass an actual std::function<T (typename GT::Node *)> (rather than a lambda or other callable) and rely on T being deduced from it, as the generic overload above cannot: T appears only in its return type and requires clause, never in a parameter, so it is not a deduced context there.
template<AlephGraph GT, typename T , template< typename > class Container = DynList, ArcFilter< GT > SA = Dft_Show_Arc<GT>, class Op > requires std::is_invocable_r_v<T, Op &, typename GT::Arc *>
Container< T >	Aleph::arcs_map (GT &g, Op transformation, SA sa=SA())
	Map the filtered arcs of a graph to a transformed type.
template<AlephGraph GT, typename T , template< typename > class Container = DynList, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
Container< T >	Aleph::arcs_map (GT &g, std::function< T(typename GT::Arc *)> transformation, SA sa=SA())
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Compatibility overload deducing T from an actual std::function<T (typename GT::Arc *)> argument; see the equivalent nodes_map overload for why the generic one above cannot deduce it.
template<AlephGraph GT, typename T , template< typename > class Container = DynList, ArcFilter< GT > SA = Dft_Show_Arc<GT>, class Op > requires std::is_invocable_r_v<T, Op &, typename GT::Arc *>
Container< T >	Aleph::arcs_map (GT &g, typename GT::Node *p, Op transformation, SA sa=SA())
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Map the filtered arcs of a specific node in a graph to a transformed type.
template<AlephGraph GT, typename T , template< typename > class Container = DynList, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
Container< T >	Aleph::arcs_map (GT &g, typename GT::Node *p, std::function< T(typename GT::Arc *)> transformation, SA sa=SA())
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Compatibility overload deducing T from an actual std::function<T (typename GT::Arc *)> argument; see the equivalent nodes_map overload for why the generic one above cannot deduce it.
template<AlephGraph GT, typename T , NodeFilter< GT > SN = Dft_Show_Node<GT>, class Op > requires std::is_invocable_r_v<T, Op &, const T &, typename GT::Node *>
T	Aleph::foldl_nodes (GT &g, const T &init, Op operation, SN sn=SN())
	Fold the filtered nodes of a graph.
template<AlephGraph GT, typename T , ArcFilter< GT > SA = Dft_Show_Arc<GT>, class Op > requires std::is_invocable_r_v<T, Op &, const T &, typename GT::Arc *>
T	Aleph::foldl_arcs (GT &g, const T &init, Op operation, SA sa=SA())
	Fold the filtered arcs of a graph.
template<AlephGraph GT, typename T , ArcFilter< GT > SA = Dft_Show_Arc<GT>, class Op > requires std::is_invocable_r_v<T, Op &, const T &, typename GT::Arc *>
T	Aleph::foldl_arcs (GT &g, typename GT::Node *p, const T &init, Op operation, SA sa=SA())
	Fold the filtered adjacent arcs of a node.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
DynList< typename GT::Node * >	Aleph::out_nodes (typename GT::Node *p, SA sa=SA())
	Return the nodes connected to the filtered outcoming arcs of p.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
DynList< typename GT::Node * >	Aleph::in_nodes (typename GT::Node *p, SA sa=SA())
	Return the nodes connected to the filtered incoming arcs to p.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
DynList< typename GT::Arc * >	Aleph::out_arcs (typename GT::Node *p, SA sa=SA())
	Return the filtered incoming arcs of p.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
DynList< typename GT::Arc * >	Aleph::in_arcs (typename GT::Node *p, SA sa=SA())
	Return the filtered incoming arcs of p.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
DynList< typename GT::Arc * >	Aleph::arcs (typename GT::Node *p, SA sa=SA())
	Return all the filtered arcs related to p
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
DynList< ArcPair< GT > >	Aleph::in_pairs (typename GT::Node *p, SA sa=SA())
	Return the filtered incoming pairs of (arc,node) related to node p
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
DynList< ArcPair< GT > >	Aleph::out_pairs (typename GT::Node *p, SA sa=SA())
	Return the filtered outcoming pairs of (arc,node) related to node p
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
size_t	Aleph::in_degree (typename GT::Node *p, SA sa=SA())
	Compute the filtered in degree of node p.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
size_t	Aleph::out_degree (typename GT::Node *p, SA sa=SA())
	Compute the filtered out degree of node p
template<AlephGraph GT, class Itor , class Operation >
bool	Aleph::traverse_arcs (typename GT::Node *p, Operation op=Operation())
	Generic arcs traverse of a node.
template<AlephGraph GT, class Itor , class Operation >
void	Aleph::for_each_arc (typename GT::Node *p, Operation op=Operation())
	Execute an operation on each arc of a node.
template<AlephGraph GT, class Op >
bool	Aleph::traverse_in_arcs (typename GT::Node *p, Op op=Op())
	Conditioned traversal of incoming arcs of a node.
template<AlephGraph GT, class Op >
void	Aleph::for_each_in_arc (typename GT::Node *p, Op op=Op())
	Traverse the incoming arcs of a node and executes an operation.
template<AlephGraph GT, typename T >
auto	Aleph::map_in_arcs (typename GT::Node *p, std::function< T(typename GT::Arc *)> op)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Compatibility overload deducing T from an actual std::function<T (typename GT::Arc *)> argument; see the equivalent nodes_map overload for why the generic one above cannot deduce it.
template<AlephGraph GT, class Op >
bool	Aleph::traverse_out_arcs (typename GT::Node *p, Op op=Op())
	Conditioned traversal of outcoming arcs of a node.
template<AlephGraph GT, class Op >
void	Aleph::for_each_out_arc (typename GT::Node *p, Op op=Op())
	Traverse the outcoming arcs of a node and executes an operation.
template<AlephGraph GT, typename T >
auto	Aleph::map_out_arcs (typename GT::Node *p, std::function< T(typename GT::Arc *)> op)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Compatibility overload deducing T from an actual std::function<T (typename GT::Arc *)> argument; see the equivalent nodes_map overload for why the generic one above cannot deduce it.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
GT::Arc *	Aleph::search_arc (const GT &g, typename GT::Node *src, typename GT::Node *tgt, SA sa=SA()) noexcept
	Arc filtered searching given two nodes.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
GT::Arc *	Aleph::search_directed_arc (const GT &g, typename GT::Node *src, typename GT::Node *tgt, SA sa=SA()) noexcept
	Searching of directed arc linking two nodes.
template<AlephGraph GT>
GT::Node *	Aleph::mapped_node (typename GT::Node *p) noexcept
	Return the mapped node through the cookie of p
template<AlephGraph GT>
void	Aleph::copy_graph (GT &gtgt, const GT &gsrc, bool cookie_map=false)
	Explicit copy of graph.
template<AlephGraph GT>
void	Aleph::clear_graph (GT &g) noexcept
	Clean a graph: all its nodes and arcs are removed and freed.
template<AlephGraph GT>
Path< GT >	Aleph::find_path_depth_first (const GT &g, typename GT::Node *start_node, typename GT::Node *end_node)
	Depth-first search of a path between two nodes.
template<AlephGraph GTS, AlephGraph GTT>
void	Aleph::map_nodes (typename GTS::Node *p, typename GTT::Node *q) noexcept
	Map two nodes of different types of graphs through their cookies.
template<AlephGraph GTS, AlephGraph GTT>
void	Aleph::map_arcs (typename GTS::Arc *p, typename GTT::Arc *q) noexcept
	Map two arcs of different types of graphs through their cookies.
template<AlephGraph GTT, AlephGraph GTS, class Copy_Node = Dft_Copy_Node<GTT, GTS>, class Copy_Arc = Dft_Copy_Arc<GTT, GTS>>
void	Aleph::inter_copy_graph (GTT &gtgt, const GTS &gsrc, const bool cookie_map=false)
	Copy between different types of graphs.
template<AlephGraph GT>
size_t	Aleph::depth_first_traversal (const GT &g, typename GT::Node *start_node, bool(*visit)(const GT &g, typename GT::Node *, typename GT::Arc *))
	Depth-first traversal starting from a given node.
template<AlephGraph GT>
size_t	Aleph::breadth_first_traversal (const GT &g, typename GT::Node *start, bool(*visit)(const GT &, typename GT::Node *, typename GT::Arc *))
	Breadth-first traversal starting from a given node.
template<AlephGraph GT>
Path< GT >	Aleph::find_path_breadth_first (const GT &g, typename GT::Node *start, typename GT::Node *end)
	Breadth-first search of a (shortest-by-edges) path between two nodes.
template<AlephGraph GT>
bool	Aleph::test_connectivity (const GT &g)
	Connectivity test for undirected graphs.
template<AlephGraph GT>
bool	Aleph::test_for_cycle (const GT &g, typename GT::Node *src)
	Search for a cycle reachable from a given node.
template<AlephGraph GT>
bool	Aleph::is_graph_acyclique (const GT &g, typename GT::Node *start_node)
	Return true if an undirected graph is acyclic.
template<AlephGraph GT>
bool	Aleph::is_graph_acyclique (const GT &g)
	Return true if an undirected graph is acyclic.
template<AlephGraph GT>
bool	Aleph::has_cycle (const GT &g)
	Return true if an undirected graph has at least one cycle.
template<AlephGraph GT>
bool	Aleph::test_for_path (const GT &g, typename GT::Node *start_node, typename GT::Node *end_node)
	Return true if there is a path between two nodes.
template<AlephGraph GT>
DynList< GT >	Aleph::inconnected_components (const GT &g)
	Forward declaration for inconnected_components().
template<AlephGraph GT>
void	Aleph::build_subgraph (const GT &g, GT &sg, typename GT::Node *g_src, size_t &node_count)
	Forward declaration for build_subgraph().
template<AlephGraph GT>
GT	Aleph::find_depth_first_spanning_tree (const GT &g, typename GT::Node *gnode)
	Build a depth-first spanning tree (mapped to the original graph).
template<AlephGraph GT>
GT	Aleph::find_breadth_first_spanning_tree (GT &g, typename GT::Node *gp)
	Build a breadth-first spanning tree (mapped to the original graph).
template<AlephGraph GT>
GT	Aleph::build_spanning_tree (const DynArray< typename GT::Arc * > &arcs)
	Build a graph from a list of arcs (typically a spanning tree).
template<AlephGraph GT>
DynList< typename GT::Node * >	Aleph::compute_cut_nodes (const GT &g, typename GT::Node *start)
	Compute articulation points (cut vertices) of an undirected graph.
template<AlephGraph GT>
long	Aleph::paint_subgraphs (const GT &g, const DynList< typename GT::Node * > &cut_node_list)
	Paint connected blocks around articulation points.
template<AlephGraph GT>
GT	Aleph::map_subgraph (const GT &g, const long color)
	Extract a mapped subgraph containing a given color.
template<AlephGraph GT>
std::tuple< GT, DynList< typename GT::Arc * > >	Aleph::map_cut_graph (const GT &g, const DynList< typename GT::Node * > &cut_node_list)
	Extract the cut graph and cross-arc list.
template<AlephGraph GT>
GT	Aleph::invert_digraph (const GT &g)
	Compute the transpose (arc-reversed) digraph.
template<AlephGraph GT, template< class > class Max_Flow = Random_Preflow_Maximum_Flow, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
long	Aleph::edge_connectivity (GT &g)
	Compute edge connectivity (arc connectivity) of an undirected graph.
template<AlephGraph GT, template< class > class Max_Flow = Heap_Preflow_Maximum_Flow, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
long	Aleph::compute_min_cut (GT &g, DynSetTree< typename GT::Node * > &l, DynSetTree< typename GT::Node * > &r, DynDlist< typename GT::Arc * > &cut)
	Compute a minimum edge cut of an undirected graph.
template<AlephGraph GT, template< class > class Max_Flow = Random_Preflow_Maximum_Flow, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
long	Aleph::vertex_connectivity (GT &g)
	Compute vertex connectivity of an undirected graph.
template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
void	Aleph::warshall_compute_transitive_clausure (GT &g, Bit_Mat_Graph< GT, SA > &mat)
	Computes the transitive closure of a graph using Warshall's algorithm.

Variables
const unsigned char	Aleph::Processed = 2
	The node or arc has already been processed.
const unsigned char	Aleph::Processing = 1
	The node are being processed; probably it is inside a queue, stack or heap.
const unsigned char	Aleph::Unprocessed = 0
	The node have not bees processed.
bool	Aleph::with_power = false
	Configuration options for DOT file generation.
bool	Aleph::with_nes = false
	If true, include NES percentage in node labels.
bool	Aleph::only_num = false
	If true, show only the node number, not the full label.
bool	Aleph::with_class = false
	If true, set node shapes based on class field.
size_t	Aleph::font_size = 6
	Font size for the DOT output.
bool	Aleph::vertical = true
	If true, use vertical layout (default).

Detailed Description

Filtered iterators

The graph classes export several iterators: Node_Iterator, Arc_Iterator, Node_Arc_Iterator, Out_Iterator and In_Iterator. These iterators are exported as subclasses of the graph class. Suppose, for example, that you are using a class Map based on Array_Graph class (but it could have perfectly been base on any other graph class) and the graph is named g. Then, you could iterate on all the arcs through some such as:

for (auto it = g.get_arc_it(); it.has_cur(); it.next()) auto arc = it.get_curr(); // each arc of the graph is seen

Now, there are several, perhaps many, situations where not all the arcs must be processed, but a subset of them satisfying a particular condition. In these cases, the filtered iterator come for us.

As seen in the class Filter_Iterator, a filtered iterator is almost exactly the same thing as a normal iterator. The subtle difference is that on it operates a filter condition that filters all the items satisfying a special condition. Let's show a brief but constructive example.

A brief example

Suppose that your graph represents pathways of automotive transportation. Nodes are the cities and arcs are the pathways. Now suppose that your pathways are classified in Highway, Road and Trail. Now suppose that you wish to solve a problem that only involves highways; for example, you want to find the shortest path between two cities connected by only highways. Then you could specify a filter that catches highways:

struct Only_Highway { bool operator () (GT::Arc * a) { return a->get_info().type == Highway; } };

Now, if your shortest path algorithm receives this filter, this will only see highways and its results will only contain highways.

Convention about filtered iterators

For each subclass iterator on a graph, it is exported a filtered iterator with the same name of subclassed one. Thus, for the subclass GT::Arc_Iterator exists a filtered version named Arc_Iterator and so on for the remainder iterator subclasses on the graphs.

The filtered iterators have a great importance in Aleph-w ( \(\aleph_\omega\)) algorithms on graphs, since almost every algorithm operates with filtered iterator.

When to use then?

The short answer is: almost always!

Filtered iterators have of course a light but constant impact on performance. For each seen graph object a boolean predicate is tested. So, if you know that your algorithm does not require to filter, the use the subclass iterator. But if, in pursuit of generalization your algorithm could profit the filtered version, then design your algorithm on filtered iterator. In this way you will provide generality, which allows to reuse algorithms in a transparent way.

A very good and concrete example of intensive use of filtered iterator is for solving the problem of maximizing a network flow at minimum cost. First, in order to manage the residual net, the arcs are filtered according to source node. Second, the residual cut arcs are also filtered according to flow value; if the flow is equal to the capacity then the arc is filtered. Third, in order to detect negative cycles the Bellman-Ford algorithm is used with a filter that only sees the arcs cost.

Macro Definition Documentation

ALEPH_GRAPH_COPY_MOVE_CTORS

#define ALEPH_GRAPH_COPY_MOVE_CTORS

(

GraphClass

)

Value:

                 \
  GraphClass(const GraphClass & g)                                           \
  {                                                                          \
    copy_graph(*this, g);                                                    \
  }                                                                          \
                                                                             \
  GraphClass(GraphClass && g) noexcept                                       \
  {                                                                          \
    swap(g);                                                                 \
  }                                                                          \
                                                                             \
  GraphClass & operator=(const GraphClass & g)                               \
  {                                                                          \
    if (this == &g)                                                          \
      return *this;                                                          \
    copy_graph(*this, g);                                                    \
    return *this;                                                            \
  }                                                                          \
                                                                             \
  GraphClass & operator=(GraphClass && g) noexcept                           \
  {                                                                          \
    swap(g);                                                                 \
    return *this;                                                            \
  }

Macro to generate copy/move constructors and assignment operators.

This macro generates the standard copy constructor, move constructor, copy assignment operator, and move assignment operator for graph classes.

Requirements for the graph class:

• Must have a swap(GraphClass&) method
• Must work with the free function copy_graph(dest, src)

Parameters

GraphClass

The name of the graph class

Usage example:

class List_Graph : public GraphCommon<...> {
  // ... other members ...
 
  void swap(List_Graph & g) noexcept { ... }
 
  ALEPH_GRAPH_COPY_MOVE_CTORS(List_Graph)
 
  virtual ~List_Graph() { clear_graph(*this); }
};

Note

This macro does NOT generate the destructor, as destruction logic varies between graph implementations.

Definition at line 3898 of file graph-dry.H.

ARC_BITS

#define ARC_BITS

(

p

)

((p)->attrs.control_bits)

Return the control bits of arc p.

Definition at line 379 of file aleph-graph.H.

ARC_COLOR

#define ARC_COLOR

(

p

)

((p)->attrs.counter)

Return the color of arc p.

Definition at line 373 of file aleph-graph.H.

ARC_COOKIE

#define ARC_COOKIE

(

p

)

((p)->attrs.cookie)

Return the arc cookie

Definition at line 394 of file aleph-graph.H.

ARC_COUNTER

#define ARC_COUNTER

(

p

)

((p)->attrs.counter)

Return the counter of arc p.

Definition at line 367 of file aleph-graph.H.

IS_ARC_VISITED

#define IS_ARC_VISITED	(		p,
			bit
	)		(ARC_BITS(p).get_bit(bit))

Determine whether the bit field is or not set to one.

Parameters

p	pointer to arc
bit	number of bit to be read

Returns

true if bit is 1; false otherwise (bit is set to 0)

Definition at line 388 of file aleph-graph.H.

IS_NODE_VISITED

#define IS_NODE_VISITED	(		p,
			bit
	)		(NODE_BITS(p).get_bit(bit))

Determine whether the control bit is set or not to one.

Parameters

p	pointer to the node
bit	number of bit to read

Returns

true if the bit is 1; false if 0

Definition at line 355 of file aleph-graph.H.

NODE_BITS

#define NODE_BITS

(

p

)

((p)->attrs.control_bits)

Get the control bits of a node.

Definition at line 333 of file aleph-graph.H.

NODE_COLOR

#define NODE_COLOR

(

p

)

((p)->attrs.counter)

Synonymous of NODE_COUNTER.

Definition at line 345 of file aleph-graph.H.

NODE_COOKIE

#define NODE_COOKIE

(

p

)

((p)->attrs.cookie)

Return the node cookie

Definition at line 361 of file aleph-graph.H.

NODE_COUNTER

#define NODE_COUNTER

(

p

)

((p)->attrs.counter)

Get the counter of a node.

Definition at line 339 of file aleph-graph.H.

Typedef Documentation

_In_Iterator

template<class GT >

using Aleph::_In_Iterator = typedef Digraph_Iterator<GT, __In_Filt<GT> >

Basic iterator for incoming arcs of a node.

Definition at line 1818 of file tpl_graph.H.

_Out_Iterator

template<class GT >

using Aleph::_Out_Iterator = typedef Digraph_Iterator<GT, __Out_Filt<GT> >

Basic iterator for outcoming arcs of a node.

Definition at line 1810 of file tpl_graph.H.

ArcPair

template<class GT >

using Aleph::ArcPair = typedef std::tuple<typename GT::Arc *, typename GT::Node *>

Alias used for encapsulating a pair of arc and node (related between them).

Definition at line 1622 of file tpl_graph.H.

Array_Digraph

template<typename __Graph_Node = Graph_Anode<int>, typename __Graph_Arc = Graph_Aarc<int>>

using Aleph::Array_Digraph = typedef Digraph<Array_Graph<__Graph_Node, __Graph_Arc> >

Directed graph (digraph) implemented with array-based adjacency lists.

This class models a directed graph. Functionally it is equivalent to the Array_Graph class, except that this one handles directed graphs.

This is a type alias for Digraph<Array_Graph<...>>, which provides all the directed graph functionality through the generic Digraph template wrapper defined in graph-dry.H.

Template Parameters

__Graph_Node	The node type. Must be defined from the Graph_Anode class, either by attribute inclusion, by derivation, or by a combination of both.
__Graph_Arc	The arc type. Must be defined from the Graph_Aarc class, either by attribute inclusion, by derivation, or by a combination of both.

See also

Graph_Anode Graph_Aarc Digraph

Array_Graph

Definition at line 617 of file tpl_agraph.H.

Distinct_Count_Mo_On_Trees

template<class GT >

using Aleph::Distinct_Count_Mo_On_Trees = typedef Gen_Mo_On_Trees<GT, Distinct_Count_Policy<typename GT::Node::Node_Type> >

Mo on Trees specialised for counting distinct node values.

Template Parameters

GT	Graph type.

Definition at line 1216 of file tpl_mo_on_trees.H.

List_Digraph

template<typename __Graph_Node = Graph_Node<int>, typename __Graph_Arc = Graph_Arc<int>>

using Aleph::List_Digraph = typedef Digraph<List_Graph<__Graph_Node, __Graph_Arc> >

Directed graph (digraph) implemented with double-linked adjacency lists.

This class models a directed graph. Functionally, it is equivalent to the List_Graph class, except that this one handles directed graphs.

This is a type alias for Digraph<List_Graph<...>>, which provides all the directed graph functionality through the generic Digraph template wrapper defined in graph-dry.H.

Template Parameters

__Graph_Node	The node type. Must be defined from the Graph_Node class, either by attribute inclusion, by derivation, or by a combination of both.
__Graph_Arc	The arc type. Must be defined from the Graph_Arc class, either by attribute inclusion, by derivation, or by a combination of both.

See also

Graph_Node Graph_Arc Digraph

List_Graph

Definition at line 1613 of file tpl_graph.H.

List_SDigraph

template<typename __Graph_Node = Graph_Snode<int>, typename __Graph_Arc = Graph_Sarc<int>>

using Aleph::List_SDigraph = typedef Digraph<List_SGraph<__Graph_Node, __Graph_Arc> >

Directed graph (digraph) implemented with simple adjacency lists.

This class models a directed graph. Functionally it is equivalent to the List_SGraph class, except that this one handles directed graphs.

This is a type alias for Digraph<List_SGraph<...>>, which provides all the directed graph functionality through the generic Digraph template wrapper defined in graph-dry.H.

Template Parameters

__Graph_Node	The node type. Must be defined from the Graph_Snode class, either by attribute inclusion, by derivation, or by a combination of both.
__Graph_Arc	The arc type. Must be defined from the Graph_Sarc class, either by attribute inclusion, by derivation, or by a combination of both.

See also

Graph_Snode Graph_Sarc Digraph

List_SGraph

Definition at line 656 of file tpl_sgraph.H.

Powerful_Array_Mo_On_Trees

template<class GT >

using Aleph::Powerful_Array_Mo_On_Trees = typedef Gen_Mo_On_Trees<GT, Powerful_Array_Policy<typename GT::Node::Node_Type> >

Mo on Trees specialised for the "powerful array" query.

Template Parameters

GT	Graph type.

Definition at line 1225 of file tpl_mo_on_trees.H.

Range_Mode_Mo_On_Trees

template<class GT >

using Aleph::Range_Mode_Mo_On_Trees = typedef Gen_Mo_On_Trees<GT, Range_Mode_Policy<typename GT::Node::Node_Type> >

Mo on Trees specialised for range mode queries.

Template Parameters

GT	Graph type.

Definition at line 1234 of file tpl_mo_on_trees.H.

Enumeration Type Documentation

Graph_Bits

enum Aleph::Graph_Bits

Bit numbers of nodes or arcs.

Nodes y arcs of graph have as control attributes (internal representation of state), a set of bits. These are their numbers named according to their use by the library.

You can use then for purposes other than the suggested name. However, be careful.

See also

Bit_Fields

Enumerator
Depth_First
Breadth_First
Test_Cycle
Find_Path
Euler
Maximum_Flow
Spanning_Tree
Build_Subtree
Convert_Tree
Cut
Min
Num_Bits_Graph

Definition at line 71 of file aleph-graph.H.

Planarity_Certificate_Type

enum class Aleph::Planarity_Certificate_Type

strong

Non-planarity witness classification.

Enumerator
None
K5_Subdivision
K33_Subdivision
Minimal_NonPlanar_Obstruction

Definition at line 111 of file Planarity_Test.H.

Function Documentation

arcs()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

DynList< typename GT::Arc * > Aleph::arcs	(	typename GT::Node *	p,
		SA	sa = SA()
	)

Return all the filtered arcs related to p

Parameters

[in]	p	node pointer
[in]	sa	arc filter

Definition at line 1984 of file tpl_graph.H.

References Aleph::DynList< T >::append(), Aleph::blossom_maximum_cardinality_matching(), and Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne().

arcs_map() [1/4]

template<AlephGraph GT, typename T , template< typename > class Container = DynList, ArcFilter< GT > SA = Dft_Show_Arc<GT>, class Op >
requires std::is_invocable_r_v<T, Op &, typename GT::Arc *>

Container< T > Aleph::arcs_map	(	GT &	g,
		Op	transformation,
		SA	sa = SA()
	)

Map the filtered arcs of a graph to a transformed type.

Template Parameters

GT	Graph type
T	Result type
Container	Container type (default: DynList)
SA	Arc filter type (default: Dft_Show_Arc<GT>)

Parameters

g	the graph
transformation	function Arc* -> T that transforms each arc
sa	arc filter functor (default: Dft_Show_Arc<GT>)

Returns

a Container<T> object with all the arcs mapped through the transformation

Definition at line 1427 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching().

Referenced by Aleph::max_flow_min_cost_by_cycle_canceling().

arcs_map() [2/4]

template<AlephGraph GT, typename T , template< typename > class Container = DynList, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

Container< T > Aleph::arcs_map	(	GT &	g,
		std::function< T(typename GT::Arc *)>	transformation,
		SA	sa = SA()
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Compatibility overload deducing T from an actual std::function<T (typename GT::Arc *)> argument; see the equivalent nodes_map overload for why the generic one above cannot deduce it.

Definition at line 1450 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching().

arcs_map() [3/4]

template<AlephGraph GT, typename T , template< typename > class Container = DynList, ArcFilter< GT > SA = Dft_Show_Arc<GT>, class Op >
requires std::is_invocable_r_v<T, Op &, typename GT::Arc *>

Container< T > Aleph::arcs_map	(	GT &	g,
		typename GT::Node *	p,
		Op	transformation,
		SA	sa = SA()
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Map the filtered arcs of a specific node in a graph to a transformed type.

This overload filters arcs connected to a specific node p.

Template Parameters

GT	Graph type
T	Result type
Container	Container type (default: DynList)
SA	Arc filter type (default: Dft_Show_Arc<GT>)

Parameters

g	the graph
p	node pointer (arcs connected to this node are filtered)
transformation	function Arc* -> T that transforms each arc
sa	arc filter functor (default: Dft_Show_Arc<GT>)

Returns

a Container<T> object with all the arcs mapped through the transformation

See also

arcs_map(GT &, std::function<T (typename GT::Arc *)>, SA) For the version that maps all arcs in the graph.

Definition at line 1484 of file tpl_graph.H.

References Aleph::Dlink::append(), and Aleph::blossom_maximum_cardinality_matching().

arcs_map() [4/4]

template<AlephGraph GT, typename T , template< typename > class Container = DynList, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

Container< T > Aleph::arcs_map	(	GT &	g,
		typename GT::Node *	p,
		std::function< T(typename GT::Arc *)>	transformation,
		SA	sa = SA()
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Compatibility overload deducing T from an actual std::function<T (typename GT::Arc *)> argument; see the equivalent nodes_map overload for why the generic one above cannot deduce it.

Definition at line 1508 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching().

blossom_maximum_cardinality_matching()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

size_t Aleph::blossom_maximum_cardinality_matching	(	const GT &	g,
		DynDlist< typename GT::Arc * > &	matching,
		SA	sa = SA()
	)

Alias of compute_maximum_cardinality_general_matching().

This convenience function keeps the word "blossom" explicit in the call site.

Definition at line 466 of file Blossom.H.

References Aleph::blossom_maximum_cardinality_matching().

Referenced by Aleph::Abstract_Euclidian_Plane< __Euclidian_Graph >::Abstract_Euclidian_Plane(), Aleph::Ady_Mat< GT, __Entry_Type, SA >::Ady_Mat(), Aleph::AhArenaAllocator::AhArenaAllocator(), Aleph::Array_Graph< __Graph_Node, __Graph_Arc >::Array_Graph(), Aleph::Array_Iterator< T >::Array_Iterator(), Aleph::Array_Iterator< T >::Array_Iterator(), Aleph::Array_Iterator< T >::Array_Iterator(), Aleph::Array_Iterator< T >::Array_Iterator(), Aleph::ArrayHeap< T, Compare >::ArrayHeap(), Aleph::FFT< Real >::BatchedISTFTProcessor::BatchedISTFTProcessor(), Aleph::BitArray::BitArray(), Aleph::BitArray::BitArray(), Aleph::Bloom_Filter< T >::Bloom_Filter(), Aleph::CA::Reproductions::BTW_Sandpile::BTW_Sandpile(), Aleph::Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::Bucket::Bucket(), Aleph::Cnode::Clone_Target_Rollback::Clone_Target_Rollback(), Aleph::Compact_Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::Compact_Cuckoo_Filter(), Aleph::Compact_Quotient_Filter< T >::Compact_Quotient_Filter(), Aleph::ConcurrentHashMap< Key, T, Cmp, Shards >::ConcurrentHashMap(), Aleph::CancellationToken::ConditionVariableRegistration::ConditionVariableRegistration(), Aleph::Cookie_Guard< GT >::Cookie_Guard(), Aleph::Cookie_Saver< GT >::Cookie_Saver(), Aleph::Count_Min_Sketch< T, CounterT >::Count_Min_Sketch(), Aleph::CsvReader::CsvReader(), CtorContainer< C >::CtorContainer(), Aleph::Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::Cuckoo_Filter(), Aleph::CA::Custom_Neighborhood< N, K, Radius >::Custom_Neighborhood(), Aleph::CA::Directory_Frame_Sink::Directory_Frame_Sink(), Aleph::Dlink::Dlink(), Aleph::DynLhashTable< Key, Record, Cmp >::DLProxy::DLProxy(), Dynamic_Event_Table< Signature >::Dynamic_Event_Table(), Aleph::DynArray< T >::DynArray(), Aleph::DynArray< T >::DynArray(), Aleph::DynArray< T >::DynArray(), Aleph::DynArray< T >::DynArray(), Aleph::DynDlist< T >::DynDlist(), Aleph::DynHashTable< Key, HashTable, Cmp >::DynHashTable(), Aleph::DynHashTable< Key, HashTable, Cmp >::DynHashTable(), Aleph::DynIntervalTree< T, Compare >::DynIntervalTree(), Aleph::DynListQueue< T >::DynListQueue(), Aleph::DynListStack< T >::DynListStack(), Aleph::DynMatrix< T >::DynMatrix(), Aleph::DynSetTree< Key, Tree, Compare >::DynSetTree(), Aleph::DynSetTree< Key, Tree, Compare >::DynSetTree(), Aleph::DynSkipList< Key, Compare >::DynSkipList(), Aleph::DynSkipList< Key, Compare >::DynSkipList(), Aleph::DynSlist< T >::DynSlist(), Aleph::DynSlist< T >::DynSlist(), Aleph::MonotonePolygonTriangulation::EdgeStatusTree::EdgeStatusTree(), Aleph::Empty_Class::Empty_Class(), Aleph::Empty_Class::Empty_Class(), Aleph::Empty_Class::Empty_Class(), Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::Euclidian_Graph(), TimeoutQueue::Event::Event(), TimeoutQueue::Event::Event(), Aleph::expected< T, E >::expected(), Aleph::expected< void, E >::expected(), Aleph::expected< void, E >::expected(), Aleph::expected< T, E >::expected(), Aleph::extents< IndexType, Exts >::extents(), Aleph::extents< IndexType, Exts >::extents(), Aleph::extents< IndexType, Exts >::extents(), Aleph::CA::Ffmpeg_Frame_Sink< Mapper >::Ffmpeg_Frame_Sink(), Aleph::Fibonacci_Heap< T, Compare >::Fibonacci_Heap(), Aleph::Filter_Iterator< Container, It, Show_Item >::Filter_Iterator(), Aleph::FixedStack< T >::FixedStack(), Aleph::Floyd_All_Shortest_Paths< GT, Distance, SA >::Floyd_All_Shortest_Paths(), Foo::Foo(), Foo::Foo(), Foo::Foo(), Foo::Foo(), Aleph::CA::Forest_Fire_Rule< Engine >::Forest_Fire_Rule(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::Gen_BPlus_Tree(), Aleph::Gen_Cartesian_Tree< T, Comp >::Gen_Cartesian_Tree(), Aleph::Gen_Disjoint_Sparse_Table< T, Op >::Gen_Disjoint_Sparse_Table(), Aleph::Gen_Disjoint_Sparse_Table< T, Op >::Gen_Disjoint_Sparse_Table(), Aleph::Gen_Fenwick_Tree< T, Plus, Minus >::Gen_Fenwick_Tree(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::Gen_File_B_Tree(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::Gen_File_BPlus_Tree(), Aleph::Gen_HLD< GT, T, Op, SA >::Gen_HLD(), Aleph::Gen_HLD< GT, T, Op, SA >::Gen_HLD(), Aleph::Gen_Lazy_Segment_Tree< Policy >::Gen_Lazy_Segment_Tree(), Aleph::Gen_Lazy_Segment_Tree< Policy >::Gen_Lazy_Segment_Tree(), Aleph::Gen_Mo_Algorithm< T, Policy >::Gen_Mo_Algorithm(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::Gen_MultiPolynomial(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::Gen_MultiPolynomial(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::Gen_MultiPolynomial(), Aleph::Gen_Polynomial< Coefficient >::Gen_Polynomial(), Aleph::Gen_Polynomial< Coefficient >::Gen_Polynomial(), Aleph::Gen_Polynomial< Coefficient >::Gen_Polynomial(), Aleph::Gen_Polynomial< Coefficient >::Gen_Polynomial(), Aleph::Gen_Polynomial< Coefficient >::Gen_Polynomial(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::Gen_Rand_Tree(), Aleph::Gen_Reroot_DP< GT, T, SA >::Gen_Reroot_DP(), Aleph::Gen_Segment_Tree< T, Op >::Gen_Segment_Tree(), Aleph::Gen_Segment_Tree< T, Op >::Gen_Segment_Tree(), Aleph::Gen_Sparse_Table< T, Op >::Gen_Sparse_Table(), Aleph::Gen_Sparse_Table< T, Op >::Gen_Sparse_Table(), Aleph::GenLhashTable< Key, BucketType, Cmp >::GenLhashTable(), Aleph::GenTdRbTree< NodeType, Key, Compare >::GenTdRbTree(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::GenTdRbTreeRk(), gsl_rng_holder::gsl_rng_holder(), Aleph::HashMap< Key, Data, HashMapTable, Cmp >::HashMap(), Aleph::HashMap< Key, Data, HashMapTable, Cmp >::HashMap(), Aleph::CA::History_Cell< State, Depth >::History_Cell(), Aleph::Hungarian_Assignment< Cost_Type >::Hungarian_Assignment(), Aleph::Hungarian_Assignment< Cost_Type >::Hungarian_Assignment(), Aleph::IndexArc< GT, Tree, SA >::IndexArc(), Aleph::IndexArc< GT, Tree, SA >::IndexArc(), Aleph::Init_Guard< CleanupFunc >::Init_Guard(), Aleph::Init_P< GT >::Init_P(), Aleph::Interpreter_Value::Interpreter_Value(), Aleph::Interpreter_Value::Interpreter_Value(), Aleph::MemArray< T >::Iterator::Iterator(), RingFileCache< T >::Iterator::Iterator(), Aleph::CsvReader::Iterator::Iterator(), Aleph::Johnson< GT, Distance, Ait, NAit, SA >::Johnson(), K2Tree< T >::K2Tree(), Aleph::Karger_Min_Cut< GT, SA >::Karger_Min_Cut(), Aleph::Karger_Min_Cut< GT, SA >::Karger_Min_Cut(), KnapsackDomain::KnapsackDomain(), Aleph::Testing::LayeredNetworkGenerator< Net >::LayeredNetworkGenerator(), LFit::LFit(), Log_Manager::Log_Manager(), Aleph::Map_Matrix_Graph< GT, SA >::Map_Matrix_Graph(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::MatchingContext(), Aleph::Matrix< Trow, Tcol, NumType >::Matrix(), Aleph::Matrix< Trow, Tcol, NumType >::Matrix(), Aleph::Matrix_Graph< GT, SA >::Matrix_Graph(), Aleph::MemArray< T >::MemArray(), Aleph::MemArray< T >::MemArray(), Aleph::MinHash< T >::MinHash(), Aleph::Modular_Matrix< MatrixT >::Modular_Matrix(), Aleph::ModularCombinatorics::ModularCombinatorics(), MoveOnly::MoveOnly(), Aleph::CA::Multi_Field_Lattice< Layout, Boundary, Rank, Fields >::Multi_Field_Lattice(), Aleph::CA::Multi_Field_Lattice< Layout, Boundary, Rank, Fields >::Multi_Field_Lattice(), Aleph::Net_Cap_Graph< NodeT, ArcT >::Net_Cap_Graph(), Aleph::Net_Cost_Graph< NodeT, ArcT >::Net_Cost_Graph(), Aleph::Net_Graph< NodeT, ArcT >::Net_Graph(), Aleph::Net_Graph< NodeT, ArcT >::Net_Graph(), Aleph::DynSkipList< Key, Compare >::Node::Node(), Aleph::DynSkipList< Key, Compare >::Node::Node(), Aleph::DynSkipList< Key, Compare >::Node::Node(), Aleph::blossom_weighted_detail::mwmatching::impl::NonTrivialBlossom< WeightType >::NonTrivialBlossom(), Aleph::Now::Now(), Aleph::Now::Now(), Aleph::ODhashTable< Key, Cmp >::ODhashTable(), Aleph::ODhashTable< Key, Cmp >::ODhashTable(), Aleph::OLhashTable< Key, Cmp >::OLhashTable(), Aleph::FFT< Real >::OverlapAdd::OverlapAdd(), Aleph::FFT< Real >::OverlapAddBank::OverlapAddBank(), Aleph::FFT< Real >::OverlapSave::OverlapSave(), Aleph::FFT< Real >::PartitionedConvolver::PartitionedConvolver(), Aleph::Path< GT >::Path(), Aleph::PatriciaMap< UInt, T >::PatriciaMap(), Aleph::PatriciaSet< UInt >::PatriciaSet(), Aleph::FFT< Real >::Plan::Plan(), Aleph::NTT< MOD, ROOT >::Plan::Plan(), Polinomio::Polinomio(), Aleph::Polygon::Polygon(), Aleph::Prefix_Tree::Prefix_Tree(), Aleph::Prefix_Tree_Map< T >::Prefix_Tree_Map(), QuadNode::QuadNode(), Aleph::Quotient_Filter< T >::Quotient_Filter(), Aleph::RadixTree< T, Char >::RadixTree(), Aleph::Random_Graph_Base< GT, Init_Node, Init_Arc >::Random_Graph_Base(), Random_Network_Flow< Net >::Random_Network_Flow(), Aleph::Random_Set< T >::Random_Set(), RandTree< T >::RandTree(), Aleph::Range_Fenwick_Tree< T >::Range_Fenwick_Tree(), Aleph::Rectangle::Rectangle(), Aleph::Regular_Polygon::Regular_Polygon(), Aleph::Reservoir_Sampler< T >::Reservoir_Sampler(), Aleph::RevisedSimplex< T >::RevisedSimplex(), Aleph::RingBuffer< T >::RingBuffer(), Aleph::RingBuffer< T >::RingBuffer(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::RTree(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::RTree(), Aleph::CA::Schelling_Rule< Engine >::Schelling_Rule(), Aleph::Scope_Guard< GT, Cleanup >::Scope_Guard(), Aleph::Segment::Segment(), Aleph::Segment_Tree_Beats< T >::Segment_Tree_Beats(), Aleph::Segment_Tree_Beats< T >::Segment_Tree_Beats(), Aleph::Segment_Tree_Beats< T >::Segment_Tree_Beats(), Aleph::CA::SIR_Rule< Engine >::SIR_Rule(), Aleph::SkipList< Key, Type >::SkipList(), Aleph::SkipList< Key, Type >::SkipList(), Aleph::SmallVector< T, N >::SmallVector(), Aleph::SmallVector< T, N >::SmallVector(), Aleph::SmallVector< T, N >::SmallVector(), Aleph::FFT< Real >::SOSFilterBank::SOSFilterBank(), Static_Event_Table< Signature >::Static_Event_Table(), OhashCommon< HashTbl, Key >::Stats::Stats(), Aleph::SweepLineSegmentIntersection::StatusTree::StatusTree(), Aleph::ThreadPool::ThreadPool(), Aleph::Tikz_Plane::Tikz_Plane(), Aleph::CA::Tile_Cache< State, TileSide >::Tile_Cache(), Tree_Data::Tree_Data(), TreeContainer::TreeContainer(), Aleph::Vector< T, NumType >::Vector(), Aleph::CA::X11_Frame_Sink< Mapper >::X11_Frame_Sink(), Aleph::Cnode::Clone_Target_Rollback::~Clone_Target_Rollback(), Aleph::Dial_Min_Paths< GT, Distance, Itor, SA >::Dial_Init_Guard::~Dial_Init_Guard(), Aleph::DynSkipList< Key, Compare >::~DynSkipList(), Eepic_Plane::~Eepic_Plane(), TimeoutQueue::Event::~Event(), Aleph::CA::Ffmpeg_Frame_Sink< Mapper >::~Ffmpeg_Frame_Sink(), Foo::~Foo(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::~Gen_Avl_Tree(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::~Gen_Avl_Tree_Rk(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::~Gen_Interval_Tree(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::~Gen_Rand_Tree(), Aleph::Gen_Treap< NodeType, Key, Compare >::~Gen_Treap(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::~Gen_Treap_Rk(), Aleph::Graph_Anode< Node_Info >::~Graph_Anode(), gsl_rng_holder::~gsl_rng_holder(), Aleph::Init_Guard< CleanupFunc >::~Init_Guard(), Aleph::Testing::detail::Joining_Thread_Guard::~Joining_Thread_Guard(), Aleph::CA::JSON_Frame_Stream_Writer::~JSON_Frame_Stream_Writer(), Aleph::Karger_Min_Cut< GT, SA >::~Karger_Min_Cut(), Node_Pool< Node >::~Node_Pool(), QueueTheadsPool< T >::~QueueTheadsPool(), Aleph::Random_Graph_Base< GT, Init_Node, Init_Arc >::~Random_Graph_Base(), Random_Network_Flow< Net >::~Random_Network_Flow(), Aleph::Random_Set< T >::~Random_Set(), RandTree< T >::~RandTree(), Aleph::SkipList< Key, Type >::~SkipList(), TenVectors::~TenVectors(), TimeoutQueue::~TimeoutQueue(), Aleph::CA::ca_checkpoint_detail::Tmp_File_Guard::~Tmp_File_Guard(), WorkersSet< WorkerFct >::~WorkersSet(), Aleph::CA::X11_Frame_Sink< Mapper >::~X11_Frame_Sink(), Aleph::Zero_One_BFS< GT, Distance, Itor, SA >::ZOB_Init_Guard::~ZOB_Init_Guard(), Aleph::DynList< T >::__append(), Aleph::__compute_cut_nodes(), Aleph::__depth_first_traversal(), Aleph::__dfp_phase2_list(), Aleph::__dfp_phase2_subgraph(), Aleph::Compute_Bridges< GT, SA >::__dfs(), Aleph::Karger_Min_Cut< GT, SA >::__fast_karger_min_cut(), Aleph::__find_depth_first_spanning_tree(), Aleph::__find_path_depth_first(), Aleph::GenBinHeap< NodeType, Key, Compare >::__for_each_in_inorder(), Aleph::GenBinHeap< NodeType, Key, Compare >::__for_each_in_preorder(), Aleph::__generate_tree(), Aleph::__graph_to_tree_node(), GenTdSplayTreeRk< NodeType, Key, Compare >::__insert(), GenTdSplayTree< NodeType, Key, Compare >::__insert(), Aleph::DynList< T >::__insert(), Aleph::__is_graph_acyclique(), Aleph::GenBinHeap< NodeType, Key, Compare >::__level_traverse(), Aleph::__map_subgraph(), Aleph::__paint_from_cut_node(), Aleph::__paint_subgraph(), Aleph::GenBinHeap< NodeType, Key, Compare >::__postorder_delete(), Aleph::__random_select(), Aleph::__random_select(), Aleph::__random_select(), Aleph::__remove_by_pos_xt(), Aleph::__search_deway(), Aleph::__select_rec(), Aleph::__split_key_rec_xt(), Aleph::__split_pos_rec(), Aleph::__test_for_path(), Aleph::BitArray::__traverse(), Aleph::DynArray< T >::__traverse(), Aleph::__tree_postorder_traversal(), Aleph::__tree_preorder_traversal(), Aleph::DynDlist< T >::_append(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_append_unique(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_build_affine_factor(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_build_affine_factor_from_linear_data(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_build_eval_point(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_build_interpolation_grid(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_collect_sorted_primitive_factor_groups(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_collect_sorted_primitive_linear_factors(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_collect_unique_monic_linear_roots(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_count_active_vars(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_decode_grid_point(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_divides_exactly(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_embed_coeff_poly_as_x_term(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_embed_univariate(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_eval_index_for_var(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_eval_monomial(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_exact_quotient(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_expanded_univariate_factors(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_factorize_as_univariate_in_var(), Aleph::DynDlist< T >::_insert(), Aleph::Gen_Polynomial< Coefficient >::_integer_exact_quot(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_interpolated_factors_for_main_var(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_list_size(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_search_affine_lift_options(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_substitute_var(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_try_extract_affine_linear_factor(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_try_extract_interpolated_factor(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_try_lift_affine_linear_factor_for_main_var(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::_try_lift_primitive_affine_linear_factor_for_main_var(), Aleph::polynomial_detail::abs_to_u64(), Aleph::CA::Dot_Frame_Sink< Palette >::accept(), Aleph::CA::Ffmpeg_Frame_Sink< Mapper >::accept(), Aleph::CA::Gif_Frame_Sink< Mapper >::accept(), Aleph::CA::HTML_Player_Frame_Sink< Mapper >::accept(), Aleph::CA::Npy_Frame_Sink::accept(), Aleph::CA::Png_Frame_Sink< Mapper >::accept(), Aleph::CA::VTK_Frame_Sink::accept(), Aleph::CA::X11_Frame_Sink< Mapper >::accept(), Aleph::CA::Svg_Frame_Sink< Palette >::accept(), Aleph::CA::Directory_Frame_Sink::accept(), Aleph::CA::JSON_Frame_Stream_Writer::accept(), Aleph::DynArray< T >::access(), Aleph::MemArray< T >::access(), Aleph::accumulate(), Aleph::accumulate(), Aleph::adversarial_search_detail::accumulate_adversarial_stats(), Aleph::FFT< Real >::ISTFTProcessor::accumulate_frame(), Aleph::adversarial_search_detail::accumulate_move_ordering_stats(), Aleph::adversarial_search_detail::accumulate_search_stats(), Aleph::adversarial_search_detail::accumulate_transposition_stats(), Aleph::detail::Pid_File_Lock::acquire(), Aleph::CA::X11_Frame_Sink< Mapper >::active(), Aleph::Range_Mode_Policy< T >::add(), Aleph::HashMap< Key, Data, HashMapTable, Cmp >::add(), Aleph::Two_Sat< GT >::add_at_most_one(), Aleph::Two_Sat< GT >::add_clause_signed(), Aleph::Compiler_CFG_Lowering::add_edge(), Aleph::Compiler_IR_Builder::add_edge(), Aleph::Compiler_IR_Lowering::Module_Builder::add_edge(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::add_entry(), Aleph::Compiler_IR_Lowering::Module_Builder::add_global_slot(), Aleph::CA::Reproductions::BTW_Sandpile::add_if_inside(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::add_key_to_crc(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::add_key_to_crc(), Aleph::Convex_Hull_Trick< T >::add_line(), Aleph::Li_Chao_Tree< T >::add_line_impl(), Aleph::Compiler_IR_Lowering::Module_Builder::add_local_slot(), Aleph::NTT< MOD, ROOT >::add_mod(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::add_native_key_to_crc(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::add_native_key_to_crc(), Aleph::Aho_Corasick::add_pattern(), Aleph::TestVisual::add_polygon_vertices(), Aleph::Tikz_Scene::add_polygons(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::add_s_to_s_edge(), Aleph::FFT< Real >::add_scaled_polynomial(), Aleph::Gen_Polynomial< Coefficient >::add_scaled_shifted(), add_super_source_and_sink(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::add_to_coeff(), Aleph::Gen_Polynomial< Coefficient >::add_to_coeff(), Aleph::Gen_File_B_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::Record_Codec::add_to_crc(), Aleph::Gen_File_BPlus_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::Record_Codec::add_to_crc(), Aleph::detail::Paged_Bounded_String_Codec< Capacity, SizeType >::add_to_crc(), Aleph::detail::Paged_Value_Codec< T >::add_to_crc(), Aleph::detail::Paged_Value_Codec< std::array< T, N > >::add_to_crc(), add_to_ref(), Aleph::Polygon::add_vertex(), Aleph::adjacent_difference(), Aleph::adjacent_difference(), Aleph::adjacent_find(), adjust_minimal_separation_with_letf_sibling(), adjust_nodes(), Aleph::blossom_weighted_detail::mwmatching::adjust_weights_for_maximum_cardinality_matching(), Aleph::CA::Hashlife_Engine::advance(), Aleph::stl_zip_detail::advance_all(), Aleph::std_zip_detail::advance_all(), Aleph::GenBinHeap< NodeType, Key, Compare >::advance_right(), aleatorio(), aleph_ca_api_version_v1(), aleph_ca_copy_frame_v1(), aleph_ca_create_gol_engine_v1(), aleph_ca_error_message_v1(), aleph_ca_extents_v1(), aleph_ca_get_cell_v1(), aleph_ca_last_error_v1(), aleph_ca_run_v1(), aleph_ca_set_cell_v1(), aleph_ca_step_v1(), algebraic_transformations(), Aleph::FFT< Real >::align_phase_near_reference(), Aleph::align_text_to_left(), Aleph::align_text_to_left_except_first(), Aleph::CA::Hashlife_Engine::alive_at(), Aleph::CA::alive_density(), Aleph::all(), Aleph::all(), Aleph::all(), Aleph::all(), Aleph::FunctionalMixin< Derived, Type >::all(), Aleph::FunctionalMixin< Derived, Type >::all(), Aleph::DynSkipList< Key, Compare >::all(), Aleph::DynSkipList< Key, Compare >::all(), Aleph::DelaunayTriangulationBowyerWatson::all_collinear(), Aleph::VoronoiDiagramFortune::all_collinear(), Aleph::all_in_arc(), Aleph::string_search_detail::all_match_positions(), Aleph::all_out_arc(), Aleph::all_ready(), Aleph::all_unique(), Aleph::all_unique(), Aleph::stl_zip_detail::all_valid(), Aleph::std_zip_detail::all_valid(), Aleph::AhArenaAllocator::alloc(), Aleph::AhArenaAllocator::alloc_aligned(), Aleph::ArenaTreeAllocator< Node >::alloc_lval(), Aleph::ArenaTreeAllocator< Node >::alloc_rval(), Aleph::MemArray< T >::allocate(), Aleph::allocate(), Pointer_Table::allocate_above_heap(), Aleph::DynArray< T >::allocate_block(), Aleph::DynArray< T >::allocate_block(), Aleph::ODhashTable< Key, Cmp >::allocate_bucket(), Aleph::ODhashTable< Key, Cmp >::allocate_bucket(), Aleph::OLhashTable< Key, Cmp >::allocate_bucket(), Aleph::DynArray< T >::allocate_dir(), Aleph::DynArray< T >::allocate_dir(), Aleph::Graph_Anode< Node_Info >::allocate_more(), Aleph::DynArray< T >::allocate_segment(), Aleph::DynArray< T >::allocate_segment(), Aleph::ArrayHeap< T, Compare >::allocate_storage(), Aleph::FFT< Real >::analytic_group_delay_impl(), Aleph::FFT< Real >::analytic_phase_delay_impl(), Aleph::FFT< Real >::analytic_sos_group_delay_impl(), Aleph::Compiler_Line_Frontend::analyze(), Aleph::Compiler_MVP_Frontend::analyze(), Aleph::Compiler_Typed_Semantic_Analyzer::analyze_block(), Aleph::NTTExact::analyze_coefficients(), Aleph::analyze_dataflow_function(), Aleph::Test_Eulerian< GT, SN, SA >::analyze_digraph(), Aleph::Compiler_Typed_Semantic_Analyzer::analyze_expr(), Aleph::analyze_fit(), Aleph::Compiler_Semantic_Analyzer::analyze_function(), Aleph::Compiler_Typed_Semantic_Analyzer::analyze_function(), Aleph::Test_Eulerian< GT, SN, SA >::analyze_graph(), Aleph::Compiler_Semantic_Analyzer::analyze_imports(), Aleph::Compiler_Semantic_Analyzer::analyze_module(), Aleph::Compiler_Typed_Semantic_Analyzer::analyze_module(), Aleph::Compiler_Semantic_Analyzer::analyze_stmt(), Aleph::Compiler_Typed_Semantic_Analyzer::analyze_stmt(), Aleph::VisibilityPolygon::angle_less(), Aleph::SegmentArrangement::angle_lt(), Aleph::SegmentArrangement::angle_quad(), Aleph::VisibilityPolygon::angle_quadrant(), Aleph::zip_index_detail::any_of_tuple_impl(), Aleph::Path< GT >::append(), Aleph::Array< T >::append(), Aleph::DynIntervalTree< T, Compare >::append(), Aleph::MemArray< T >::append(), Aleph::Dyn_Slist_Nc< T >::append(), Aleph::DynDlist< T >::Iterator::append(), Aleph::MemArray< T >::append(), Aleph::Random_Set< T >::append(), Aleph::Dlink::append(), Aleph::HTList::append(), Aleph::DynDlist< T >::Iterator::append(), Aleph::MemArray< T >::append(), Aleph::Random_Set< T >::append(), Aleph::FFT< Real >::append_all(), Aleph::Compiler_HIR_Builder::append_argument(), Aleph::Gen_Centroid_Decomposition< GT, SA >::append_centroid_annotations(), Aleph::Huffman_Encoder_Engine::append_code(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::append_copy_range(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::append_copy_range(), Aleph::Diagnostic_Engine::append_diagnostic(), Aleph::Path< GT >::append_directed(), Aleph::Path< GT >::append_directed(), Aleph::GeomTriangleAdjacencyUtils::append_edge(), Aleph::PersistentHashMap< Key, T, Cmp >::append_entry(), Event_Table< Signature >::append_event_to_table(), Event_Table< void *(void *)>::append_event_to_table(), Aleph::Compiler_CFG_Detail::append_hir_expr_dump(), Aleph::Compiler_CFG_Detail::append_hir_stmt_dump(), Aleph::append_in_container(), Aleph::Compiler_Bytecode_Detail::append_indented_text(), Aleph::Compiler_CFG_Detail::append_indented_text(), Aleph::Compiler_IR_Detail::append_indented_text(), Aleph::Compiler_SSA_Detail::append_indented_text(), Aleph::Compiler_IR_Builder::append_instruction(), Aleph::Compiler_CFG_Lowering::append_linear_stmt(), Aleph::DynDlist< T >::Iterator::append_list(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::append_move_range(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::append_move_range(), Aleph::Tikz_Plane::append_option(), Aleph::SmallVector< T, N >::append_range(), Aleph::Compiler_Driver::append_run_failure_if_needed(), Aleph::Compiler_Generic_Driver::append_run_failure_if_needed(), Aleph::Compiler_Symbol_Bindings::append_symbol(), Aleph::Compiler_Type_Context::append_type_text(), Aleph::append_unique_tikz_library(), Aleph::Compiler_Typed_Semantic_Analyzer::append_unique_type_id(), Aleph::Compiler_Type_Substitution::apply(), Aleph::CA::Kernel2D< T, Rows, Cols >::apply(), Aleph::Assign_Sum_Policy< T >::apply(), Aleph::CA::Synchronous_Update< Order >::apply(), Aleph::CA::Sequential_Update< Order >::apply(), Aleph::CA::Random_Asynchronous_Update< Engine_Type >::apply(), Aleph::CA::Block_Synchronous_Update< BlockSize, Order >::apply(), ThrowingPostApplyDomain::apply(), Aleph::FFT< Real >::apply_analog_rational_transform(), Aleph::FFT< Real >::Plan::apply_bluestein_transform(), Aleph::NTT< MOD, ROOT >::Plan::apply_bluestein_transform(), Aleph::FFT< Real >::Plan::apply_butterflies(), Aleph::NTT< MOD, ROOT >::Plan::apply_butterflies(), Aleph::NTT< MOD, ROOT >::Plan::apply_butterflies_scalar(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::apply_current_cache_to_storage(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::apply_current_cache_to_storage(), Aleph::FFT< Real >::Plan::apply_mixed_radix_transform(), Aleph::Branch_And_Bound< Domain, ObjectivePolicy >::apply_move_and_recurse(), Aleph::CA::apply_multi_field_rule(), Aleph::FFT< Real >::apply_one_sided_density_scaling(), Aleph::NTT< MOD, ROOT >::Plan::apply_scalar_butterfly_range(), Aleph::bucket_sort_detail::apply_sort_with_temp(), Aleph::FFT< Real >::Plan::apply_transform(), Aleph::NTT< MOD, ROOT >::Plan::apply_transform(), Aleph::CA::Margolus_Update::apply_with_origin(), Aleph::BezierCurve::approximate_cubic(), Aleph::BezierCurve::approximate_quadratic(), Aleph::approximate_string_size(), arc_segment(), arc_trigon(), Aleph::Path< GT >::arcs(), Aleph::arcs(), Aleph::arcs_map(), Aleph::arcs_map(), Aleph::arcs_map(), Aleph::arcs_map(), Aleph::Test_Hamiltonian_Sufficiency< GT, SN, SA >::are_adjacent(), Aleph::are_eq(), Aleph::are_equal(), Aleph::are_equals(), Aleph::are_equals(), Aleph::are_tree_equal(), Aleph::are_tree_equal(), Aleph::GeomPolygonUtils::area(), Aleph::areEquivalents(), Aleph::areEquivalents(), Aleph::areSimilar(), Aleph::stl_comb_detail::arrangements_impl(), Aleph::array_to_DynArray(), Aleph::Testing::Deterministic_Start_Gate::arrive_and_wait(), Aleph::DelaunayTriangulationBowyerWatson::as_triangles(), Aleph::ConstrainedDelaunayTriangulation::as_triangles(), Aleph::assert_valid_tree_root(), assertMinHashContracts(), Aleph::Interpreter_Environment::assign(), assign_arcs(), Aleph::assign_container(), assign_distance(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::assign_label_s(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::assign_label_t(), assign_parrectangle(), assign_rectangle(), assign_scratch(), assign_shadow(), assign_tag(), assign_triangle(), assign_without_arc(), assign_without_node(), assign_xoffset(), assign_yoffset(), Aleph::CA::Tile_Cache< State, TileSide >::at(), Aleph::CA::Grid_Snapshot< T >::at(), Aleph::CA::Ghost_Lattice< Storage, Boundary, Halo >::at(), Aleph::CA::Graph_Lattice< T >::at(), Aleph::FlatMap< Key, T, Compare >::at(), Aleph::FlatMap< Key, T, Compare >::at(), Aleph::Gen_File_B_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::at(), Aleph::Gen_File_BPlus_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::at(), Aleph::mdspan< T, Extents, LayoutPolicy, AccessorPolicy >::at(), Aleph::CA::Multi_Field_Lattice< Layout, Boundary, Rank, Fields >::at_cell_impl(), Aleph::CA::Hex_Lattice< Storage, Boundary >::at_offset_even_r(), Aleph::CA::Ghost_Lattice< Storage, Boundary, Halo >::at_safe(), Aleph::CA::Graph_Lattice< T >::at_safe(), Aleph::CA::attach_observer(), Aleph::CA::attach_observer_graph(), Aleph::Network_Simplex< Net >::augment_and_find_leaving(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::augment_blossom(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::augment_blossom_rec(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::augment_matching(), Aleph::blossom_detail::Edmonds_Blossom_Matcher< GT, SA >::augment_matching(), Aleph::aumenting_path_maximum_flow(), Aleph::FFT< Real >::Plan::automatic_batch_simd_candidate(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::autoreduce_groebner_basis(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::autoreduced_generators(), avanceItor(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::avl_stack_at_base(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::avl_stack_at_base(), avl_to_btreepic(), Aleph::FFT< Real >::avx2_dispatch_available(), Aleph::NTT< MOD, ROOT >::avx2_dispatch_available(), Aleph::CA::axial_to_pixel_flat(), Aleph::CA::axial_to_pixel_pointy(), Aleph::FFT< Real >::axis_base_offsets(), Aleph::Filter_Iterator< Container, It, Show_Item >::backward(), Aleph::Random_Digraph< GT, Init_Node, Init_Arc >::balance_digraph_node(), Aleph::Random_Digraph< GT, Init_Node, Init_Arc >::balance_digraph_nodes_degree(), Aleph::Random_Graph< GT, Init_Node, Init_Arc >::balance_graph_nodes_degree(), Aleph::FFT< Real >::balance_polynomial_for_roots(), Aleph::HtdRbTree< Key, Compare >::balanceDownAndColor(), Aleph::HtdRbTreeRk< Key, Compare >::balanceDownAndColor(), bar(), Aleph::Triangle3D::barycentric(), basic_arithmetic(), Aleph::FFT< Real >::batched_plan_simd_backend(), Aleph::FFT< Real >::batched_sosfilt(), Aleph::FFT< Real >::batched_sosfilt(), Aleph::FFT< Real >::batched_stft(), Aleph::FFT< Real >::batched_stft(), Aleph::CA::Hashlife_Engine::bbox(), Aleph::Tikz_Plane::bbox_of(), Aleph::Tikz_Plane::bbox_of(), Aleph::Tikz_Plane::bbox_of(), Aleph::Tikz_Plane::bbox_of(), Aleph::Tikz_Scene::beamer_picture_scale(), Aleph::Generator< T >::begin(), Aleph::StlZipView< Containers >::begin(), Aleph::UniZipView< Containers >::begin(), benchmark_array_algorithms(), benchmark_comparison(), benchmark_contiguous_array(), benchmark_hash_set(), benchmark_list_algorithms(), Aleph::benchmark_maxflow(), benchmark_set(), benchmark_skip_list(), benchmark_std_set(), benchmark_std_unordered_set(), benchmark_tree_set(), Aleph::FFT< Real >::bessel_bandpass(), Aleph::FFT< Real >::bessel_bandstop(), Aleph::FFT< Real >::bessel_highpass(), Aleph::FFT< Real >::bessel_lowpass(), Aleph::FFT< Real >::bessel_prototype(), Aleph::Maximize_Objective< Value >::better(), Aleph::Minimize_Objective< Value >::better(), Aleph::Directed_Find_Path< GT, Itor, SA >::bfs(), Aleph::Directed_Find_Path< GT, Itor, SA >::bfs(), Aleph::Breadth_First_Traversal< GT, Operation, SA >::bft(), Aleph::NTT< MOD, ROOT >::bigint_multiply(), Aleph::FFT< Real >::bilinear_substitute_polynomial(), Aleph::FFT< Real >::bilinear_transform(), Aleph::FFT< Real >::bilinear_transform(), Aleph::FFT< Real >::bilinear_transform_impl(), bin_coef(), Aleph::bin_to_forest(), Aleph::bin_to_tree(), Aleph::timsort_detail::binary_insertion_sort(), Aleph::binary_search(), Aleph::binary_search(), Aleph::binary_search_dup(), Aleph::binary_search_rec(), Aleph::Compiler_Type_Substitution::bind(), Aleph::Compiler_IR_Lowering::Module_Builder::bind(), Aleph::bind1st(), Aleph::bind2nd(), Aleph::Compiler_Driver::bind_host_function(), Aleph::Compiler_Generic_Driver::bind_host_function(), Aleph::Interpreter_Runtime::bind_host_function(), Aleph::Compiler_Type_Unifier::bind_variable(), Aleph::binindex_dup(), Aleph::binindex_dup(), biodiversity_survey(), Aleph::Gen_Polynomial< Coefficient >::bisect_root(), Aleph::VoronoiDiagramFromDelaunay::bisector_halfplane_for_site(), Aleph::patricia_trie_detail::Bitwise_Trie_Utils< UInt >::bit_at(), Aleph::Compiler_Dataflow_Detail::bit_set_subtract(), Aleph::Compiler_Dataflow_Detail::bit_set_union(), HashAvalancheTest::bitDifference(), Aleph::BitArray::bits_list(), Aleph::bits_to_tree(), Aleph::bits_to_tree_helper(), Aleph::HtdRbTree< Key, Compare >::blackHeight(), Aleph::FFT< Real >::blackman_window(), Aleph::CA::ca_io_detail::blank(), Aleph::blossom_maximum_cardinality_matching(), Aleph::blossom_maximum_weight_matching(), Aleph::blossom_minimum_cost_matching(), Aleph::blossom_minimum_cost_perfect_matching(), Aleph::Compiler_Dataflow_Detail::boolean_constant(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::borrow_from_next(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::borrow_from_next(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::borrow_from_next(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::borrow_from_prev(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::borrow_from_prev(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::borrow_from_prev(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::borrow_from_prev(), KnapsackDomain::bound(), Aleph::planarity_detail::bounding_boxes_intersect(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::box_contains_box(), Aleph::boyer_moore_horspool_search(), Aleph::detail::bplus_equiv(), Aleph::breadth_first_traversal(), Aleph::breadth_first_traversal(), Aleph::VoronoiDiagramFortune::breakpoint_x(), brute_convex_distance_squared(), brute_distance_squared(), Aleph::ClosestPairDivideAndConquer::brute_force(), brute_path_distinct(), brute_subtree_distinct(), Aleph::bsearch_dup(), Aleph::bsearch_dup(), Aleph::bsearch_dup(), Aleph::RevisedSimplex< T >::btran(), K2Tree< T >::bu_insert(), Aleph::bucket_sort(), Aleph::bucket_sort_detail::bucket_sort_impl(), Aleph::ODhashTable< Key, Cmp >::bucket_to_index(), Aleph::Aho_Corasick::build(), Aleph::Gen_Cartesian_Tree< T, Comp >::build(), Aleph::Gen_Disjoint_Sparse_Table< T, Op >::build(), Aleph::Gen_Mo_On_Trees< GT, Policy >::build(), Aleph::Gen_Mo_On_Tree_Node< T, Policy >::build(), Aleph::AABBTree::build(), Aleph::AABBTree::build(), Aleph::KDTreePointSearch::build(), Aleph::RangeTree2D::build(), Aleph::Naive_Suffix_Tree::build(), Aleph::Gen_Segment_Tree< T, Op >::build(), Aleph::Gen_Lazy_Segment_Tree< Policy >::build(), Aleph::Segment_Tree_Beats< T >::build(), Aleph::blossom_detail::Edmonds_Blossom_Matcher< GT, SA >::build_adjacency(), Aleph::tree_dp_detail::Tree_Topology< GT, SA >::build_adjacency(), Aleph::ConstrainedDelaunayTriangulation::build_adjacency(), Aleph::blossom_weighted_detail::mwmatching::impl::Problem_Data< WeightType >::build_adjacent_graph(), Aleph::build_array(), Aleph::PolygonOffset::build_augmented(), K2Tree< T >::build_balanced(), Aleph::Rope< Char, LeafSize >::build_balanced_from_leaves(), build_barbell_graph(), Aleph::Gen_HLD_Path_Query< GT, T, Op, SA >::build_base_array(), Aleph::Gen_HLD_Path_Query< GT, T, Op, SA >::build_base_from_node_info(), build_campus_network(), Aleph::Gen_Centroid_Decomposition< GT, SA >::build_centroid_tree(), build_city_graph(), Aleph::build_combinations(), Aleph::build_combinations(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::build_combinatorial_embedding(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::build_combinatorial_embedding_bruteforce(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::build_combinatorial_embedding_linear_lr(), Aleph::build_combs(), build_complete_bipartite(), build_complete_graph(), build_complete_graph(), build_complete_graph(), Aleph::FFT< Real >::build_complex_input(), build_computer_network(), Aleph::build_container(), Aleph::GraphCopyWithMapping< GT, Tree >::build_copy(), build_courses_graph(), build_cross_net_graph(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::build_cycle(), build_cycle_graph(), build_cyclic_graph(), build_datacenter_network(), Aleph::Gen_Heavy_Light_Decomposition< GT, SA >::build_decomposition(), Aleph::lca_detail::Rooted_Tree_Data< GT, SA >::build_dfs_data(), Aleph::build_dominator_tree(), Aleph::build_dynlist(), Aleph::Gen_Euler_Tour_LCA< T, Comp >::build_euler_tour(), Aleph::MonotonePolygonTriangulation::build_faces_from_diagonals(), Aleph::Range_Fenwick_Tree< T >::build_from_diffs(), Aleph::Rope< Char, LeafSize >::build_from_view(), Aleph_Test_Helpers::build_graph_with_unit_arcs(), Aleph_Test_Helpers::build_graph_with_unit_arcs(), Aleph::build_gray_code(), build_grid_network(), Aleph::Compiler_Line_Frontend::build_hir_operand(), Aleph::build_index(), Aleph::build_index_ptr(), Aleph::build_index_ptr(), build_int_list(), Aleph::Compiler_Line_Frontend::build_ir_operand(), Aleph::Gen_Binary_Lifting_LCA< GT, SA >::build_jump_table(), Aleph::Karger_Min_Cut< GT, SA >::build_kgraph(), Aleph::build_level_graph(), build_module_graph(), Aleph::detail::build_msg_impl(), build_net_graph(), build_network_graph(), Aleph::RangeTree2D::build_node(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::build_nonplanar_certificate(), Aleph::build_optimal_tree(), Aleph::tree_dp_detail::Tree_Topology< GT, SA >::build_order(), Aleph::FFT< Real >::build_padded_frame_from_prefix(), Aleph::CA::ca_gif_detail::build_palette(), Aleph::build_pars_list(), Aleph::build_pars_list(), Aleph::build_pars_list(), Aleph::build_pars_list(), Aleph::build_pars_list(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::build_path(), Aleph::Bidirectional_BFS< GT, Fwd_Itor, Bck_Itor, SA >::build_path(), build_path_graph(), Aleph::build_perms(), Aleph::build_planar_dual_graph(), Aleph::build_planar_dual_graph(), build_point_set(), Aleph::PolygonOffset::build_poly(), Aleph::BooleanPolygonOperations::build_poly(), build_poly_graph(), Aleph::ConvexPolygonIntersectionBasic::build_polygon(), Aleph::HalfPlaneIntersection::build_polygon(), Aleph::build_post_dominator_tree(), Aleph::build_postorder(), Aleph::NTT< MOD, ROOT >::build_product_tree(), build_project_graph(), build_ptr_list(), build_random_graph(), build_random_graph(), Aleph::FFT< Real >::build_real_input(), Aleph::build_residual_net(), Aleph::Johnson< GT, Distance, Ait, NAit, SA >::build_reverse_mappings(), Aleph::Gen_Euler_RMQ_LCA< GT, SA >::build_rmq(), Aleph::FFT< Real >::OverlapSave::build_segment_spectrum(), Aleph::Gen_HLD< GT, T, Op, SA >::build_segment_tree(), Aleph::FFT< Real >::OverlapAddBank::build_signal_batch(), Aleph::FFT< Real >::OverlapAddBank::build_signal_batch(), Aleph::FFT< Real >::OverlapAdd::build_signal_block(), Aleph::FFT< Real >::OverlapAddBank::build_signal_block(), Aleph::hld_detail::HLD_Tree_Data< GT, SA >::build_simple_adjacency(), Aleph::lca_detail::Rooted_Tree_Data< GT, SA >::build_simple_adjacency(), Aleph::tree_decomposition_detail::Rooted_Tree_Topology< GT, SA >::build_simple_adjacency(), build_social_network(), Aleph::Network_Simplex< Net >::build_spanning_tree(), Aleph::build_spanning_tree(), Aleph::Gen_Euler_Tour_LCA< T, Comp >::build_sparse_table(), Aleph::build_subgraph(), Aleph::Build_Subgraph< GT, SA >::build_subgraph(), Aleph::k_shortest_paths_detail::build_suffix_index(), Aleph::k_shortest_paths_detail::build_suffix_index_digraph(), Aleph::k_shortest_paths_detail::build_suffix_index_with_itor(), Aleph::k_shortest_paths_detail::build_suffix_state(), build_supply_chain(), build_tree(), Aleph::build_tree(), Aleph::Lengauer_Tarjan_Post_Dominators< GT, SA >::build_tree(), Aleph::Lengauer_Tarjan_Dominators< GT, SA >::build_tree(), Aleph::Find_Depth_First_Spanning_Tree< GT, SA >::build_tree(), Aleph::Find_Breadth_First_Spanning_Tree< GT, SA >::build_tree(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::build_tree(), Aleph::Find_Depth_First_Spanning_Tree< GT, SA >::build_tree(), Aleph::ShortestPathInPolygon::build_tris(), build_two_clusters(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::build_underlying_simple_graph(), Aleph::graph_coloring_detail::build_undirected_adj(), Aleph::Gen_Sparse_Table< T, Op >::build_upper_levels(), Aleph::CA::ca_mf_engine_detail::build_views(), build_web_graph(), build_weighted_chain(), Aleph::FFT< Real >::build_weighted_frequency_grid(), build_wheel(), buscar_ciudad(), Aleph::FFT< Real >::butterworth_bandpass(), Aleph::FFT< Real >::butterworth_bandstop(), Aleph::FFT< Real >::butterworth_highpass(), Aleph::FFT< Real >::butterworth_lowpass(), Aleph::FFT< Real >::butterworth_prototype(), Aleph::Compiler_Backend_C_Detail::c_string_literal(), calculus_example(), Aleph::Compiler_Bytecode_VM::call_function(), Aleph::Interpreter_Runtime::call_hir_function(), Aleph::ObjectiveIncumbent< Solution, ObjectivePolicy >::can_improve(), Aleph::detail::PersistentTreapNodeOps< Node, Key, Compare >::can_join(), Aleph::ConvexPolygonDecomposition::can_merge(), TimeoutQueue::cancel_by_id(), Aleph::cancel_cycle(), TimeoutQueue::cancel_delete_event(), TimeoutQueue::cancel_event(), Aleph::Compact_Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::capacity(), Aleph::Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::capacity(), Aleph::PersistentVector< T >::capacity_for_shift(), Aleph::capacity_scaling_maximum_flow(), Aleph::FFT< Real >::carlson_rf_impl(), Aleph::Fibonacci_Heap< T, Compare >::cascading_cut(), Aleph::Gen_Polynomial< Coefficient >::cauchy_bound(), cdt_has_edge(), Aleph::CA::ca_scheme_detail::cell_count(), Aleph::CA::cell_diff_count(), Aleph::CA::cell_key_from_coord(), Aleph::CA::cell_seed(), Aleph::CA::cell_seed(), Aleph::polynomial_detail::centered_from_mod_u64(), Aleph::Polygon::centroid(), Aleph::FFT< Real >::BatchedISTFTProcessor::channel_options(), Aleph::Rope< Char, LeafSize >::char_at(), Aleph::Compiler_Lexer::char_at(), Aleph::char_to_nibble(), Aleph::FFT< Real >::chebyshev1_bandpass(), Aleph::FFT< Real >::chebyshev1_bandstop(), Aleph::FFT< Real >::chebyshev1_highpass(), Aleph::FFT< Real >::chebyshev1_lowpass(), Aleph::FFT< Real >::chebyshev1_prototype(), Aleph::FFT< Real >::chebyshev2_bandpass(), Aleph::FFT< Real >::chebyshev2_bandstop(), Aleph::FFT< Real >::chebyshev2_highpass(), Aleph::FFT< Real >::chebyshev2_lowpass(), Aleph::FFT< Real >::chebyshev2_prototype(), Aleph::Dlink::check(), Aleph::Path< GT >::check(), OhashCommon< HashTbl, Key >::Iterator::check(), Event_Table< void *(void *)>::check(), check(), Aleph::SweepLineSegmentIntersection::check_and_enqueue(), Aleph::check_baseball_elimination(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingVerifier< WeightType >::check_blossom(), Aleph::check_bst(), Aleph::check_bst_range(), Aleph::detail::check_composite(), check_delaunay_for_non_constrained(), Aleph::AStar_Min_Path< GT, Distance, Heuristic, Itor, SA, HeapT >::check_heuristic_admissibility(), Aleph::hld_detail::HLD_Tree_Data< GT, SA >::check_id(), Aleph::lca_detail::Rooted_Tree_Data< GT, SA >::check_id(), Aleph::tree_decomposition_detail::Rooted_Tree_Topology< GT, SA >::check_id(), Aleph::blossom_weighted_detail::mwmatching::impl::check_input_graph(), Aleph::PatriciaSet< UInt >::check_invariants(), Aleph::PatriciaMap< UInt, T >::check_invariants(), Aleph::patricia_trie_detail::Bitwise_Trie_Utils< UInt >::check_invariants_rec(), check_list(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::check_max(), Aleph::Net_Graph< NodeT, ArcT >::check_network(), Aleph::Net_Graph< NodeT, ArcT >::check_node(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::check_painted_arcs(), Aleph::test_helpers::check_snapshot_node(), Aleph::test_helpers::detail::check_snapshot_node_impl(), Aleph::CA::ca_continuous_detail::checked_bounded(), Aleph::matgraph_detail::checked_index_array(), Aleph::matrix_chain_detail::checked_mul(), Aleph::Tree_Node< T >::children(), Aleph::Tree_Node< T >::children_nodes(), Aleph::Segment_Tree_Beats< T >::chmax_impl(), Aleph::Segment_Tree_Beats< T >::chmin_impl(), Aleph::Gen_Centroid_Decomposition< GT, SA >::choose_centroid(), Aleph::FFT< Real >::choose_remez_extrema(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::choose_subtree(), Aleph::Naive_Suffix_Tree::choose_terminal(), Aleph::chromatic_number(), Aleph::FunctionalMixin< Derived, Type >::chunk(), Aleph::parallel_detail::chunk_size(), Aleph::BitArray::circular_left_shift(), Aleph::BitArray::circular_right_shift(), Aleph::Triangle::circumcenter(), Aleph::VoronoiDiagramFromDelaunay::circumcenter(), Aleph::CA::ca_continuous_detail::clamp_unit_after_check(), Aleph::dp_optimization_detail::clamped_cast(), Aleph::Compiler_Bytecode_Detail::classify_constant(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::classify_k33(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::classify_k5(), Aleph::MonotonePolygonTriangulation::classify_vertex(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::clean_avl_stack(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::clean_avl_stack(), Aleph::PolygonOffset::cleanup(), Pointer_Table::cleanup_free_table(), Aleph::Compact_Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::Bucket::clear(), Aleph::Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::Bucket::clear(), Aleph::Convex_Hull_Trick< T >::clear(), Aleph::Li_Chao_Tree< T >::clear(), Aleph::MinHash< T >::clear(), Pointer_Table::clear(), Aleph::Prefix_Tree_Map< T >::clear(), Aleph::Reservoir_Sampler< T >::clear(), Aleph::ConcurrentHashMap< Key, T, Cmp, Shards >::clear(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::clear(), Aleph::Compact_Quotient_Filter< T >::clear(), Aleph::Array_Graph< __Graph_Node, __Graph_Arc >::clear(), Aleph::DynSlist< T >::clear(), Aleph::Huffman_Encoder_Engine::clear_build_state(), Aleph::FFT< Real >::OverlapAddBank::clear_channel_overlap(), Aleph::Compact_Quotient_Filter< T >::clear_element(), Aleph::Quotient_Filter< T >::clear_element(), Aleph::FFT< Real >::OverlapSave::clear_history(), Aleph::Cookie_Guard< GT >::clear_now(), Aleph::FFT< Real >::OverlapAdd::clear_overlap(), Aleph::PersistentVector< T >::clear_rec(), Aleph::FFT< Real >::PartitionedConvolver::clear_state(), Aleph::BitArray::clear_unused_bits_in_last_byte(), Aleph::VoronoiDiagramFromDelaunay::clipped_cells(), Aleph::VoronoiDiagramFromDelaunay::clipped_cells(), Aleph::VoronoiDiagram::clipped_cells(), Aleph::VoronoiDiagramFortune::clipped_cells(), Aleph::VoronoiDiagramFromDelaunay::clipped_cells(), Aleph::VoronoiDiagramFromDelaunay::clipped_cells(), Aleph::VoronoiDiagramFortune::clipped_cells(), Aleph::VoronoiDiagramFromDelaunay::clipped_cells_indexed(), Aleph::VoronoiDiagramFromDelaunay::clipped_cells_indexed(), Aleph::VoronoiDiagramFromDelaunay::clipped_cells_indexed(), Aleph::VoronoiDiagramFromDelaunay::clipped_cells_indexed(), Aleph::Cnode::clone(), Aleph::Prefix_Tree_Map< T >::Node::clone(), Aleph::Cnode::clone(), Aleph::Prefix_Tree_Map< T >::Node::clone_into(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::clone_node(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::clone_node(), Aleph::PatriciaSet< UInt >::clone_node(), Aleph::PatriciaMap< UInt, T >::clone_node(), Aleph::RadixTree< T, Char >::clone_node(), Aleph::clone_tree(), Aleph::clone_tree(), Aleph::Polygon::close(), RingFileCache< T >::close(), Aleph::MemArray< T >::close_gap(), Aleph::close_gap(), Aleph::close_token_scanning(), Aleph::ConvexPolygonDistanceGJK::closest_from_simplex(), Aleph::ClosestPairDivideAndConquer::closest_segment(), Aleph::BruteForceConvexHull::CmpSegment::cmp_point(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::coeff_at(), Aleph::Gen_Polynomial< Coefficient >::coeff_at(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::coeff_is_zero(), Aleph::Gen_Polynomial< Coefficient >::coeff_is_zero(), Aleph::NTTExact::coeff_to_string(), Aleph::Compiler_Typed_Semantic_Analyzer::collect_binding_free_type_variables(), Aleph::planarity_detail::collect_certificate_nodes(), Aleph::Gen_Centroid_Decomposition< GT, SA >::collect_component_nodes(), Aleph::Compiler_Typed_Semantic_Analyzer::collect_environment_free_type_variables(), Aleph::Compiler_Typed_Semantic_Analyzer::collect_free_type_variables(), Aleph::Compiler_Generic_Driver::collect_frontend_state(), Aleph::PersistentHashMap< Key, T, Cmp >::collect_items(), Aleph::RadixTree< T, Char >::collect_keys(), Aleph::PersistentHashMap< Key, T, Cmp >::collect_keys(), Aleph::Naive_Suffix_Tree::collect_leaf_suffixes(), Aleph::Tikz_Plane::collect_legend_entries(), Aleph::Alpha_Beta< Domain >::collect_ordered_moves(), Aleph::Branch_And_Bound< Domain, ObjectivePolicy >::collect_ordered_moves(), Aleph::Tikz_Scene::collect_required_libraries(), Aleph::TestVisual::collect_scene_points(), Aleph::SegmentSegmentIntersection::collinear_overlap(), color_legend(), Aleph::HtdRbTree< Key, Compare >::colorParentAndSibling(), Aleph::HtdRbTreeRk< Key, Compare >::colorParentAndSibling(), Aleph::HtdRbTree< Key, Compare >::colorSiblingAsRed(), Aleph::HtdRbTreeRk< Key, Compare >::colorSiblingAsRed(), Aleph::combination_count(), Aleph::stl_comb_detail::combinations_impl(), Aleph::command_line_to_string(), Aleph::Bloom_Filter< T >::common_hashes(), Aleph::RadixTree< T, Char >::common_prefix_length(), Aleph::FFT< Real >::comp_ellint_1_impl(), Aleph::FFT< Real >::compact_real_batch_spectra(), Aleph::FFT< Real >::compact_real_spectrum(), compare_algorithms(), compare_with_floyd(), Aleph::compiler_bind_module_surfaces(), Aleph::compiler_build_module_name_table(), Aleph::compiler_build_module_semantic_environment(), Aleph::compiler_driver_action_name(), Aleph::compiler_dump_bytecode_function(), Aleph::compiler_dump_bytecode_globals(), Aleph::compiler_dump_bytecode_module(), Aleph::compiler_dump_dataflow_analysis(), Aleph::compiler_dump_function(), Aleph::compiler_dump_hir_function(), Aleph::compiler_dump_hir_module(), Aleph::compiler_dump_import_decl(), Aleph::compiler_dump_ir_function(), Aleph::compiler_dump_ir_module(), Aleph::compiler_dump_module(), Aleph::compiler_dump_ssa_function(), Aleph::compiler_dump_ssa_module(), Aleph::compiler_dump_type_decl(), Aleph::compiler_emit_module_name_resolution_diagnostic(), Aleph::compiler_find_module_semantic_environment(), Aleph::compiler_hir_merge_spans(), Aleph::compiler_link_module_surfaces(), Aleph::compiler_merge_spans(), Aleph::compiler_parse_driver_action(), Aleph::compiler_render_module_bindings(), Aleph::compiler_render_module_linkage(), Aleph::compiler_render_module_semantic_environment(), Aleph::compiler_resolve_module_name(), Aleph::compiler_resolve_module_name(), Aleph::CA::Bench::compiler_string(), Aleph::compiler_token_is_comment(), Aleph::Compiler_Bytecode_VM::complete_current_frame(), Aleph::FFT< Real >::complete_elliptic_first_kind(), Aleph::ArrayQueue< T >::complete_put(), Aleph::complete_rows(), Aleph::completed(), Aleph::ZipIterator< C >::completed(), Aleph::EnumZipIterator< C >::completed(), Aleph::Gen_Polynomial< Coefficient >::compose(), Aleph::Assign_Sum_Policy< T >::compose(), Aleph::Add_Sum_Policy< T >::compose(), Aleph::Add_Min_Policy< T >::compose(), Aleph::Add_Max_Policy< T >::compose(), Aleph::AssignLazyTag< T >::compose(), Aleph::Tikz_Scene::compose_beamer_class_options(), Aleph::k_shortest_paths_detail::compose_candidate(), Aleph::k_shortest_paths_detail::compose_general_candidate(), Aleph::Graph_Anode< Node_Info >::compress(), Aleph::Lengauer_Tarjan_Dominators< GT, SA >::compress(), Aleph::Johnson< GT, Distance, Ait, NAit, SA >::compute_all_pairs_distances(), compute_assignment_cost(), Aleph::Net_Cap_Graph< NodeT, ArcT >::compute_aux_net(), Aleph::compute_bipartite(), Aleph::compute_bipartite_all_components(), Aleph::Compiler_Dataflow_Detail::compute_block_use_def(), Aleph::Unconnected_Components< GT, SA >::compute_blocks(), Aleph::Compute_Cut_Nodes< GT, SA >::compute_blocks(), Aleph::Gen_Sparse_Table< T, Op >::compute_cells(), compute_coordinates_for_forest_and_set_picture_size(), Aleph::k_shortest_paths_detail::compute_cost_from_arcs(), Aleph::compute_cut_nodes(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::compute_cycle(), compute_definitive_coordinates_for_node(), Aleph::BooleanPolygonOperations::compute_difference(), Aleph::compute_dominance_frontiers(), Aleph::Compiler_SSA_Detail::compute_dominance_info(), Aleph::compute_dominators(), Eepic_Plane::compute_extreme_points(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::compute_faces_from_rotation(), Eepic_Plane::compute_geom_plane(), Aleph::compute_height(), Aleph::hld_detail::HLD_Tree_Data< GT, SA >::compute_hld_positions(), Aleph::Lengauer_Tarjan_Dominators< GT, SA >::compute_idom(), Aleph::BooleanPolygonOperations::compute_intersection(), Aleph::Lengauer_Tarjan_Post_Dominators< GT, SA >::compute_ipdom(), Aleph::Gen_Disjoint_Sparse_Table< T, Op >::compute_levels(), Aleph::Gen_Sparse_Table< T, Op >::compute_levels(), Aleph::Source_Manager::compute_line_starts(), Aleph::HyperLogLog< T >::compute_m_or_throw(), Aleph::Tikz_Plane::compute_mapping(), Aleph::compute_maximum_cardinality_bipartite_matching(), Aleph::compute_maximum_cardinality_general_matching(), Aleph::compute_maximum_weight_general_matching(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::compute_mbr(), Aleph::compute_min_cut(), compute_min_cut_capacity(), Aleph::Karger_Min_Cut< GT, SA >::compute_min_cut_size(), Aleph::AStar_Min_Path< GT, Distance, Heuristic, Itor, SA, HeapT >::compute_min_paths_tree(), Aleph::Dijkstra_Min_Paths< GT, Distance, Itor, SA, HeapT >::compute_min_paths_tree(), Aleph::compute_minimum_cost_general_matching(), Aleph::compute_minimum_cost_perfect_general_matching(), Aleph::CA::ca_neighborhood_detail::compute_moore_offsets(), Aleph::compute_nodes_in_level_helper(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::compute_nodes_weights(), Aleph::compute_optimal_costs(), Aleph::AStar_Min_Path< GT, Distance, Heuristic, Itor, SA, HeapT >::compute_partial_min_paths_tree(), Aleph::Dijkstra_Min_Paths< GT, Distance, Itor, SA, HeapT >::compute_partial_min_paths_tree(), Aleph::AStar_Min_Path< GT, Distance, Heuristic, Itor, SA, HeapT >::compute_partial_path(), Aleph::Simplex< T >::compute_pivot_col(), Aleph::Simplex< T >::compute_pivot_row(), Aleph::compute_post_dominance_frontiers(), Aleph::compute_post_dominators(), Aleph::PolygonOffset::compute_raw_offset(), Aleph::Compiler_Dataflow_Detail::compute_reachability(), Aleph::Compiler_SSA_Detail::compute_reachable_blocks(), Aleph::RevisedSimplex< T >::compute_reduced_cost(), Aleph::compute_shortest_path_funnel_trace(), Aleph::hld_detail::HLD_Tree_Data< GT, SA >::compute_sizes_and_parents(), Aleph::Segment::compute_slope(), Aleph::compute_stats(), Aleph::compute_stats(), Aleph::Ellipse::compute_tangents(), Aleph::Segment::compute_tgt_point(), Aleph::Now::compute_time_diff(), Aleph::compute_tree(), Aleph::BooleanPolygonOperations::compute_union(), Aleph::CA::ca_neighborhood_detail::compute_von_neumann_offsets(), Aleph::computeHeightRec(), Aleph::concat(), Aleph::concat(), Aleph::Rope< Char, LeafSize >::concat(), Aleph::Dlink::concat_list(), Aleph::Rope< Char, LeafSize >::concat_nodes(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::conflicting(), Aleph::Random_Graph< GT, Init_Node, Init_Arc >::connect(), Aleph::Random_Digraph< GT, Init_Node, Init_Arc >::connect(), Aleph::List_Graph< _Graph_Node, _Graph_Arc >::connect_arc(), Random_Network_Flow< Net >::connect_ranks(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::connected(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::connected_components(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::connected_components(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::connected_components(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::connected_components(), Aleph::NTTExact::conservative_bound(), Aleph::BestSolution< Solution, Compare >::consider(), Aleph::BestSolution< Solution, Compare >::consider(), Aleph::Fibonacci_Heap< T, Compare >::consolidate(), OhashCommon< HashTbl, Key >::const_me(), HashStats< HashTbl >::const_me(), Aleph::Compiler_Dataflow_Detail::constant_from_instruction(), Aleph::Compiler_Bytecode_Detail::constant_to_string(), Aleph::Compiler_Dataflow_Detail::constant_to_string(), Aleph::Compiler_Bytecode_Interpreter_Detail::constant_to_value(), Aleph::Compiler_Dataflow_Detail::constant_vector_equals(), Aleph::containers_eq(), Aleph::Compact_Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::Bucket::contains(), Aleph::ConcurrentHashMap< Key, T, Cmp, Shards >::contains(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::contains(), Aleph::TrapezoidalMapPointLocation::Result::contains(), Aleph::Tetrahedron::contains(), Aleph::PointInPolygonWinding::contains(), Aleph::Cnode::contains(), Aleph::Prefix_Tree::contains(), Aleph::Naive_Suffix_Tree::contains(), Aleph::Bloom_Filter< T >::contains(), Aleph::Compact_Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::contains(), Aleph::Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::contains(), Aleph::Compact_Quotient_Filter< T >::contains(), Aleph::Quotient_Filter< T >::contains(), Aleph::Interval< T >::contains(), Aleph::Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::Bucket::contains(), Aleph::Aho_Corasick::contains_any(), Aleph::Compiler_CFG_Detail::contains_block_id(), Aleph::Compiler_IR_Detail::contains_block_id(), Aleph::Compiler_SSA_Detail::contains_block_id(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::contains_equal_polynomial(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::contains_ideal(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::contains_in(), QuadTree::contains_only(), OhashCommon< HashTbl, Key >::contains_or_insert(), OhashCommon< HashTbl, Key >::contains_or_insert(), Aleph::k_shortest_paths_detail::contains_path(), Aleph::LineEq::contains_point(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::content(), Aleph::Gen_Polynomial< Coefficient >::content(), Aleph::contiguous_range(), Aleph::GenLinearHashTable< Key, BucketType, Cmp >::contract(), Aleph::MemArray< T >::contract(), Aleph::Karger_Min_Cut< GT, SA >::contract(), Aleph::BezierCurve::control_bbox(), Aleph::FFT< Real >::OverlapAddBank::convolve(), Aleph::FFT< Real >::OverlapAddBank::convolve_impl(), Aleph::FFT< Real >::OverlapAdd::convolve_impl(), Aleph::CA::ca_scheme_detail::coord_from_hash(), Aleph::Ady_Mat< GT, __Entry_Type, SA >::copy(), Aleph::DynHashTable< Key, HashTable, Cmp >::copy(), Aleph::Copy_Graph< GT, SN, SA >::copy(), Aleph::copy(), Aleph::Matrix_Graph< GT, SA >::copy(), Aleph::DynArray< T >::copy_array(), Aleph::copy_backward(), Aleph::detail::copy_file_contents(), Aleph::DynIntervalTree< T, Compare >::copy_from(), OhashCommon< HashTbl, Key >::copy_from_table(), Aleph::copy_graph(), Aleph::Map_Matrix_Graph< GT, SA >::copy_list_graph(), Aleph::Bit_Mat_Graph< GT, SA >::copy_list_graph(), Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::copy_painted_min_paths_tree(), Aleph::Polygon::copy_regular_polygon(), QuadTree::copy_tree(), Aleph::copyRec(), Aleph::correlation(), Aleph::FFT< Real >::cosine_sum_window(), Aleph::Prefix_Tree::count(), Aleph::count(), count_active_trapezoids(), Aleph::CA::count_alive(), Aleph::Gen_Polynomial< Coefficient >::count_all_real_roots(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::count_components(), Aleph::Unconnected_Components< GT, SA >::count_components(), count_distinct_colors(), Aleph::count_if(), Aleph::Compiler_Dataflow_Detail::count_instructions(), Aleph::FFT< Real >::count_non_empty_real_batch(), Aleph::blossom_weighted_detail::mwmatching::impl::Problem_Data< WeightType >::count_num_vertex(), Aleph::BitArray::count_ones(), QuadNode::count_points(), Aleph::count_ready(), Aleph::Gen_Polynomial< Coefficient >::count_real_roots(), Aleph::timsort_detail::count_run_and_make_ascending(), Aleph::CA::count_state(), count_total_nodes(), Aleph::BitArray::count_zeros(), Aleph::Segment::counterclockwise_angle(), Aleph::Segment::counterclockwise_angle_with(), Aleph::sort_utils_detail::counting_bucket_count(), Aleph::sort_utils_detail::counting_sort_impl(), Aleph::sort_utils_detail::counting_sort_impl(), Aleph::sort_utils_detail::counting_sort_impl(), Aleph::sort_utils_detail::counting_sort_impl(), Aleph::counting_sort_indices(), Aleph::sort_utils_detail::counting_value_from_bucket(), Aleph::covariance(), Aleph::CA::Bench::cpu_string(), Aleph::CA::ca_png_detail::crc32(), Aleph::detail::crc32_add(), Aleph::detail::crc32_add_bytes(), Aleph::detail::crc32_finish(), Aleph::Random_Graph_Base< GT, Init_Node, Init_Arc >::create(), RingFileCache< T >::create(), Aleph::Array< T >::create(), Aleph::Compute_Cut_Nodes< GT, SA >::create_and_map_node(), Random_Network_Flow< Net >::create_arcs(), Random_Network_Flow< Net >::create_backward_arcs_in_rank(), Aleph::Compiler_IR_Builder::create_block(), Aleph::Matrix< Trow, Tcol, NumType >::create_by_columns(), Aleph::Matrix< Trow, Tcol, NumType >::create_by_rows(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::create_dummy_node(), HuffmanBtreepicTest::create_encoder(), Random_Network_Flow< Net >::create_forward_arcs_in_rank(), create_graph(), create_grid_graph(), create_list(), Aleph::Simplex< T >::create_matrix(), create_memarray(), Aleph::Random_Graph< GT, Init_Node, Init_Arc >::create_nodes_and_initialize_arc_index(), Aleph::Random_Digraph< GT, Init_Node, Init_Arc >::create_nodes_and_initialize_arc_index(), Aleph::Random_Digraph< GT, Init_Node, Init_Arc >::create_p(), Aleph::Random_Graph< GT, Init_Node, Init_Arc >::create_p(), create_queue(), create_random_list(), Random_Network_Flow< Net >::create_ranks(), Aleph::create_residual_arc(), Aleph::create_residual_arc(), BaseballEliminationTest::create_simple_division(), create_table(), create_table(), create_table(), QueueTheadsPool< T >::create_thread(), JohnsonTest::createCompleteGraph(), JohnsonTest::createSparseGraph(), Aleph::crt(), Aleph::csv_add_column(), Aleph::csv_count_if(), Aleph::csv_distinct(), Aleph::csv_escape(), Aleph::csv_filter(), Aleph::csv_filter_by_value(), Aleph::csv_find_by_value(), Aleph::csv_find_row(), Aleph::csv_get_column(), Aleph::csv_group_by(), Aleph::csv_inner_join(), Aleph::csv_is_rectangular(), Aleph::csv_join_horizontal(), Aleph::csv_read_all(), Aleph::csv_read_file(), Aleph::csv_read_row(), Aleph::csv_read_row(), Aleph::csv_rename_column(), Aleph::csv_select_columns(), Aleph::csv_skip_bom(), Aleph::csv_sort_by_column(), Aleph::csv_sort_by_column_numeric(), Aleph::csv_take_rows(), Aleph::csv_to_number(), Aleph::csv_transform(), Aleph::csv_transpose(), Aleph::csv_unique(), Aleph::csv_write_all(), Aleph::csv_write_file(), Aleph::csv_write_row(), ctors_test(), Aleph::BezierCurve::cubic(), cuckoo_theoretical_fp_rate(), Aleph::detail::current_process_id(), Aleph::Compiler_SSA_Detail::current_slot_value(), Aleph::DynArray< T >::cut(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::cut(), Aleph::HTList::cut(), Aleph::Dlink::cut_list(), Aleph::DynArray< T >::cut_ne(), Aleph::Compute_Cut_Nodes< GT, SA >::cut_nodes(), Aleph::Compute_Cut_Nodes< GT, SA >::cut_nodes(), Aleph::TrapezoidalMapPointLocation::dag_locate(), Aleph::damerau_levenshtein_distance(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::data_entry_count(), Aleph::Dnode< T >::data_to_node(), Aleph::data_to_pair(), Aleph::MapOpenHash< Key, Data, Cmp, HashTable >::data_to_pair(), Aleph::data_to_pair(), Aleph::MapOpenHash< Key, Data, Cmp, HashTable >::data_to_pair(), Aleph::GeomSerializer::dbl(), Aleph::dealloc(), Aleph::AhArenaAllocator::dealloc(), Aleph::AhArenaAllocator::deallocate(), Aleph::OLhashTable< Key, Cmp >::deallocate_bucket(), Aleph::ODhashTable< Key, Cmp >::deallocate_bucket_with_record(), Aleph::KDTreePointSearch::debug_snapshot(), Aleph::RangeTree2D::debug_snapshot(), Aleph::AABBTree::debug_snapshot(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::debug_snapshot(), Aleph::Compiler_Symbol_Bindings::declare(), Aleph::Compiler_Semantic_Analyzer::declare_symbol(), Aleph::Huffman_Decoder_Engine::decode(), Aleph::detail::Paged_Bounded_String_Codec< Capacity, SizeType >::decode(), Aleph::Gen_File_B_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::Record_Codec::decode(), Aleph::Gen_File_BPlus_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::Record_Codec::decode(), Aleph::detail::Paged_Value_Codec< T >::decode(), Aleph::detail::Paged_Value_Codec< std::array< T, N > >::decode(), Aleph::graph_coloring_detail::decode_color(), Aleph::Compiler_Bytecode_Detail::decode_escape_string(), Aleph::Interpreter_Runtime::decode_escaped_text(), Aleph::CA::Reproductions::decode_native_png(), Aleph::detail::decode_unsigned_le(), Aleph::decompose_flow(), Aleph::MonotonePolygonTriangulation::decompose_to_monotone_faces(), Aleph::decrease_flow(), Aleph::ODhashTable< Key, Cmp >::decrease_probe_counter(), Aleph::FFT< Real >::OverlapAdd::default_block_size(), Aleph::FFT< Real >::OverlapAddBank::default_block_size(), Aleph::FFT< Real >::OverlapSave::default_block_size(), Aleph::FFT< Real >::default_filtfilt_pad_length(), Aleph::FFT< Real >::PartitionedConvolver::default_partition_size(), Aleph::Gen_Polynomial< Coefficient >::definite_integral(), Aleph::CA::ca_checkpoint_detail::deflate_bytes(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::degree(), Aleph::Dlink::Iterator::del(), OhashCommon< HashTbl, Key >::Iterator::del(), Aleph::HTList::Iterator::del(), Aleph::DynList< T >::Iterator::del(), Aleph::BinTreeXt_Iterator< TreeType, Node, Key, Compare >::del(), Aleph::DynDlist< T >::Iterator::del(), Aleph::GenLhashTable< Key, BucketType, Cmp >::Iterator::del(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::Iterator::del(), Aleph::Dlink::del(), Aleph::DynSetTree< Key, Tree, Compare >::del(), Aleph::DynSkipList< Key, Compare >::del(), Aleph::Dlink::Iterator::del_ne(), Aleph::HTList::Iterator::del_ne(), Aleph::Fibonacci_Heap< T, Compare >::delete_node(), Aleph::Polygon::delete_points(), Aleph::CA::ca_ising_detail::delta_energy(), Aleph::MCF_Graph< NodeT, ArcT >::demands_satisfied(), Aleph::demangle(), Aleph::FFT< Real >::demean_copy(), demo_access(), demo_adjacency_matrix(), demo_advanced(), demo_advanced_algorithms(), demo_algorithm_comparison(), demo_algorithm_steps(), demo_any_path(), demo_arena_growth(), demo_assignment_problem(), demo_baseball_elimination(), demo_basic(), demo_basic_operations(), demo_basic_zip(), demo_benchmarking(), demo_bfs(), demo_bfs_topological_sort(), demo_biconnected_components(), demo_binary_heap(), demo_bitwise_operations(), demo_bridges(), demo_build(), demo_build_order(), demo_cache(), demo_cache_filter(), demo_calculator(), demo_callback_event(), demo_cancel_delete(), demo_cancellation(), demo_city_coordinates(), demo_collision_detection(), demo_command_autocomplete(), demo_compare_algorithms_on_logistics(), demo_comparison(), demo_config_store(), demo_connected(), demo_connected_components(), demo_conversion(), demo_convex_hull_cities(), demo_convex_hull_performance(), demo_cookie_safety(), demo_course_scheduling(), demo_coverage_area(), demo_cut_nodes(), demo_cycle_detection(), demo_dag_detection(), demo_dating(), demo_definition(), demo_degrees_of_separation(), demo_density(), demo_department_codes(), demo_dependency_analysis(), demo_dfs(), demo_dfs_topological_sort(), demo_diet_problem(), demo_digraph(), demo_dirac(), demo_directed(), demo_dot_export(), demo_dynarray(), demo_dynset_lhash(), demo_dynset_linhash(), demo_early_termination(), demo_encoding_decoding(), demo_enum_zip(), demo_epsilon(), demo_erdos_renyi(), demo_eulerian(), demo_eulerian_cycle(), demo_eulerian_digraph(), demo_eulerian_type(), demo_event_simulation(), demo_event_status(), demo_exam_scheduling(), demo_false_positives(), demo_fibonacci_heap(), demo_filtering(), demo_find_sccs(), demo_fixing_vulnerabilities(), demo_fold(), demo_fold_reduce(), demo_folding(), demo_formatting(), demo_fp(), demo_functional(), demo_geographic_points(), demo_geometric_primitives(), demo_grid_networks(), demo_grouping(), demo_halls_theorem(), demo_hash_dispatcher(), demo_hierholzer(), demo_identity(), demo_image_segmentation(), demo_initializer_list(), demo_integration(), demo_iteration(), demo_joining(), demo_json_export(), demo_konigsberg(), demo_kruskal_simulation(), demo_layered_networks(), demo_length_checking(), demo_linear_system(), demo_list_dynlist(), demo_log_buffer(), demo_map_coloring(), demo_map_filter(), demo_map_transformations(), demo_matching(), demo_matrix_arithmetic(), demo_matrix_mult(), demo_matrix_vector_mult(), demo_max_heap(), demo_memory_stats(), demo_merge(), demo_mincost_maxflow(), demo_mixed_containers(), demo_modifiable_mapping(), demo_modular_arithmetic(), demo_modular_combinatorics(), demo_modular_linalg(), demo_move_semantics(), demo_named_matrix(), demo_network_analysis(), demo_network_connectivity(), demo_network_vulnerability(), demo_numeric_mapping(), demo_odhash(), demo_optimal_params(), demo_ore_theorem(), demo_outer_product(), demo_parameters(), demo_path_compression(), demo_performance(), demo_performance(), demo_performance_comparison(), demo_periodic_event(), demo_perm_predicates(), demo_permutations(), demo_practical(), demo_practical_example(), demo_predicates(), demo_prefix_search(), demo_primality_factorization(), demo_priority_ordering(), demo_production_planning(), demo_project_selection(), demo_queue(), demo_random_networks(), demo_range_conversions(), demo_ranges(), demo_regions_menu(), demo_register_allocation(), demo_rescheduling(), demo_resilience_comparison(), demo_resource_allocation(), demo_row_col_operations(), demo_set_operations(), demo_sieve_of_eratosthenes(), demo_simple_bloom_filter(), demo_simple_event(), demo_slicing(), demo_space_comparison(), demo_spanning_tree(), demo_sparse_matrix(), demo_sparse_vector(), demo_special_cases(), demo_spell_checker(), demo_splitting(), demo_stack(), demo_state_machine(), demo_statistics(), demo_stl_compatibility(), demo_string_indexed_vector(), demo_strongly_connected(), demo_structured_data(), demo_subset_enumeration(), demo_survey_design(), demo_testing(), demo_text_processor(), demo_transformation(), demo_transformations(), demo_transportation_problem(), demo_transpose(), demo_traversal(), demo_traverse(), demo_tree_backends(), demo_tree_structure(), demo_triangulation_basic(), demo_triangulation_complex(), demo_trie_structure(), demo_trimming(), demo_tuple_conversions(), demo_tuple_operations(), demo_unified_api(), demo_utilities(), demo_validation(), demo_variadic_constructor(), demo_variadic_dispatcher(), demo_variadic_packing(), demo_vector_arithmetic(), demo_vector_dynarray(), demo_vector_dynlist(), demo_web_communities(), demo_word_frequency(), demo_zip_transformation(), demo_zip_utilities(), demo_zipping(), demonstrate_basic_operations(), demonstrate_bipartite_matching(), demonstrate_complexity(), demonstrate_flow_decomposition(), demonstrate_functional(), demonstrate_functional_features(), demonstrate_min_cut(), demonstrate_min_cut(), demonstrate_ranked_operations(), demonstrate_string_set(), demonstrate_tree_types(), Aleph::CA::density(), density_to_num_arcs(), Aleph::depth_first_traversal(), Aleph::depth_first_traversal(), Aleph::deque_to_Array(), Aleph::deque_to_DynArray(), Aleph::deque_to_DynList(), Aleph::stl_zip_detail::deref_all(), Aleph::std_zip_detail::deref_all(), Aleph::Gen_Polynomial< Coefficient >::derivative(), Aleph::FFT< Real >::design_bandstop_sections_without_numerator_roots(), Aleph::FFT< Real >::design_low_high_sections(), Aleph::FFT< Real >::design_prototype_sections(), Aleph::design_survey(), Aleph::FFT< Real >::design_transformed_sections(), Aleph::expected< void, E >::destroy(), Aleph::destroy_forest(), destroy_mutex(), Aleph::destroy_tree(), destroy_tree(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::destroy_vertex(), Aleph::Modular_Matrix< MatrixT >::determinant(), deway(), Aleph::ida_star_detail::dfs(), Aleph::Lengauer_Tarjan_Dominators< GT, SA >::dfs(), Aleph::Depth_First_Backtracking< Domain >::dfs(), Aleph::Branch_And_Bound< Domain, ObjectivePolicy >::dfs(), Aleph::Directed_Find_Path< GT, Itor, SA >::dfs(), Aleph::Directed_Find_Path< GT, Itor, SA >::dfs(), Aleph::Branch_And_Bound< Domain, ObjectivePolicy >::dfs_visited(), Aleph::Depth_First_Backtracking< Domain >::dfs_visited(), Aleph::Depth_First_Traversal< GT, Operation, SA >::dft(), Aleph::RotatingCalipersConvexPolygon::diameter(), Aleph::diff(), Aleph::DynSkipList< Key, Compare >::diff(), Aleph::To_Graphviz< GT, Node_Attr, Arc_Attr, SN, SA >::digraph(), Aleph::digraph_graphviz(), Aleph::CA::Multi_Field_Lattice< Layout, Boundary, Rank, Fields >::dimension(), Aleph::dinic_blocked(), Aleph::dinic_blocking_flow(), Aleph::dinic_current_arc(), Aleph::dinic_level(), Aleph::dinic_maximum_flow(), Aleph::Array_Graph< __Graph_Node, __Graph_Arc >::disconnect_arc(), Aleph::List_SGraph< __Graph_Node, __Graph_Arc >::disconnect_arc(), Aleph::List_Graph< _Graph_Node, _Graph_Arc >::disconnect_arc(), Aleph::CA::ca_gif_detail::dist2(), Aleph::Gen_Euler_Tour_LCA< T, Comp >::distance(), Aleph::Point3D::distance_squared_to(), Aleph::LineEq::distance_to(), Aleph::Segment3D::distance_to(), Aleph::Gen_Centroid_Decomposition< GT, SA >::distance_to_centroid_id(), Aleph::Suffix_Automaton::distinct_substring_count(), Aleph::divide_and_conquer_partition_dp(), Aleph::DynArray< T >::divide_by_block_size(), Aleph::Gen_Polynomial< Coefficient >::divide_by_monic_linear_mod(), Aleph::FFT< Real >::divide_polynomial_by_linear_root(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::divide_scalar_inplace(), Aleph::Gen_Polynomial< Coefficient >::divide_scalar_inplace(), Aleph::multi_poly_detail::divides_index(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::divmod(), Aleph::Gen_Polynomial< Coefficient >::divmod(), Aleph::dlink_random_search(), Aleph::dlink_random_select(), Aleph::Lengauer_Tarjan_Dominators< GT, SA >::do_compute(), Aleph::Compact_Quotient_Filter< T >::do_insert(), Aleph::Quotient_Filter< T >::do_insert(), Aleph::Lengauer_Tarjan_Dominators< GT, SA >::dominance_frontiers(), Aleph::Lengauer_Tarjan_Dominators< GT, SA >::dominates(), Aleph::Generator< T >::iterator::done(), Aleph::ConvexPolygonDistanceGJK::dot2(), Aleph::planarity_detail::dot_escape_string(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::doubleRotateLeft(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::doubleRotateLeft(), Aleph::HtdRbTree< Key, Compare >::doubleRotateNephewAndColor(), Aleph::HtdRbTreeRk< Key, Compare >::doubleRotateNephewAndColor(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::doubleRotateRight(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::doubleRotateRight(), Aleph::DouglasPeuckerSimplification::dp_recurse(), Aleph::FFT< Real >::ISTFTProcessor::drain_ready_samples(), Eepic_Geom_Object::draw(), Eepic_Triangle::draw(), Aleph::Tikz_Plane::draw(), Aleph::Tikz_Scene::draw_beamer_document(), Aleph::Tikz_Scene::draw_beamer_document_preamble(), Aleph::Tikz_Scene::draw_beamer_frame_begin(), Aleph::Tikz_Scene::draw_beamer_overlays_document(), Aleph::Tikz_Plane::draw_cartesian_axis(), Eepic_Plane::draw_cartesian_axis(), Aleph::Tikz_Plane::draw_coordinate_grid(), Aleph::Tikz_Plane::draw_cubic_bezier(), Aleph::Tikz_Plane::draw_ellipse(), Aleph::Tikz_Scene::draw_fitted_beamer_picture(), Aleph::Tikz_Plane::draw_legend(), Aleph::Tikz_Plane::draw_line_eq(), Aleph::Tikz_Plane::draw_object(), Aleph::Tikz_Plane::draw_options(), Aleph::Tikz_Plane::draw_point(), Eepic_Plane::draw_polygon(), Aleph::Tikz_Plane::draw_polyline(), Aleph::Tikz_Plane::draw_quadratic_bezier(), Aleph::Tikz_Plane::draw_rotated_ellipse(), Aleph::Tikz_Plane::draw_text(), Eepic_Plane::draw_text(), Aleph::Tikz_Scene::draw_tikz_libraries(), Aleph::Tikz_Plane::draw_tikzset_styles(), Aleph::FunctionalMixin< Derived, Type >::drop(), Aleph::CA::Reproductions::BTW_Sandpile::drop_at(), Aleph::FFT< Real >::drop_prefix(), Aleph::drop_while(), Aleph::dsatur_coloring(), Aleph::CA::ca_npy_detail::dtype_descr(), Aleph::Simplex< T >::dual_solve(), Aleph::Compiler_Ast_Detail::dump_import_decl(), Aleph::Compiler_Line_Frontend::dump_parsed_program(), Aleph::Compiler_Symbol_Bindings::dump_symbols(), Aleph::Compiler_Ast_Detail::dump_type_decl(), Aleph::Compiler_Ast_Detail::dump_type_expr(), Aleph::Compiler_Type_Context::dump_types(), Aleph::dynarray_to_Array(), Aleph::dynarray_to_DynDlist(), Aleph::dynarray_to_DynList(), Aleph::DynArray_to_vector(), Aleph::dyndlist_to_DynArray(), Aleph::dyndlist_to_DynList(), Aleph::dynlist_to_DynArray(), Aleph::dynlist_to_DynDlist(), Aleph::DynList_to_list(), east_offset(), Aleph::edge_connectivity(), Aleph::ConstrainedDelaunayTriangulation::edge_exists(), Aleph::MonotonePolygonTriangulation::edge_goes_down(), Aleph::ConstrainedDelaunayTriangulation::edge_opposite(), Aleph::PolygonOffset::edge_param(), Aleph::BooleanPolygonOperations::edge_param(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::edge_slack(), Aleph::MonotonePolygonTriangulation::edge_status_less(), Aleph::MonotonePolygonTriangulation::edge_x_at_y(), Aleph::edmonds_karp_maximum_flow(), Aleph::VisvalingamWhyattSimplification::effective_area(), Aleph::FFT< Real >::effective_coeff_length(), Aleph::parallel_detail::effective_parallel_chunk_size(), Aleph::CA::Parallel_Synchronous_Engine< Lattice, Rule, Neighborhood, Order >::effective_partitions(), Aleph::Now::elapsed(), Aleph::CA::Bench_Timer::elapsed_milliseconds(), Timer::elapsed_ms(), Aleph::CA::Bench_Timer::elapsed_seconds(), election_polling(), Aleph::elf_hash(), Aleph::elf_hash(), Aleph::eliminate_dead_code(), Aleph::FFT< Real >::ellint_1_impl(), Aleph::FFT< Real >::elliptic_bandpass(), Aleph::FFT< Real >::elliptic_bandstop(), Aleph::FFT< Real >::elliptic_cd_minus_imaginary(), Aleph::FFT< Real >::elliptic_highpass(), Aleph::FFT< Real >::elliptic_lowpass(), Aleph::FFT< Real >::elliptic_prototype(), Aleph::TestVisual::emit_case_svg(), Aleph::Compiler_C_Backend::Emitter::emit_constant_expression(), Aleph::Compiler_Driver::emit_driver_diagnostic(), Aleph::Compiler_MVP_Frontend::emit_driver_diagnostic(), Aleph::Compiler_Typed_Semantic_Analyzer::emit_error(), Aleph::Compiler_Lexer::emit_error(), Aleph::Compiler_Parser::emit_error(), Aleph::Compiler_Parser_Stream::emit_error(), Aleph::Compiler_Semantic_Analyzer::emit_error(), Aleph::Compiler_C_Backend::Emitter::emit_function_body(), Aleph::Compiler_IR_Lowering::Module_Builder::emit_instruction(), Aleph::Compiler_C_Backend::Emitter::emit_instruction(), Aleph::Compiler_C_Backend::Emitter::emit_instruction_comment(), Aleph::CA::Bench::emit_json(), Aleph::Compiler_C_Backend::Emitter::emit_main(), Aleph::Compiler_C_Backend::emit_module(), Aleph::Compiler_C_Backend::Emitter::emit_module_layout(), Aleph::Compiler_C_Backend::Emitter::emit_parameter_bindings(), Aleph::FFT< Real >::STFTProcessor::emit_ready_frames(), Aleph::FFT< Real >::ISTFTProcessor::emit_samples(), Aleph::Compiler_C_Backend::Emitter::emit_slot_declarations(), Aleph::Compiler_IR_Lowering::Module_Builder::emit_unit_constant(), Aleph::BoundedChannel< T >::emplace(), Aleph::SpscQueue< T >::emplace(), Aleph::DynListQueue< T >::emplace(), Aleph::DynListStack< T >::emplace(), Aleph::Fibonacci_Heap< T, Compare >::emplace(), Aleph::MpscQueue< T >::emplace(), Aleph::FlatSet< Key, Compare >::emplace(), Aleph::RingBuffer< T >::emplace(), Aleph::BoundedChannel< T >::emplace(), Aleph::BoundedChannel< T >::emplace(), Aleph::FlatMap< Key, T, Compare >::emplace(), Aleph::Net_Cost_Graph< NodeT, ArcT >::emplace_arc(), Aleph::Net_Graph< NodeT, ArcT >::emplace_arc(), Aleph::SmallVector< T, N >::emplace_back(), Aleph::SpscQueue< T >::emplace_impl(), Aleph::Net_Graph< NodeT, ArcT >::emplace_node(), Aleph::Filter_Iterator< Container, It, Show_Item >::empty(), Aleph::Dyn_Slist_Nc< T >::empty(), Aleph::Path< GT >::empty(), Aleph::StlZipView< Containers >::empty(), Aleph::CA::Tile2D_Range::empty(), Aleph::DynDlist< T >::empty(), Aleph::DynListQueue< T >::empty(), Aleph::GenLhashTable< Key, BucketType, Cmp >::empty(), Aleph::GenLinearHashTable< Key, BucketType, Cmp >::empty(), Aleph::MemArray< T >::empty_and_release(), Aleph::CA::Hashlife_Engine::empty_node(), Aleph::Huffman_Encoder_Engine::encode(), Aleph::detail::Paged_Bounded_String_Codec< Capacity, SizeType >::encode(), Aleph::Huffman_Encoder_Engine::encode(), Aleph::graph_coloring_detail::encode_color(), Aleph::detail::encode_unsigned_le(), Aleph::StlZipView< Containers >::end(), Aleph::FFT< Real >::enforce_conjugate_symmetry(), Aleph::ConstrainedDelaunayTriangulation::enforce_constraint(), Aleph::FFT< Real >::enforce_real_polynomial_symmetry(), Aleph::CA::ca_ghost_detail::enlarge_extents(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::enlargement(), Aleph::ThreadPool::enqueue(), Aleph::ThreadPool::enqueue_batch(), Aleph::ThreadPool::enqueue_bounded(), Aleph::ThreadPool::enqueue_bounded_detached(), Aleph::ThreadPool::enqueue_bulk(), Aleph::VoronoiDiagramFortune::enqueue_circle_event(), Aleph::ThreadPool::enqueue_detached(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::enqueue_pair_if_needed(), Aleph::GeomPolygonUtils::ensure_ccw(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::ensure_child_has_extra(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::ensure_child_has_extra(), Aleph::Lengauer_Tarjan_Post_Dominators< GT, SA >::ensure_computed(), Aleph::Killer_Move_Table< Move, true >::ensure_depth(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::ensure_legacy_native_format_supported(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::ensure_legacy_native_format_supported(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::ensure_legacy_native_wal_supported(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::ensure_legacy_native_wal_supported(), Aleph::Gen_HLD< GT, T, Op, SA >::ensure_not_empty(), Aleph::Gen_Binary_Lifting_LCA< GT, SA >::ensure_not_empty(), Aleph::Gen_Euler_RMQ_LCA< GT, SA >::ensure_not_empty(), Aleph::Gen_Heavy_Light_Decomposition< GT, SA >::ensure_not_empty(), Aleph::Gen_HLD_Path_Query< GT, T, Op, SA >::ensure_not_empty(), Aleph::Gen_Centroid_Decomposition< GT, SA >::ensure_not_empty(), Aleph::detail::ensure_ordered_tree_snapshot_parent_dir(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::ensure_parent_dir(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::ensure_parent_dir(), Aleph::FFT< Real >::ISTFTProcessor::ensure_pending_size(), Aleph::parallel_detail::ensure_random_access(), Aleph::CA::ca_io_detail::ensure_stream_ok(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::ensure_writable(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::ensure_writable(), Aleph::Floyd_All_Shortest_Paths< GT, Distance, SA >::entry(), Aleph::enum_for_each(), Aleph::enum_for_each(), Aleph::enum_zip_it(), Aleph::enum_zip_it_pos(), Aleph::FunctionalMixin< Derived, Type >::enumerate(), Aleph::enumerate(), Aleph::subset_sum_detail::enumerate_sums(), Aleph::eppstein_k_shortest_paths(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::epsilon(), Aleph::Gen_Polynomial< Coefficient >::epsilon(), Aleph::eq(), Aleph::equal(), Aleph::equal_length(), Aleph::equal_range(), Aleph::equal_range(), Aleph::Matrix< Trow, Tcol, NumType >::equal_to(), Aleph::Vector< T, NumType >::equal_to(), Aleph::GenTdRbTree< NodeType, Key, Compare >::equals(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::equals(), Aleph::HtdRbTreeRk< Key, Compare >::equals(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::equals(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::equals(), Aleph::Gen_File_B_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::equals_key(), Aleph::Gen_File_BPlus_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::equals_key(), Aleph::detail::equiv(), Aleph::FlatMap< Key, T, Compare >::erase(), Aleph::FlatSet< Key, Compare >::erase(), Aleph::ConcurrentHashMap< Key, T, Cmp, Shards >::erase(), Aleph::RadixTree< T, Char >::erase(), Aleph::PersistentHashMap< Key, T, Cmp >::erase(), Aleph::PersistentTreapSet< Key, Compare >::erase(), Aleph::PersistentTreapMap< Key, T, Compare >::erase(), Aleph::Prefix_Tree_Map< T >::erase(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::erase(), Aleph::MonotonePolygonTriangulation::EdgeStatusTree::erase(), Aleph::VisibilityPolygon::EdgeStatusTree::erase(), Aleph::Rope< Char, LeafSize >::erase(), Aleph::SweepLineSegmentIntersection::StatusTree::erase(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::erase_at(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::erase_at(), Aleph::SweepLineSegmentIntersection::StatusTree::erase_by_label(), Aleph::MonotonePolygonTriangulation::EdgeStatusTree::erase_by_label(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::erase_child_at(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::erase_descend(), Aleph::PersistentHashMap< Key, T, Cmp >::erase_impl(), Aleph::patricia_trie_detail::Bitwise_Trie_Utils< UInt >::erase_key(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::erase_key_at(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::erase_nontrivial_blossom(), Aleph::detail::PersistentTreapNodeOps< Node, Key, Compare >::erase_rec(), Aleph::error_msg(), Aleph::escape_dot_label(), Aleph::Tikz_Plane::escape_latex(), Aleph::Compiler_Ast_Detail::escape_text(), Aleph::Compiler_HIR_Detail::escape_text(), Aleph::Compiler_Token_Detail::escape_token_lexeme(), Aleph::HyperLogLog< T >::estimate(), Aleph::Bloom_Filter< T >::estimate(), Aleph::Count_Min_Sketch< T, CounterT >::estimate(), Aleph::Compact_Quotient_Filter< T >::estimate(), Aleph::Quotient_Filter< T >::estimate(), Aleph::Gen_Euler_Tour_LCA< T, Comp >::euler_tour(), Aleph::Random_Graph_Base< GT, Init_Node, Init_Arc >::eulerian(), Aleph::Random_Graph< GT, Init_Node, Init_Arc >::eulerian(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::eval(), Aleph::Gen_Polynomial< Coefficient >::eval(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::eval_batch(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::eval_gradient(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::eval_hessian(), Aleph::Gen_Polynomial< Coefficient >::eval_mod_u64(), Aleph::multi_poly_detail::eval_monomial(), Aleph::FFT< Real >::evaluate_analog_transfer_magnitude(), Aleph::Compiler_Dataflow_Detail::evaluate_binary(), Aleph::FFT< Real >::evaluate_cosine_series(), Aleph::Interpreter_Runtime::evaluate_expr(), Aleph::FFT< Real >::evaluate_fir_response_magnitude(), Aleph::Interpreter_Runtime::evaluate_module(), Aleph::FFT< Real >::evaluate_polynomial_and_derivative(), Aleph::FFT< Real >::evaluate_series_at_unit_circle(), Aleph::FFT< Real >::evaluate_sos_transfer_at(), Aleph::Interpreter_Runtime::evaluate_stmt(), Aleph::FFT< Real >::evaluate_transfer_at(), Aleph::FFT< Real >::evaluate_transfer_terms_at(), Aleph::Compiler_Dataflow_Detail::evaluate_unary(), Aleph::FFT< Real >::evenly_spaced_extrema(), event_hello(), SimpleEvent::EventFct(), NumberedEvent::EventFct(), CancellableEvent::EventFct(), ReschedulableEvent::EventFct(), PeriodicEvent::EventFct(), SignalingEvent::EventFct(), Aleph::CA::Hashlife_Engine::evolve(), Aleph::ConvexPolygonDistanceGJK::exact_refine_disjoint(), example_2_coloring(), example_algorithm_comparison(), example_api_patterns(), example_backpressure(), example_basic_all_pairs(), example_basic_assignment(), example_basic_formula(), example_basic_negative_weights(), example_basic_parallel(), example_basic_sccs(), example_basic_usage(), example_batch_processing(), example_cache_admission(), example_channels_and_shared_state(), example_community_detection(), example_comparison_tarjan(), example_connectivity(), example_custom_fingerprints(), example_dag(), example_deletion(), example_duplicates(), example_embedded_systems(), example_fire_and_forget(), example_from_capacity(), example_graph_backends(), example_lazy_updates(), example_lca(), example_lightweight_version(), example_load_shedding(), example_maximization(), example_memory_optimization(), example_merge(), example_negative_cycle(), example_network_reliability(), example_packet_deduplication(), example_parallel_aggregations(), example_parallel_building_blocks(), example_parallel_enumerate(), example_parallel_filter(), example_parallel_find(), example_parallel_fold(), example_parallel_map(), example_parallel_predicates(), example_parallel_scan_merge_partition(), example_parallel_sort(), example_parallel_zip(), example_path_aggregates(), example_performance(), example_performance_comparison(), example_rectangular(), example_rerooting(), example_signed_api(), example_spfa_comparison(), example_strongly_connected(), example_structured_concurrency(), example_team_assignment(), example_url_deduplication(), example_variadic_zip(), example_weighted_bandwidth(), Graph_Traverse< GT, Itor, Q, Show_Arc >::exec(), Aleph::Compiler_Bytecode_VM::execute_entry(), Event_Table< Signature >::execute_event(), Event_Table< void *(void *)>::execute_event(), Aleph::Compiler_Driver::execute_files(), Aleph::Compiler_Generic_Driver::execute_files(), Aleph::Compiler_Bytecode_VM::execute_host_call(), Aleph::Compiler_Bytecode_VM::execute_loop(), Aleph::execute_R_script(), Aleph::Compiler_Driver::execute_source(), Aleph::Compiler_Generic_Driver::execute_source(), Aleph::Compiler_Driver::execute_sources(), Aleph::Compiler_Generic_Driver::execute_sources(), Aleph::DynArray< T >::exist(), Aleph::Net_Sup_Dem_Graph< NodeT, ArcT >::exist_aux_net(), Aleph::exists(), Aleph::exists(), Aleph::exists(), Aleph::exists(), Aleph::FunctionalMixin< Derived, Type >::exists(), Aleph::FunctionalMixin< Derived, Type >::exists(), Aleph::DynSkipList< Key, Compare >::exists(), Aleph::exists_file(), Aleph::exists_in_arc(), Aleph::exists_out_arc(), Aleph::exists_perm(), Aleph::GenLinearHashTable< Key, BucketType, Cmp >::expand(), Aleph::CA::Hashlife_Engine::expand(), Aleph::MemArray< T >::expand(), Aleph::Bidirectional_BFS< GT, Fwd_Itor, Bck_Itor, SA >::expand_frontier(), Aleph::FFT< Real >::expand_real_batch_spectra(), Aleph::FFT< Real >::expand_real_spectrum(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::expand_t_blossom(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::expand_unlabeled_blossom(), Aleph::Compiler_Parser_Stream::expect(), Aleph::expect(), Aleph::test_helpers::expect_array_eq(), expect_autoreduced_basis(), expect_buchberger_criterion(), Aleph::expect_char(), expect_engine_equivalence(), expect_equivalent_at_safe(), Aleph::Compiler_Parser_Stream::expect_identifier(), expect_tokens_eq(), expect_tokens_eq(), Aleph::Bloom_Filter< T >::expected_size(), explain_union_find(), export_csv(), export_csv(), Aleph::export_network_to_dimacs(), Aleph::export_network_to_dot(), Aleph::export_network_to_json(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::export_to_tree_node(), Aleph::Gen_Link_Cut_Tree_WithEdges< VT, ET, EdgeMonoid, LazyTag >::export_to_tree_node(), export_variant(), Aleph::Compiler_HIR_Lowering::expr_type(), Aleph::Suffix_Automaton::extend(), Aleph::PolygonOffset::extract_contours(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::extract_max(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::extract_max_rb(), Aleph::Fibonacci_Heap< T, Compare >::extract_min(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::extract_min(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::extract_min_rb(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::extract_min_spanning_tree(), Aleph::detail::extract_prime_factors(), Aleph::FFT< Real >::extract_repeated_unit_roots(), Aleph::subset_sum_detail::extract_values_checked(), Aleph::VoronoiDiagramFromDelaunay::extract_vertices(), Aleph::GeomPolygonUtils::extract_vertices(), Aleph::RotatingCalipersConvexPolygon::extract_vertices(), Aleph::ConvexPolygonIntersectionBasic::extract_vertices(), Aleph::knapsack_detail::extract_weights_checked(), Aleph::extrapolate_left(), Aleph::extrapolate_right(), Aleph::RotatedEllipse::extremal_points(), Aleph::BruteForceConvexHull::extreme_edges(), Aleph::Gen_Polynomial< Coefficient >::factor_mod_p(), Aleph::CA::Block_Partition_2D::factor_partitions(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::factor_recombination(), Aleph::FFT< Real >::factor_small_radices(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::factorial_bounded(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::factorize(), Aleph::Gen_Polynomial< Coefficient >::factorize(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::fails_component_euler_bound(), Aleph::multi_poly_detail::falling_factorial(), Aleph::Karger_Min_Cut< GT, SA >::fast(), Aleph::faster_heapsort(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::faster_paint_spanning_tree(), DataGenerator::few_unique(), fib_it(), fib_iterative(), fib_st(), fib_stack(), file_to_dynarrays(), filesystem_inodes(), Aleph::CA::Ghost_Lattice< Storage, Boundary, Halo >::fill(), Aleph::fill(), fill(), Aleph::Gen_Segment_Tree< T, Op >::fill_and_build(), Aleph::Gen_Lazy_Segment_Tree< Policy >::fill_and_build(), Aleph::Segment_Tree_Beats< T >::fill_and_build(), Aleph::Gen_Sparse_Table< T, Op >::fill_and_build(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::fill_certificate_paths(), Aleph::Gen_Disjoint_Sparse_Table< T, Op >::fill_data(), Aleph::DynArray< T >::fill_dir_to_null(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::fill_embedding_result(), Aleph::Gen_Segment_Tree< T, Op >::fill_from_aleph_it(), Aleph::Gen_Lazy_Segment_Tree< Policy >::fill_from_aleph_it(), Aleph::Gen_Fenwick_Tree< T, Plus, Minus >::fill_from_indexed(), Aleph::Segment_Tree_Beats< T >::fill_leaves_recursive(), Aleph::Gen_Segment_Tree< T, Op >::fill_leaves_recursive(), Aleph::Gen_Lazy_Segment_Tree< Policy >::fill_leaves_recursive(), Aleph::fill_n(), Aleph::DynArray< T >::fill_seg_to_null(), Aleph::fill_string(), Aleph::FFT< Real >::LFilterBank::filter(), Aleph::FFT< Real >::SOSFilterBank::filter(), Aleph::FFT< Real >::SOSFilter::filter(), Aleph::filter(), Aleph::filter(), Aleph::filter(), Aleph::filter(), Aleph::FunctionalMixin< Derived, Type >::filter(), Aleph::FunctionalMixin< Derived, Type >::filter(), Aleph::filter_in_arcs(), Aleph::filter_out_arcs(), Aleph::filter_perm(), Aleph::FFT< Real >::filtfilt(), Aleph::FFT< Real >::filtfilt(), Aleph::FFT< Real >::filtfilt(), Aleph::CA::ca_io_detail::finalise_absolute_pattern(), Aleph::Compiler_Driver::finalize(), Aleph::Compiler_Generic_Driver::finalize(), Aleph::Find_Path_Depth_First< GT, Itor, SA >::find(), Aleph::find(), Aleph::Gen_File_B_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::find(), Aleph::Gen_File_BPlus_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::find(), Aleph::Directed_Find_Path< GT, Itor, SA >::find(), Aleph::Naive_Suffix_Tree::find_all(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::find_all_overlaps(), Aleph::detail::find_any_factor(), Aleph::blossom_detail::Edmonds_Blossom_Matcher< GT, SA >::find_augmenting_path(), Aleph::Find_Aumenting_Path< Net, Q >::find_aum_path(), Aleph::find_aumenting_path(), Aleph::find_aumenting_path_bfs(), Aleph::find_aumenting_path_dfs(), Aleph::find_aumenting_semi_path(), Aleph::find_aumenting_semi_path_bfs(), Aleph::find_aumenting_semi_path_dfs(), find_benchmark(), Aleph::find_breadth_first_spanning_tree(), Aleph::find_bridges(), Aleph::find_bridges(), Aleph::Compute_Bridges< GT, SA >::find_bridges(), TimeoutQueue::find_by_id(), Aleph::RadixTree< T, Char >::find_child(), Aleph::ConcurrentHashMap< Key, T, Cmp, Shards >::find_copy(), Aleph::TrapezoidalMapPointLocation::find_crossed_trapezoids(), Aleph::ConstrainedDelaunayTriangulation::find_crossing_edges(), Aleph::Find_Aumenting_Path< Net, Q >::find_dec_path(), Aleph::find_decrementing_path(), Aleph::find_decrementing_path_bfs(), Aleph::find_decrementing_path_dfs(), Aleph::find_depth_first_spanning_tree(), Aleph::find_end(), Aleph::Network_Simplex< Net >::find_entering_arc(), Aleph::find_first_of(), Aleph::find_if(), Aleph::PersistentHashMap< Key, T, Cmp >::find_impl(), Aleph::ShortestPathInPolygon::find_index(), Aleph::LocateMixin< Derived, Type >::find_item(), Aleph::LocateMixin< Derived, Type >::find_item(), Aleph::LocateMixin< Derived, Type >::find_item(), Aleph::LocateMixin< Derived, Type >::find_item(), Aleph::Fenwick_Tree< T >::find_kth(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::find_leaf(), Aleph::find_max(), Aleph::Dial_Min_Paths< GT, Distance, Itor, SA >::find_max_weight(), Aleph::Compiler_Module_Linker_Detail::find_metadata_index(), Aleph::find_min(), Aleph::Test_Dirac_Condition< GT, SN, SA >::find_min_degree_vertex(), Aleph::Dial_Min_Paths< GT, Distance, Itor, SA >::find_min_path(), Aleph::Zero_One_BFS< GT, Distance, Itor, SA >::find_min_path(), Aleph::AStar_Min_Path< GT, Distance, Heuristic, Itor, SA, HeapT >::find_min_path(), Aleph::Dijkstra_Min_Paths< GT, Distance, Itor, SA, HeapT >::find_min_path(), Aleph::find_min_path(), Aleph::find_min_path(), Aleph::RadixTree< T, Char >::find_node(), Aleph::Prefix_Tree_Map< T >::find_node(), Aleph::Prefix_Tree_Map< T >::find_node(), Aleph::Find_Eulerian_Path< GT, SN, SA >::find_node_sequence(), Aleph::find_opt(), Aleph::Bidirectional_BFS< GT, Fwd_Itor, Bck_Itor, SA >::find_path(), Aleph::IDA_Star< GT, Distance, Heuristic, Itor, SA >::find_path(), Aleph::Find_Path_Breadth_First< GT, Itor, SA >::find_path(), Aleph::Johnson< GT, Distance, Ait, NAit, SA >::find_path(), Aleph::Find_Path_Depth_First< GT, Itor, SA >::find_path(), Aleph::find_path_breadth_first(), Aleph::find_path_depth_first(), Aleph::ConstrainedDelaunayTriangulation::find_point_index(), GenTdSplayTreeRk< NodeType, Key, Compare >::find_position(), Aleph::DynSetTree< Key, Tree, Compare >::find_position(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::find_position(), Aleph::HtdRbTreeRk< Key, Compare >::find_position(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::find_position(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::find_position(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::find_position(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::find_position(), Aleph::BinTreeXt_Operation< Node, Cmp >::find_position(), Aleph::find_position(), Aleph::find_predecessor(), Aleph::find_ptr(), Aleph::find_ptr(), Aleph::LocateMixin< Derived, Type >::find_ptr(), Aleph::LocateMixin< Derived, Type >::find_ptr(), Aleph::LocateMixin< Derived, Type >::find_ptr(), Aleph::LocateMixin< Derived, Type >::find_ptr(), Aleph::Gen_File_B_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::find_record(), Aleph::Gen_File_BPlus_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::find_record(), Aleph::Compact_Quotient_Filter< T >::find_run_start(), Aleph::Quotient_Filter< T >::find_run_start(), Aleph::PolygonOffset::find_self_intersections(), find_site(), Aleph::ShortestPathInPolygon::find_sleeve(), Aleph::Find_Eulerian_Path< GT, SN, SA >::find_start_vertex(), Aleph::blossom_weighted_detail::mwmatching::impl::NonTrivialBlossom< WeightType >::find_subblossom_pos(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::find_succ_and_swap(), Aleph::Gen_Rb_Tree< NodeType, Key, Compare >::find_succ_and_swap(), Aleph::find_successor(), find_test(), Aleph::ShortestPathInPolygon::find_tri(), Aleph::string_search_detail::find_unused_delimiter(), Aleph::Simplex< T >::find_value(), Aleph::SegmentArrangement::find_vertex(), Aleph::GenTdRbTree< NodeType, Key, Compare >::findPredAndSwap(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::findPredAndSwap(), Aleph::HtdRbTree< Key, Compare >::findSuccAndSwap(), Aleph::HtdRbTreeRk< Key, Compare >::findSuccAndSwap(), Aleph::GenTdRbTree< NodeType, Key, Compare >::findSuccAndSwap(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::findSuccAndSwap(), Aleph::Compact_Quotient_Filter< T >::fingerprint(), Aleph::Quotient_Filter< T >::fingerprint(), Aleph::FFT< Real >::firls(), Aleph::FFT< Real >::firls(), Aleph::FFT< Real >::firls_impl(), Aleph::first_combination_mask(), Aleph::patricia_trie_detail::Bitwise_Trie_Utils< UInt >::first_differing_bit(), Aleph::FunctionalMixin< Derived, Type >::first_or(), Aleph::FFT< Real >::firwin_bandpass(), Aleph::FFT< Real >::firwin_bandpass(), Aleph::FFT< Real >::firwin_bandstop(), Aleph::FFT< Real >::firwin_bandstop(), Aleph::FFT< Real >::firwin_highpass(), Aleph::FFT< Real >::firwin_highpass(), Aleph::FFT< Real >::firwin_lowpass(), Aleph::FFT< Real >::firwin_lowpass(), Aleph::FFT< Real >::firwin_lowpass_impl(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::fit(), Aleph::CA::Reproductions::fit_log_log_histogram(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::fit_parallel(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::fit_ridge(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::fit_weighted(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::fix_black_condition(), Aleph::Gen_Rb_Tree< NodeType, Key, Compare >::fix_black_condition(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::fix_red_condition(), Aleph::Gen_Rb_Tree< NodeType, Key, Compare >::fix_red_condition(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::fix_red_violation(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::fix_underflow(), Aleph::flat_map(), Aleph::multi_poly_detail::flat_to_multi_index(), Aleph::flatten(), Aleph::flatten(), Aleph::flatten(), Aleph::flatten(), Aleph::Rope< Char, LeafSize >::flatten_into(), Aleph::FFT< Real >::flatten_matrix_row_major(), Aleph::Compiler_Line_Frontend::flatten_program_in_import_order(), Aleph::FFT< Real >::flatten_tensor3_row_major(), Aleph::ConstrainedDelaunayTriangulation::flip_edge(), Aleph::HtdRbTree< Key, Compare >::flipColors(), Aleph::HtdRbTreeRk< Key, Compare >::flipColors(), Aleph::GenTdRbTree< NodeType, Key, Compare >::flipColors(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::flipColors(), Aleph::Net_Cost_Graph< NodeT, ArcT >::flow_cost(), Aleph::Net_Graph< NodeT, ArcT >::flow_value(), Aleph::floyd_all_shortest_paths(), Aleph::floyd_all_shortest_paths_latex(), Aleph::CA::Ascii_Frame_Sink< Palette >::flush(), Aleph::CA::Ffmpeg_Frame_Sink< Mapper >::flush(), Aleph::CA::X11_Frame_Sink< Mapper >::flush(), Aleph::FFT< Real >::STFTProcessor::flush(), Aleph::FFT< Real >::ISTFTProcessor::flush(), Aleph::FFT< Real >::OverlapAdd::flush(), Aleph::FFT< Real >::OverlapAddBank::flush(), Aleph::FFT< Real >::OverlapSave::flush(), Aleph::FFT< Real >::PartitionedConvolver::flush(), Aleph::CA::Directory_Frame_Sink::flush(), Aleph::CA::Gif_Frame_Sink< Mapper >::flush(), Aleph::CA::HTML_Player_Frame_Sink< Mapper >::flush(), Aleph::Tikz_Plane::fmt_double(), Aleph::CA::ca_metrics_detail::fnv1a_mix(), Aleph::FunctionalMixin< Derived, Type >::fold(), Aleph::FunctionalMixin< Derived, Type >::fold(), Aleph::CA::Lattice< Storage, Boundary >::fold_coord(), Aleph::FunctionalMixin< Derived, Type >::fold_left(), Aleph::fold_perm(), Aleph::FunctionalMixin< Derived, Type >::foldl(), Aleph::foldl(), Aleph::DynSkipList< Key, Compare >::foldl(), Aleph::DynSkipList< Key, Compare >::foldl(), Aleph::DynSkipList< Key, Compare >::foldl(), Aleph::foldl_arcs(), Aleph::foldl_arcs(), Aleph::foldl_in_arcs(), Aleph::foldl_nodes(), Aleph::foldl_out_arcs(), Aleph::foldr(), Aleph::blossom_weighted_detail::mwmatching::impl::Problem_Data< WeightType >::for_adjacent_edges(), Aleph::CA::Per_Thread_RNG< Engine >::for_cell(), Aleph::CA::Per_Thread_RNG< Engine >::for_cell(), Aleph::for_each(), Aleph::for_each(), Aleph::for_each(), Aleph::for_each(), Aleph::for_each(), QuadTree::for_each(), QuadTree::for_each(), Aleph::DynSkipList< Key, Compare >::for_each(), Aleph::FunctionalMixin< Derived, Type >::for_each(), Aleph::FunctionalMixin< Derived, Type >::for_each(), Aleph::FunctionalMixin< Derived, Type >::for_each(), Aleph::FunctionalMixin< Derived, Type >::for_each(), Aleph::CA::Hashlife_Engine::for_each_alive(), Aleph::for_each_arc(), Aleph::for_each_arc(), Aleph::CA::for_each_cell(), Aleph::Gen_Centroid_Decomposition< GT, SA >::for_each_centroid_ancestor_id(), Aleph::Tree_Node< T >::for_each_child(), Aleph::for_each_combination(), Aleph::for_each_combination(), Aleph::CA::ca_scheme_detail::for_each_coord(), Aleph::CA::ca_scheme_detail::for_each_coord_1d(), Aleph::CA::ca_scheme_detail::for_each_coord_2d_col(), Aleph::CA::ca_scheme_detail::for_each_coord_2d_row(), Aleph::CA::ca_scheme_detail::for_each_coord_2d_tile(), Aleph::CA::ca_scheme_detail::for_each_coord_3d_row(), Aleph::CA::Reproductions::for_each_gosper_gun_cell(), Aleph::CA::Ghost_Lattice< Storage, Boundary, Halo >::for_each_halo_cell(), Aleph::for_each_in_arc(), Aleph::GenBinHeap< NodeType, Key, Compare >::for_each_in_inorder(), Aleph::GenBinHeap< NodeType, Key, Compare >::for_each_in_inorder(), Aleph::for_each_in_order(), Aleph::GenBinHeap< NodeType, Key, Compare >::for_each_in_preorder(), Aleph::GenBinHeap< NodeType, Key, Compare >::for_each_in_preorder(), Aleph::DynSetTree< Key, Tree, Compare >::for_each_in_preorder(), Aleph::NTT< MOD, ROOT >::Plan::for_each_index(), Aleph::DynSetTree< Key, Tree, Compare >::for_each_inorder(), Aleph::DynSetTree< Key, Tree, Compare >::for_each_inorder(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::for_each_intersecting(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::for_each_intersecting_rec(), Aleph::for_each_node(), Aleph::CA::Hex_Neighborhood::for_each_offset(), Aleph::CA::Triangular_Neighborhood::for_each_offset(), Aleph::CA::Moore< N, R >::for_each_offset(), Aleph::CA::Von_Neumann< N, R >::for_each_offset(), Aleph::CA::Custom_Neighborhood< N, K, Radius >::for_each_offset(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::for_each_on_path(), Aleph::for_each_out_arc(), Aleph::Gen_Heavy_Light_Decomposition< GT, SA >::for_each_path_segment(), Aleph::Gen_Heavy_Light_Decomposition< GT, SA >::for_each_path_segment_id(), Aleph::Gen_Heavy_Light_Decomposition< GT, SA >::for_each_path_segment_undirected_id(), QuadNode::for_each_point(), Aleph::DynSetTree< Key, Tree, Compare >::for_each_postorder(), Aleph::DynSetTree< Key, Tree, Compare >::for_each_postorder(), Aleph::for_each_postorder(), Aleph::DynSetTree< Key, Tree, Compare >::for_each_preorder(), Aleph::DynSetTree< Key, Tree, Compare >::for_each_preorder(), Aleph::for_each_preorder(), Aleph::GeomTriangleAdjacencyUtils::for_each_sorted_edge_group(), CyclicGraphDomain::for_each_successor(), KnapsackDomain::for_each_successor(), UnreachableGoalDomain::for_each_successor(), InadmissibleDomain::for_each_successor(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::for_each_term_desc(), Aleph::Gen_Polynomial< Coefficient >::for_each_term_desc(), Aleph::CA::Per_Thread_RNG< Engine >::for_thread_step(), Aleph::blossom_weighted_detail::mwmatching::impl::for_vertices_in_blossom(), Aleph::FunctionalMixin< Derived, Type >::forall(), Aleph::FunctionalMixin< Derived, Type >::forall(), Aleph::forall_arc(), Aleph::forall_arc(), Aleph::forall_node(), Aleph::Network_Simplex< Net >::force_partial_arcs_into_tree(), Aleph::ford_fulkerson_maximum_flow(), Aleph::forest_postorder_traversal(), Aleph::forest_preorder_traversal(), Aleph::forest_to_bin(), Aleph::Compiler_Dataflow_Detail::format_slot_set(), Aleph::CA::ca_frame_stream_detail::format_step_path(), Aleph::format_string(), Aleph::format_string(), Aleph::format_string(), Aleph::format_string_csv(), Aleph::CA::format_throughput(), format_time(), Aleph::Filter_Iterator< Container, It, Show_Item >::forward(), Aleph::CA::frame_hash(), Aleph::FFT< Real >::frame_offsets(), Aleph::FFT< Real >::frame_offsets_impl(), Aleph::FFT< Real >::frame_signal(), frames_equal(), Aleph::CA::frames_equal(), Aleph::Net_Sup_Dem_Graph< NodeT, ArcT >::free_aux_net(), Aleph::FFT< Real >::freqz(), Aleph::FFT< Real >::freqz(), Aleph::FFT< Real >::freqz(), Aleph::FFT< Real >::freqz(), Aleph::FFT< Real >::freqz(), Aleph::FFT< Real >::freqz(), Aleph::FFT< Real >::freqz(), Aleph::FFT< Real >::freqz_impl(), Aleph::SweepLineSegmentIntersection::StatusTree::fresh_label_between(), Aleph::MonotonePolygonTriangulation::EdgeStatusTree::fresh_label_between(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::from_binary(), Aleph::Compact_Quotient_Filter< T >::from_capacity(), Aleph::Quotient_Filter< T >::from_capacity(), Aleph::HalfPlaneIntersection::from_convex_polygon(), Aleph::Count_Min_Sketch< T, CounterT >::from_error_bounds(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::from_json(), Aleph::Gen_Polynomial< Coefficient >::from_roots(), Aleph::MinimumEnclosingCircle::from_three_points(), Aleph::FixedQueue< T >::front(), Aleph::Compiler_HIR_Lowering::function_type(), functional_test(), Aleph::FFT< Real >::gain_margin(), Aleph::FFT< Real >::gain_margin(), Aleph::FFT< Real >::gain_margin(), Aleph::FFT< Real >::gain_margin(), Aleph::FFT< Real >::gain_margin(), Aleph::FFT< Real >::gain_margin(), Aleph::FFT< Real >::gain_margin_impl(), Aleph::FFT< Real >::gain_margin_refined_impl(), Aleph::timsort_detail::gallop_left(), Aleph::timsort_detail::gallop_right(), Aleph::FFT< Real >::gather_axis_slice(), Aleph::CA::gather_neighbors(), Aleph::CA::gaussian_3x3_kernel(), Aleph::CA::gaussian_5x5_kernel(), Aleph::Gen_Polynomial< Coefficient >::gcd(), Aleph::gen_random_euclidian_graph(), Aleph::gen_seq_list_tuples(), Aleph::generate(), Aleph::Testing::LayeredNetworkGenerator< Net >::generate(), Aleph::Testing::GridNetworkGenerator< Net >::generate(), Aleph::Testing::BipartiteNetworkGenerator< Net >::generate(), generate_bin_tree(), Aleph::generate_bipartite_network(), Aleph::generate_btree(), Aleph::generate_cross_graph(), generate_cross_spanning_tree(), generate_curve(), Aleph::generate_dot_file(), generate_epilogue(), Aleph::generate_forest(), Aleph::k_shortest_paths_detail::generate_general_deviation_candidates(), Aleph::generate_graphpic(), Aleph::generate_graphviz(), Aleph::generate_graphviz(), Aleph::generate_grid_network(), Aleph::Huffman_Encoder_Engine::generate_huffman_tree(), Aleph::generate_layered_network(), Aleph::generate_n(), Aleph::generate_net_graph(), generate_net_spanning_tree(), generate_points(), generate_prologue(), generate_random_data(), generate_random_graph(), Aleph::generate_random_network(), Aleph::generate_random_network(), generate_random_values(), generate_split_lines(), Aleph::generate_tree(), generate_tree(), generate_tree(), Aleph::SkipList< Key, Type >::generateRandomLevel(), Aleph::generic_preflow_vertex_push_maximum_flow(), Eepic_Plane::geom_number_to_plane(), Aleph::ArrayQueue< T >::get(), Aleph::DynListQueue< T >::get(), Aleph::Random_Set< T >::get(), Aleph::RingBuffer< T >::get(), Aleph::FixedQueue< T >::get(), Aleph::DynList< T >::get(), Aleph::MemArray< T >::get(), Aleph::CsvRow::get(), Aleph::CsvRow::get(), Aleph::get16bits(), Aleph::Simplex< T >::get_all_reduced_costs(), Aleph::Simplex< T >::get_all_shadow_prices(), Aleph::get_array_it(), Aleph::Net_Sup_Dem_Graph< NodeT, ArcT >::get_aux_net(), Aleph::Bit_Fields::get_bit(), Aleph::Compact_Quotient_Filter< T >::get_bit_at(), Aleph::BitArray::get_bit_str(), QuadNode::get_child_to(), Aleph::Matrix< Trow, Tcol, NumType >::get_col_as_list(), Aleph::Matrix< Trow, Tcol, NumType >::get_col_vector(), Aleph::RevisedSimplex< T >::get_column(), Aleph::GraphCopyWithMapping< GT, Tree >::get_copy(), Aleph::Johnson< GT, Distance, Ait, NAit, SA >::get_copy_node(), OhashCommon< HashTbl, Key >::Iterator::get_curr(), Aleph::Slist< T >::Iterator::get_curr(), Aleph::BitArray::Iterator::get_curr(), Aleph::Dlink::Iterator::get_curr(), Aleph::Slinknc::Iterator::get_curr(), RingFileCache< T >::Iterator::get_curr(), Aleph::Slink_Nc::Iterator::get_curr(), Aleph::GenBinHeap< NodeType, Key, Compare >::Iterator::get_curr(), Aleph::BinNodePrefixIterator< Node >::get_curr(), Aleph::BinNodeInfixIterator< Node >::get_curr(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::Iterator::get_curr(), Aleph::DynArray< T >::Iterator::get_curr(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::Iterator::get_curr(), Aleph::Tree_Node< T >::Iterator::get_curr(), Aleph::Dlink::Iterator::get_curr_ne(), Aleph::Slink_Nc::Iterator::get_curr_ne(), Aleph::BinTreeXt_Iterator< TreeType, Node, Key, Compare >::get_curr_ne(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::Iterator::get_curr_ne(), OhashCommon< HashTbl, Key >::Iterator::get_curr_ne(), Aleph::GenLhashTable< Key, BucketType, Cmp >::Iterator::get_curr_ne(), Aleph::BinTreeXt_Iterator< TreeType, Node, Key, Compare >::get_current_position(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::Iterator::get_current_position(), Aleph::Polygon::Segment_Iterator::get_current_segment(), Aleph::Regular_Polygon::Segment_Iterator::get_current_segment(), Aleph::Regular_Polygon::Vertex_Iterator::get_current_vertex(), Aleph::Empty_Node::get_data(), Aleph::DynMapHashTable< Key, Data, HashTable, Cmp >::get_data(), Aleph::DynMapTree< Key, Data, Tree, Compare >::get_data(), Aleph::DynMapTree< Key, Data, Tree, Compare >::get_data(), Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::get_distance(), Aleph::Dial_Min_Paths< GT, Distance, Itor, SA >::get_distance(), Aleph::Zero_One_BFS< GT, Distance, Itor, SA >::get_distance(), Aleph::Johnson< GT, Distance, Ait, NAit, SA >::get_distance(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::get_distance(), Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::get_distance(), QuadNode::get_east_neighbor(), Aleph::Vector< T, NumType >::get_entry(), Aleph::Vector< T, NumType >::get_entry(), Aleph::Matrix< Trow, Tcol, NumType >::get_entry(), Aleph::Matrix< Trow, Tcol, NumType >::get_entry(), Aleph::get_enum_zip_it(), Aleph::get_enum_zip_it_pos(), Aleph::QuickHull::get_farthest_point(), Aleph::SimHash< T >::get_fingerprint(), Aleph::Polygon::get_first_segment(), Aleph::get_freq(), Aleph::get_from_active_queue(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::get_from_queue(), Aleph::get_futures(), Aleph::get_futures(), Aleph::get_futures(), Aleph::get_futures(), Aleph::Lengauer_Tarjan_Dominators< GT, SA >::get_idom(), Aleph::CA::Hashlife_Engine::get_in_node(), Aleph::Lengauer_Tarjan_Post_Dominators< GT, SA >::get_ipdom(), Aleph::None< T >::get_item(), Aleph::None< T >::get_item(), Aleph::DynMapTree< Key, Data, Tree, Compare >::get_key(), Aleph::DynMapHashTable< Key, Data, HashTable, Cmp >::get_key(), Aleph::DynMapTree< Key, Data, Tree, Compare >::get_key(), Aleph::Path< GT >::get_last_node(), Aleph::Polygon::get_last_segment(), Aleph::Tree_Node< T >::get_last_tree(), Aleph::Tree_Node< T >::get_left_tree(), Aleph::GiftWrappingConvexHull::get_lowest_point(), ArcHeap< GT, Distance, Access_Heap_Node >::get_min_arc(), ArcFibonacciHeap< GT, Distance, Access_Heap_Node >::get_min_arc(), Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::get_min_path(), Aleph::Floyd_All_Shortest_Paths< GT, Distance, SA >::get_min_path(), Aleph::Dial_Min_Paths< GT, Distance, Itor, SA >::get_min_path(), Aleph::Zero_One_BFS< GT, Distance, Itor, SA >::get_min_path(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::get_min_path(), Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::get_min_path(), Aleph::get_min_path(), Aleph::MemArray< T >::get_ne(), QuadNode::get_neighbors(), QuadNode::get_neighbors_by_side(), Aleph::Slink_Nc::get_next(), Aleph::Slink_Nc::get_next(), Aleph::Dlink::get_next(), Aleph::matgraph_detail::get_node(), Aleph::matgraph_detail::get_node(), Aleph::__Out_Filt< GT >::get_node(), Aleph::__In_Filt< GT >::get_node(), Aleph::Net_Filt< Net >::get_node(), QuadNode::get_north_neighbor(), get_opt_value(), get_opt_value(), Aleph::get_pair_it(), Aleph::get_pair_it(), Aleph::Tree_Node< T >::get_parent(), Aleph::get_partial_arcs(), Aleph::Segment::get_perpendicular(), Pointer_Table::get_pointer(), Aleph::Johnson< GT, Distance, Ait, NAit, SA >::get_potential(), Aleph::Dlink::get_prev(), Aleph::DynSlist< T >::get_previous_to_pos(), Aleph::Polar_Point::get_quadrant(), get_rand(), Aleph::Compact_Quotient_Filter< T >::get_rem(), Aleph::Simplex< T >::get_restriction(), Aleph::Simplex< T >::get_restriction_coef(), Aleph::Tree_Node< T >::get_right_child(), Aleph::QuickHull::get_right_points(), Aleph::Tree_Node< T >::get_right_tree(), Aleph::Matrix< Trow, Tcol, NumType >::get_row_as_list(), Aleph::Matrix< Trow, Tcol, NumType >::get_row_vector(), get_seed(), Aleph::Compact_Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::Bucket::get_slot(), Aleph::Simplex< T >::get_solution(), QuadNode::get_south_neighbor(), Log_Manager::get_time(), get_token(), Aleph::Net_Cap_Graph< NodeT, ArcT >::get_total_flow(), Aleph::get_unitarian_DynList(), Aleph::BitArray::get_unum(), QuadNode::get_west_neighbor(), Aleph::get_zip_it(), Aleph::get_zip_it_pos(), Aleph::SkipList< Key, Type >::Node::getForward(), Aleph::SkipList< Key, Type >::HeaderNode::getForward(), Aleph::ArrayHeap< T, Compare >::getMin(), Aleph::DynArrayHeap< T, Compare >::getMin(), Aleph::GenBinHeap< NodeType, Key, Compare >::getMin_ne(), Aleph::FixedQueue< T >::getn(), Aleph::HtdRbTree< Key, Compare >::getSibling(), Aleph::HtdRbTreeRk< Key, Compare >::getSibling(), Aleph::GenTdRbTree< NodeType, Key, Compare >::getSibling(), Aleph::TestVisual::golden_output_dir(), Aleph::Out_Iterator< GT, Show_Arc >::goto_first_valid(), Aleph::In_Iterator< GT, SA >::goto_first_valid(), Aleph::Filter_Iterator< Container, It, Show_Item >::goto_first_valid_item(), Aleph::Filter_Iterator< Container, It, Show_Item >::goto_last_valid_item(), Aleph::GenTdRbTree< NodeType, Key, Compare >::gotoLeftAndColorRed(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::gotoLeftAndColorRed(), Aleph::GenTdRbTree< NodeType, Key, Compare >::gotoRightAndColorRed(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::gotoRightAndColorRed(), Aleph::Graph_To_Tree_Node< GT, Key, Convert, SA >::graph_to_tree(), Aleph::Graph_To_Tree_Node< GT, Key, Convert, SA >::graph_to_tree(), Aleph::graph_to_tree_node(), Aleph::Cnode::greater_child_impl(), Aleph::Prefix_Tree_Map< T >::Node::greater_child_impl(), Aleph::greater_or_equal_than(), Aleph::greater_or_equal_than(), Aleph::greater_than(), Aleph::greater_than(), Aleph::greedy_coloring(), Aleph::BooleanPolygonOperations::greiner_hormann(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::groebner_basis(), Aleph::group_by(), Aleph::group_by_eq(), Aleph::group_by_reduce(), Aleph::FFT< Real >::group_center(), Aleph::FFT< Real >::group_delay(), Aleph::FFT< Real >::group_delay(), Aleph::FFT< Real >::group_delay(), Aleph::FFT< Real >::group_delay(), Aleph::FFT< Real >::group_delay(), Aleph::FFT< Real >::group_delay(), Aleph::FFT< Real >::group_delay(), Aleph::FFT< Real >::group_delay(), Aleph::FFT< Real >::group_delay_impl(), Aleph::SmallVector< T, N >::grow(), Aleph::CA::Ghost_Lattice< Storage, Boundary, Halo >::halo_radius(), Aleph::FFT< Real >::hamming_window(), Aleph::Branch_And_Bound< Domain, ObjectivePolicy >::handle_complete_solution(), QueueTheadsPool< T >::handler(), Aleph::FFT< Real >::hann_window(), Aleph::ODhashTable< Key, Cmp >::hard_allocate_bucket(), Aleph::OLhashTable< Key, Cmp >::hard_allocate_bucket(), Aleph::CsvRow::has_column(), has_constrained_edge(), Aleph::Interpreter_Execution_Result::has_control_flow(), Aleph::GraphCopyWithMapping< GT, Tree >::has_copy(), Aleph::Polygon::Segment_Iterator::has_curr(), Aleph::Slink_Nc::Iterator::has_curr(), Aleph::Dlink::Iterator::has_curr(), OhashCommon< HashTbl, Key >::Iterator::has_curr(), Aleph::BinTreeXt_Iterator< TreeType, Node, Key, Compare >::has_curr(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::Iterator::has_curr(), Aleph::Path< GT >::Iterator::has_current_arc(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::has_cycle(), Aleph::has_cycle(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::has_cycle(), Aleph::Compact_Quotient_Filter< T >::has_element(), Aleph::Compiler_Bytecode_Runtime_Error::has_error(), Aleph::Interpreter_Runtime_Error::has_error(), Aleph::LineSweepFramework< Event, CmpEvent >::has_events(), has_flag(), has_flag(), has_flag(), has_flag(), QuadTree::has_four_leaf_children(), Aleph::AdversarialIterativeDeepeningResult< Move, Score >::has_iterations(), Aleph::FFT< Real >::has_near_pole_zero_cancellation(), Aleph::FFT< Real >::has_near_pole_zero_cancellation(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::has_negative_cycle(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::has_negative_cycle(), Aleph::AdversarialSearchResult< Move, Score >::has_principal_variation(), Aleph::HyperLogLog< T >::hash64(), Aleph::SimHash< T >::hash64(), Aleph::Bloom_Filter< T >::hash_seeds(), Aleph::Bloom_Filter< T >::hashes(), Aleph::PersistentHashMap< Key, T, Cmp >::hashes_match_slot(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::header_checksum(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::header_checksum(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::header_checksum_v2(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::header_checksum_v2(), Aleph::CA::ca_io_detail::header_value(), Aleph::heapsort(), Aleph::heapsort(), Aleph::heapsort_subrange(), Aleph::Gen_Heavy_Light_Decomposition< GT, SA >::heavy_child(), Aleph::Gen_Cartesian_Tree< T, Comp >::height(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::height_of(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::height_of(), Aleph::Gen_Polynomial< Coefficient >::hensel_lift(), Aleph::FFT< Real >::hermitian_tolerance(), Aleph::CA::hex_distance(), Aleph::CA::ca_svg_detail::hex_points(), Aleph::Find_Eulerian_Path< GT, SN, SA >::hierholzer_directed(), Aleph::Find_Eulerian_Path< GT, SN, SA >::hierholzer_undirected(), Aleph::histogram(), Aleph::hlpp_maximum_flow(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::homomorphic_eval(), Aleph::hopcroft_karp_dfs(), Aleph::hopcroft_karp_matching(), Aleph::Gen_Polynomial< Coefficient >::horner_eval(), huffman_to_btreepic(), huffman_to_btreepic(), hull_signature(), Aleph::hungarian_assignment(), Aleph::hungarian_max_assignment(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::ideal_member(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::ideal_power(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::ideal_product(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::ideal_sum(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::ideals_equal(), Aleph::Matrix< Trow, Tcol, NumType >::identity(), Aleph::FFT< Real >::iir_filter_impl(), Aleph::FFT< Real >::iir_filtfilt_impl(), Aleph::FFT< Real >::iir_steady_state(), Aleph::import_network_from_dimacs(), imprime(), imprime(), imprimir_camino(), imprimir_mapa(), Aleph::Net_Graph< NodeT, ArcT >::in_arcs(), Aleph::in_arcs(), Aleph::DelaunayTriangulationRandomizedIncremental::in_cc(), Aleph::in_circle(), Aleph::in_circle_determinant(), Aleph::CuttingEarsTriangulation::in_cone(), Aleph::Net_Graph< NodeT, ArcT >::in_nodes(), Aleph::in_nodes(), Aleph::in_pairs(), Aleph::Net_Cost_Graph< NodeT, ArcT >::in_pars(), Aleph::in_place_multisort_arrays(), Aleph::in_place_multisort_arrays(), Aleph::in_place_transpose(), Aleph::in_place_transpose(), Aleph::includes(), Aleph::inconnected_components(), Aleph::increase_flow(), Aleph::increase_flow(), Aleph::increase_freq(), Aleph::ArrayQueue< T >::increase_index(), Aleph::FixedQueue< T >::increase_index(), Aleph::PersistentHashMap< Key, T, Cmp >::index(), Aleph::ODhashTable< Key, Cmp >::index_backward(), Aleph::ODhashTable< Key, Cmp >::index_forward(), Aleph::DynArray< T >::index_in_block(), Aleph::DynArray< T >::index_in_dir(), Aleph::DynArray< T >::index_in_seg(), Aleph::Floyd_All_Shortest_Paths< GT, Distance, SA >::index_node(), Aleph::hld_detail::HLD_Tree_Data< GT, SA >::index_nodes(), Aleph::lca_detail::Rooted_Tree_Data< GT, SA >::index_nodes(), Aleph::tree_decomposition_detail::Rooted_Tree_Topology< GT, SA >::index_nodes(), Aleph::tree_dp_detail::Tree_Topology< GT, SA >::index_nodes(), Aleph::VoronoiDiagramFromDelaunay::indexed_clipped_cells(), Aleph::indexes(), Aleph::infix(), Aleph::infix(), Aleph::infix_traverse(), Aleph::CA::ca_checkpoint_detail::inflate_bytes(), Aleph::CA::ca_checkpoint_detail::inflate_bytes_up_to(), Aleph::Distinct_Count_Policy< T >::init(), Aleph::Powerful_Array_Policy< T >::init(), Aleph::Range_Mode_Policy< T >::init(), Aleph::Zero_One_BFS< GT, Distance, Itor, SA >::init(), Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::init(), Aleph::Graph_Anode< Node_Info >::init(), RingFileCache< T >::init(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::init(), Aleph::Gen_Treap< NodeType, Key, Compare >::init(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::init(), Aleph::Path< GT >::init(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::init(), Aleph::DynSkipList< Key, Compare >::init(), Aleph::SkipList< Key, Type >::init(), Aleph::MemArray< T >::init_dim(), Aleph::CuttingEarsTriangulation::init_ears(), Aleph::Stoer_Wagner_Min_Cut< GT, Distance, SA >::init_from_graph(), Aleph::init_height_in_nodes(), Aleph::init_height_in_nodes(), Aleph::init_jsw(), Log_Manager::init_line(), init_mutex(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::init_node_and_push_in_stack(), init_random(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::init_simple(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::init_tarjan(), Aleph::init_to_Array(), Aleph::init_to_DynArray(), Aleph::init_to_DynDlist(), Aleph::init_to_DynList(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::init_with_indexes(), Aleph::Compiler_Dataflow_Detail::initial_assigned_state(), Aleph::Random_Graph_Base< GT, Init_Node, Init_Arc >::initialize_and_create_nodes(), Aleph::FFT< Real >::Plan::initialize_bluestein_plan(), Aleph::NTT< MOD, ROOT >::Plan::initialize_bluestein_plan(), Aleph::Compiler_Type_Context::initialize_builtins(), Aleph::FFT< Real >::Plan::initialize_mixed_radix_plan(), Aleph::FFT< Real >::STFTProcessor::initialize_pending(), Aleph::FFT< Real >::Plan::initialize_power_of_two_plan(), Aleph::NTT< MOD, ROOT >::Plan::initialize_power_of_two_plan(), Aleph::FFT< Real >::initialize_root_guesses(), Aleph::FFT< Real >::LFilter::initialize_state(), Aleph::FFT< Real >::SOSFilter::initialize_states(), Aleph::NTT< MOD, ROOT >::Plan::initialize_twiddles(), Aleph::inner_product(), Aleph::inner_product(), Aleph::Gen_Cartesian_Tree< T, Comp >::inorder(), inorder(), inorder_keys(), Aleph::BinTreeXt_Operation< Node, Cmp >::inorder_position(), Aleph::inorder_position(), Aleph::inorder_rec_helper(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::inorder_traverse(), Aleph::inOrderRec(), Aleph::Path< GT >::insert(), Aleph::DynList< T >::insert(), Aleph::DynIntervalTree< T, Compare >::insert(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::insert(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::insert(), Aleph::DynSetTree< Key, Tree, Compare >::insert(), Aleph::DynSkipList< Key, Compare >::insert(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::insert(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::insert(), Aleph::PersistentTreapSet< Key, Compare >::insert(), Aleph::ConcurrentHashMap< Key, T, Cmp, Shards >::insert(), Aleph::PersistentHashMap< Key, T, Cmp >::insert(), AhHashDispatcher< Key, Operation >::insert(), Aleph::ConcurrentHashMap< Key, T, Cmp, Shards >::insert(), Aleph::PersistentHashMap< Key, T, Cmp >::insert(), Aleph::PatriciaSet< UInt >::insert(), Aleph::KDTreePointSearch::insert(), QuadTree::insert(), K2Tree< T >::insert(), Aleph::MonotonePolygonTriangulation::EdgeStatusTree::insert(), Aleph::Rope< Char, LeafSize >::insert(), Aleph::Compact_Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::insert(), Aleph::Compact_Quotient_Filter< T >::insert(), Aleph::Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::insert(), Aleph::Quotient_Filter< T >::insert(), Aleph::DynArray< T >::insert(), Aleph::DynDlist< T >::Iterator::insert(), Aleph::MemArray< T >::insert(), Aleph::Dlink::insert(), Aleph::Compact_Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::Bucket::insert(), Aleph::Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::Bucket::insert(), Aleph::PersistentTreapMap< Key, T, Compare >::insert(), Aleph::DynIntervalTree< T, Compare >::insert(), Aleph::DynSetTree< Key, Tree, Compare >::insert(), Aleph::DynSkipList< Key, Compare >::insert(), Aleph::PersistentTreapSet< Key, Compare >::insert(), QuadTree::insert(), Aleph::BinTree_Operation< Node, Cmp >::insert(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::insert(), Aleph::Path< GT >::insert(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::insert(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::insert(), GenTdSplayTreeRk< NodeType, Key, Compare >::insert(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::insert(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::insert(), Aleph::GenBinHeap< NodeType, Key, Compare >::insert(), Aleph::GenBinTree< NodeType, Key, Compare >::insert(), Aleph::HtdRbTree< Key, Compare >::insert(), Aleph::HtdRbTreeRk< Key, Compare >::insert(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::insert(), Aleph::Gen_Rb_Tree< NodeType, Key, Compare >::insert(), Aleph::SkipList< Key, Type >::insert(), GenTdSplayTree< NodeType, Key, Compare >::insert(), Aleph::GenTdRbTree< NodeType, Key, Compare >::insert(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::insert(), Aleph::Gen_Treap< NodeType, Key, Compare >::insert(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::insert(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::insert(), Aleph::Gen_Treap< NodeType, Key, Compare >::insert(), Aleph::SmallVector< T, N >::insert(), Aleph::Slink_Nc::insert(), Aleph::HTList::insert(), Aleph::HTList::insert(), Aleph::Slinknc::insert(), Aleph::DynArray< T >::insert(), Aleph::DynDlist< T >::Iterator::insert(), Aleph::MemArray< T >::insert(), RankTreeTest< Tree >::insert_all(), Aleph::Index_Graph< GT, Compare, Tree >::insert_arc(), Aleph::GraphCopyWithMapping< GT, Tree >::insert_arc(), Aleph::Array_Graph< __Graph_Node, __Graph_Arc >::insert_arc(), Aleph::List_SGraph< __Graph_Node, __Graph_Arc >::insert_arc(), Aleph::Net_Cost_Graph< NodeT, ArcT >::insert_arc(), Aleph::Net_Graph< NodeT, ArcT >::insert_arc(), Aleph::List_Graph< _Graph_Node, _Graph_Arc >::insert_arc(), Aleph::Graph_Anode< Node_Info >::insert_arc(), Aleph::DynHashTable< Key, HashTable, Cmp >::insert_bucket(), Aleph::insert_by_key_xt(), Aleph::insert_by_pos_xt(), Aleph::insert_child(), Aleph::Cnode::insert_child(), Aleph::Prefix_Tree_Map< T >::Node::insert_child(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::insert_child_at(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::insert_child_at(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::insert_descend(), Aleph::Path< GT >::insert_directed(), Aleph::Path< GT >::insert_directed(), Aleph::DynIntervalTree< T, Compare >::insert_dup(), Aleph::BinTree_Operation< Node, Cmp >::insert_dup(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::insert_dup(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::insert_dup(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::insert_dup(), GenTdSplayTreeRk< NodeType, Key, Compare >::insert_dup(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::insert_dup(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::insert_dup(), Aleph::GenBinTree< NodeType, Key, Compare >::insert_dup(), Aleph::HtdRbTree< Key, Compare >::insert_dup(), Aleph::HtdRbTreeRk< Key, Compare >::insert_dup(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::insert_dup(), Aleph::Gen_Rb_Tree< NodeType, Key, Compare >::insert_dup(), GenTdSplayTree< NodeType, Key, Compare >::insert_dup(), Aleph::GenTdRbTree< NodeType, Key, Compare >::insert_dup(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::insert_dup(), Aleph::Gen_Treap< NodeType, Key, Compare >::insert_dup(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::insert_dup(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::insert_dup(), Aleph::Gen_Treap< NodeType, Key, Compare >::insert_dup(), Aleph::insert_dup_by_key_xt(), Aleph::insert_dup_in_bst(), insert_dup_traversal_test(), Aleph::Huffman_Encoder_Engine::insert_end_symbol_node(), Aleph::Slist< T >::insert_first(), Aleph::RadixTree< T, Char >::insert_impl(), Aleph::PatriciaMap< UInt, T >::insert_impl(), Aleph::PersistentHashMap< Key, T, Cmp >::insert_impl(), Aleph::Prefix_Tree_Map< T >::insert_impl(), Aleph::insert_in_bst(), Aleph::insert_in_container(), Pointer_Table::insert_in_free_table(), Aleph::Nodes_Index< GT, Compare, Tree, SN >::insert_in_graph(), Aleph::Nodes_Index< GT, Compare, Tree, SN >::insert_in_graph(), Aleph::IndexNode< GT, Compare, Tree, SN >::insert_in_graph(), Aleph::Arcs_Index< GT, Compare, Tree, SA >::insert_in_graph(), Aleph::Arcs_Index< GT, Compare, Tree, SA >::insert_in_graph(), Aleph::IndexArc< GT, Tree, SA >::insert_in_graph(), Aleph::IndexArc< GT, Tree, SA >::insert_in_graph(), Aleph::IndexNode< GT, Compare, Tree, SN >::insert_in_graph(), Aleph::Tree_Node< T >::insert_left_sibling(), Aleph::Tree_Node< T >::insert_leftmost_child(), Aleph::DynDlist< T >::Iterator::insert_list(), insert_n_random_items_in_map(), insert_n_random_items_in_map(), insert_n_random_items_in_set(), insert_n_random_items_in_set(), Aleph::Slink::insert_next(), Aleph::Net_Sup_Dem_Graph< NodeT, ArcT >::insert_node(), Aleph::Index_Graph< GT, Compare, Tree >::insert_node(), Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::insert_node(), Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::insert_node(), Aleph::Net_Sup_Dem_Graph< NodeT, ArcT >::insert_node(), Aleph::Array_Graph< __Graph_Node, __Graph_Arc >::insert_node(), Aleph::List_SGraph< __Graph_Node, __Graph_Arc >::insert_node(), Aleph::Net_Graph< NodeT, ArcT >::insert_node(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::insert_nonfull(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::insert_nonfull(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::insert_one(), Aleph::PersistentHashMap< Key, T, Cmp >::insert_or_assign(), Aleph::Gen_File_B_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::insert_or_assign(), Aleph::PersistentHashMap< Key, T, Cmp >::insert_or_assign(), Aleph::ConcurrentHashMap< Key, T, Cmp, Shards >::insert_or_assign(), Aleph::PatriciaMap< UInt, T >::insert_or_assign(), Aleph::PersistentTreapMap< Key, T, Compare >::insert_or_assign(), Aleph::PersistentTreapMap< Key, T, Compare >::insert_or_assign_rec(), Pointer_Table::insert_pointer(), Aleph::PersistentTreapSet< Key, Compare >::insert_rec(), Aleph::PersistentTreapMap< Key, T, Compare >::insert_rec(), Aleph::Tree_Node< T >::insert_right_sibling(), Aleph::Tree_Node< T >::insert_rightmost_child(), Aleph::BinTree_Operation< Node, Cmp >::insert_root(), Aleph::BinTreeXt_Operation< Node, Cmp >::insert_root(), Aleph::insert_root(), Aleph::BinTree_Operation< Node, Cmp >::insert_root_rec(), Aleph::insert_root_rec(), Aleph::insert_root_xt(), Aleph::insert_sibling(), Aleph::insert_sorted(), Aleph::Prefix_Tree_Map< T >::Node::insert_suffix(), Aleph::Naive_Suffix_Tree::insert_suffix(), Aleph::Tree_Node< T >::insert_tree_to_right(), Aleph::GraphCopyWithMapping< GT, Tree >::insert_unmapped_node(), Aleph::GraphCopyWithMapping< GT, Tree >::insert_unmapped_node(), insert_via(), Aleph::Cnode::insert_word(), Aleph::Prefix_Tree::insert_word(), insertar_arco(), Aleph::insertion_sort(), Aleph::insertion_sort(), Aleph::insertion_sort(), Aleph::insertion_sort(), Aleph::insertion_sort(), Aleph::AABBTree::insertion_sort_by_center(), Aleph::bucket_sort_detail::insertion_sort_range(), Aleph::Path< GT >::inside_graph(), Aleph::ConvexPolygonIntersectionBasic::inside_half_plane(), Aleph::CA::inspect_checkpoint(), Aleph::Compiler_Typed_Semantic_Analyzer::instantiate_binding(), INSTANTIATE_TEST_SUITE_P(), Aleph::Compiler_Typed_Semantic_Analyzer::instantiate_type(), Aleph::Compiler_Dataflow_Detail::instruction_is_trivially_dead(), Aleph::Compiler_Dataflow_Detail::integer_constant(), Aleph::Gen_Polynomial< Coefficient >::integer_gcd(), Aleph::FFT< Real >::integer_power(), Aleph::FFT< Real >::integrate_cos_basis(), Aleph::FFT< Real >::integrate_cos_product(), Aleph::FFT< Real >::integrate_linear_cos_basis(), Aleph::FFT< Real >::integrate_offset_cos_basis(), Aleph::inter_copy_graph(), Aleph::intercept(), Aleph::Compiler_Bytecode_Detail::intern_constant(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::interpolate(), Aleph::NTT< MOD, ROOT >::interpolate(), Aleph::interpolate(), Aleph::Gen_Polynomial< Coefficient >::interpolate(), Aleph::FFT< Real >::interpolate_crossing(), Aleph::NTT< MOD, ROOT >::interpolate_recursive(), Aleph::FFT< Real >::interpolate_value_at(), Aleph::interpreter_dump_environment(), Aleph::interpreter_dump_globals(), Aleph::interpreter_value_to_string(), Aleph::interpreter_values_equal(), Aleph::DynSkipList< Key, Compare >::intersect(), Aleph::intersect_improp(), Aleph::RotatedEllipse::intersection_with(), Aleph::Ellipse::intersection_with(), Aleph::Segment::intersection_with(), Aleph::Rectangle::intersects(), Aleph::Segment::intersects_with(), Aleph::Ellipse::intersects_with(), Aleph::RotatedEllipse::intersects_with(), Aleph::Polygon::intersects_with(), Aleph::Segment::intersects_with(), Aleph::FunctionalMixin< Derived, Type >::intersperse(), Aleph::introsort(), Aleph::introsort(), Aleph::introsort(), Aleph::introsort_loop(), Aleph::introsort_loop(), Pointer_Table::invariant(), Aleph::AHMapping< Key, ValueType >::inverse(), Aleph::Modular_Matrix< MatrixT >::inverse(), Aleph::FFT< Real >::inverse_jacobi_sc(), Aleph::FFT< Real >::inverse_transform(), Aleph::FFT< Real >::Plan::inverse_transform(), Aleph::FFT< Real >::inverse_transform(), Aleph::FFT< Real >::inverse_transform2d(), Aleph::FFT< Real >::inverse_transform3d(), Aleph::FFT< Real >::inverse_transform_batch(), Aleph::FFT< Real >::Plan::inverse_transform_batch(), Aleph::FFT< Real >::inverse_transform_real(), Aleph::FFT< Real >::Plan::inverse_transform_real(), Aleph::FFT< Real >::inverse_transform_real(), Aleph::FFT< Real >::Plan::inverse_transform_real_batch(), Aleph::FFT< Real >::inverse_transform_real_general_impl(), Aleph::FFT< Real >::inverse_transform_real_optimized_impl(), Aleph::CA::ca_block_rule_detail::invert(), Aleph::invert_digraph(), Aleph::ConvexPolygonOffset::inward(), Aleph::FFT< Real >::irfft(), Aleph::FFT< Real >::irfft(), Aleph::FFT< Real >::Plan::irfft_batch(), Aleph::FFT< Real >::irfft_batch(), Aleph::MonotonePolygonTriangulation::is_above(), Aleph::Is_Graph_Acyclique< GT, SA >::is_acyclique(), Aleph::Is_Graph_Acyclique< GT, SA >::is_acyclique(), Aleph::Gen_Heavy_Light_Decomposition< GT, SA >::is_ancestor_id(), is_avl(), Aleph::is_avl_rk(), Aleph::Simplex< T >::is_basic_variable(), Aleph::Point::is_between(), Aleph::Interpreter_Value::is_callable(), Aleph::CA::Hashlife_Engine::is_centered_well(), Aleph::Gen_Centroid_Decomposition< GT, SA >::is_centroid_ancestor_id(), Aleph::Test_Eulerian< GT, SN, SA >::is_connected(), Aleph::Net_Graph< NodeT, ArcT >::is_connected(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::is_connected(), Aleph::Gen_Polynomial< Coefficient >::is_constant(), Aleph::Polygon::is_convex(), Aleph::GeomPolygonUtils::is_convex(), Aleph::RotatingCalipersConvexPolygon::is_convex(), Aleph::ConvexPolygonIntersectionBasic::is_convex(), Aleph::VoronoiDiagramFromDelaunay::is_convex(), Aleph::MinkowskiSumConvex::is_convex(), Aleph::ConstrainedDelaunayTriangulation::is_convex_quad(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::is_dag(), Aleph::is_double(), Aleph::Slink_Nc::is_empty(), Aleph::ConcurrentHashMap< Key, T, Cmp, Shards >::is_empty(), Aleph::is_equal(), Aleph::is_equal(), Aleph::Net_Sup_Dem_Graph< NodeT, ArcT >::is_feasible(), Aleph::is_float(), Aleph::is_graph_acyclique(), Aleph::is_graph_acyclique(), Aleph::Compiler_Lexer::is_ident_continue(), Aleph::Compiler_Lexer::is_ident_start(), Aleph::Compiler_Line_Frontend::is_identifier_continue(), Aleph::Compiler_Line_Frontend::is_identifier_start(), Aleph::Dlink::Iterator::is_in_first(), Aleph::HTList::Iterator::is_in_first(), Aleph::Compiler_Typed_Semantic_Analyzer::is_invalid_type(), Aleph::is_inversely_sorted(), Aleph::ODhashTable< Key, Cmp >::is_key_in_table(), Aleph::is_keyword(), Aleph::Killer_Move_Table< Move, true >::is_killer(), Aleph::Compiler_Dataflow_Constant::is_known(), Aleph::Dlink::Iterator::is_last(), Aleph::HTList::Iterator::is_last(), Aleph::AABBTree::Node::is_leaf(), Aleph::is_leap_year(), Aleph::Compiler_CFG_Detail::is_linear_stmt(), Aleph::is_long(), is_min_heap(), Aleph::Gen_Polynomial< Coefficient >::is_monic(), Aleph::is_multimodal(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::is_node_in_stack(), Aleph::is_normal_number(), Aleph::is_odd(), Aleph::FFT< Real >::is_one_sided_interior_bin(), Aleph::is_planar_graph(), Aleph::is_planar_graph(), Aleph::ConvexPolygonDecomposition::is_polygon_edge(), Aleph::Two_Sat< GT >::is_pos_lit(), Aleph::is_prefix(), Aleph::Compiler_Dataflow_Detail::is_pure_instruction(), Aleph::is_red_black_bst_rk(), Aleph::is_red_black_rk(), Aleph::is_red_black_tree_rk(), Aleph::is_residual(), Aleph::Point::is_right_on_of(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::is_root(), Aleph::Compact_Quotient_Filter< T >::is_run_start(), Aleph::Quotient_Filter< T >::is_run_start(), TimeoutQueue::is_running(), QueueTheadsPool< T >::is_shutdown(), is_simple_graph(), Aleph::is_size_t(), Aleph::is_sorted(), Aleph::FFT< Real >::is_stable(), Aleph::FFT< Real >::is_stable(), Aleph::FFT< Real >::is_stable(), Aleph::Test_Eulerian< GT, SN, SA >::is_strongly_connected(), is_subsequence(), QueueTheadsPool< T >::is_suspended(), Aleph::is_there_a_double_arc(), Aleph::Point::is_to_left_on_from(), Aleph::is_treap(), is_two_power(), Aleph::Interval< T >::is_valid(), Aleph::ODhashTable< Key, Cmp >::is_valid_bucket(), Aleph::OLhashTable< Key, Cmp >::is_valid_bucket(), Aleph::is_valid_coloring(), Aleph::VoronoiDiagramFortune::is_valid_delaunay(), RingFileCache< T >::is_valid_position(), Aleph::Compiler_Dataflow_Detail::is_value_used(), Aleph::MonotonePolygonTriangulation::is_y_monotone(), Aleph::Matrix< Trow, Tcol, NumType >::is_zero(), Aleph::Vector< T, NumType >::is_zero(), Aleph::Compiler_Module_Name_Resolver_Detail::issue_matches_query(), Aleph::FFT< Real >::istft(), Aleph::FFT< Real >::istft(), Aleph::FFT< Real >::istft(), Aleph::FFT< Real >::istft(), Aleph::FFT< Real >::istft(), Aleph::FFT< Real >::istft(), Aleph::FFT< Real >::istft_impl(), Aleph::KeysMixin< Derived, Type >::items(), Aleph::MapOpenHash< Key, Data, Cmp, HashTable >::items_ptr(), Aleph::DynMapTree< Key, Data, Tree, Compare >::items_ptr(), Aleph::DynMapHashTable< Key, Data, HashTable, Cmp >::items_ptr(), Aleph::CA::ca_engine_detail::iterate_1d(), Aleph::CA::ca_engine_detail::iterate_2d_column_major(), Aleph::CA::ca_engine_detail::iterate_2d_row_major(), Aleph::CA::ca_engine_detail::iterate_2d_tile(), Aleph::CA::ca_engine_detail::iterate_3d_row_major(), Aleph::FFT< Real >::jacobi_sn_cn_dn(), Aleph::jen_hash(), Aleph::jen_hash(), Aleph::jen_hash(), Aleph::join(), Aleph::join(), Aleph::join(), Aleph::DynSkipList< Key, Compare >::join(), Aleph::GenBinTree< NodeType, Key, Compare >::join(), Aleph::Gen_Treap< NodeType, Key, Compare >::join(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::join(), QuadTree::join(), Aleph::BinTree_Operation< Node, Cmp >::join(), Aleph::join(), Aleph::Tree_Node< T >::join(), Aleph::GenBinTree< NodeType, Key, Compare >::join_dup(), Aleph::Gen_Treap< NodeType, Key, Compare >::join_dup(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::join_dup(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::join_exclusive(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::join_exclusive(), Aleph::GenBinTree< NodeType, Key, Compare >::join_exclusive(), Aleph::join_exclusive(), Aleph::Gen_Treap< NodeType, Key, Compare >::join_exclusive(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::join_exclusive(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::join_exclusive(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::join_exclusive_rec(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::join_exclusive_rec_rb(), Aleph::join_exclusive_xt(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::join_left(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::join_left_rb(), Aleph::detail::PersistentTreapNodeOps< Node, Key, Compare >::join_nodes(), Aleph::BinTree_Operation< Node, Cmp >::join_preorder(), Aleph::join_preorder(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::join_right(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::join_right_rb(), Aleph::FunctionalMixin< Derived, Type >::join_str(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::join_with_pivot(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::join_with_pivot_rb(), Aleph::planarity_detail::json_escape_string(), Aleph::jsw_fill_table(), Aleph::jsw_hash(), Aleph::jsw_hash(), Aleph::justify_line(), Aleph::justify_line_except_first(), Aleph::justify_text(), Aleph::FFT< Real >::kaiser_beta(), Aleph::FFT< Real >::kaiser_window(), Aleph::Karger_Min_Cut< GT, SA >::karger_min_cut(), Aleph::karp_minimum_mean_cycle(), Aleph::karp_minimum_mean_cycle_value(), Aleph::ODhashTable< Key, Cmp >::key_in_table_to_bucket(), Aleph::ODhashTable< Key, Cmp >::key_to_bucket(), Aleph::OLhashTable< Key, Cmp >::key_to_bucket(), Aleph::key_to_pair(), Aleph::key_to_pair(), Aleph::KeysMixin< Derived, Type >::keys(), Aleph::AlDomain< T >::keys(), OhashCommon< HashTbl, Key >::keys(), Aleph::MapOpenHash< Key, Data, Cmp, HashTable >::keys(), Aleph::DynMapTree< Key, Data, Tree, Compare >::keys(), Aleph::DynMapHashTable< Key, Data, HashTable, Cmp >::keys(), Aleph::Gen_File_B_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::keys(), Aleph::Gen_File_BPlus_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::keys(), Aleph::FlatMap< Key, T, Compare >::keys(), Aleph::DynSkipList< Key, Compare >::keys_equal(), Aleph::RadixTree< T, Char >::keys_with_prefix(), Aleph::kmp_search(), Aleph::knapsack_01(), Aleph::knapsack_01_value(), Aleph::knapsack_bounded(), Aleph::knapsack_unbounded(), Aleph::knuth_optimize_interval(), Aleph::kosaraju_connected_components(), Aleph::kosaraju_connected_components(), Aleph::kurtosis(), Aleph::CA::Gray_Scott_Rule< Real, Kernel >::laplace_u(), Aleph::CA::FitzHugh_Nagumo_Rule< Real, Kernel >::laplace_u(), Aleph::CA::Gray_Scott_Rule< Real, Kernel >::laplace_v(), Aleph::CA::FitzHugh_Nagumo_Rule< Real, Kernel >::laplace_v(), Aleph::CA::laplacian_5p_kernel(), Aleph::CA::laplacian_9p_kernel(), Aleph::FunctionalMixin< Derived, Type >::last_or(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::last_relax_and_prepare_check_negative_cycle(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::last_relax_and_test_negative_cycle(), Aleph::Simplex< T >::latex_linear_program(), Aleph::Simplex< T >::latex_matrix(), Aleph::Simplex< T >::latex_solve(), FloydIntGraphTest::latex_temp_filename(), Aleph::ConstrainedDelaunayTriangulation::lawson_flip(), Aleph::lazy_combinations(), Aleph::lazy_post_order(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::lca(), Aleph::blossom_detail::Edmonds_Blossom_Matcher< GT, SA >::lca(), Aleph::Gen_Binary_Lifting_LCA< GT, SA >::lca_id(), Aleph::Gen_Polynomial< Coefficient >::lcm(), Aleph::multi_poly_detail::lcm_indices(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::lcm_pair_less(), Aleph::lcp_array_kasai(), Aleph::Gen_Polynomial< Coefficient >::leading_coeff(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::leading_monomials_coprime(), QuadTree::leaf_children_size(), Aleph::patricia_trie_detail::Bitwise_Trie_Utils< UInt >::leaf_for(), Aleph::Scope< Key, Value >::leave_scope(), Aleph::Compiler_IR_Lowering::Module_Builder::leave_scope(), Aleph::MonotonePolygonTriangulation::EdgeStatusTree::left_edge_of_point(), Aleph::BitArray::left_shift(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::leftmost_leaf(), Aleph::Point::lerp(), Aleph::ConvexPolygonDistanceGJK::lerp_point(), Aleph::HtdRbTreeRk< Key, Compare >::less(), Aleph::less_or_equal_than(), Aleph::less_or_equal_than(), Aleph::less_than(), Aleph::less_than(), Aleph::lesser(), level_order(), Aleph::level_traverse(), Aleph::level_traverse(), Aleph::Tree_Node< T >::level_traverse(), Aleph::GenBinHeap< NodeType, Key, Compare >::level_traverse(), Aleph::levelOrder(), Aleph::levenshtein_distance(), Aleph::Compiler_Lexer::lex_block_comment(), Aleph::Compiler_Lexer::lex_char_literal(), Aleph::Compiler_Lexer::lex_identifier_or_keyword(), Aleph::Compiler_Lexer::lex_line_comment(), Aleph::Compiler_Lexer::lex_number(), Aleph::Compiler_Lexer::lex_punctuation_or_operator(), Aleph::Compiler_Lexer::lex_string(), Aleph::Compiler_Lexer::lex_token(), Aleph::lexicographical_compare(), Aleph::Gen_Binary_Lifting_LCA< GT, SA >::lift(), Aleph::NTT< MOD, ROOT >::Plan::lift_input(), Aleph::FFT< Real >::lift_real_input(), Aleph::Source_Manager::line_end_offset(), Aleph::Source_Manager::line_index_from_offset(), Aleph::ConvexPolygonOffset::line_intersect(), Aleph::HalfPlaneIntersection::line_intersection(), Aleph::ConvexPolygonIntersectionBasic::line_intersection(), Aleph::CA::Bit_Cell_Storage< N >::linear_index(), Aleph::CA::Dense_Cell_Storage< T, N >::linear_index(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::link(), Aleph::Gen_Link_Cut_Tree_WithEdges< VT, ET, EdgeMonoid, LazyTag >::link(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::link_cookies_and_free(), Aleph::lis_length(), Aleph::list_insertion_sort(), Aleph::Compiler_Type_Context::list_to_array(), Aleph::list_to_DynList(), Aleph::Two_Sat< GT >::lit_var(), LLVMFuzzerTestOneInput(), Aleph::IO_Graph< GT, Load_Node, Store_Node, Load_Arc, Store_Arc, NF, AF >::load(), Aleph::BitArray::load(), load_arc_option(), Aleph::load_binary_number(), Aleph::load_char_literal(), load_deway_number(), Aleph::load_digraph(), load_distance_option(), Aleph::load_double(), Aleph::load_escaped_string(), Aleph::Source_Manager::load_file(), Aleph::load_file_contents(), Aleph::load_file_lines(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::load_from_disk(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::load_from_disk(), Aleph::load_hex_number(), Aleph::load_identifier(), Aleph::IO_Graph< GT, Load_Node, Store_Node, Load_Arc, Store_Arc, NF, AF >::load_in_text_mode(), load_key_option(), Aleph::Huffman_Encoder_Engine::load_leaf_keys_in_prefix(), load_node(), load_nodes(), Aleph::load_number(), Aleph::load_octal_number(), load_offset_option(), Aleph::detail::load_ordered_tree_snapshot(), load_parrectangle_option(), load_rectangle_option(), Aleph::CA::Hashlife_Engine::load_rle(), Aleph::CA::Hashlife_Engine::load_rle_string(), Aleph::Compiler_Line_Frontend::load_sources(), Aleph::Compiler_MVP_Frontend::load_sources(), load_split_option(), Aleph::load_string(), Aleph::Huffman_Encoder_Engine::load_string_from_bytes(), load_tag_option(), load_thread_option(), Aleph::Huffman_Encoder_Engine::load_tree(), Aleph::load_tree(), Aleph::load_tree_from_array(), Aleph::load_tree_keys_from_array(), Aleph::load_tree_keys_in_prefix(), load_triangle_option(), load_triangleh_option(), Aleph::CA::Tile_Cache< State, TileSide >::local_index(), Aleph::DelaunayTriangulationRandomizedIncremental::locate(), Aleph::TrapezoidalMapPointLocation::Result::locate(), Aleph::PointInPolygonWinding::locate(), Aleph::VoronoiDiagramFortune::locate_arc(), Aleph::GenLhashTable< Key, BucketType, Cmp >::Iterator::locate_next_available_bucket(), Aleph::GenLhashTable< Key, BucketType, Cmp >::Iterator::locate_next_available_bucket_ne(), Aleph::GenLhashTable< Key, BucketType, Cmp >::Iterator::locate_next_available_entry(), OhashCommon< HashTbl, Key >::Iterator::locate_next_available_entry_ne(), Aleph::GenLhashTable< Key, BucketType, Cmp >::Iterator::locate_next_available_entry_ne(), Aleph::Polygon::locate_point(), Aleph::GenLhashTable< Key, BucketType, Cmp >::Iterator::locate_prev_available_bucket(), Aleph::GenLhashTable< Key, BucketType, Cmp >::Iterator::locate_prev_available_bucket_ne(), Aleph::GenLhashTable< Key, BucketType, Cmp >::Iterator::locate_prev_available_entry(), OhashCommon< HashTbl, Key >::Iterator::locate_prev_available_entry_ne(), Aleph::GenLhashTable< Key, BucketType, Cmp >::Iterator::locate_prev_available_entry_ne(), UseMutex::lock(), SmartHomeState::log(), ModernSmartHome::log(), Aleph::longest_common_substring(), Aleph::Suffix_Automaton::longest_common_substring(), Aleph::longest_common_substring_sam(), Aleph::longest_increasing_subsequence(), Aleph::longest_nondecreasing_subsequence(), Aleph::RadixTree< T, Char >::longest_prefix(), Aleph::Compiler_Typed_Semantic_Analyzer::lookup_name_type(), Aleph::CA::ca_gif_detail::lookup_palette_index(), Aleph::Gen_Link_Cut_Tree_WithEdges< VT, ET, EdgeMonoid, LazyTag >::lookup_vertex_val(), Aleph::Gen_Fenwick_Tree< T, Plus, Minus >::lowbit(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::lower_bound(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::lower_bound(), Aleph::Gen_File_B_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::lower_bound(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::lower_bound(), Aleph::Gen_File_BPlus_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::lower_bound(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::lower_bound(), Aleph::lower_bound(), Aleph::lower_bound(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::lower_bound_index(), Aleph::lis_detail::lower_bound_pos(), Aleph::RangeTree2D::lower_bound_x(), Aleph::RangeTree2D::lower_bound_y(), Aleph::Compiler_Driver::lower_bytecode(), Aleph::Compiler_Generic_Driver::lower_bytecode(), Aleph::Compiler_IR_Lowering::Module_Builder::lower_expr(), Aleph::Compiler_HIR_Lowering::lower_function(), Aleph::Compiler_CFG_Lowering::lower_function(), Aleph::Compiler_Bytecode_Lowering::lower_function(), Aleph::Compiler_IR_Lowering::Module_Builder::lower_function_body(), Aleph::Compiler_SSA_Lowering::lower_function_internal(), Aleph::Compiler_Driver::lower_hir(), Aleph::Compiler_Line_Frontend::lower_hir(), Aleph::Compiler_MVP_Frontend::lower_hir(), Aleph::FlatMap< Key, T, Compare >::lower_idx(), Aleph::FlatSet< Key, Compare >::lower_idx(), Aleph::Compiler_Driver::lower_ir(), Aleph::Compiler_Line_Frontend::lower_ir(), Aleph::Compiler_MVP_Frontend::lower_ir(), Aleph::Compiler_CFG_Lowering::lower_module(), Aleph::Compiler_IR_Lowering::lower_module(), Aleph::NTT< MOD, ROOT >::Plan::lower_output(), Aleph::Compiler_CFG_Lowering::lower_statement_sequence(), Aleph::Compiler_CFG_Lowering::lower_stmt(), Aleph::Compiler_IR_Lowering::Module_Builder::lower_stmt(), Aleph::Compiler_HIR_Lowering::lower_stmt(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::lowest(), K2Tree< T >::lr_insert(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::lset_add_blossom_edge(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::lset_add_vertex_edge(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::lset_get_best_blossom_edge(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::lset_get_best_vertex_edge(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::lset_merge_blossoms(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::lset_new_blossom(), Aleph::ltrim(), Aleph::ModularCombinatorics::lucas_nCk(), luka_to_tree(), Aleph::CA::ca_gif_detail::lzw_bytes(), Aleph::FFT< Real >::magnitude_spectrum(), Aleph::FFT< Real >::magnitude_spectrum(), main(), main(), main(), main(), Aleph::Compiler_Bytecode_Context::make(), Aleph::Compiler_SSA_Context::make(), Aleph::Compiler_Ast_Context::make(), Aleph::Compiler_CFG_Context::make(), Aleph::Compiler_HIR_Context::make(), Aleph::Compiler_IR_Context::make(), make_array(), Aleph::make_array_container(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::make_blossom(), Aleph::Compiler_Bytecode_Value::make_character(), Aleph::Interpreter_Value::make_character(), make_circle(), make_clip_window(), Aleph::CA::make_composite_observer(), make_dynarray(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::make_edge_witness(), Aleph::Compiler_Type_Context::make_enum_type(), Aleph::Compiler_Lexer::make_eof_token(), Aleph::Compiler_Bytecode_VM::make_error(), Aleph::Random_Graph< GT, Init_Node, Init_Arc >::make_eulerian(), Aleph::Random_Digraph< GT, Init_Node, Init_Arc >::make_eulerian(), Aleph::Interpreter_Value::make_function(), Aleph::Compiler_Type_Context::make_function_type(), Aleph::CA::make_gol_engine(), Aleph::CA::make_gol_engine(), Aleph::CA::Reproductions::make_gray_scott_seed(), Aleph::CA::make_grid_graph_adjacency(), Aleph::CA::make_history_rule(), Aleph::Compiler_Bytecode_Value::make_host_function(), Aleph::Interpreter_Value::make_host_function(), Aleph::make_init_guard(), Aleph::ThreadPool::make_invocable(), Aleph::CA::make_lattice_from_snapshot(), Aleph::PersistentHashMap< Key, T, Cmp >::make_leaf_from_value(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::make_monic_inplace(), Aleph::PersistentTreapSet< Key, Compare >::make_node(), Aleph::PersistentTreapMap< Key, T, Compare >::make_node(), make_noisy_circle(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::make_pair_candidate(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::make_path(), Aleph::CA::make_path_graph_adjacency(), make_pentagon(), make_random_polygon(), Aleph_Test_Helpers::make_random_tree_edges(), Aleph::FlatMap< Key, T, Compare >::make_room(), Aleph::CA::Multi_Field_Lattice< Layout, Boundary, Rank, Fields >::make_soa(), Aleph::CA::Multi_Field_Lattice< Layout, Boundary, Rank, Fields >::make_soa_init(), make_square(), make_square_poly(), make_star(), make_star(), Aleph::Compiler_Type_Context::make_struct_type(), Aleph::Net_Graph< NodeT, ArcT >::make_super_sink(), Aleph::CA::ca_checkpoint_detail::make_tmp_path(), Aleph::Compiler_Lexer::make_token(), Aleph::TrapezoidalMapPointLocation::make_trapezoid(), Aleph::Compiler_Type_Context::make_tuple_type(), Aleph::Compiler_Type_Context::make_type_variable(), Aleph::Compiler_Bytecode_VM::make_validation_error(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::make_vertex(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::make_vertices(), Aleph::CA::make_wolfram_elementary_rule(), Aleph::CA::make_wolfram_engine(), Aleph::CA::make_wolfram_engine(), Aleph::manacher(), Aleph::map_arcs(), Aleph::ConstrainedDelaunayTriangulation::map_constraints(), Aleph::Johnson< GT, Distance, Ait, NAit, SA >::map_copy_path_to_original(), Aleph::map_cut_graph(), Aleph::Compute_Cut_Nodes< GT, SA >::map_cut_graph(), Aleph::map_hash_fct(), Aleph::map_in_arcs(), Aleph::map_in_arcs(), Aleph::map_keys_to_DynList(), Aleph::map_nodes(), Aleph::map_out_arcs(), Aleph::map_out_arcs(), Aleph::map_perm(), Aleph::map_perm(), Aleph::map_subgraph(), Aleph::Compute_Cut_Nodes< GT, SA >::map_subgraph(), Aleph::Compute_Cut_Nodes< GT, SA >::map_subgraph(), Aleph::map_to_Array(), Aleph::map_to_DynList(), Aleph::map_unify(), Aleph::map_values_to_DynList(), Aleph::map_vector(), Aleph::Tikz_Plane::map_x(), Aleph::Tikz_Plane::map_x_length(), Aleph::Tikz_Plane::map_y(), Aleph::Tikz_Plane::map_y_length(), Aleph::maphash_keys_to_DynList(), Aleph::maphash_to_Array(), Aleph::maphash_to_DynList(), Aleph::maphash_to_stdmap(), Aleph::maphash_values_to_DynList(), Aleph::mapped_arc(), Aleph::mapped_arc(), Aleph::mapped_node(), Aleph::mapped_node(), Aleph::maps(), Aleph::FunctionalMixin< Derived, Type >::maps(), Aleph::FunctionalMixin< Derived, Type >::maps(), Aleph::maptree_keys_to_DynList(), Aleph::maptree_to_Array(), Aleph::maptree_to_DynList(), Aleph::maptree_to_stdmap(), Aleph::maptree_values_to_DynList(), Aleph::ConstrainedDelaunayTriangulation::mark_constrained(), Aleph::Cnode::mark_end_word(), Aleph::blossom_detail::Edmonds_Blossom_Matcher< GT, SA >::mark_path(), Aleph::mark_position(), Aleph::Compiler_Dataflow_Detail::mark_value_used(), Aleph::mat_to_latex(), Aleph::mat_to_latex(), Aleph::mat_to_latex_simple(), Aleph::Compiler_Parser_Stream::match(), Aleph::FlatMap< Key, T, Compare >::match_at(), Aleph::FlatSet< Key, Compare >::match_at(), Aleph::matrix_chain_min_cost(), Aleph::matrix_chain_order(), Aleph::FFT< Real >::matrix_shape(), Aleph::Matrix< Trow, Tcol, NumType >::matrix_vector_mult(), Aleph::FFT< Real >::max_abs_value(), Aleph::FFT< Real >::OverlapAddBank::max_batch_length(), Aleph::FunctionalMixin< Derived, Type >::max_by(), Aleph::Gen_Centroid_Decomposition< GT, SA >::max_centroid_level(), Aleph::max_element(), Aleph::max_flow_min_cost_by_cycle_canceling(), Aleph::max_flow_min_cost_by_network_simplex(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::max_in(), Aleph::Gen_File_B_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::max_item(), Aleph::Gen_File_BPlus_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::max_item(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::max_key(), Aleph::max_ptr(), Aleph::FFT< Real >::max_root_radius(), Aleph::NTT< MOD, ROOT >::max_transform_size_impl(), Aleph::blossom_weighted_detail::mwmatching::maximum_weight_matching(), Aleph::Rope< Char, LeafSize >::maybe_rebalance(), OhashCommon< HashTbl, Key >::me(), HashStats< HashTbl >::me(), Aleph::CA::mean_3x3_kernel(), Aleph::CA::mean_5x5_kernel(), Aleph::CA::Reproductions::mean_channel_difference(), Aleph::CA::Bench::measure(), HashDistributionTest::measureHashUniqueness(), Aleph::MinimumEnclosingCircle::mec_with_point(), Aleph::MinimumEnclosingCircle::mec_with_two_points(), Aleph::Compiler_Dataflow_Detail::meet_constants(), meeting_scheduler(), Aleph::mem_fun(), Aleph::mem_fun(), Aleph::mem_fun(), Aleph::mem_fun(), Aleph::mem_fun_ref(), Aleph::mem_fun_ref(), Aleph::mem_fun_ref(), Aleph::mem_fun_ref(), Aleph::Compact_Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::memory_usage(), Aleph::Quotient_Filter< T >::memory_usage(), Aleph::Compact_Quotient_Filter< T >::merge(), Aleph::Count_Min_Sketch< T, CounterT >::merge(), Aleph::HyperLogLog< T >::merge(), Aleph::MinHash< T >::merge(), Aleph::Quotient_Filter< T >::merge(), Aleph::Fibonacci_Heap< T, Compare >::merge(), Aleph::Fibonacci_Heap< T, Compare >::merge(), Aleph::merge(), Aleph::merge(), Aleph::merge(), Aleph::ConstrainedDelaunayTriangulation::merge_and_deduplicate(), Aleph::timsort_detail::merge_at(), Aleph::Tikz_Plane::merge_box(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::merge_children(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::merge_children(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::merge_children(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::merge_children(), Aleph::timsort_detail::merge_collapse(), Aleph::ConvexPolygonDecomposition::merge_faces(), Aleph::timsort_detail::merge_force_collapse(), Aleph::timsort_detail::merge_hi(), Aleph::PersistentHashMap< Key, T, Cmp >::merge_leaves(), Aleph::merge_lists(), Aleph::merge_lists(), Aleph::timsort_detail::merge_lo(), Aleph::Compiler_Driver::merge_modules_from_order(), Aleph::Compiler_MVP_Frontend::merge_modules_from_order(), Aleph::Compiler_Driver_Detail::merge_report(), Aleph::parallel_detail::merge_sequential(), Aleph::Compiler_CFG_Lowering::merge_span(), Aleph::Compiler_IR_Lowering::Module_Builder::merge_span(), Aleph::Compiler_HIR_Builder::merge_span(), Aleph::Compiler_IR_Builder::merge_span(), Aleph::mergeinsertsort(), Aleph::mergesort(), Aleph::mergesort(), Aleph::mergesort(), Aleph::mergesort(), Aleph::mergesort(), Aleph::mergesort(), Aleph::mergesort(), Aleph::Segment::mid_perpendicular(), Aleph::Point::midpoint(), Aleph::Gen_Polynomial< Coefficient >::mignotte_bound(), Aleph::miller_rabin(), Aleph::FunctionalMixin< Derived, Type >::min_by(), Aleph::min_cut(), Aleph::Stoer_Wagner_Min_Cut< GT, Distance, SA >::min_cut_weight(), Aleph::min_element(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::min_in(), Aleph::Gen_File_B_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::min_item(), Aleph::Gen_File_BPlus_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::min_item(), Aleph::min_ptr(), Aleph::Prim_Min_Spanning_Tree< GT, Distance, SA >::min_spanning_tree(), Aleph::min_weighted_squared_distance_1d(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::minimize_groebner_basis(), Aleph::FFT< Real >::minimum_cancellation_distance_impl(), Aleph::Stoer_Wagner_Min_Cut< GT, Distance, SA >::minimum_cut_phase(), Aleph::minimum_mean_cycle(), Aleph::minimum_mean_cycle_value(), Aleph::FFT< Real >::minimum_pole_zero_distance(), Aleph::FFT< Real >::minimum_pole_zero_distance(), Aleph::RotatingCalipersConvexPolygon::minimum_width(), Aleph::minmax_ptr(), Aleph::mismatch(), Aleph::FFT< Real >::Plan::mixed_radix_transform_recursive(), Aleph::Gen_Mo_On_Trees< GT, Policy >::mo_sweep(), Aleph::Gen_Mo_On_Tree_Node< T, Policy >::mo_sweep(), Aleph::mod_exp(), Aleph::mod_inv(), Aleph::mod_mul(), Aleph::mode(), Aleph::FFT< Real >::modified_bessel_i0(), Aleph::Compiler_Bytecode_VM::module_is_valid(), Aleph::DynArray< T >::modulus_by_block_size(), Aleph::DynArray< T >::modulus_from_index_in_dir(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::monomial(), Aleph::monotone_queue_min_dp(), Aleph::CA::Directory_Frame_Sink::montage_command_hint(), monte_carlo_simulation(), Aleph::CA::Reproductions::morans_i_binary(), Aleph::GenBinTree< NodeType, Key, Compare >::move_all(), mst_total_weight(), Aleph::NTTExact::mul_capped(), Aleph::mul_xor_fold64(), Aleph::Matrix< Trow, Tcol, NumType >::mult_by_scalar(), Aleph::Matrix< Trow, Tcol, NumType >::mult_matrix_vector_dot_product(), Aleph::Matrix< Trow, Tcol, NumType >::mult_matrix_vector_linear_comb(), Aleph::Matrix< Trow, Tcol, NumType >::mult_matrix_vector_sparse(), Aleph::Matrix< Trow, Tcol, NumType >::mult_vector_matrix_dot_product(), Aleph::Matrix< Trow, Tcol, NumType >::mult_vector_matrix_linear_comb(), Aleph::Gen_Polynomial< Coefficient >::multi_eval(), Aleph::multi_poly_detail::multi_to_flat_index(), Polinomio::multiplicado_por(), Aleph::NTT< MOD, ROOT >::multiply(), Aleph::NTTExact::multiply(), Aleph::FFT< Real >::multiply_complex_impl(), Aleph::NTT< MOD, ROOT >::Plan::multiply_impl(), Aleph::FFT< Real >::multiply_real_optimized(), Aleph::NTT< MOD, ROOT >::multipoint_eval(), Aleph::NTT< MOD, ROOT >::multipoint_eval_recursive(), Aleph::murmur3hash(), Aleph::murmur3hash(), Aleph::murmur3hash(), Aleph::MurmurHash3_x64_128(), Aleph::MurmurHash3_x86_128(), Aleph::MurmurHash3_x86_32(), Aleph::FunctionalMixin< Derived, Type >::mutable_for_each(), Aleph::FunctionalMixin< Derived, Type >::mutable_for_each(), Aleph::ModularCombinatorics::nCk(), DataGenerator::nearly_sorted(), Aleph::NTT< MOD, ROOT >::negacyclic_multiply(), Aleph::Two_Sat< GT >::negate_lit(), Aleph::FFT< Real >::neon_dispatch_available(), Aleph::NTT< MOD, ROOT >::neon_dispatch_available(), network_latency(), network_packet_analysis(), Aleph::network_to_dot_string(), Aleph::network_to_json_string(), Aleph::Gen_Polynomial< Coefficient >::newton_root(), Aleph::Array_Iterator< T >::next(), Aleph::Dlink::Iterator::next(), Aleph::Slinknc::Iterator::next(), Aleph::HTList::Iterator::next(), Aleph::Regular_Polygon::Vertex_Iterator::next(), Aleph::Regular_Polygon::Segment_Iterator::next(), RingFileCache< T >::Iterator::next(), Aleph::Slink_Nc::Iterator::next(), Aleph::GenBinHeap< NodeType, Key, Compare >::Iterator::next(), Aleph::BinNodePrefixIterator< Node >::next(), Aleph::BinNodeInfixIterator< Node >::next(), Aleph::BinTreeXt_Iterator< TreeType, Node, Key, Compare >::next(), Aleph::DynArray< T >::Iterator::next(), Aleph::Slist< T >::Iterator::next(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::Iterator::next(), Aleph::Tree_Node< T >::Iterator::next(), Aleph::next_combination_indices(), Aleph::next_combination_mask(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::Iterator::next_ne(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::Iterator::next_ne(), Aleph::HTList::Iterator::next_ne(), Aleph::Tree_Node< T >::Iterator::next_ne(), Aleph::next_permutation(), Aleph::next_permutation(), Aleph::next_power_of_2(), Aleph::MemArray< T >::next_power_of_two(), Aleph::next_value(), Aleph::Vertex::next_vertex(), Aleph::nibble_to_char(), Aleph::no_equals(), Aleph::no_equals(), Aleph::Gen_Link_Cut_Tree_WithEdges< VT, ET, EdgeMonoid, LazyTag >::node_ptr_hash(), Aleph::Path< GT >::nodes(), Aleph::nodes_map(), Aleph::nodes_map(), Aleph::Net_Sup_Dem_Graph< NodeT, ArcT >::non_feasible_nodes(), Aleph::none(), Aleph::none(), Aleph::DynSkipList< Key, Compare >::none(), Aleph::DynSkipList< Key, Compare >::none(), Aleph::FunctionalMixin< Derived, Type >::none(), Aleph::FunctionalMixin< Derived, Type >::none(), Aleph::none_of_tuple(), Aleph::none_perm(), Aleph::nonplanar_certificate_to_dot(), Aleph::nonplanar_certificate_to_gexf(), Aleph::nonplanar_certificate_to_graphml(), Aleph::nonplanar_certificate_to_json(), Aleph::MinkowskiSumConvex::normalize(), Aleph::FFT< Real >::normalize_axes(), Aleph::FFT< Real >::normalize_fir_at_omega(), Aleph::FFT< Real >::normalize_iir_coefficients(), Aleph::Compiler_SSA_Detail::normalize_ir_function(), Aleph::polynomial_detail::normalize_mod_u64(), Aleph::NTT< MOD, ROOT >::normalize_poly(), Aleph::FFT< Real >::ISTFTProcessor::normalize_prefix(), Aleph::FFT< Real >::normalize_tensor_layout(), Aleph::CuttingEarsTriangulation::normalize_to_ccw(), Aleph::ConvexPolygonIntersectionBasic::normalize_vertices(), Aleph::HalfPlaneIntersection::normalize_vertices(), Aleph::FFT< Real >::normalized_sinc(), north_offset(), Aleph::not1(), Aleph::not2(), Aleph::CancellationState::notify_observers(), Aleph::CancellationToken::notify_on_cancel(), now_str(), Aleph::nrange(), Aleph::Gen_Polynomial< Coefficient >::nth_derivative(), Aleph::Simplex< T >::objective_sensitivity(), Aleph::Compiler_Type_Unifier::occurs_in(), Aleph::ConvexPolygonOffset::offset_edge(), Aleph::PolygonOffset::offset_edge(), Aleph::PolygonOffset::offset_polygon(), Aleph::CA::offset_to_axial_even_r(), Aleph::CA::offset_to_axial_odd_r(), Aleph::Compiler_Driver::ok(), Aleph::Compiler_Driver_Run_Output::ok(), Aleph::Compiler_Generic_Driver::ok(), Aleph::CA::Density_Observer< State >::on_step_begin(), Aleph::CA::Entropy_Observer< MaxState >::on_step_begin(), Aleph::CA::Composite_Observer< Observers >::on_step_begin(), Aleph::CA::Activity_Observer< Lattice >::on_step_begin(), Aleph::CA::Density_Observer< State >::on_step_end(), Aleph::CA::Activity_Observer< Lattice >::on_step_end(), Aleph::CA::Entropy_Observer< MaxState >::on_step_end(), Aleph::CA::Composite_Observer< Observers >::on_step_end(), Aleph::CA::Stationary_Detector::on_step_end(), Test::on_step_end(), Aleph::Gen_Polynomial< Coefficient >::one(), Aleph::FFT< Real >::one_sided_frequency_grid(), Aleph::only_alpha(), PercolationSystem::open(), Aleph::MemArray< T >::open_gap(), Aleph::open_gap(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::open_storage(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::open_storage(), Aleph::Ady_Mat< GT, __Entry_Type, SA >::operate_all_arcs_list_graph(), Aleph::Ady_Mat< GT, __Entry_Type, SA >::operate_all_arcs_list_graph(), Aleph::Ady_Mat< GT, __Entry_Type, SA >::operate_all_arcs_matrix(), Aleph::Ady_Mat< GT, __Entry_Type, SA >::operate_all_arcs_matrix(), QuadTree::operate_on_nodes(), operator delete(), operator delete(), operator delete(), operator delete[](), operator delete[](), operator delete[](), Foo::operator int(), operator new(), operator new(), operator new[](), operator new[](), Aleph::RingBuffer< T >::basic_iterator< IsConst >::operator!=(), Aleph::BinTreeXt_Iterator< TreeType, Node, Key, Compare >::operator!=(), Counted::operator!=(), Aleph::Ellipse::operator!=(), Aleph::FlatMap< Key, T, Compare >::operator!=(), Aleph::FlatSet< Key, Compare >::operator!=(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::operator!=(), Aleph::Gen_Polynomial< Coefficient >::operator!=(), Aleph::Interval< T >::operator!=(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::Iterator::operator!=(), Aleph::Polygon::Iterator::operator!=(), Aleph::CsvReader::Iterator::operator!=(), Aleph::LineEq::operator!=(), Aleph::Matrix< Trow, Tcol, NumType >::operator!=(), Aleph::Path< GT >::operator!=(), Aleph::Point::operator!=(), Aleph::Rectangle::operator!=(), Aleph::RingBuffer< T >::operator!=(), Aleph::RotatedEllipse::operator!=(), Aleph::Segment::operator!=(), Aleph::Segment3D::operator!=(), Aleph::SmallVector< T, N >::operator!=(), Aleph::StlEnumerateIterator< Container >::operator!=(), Aleph::StlZipIterator< Containers >::operator!=(), Aleph::Triangle::operator!=(), Aleph::UniZipIterator< Containers >::operator!=(), Aleph::Vector< T, NumType >::operator!=(), Aleph::BitArray::operator&=(), Aleph::Bloom_Filter< T >::operator&=(), Aleph::pointer_to_unary_function< _Arg, _Result >::operator()(), Aleph::pointer_to_binary_function< _Arg1, _Arg2, _Result >::operator()(), Aleph::_Select1st< _Pair >::operator()(), Aleph::_Select2nd< _Pair >::operator()(), Aleph::mem_fun_ref_t< _Ret, _Tp >::operator()(), Aleph::mem_fun_ref_t< void, _Tp >::operator()(), Aleph::mem_fun1_ref_t< _Ret, _Tp, _Arg >::operator()(), Aleph::mem_fun1_ref_t< void, _Tp, _Arg >::operator()(), Aleph::_Identity< _Tp >::operator()(), Aleph::mem_fun_t< _Ret, _Tp >::operator()(), Aleph::mem_fun_t< void, _Tp >::operator()(), Aleph::mem_fun1_t< _Ret, _Tp, _Arg >::operator()(), Aleph::mem_fun1_t< void, _Tp, _Arg >::operator()(), InitFromArc::operator()(), InitAll::operator()(), Aleph::k_shortest_paths_detail::Filtered_Show_Arc< GT, SA >::operator()(), Aleph::k_shortest_paths_detail::Reverse_Arc_Distance< GT, Distance >::operator()(), Cargar_Clave::operator()(), Aleph::Huffman_Encoder_Engine::Load_Key::operator()(), Aleph::_Select1st< _Pair >::operator()(), Aleph::_Select2nd< _Pair >::operator()(), Aleph::const_mem_fun_ref_t< _Ret, _Tp >::operator()(), Aleph::const_mem_fun_ref_t< void, _Tp >::operator()(), Aleph::const_mem_fun1_ref_t< _Ret, _Tp, _Arg >::operator()(), Aleph::const_mem_fun1_ref_t< void, _Tp, _Arg >::operator()(), Aleph::_Identity< _Tp >::operator()(), Aleph::negate< _Tp >::operator()(), Aleph::logical_not< _Tp >::operator()(), Aleph::plus< _Tp >::operator()(), Aleph::minus< _Tp >::operator()(), Aleph::multiplies< _Tp >::operator()(), Aleph::divides< _Tp >::operator()(), Aleph::modulus< _Tp >::operator()(), Aleph::equal_to< _Tp >::operator()(), Aleph::not_equal_to< _Tp >::operator()(), Aleph::greater< _Tp >::operator()(), Aleph::less< _Tp >::operator()(), Aleph::greater_equal< _Tp >::operator()(), Aleph::less_equal< _Tp >::operator()(), Aleph::logical_and< _Tp >::operator()(), Aleph::logical_or< _Tp >::operator()(), Aleph::const_mem_fun_t< _Ret, _Tp >::operator()(), Aleph::const_mem_fun_t< void, _Tp >::operator()(), Aleph::const_mem_fun1_t< _Ret, _Tp, _Arg >::operator()(), Aleph::const_mem_fun1_t< void, _Tp, _Arg >::operator()(), Aleph::HalfPlaneIntersection::operator()(), Aleph::VisvalingamWhyattSimplification::operator()(), Aleph::DouglasPeuckerSimplification::operator()(), Aleph::ChaikinSmoothing::operator()(), Aleph::TrapezoidalMapPointLocation::operator()(), Aleph::TrapezoidalMapPointLocation::operator()(), Aleph::SweepLineSegmentIntersection::operator()(), Aleph::SegmentArrangement::operator()(), Aleph::Lex_Order::operator()(), Aleph::Grlex_Order::operator()(), Aleph::Grevlex_Order::operator()(), Aleph::PowerDiagram::operator()(), Aleph::RegularTriangulationBowyerWatson::operator()(), Aleph::CA::Cell_Rule_As_Block_Rule< Cell_Rule >::operator()(), Aleph::CA::Critters_Rule::operator()(), Aleph::CA::BBM_Rule::operator()(), Aleph::CA::TM_Gas_Rule::operator()(), Ciudad_Igual::operator()(), Ciudad_Igual::operator()(), Clave_Igual::operator()(), Aleph::bucket_sort_detail::sort_invoker_factory< SortFn >::operator()(), Aleph::CmpContainer< Container, T >::operator()(), Aleph::VoronoiDiagramFromDelaunay::operator()(), Aleph::Build_Spanning_Tree< GT >::operator()(), Aleph::Build_Spanning_Tree< GT >::operator()(), Aleph::ClosestPairDivideAndConquer::operator()(), Aleph::DelaunayTriangulationBowyerWatson::operator()(), Aleph::DelaunayTriangulationRandomizedIncremental::operator()(), Aleph::VoronoiDiagramFromDelaunay::operator()(), Aleph::AndrewMonotonicChainConvexHull::operator()(), Aleph::GrahamScanConvexHull::operator()(), Aleph::BruteForceConvexHull::operator()(), Aleph::GiftWrappingConvexHull::operator()(), Aleph::QuickHull::operator()(), Aleph::MinimumEnclosingCircle::operator()(), Aleph::ConstrainedDelaunayTriangulation::operator()(), Aleph::AlphaShape::operator()(), Aleph::VisvalingamWhyattSimplification::operator()(), Aleph::DouglasPeuckerSimplification::operator()(), Aleph::ChaikinSmoothing::operator()(), Aleph::VoronoiDiagram::operator()(), Aleph::VoronoiDiagramFortune::operator()(), Aleph::Gen_Link_Cut_Tree_WithEdges< VT, ET, EdgeMonoid, LazyTag >::EdgeKeyHash::operator()(), Aleph::Prefer_Exact_Adversarial_Entry< Move, Score >::operator()(), Aleph::Prefer_Deeper_Entry< Entry >::operator()(), Aleph::CA::Field_Slice_Rule< I, Inner >::operator()(), Aleph::CA::Field_Slice_Rule< I, Inner >::operator()(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::Uni_Factor_Signature_Less::operator()(), Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::Destroy_Arc::operator()(), Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::Destroy_Tree_Arc::operator()(), Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::Destroy_Node::operator()(), Aleph::Karp_Minimum_Mean_Cycle< GT, Distance, SA >::operator()(), Aleph::Karp_Minimum_Mean_Cycle_Value< GT, Distance, SA >::operator()(), Aleph::Planarity_Test< GT, SA >::operator()(), Aleph::Is_Planar_Graph< GT, SA >::operator()(), Aleph::Compute_Cycle_In_Digraph< GT, Itor, SA >::operator()(), Aleph::Invert_Digraph< GT, SA >::operator()(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::operator()(), Aleph::Q_Topological_Sort< GT, Itor, SA >::operator()(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::operator()(), Aleph::Compute_Maximum_Cardinality_General_Matching< GT, SA >::operator()(), Aleph::Compute_Maximum_Weight_General_Matching< GT, Weight, SA >::operator()(), Aleph::Compute_Minimum_Cost_General_Matching< GT, Cost, SA >::operator()(), Aleph::Compute_Minimum_Cost_Perfect_General_Matching< GT, Cost, SA >::operator()(), Aleph::Compute_Maximum_Cardinality_Bipartite_Matching< GT, Max_Flow, SA >::operator()(), Aleph::Hopcroft_Karp_Matching< GT, SA >::operator()(), Aleph::Compute_Bipartite< GT, SA >::operator()(), Aleph::Topological_Sort< GT, Itor, SA >::operator()(), Aleph::Q_Topological_Sort< GT, Itor, SA >::operator()(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::operator()(), Aleph::Q_Topological_Sort< GT, Itor, SA >::operator()(), Aleph::Unconnected_Components< GT, SA >::operator()(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::operator()(), Aleph::Kosaraju_Connected_Components< GT >::operator()(), Aleph::Unconnected_Components< GT, SA >::operator()(), Aleph::Build_Subgraph< GT, SA >::operator()(), Aleph::Greedy_Coloring< GT, SA >::operator()(), Aleph::Welsh_Powell_Coloring< GT, SA >::operator()(), Aleph::DSatur_Coloring< GT, SA >::operator()(), Aleph::Build_Subgraph< GT, SA >::operator()(), Aleph::Lengauer_Tarjan_Post_Dominators< GT, SA >::operator()(), Aleph::Compute_Cycle_In_Digraph< GT, Itor, SA >::operator()(), Aleph::To_Graphviz< GT, Node_Attr, Arc_Attr, SN, SA >::operator()(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::Init_Tarjan_Node::operator()(), Aleph::Yen_K_Shortest_Paths< GT, Distance, SA >::operator()(), Aleph::Eppstein_K_Shortest_Paths< GT, Distance, SA >::operator()(), Aleph::Compute_Cycle_In_Digraph< GT, Itor, SA >::operator()(), Aleph::Find_Path_Depth_First< GT, Itor, SA >::operator()(), Aleph::Find_Path_Breadth_First< GT, Itor, SA >::operator()(), Aleph::Find_Path_Depth_First< GT, Itor, SA >::operator()(), Aleph::Find_Path_Breadth_First< GT, Itor, SA >::operator()(), Aleph::Find_Path_Depth_First< GT, Itor, SA >::operator()(), Aleph::Find_Path_Breadth_First< GT, Itor, SA >::operator()(), Aleph::Test_For_Path< GT, SA >::operator()(), Aleph::IndexArc< GT, Tree, SA >::Cmp_Arc::operator()(), Aleph::CA::History_Rule< Depth, F >::operator()(), Aleph::Equal_Node::operator()(), std::hash< MoveTracker >::operator()(), MyRecord::Eq::operator()(), Aleph::CA::ca_hashlife_detail::Node_Key_Hash::operator()(), std::hash< Point >::operator()(), Aleph::BooleanPolygonOperations::operator()(), Aleph::MinkowskiSumConvex::operator()(), Aleph::ConvexPolygonDistanceGJK::operator()(), Aleph::CuttingEarsTriangulation::operator()(), Aleph::ConvexPolygonDecomposition::operator()(), Aleph::PolygonOffset::operator()(), Aleph::TrapezoidalMapPointLocation::operator()(), Aleph::VisibilityPolygon::operator()(), Aleph::ShortestPathInPolygon::operator()(), Aleph::ConvexPolygonIntersectionBasic::operator()(), Cmp_Sample< Key >::operator()(), Aleph::BruteForceConvexHull::CmpSegment::operator()(), Aleph::SegmentSegmentIntersection::operator()(), Aleph::Random_Graph< GT, Init_Node, Init_Arc >::operator()(), Aleph::Random_Graph< GT, Init_Node, Init_Arc >::operator()(), Aleph::Random_Digraph< GT, Init_Node, Init_Arc >::operator()(), Aleph::MemArray< T >::operator()(), Random_Network_Flow< Net >::operator()(), Aleph::CA::Game_Of_Life_Functor::operator()(), Aleph::CA::Continuous_Rule< F, Kernel >::operator()(), Aleph::CA::Totalistic_Rule< F >::operator()(), Aleph::CA::Lookup_Rule< NumStates, NumNeighbors >::operator()(), Aleph::CA::Composite_Rule< Rules >::operator()(), Aleph::CA::Probabilistic_Rule< F, Engine >::operator()(), Aleph::CA::Forest_Fire_Rule< Engine >::operator()(), Aleph::CA::SIR_Rule< Engine >::operator()(), Aleph::CA::Ising_Glauber_Rule< Engine >::operator()(), Aleph::CA::Ising_Metropolis_Rule< Engine >::operator()(), Aleph::CA::Schelling_Rule< Engine >::operator()(), Aleph::CA::Gray_Scott_Rule< Real, Kernel >::operator()(), Aleph::CA::FitzHugh_Nagumo_Rule< Real, Kernel >::operator()(), Aleph::HalfPlaneIntersection::operator()(), Aleph::DelaunayTriangulationBowyerWatson::operator()(), Aleph::DelaunayTriangulationRandomizedIncremental::operator()(), Aleph::VoronoiDiagramFromDelaunay::operator()(), Aleph::VoronoiDiagram::operator()(), Aleph::VoronoiDiagramFortune::operator()(), Aleph::ConstrainedDelaunayTriangulation::operator()(), Aleph::CA::Kernel2D< T, Rows, Cols >::operator()(), CaseInsensitiveStringEqual::operator()(), CaseInsensitiveStringHash::operator()(), Aleph::Negate_Compare< T, Compare >::operator()(), Aleph::Compare_Dup< T, Compare >::operator()(), Aleph::Inversed_Compare< T, Compare >::operator()(), Aleph::binder2nd< _Operation >::operator()(), Aleph::binder1st< _Operation >::operator()(), Aleph::unary_negate< _Predicate >::operator()(), Aleph::binary_negate< _Predicate >::operator()(), Convertir::operator()(), InitArc::operator()(), IntConvert::operator()(), GslRngDeleter::operator()(), Aleph::Init_P< GT >::operator()(), Aleph::Find_Eulerian_Path< GT, SN, SA >::operator()(), Aleph::Test_Single_Graph< GT, SN, SA >::operator()(), Aleph::Edge_Connectivity< GT, Max_Flow >::operator()(), Aleph::Has_Cycle< GT, SA >::operator()(), Aleph::Warshall_Compute_Transitive_Clausure< GT, SA >::operator()(), Aleph::Build_Grid< GT, Operation_On_Node, Operation_On_Arc >::operator()(), Aleph::Bellman_Ford_Negative_Cycle< GT, Distance, Ait, NAit, SA >::operator()(), Aleph::Bellman_Ford_Negative_Cycle< GT, Distance, Ait, NAit, SA >::operator()(), Aleph::Stoer_Wagner_Min_Cut< GT, Distance, SA >::operator()(), Aleph::Karger_Min_Cut< GT, SA >::operator()(), Aleph::Karger_Min_Cut< GT, SA >::operator()(), Aleph::Compute_Min_Cut< GT, Max_Flow, SA >::operator()(), Aleph::Find_Depth_First_Spanning_Tree< GT, SA >::operator()(), Aleph::Find_Breadth_First_Spanning_Tree< GT, SA >::operator()(), Aleph::Bellman_Ford_Negative_Cycle< GT, Distance, Ait, NAit, SA >::operator()(), Aleph::Bellman_Ford_Negative_Cycle< GT, Distance, Ait, NAit, SA >::operator()(), Test_Connectivity< GT, SA >::operator()(), Test_Connectivity< GT, SA >::operator()(), Aleph::Has_Cycle< GT, SA >::operator()(), Aleph::Generate_Graphviz< GT, Write_Node, Write_Arc, Shade_Node, Shade_Arc, Dashed_Node, Dashed_Arc, SA, SN >::operator()(), Aleph::Init_Arc< GT >::operator()(), Aleph::Default_Operation_On_Arc< GT >::operator()(), Aleph::Find_Depth_First_Spanning_Tree< GT, SA >::operator()(), Aleph::Find_Breadth_First_Spanning_Tree< GT, SA >::operator()(), Aleph::Graph_To_Tree_Node< GT, Key, Convert, SA >::operator()(), Aleph::Graph_To_Tree_Node< GT, Key, Convert, SA >::operator()(), Aleph::Default_Operation_On_Node< GT >::operator()(), Aleph::Bellman_Ford_Negative_Cycle< GT, Distance, Ait, NAit, SA >::operator()(), Aleph::Bellman_Ford_Negative_Cycle< GT, Distance, Ait, NAit, SA >::operator()(), Aleph::Bellman_Ford_Negative_Cycle< GT, Distance, Ait, NAit, SA >::operator()(), Aleph::Bellman_Ford_Negative_Cycle< GT, Distance, Ait, NAit, SA >::operator()(), Aleph::Copy_Graph< GT, SN, SA >::operator()(), Aleph::mdspan< T, Extents, LayoutPolicy, AccessorPolicy >::operator()(), Aleph::layout_right::mapping< Extents >::operator()(), Aleph::layout_left::mapping< Extents >::operator()(), Aleph::Matrix_Graph< GT, SA >::operator()(), Di_ij< M >::operator()(), TestDistFormatter< Mat >::operator()(), Aleph::Default_Entry_Formatter< Mat >::operator()(), Aleph::Find_Min_Path< Mat >::operator()(), Aleph::Find_Min_Path< Mat >::operator()(), Aleph::Max_Flow_Min_Cost_By_Network_Simplex< Net, Max_Flow_Algo >::operator()(), Aleph::Edmonds_Karp_Maximum_Flow< Net >::operator()(), Aleph::Max_Flow_Min_Cost_By_Cycle_Canceling< Net, Max_Flow_Algo >::operator()(), Aleph::Min_Cut< Net, Maxflow >::operator()(), Preorder_Nodes< Node >::operator()(), Inorder_Nodes< Node >::operator()(), Inorder_Diff< Node >::operator()(), Aleph::DynSetTree< Key, Tree, Compare >::Node_Op< Key_Op >::operator()(), Aleph::MonotonePolygonTriangulation::operator()(), RandTree< T >::operator()(), Aleph::Dft_Load_Arc< GT >::operator()(), Aleph::Dft_Load_Node< GT >::operator()(), Aleph::Rarc< GT >::operator()(), Aleph::Rnode< GT >::operator()(), Aleph::Dft_Load_Arc< GT >::operator()(), Aleph::Dft_Load_Node< GT >::operator()(), Aleph::Dft_Store_Arc< GT >::operator()(), Aleph::Dft_Store_Node< GT >::operator()(), Aleph::Dft_Store_Arc< GT >::operator()(), Aleph::Dft_Store_Node< GT >::operator()(), Aleph::Compare_Tnode< Tlink, Tnode, T, Compare >::operator()(), Aleph::Compare_Tnode< Tlink, Tnode, T, Compare >::operator()(), Write_Df::operator()(), Write_Low::operator()(), ProcessWriter::operator()(), Aleph::binder2nd< _Operation >::operator()(), Aleph::binder1st< _Operation >::operator()(), Aleph::Kruskal_Min_Spanning_Tree< GT, Distance, SA >::Paint_Filt< G, GT_SA >::operator()(), Aleph::Total_Cost< GT, Distance, SA >::operator()(), Aleph::__Out_Filt< GT >::operator()(), Aleph::__In_Filt< GT >::operator()(), Aleph::Painted_Min_Spanning_Tree< GT, Distance >::operator()(), Aleph::Dft_Arc_Cmp< GT >::operator()(), Graph_Traverse< GT, Itor, Q, Show_Arc >::operator()(), Graph_Traverse< GT, Itor, Q, Show_Arc >::operator()(), Graph_Traverse< GT, Itor, Q, Show_Arc >::operator()(), Aleph::Net_Filt< Net >::operator()(), Aleph::Find_Aumenting_Path< Net, Q >::operator()(), Aleph::Compare_Height< Net >::operator()(), Aleph::Find_Aumenting_Path< Net, Q >::operator()(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::operator*(), Aleph::Gen_Polynomial< Coefficient >::operator*(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::operator*(), Aleph::Gen_Polynomial< Coefficient >::operator*(), Aleph::Vector< T, NumType >::operator*(), Aleph::operator*(), Aleph::operator*(), Polinomio::operator*(), Polinomio::Termino::operator*(), Aleph::Matrix< Trow, Tcol, NumType >::operator*(), Aleph::operator*(), RingFileCache< T >::Pointer::operator+(), Aleph::Matrix< Trow, Tcol, NumType >::operator+(), Polinomio::operator+(), Aleph::Vector< T, NumType >::operator+(), Aleph::FlatMap< Key, T, Compare >::basic_iterator< IsConst >::operator+(), Aleph::RingBuffer< T >::basic_iterator< IsConst >::operator+(), Aleph::StlZipIterator< Containers >::operator++(), RingFileCache< T >::Pointer::operator++(), Aleph::DynSkipList< Key, Compare >::Iterator::operator++(), Aleph::FlatMap< Key, T, Compare >::basic_iterator< IsConst >::operator++(), Aleph::RingBuffer< T >::basic_iterator< IsConst >::operator++(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::operator+=(), Aleph::Gen_Polynomial< Coefficient >::operator+=(), Aleph::Matrix< Trow, Tcol, NumType >::operator+=(), Polinomio::operator+=(), Polinomio::Termino::operator+=(), Aleph::Vector< T, NumType >::operator+=(), Aleph::ExceptionBuilder< E >::operator,(), Aleph::Vector< T, NumType >::operator-(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::operator-(), Aleph::operator-(), Aleph::operator-(), RingFileCache< T >::Pointer::operator-(), Aleph::Matrix< Trow, Tcol, NumType >::operator-(), Aleph::Vector< T, NumType >::operator-(), Aleph::FlatMap< Key, T, Compare >::basic_iterator< IsConst >::operator-(), Aleph::RingBuffer< T >::basic_iterator< IsConst >::operator-(), RingFileCache< T >::Pointer::operator--(), Aleph::FlatMap< Key, T, Compare >::basic_iterator< IsConst >::operator--(), Aleph::RingBuffer< T >::basic_iterator< IsConst >::operator--(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::operator-=(), Aleph::Gen_Polynomial< Coefficient >::operator-=(), Aleph::Matrix< Trow, Tcol, NumType >::operator-=(), Aleph::Vector< T, NumType >::operator-=(), Aleph::DynArray< T >::Proxy::operator->(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::operator/(), Aleph::Gen_Polynomial< Coefficient >::operator/(), Aleph::Vector< T, NumType >::operator/(), Aleph::planarity_detail::Dart_Key::operator<(), Edge::operator<(), Aleph::planarity_detail::Edge_Key::operator<(), LtOnlyType::operator<(), Point::operator<(), Aleph::Point::operator<(), Aleph::Stoer_Wagner_Min_Cut< GT, Distance, SA >::PQEntry::operator<(), Task::operator<(), TestNodeData::operator<(), Aleph::VoronoiDiagramFortune::TriKey::operator<(), Aleph::VisvalingamWhyattSimplification::VWEntry::operator<(), operator<<(), Aleph::operator<<(), Aleph::operator<<(), Aleph::operator<<(), Aleph::operator<<(), Aleph::operator<<(), Aleph::operator<<(), Aleph::operator<<(), Aleph::operator<<(), Aleph::operator<<(), Aleph::operator<<(), Aleph::operator<<(), Aleph::operator<<(), Aleph::operator<<(), Aleph::operator<<(), Aleph::Ady_Mat< GT, __Entry_Type, SA >::operator=(), Aleph::AhArenaAllocator::operator=(), ArcFibonacciHeap< GT, Distance, Access_Heap_Node >::operator=(), ArcHeap< GT, Distance, Access_Heap_Node >::operator=(), ComplexValue::operator=(), Aleph::CancellationToken::ConditionVariableRegistration::operator=(), Aleph::BinTreeXt_Iterator< TreeType, Node, Key, Compare >::operator=(), Aleph::Bit_Mat_Graph< GT, SA >::operator=(), Aleph::BitArray::BitProxy::operator=(), Aleph::Bloom_Filter< T >::operator=(), ComplexValue::operator=(), Counted::operator=(), Aleph::Dlink::operator=(), Aleph::DynLhashTable< Key, Record, Cmp >::DLProxy::operator=(), Aleph::Dyn_Slist_Nc< T >::operator=(), Aleph::DynDlist< T >::operator=(), Aleph::DynHashTable< Key, HashTable, Cmp >::operator=(), Aleph::DynIntervalTree< T, Compare >::operator=(), Aleph::DynSetTree< Key, Tree, Compare >::operator=(), Aleph::DynSkipList< Key, Compare >::operator=(), Aleph::DynSlist< T >::operator=(), Aleph::Empty_Class::operator=(), Aleph::expected< T, E >::operator=(), Aleph::expected< void, E >::operator=(), Aleph::FixedQueue< T >::operator=(), Aleph::FixedStack< T >::operator=(), Foo::operator=(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::operator=(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::operator=(), Aleph::Interpreter_Value::operator=(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::Iterator::operator=(), Aleph::Matrix< Trow, Tcol, NumType >::operator=(), Aleph::MemArray< T >::operator=(), Aleph::Net_Cap_Graph< NodeT, ArcT >::operator=(), Aleph::Net_Cap_Node< Node_Info, F_Type >::operator=(), Aleph::Net_Cost_Graph< NodeT, ArcT >::operator=(), Aleph::Net_Graph< NodeT, ArcT >::operator=(), Aleph::ODhashTable< Key, Cmp >::operator=(), Aleph::OLhashTable< Key, Cmp >::operator=(), Aleph::PatriciaMap< UInt, T >::operator=(), Aleph::PatriciaSet< UInt >::operator=(), Aleph::Prefix_Tree::operator=(), Aleph::Prefix_Tree_Map< T >::operator=(), Aleph::Bit_Mat_Graph< GT, SA >::Proxy::operator=(), Aleph::Vector< T, NumType >::Proxy::operator=(), Aleph::DynArray< T >::Proxy::operator=(), Aleph::RadixTree< T, Char >::operator=(), Aleph::RingBuffer< T >::operator=(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::operator=(), Aleph::BitArray::BitProxy::operator=(), Aleph::Slink_Nc::operator=(), Aleph::SmallVector< T, N >::operator=(), Aleph::DynArray< T >::Proxy::operator=(), Aleph::Cookie_Guard< GT >::operator=(), Aleph::Cookie_Saver< GT >::operator=(), Counted::operator=(), Aleph::DynArray< T >::operator=(), Aleph::DynHashTable< Key, HashTable, Cmp >::operator=(), Aleph::DynSetTree< Key, Tree, Compare >::operator=(), Aleph::DynSkipList< Key, Compare >::operator=(), Aleph::DynSlist< T >::operator=(), Aleph::Euclidian_Digraph< __Euclidian_Node, __Euclidian_Arc >::operator=(), Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::operator=(), Aleph::expected< void, E >::operator=(), Aleph::expected< T, E >::operator=(), Aleph::Fibonacci_Heap< T, Compare >::operator=(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::operator=(), Aleph::Generator< T >::operator=(), Aleph::GenLhashTable< Key, BucketType, Cmp >::operator=(), Aleph::GenTdRbTree< NodeType, Key, Compare >::operator=(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::operator=(), Aleph::Init_Guard< CleanupFunc >::operator=(), Aleph::Interpreter_Value::operator=(), K2Tree< T >::operator=(), Aleph::Karger_Min_Cut< GT, SA >::operator=(), Aleph::Map_Matrix_Graph< GT, SA >::operator=(), Aleph::Matrix< Trow, Tcol, NumType >::operator=(), Aleph::Matrix_Graph< GT, SA >::operator=(), MoveOnly::operator=(), Aleph::Net_Cap_Graph< NodeT, ArcT >::operator=(), Aleph::Net_Graph< NodeT, ArcT >::operator=(), NonCopyable::operator=(), Aleph::ODhashTable< Key, Cmp >::operator=(), Aleph::OLhashTable< Key, Cmp >::operator=(), Aleph::PatriciaMap< UInt, T >::operator=(), Aleph::PatriciaSet< UInt >::operator=(), Aleph::Prefix_Tree::operator=(), Aleph::Prefix_Tree_Map< T >::operator=(), Aleph::RadixTree< T, Char >::operator=(), Aleph::RingBuffer< T >::operator=(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::operator=(), Aleph::SkipList< Key, Type >::operator=(), Static_Event_Table< Signature >::operator=(), Aleph::BinTreeXt_Iterator< TreeType, Node, Key, Compare >::operator==(), ComplexValue::operator==(), Coord::operator==(), Counted::operator==(), EqOnlyType::operator==(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::operator==(), Aleph::Gen_Polynomial< Coefficient >::operator==(), Aleph::Interval< T >::operator==(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::Iterator::operator==(), Aleph::Polygon::Iterator::operator==(), Aleph::Aho_Corasick::Match::operator==(), MixinVector< T >::operator==(), MoveOnly::operator==(), Aleph::CA::ca_hashlife_detail::Node_Key::operator==(), Nodo::operator==(), Aleph::Path< GT >::Path_Desc::operator==(), Person::operator==(), Point::operator==(), Aleph::RingBuffer< T >::operator==(), Aleph::Rope< Char, LeafSize >::operator==(), Aleph::Segment::operator==(), Aleph::Segment3D::operator==(), Aleph::SmallVector< T, N >::operator==(), Aleph::StlEnumerateIterator< Container >::operator==(), Aleph::StlZipIterator< Containers >::operator==(), Aleph::AssignLazyTag< T >::tag_type::operator==(), TestStruct::operator==(), Aleph::Triangle::operator==(), Aleph::UniZipIterator< Containers >::operator==(), Task::operator>(), Aleph::VisvalingamWhyattSimplification::VWEntry::operator>(), Aleph::DynSlist< T >::operator[](), Aleph::MemArray< T >::operator[](), Aleph::DynDlist< T >::operator[](), Aleph::CsvRow::operator[](), Aleph::BitArray::operator|=(), Aleph::Bloom_Filter< T >::operator|=(), Aleph::optimal_merge_knuth(), orden_ejecucion(), Aleph::detail::ordered_tree_read_key(), Aleph::detail::ordered_tree_snapshot_magic(), Aleph::detail::ordered_tree_validate_header(), Aleph::detail::ordered_tree_write_key(), Aleph::Alpha_Beta< Domain >::ordering_active(), org_chart(), Aleph::planarity_detail::orient2d(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::orient_dfs(), orientation_str(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::other_endpoint(), Aleph::Net_Graph< NodeT, ArcT >::out_arcs(), Aleph::out_arcs(), Aleph::Net_Graph< NodeT, ArcT >::out_nodes(), Aleph::out_nodes(), Aleph::out_pairs(), Aleph::Net_Cost_Graph< NodeT, ArcT >::out_pars(), Aleph::outer_product(), Aleph::ConvexPolygonOffset::outward(), Aleph::FFT< Real >::overlap_add_convolution(), Aleph::FFT< Real >::overlap_add_convolution_batch(), Aleph::FFT< Real >::overlap_add_frames(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::overlap_area(), Aleph::FFT< Real >::overlap_profile(), Aleph::FFT< Real >::overlap_profile_has_cola(), Aleph::FFT< Real >::overlap_profile_has_nola(), Aleph::FFT< Real >::overlap_save_convolution(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::overlap_search(), Aleph::Interval< T >::overlaps(), Aleph::FFT< Real >::OverlapSave::padded_chunk_copy(), Aleph::NTT< MOD, ROOT >::padded_copy(), Aleph::FFT< Real >::PartitionedConvolver::padded_partition(), Aleph::CA::ca_frame_stream_detail::padded_step(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::page_checksum(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::page_checksum(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::page_checksum_v3(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::page_checksum_v3(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::page_checksum_v4(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::page_checksum_v4(), Aleph::CA::Tile_Cache< State, TileSide >::page_in(), Aleph::Compute_Cut_Nodes< GT, SA >::paint_from_cut_node(), Aleph::Dial_Min_Paths< GT, Distance, Itor, SA >::paint_min_paths_tree(), Aleph::Zero_One_BFS< GT, Distance, Itor, SA >::paint_min_paths_tree(), Aleph::AStar_Min_Path< GT, Distance, Heuristic, Itor, SA, HeapT >::paint_min_paths_tree(), Aleph::Dijkstra_Min_Paths< GT, Distance, Itor, SA, HeapT >::paint_min_paths_tree(), Aleph::Kruskal_Min_Spanning_Tree< GT, Distance, SA >::paint_min_spanning_tree(), Aleph::Kruskal_Min_Spanning_Tree< GT, Distance, SA >::paint_min_spanning_tree(), Aleph::Prim_Min_Spanning_Tree< GT, Distance, SA >::paint_min_spanning_tree(), Aleph::AStar_Min_Path< GT, Distance, Heuristic, Itor, SA, HeapT >::paint_partial_min_paths_tree(), Aleph::Dijkstra_Min_Paths< GT, Distance, Itor, SA, HeapT >::paint_partial_min_paths_tree(), Aleph::AStar_Min_Path< GT, Distance, Heuristic, Itor, SA, HeapT >::paint_partial_path(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::paint_spanning_tree(), Aleph::Compute_Cut_Nodes< GT, SA >::paint_subgraph(), Aleph::paint_subgraphs(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::paint_tree(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::pair_is_zero_known(), Aleph::FFT< Real >::pair_poles_and_zeros(), Aleph::FFT< Real >::pair_poles_and_zeros(), Aleph::pair_ranks(), Aleph::pair_ranks(), Aleph::pair_ranks(), Aleph::pair_ranks(), Aleph::CA::ca_gif_detail::palette_index(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::parent(), Aleph::Compiler_Line_Frontend::parse(), Aleph::Compiler_MVP_Frontend::parse(), parse_arc(), parse_arc_definition(), parse_arc_text_definition(), Aleph::Compiler_Parser::parse_block_statement(), Aleph::Compiler_Parser::parse_break_statement(), Aleph::Compiler_Parser::parse_call_suffix(), Aleph::Interpreter_Runtime::parse_char_literal(), parse_connexion(), Aleph::Compiler_Parser::parse_continue_statement(), parse_curve_arc_definition(), parse_dashed_arc(), parse_dashed_arc_definition(), parse_dashed_curve_arc_definition(), parse_deway_number(), parse_ellipse(), Aleph::Compiler_Parser::parse_enum_declaration(), Aleph::Compiler_Parser::parse_expression(), parse_first_root_definition(), Aleph::Compiler_Parser::parse_function(), Aleph::Compiler_Line_Frontend::parse_function_line(), Aleph::Compiler_Parser::parse_function_type(), parse_graph_definition(), Aleph::Compiler_Parser::parse_grouping_expr(), Aleph::CA::Hashlife_Engine::parse_header_value(), parse_hradio(), parse_hradio_definition(), Aleph::Compiler_Line_Frontend::parse_identifier(), Aleph::Compiler_Parser::parse_if_statement(), Aleph::Compiler_Parser::parse_import_declaration(), Aleph::Compiler_Line_Frontend::parse_import_line(), Aleph::CA::ca_io_detail::parse_index_token(), Aleph::Compiler_Dataflow_Detail::parse_integer_constant(), Aleph::Interpreter_Runtime::parse_integer_literal(), Aleph::CA::ca_io_detail::parse_json_number(), Aleph::CA::ca_io_detail::parse_json_size_field(), parse_key_node_and_allocate(), Aleph::Compiler_Line_Frontend::parse_let_line(), Aleph::Compiler_Parser::parse_let_statement(), Aleph::Compiler_Parser::parse_module(), Aleph::Compiler_Parser::parse_named_type(), parse_node_definition(), parse_node_definition(), parse_node_text_definition(), Aleph::Compiler_Line_Frontend::parse_operand(), Aleph::Compiler_Parser::parse_parenthesized_type(), Aleph::Compiler_Parser::parse_primary(), parse_rectangle(), Aleph::Compiler_Driver::parse_registered_sources(), Aleph::Compiler_Parser::parse_return_statement(), parse_root_definition(), Aleph::CA::parse_rule(), Aleph::CA::Hashlife_Engine::parse_rule_field(), Aleph::CA::ca_io_detail::parse_scalar(), Aleph::Compiler_Parser_Stream::parse_separated_list(), parse_shadow(), parse_shadow_arc_definition(), parse_shadow_curve_arc_definition(), parse_shadow_node_definition(), Aleph::CA::ca_io_detail::parse_size_token(), Aleph::Compiler_Line_Frontend::parse_source_file(), Aleph::Compiler_Parser::parse_statement(), Aleph::Compiler_Parser::parse_statement_terminator(), Aleph::Interpreter_Runtime::parse_string_literal(), Aleph::Compiler_Parser::parse_struct_declaration(), parse_tag(), parse_tag_definition(), Aleph::Compiler_Parser::parse_type_alias_declaration(), Aleph::Compiler_Parser::parse_type_primary(), Aleph::Compiler_Parser::parse_unary(), parse_vradio(), parse_vradio_definition(), Aleph::Compiler_Parser::parse_while_statement(), parse_without_arc(), parse_without_node(), parse_without_node_definition(), parse_xoffset(), parse_yoffset(), parser_opt(), parser_opt(), parser_opt(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::partial(), Aleph::partial_sum(), Aleph::partial_sum(), Aleph::partition(), Aleph::QuickHull::partition(), Aleph::partition(), Aleph::FunctionalMixin< Derived, Type >::partition(), Aleph::FunctionalMixin< Derived, Type >::partition(), Aleph::partition(), Aleph::partition_op(), Aleph::partition_op(), Aleph::partition_op_impl(), Aleph::partition_three_way(), Aleph::partition_three_way_op(), Aleph::FFT< Real >::partitioned_convolution(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::path_apply(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::path_query(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::path_size(), Aleph::Gen_Link_Cut_Tree_WithEdges< VT, ET, EdgeMonoid, LazyTag >::path_size(), Aleph::Gen_Mo_On_Trees< GT, Policy >::path_solve(), Aleph::Gen_Mo_On_Tree_Node< T, Policy >::path_solve(), Aleph::Gen_Mo_On_Trees< GT, Policy >::path_solve(), Aleph::Gen_Mo_On_Tree_Node< T, Policy >::path_solve(), Aleph::FFT< Real >::pbatched_sosfilt(), Aleph::FFT< Real >::pbatched_stft(), Aleph::FFT< Real >::pbatched_stft(), Aleph::NTT< MOD, ROOT >::pbigint_multiply(), Aleph::FFT< Real >::OverlapAddBank::pconvolve(), Aleph::Compiler_Lexer::peek(), Aleph::peek_char(), Aleph::percentile(), Aleph::Topological_Sort< GT, Itor, SA >::perform(), Aleph::Q_Topological_Sort< GT, Itor, SA >::perform(), Aleph::Ellipse::perimeter(), Aleph::stl_comb_detail::permutations_impl(), Aleph::LineEq::perpendicular_through(), Aleph::FunctionalMixin< Derived, Type >::pfilter(), Aleph::FunctionalMixin< Derived, Type >::pfilter(), Aleph::FFT< Real >::LFilterBank::pfilter(), Aleph::FFT< Real >::SOSFilterBank::pfilter(), Aleph::FFT< Real >::pfiltfilt(), Aleph::FFT< Real >::STFTProcessor::pflush(), Aleph::FFT< Real >::OverlapAddBank::pflush(), Aleph::FFT< Real >::phase_delay(), Aleph::FFT< Real >::phase_delay(), Aleph::FFT< Real >::phase_delay(), Aleph::FFT< Real >::phase_delay(), Aleph::FFT< Real >::phase_delay(), Aleph::FFT< Real >::phase_delay(), Aleph::FFT< Real >::phase_delay(), Aleph::FFT< Real >::phase_delay(), Aleph::FFT< Real >::phase_delay_impl(), Aleph::FFT< Real >::phase_margin(), Aleph::FFT< Real >::phase_margin(), Aleph::FFT< Real >::phase_margin(), Aleph::FFT< Real >::phase_margin(), Aleph::FFT< Real >::phase_margin(), Aleph::FFT< Real >::phase_margin(), Aleph::FFT< Real >::phase_margin_impl(), Aleph::FFT< Real >::phase_margin_refined_impl(), Aleph::FFT< Real >::phase_spectrum(), Aleph::FFT< Real >::phase_spectrum(), Aleph::Random_Set< T >::pick(), Aleph::FFT< Real >::pinverse_transform(), Aleph::FFT< Real >::Plan::pinverse_transform(), Aleph::FFT< Real >::pinverse_transform(), Aleph::FFT< Real >::pinverse_transform2d(), Aleph::FFT< Real >::pinverse_transform3d(), Aleph::FFT< Real >::pinverse_transform_batch(), Aleph::FFT< Real >::Plan::pinverse_transform_batch(), Aleph::FFT< Real >::pinverse_transform_real(), Aleph::FFT< Real >::Plan::pinverse_transform_real(), Aleph::FFT< Real >::pinverse_transform_real(), Aleph::FFT< Real >::Plan::pinverse_transform_real_batch(), Aleph::FFT< Real >::pirfft(), Aleph::FFT< Real >::pirfft(), Aleph::FFT< Real >::Plan::pirfft_batch(), Aleph::FFT< Real >::pirfft_batch(), Aleph::FFT< Real >::pistft(), Aleph::FFT< Real >::pistft(), Aleph::FFT< Real >::pistft(), Aleph::FFT< Real >::pistft(), Aleph::FFT< Real >::pistft(), Aleph::FFT< Real >::pistft(), Aleph::Network_Simplex< Net >::pivot_tree(), Aleph::planar_dual_metadata(), Aleph::planar_geometric_drawing(), Aleph::planarity_test(), Aleph::pmaps(), Aleph::NTT< MOD, ROOT >::pmultiply(), Aleph::NTTExact::pmultiply(), Aleph::DelaunayTriangulationBowyerWatson::point_in_circumcircle(), Aleph::RegularTriangulationBowyerWatson::point_in_power_circle(), Aleph::DelaunayTriangulationRandomizedIncremental::point_in_tri(), Aleph::ShortestPathInPolygon::point_in_triangle(), Aleph::BooleanPolygonOperations::point_inside_ccw(), Aleph::SegmentSegmentIntersection::point_less_on_axis(), Aleph::SegmentSegmentIntersection::point_max_on_axis(), Aleph::SegmentSegmentIntersection::point_min_on_axis(), Aleph::Tikz_Plane::point_options(), Aleph::Gen_HLD< GT, T, Op, SA >::point_update(), Aleph::Gen_HLD< GT, T, Op, SA >::point_update_id(), Pointer_Table::pointer_matches_with_index(), Aleph::pointers_list(), Aleph::pointers_list(), Aleph::FFT< Real >::OverlapAdd::pointwise_multiply(), Aleph::FFT< Real >::OverlapAddBank::pointwise_multiply_batch(), Aleph::FFT< Real >::pole_zero_pairs_impl(), Aleph::FFT< Real >::poles(), Aleph::FFT< Real >::poles(), Aleph::FFT< Real >::poles(), Aleph::FFT< Real >::polish_roots_with_newton(), Aleph::pollard_rho(), Aleph::detail::pollard_rho_step(), Aleph::NTT< MOD, ROOT >::poly_add_series(), Aleph::NTT< MOD, ROOT >::poly_derivative(), Aleph::NTT< MOD, ROOT >::poly_divmod(), Aleph::NTT< MOD, ROOT >::poly_eval(), Aleph::NTT< MOD, ROOT >::poly_exp(), Aleph::NTT< MOD, ROOT >::poly_integral(), Aleph::NTT< MOD, ROOT >::poly_inverse(), Aleph::NTT< MOD, ROOT >::poly_log(), Aleph::NTT< MOD, ROOT >::poly_mod(), Aleph::NTT< MOD, ROOT >::poly_mul_trunc(), Aleph::NTT< MOD, ROOT >::poly_power(), Aleph::NTT< MOD, ROOT >::poly_scalar_mul_series(), Aleph::NTT< MOD, ROOT >::poly_sqrt(), Aleph::NTT< MOD, ROOT >::poly_sub_series(), polygon_area(), Aleph::polygon_from_vertex_indices(), Aleph::ConvexPolygonDistanceGJK::polygons_intersect_or_contain(), Aleph::FFT< Real >::polynomial_from_roots_complex(), Aleph::FFT< Real >::polynomial_multiply(), Aleph::FFT< Real >::polynomial_power(), Aleph::FFT< Real >::polynomial_root_lower_bound(), Aleph::FFT< Real >::polynomial_root_upper_bound(), Aleph::FFT< Real >::polynomial_roots_impl(), Aleph::DynArray< T >::pop(), Aleph::DynListStack< T >::pop(), Aleph::FixedStack< T >::pop(), Aleph::PersistentVector< T >::pop_back(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::pop_best_pair(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::pop_from_stack(), Aleph::FixedStack< T >::popn(), GenTdSplayTreeRk< NodeType, Key, Compare >::position(), Aleph::DynSetTree< Key, Tree, Compare >::position(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::position(), Aleph::HtdRbTreeRk< Key, Compare >::position(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::position(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::position(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::position(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::position(), Aleph::Source_Manager::position(), Aleph::Gen_Polynomial< Coefficient >::positive_divisors(), Aleph::Lengauer_Tarjan_Post_Dominators< GT, SA >::post_dominance_frontiers(), Aleph::Lengauer_Tarjan_Post_Dominators< GT, SA >::post_dominates(), Aleph::postorder_rec_helper(), Aleph::postOrderRec(), Aleph::FFT< Real >::poverlap_add_convolution(), Aleph::FFT< Real >::poverlap_add_convolution_batch(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::pow(), Aleph::Gen_Polynomial< Coefficient >::pow(), Aleph::NTT< MOD, ROOT >::pow_mod_constexpr(), Aleph::PowerDiagram::power_center(), Aleph::FFT< Real >::power_spectrum(), Aleph::FFT< Real >::power_spectrum(), powerful_array(), Aleph::FFT< Real >::ISTFTProcessor::pprocess_block(), Aleph::FFT< Real >::OverlapAddBank::pprocess_block(), Aleph::FFT< Real >::OverlapAdd::pprocess_block(), precompute_x_for_node(), Aleph::SweepLineSegmentIntersection::StatusTree::predecessor(), Aleph::MonotonePolygonTriangulation::EdgeStatusTree::predecessor_for_insert(), Aleph::SweepLineSegmentIntersection::StatusTree::predecessor_for_insert(), Aleph::Compiler_Typed_Semantic_Analyzer::predeclare_function(), Aleph::Compiler_IR_Lowering::Module_Builder::predeclare_function(), Aleph::Compiler_Typed_Semantic_Analyzer::predeclare_module_type_declarations(), LFit::predict(), Aleph::prefix(), Aleph::prefix(), Aleph::FFT< Real >::prefix_copy(), Aleph::NTT< MOD, ROOT >::prefix_copy(), Aleph::prefix_traverse(), Aleph::preflow_create_residual_net(), Aleph::Tree_Node< T >::preorder(), preorder(), Aleph::preorder_rec_helper(), Aleph::preorder_to_bst(), Aleph::GenBinHeap< NodeType, Key, Compare >::preorder_traverse(), Aleph::preOrderRec(), Aleph::Compiler_Driver::prepare_inputs(), Aleph::Array_Iterator< T >::prev(), Aleph::Dlink::Iterator::prev(), Aleph::Regular_Polygon::Vertex_Iterator::prev(), Aleph::Regular_Polygon::Segment_Iterator::prev(), Aleph::BinTreeXt_Iterator< TreeType, Node, Key, Compare >::prev(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::Iterator::prev(), Aleph::prev_value(), Aleph::Vertex::prev_vertex(), Aleph::CA::History_Cell< State, Depth >::previous(), Aleph::FFT< Real >::prewarp_band_edges(), Aleph::FFT< Real >::prewarp_frequency(), Aleph::FFT< Real >::prfft(), Aleph::FFT< Real >::Plan::prfft(), Aleph::FFT< Real >::prfft(), Aleph::FFT< Real >::prfft_batch(), Aleph::FFT< Real >::Plan::prfft_batch(), Aleph::NTTExact::prime_supports_product_size(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::primitive_part(), Aleph::Gen_Polynomial< Coefficient >::primitive_part(), Aleph::NTT< MOD, ROOT >::primitive_root_of_unity(), Aleph::GenLinearHashTable< Key, BucketType, Cmp >::print(), PercolationSystem::print(), Polinomio::print(), ComplexArray::print(), SimpleQueue::print(), SimpleArray::print(), print(), print(), Aleph::print(), print(), print(), print_aleatorio_and_reset_dynarray(), print_aleph(), print_arena_status(), Aleph::print_benchmark_results(), print_bits(), print_code(), print_coloring(), print_container(), print_cost_network(), print_degrees(), print_dewey_view(), Aleph::Network_Simplex< Net >::print_diagnostics(), print_dynarray(), print_dynlist(), print_ex(), print_flow_stats(), print_graph(), print_graph(), print_graph(), print_graph(), print_graph(), print_graph(), print_graph(), print_graph_stats(), print_grid_with_path(), print_header(), print_header(), print_key(), print_list(), print_list(), print_list(), print_list(), print_matching(), Aleph::Simplex< T >::print_matrix(), print_matrix(), print_mst(), print_nested(), Aleph::print_net_cost(), print_network(), print_network_stats(), print_operations_per_second(), print_pair(), print_pair(), print_pairs(), print_pairs(), print_parameters(), print_partition(), print_path(), print_path_detailed(), print_point(), print_polygon(), print_polygon(), print_prio(), Aleph::print_residual_net(), print_result(), print_results_table(), Aleph::Simplex< T >::print_sensitivity_analysis(), print_separator(), print_seq(), print_stats(), print_status(), print_stl(), print_stl_container(), print_subheader(), print_tag(), print_tex(), print_tree(), print_triangle(), print_usage(), print_vec(), Aleph::Cnode::print_words(), printList(), printPars(), Aleph::Negamax< Domain >::probe_transposition(), Aleph::Alpha_Beta< Domain >::probe_transposition(), Aleph::Branch_And_Bound< Domain, ObjectivePolicy >::process_best_first_candidate(), Aleph::FFT< Real >::ISTFTProcessor::process_block(), Aleph::FFT< Real >::OverlapAddBank::process_block(), Aleph::FFT< Real >::OverlapAdd::process_block(), Aleph::FFT< Real >::OverlapSave::process_block(), Aleph::FFT< Real >::PartitionedConvolver::process_block(), Aleph::FFT< Real >::OverlapAddBank::process_chunk_batch_impl(), Aleph::FFT< Real >::OverlapAdd::process_chunk_impl(), Aleph::FFT< Real >::OverlapSave::process_chunk_impl(), process_file(), FloydIntGraphTest::process_id(), NetUtilsTest::process_id(), ParseUtilsTest::process_id(), Aleph::detail::process_is_alive(), process_node(), Aleph::FFT< Real >::PartitionedConvolver::process_partition_impl(), Aleph::CA::Parallel_Synchronous_Engine< Lattice, Rule, Neighborhood, Order >::process_slab(), process_tag_node(), process_text_arc(), process_text_arc(), Aleph::CA::Dense_Cell_Storage< T, N >::product(), Aleph::Segment::project(), Aleph::FFT< Real >::project_real_batch_output(), Aleph::FFT< Real >::project_real_output(), Aleph::FFT< Real >::project_to_plan_batch_spectra(), Aleph::FFT< Real >::project_to_plan_spectrum(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::promote(), Aleph::proper_intersection(), Aleph::Gen_Polynomial< Coefficient >::pseudo_divmod(), Aleph::FFT< Real >::pspectrum(), Aleph::FFT< Real >::pspectrum(), Aleph::FFT< Real >::pspectrum(), Aleph::ptr_fun(), Aleph::ptr_fun(), Aleph::FFT< Real >::ptransform(), Aleph::FFT< Real >::ptransform(), Aleph::FFT< Real >::ptransform_axes(), Aleph::FFT< Real >::ptransform_axis(), Aleph::FFT< Real >::ptransform_batch(), Aleph::FFT< Real >::Plan::ptransform_batch(), Aleph::NTT< MOD, ROOT >::ptransform_batch(), Aleph::NTT< MOD, ROOT >::Plan::ptransform_batch(), Aleph::FFT< Real >::ptransform_padded(), Aleph::FFT< Real >::ptransform_padded(), Aleph::FFT< Real >::ptransform_padded(), Aleph::FFT< Real >::ptransformed(), Aleph::FFT< Real >::Plan::ptransformed(), Aleph::NTT< MOD, ROOT >::ptransformed(), Aleph::NTT< MOD, ROOT >::Plan::ptransformed(), Aleph::FFT< Real >::ptransformed(), Aleph::FFT< Real >::ptransformed2d(), Aleph::FFT< Real >::ptransformed2d_batch(), Aleph::FFT< Real >::ptransformed3d(), Aleph::FFT< Real >::ptransformed_axes(), Aleph::FFT< Real >::ptransformed_batch(), Aleph::FFT< Real >::Plan::ptransformed_batch(), Aleph::NTT< MOD, ROOT >::Plan::ptransformed_batch(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::pull(), Aleph::CA::History_Cell< State, Depth >::push(), Aleph::CA::Stationary_Detector::push(), Aleph::DynListStack< T >::push(), Aleph::FixedStack< T >::push(), Aleph::MemArray< T >::push(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::push(), Aleph::DynListStack< T >::push(), Aleph::FixedStack< T >::push(), Aleph::MemArray< T >::push(), Aleph::PersistentVector< T >::push_back(), Aleph::Segment_Tree_Beats< T >::push_chmax_to_child(), Aleph::Segment_Tree_Beats< T >::push_chmin_to_child(), Aleph::Segment_Tree_Beats< T >::push_down(), Aleph::Gen_Lazy_Segment_Tree< Policy >::push_down(), Aleph::Compiler_Bytecode_VM::push_frame(), Aleph::FixedStack< T >::pushn(), Eepic_Plane::put(), Aleph::Tikz_Plane::put(), Aleph::Tikz_Plane::put(), Aleph::DynListQueue< T >::put(), RingFileCache< T >::put(), Aleph::MemArray< T >::put(), Aleph::FixedQueue< T >::put(), Aleph::DynListQueue< T >::put(), QueueTheadsPool< T >::put(), Aleph::MemArray< T >::put(), Aleph::FixedQueue< T >::put(), Aleph::put_aabb_tree_result(), Aleph::put_alpha_shape_result(), ArcHeap< GT, Distance, Access_Heap_Node >::put_arc(), ArcFibonacciHeap< GT, Distance, Access_Heap_Node >::put_arc(), Aleph::put_cdt_result(), Aleph::put_char_in_buffer(), Aleph::put_closest_pair_result(), Aleph::put_convex_decomposition_result(), Aleph::Tikz_Plane::put_coordinate_grid(), Aleph::Tikz_Scene::put_coordinate_grid(), Aleph::put_delaunay_result(), Aleph::Simplex< T >::put_eq_restriction(), Aleph::Tikz_Scene::put_funnel_trace_step(), Aleph::put_funnel_trace_step(), Aleph::Simplex< T >::put_ge_restriction(), Aleph::put_half_plane_intersection_result(), Aleph::put_in_plane(), Aleph::put_in_plane(), Aleph::put_kdtree_partitions_result(), Aleph::put_line_sweep_result(), Aleph::put_mec_result(), Aleph::put_minkowski_sum_result(), Aleph::put_monotone_triangulation_result(), Aleph::Simplex< T >::put_objetive_function(), Aleph::Simplex< T >::put_objetive_function(), Aleph::put_offset_result(), Aleph::RingBuffer< T >::put_overwrite(), Aleph::RingBuffer< T >::put_overwrite(), Aleph::put_path(), Aleph::put_path(), Aleph::put_point_label_in_plane(), Aleph::put_point_labels(), Aleph::put_point_labels(), Aleph::put_points(), Aleph::put_points(), Aleph::put_polygons(), Aleph::put_portals(), Aleph::put_power_diagram_result(), Aleph::put_range_tree_result(), Aleph::put_regular_triangulation_result(), Aleph::Simplex< T >::put_restriction(), Aleph::Simplex< T >::put_restriction(), Aleph::Simplex< T >::put_restriction_coef(), Aleph::put_rotating_calipers_result(), Aleph::put_rtree_result(), Aleph::put_segment_arrangement_result(), Aleph::put_simplification_result(), Aleph::put_smoothing_result(), Aleph::put_trapezoidal_map_result(), Aleph::put_tree_keys_in_array(), Aleph::put_visibility_polygon_result(), Aleph::put_voronoi_result(), Aleph::MemArray< T >::putn(), Aleph::FixedQueue< T >::putn(), Aleph::ArrayQueue< T >::putn(), Aleph::BezierCurve::quadratic(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::quadratic_split(), Aleph::quartiles(), Aleph::RangeTree2D::query(), Aleph::AABBTree::query(), Aleph::Convex_Hull_Trick< T >::query(), Aleph::Li_Chao_Tree< T >::query(), Aleph::Li_Chao_Tree< T >::query_impl(), Aleph::AABBTree::query_impl(), Aleph::Gen_Segment_Tree< T, Op >::query_impl(), Aleph::Gen_Lazy_Segment_Tree< Policy >::query_impl(), Aleph::Segment_Tree_Beats< T >::query_max_impl(), Aleph::Segment_Tree_Beats< T >::query_min_impl(), Aleph::Gen_HLD_Path_Query< GT, T, Op, SA >::query_path_id(), Aleph::AABBTree::query_point(), Aleph::AABBTree::query_point_impl(), Aleph::RangeTree2D::query_range(), Aleph::Segment_Tree_Beats< T >::query_sum_impl(), Aleph::ThreadPoolStats::queue_utilization(), Aleph::QuickHull::quick_hull(), Aleph::quicksort(), Aleph::quicksort(), Aleph::quicksort(), Aleph::quicksort(), Aleph::quicksort(), Aleph::quicksort(), Aleph::quicksort_insertion(), Aleph::quicksort_no_tail(), Aleph::quicksort_op(), Aleph::quicksort_rec(), Aleph::quicksort_rec(), Aleph::quicksort_rec_min(), Aleph::CA::ca_dot_detail::quote(), Aleph::CA::ca_dot_detail::quote_id_if_needed(), Aleph::rabin_karp_search(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::radical_member(), Aleph::RotatedEllipse::radius_value(), Aleph::sort_utils_detail::radix_key(), Aleph::sort_utils_detail::radix_sort_impl(), Aleph::sort_utils_detail::radix_sort_impl(), Aleph::sort_utils_detail::radix_sort_impl(), Aleph::sort_utils_detail::radix_sort_impl(), rainforest_biodiversity(), TenVectors::rand_vec(), DataGenerator::random(), random(), RandTree< T >::random(), random_ascii_token(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::random_insert(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::random_insert_dup(), random_int(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::random_join(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::random_join(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::random_join_exclusive(), Aleph::DynSkipList< Key, Compare >::random_level(), Aleph::random_preflow_maximum_flow(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::random_remove(), Aleph::random_search(), Aleph::random_search(), Aleph::random_search(), Aleph::random_search(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::random_search_or_insert(), Aleph::random_select(), Aleph::random_select(), Aleph::random_select(), Aleph::random_select(), Aleph::random_select(), Aleph::random_select(), random_string(), random_tree(), random_tree(), randomLong(), K2Tree< T >::range(), Aleph::range(), Aleph::range(), K2Tree< T >::range(), range_methods_throw_domain_error_test(), Aleph::range_to_DynList(), Aleph::detail::ranges_all_of(), Aleph::detail::ranges_any_of(), Aleph::detail::ranges_count_if(), Aleph::detail::ranges_fold_left(), Aleph::extents< IndexType, Exts >::rank_dynamic(), Aleph::rank_graphviz(), Aleph::ranks(), Aleph::ranks(), Aleph::ranks(), Aleph::ranks(), Aleph::Q_Topological_Sort< GT, Itor, SA >::ranks(), Aleph::To_Graphviz< GT, Node_Attr, Arc_Attr, SN, SA >::ranks(), Aleph::VisibilityPolygon::ray_edge_hit(), Aleph::ray_endpoint(), Aleph::VisibilityPolygon::ray_param(), Aleph::Xml_Graph< GT, Node_Reader, Arc_Reader, Node_Writer, Arc_Writer >::read(), RingFileCache< T >::read(), RingFileCache< T >::read_absolute(), RingFileCache< T >::read_all(), read_and_encode(), Aleph::Byte::read_bit(), Aleph::Compiler_Bytecode_VM::read_callee_and_arguments(), Aleph::read_char_from_stream(), RingFileCache< T >::read_entry(), RingFileCache< T >::read_entry(), Aleph::Compiler_Generic_Driver::read_file_text(), RingFileCache< T >::read_first(), RingFileCache< T >::read_from(), RingFileCache< T >::read_from(), Aleph::Compiler_Bytecode_VM::read_global(), Aleph::Xml_Graph< GT, Node_Reader, Arc_Reader, Node_Writer, Arc_Writer >::read_graph(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::read_image(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::read_image(), Aleph::Huffman_Encoder_Engine::read_input(), Aleph::Huffman_Encoder_Engine::read_input(), read_input_and_build_graph(), read_input_and_build_tree(), Aleph::CA::read_json_snapshot(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::read_key(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::read_key(), Aleph::CA::ca_checkpoint_detail::read_le(), Aleph::CA::read_life_105(), Aleph::CA::read_life_106(), Aleph::Compiler_Bytecode_VM::read_local(), Aleph::matgraph_detail::read_matrix(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::read_native_key(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::read_native_key(), Aleph::CA::Reproductions::read_native_png(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::read_page_from_stream(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::read_page_from_stream(), read_parameters(), RingFileCache< T >::read_pars(), Aleph::CA::read_plaintext(), Aleph::CA::read_plaintext_string(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::read_pod(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::read_pod(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::read_portable_key(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::read_portable_key(), Aleph::Compiler_Bytecode_VM::read_register(), Aleph::CA::read_rle(), Aleph::CA::read_rle_string(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::read_storage_page_if_current(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::read_storage_page_if_current(), Aleph::CA::Tile_Cache< State, TileSide >::read_tile_from_disk(), Aleph::FFT< Real >::real_polynomial_from_roots(), Aleph::FFT< Real >::real_projection_tolerance(), Aleph::FixedQueue< T >::rear(), Aleph::FixedQueue< T >::rear_item(), reassign_key(), Aleph::Karger_Min_Cut< GT, SA >::rebuild_arc_index(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::rebuild_groebner_pair_state(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::rebuild_separators(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::rebuild_separators(), Aleph::FFT< Real >::recommended_cache_tile_size(), Aleph::NTTExact::reconstruct_coefficient(), Aleph::NTTExact::reconstruct_product(), Aleph::History_Heuristic_Table< Key, HashMapTable, Cmp >::record(), Aleph::Compiler_Generic_Driver::record_import_order_artifact(), Aleph::Compiler_Generic_Driver::record_module_bindings_artifact(), Aleph::Compiler_Generic_Driver::record_module_linkage_artifact(), Aleph::Compiler_Generic_Driver::record_module_metadata_artifact(), Aleph::Compiler_Generic_Driver::record_module_name_table_artifact(), Aleph::Compiler_Generic_Driver::record_module_semantic_environment_artifact(), Aleph::Compiler_Semantic_Analyzer::record_resolution(), Aleph::DynLhashTable< Key, Record, Cmp >::record_to_bucket(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::recover_from_wal(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::recover_from_wal(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::recover_if_needed(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::recover_if_needed(), Aleph::ClosestPairDivideAndConquer::recurse(), Aleph::BoundedChannel< T >::recv(), Aleph::BoundedChannel< T >::recv(), Aleph::BoundedChannel< T >::recv(), Aleph::BoundedChannel< T >::recv(), Aleph::Gen_Polynomial< Coefficient >::reduce_coeffs_mod(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::reduce_modulo(), Aleph::reduced_cost(), Aleph::Simplex< T >::reduced_cost(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::reduced_groebner_basis(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::redundant_pair_by_chain_criterion(), Aleph::RevisedSimplex< T >::refactorize(), reference_split_string(), Aleph::FFT< Real >::refine_scalar_crossing(), Aleph::CA::ca_ghost_detail::reflect_index(), Aleph::CA::ca_lattice_detail::reflect_into_range(), Aleph::FFT< Real >::reflect_pad_signal(), Aleph::CA::Ghost_Lattice< Storage, Boundary, Halo >::refresh_halo(), Event_Table< Signature >::register_event(), Event_Table< void *(void *)>::register_event(), Event_Table< Signature >::register_event(), Event_Table< void *(void *)>::register_event(), Aleph::detail::Pid_File_Lock::register_path(), OhashCommon< HashTbl, Key >::rehash(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::reinsert_farthest(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::relax_arcs(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::relax_arcs(), Aleph::Cnode::Detached_Subtree_Guard::release(), Aleph::Prefix_Tree_Map< T >::Node::Detached_Subtree_Guard::release(), Aleph::detail::Pid_File_Lock::release(), Aleph::SmallVector< T, N >::release(), Aleph::DynArray< T >::release_all_segments_and_blocks(), Aleph::DynArray< T >::release_block(), Aleph::DynArray< T >::release_blocks_and_segment(), Aleph::DynArray< T >::release_dir(), Aleph::Zero_One_BFS< GT, Distance, Itor, SA >::release_owned_node_infos(), Aleph::Zero_One_BFS< GT, Distance, Itor, SA >::release_owned_painted_infos(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::release_page(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::release_page(), Aleph::DynArray< T >::release_segment(), Aleph::SmallVector< T, N >::relocate(), Aleph::remaining_flow(), Aleph::DelaunayTriangulationRandomizedIncremental::remap_adj(), Aleph::Compiler_Typed_Semantic_Analyzer::remember_function_annotation_type_variables(), Aleph::FFT< Real >::remez(), Aleph::FFT< Real >::remez(), Aleph::FFT< Real >::remez_impl(), Aleph::DynList< T >::remove(), Aleph::Range_Mode_Policy< T >::remove(), Aleph::DynSlist< T >::remove(), Aleph::DynIntervalTree< T, Compare >::remove(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::remove(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::remove(), Aleph::DynHashTable< Key, HashTable, Cmp >::remove(), Aleph::DynMapHashTable< Key, Data, HashTable, Cmp >::remove(), Aleph::DynSkipList< Key, Compare >::remove(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::remove(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::remove(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::remove(), Aleph::ODhashTable< Key, Cmp >::remove(), Aleph::OLhashTable< Key, Cmp >::remove(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::remove(), GenTdSplayTreeRk< NodeType, Key, Compare >::remove(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::remove(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::remove(), Aleph::GenBinTree< NodeType, Key, Compare >::remove(), Aleph::HtdRbTree< Key, Compare >::remove(), Aleph::HtdRbTreeRk< Key, Compare >::remove(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::remove(), Aleph::Gen_Rb_Tree< NodeType, Key, Compare >::remove(), GenTdSplayTree< NodeType, Key, Compare >::remove(), Aleph::GenTdRbTree< NodeType, Key, Compare >::remove(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::remove(), Aleph::Gen_Treap< NodeType, Key, Compare >::remove(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::remove(), Aleph::SkipList< Key, Type >::remove(), QuadTree::remove(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::remove(), Aleph::Compact_Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::remove(), Aleph::Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::remove(), Aleph::Compact_Quotient_Filter< T >::remove(), Aleph::Quotient_Filter< T >::remove(), Aleph::DynList< T >::remove(), Aleph::Compact_Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::Bucket::remove(), Aleph::Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::Bucket::remove(), Aleph::remove(), Aleph::Karger_Min_Cut< GT, SA >::ArcIndex::remove(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::remove(), Aleph::BinTree_Operation< Node, Cmp >::remove(), Aleph::Gen_Treap< NodeType, Key, Compare >::remove(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::remove(), Aleph::DynBinHeap< T, Compare >::remove(), Aleph::ArrayHeap< T, Compare >::remove(), Aleph::DynArray_Set< T, Equal >::remove_all(), Aleph::Dlink::remove_all_and_delete(), Aleph::HTList::remove_all_and_delete(), Aleph::GenBinHeap< NodeType, Key, Compare >::remove_all_and_delete(), Aleph::List_Graph< _Graph_Node, _Graph_Arc >::remove_arc(), Aleph::Graph_Anode< Node_Info >::remove_arc(), Aleph::Graph_Anode< Node_Info >::remove_arc_ne(), Aleph::FlatMap< Key, T, Compare >::remove_at(), Aleph::FlatSet< Key, Compare >::remove_at(), Aleph::ODhashTable< Key, Cmp >::remove_bucket(), Aleph::GenLinearHashTable< Key, BucketType, Cmp >::remove_bucket(), Aleph::DynMapHashTable< Key, Data, HashTable, Cmp >::remove_by_data(), Aleph::remove_by_key_xt(), Aleph::remove_copy_if(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::remove_dummy_node(), Aleph::Gen_Link_Cut_Tree_WithEdges< VT, ET, EdgeMonoid, LazyTag >::remove_edge_at(), Aleph::detail::remove_file_if_exists(), Aleph::Dyn_Slist_Nc< T >::remove_first(), Aleph::MemArray< T >::remove_first(), Aleph::DynDlist< T >::remove_first_ne(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::remove_from(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::remove_from(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::remove_from(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::remove_from(), Aleph::remove_from_active_queue(), Aleph::remove_from_bst(), Aleph::remove_from_container(), Aleph::HTList::remove_head_ne(), Aleph::remove_if(), Aleph::DynMapTree< Key, Data, Tree, Compare >::remove_key(), Aleph::SmallVector< T, N >::remove_last(), Aleph::GenBinHeap< NodeType, Key, Compare >::remove_last(), Aleph::DynDlist< T >::remove_last_ne(), Aleph::DynList< T >::remove_ne(), Aleph::DynList< T >::remove_ne(), Aleph::blossom_weighted_detail::mwmatching::impl::Problem_Data< WeightType >::remove_negative_weight_edges(), Aleph::Slink::remove_next(), Aleph::Slink_Nc::remove_next(), Aleph::Dlink::remove_next(), Aleph::Slinknc::remove_next(), Aleph::GraphCopyWithMapping< GT, Tree >::remove_node(), Aleph::List_Graph< _Graph_Node, _Graph_Arc >::remove_node(), Aleph::Array_Graph< __Graph_Node, __Graph_Arc >::remove_node(), Aleph::List_SGraph< __Graph_Node, __Graph_Arc >::remove_node(), Pointer_Table::remove_pointer(), Aleph::DynSetTree< Key, Tree, Compare >::remove_pos(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::remove_pos(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::remove_pos(), Aleph::Dlink::remove_prev(), Aleph::remove_spaces(), Aleph::remove_symbols(), Aleph::Polygon::remove_vertex(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::remove_zero_and_duplicates(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::remove_zeros(), Aleph::HtdRbTree< Key, Compare >::removeAndFixBlackCondition(), Aleph::HtdRbTreeRk< Key, Compare >::removeAndFixBlackCondition(), Aleph::GenTdRbTree< NodeType, Key, Compare >::removeAndRendLeafRed(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::removeAndRendLeafRed(), Aleph::detail::rename_file_atomic(), Aleph::Compiler_SSA_Detail::rename_recursive(), Aleph::CA::render_hex_lattice_tikz(), Aleph::CA::render_hex_lattice_tikz(), Aleph::Diagnostic_Engine::render_label_snippet(), Aleph::Diagnostic_Engine::render_plain(), Aleph::Compiler_Driver_Detail::render_run_result(), Aleph::Diagnostic_Engine::render_secondary_labels(), Aleph::CA::render_triangular_lattice_tikz(), Aleph::CA::render_triangular_lattice_tikz(), Aleph::hld_detail::HLD_Tree_Data< GT, SA >::reorder_adjacency_heavy_first(), Aleph::rep(), Aleph::rep(), Aleph::repeated(), Aleph::repeated_with_index(), Aleph::replace(), Aleph::Naive_Suffix_Tree::replace_child(), Aleph::replace_copy(), Aleph::replace_copy_if(), Aleph::replace_if(), Aleph::TrapezoidalMapPointLocation::replace_leaf(), Aleph::GenBinHeap< NodeType, Key, Compare >::replace_node(), Aleph::Compiler_Bytecode_VM::require_bool(), Aleph::FFT< Real >::STFTProcessor::require_configured(), Aleph::FFT< Real >::ISTFTProcessor::require_configured(), Aleph::FFT< Real >::LFilter::require_configured(), Aleph::FFT< Real >::SOSFilter::require_configured(), Aleph::CA::ca_continuous_detail::require_domain(), Aleph::CA::ca_continuous_detail::require_finite(), Aleph::Compiler_Bytecode_VM::require_integer(), Aleph::CA::ca_continuous_detail::require_positive_dt(), Aleph::CA::ca_io_detail::require_rank2(), Aleph::CA::ca_tikz_detail::require_rank2_rect(), Aleph::Compiler_Typed_Semantic_Analyzer::require_unify(), Aleph::layout_right::mapping< Extents >::required_span_size(), Aleph::layout_left::mapping< Extents >::required_span_size(), Aleph::Tikz_Plane::required_tikz_libraries(), Aleph::FFT< Real >::resample_poly(), Aleph::FFT< Real >::resample_poly(), TimeoutQueue::reschedule_event(), Aleph::Karger_Min_Cut< GT, SA >::reseed(), Aleph::Testing::RandomNetworkGenerator< Net >::reseed(), Aleph::MemArray< T >::reserve(), Aleph::DynArray< T >::reserve(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::reserved_bytes_for_version(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::reserved_bytes_for_version(), Aleph::reservoir_sample(), Aleph::FFT< Real >::LFilter::reset(), Aleph::FFT< Real >::SOSFilter::reset(), Aleph::Slink_Nc::reset(), Aleph::Compiler_Lexer::reset(), Aleph::Slink_Nc::Iterator::reset(), Aleph::Slink_Nc::Iterator::reset_first(), Aleph::Dlink::Iterator::reset_first(), OhashCommon< HashTbl, Key >::Iterator::reset_first(), Aleph::BitArray::Iterator::reset_last(), Aleph::Dlink::Iterator::reset_last(), OhashCommon< HashTbl, Key >::Iterator::reset_last(), Aleph::FFT< Real >::reshape_matrix_row_major(), Aleph::FFT< Real >::reshape_tensor3_row_major(), Aleph::residual_to_net(), Aleph::GenLhashTable< Key, BucketType, Cmp >::resize(), RingFileCache< T >::resize(), OhashCommon< HashTbl, Key >::resize(), Aleph::ThreadPool::resize(), Aleph::DynArray< T >::resize_dir(), Aleph::CA::Tile_Cache< State, TileSide >::resolve(), Aleph::Compiler_Typed_Semantic_Analyzer::resolve_alias_binding(), Aleph::Compiler_Typed_Semantic_Analyzer::resolve_builtin_type_name(), Aleph::parallel_detail::resolve_chunk_size(), Aleph::Compiler_Driver::resolve_import_order(), Aleph::Compiler_Line_Frontend::resolve_import_order(), Aleph::Compiler_MVP_Frontend::resolve_import_order(), Aleph::FFT< Real >::resolve_irfft_signal_size(), Aleph::Compiler_Typed_Semantic_Analyzer::resolve_module_type_declaration(), Aleph::CA::Bench::resolve_repeats(), Aleph::Compiler_Typed_Semantic_Analyzer::resolve_type_annotation(), Aleph::CA::Ghost_Lattice< Storage, Boundary, Halo >::resolve_via_policy(), Aleph::Compiler_Module_Resolver_Detail::resolve_visit(), Aleph::Compiler_Semantic_Analyzer::resolved_symbol(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::restore_avl(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::restore_avl(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::restore_avl_after_deletion(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::restore_avl_after_deletion(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::restore_avl_after_insertion(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::restore_avl_after_insertion(), Aleph::Cookie_Saver< GT >::restore_now(), Aleph::restore_position(), Aleph::HtdRbTree< Key, Compare >::restoreRedCondition(), Aleph::HtdRbTreeRk< Key, Compare >::restoreRedCondition(), Aleph::GenTdRbTree< NodeType, Key, Compare >::restoreRedCondition(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::restoreRedCondition(), QueueTheadsPool< T >::resume(), Aleph::FunctionalMixin< Derived, Type >::rev(), Aleph::DynList< T >::reverse(), Aleph::Array< T >::reverse(), Aleph::DynDlist< T >::reverse(), Aleph::HTList::reverse(), Aleph::reverse(), Aleph::reverse(), Aleph::BooleanPolygonOperations::reverse_array(), Aleph::FFT< Real >::reverse_bessel_polynomial(), Aleph::FFT< Real >::reverse_copy(), Aleph::reverse_copy(), Aleph::Dlink::reverse_list(), Aleph::NTT< MOD, ROOT >::reverse_poly(), Aleph::Johnson< GT, Distance, Ait, NAit, SA >::reweight_arcs(), Aleph::FFT< Real >::rfft(), Aleph::FFT< Real >::Plan::rfft(), Aleph::FFT< Real >::rfft(), Aleph::FFT< Real >::rfft_batch(), Aleph::FFT< Real >::Plan::rfft_batch(), Aleph::CA::ca_html_detail::rgb_hex(), Aleph::CA::ca_svg_detail::rgb_hex(), Aleph::Simplex< T >::rhs_sensitivity(), Aleph::BitArray::right_shift(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::rightmost_leaf(), root_analysis(), Aleph::FFT< Real >::Plan::root_for_length(), Aleph::FFT< Real >::root_groups_impl(), roots_and_interpolation(), Aleph::FFT< Real >::roots_pass_residual_check(), Aleph::Segment::rotate(), Aleph::Point::rotate(), Aleph::rotate(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::rotate(), Aleph::rotate_copy(), Aleph::detail::PersistentTreapNodeOps< Node, Key, Compare >::rotate_left(), Aleph::rotate_left(), Aleph::detail::PersistentTreapNodeOps< Node, Key, Compare >::rotate_right(), Aleph::rotate_right(), Aleph::rotate_to_left(), Aleph::rotate_to_left(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::rotate_to_left_it(), Aleph::HtdRbTreeRk< Key, Compare >::rotate_to_left_rk(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::rotate_to_left_rk(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::rotate_to_left_rk(), Aleph::rotate_to_left_xt(), Aleph::rotate_to_right(), Aleph::rotate_to_right(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::rotate_to_right_it(), Aleph::HtdRbTreeRk< Key, Compare >::rotate_to_right_rk(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::rotate_to_right_rk(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::rotate_to_right_rk(), Aleph::rotate_to_right_xt(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::rotateLeft(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::rotateLeft(), Aleph::HtdRbTree< Key, Compare >::rotateNephewAndColor(), Aleph::HtdRbTreeRk< Key, Compare >::rotateNephewAndColor(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::rotateRight(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::rotateRight(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::rotation_type(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::rotation_type(), Aleph::FFT< Real >::row_major_layout(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::rstar_choose_overlap(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::rstar_split(), Aleph::rtrim(), Aleph::Compiler_C_Backend::Emitter::run(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::run(), Aleph::Tikz_Scene::run(), Aleph::Tikz_Scene::run(), AHDispatcher< Key, Operation >::run(), AhHashDispatcher< Key, Operation >::run(), Aleph::Network_Simplex< Net >::run(), Aleph::CA::Hashlife_Engine::run(), run_benchmarks(), Aleph::Zero_One_BFS< GT, Distance, Itor, SA >::run_bfs(), Aleph::Dial_Min_Paths< GT, Distance, Itor, SA >::run_dial(), run_engine_equivalence(), QueueTheadsPool< T >::run_event(), run_experiment(), run_full_benchmark(), Aleph::CA::Reproductions::run_gray_scott(), Aleph::adversarial_search_detail::run_iterative_deepening(), run_kruskal(), run_legacy_example(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::run_lr_planarity_test(), run_modern_example(), run_performance_comparison(), run_prim(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::run_stage(), Aleph::Compiler_Bytecode_VM::run_top_level(), run_tree(), Aleph::Compiler_Driver::run_typed_semantics(), Aleph::Testing::run_workers(), Aleph::Interpreter_Runtime::runtime_error(), Aleph::Rvector(), Aleph::Rvector(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::s_poly(), Aleph::safe_atof(), Aleph::safe_atol(), Aleph::stl_detail::safe_size(), Aleph::k_shortest_paths_detail::same_path_sequence(), Aleph::k_shortest_paths_detail::same_prefix_nodes(), Aleph::Ellipse::sample(), Aleph::RotatedEllipse::sample(), Aleph::RotatedEllipse::sample(), Aleph::BezierCurve::sample_cubic(), Aleph::BezierCurve::sample_quadratic(), sample_tree(), sample_tree(), Aleph::TestVisual::sanitize_filename(), Aleph::Compiler_Backend_C_Detail::sanitize_identifier(), Aleph::FFT< Real >::satisfies_cola(), Aleph::FFT< Real >::satisfies_nola(), satisfies_ore_condition(), Aleph::adversarial_search_detail::saturating_add(), Aleph::FFT< Real >::saturating_product(), Aleph::adversarial_search_detail::saturating_subtract(), Aleph::IO_Graph< GT, Load_Node, Store_Node, Load_Arc, Store_Arc, NF, AF >::save(), Aleph::BitArray::save(), Aleph::BitArray::save_in_array_of_chars(), Aleph::IO_Graph< GT, Load_Node, Store_Node, Load_Arc, Store_Arc, NF, AF >::save_in_text_mode(), save_level_pos_1(), save_level_pos_2(), Aleph::detail::save_ordered_tree_snapshot(), save_parameters(), Aleph::Huffman_Encoder_Engine::save_tree_in_array_of_chars(), Aleph::save_tree_in_array_of_chars(), DataGenerator::sawtooth(), Aleph::matrix_chain_detail::scalar_cost(), Aleph::Vector< T, NumType >::scalar_product(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::scale_inplace(), Aleph::Gen_Polynomial< Coefficient >::scale_inplace(), Aleph::NTT< MOD, ROOT >::Plan::scale_inverse(), Aleph::FFT< Real >::scaled_copy(), Aleph::FFT< Real >::scaled_tolerance(), Aleph::scanl(), Aleph::scanl_sum(), Aleph::FFT< Real >::scatter_axis_slice(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::scc_by_blocks(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::scc_by_len(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::scc_by_lists(), scenario_1(), scenario_1_el_arbol_del_tiempo(), scenario_2(), scenario_2_ajustes_salariales(), scenario_3(), scenario_3_balanceo_servidores(), scenario_4(), scenario_4_rmq_comparison(), scenario_betting_promos(), scenario_construction(), scenario_construction(), scenario_exact_intersection(), scenario_in_circle_in_delaunay_context(), scenario_intersection_detection(), scenario_order_book(), scenario_orientation(), scenario_parlay_betting(), scenario_pnl_dashboard(), scenario_probability(), scenario_range_gcd(), scenario_road_network(), scenario_sales_analytics(), scenario_sensor_monitoring(), scenario_sports_leaderboard(), scenario_xor_checksum(), TimeoutQueue::schedule_after_ms(), WorkersSet< WorkerFct >::schedule_call(), TimeoutQueue::schedule_event(), TimeoutQueue::schedule_event(), Aleph::IDA_Star< GT, Distance, Heuristic, Itor, SA >::search(), Aleph::Nodes_Index< GT, Compare, Tree, SN >::search(), Aleph::IndexNode< GT, Compare, Tree, SN >::search(), Aleph::DynIntervalTree< T, Compare >::search(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::search(), GenTdSplayTreeRk< NodeType, Key, Compare >::search(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::search(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::search(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::search(), Aleph::GenBinTree< NodeType, Key, Compare >::search(), Aleph::HtdRbTree< Key, Compare >::search(), Aleph::HtdRbTreeRk< Key, Compare >::search(), Aleph::ODhashTable< Key, Cmp >::search(), Aleph::OLhashTable< Key, Cmp >::search(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::search(), Aleph::Gen_Treap< NodeType, Key, Compare >::search(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::search(), GenTdSplayTree< NodeType, Key, Compare >::search(), Aleph::SkipList< Key, Type >::search(), QuadTree::search(), Aleph::Aho_Corasick::search(), Aleph::Nodes_Index< GT, Compare, Tree, SN >::search(), Aleph::IndexNode< GT, Compare, Tree, SN >::search(), Aleph::Arcs_Index< GT, Compare, Tree, SA >::search(), Aleph::Arcs_Index< GT, Compare, Tree, SA >::search(), Aleph::search(), Aleph::Alpha_Beta< Domain >::search(), Aleph::Depth_First_Backtracking< Domain >::search(), Aleph::Branch_And_Bound< Domain, ObjectivePolicy >::search(), Aleph::Negamax< Domain >::search(), Aleph::IDA_Star_State_Search< Domain >::search(), Aleph::Depth_First_Backtracking< Domain >::search(), Aleph::Branch_And_Bound< Domain, ObjectivePolicy >::search(), Aleph::Depth_First_Backtracking< Domain >::search(), Aleph::Branch_And_Bound< Domain, ObjectivePolicy >::search(), Aleph::IDA_Star_State_Search< Domain >::search(), Aleph::Alpha_Beta< Domain >::search(), Aleph::Negamax< Domain >::search(), Aleph::Alpha_Beta< Domain >::search(), Aleph::Negamax< Domain >::search(), Aleph::Alpha_Beta< Domain >::search(), Aleph::Negamax< Domain >::search(), Aleph::Alpha_Beta< Domain >::search(), Aleph::Negamax< Domain >::search(), Aleph::Alpha_Beta< Domain >::search(), Aleph::Negamax< Domain >::search(), Aleph::Branch_And_Bound< Domain, ObjectivePolicy >::search(), Aleph::Branch_And_Bound< Domain, ObjectivePolicy >::search(), Aleph::Depth_First_Backtracking< Domain >::search(), Aleph::Depth_First_Backtracking< Domain >::search(), Aleph::Find_Aumenting_Path< Net, Q >::search(), Aleph::IndexArc< GT, Tree, SA >::search(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::search_and_stack_avl(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::search_and_stack_avl(), Aleph::Gen_Rb_Tree< NodeType, Key, Compare >::search_and_stack_rb(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::search_and_stack_rb(), Aleph::search_arc(), Aleph::Branch_And_Bound< Domain, ObjectivePolicy >::search_best_first(), Aleph::Cnode::search_child_impl(), Aleph::Prefix_Tree_Map< T >::Node::search_child_impl(), QuadTree::search_container_node(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::search_contains(), Aleph::GraphCopyWithMapping< GT, Tree >::search_copy(), Aleph::Branch_And_Bound< Domain, ObjectivePolicy >::search_depth_first(), Aleph::search_deway(), Aleph::IndexArc< GT, Tree, SA >::search_directed(), Aleph::search_directed_arc(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::search_dup_and_stack_avl(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::search_dup_and_stack_avl(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::search_dup_and_stack_rb(), Aleph::Gen_Rb_Tree< NodeType, Key, Compare >::search_dup_and_stack_rb(), Aleph::Vector< T, NumType >::search_entry(), Aleph::search_extreme(), Aleph::search_extreme(), Aleph::search_extreme(), Aleph::search_extreme(), Aleph::search_extreme(), Aleph::search_extreme(), Aleph::search_extreme(), Aleph::search_extreme(), Aleph::search_extreme(), Aleph::search_extreme(), Aleph::QuickHull::search_extremes(), Aleph::Negamax< Domain >::search_impl(), Aleph::Alpha_Beta< Domain >::search_impl(), Aleph::search_in_arc(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::search_intersects(), Aleph::search_inversion(), Aleph::search_max(), Aleph::search_max(), Aleph::search_max(), Aleph::search_max(), Aleph::search_min(), Aleph::search_min(), Aleph::search_min(), Aleph::search_n(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::search_negative_cycle(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::search_negative_cycle(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::search_negative_cycle(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::search_negative_cycle(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::search_negative_cycle_on_partial_graph(), Aleph::GenLhashTable< Key, BucketType, Cmp >::search_next(), Aleph::Index_Graph< GT, Compare, Tree >::search_node(), Aleph::search_node(), Aleph::Negamax< Domain >::search_node(), Aleph::Alpha_Beta< Domain >::search_node(), Aleph::DynHashTable< Key, HashTable, Cmp >::search_or_insert(), Aleph::DynSkipList< Key, Compare >::search_or_insert(), OhashCommon< HashTbl, Key >::search_or_insert(), Aleph::DynHashTable< Key, HashTable, Cmp >::search_or_insert(), Aleph::BinTree_Operation< Node, Cmp >::search_or_insert(), Aleph::Gen_Treap< NodeType, Key, Compare >::search_or_insert(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::search_or_insert(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::search_or_insert(), GenTdSplayTreeRk< NodeType, Key, Compare >::search_or_insert(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::search_or_insert(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::search_or_insert(), Aleph::GenBinTree< NodeType, Key, Compare >::search_or_insert(), Aleph::HtdRbTree< Key, Compare >::search_or_insert(), Aleph::HtdRbTreeRk< Key, Compare >::search_or_insert(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::search_or_insert(), Aleph::Gen_Rb_Tree< NodeType, Key, Compare >::search_or_insert(), GenTdSplayTree< NodeType, Key, Compare >::search_or_insert(), Aleph::GenTdRbTree< NodeType, Key, Compare >::search_or_insert(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::search_or_insert(), Aleph::Gen_Treap< NodeType, Key, Compare >::search_or_insert(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::search_or_insert(), Aleph::DynHashTable< Key, HashTable, Cmp >::search_or_insert_bucket(), Aleph::search_or_insert_by_key_xt(), Aleph::search_or_insert_in_bst(), Aleph::Nodes_Index< GT, Compare, Tree, SN >::search_or_insert_in_graph(), Aleph::Nodes_Index< GT, Compare, Tree, SN >::search_or_insert_in_graph(), Aleph::BinTree_Operation< Node, Cmp >::search_or_insert_root_rec(), Aleph::search_or_insert_root_rec(), Aleph::search_or_insert_root_rec_xt(), Aleph::search_or_insert_root_rec_xt(), Aleph::search_out_arc(), Aleph::BinTree_Operation< Node, Cmp >::search_parent(), Aleph::search_parent(), Aleph::Cnode::search_prefix_impl(), Aleph::Prefix_Tree_Map< T >::Node::search_prefix_impl(), Aleph::BinTree_Operation< Node, Cmp >::search_rank_parent(), Aleph::search_rank_parent(), Aleph::search_spanning_tree_arc(), Aleph::GenLhashTable< Key, BucketType, Cmp >::search_with_custom_hash(), Aleph::Alpha_Beta< Domain >::search_with_window(), Aleph::Alpha_Beta< Domain >::search_with_window(), Aleph::Alpha_Beta< Domain >::search_with_window(), Aleph::Alpha_Beta< Domain >::search_with_window(), Aleph::Alpha_Beta< Domain >::search_with_window(), Aleph::Alpha_Beta< Domain >::search_with_window(), Aleph::Cnode::search_word(), Aleph::HtdRbTree< Key, Compare >::searchAndBuildPath(), Aleph::HtdRbTreeRk< Key, Compare >::searchAndBuildPath(), Aleph::GenTdRbTree< NodeType, Key, Compare >::searchAndColorRed(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::searchAndColorRed(), Aleph::HtdRbTree< Key, Compare >::searchFlipColorsAndInsert(), Aleph::HtdRbTreeRk< Key, Compare >::searchFlipColorsAndInsert(), Aleph::GenTdRbTree< NodeType, Key, Compare >::searchFlipColorsAndInsert(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::searchFlipColorsAndInsert(), Aleph::HtdRbTree< Key, Compare >::searchFlipColorsAndInsertDup(), Aleph::HtdRbTreeRk< Key, Compare >::searchFlipColorsAndInsertDup(), Aleph::GenTdRbTree< NodeType, Key, Compare >::searchFlipColorsAndInsertDup(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::searchFlipColorsAndInsertDup(), Aleph::searchInBinTree(), Aleph::FFT< Real >::section_from_coefficients(), Graph_Traverse< GT, Itor, Q, Show_Arc >::seed_arc(), Aleph::Compiler_Typed_Semantic_Analyzer::seed_function_annotation_type_variables(), seed_random(), Aleph::segment_image(), segment_intersection(), Aleph::segment_intersection_point(), Aleph::segment_segment_intersection(), Aleph::segments_intersect(), Aleph::planarity_detail::segments_properly_intersect(), Aleph::select(), Aleph::DynSetTree< Key, Tree, Compare >::select(), Aleph::Karger_Min_Cut< GT, SA >::ArcIndex::select(), Aleph::DynSetTree< Key, Tree, Compare >::select(), Aleph::RevisedSimplex< T >::select_entering_variable(), Aleph::select_gotoup_root(), Aleph::AABBTree::select_kth_by_center(), Aleph::RevisedSimplex< T >::select_leaving_variable(), Aleph::select_ne(), Aleph::Simplex< T >::select_pivot(), Aleph::select_pivot_op(), Aleph::select_pivot_op(), Aleph::select_pivot_op_impl(), Aleph::Random_Graph_Base< GT, Init_Node, Init_Arc >::select_random_node(), Aleph::Random_Graph_Base< GT, Init_Node, Init_Arc >::select_random_node(), Aleph::selection_sort(), Aleph::selection_sort(), Aleph::TraverseMixin< Derived, Type >::self(), Aleph::LocateMixin< Derived, Type >::self(), Aleph::FunctionalMixin< Derived, Type >::self(), Aleph::KeysMixin< Derived, Type >::self(), Aleph::TraverseMixin< Derived, Type >::self(), Aleph::LocateMixin< Derived, Type >::self(), Aleph::FunctionalMixin< Derived, Type >::self(), Aleph::Find_Aumenting_Path< Net, Q >::semi_path(), Aleph::BoundedChannel< T >::send_impl(), Aleph::BoundedChannel< T >::send_impl(), Aleph::sequential_groups(), Aleph::sequential_search(), Aleph::sequential_search(), Aleph::sequential_search(), Aleph::sequential_search(), Aleph::sequential_search(), Aleph::sequential_search(), Aleph::sequential_search(), Aleph::sequential_search(), Aleph::sequential_search(), Aleph::NTT< MOD, ROOT >::series_prefix(), Aleph::FFT< Real >::series_zero_tolerance(), Aleph::CA::Tile_Cache< State, TileSide >::set(), Aleph::CA::Ghost_Lattice< Storage, Boundary, Halo >::set(), Aleph::CA::Graph_Lattice< T >::set(), Aleph::CA::Multi_Field_Lattice< Layout, Boundary, Rank, Fields >::set(), Aleph::Compiler_Dataflow_Bit_Set::set(), Aleph::Dlink::Iterator::set(), Aleph::Slink_Nc::Iterator::set(), Aleph::CA::Hashlife_Engine::set_alive(), Aleph::IO_Graph< GT, Load_Node, Store_Node, Load_Arc, Store_Arc, NF, AF >::set_arc_filter(), Aleph::Xml_Graph< GT, Node_Reader, Arc_Reader, Node_Writer, Arc_Writer >::set_arc_name(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::set_auto_sync(), Aleph::Bit_Fields::set_bit(), Aleph::Compact_Quotient_Filter< T >::set_bit_at(), Aleph::BitArray::set_bit_str(), Aleph::Bloom_Filter< T >::set_bits(), Aleph::Compiler_CFG_Lowering::set_branch(), Aleph::Compiler_IR_Lowering::Module_Builder::set_branch(), Aleph::Net_Graph< NodeT, ArcT >::set_cap(), Aleph::Tikz_Plane::set_clip_padding_mm(), Aleph::Gen_Polynomial< Coefficient >::set_coeff(), TimeoutQueue::Event::set_completion_callback(), Aleph::CA::Parallel_Synchronous_Engine< Lattice, Rule, Neighborhood, Order >::set_config(), Aleph::RevisedSimplex< T >::set_constraint_row(), Aleph::Quotient_Filter< T >::set_cont(), Aleph::Filter_Iterator< Container, It, Show_Item >::set_cookie(), Aleph::Net_Filt< Net >::set_cookie(), Aleph::DynMatrix< T >::set_dimension(), Aleph::Gen_Link_Cut_Tree_WithEdges< VT, ET, EdgeMonoid, LazyTag >::set_edge_val(), Aleph::Compact_Quotient_Filter< T >::set_element(), Aleph::Quotient_Filter< T >::set_element(), Aleph::Vector< T, NumType >::set_entries(), Aleph::Vector< T, NumType >::set_entries(), Aleph::Vector< T, NumType >::set_entry(), Aleph::Matrix< Trow, Tcol, NumType >::set_entry(), Aleph::Compiler_IR_Builder::set_entry_block(), Aleph::Compiler_Type_Context::set_enum_variants(), Aleph::DynArray_Set< T, Equal >::set_equal(), Aleph::Compiler_CFG_Lowering::set_exit(), Aleph::Compiler_IR_Lowering::Module_Builder::set_exit(), Aleph::Compiler_IR_Builder::set_exit_block(), Eepic_Plane::set_fill_type(), Aleph::Filter_Iterator< Container, It, Show_Item >::set_filter(), Aleph::Huffman_Encoder_Engine::set_freq(), Aleph::set_freq(), Aleph::Path< GT >::set_graph(), Aleph::Xml_Graph< GT, Node_Reader, Arc_Reader, Node_Writer, Arc_Writer >::set_graph_name(), Aleph::GenLhashTable< Key, BucketType, Cmp >::set_hash_fct(), Aleph::GenLinearHashTable< Key, BucketType, Cmp >::set_hash_fct(), Aleph::GenLhashTable< Key, BucketType, Cmp >::set_hash_fct(), Aleph::GenLinearHashTable< Key, BucketType, Cmp >::set_hash_fct(), Aleph::Gen_Segment_Tree< T, Op >::set_impl(), Aleph::Gen_Lazy_Segment_Tree< Policy >::set_impl(), Aleph::CA::Hashlife_Engine::set_in_node(), Aleph::Bit_Mat_Graph< GT, SA >::set_list_graph(), Aleph::IO_Graph< GT, Load_Node, Store_Node, Load_Arc, Store_Arc, NF, AF >::set_load_arc(), Aleph::IO_Graph< GT, Load_Node, Store_Node, Load_Arc, Store_Arc, NF, AF >::set_load_node(), HashStats< HashTbl >::set_lower_alpha(), QuadTree::set_max_num_points_per_node(), Aleph::IO_Graph< GT, Load_Node, Store_Node, Load_Arc, Store_Arc, NF, AF >::set_node_filter(), Aleph::Xml_Graph< GT, Node_Reader, Arc_Reader, Node_Writer, Arc_Writer >::set_node_name(), Aleph::BitArray::set_num(), Aleph::BitArray::set_num(), Aleph::BitArray::set_num(), Aleph::BitArray::set_num(), Aleph::BitArray::set_num(), Aleph::RevisedSimplex< T >::set_objective(), Aleph::Quotient_Filter< T >::set_occ(), Aleph::CA::Hex_Lattice< Storage, Boundary >::set_offset_even_r(), set_picture_size(), Aleph::Tikz_Plane::set_point_radius_mm(), Aleph::Tikz_Scene::set_point_radius_mm(), Aleph::Array_Iterator< T >::set_pos(), Aleph::Now::set_precision(), Aleph::ThreadPool::set_queue_limits(), Aleph::set_range(), Aleph::set_range(), Aleph::PersistentVector< T >::set_rec(), Aleph::Rectangle::set_rect(), QuadNode::set_region(), Aleph::Compact_Quotient_Filter< T >::set_rem(), Aleph::Quotient_Filter< T >::set_rem(), Eepic_Plane::set_resolution(), Aleph::ODhashTable< Key, Cmp >::set_second_hash_fct(), Aleph::ODhashTable< Key, Cmp >::set_second_hash_fct(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::set_seed(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::set_seed(), Aleph::Gen_Treap< NodeType, Key, Compare >::set_seed(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::set_seed(), Aleph::Random_Set< T >::set_seed(), Aleph::DynSkipList< Key, Compare >::set_seed(), Aleph::SkipList< Key, Type >::set_seed(), Eepic_Plane::set_shade_thickness(), Aleph::Quotient_Filter< T >::set_shft(), Aleph::BitArray::set_size(), Aleph::Compact_Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::Bucket::set_slot(), Aleph::FFT< Real >::LFilter::set_state(), Aleph::Bit_Fields::set_state(), Aleph::Compiler_Type_Context::set_struct_fields(), Aleph::Net_Sup_Dem_Graph< NodeT, ArcT >::set_supply_flow(), Aleph::Compiler_IR_Builder::set_terminator_span(), Aleph::set_to_Array(), Aleph::set_to_DynArray(), Aleph::set_to_DynList(), TimeoutQueue::Event::set_trigger_time(), Aleph::set_unify(), HashStats< HashTbl >::set_upper_alpha(), Aleph::Modular_Matrix< MatrixT >::set_val(), Aleph::Matrix< Trow, Tcol, NumType >::set_vector_as_col(), Aleph::Matrix< Trow, Tcol, NumType >::set_vector_as_row(), Aleph::Abstract_Euclidian_Plane< __Euclidian_Graph >::set_x_node_ratio(), Aleph::Abstract_Euclidian_Plane< __Euclidian_Graph >::set_x_scale(), Aleph::Abstract_Euclidian_Plane< __Euclidian_Graph >::set_y_node_ratio(), Aleph::Abstract_Euclidian_Plane< __Euclidian_Graph >::set_y_scale(), Aleph::sethash_to_Array(), Aleph::sethash_to_DynArray(), Aleph::sethash_to_DynList(), Aleph::sethash_to_vector(), Aleph::settree_to_Array(), Aleph::settree_to_DynArray(), Aleph::settree_to_DynList(), Aleph::settree_to_stdset(), Aleph::settree_to_vector(), AStarGridTest::SetUp(), CoordinateTransformTest::SetUp(), HashDistributionTest::SetUp(), IOGraphTest::SetUp(), IODigraphTest::SetUp(), AuxNetTest::SetUp(), NetUtilsTest::SetUp(), CsvFileTest::SetUp(), CsvReaderTest::SetUp(), CsvFilterTest::SetUp(), CsvStatisticsTest::SetUp(), CsvTransformationTest::SetUp(), ParseUtilsTest::SetUp(), Aleph::Simplex< T >::shadow_price(), Aleph::CA::shannon_entropy(), Aleph::ConcurrentHashMap< Key, T, Cmp, Shards >::shard_for(), Aleph::ConcurrentHashMap< Key, T, Cmp, Shards >::shard_for(), Aleph::shellsort(), Aleph::Gen_Polynomial< Coefficient >::shift(), Aleph::Compact_Quotient_Filter< T >::shift_elements_left(), Aleph::Quotient_Filter< T >::shift_elements_left(), Aleph::Compact_Quotient_Filter< T >::shift_elements_right(), Aleph::Quotient_Filter< T >::shift_elements_right(), Aleph::shift_lines_to_left(), Aleph::k_shortest_paths_detail::shortest_path_filtered(), Aleph::detail::shortest_path_portals(), Aleph::FFT< Real >::should_parallelize_batch_work(), Aleph::CA::should_run_sequential(), Aleph::NTT< MOD, ROOT >::Plan::should_use_avx2(), Aleph::FFT< Real >::Plan::should_use_avx2(), Aleph::NTT< MOD, ROOT >::Plan::should_use_neon(), Aleph::FFT< Real >::Plan::should_use_neon(), show_string(), Aleph::shuffle(), Aleph::shuffle_ptr(), QueueTheadsPool< T >::shutdown(), Aleph::ThreadPool::shutdown(), Aleph::sift_down(), Aleph::sift_down(), Aleph::GenBinHeap< NodeType, Key, Compare >::sift_down(), Aleph::sift_down(), Aleph::sift_down_up(), Aleph::sift_up(), Aleph::sift_up(), Aleph::Gen_Polynomial< Coefficient >::sign_variations(), Aleph::GeomPolygonUtils::signed_area(), Aleph::FFT< Real >::signed_binomial(), Aleph::GeomPolygonUtils::signed_double_area(), Aleph::ConvexPolygonIntersectionBasic::signed_double_area(), Aleph::HalfPlaneIntersection::signed_double_area(), Aleph::Two_Sat< GT >::signed_to_lit(), Aleph::NTT< MOD, ROOT >::simd_backend(), Aleph::NTT< MOD, ROOT >::simd_backend_name(), Aleph::FFT< Real >::simd_backend_name(), Aleph::NTT< MOD, ROOT >::simd_mod_supported(), Aleph::FFT< Real >::simd_preference(), Aleph::FFT< Real >::simd_preference_name(), Aleph::NTT< MOD, ROOT >::simd_preference_name(), Aleph::MinHash< T >::similarity(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::simple_edges_are_planar(), Aleph::VisvalingamWhyattSimplification::simplify_open_array(), Aleph::VisvalingamWhyattSimplification::simplify_polygon(), Aleph::DouglasPeuckerSimplification::simplify_polygon(), Aleph::Compiler_Dataflow_Detail::simulate_block(), Aleph::siphash24_hash(), Aleph::siphash24_hash(), Aleph::siphash24_hash(), Aleph::siphash24_hash(), Aleph::ConcurrentHashMap< Key, T, Cmp, Shards >::size(), Aleph::mdspan< T, Extents, LayoutPolicy, AccessorPolicy >::size(), Aleph::CA::Multi_Field_Lattice< Layout, Boundary, Rank, Fields >::size(), Aleph::CA::Multi_Field_Lattice< Layout, Boundary, Rank, Fields >::size(), Aleph::PersistentHashMap< Key, T, Cmp >::size_after_insert(), Aleph::skewness(), Aleph::skip_block_comment(), Aleph::skip_line_comment(), Aleph::skip_white_spaces(), Aleph::Compiler_Lexer::skip_whitespace(), Aleph::skip_whitespace_and_comments(), Aleph::CA::Row_Partition< Rank >::slab(), Aleph::CA::Column_Partition< Rank >::slab(), Aleph::Rope< Char, LeafSize >::slice(), Aleph::FFT< Real >::OverlapAddBank::slice_chunk(), Aleph::FFT< Real >::slice_copy(), Aleph::FunctionalMixin< Derived, Type >::sliding(), Aleph::SweepLineSegmentIntersection::slope_less(), Aleph::Compact_Quotient_Filter< T >::slot_empty(), Aleph::graph_coloring_detail::smallest_available(), Aleph::ChaikinSmoothing::smooth_closed_once(), Aleph::ChaikinSmoothing::smooth_open_once(), Aleph::ChaikinSmoothing::smooth_polygon(), Aleph::CA::ca_checkpoint_detail::snapshot_frame_bytes(), Aleph::Source_Manager::snippet(), Aleph::CA::sobel_x_kernel(), Aleph::CA::sobel_y_kernel(), Aleph::blossom_detail::Edmonds_Blossom_Matcher< GT, SA >::solve(), Aleph::Simplex< T >::solve(), Aleph::RevisedSimplex< T >::solve(), Aleph::MCF_LP_Solver< Net >::solve(), Aleph::Two_Sat< GT >::solve(), Aleph::Gen_Mo_Algorithm< T, Policy >::solve(), Aleph::Gen_Mo_Algorithm< T, Policy >::solve(), Aleph::Compiler_Type_Unifier::solve(), Aleph::Hungarian_Assignment< Cost_Type >::solve(), Aleph::Gen_Mo_Algorithm< T, Policy >::solve(), Aleph::solve_assignment(), Aleph::solve_circulation(), Aleph::FFT< Real >::solve_dense_system(), Aleph::FFT< Real >::solve_elliptic_selectivity_modulus(), Aleph::solve_multicommodity_flow(), Aleph::solve_project_selection(), Aleph::FFT< Real >::solve_remez_cosine_series(), Aleph::solve_transportation(), Aleph::solve_transshipment(), Aleph::sort(), Aleph::sort(), Aleph::FlatMap< Key, T, Compare >::sort_and_unique(), Aleph::FlatSet< Key, Compare >::sort_and_unique(), Aleph::List_SGraph< __Graph_Node, __Graph_Arc >::sort_arcs(), Aleph::sort_ranked_moves(), Aleph::AndrewMonotonicChainConvexHull::sorted_unique_points(), Aleph::GrahamScanConvexHull::sorted_unique_points(), Aleph::FFT< Real >::sos_filtfilt_impl(), Aleph::FFT< Real >::sosfilt(), Aleph::FFT< Real >::sosfilt(), south_offset(), Aleph::Gen_Polynomial< Coefficient >::sparse_eval(), sparse_polynomials(), Aleph::FFT< Real >::spectrum(), Aleph::FFT< Real >::spectrum(), Aleph::FFT< Real >::spectrum(), Aleph::CA::ca_ising_detail::spin_to_state(), GenTdSplayTree< NodeType, Key, Compare >::splay(), GenTdSplayTreeRk< NodeType, Key, Compare >::splay(), Aleph::Gen_Link_Cut_Tree< T, Monoid, LazyTag >::splay(), GenTdSplayTree< NodeType, Key, Compare >::splay_impl(), GenTdSplayTreeRk< NodeType, Key, Compare >::splay_impl(), GenTdSplayTreeRk< NodeType, Key, Compare >::splay_max(), Aleph::Dlink::splice(), Aleph::GenBinTree< NodeType, Key, Compare >::split(), Aleph::PersistentTreapSet< Key, Compare >::split(), Aleph::PersistentTreapMap< Key, T, Compare >::split(), Aleph::split(), Aleph::split(), Aleph::split(), QuadTree::split(), Aleph::split_camel_case(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::split_child(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::split_child(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::split_child(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::split_child(), Aleph::CA::ca_io_detail::split_comment_lines(), Aleph::BezierCurve::split_cubic(), Aleph::GenBinTree< NodeType, Key, Compare >::split_dup(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::split_entries(), Aleph::DynSetTree< Key, Tree, Compare >::split_key(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::split_key(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::split_key(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::split_key(), Aleph::Gen_Treap< NodeType, Key, Compare >::split_key(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::split_key(), Aleph::split_key(), Aleph::BinTree_Operation< Node, Cmp >::split_key(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::split_key_dup(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::split_key_dup(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::split_key_dup(), Aleph::Gen_Treap< NodeType, Key, Compare >::split_key_dup(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::split_key_dup(), Aleph::BinTree_Operation< Node, Cmp >::split_key_dup_rec(), Aleph::split_key_dup_rec(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::split_key_dup_rec(), Aleph::BinTree_Operation< Node, Cmp >::split_key_dup_rec_helper(), Aleph::split_key_dup_rec_helper(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::split_key_dup_rec_rb(), Aleph::split_key_dup_rec_xt(), Aleph::BinTree_Operation< Node, Cmp >::split_key_rec(), Aleph::split_key_rec(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::split_key_rec(), Aleph::BinTreeXt_Operation< Node, Cmp >::split_key_rec(), Aleph::BinTree_Operation< Node, Cmp >::split_key_rec_helper(), Aleph::split_key_rec_helper(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::split_key_rec_rb(), Aleph::split_key_rec_xt(), Aleph::DynDlist< T >::split_list(), Aleph::HTList::split_list(), Aleph::Dlink::split_list_ne(), Aleph::TrapezoidalMapPointLocation::split_multiple_trapezoids(), Aleph::split_n(), Aleph::DynSetTree< Key, Tree, Compare >::split_pos(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::split_pos(), Aleph::split_pos(), Aleph::Gen_Rand_Tree< NodeType, Key, Compare >::split_pos(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::split_pos(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::split_pos(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::split_pos(), Aleph::HtdRbTreeRk< Key, Compare >::split_pos(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::split_pos_inorder(), Aleph::split_pos_rec(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::split_pos_rec(), Aleph::Gen_Rb_Tree_Rk< NodeType, Key, Compare >::split_pos_rec_rb(), Aleph::CA::split_range_balanced(), Aleph::detail::PersistentTreapNodeOps< Node, Key, Compare >::split_rec(), Aleph::TrapezoidalMapPointLocation::split_single_trapezoid(), Aleph::split_string(), Aleph::split_string(), Aleph::split_text_into_words(), Aleph::split_to_array(), Aleph::split_to_list(), Aleph::Compiler_Line_Frontend::split_tokens(), Aleph::detail::spp_build_tris(), Aleph::detail::spp_find_index(), Aleph::detail::spp_find_sleeve(), Aleph::detail::spp_find_tri(), Aleph::detail::spp_point_in_triangle(), Aleph::Gen_Polynomial< Coefficient >::square_free(), Aleph::ssp_init_potentials(), Aleph::ssp_shortest_path(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::stab(), Aleph::FFT< Real >::stability_margin(), Aleph::FFT< Real >::stability_margin(), Aleph::FFT< Real >::stability_margin(), Aleph::stable_build_index(), Aleph::stable_build_index_ptr(), Aleph::stable_build_index_ptr(), Aleph::detail::Pid_File_Lock::stale_lock(), standard_cuckoo_memory_usage(), Aleph::CA::Ffmpeg_Frame_Sink< Mapper >::start(), RingFileCache< T >::state(), Aleph::CA::state_histogram(), Aleph::ODhashTable< Key, Cmp >::stats(), Aleph::SweepLineSegmentIntersection::status_less(), Aleph::std_zip(), Aleph::std_zip_n(), Aleph::stdmap_to_DynMapTree(), Aleph::stdsort(), Aleph::SmallVector< T, N >::steal(), Aleph::CA::Synchronous_Engine< Lattice, Rule, Neighborhood, Order >::step(), Aleph::CA::Graph_Synchronous_Engine< Lattice, Rule >::step(), Aleph::CA::Multi_Field_Engine< Lattice, Rule, Neighborhood >::step(), Aleph::CA::Parallel_Synchronous_Engine< Lattice, Rule, Neighborhood, Order >::step(), Aleph::FFT< Real >::stft_impl(), Aleph::stl_adjacent_all(), Aleph::stl_all(), Aleph::stl_cartesian_product(), Aleph::stl_combinations(), Aleph::stl_compare(), Aleph::stl_concat(), Aleph::stl_container_to_dynList(), Aleph::stl_count(), Aleph::stl_distinct(), Aleph::stl_drop_while(), Aleph::stl_enumerate(), Aleph::stl_equal(), Aleph::stl_exists(), Aleph::stl_filter(), Aleph::stl_filteri(), Aleph::stl_find(), Aleph::stl_find_index(), Aleph::stl_find_last(), Aleph::stl_find_mapi(), Aleph::stl_flat_map(), Aleph::stl_flatten(), Aleph::stl_foldl(), Aleph::stl_foldr(), Aleph::stl_for_each(), Aleph::stl_for_each_indexed(), Aleph::stl_generate(), Aleph::stl_group(), Aleph::stl_group_by(), Aleph::stl_map(), Aleph::stl_mapi(), Aleph::stl_max_by(), Aleph::stl_min_by(), Aleph::stl_min_max(), Aleph::stl_none(), Aleph::stl_partition(), Aleph::stl_product(), Aleph::stl_range(), Aleph::stl_scan_left(), Aleph::stl_scan_right(), Aleph::stl_take_last(), Aleph::stl_take_while(), Aleph::stl_traverse_arrangements(), Aleph::stl_traverse_combinations(), Aleph::stl_traverse_permutations(), Aleph::stl_unique(), Aleph::stl_unzip(), Aleph::stl_unzip_pairs(), Aleph::stl_unzip_tuple(), Aleph::stl_zip(), Aleph::stl_zip_all(), Aleph::stl_zip_all_eq(), Aleph::stl_zip_any(), Aleph::stl_zip_assoc(), Aleph::stl_zip_cmp(), Aleph::stl_zip_compare(), Aleph::stl_zip_count(), Aleph::stl_zip_drop(), Aleph::stl_zip_drop_while(), Aleph::stl_zip_equal(), Aleph::stl_zip_equal_by(), Aleph::stl_zip_equal_length(), Aleph::stl_zip_exists(), Aleph::stl_zip_filter(), Aleph::stl_zip_filteri(), Aleph::stl_zip_find_first(), Aleph::stl_zip_find_index(), Aleph::stl_zip_find_last(), Aleph::stl_zip_find_mapi(), Aleph::stl_zip_first(), Aleph::stl_zip_foldl(), Aleph::stl_zip_for_each(), Aleph::stl_zip_for_each_indexed(), Aleph::stl_zip_it(), Aleph::stl_zip_last(), Aleph::stl_zip_length(), Aleph::stl_zip_map(), Aleph::stl_zip_mapi(), Aleph::stl_zip_max(), Aleph::stl_zip_mem(), Aleph::stl_zip_min(), Aleph::stl_zip_min_max(), Aleph::stl_zip_none(), Aleph::stl_zip_nth(), Aleph::stl_zip_partition(), Aleph::stl_zip_reduce(), Aleph::stl_zip_scan_left(), Aleph::stl_zip_sum(), Aleph::stl_zip_take(), Aleph::stl_zip_take_while(), Aleph::stl_zip_to_pairs(), Aleph::stl_zip_to_vector(), Aleph::stl_zip_traverse(), Aleph::stl_zip_traverse_eq(), Aleph::ThreadPool::stop_workers(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::storage_format_version_on_disk(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::storage_format_version_on_disk(), Aleph::adversarial_search_detail::store_adversarial_transposition(), Aleph::CA::Ghost_Lattice< Storage, Boundary, Halo >::store_get(), Aleph::Transposition_Table< Key, Entry, HashMapTable, Cmp, ReplacePolicy >::store_impl(), Aleph::CA::Ghost_Lattice< Storage, Boundary, Halo >::store_set(), Aleph::Alpha_Beta< Domain >::store_transposition(), Aleph::Negamax< Domain >::store_transposition(), stress_multiplier(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::strictly_sorted(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::strictly_sorted(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::strictly_sorted(), Aleph::Interpreter_Runtime::strip_quotes(), Aleph::Gen_Polynomial< Coefficient >::sturm_chain(), Aleph::Gen_Polynomial< Coefficient >::sturm_sign_changes(), Aleph::Tikz_Plane::style_requires_patterns(), Aleph::multi_poly_detail::sub_indices(), Aleph::sublist(), Aleph::subset_sum(), Aleph::subset_sum_mitm(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::substage_apply_delta_step(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::substage_calc_dual_delta(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::substage_scan(), Aleph::FFT< Real >::substitute_rational_polynomial(), Aleph::Rope< Char, LeafSize >::substr(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::subtree_max_ptr(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::subtree_min_ptr(), Aleph::Gen_Mo_On_Trees< GT, Policy >::subtree_solve(), Aleph::Gen_Mo_On_Tree_Node< T, Policy >::subtree_solve(), Aleph::Gen_Mo_On_Trees< GT, Policy >::subtree_solve(), Aleph::Gen_Mo_On_Tree_Node< T, Policy >::subtree_solve(), Aleph::successive_shortest_paths(), Aleph::SweepLineSegmentIntersection::StatusTree::successor(), Aleph::MonotonePolygonTriangulation::EdgeStatusTree::successor_for_insert(), Aleph::SweepLineSegmentIntersection::StatusTree::successor_for_insert(), Aleph::suffix(), Aleph::suffix(), Aleph::suffix_array(), Aleph::CA::Kernel2D< T, Rows, Cols >::sum(), Aleph::FFT< Real >::sum_squares(), Aleph::FFT< Real >::sum_values(), Aleph::SuperFastHash(), Aleph::SuperFastHash(), Aleph::ConvexPolygonDistanceGJK::support(), Aleph::NTT< MOD, ROOT >::supports_bluestein_size(), Aleph::NTT< MOD, ROOT >::supports_power_of_two_size(), Aleph::NTTExact::supports_product_size(), Aleph::NTT< MOD, ROOT >::supports_size(), QueueTheadsPool< T >::suspend(), Aleph::Karger_Min_Cut< GT, SA >::ArcIndex::swap(), Aleph::CA::Bit_Cell_Storage< N >::swap(), Aleph::Compact_Quotient_Filter< T >::swap(), Aleph::CA::Dense_Cell_Storage< T, N >::swap(), Aleph::DynIntervalTree< T, Compare >::swap(), Aleph::DynListQueue< T >::swap(), Aleph::DynListStack< T >::swap(), Aleph::DynSetTree< Key, Tree, Compare >::swap(), Aleph::DynSkipList< Key, Compare >::swap(), Aleph::Fibonacci_Heap< T, Compare >::swap(), Aleph::Gen_Cartesian_Tree< T, Comp >::swap(), Aleph::Gen_Disjoint_Sparse_Table< T, Op >::swap(), Aleph::Gen_Fenwick_Tree< T, Plus, Minus >::swap(), Aleph::Gen_Lazy_Segment_Tree< Policy >::swap(), Aleph::Gen_Mo_Algorithm< T, Policy >::swap(), Aleph::Gen_Segment_Tree< T, Op >::swap(), Aleph::Gen_Sparse_Table< T, Op >::swap(), Aleph::GenLhashTable< Key, BucketType, Cmp >::swap(), Aleph::GenLinearHashTable< Key, BucketType, Cmp >::swap(), Aleph::GenTdRbTree< NodeType, Key, Compare >::swap(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::swap(), Aleph::CA::Ghost_Lattice< Storage, Boundary, Halo >::swap(), Aleph::CA::Graph_Lattice< T >::swap(), Aleph::CA::Lattice< Storage, Boundary >::swap(), Aleph::CA::Multi_Field_Lattice< Layout, Boundary, Rank, Fields >::swap(), Aleph::Net_Graph< NodeT, ArcT >::swap(), Aleph::ODhashTable< Key, Cmp >::swap(), Aleph::OLhashTable< Key, Cmp >::swap(), Aleph::Quotient_Filter< T >::swap(), Aleph::Range_Fenwick_Tree< T >::swap(), Aleph::RingBuffer< T >::swap(), Aleph::Segment_Tree_Beats< T >::swap(), Aleph::SmallVector< T, N >::swap(), Aleph::swap(), Aleph::CA::Multi_Field_Lattice< Layout, Boundary, Rank, Fields >::swap_field(), Aleph::swap_node_with_predecessor(), Aleph::swap_node_with_successor(), Aleph::Compact_Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::Bucket::swap_random_slot(), Aleph::Cuckoo_Filter< T, FingerprintBits, EntriesPerBucket >::Bucket::swap_random_slot(), Aleph::swap_ranges(), Aleph::GenBinHeap< NodeType, Key, Compare >::swap_root_with_last(), Aleph::Modular_Matrix< MatrixT >::swap_rows(), Aleph::Prefix_Tree::swap_state(), Aleph::GenBinHeap< NodeType, Key, Compare >::swap_with_parent(), Aleph::Gen_Avl_Tree< NodeType, Key, Compare >::swapWithSuccessor(), Aleph::Gen_Avl_Tree_Rk< NodeType, Key, Compare >::swapWithSuccessor(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::sync(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::sync(), Aleph::CA::ca_checkpoint_detail::sync_directory(), Aleph::CA::ca_checkpoint_detail::sync_file(), Aleph::detail::sync_file_by_path(), Aleph::detail::sync_file_descriptor(), Aleph::detail::sync_parent_directory(), Aleph::Compiler_Parser_Stream::synchronize_statement(), Aleph::t_enum_zip(), Aleph::t_enum_zip_eq(), Aleph::t_unzip(), Aleph::t_unzip_impl(), Aleph::t_zip(), Aleph::t_zip_eq(), Aleph::FunctionalMixin< Derived, Type >::take(), Aleph::take_while(), RankTreeTest< Tree >::TearDown(), NetUtilsTest::TearDown(), Aleph::FFT< Real >::tensor3_shape(), Aleph::FFT< Real >::tensor_element_count(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::terms(), test(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), RingFileCache< T >::test(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), test(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), test(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), test_adversarial_plateau_with_dip(), test_adversarial_plateau_with_spike(), test_adversarial_single_outlier(), test_all_constructors_agree(), Relation_T< T, Compare >::test_and_insert_new_item(), RingFileCache< T >::test_and_set_head_pointer(), test_bitwise_and_stress(), test_bitwise_or_stress(), Aleph::test_black_condition_rk(), test_complete_graph_limit(), Aleph::Tarjan_Connected_Components< GT, Itor, SA >::test_connectivity(), Aleph::test_connectivity(), test_construct_all_identical(), test_construct_from_dynlist(), test_container(), test_copy_constructor(), test_cross_comparison(), test_custom_initializers(), Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::test_dfs(), Aleph::Test_Hamiltonian_Sufficiency< GT, SN, SA >::test_digraph(), Aleph::Test_Dirac_Condition< GT, SN, SA >::test_digraph(), test_disjoint_split_min(), test_double_stress(), test_double_values(), test_DynMap(), test_DynMapLinHash(), test_DynSet(), test_DynSetLinHash(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), Aleph::test_for_path(), test_gcd_stress(), test_graph(), Aleph::Test_Hamiltonian_Sufficiency< GT, SN, SA >::test_graph(), Aleph::Test_Dirac_Condition< GT, SN, SA >::test_graph(), test_hash_table(), test_idempotent_overlap_split(), test_int_extremes(), test_ks_barbell(), test_ks_cycle(), test_ks_find_with_iterations(), test_ks_path(), test_ks_seed_reproducibility(), test_ks_single_edge(), test_ks_triangle(), test_ks_two_clusters(), test_list(), test_long_long_values(), test_map_tree(), test_map_tree(), test_max_cross_validation(), test_min_cross_validation(), test_move_constructor(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::test_negative_cycle(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::test_negative_cycle(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::test_negative_cycle(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::test_negative_cycle(), test_negative_values(), test_non_idempotent_correctness(), test_non_power_of_two_sizes(), test_num_levels(), test_num_levels_correctness(), TEST_P(), Aleph::Test_For_Path< GT, SA >::test_path(), test_perf_build(), test_perf_build_large(), test_perf_queries(), test_performance_build(), test_performance_build_large(), test_performance_ks(), test_performance_queries(), test_performance_sw(), test_power_of_two_sizes(), test_prefix_sum_consistency(), test_random_graph_deterministic_seed(), test_random_graph_different_seeds(), test_random_graph_eulerian_probability(), test_random_graph_eulerian_sparse(), test_random_graph_hamiltonian(), test_random_graph_invalid_probability(), test_random_graph_probability(), test_random_graph_probability_dense(), test_random_graph_sparse_basic(), test_random_graph_sparse_connected(), test_random_graph_sparse_disconnected(), Aleph::Ady_Mat< GT, __Entry_Type, SA >::test_same_graph(), test_self_copy_assignment(), test_self_swap(), test_single_node_graph(), Aleph::test_sorted(), test_sorted_ascending(), test_sorted_descending(), test_splitting_composability(), test_splitting_product(), test_stress_all_pairs_small(), test_stress_double_sum(), test_stress_max_small(), test_stress_min_medium(), test_stress_min_small(), test_stress_product_small(), test_string_concatenation(), test_string_stress(), test_sw_unit_weight(), test_swap(), test_tree(), test_two_elements(), test_two_node_graph(), test_values_reconstruct(), test_values_reconstruction(), test_xor_stress(), test_zero_nodes_rejected(), Aleph::GenTdRbTree< NodeType, Key, Compare >::testBlackHeight(), Aleph::HtdRbTree< Key, Compare >::testNode(), Aleph::GenTdRbTree< NodeType, Key, Compare >::testNode(), testResize(), tests(), Aleph::Tikz_Plane::text_options(), Aleph::CA::thread_step_seed(), Aleph::tikz_bold_wire_style(), Aleph::detail::tikz_palette_color(), Aleph::CA::Block_Partition_2D::tile(), time_algorithm(), time_from_now_ms(), time_from_now_ms(), timed_hull(), timespec_to_timepoint(), Aleph::timsort(), Aleph::timsort_detail::timsort_impl(), Aleph::tindexes(), Aleph::DynArray< T >::to_array(), Aleph::to_Array(), Aleph::FFT< Real >::to_array(), to_array(), Aleph::to_Array(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::to_binary(), Aleph::Matrix< Trow, Tcol, NumType >::to_collist(), to_cstr(), Aleph::Dlink::to_data(), Aleph::Slinknc::to_data(), Aleph::Dlink::to_data(), Aleph::Slinknc::to_data(), Aleph::Gen_Polynomial< Coefficient >::to_dense(), Aleph::to_deque(), Aleph::to_DynArray(), Aleph::FunctionalMixin< Derived, Type >::to_dynlist(), Aleph::to_DynList(), Aleph::to_dynlist(), Aleph::to_DynSetTree(), Aleph::GeomSerializer::to_geojson(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::to_json(), Aleph::Vector< T, NumType >::to_list(), Aleph::blossom_weighted_detail::to_ll_checked(), Aleph::min_cost_matching_detail::to_ll_checked(), Aleph::to_lower(), Aleph::CA::Kernel2D< T, Rows, Cols >::to_matrix(), Aleph::to_name(), Aleph::Lengauer_Tarjan_Post_Dominators< GT, SA >::to_orig(), Aleph::Gen_File_B_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::to_pairs(), Aleph::Gen_File_BPlus_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::to_pairs(), Aleph::to_Pascalcase(), Aleph::Simplex< T >::to_pivot(), Aleph::Lengauer_Tarjan_Post_Dominators< GT, SA >::to_rev(), Aleph::Matrix< Trow, Tcol, NumType >::to_rowlist(), Aleph::to_set(), Aleph::subset_sum_detail::to_size_checked(), Aleph::knapsack_detail::to_size_checked(), to_sorted_vector(), to_sorted_vector(), Aleph::to_stdvector(), Aleph::CA::Ghost_Lattice< Storage, Boundary, Halo >::to_store(), Aleph::AlDomain< T >::to_str(), Aleph::Matrix< Trow, Tcol, NumType >::to_str(), Aleph::Vector< T, NumType >::to_str(), Aleph::Cnode::to_str(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::to_str(), Aleph::Gen_Polynomial< Coefficient >::to_str(), Aleph::to_str(), Aleph::Source_Position::to_string(), Aleph::Source_Span::to_string(), Aleph::SourceLocation::to_string(), RingFileCache< T >::to_string(), Aleph::FlowStatistics< Flow_Type >::to_string(), Aleph::to_string(), Aleph::to_string(), Aleph::to_string(), Aleph::to_time_t(), Aleph::to_time_t(), Aleph::to_upper(), Aleph::FunctionalMixin< Derived, Type >::to_vector(), Aleph::to_vector(), Aleph::to_vector(), Aleph::GeomSerializer::to_wkt(), Aleph::GeomBowyerWatsonUtils::toggle_edge(), Aleph::tolower(), Aleph::NTT< MOD, ROOT >::tonelli_shanks(), Aleph::FixedStack< T >::top(), Aleph::FixedStack< T >::top(), Aleph::FixedStack< T >::top(), Aleph::FixedStack< T >::top(), Aleph::Topological_Sort< GT, Itor, SA >::topological_sort(), Aleph::CA::total_cells(), Aleph::Total_Cost< GT, Distance, SA >::total_cost(), Aleph::Net_Sup_Dem_Graph< NodeT, ArcT >::total_demand(), Aleph::Net_Sup_Dem_Graph< NodeT, ArcT >::total_supply(), Aleph::DynArray< T >::touch(), Aleph::toupper(), Aleph::FunctionalMixin< Derived, Type >::tpartition(), Aleph::FunctionalMixin< Derived, Type >::tpartition(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingContext< WeightType >::trace_alternating_paths(), transfer_function(), Aleph::FFT< Real >::transfer_function_to_sections(), Aleph::FFT< Real >::transfer_function_to_sections(), Aleph::FFT< Real >::transform(), Aleph::FFT< Real >::transform(), Aleph::expected< T, E >::transform(), Aleph::transform(), Aleph::transform(), Aleph::FFT< Real >::transform_any_size_impl(), Aleph::FFT< Real >::transform_axes(), Aleph::FFT< Real >::transform_axes_impl(), Aleph::FFT< Real >::transform_axis(), Aleph::FFT< Real >::transform_axis_impl(), Aleph::FFT< Real >::transform_batch(), Aleph::FFT< Real >::Plan::transform_batch(), Aleph::NTT< MOD, ROOT >::transform_batch(), Aleph::NTT< MOD, ROOT >::Plan::transform_batch(), Aleph::FFT< Real >::transform_impl(), Aleph::FFT< Real >::transform_padded(), Aleph::FFT< Real >::transform_padded(), Aleph::FFT< Real >::transform_padded(), Aleph::FFT< Real >::transform_real_optimized(), Aleph::FFT< Real >::transform_stages(), Aleph::FFT< Real >::transform_stft_frames(), Aleph::FFT< Real >::transformed(), Aleph::FFT< Real >::Plan::transformed(), Aleph::NTT< MOD, ROOT >::transformed(), Aleph::NTT< MOD, ROOT >::Plan::transformed(), Aleph::FFT< Real >::transformed(), Aleph::FFT< Real >::transformed2d(), Aleph::FFT< Real >::transformed2d_batch(), Aleph::FFT< Real >::transformed3d(), Aleph::FFT< Real >::transformed_axes(), Aleph::FFT< Real >::transformed_batch(), Aleph::FFT< Real >::Plan::transformed_batch(), Aleph::NTT< MOD, ROOT >::transformed_batch(), Aleph::NTT< MOD, ROOT >::Plan::transformed_batch(), Aleph::Compiler_Module_Binder_Detail::translate_issue(), Aleph::Matrix< Trow, Tcol, NumType >::transpose(), Aleph::transpose(), Aleph::FFT< Real >::transpose_spectrogram_layout(), Aleph::FFT< Real >::transpose_spectrogram_layout_impl(), Aleph::Array< T >::traverse(), Aleph::Array< T >::traverse(), Aleph::Array< T >::traverse(), Aleph::DynSetTree< Key, Tree, Compare >::traverse(), Aleph::DynIntervalTree< T, Compare >::traverse(), Aleph::DynBinHeap< T, Compare >::traverse(), Aleph::DynSetTree< Key, Tree, Compare >::traverse(), Aleph::DynSkipList< Key, Compare >::traverse(), Aleph::DynIntervalTree< T, Compare >::traverse(), Aleph::ArrayQueue< T >::traverse(), Aleph::DynArray< T >::traverse(), Aleph::DynMatrix< T >::traverse(), Aleph::MemArray< T >::traverse(), Aleph::ArrayQueue< T >::traverse(), Aleph::DynArray< T >::traverse(), Aleph::DynMatrix< T >::traverse(), Aleph::MemArray< T >::traverse(), Aleph::BitArray::traverse(), Aleph::ArrayHeap< T, Compare >::traverse(), Aleph::FixedQueue< T >::traverse(), Aleph::ArrayStack< T >::traverse(), Aleph::FixedStack< T >::traverse(), Aleph::DynArrayHeap< T, Compare >::traverse(), Aleph::DynListQueue< T >::traverse(), Aleph::DynListStack< T >::traverse(), Aleph::Random_Set< T >::traverse(), Aleph::BitArray::traverse(), Aleph::ArrayHeap< T, Compare >::traverse(), Aleph::FixedQueue< T >::traverse(), Aleph::ArrayStack< T >::traverse(), Aleph::FixedStack< T >::traverse(), Aleph::DynArrayHeap< T, Compare >::traverse(), Aleph::DynListQueue< T >::traverse(), Aleph::DynListStack< T >::traverse(), Aleph::Random_Set< T >::traverse(), Aleph::DynSkipList< Key, Compare >::traverse(), Aleph::TraverseMixin< Derived, Type >::traverse(), Aleph::BitArray::traverse(), Aleph::ArrayHeap< T, Compare >::traverse(), Aleph::ArrayQueue< T >::traverse(), Aleph::FixedQueue< T >::traverse(), Aleph::ArrayStack< T >::traverse(), Aleph::FixedStack< T >::traverse(), Aleph::DynArray< T >::traverse(), Aleph::DynArrayHeap< T, Compare >::traverse(), Aleph::DynListQueue< T >::traverse(), Aleph::DynListStack< T >::traverse(), Aleph::DynMatrix< T >::traverse(), Aleph::MemArray< T >::traverse(), Aleph::Random_Set< T >::traverse(), Aleph::TraverseMixin< Derived, Type >::traverse(), Aleph::BitArray::traverse(), Aleph::ArrayHeap< T, Compare >::traverse(), Aleph::ArrayQueue< T >::traverse(), Aleph::FixedQueue< T >::traverse(), Aleph::ArrayStack< T >::traverse(), Aleph::FixedStack< T >::traverse(), Aleph::DynArray< T >::traverse(), Aleph::DynArrayHeap< T, Compare >::traverse(), Aleph::DynListQueue< T >::traverse(), Aleph::DynListStack< T >::traverse(), Aleph::DynMatrix< T >::traverse(), Aleph::MemArray< T >::traverse(), Aleph::Random_Set< T >::traverse(), Aleph::TraverseMixin< Derived, Type >::traverse(), Aleph::TraverseMixin< Derived, Type >::traverse(), Aleph::FlatMap< Key, T, Compare >::traverse(), Aleph::RingBuffer< T >::traverse(), Aleph::SmallVector< T, N >::traverse(), Aleph::FlatMap< Key, T, Compare >::traverse(), Aleph::FlatSet< Key, Compare >::traverse(), Aleph::RingBuffer< T >::traverse(), Aleph::SmallVector< T, N >::traverse(), Aleph::Graph_Traverse_Generator< GT, Itor, Q, Show_Arc >::traverse(), Aleph::DynMatrix< T >::traverse_allocated(), Aleph::DynMatrix< T >::traverse_allocated(), Aleph::traverse_arcs(), Aleph::ArrayHeap< T, Compare >::traverse_impl(), Aleph::traverse_in_arcs(), Aleph::traverse_out_arcs(), Aleph::traverse_perm(), RandomTreeTest::tree_height(), Aleph::tree_max_distance(), Aleph::tree_postorder_traversal(), Aleph::tree_preorder_traversal(), Aleph::tree_subtree_sizes(), Aleph::tree_sum_of_distances(), Aleph::tree_to_bits(), Aleph::Tree_Node< T >::trees(), Aleph::CA::tri_parity(), Aleph::CA::tri_pixel_centre(), Aleph::CA::ca_svg_detail::tri_points(), triangle_area(), Aleph::GeomBowyerWatsonUtils::triangulate(), Aleph::MonotonePolygonTriangulation::triangulate_monotone(), Aleph::VoronoiDiagramFortune::triangulate_sweep(), TimeoutQueue::triggerEvent(), Aleph::trim(), Aleph::FFT< Real >::trim_leading_zeros_copy(), Aleph::FFT< Real >::trim_polynomial_leading_zeros(), Aleph::FFT< Real >::trim_to_size(), Aleph::NTT< MOD, ROOT >::trim_trailing_zeros(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::truncate(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::truncate(), Aleph::NTT< MOD, ROOT >::truncate_poly(), Aleph::FFT< Real >::try_aberth_ehrlich_roots(), Aleph::Rope< Char, LeafSize >::try_absorb_left(), Aleph::Rope< Char, LeafSize >::try_absorb_right(), Aleph::try_char(), Aleph::Gen_Polynomial< Coefficient >::try_divide_by_linear_factor(), Aleph::FFT< Real >::try_durand_kerner_roots(), Aleph::ThreadPool::try_enqueue(), Aleph::ThreadPool::try_enqueue_detached(), Aleph::Gen_Polynomial< Coefficient >::try_exact_candidate_division(), Aleph::Gen_Polynomial< Coefficient >::try_extract_primitive_cubic_factor(), Aleph::Gen_Polynomial< Coefficient >::try_extract_primitive_quadratic_factor(), Aleph::Gen_Polynomial< Coefficient >::try_extract_rational_linear_factor(), Aleph::Array_Graph< __Graph_Node, __Graph_Arc >::try_insert_arc(), Aleph::FFT< Real >::try_laguerre_roots(), Aleph::CA::ca_io_detail::try_parse(), Aleph::SpscQueue< T >::try_pop(), Aleph::CA::try_read_life_105(), Aleph::CA::try_read_life_106(), Aleph::CA::try_read_plaintext(), Aleph::CA::try_read_rle(), Aleph::BoundedChannel< T >::try_recv(), Aleph::stl_detail::try_reserve(), Aleph::BoundedChannel< T >::try_send(), Aleph::BoundedChannel< T >::try_send(), Aleph::tuple_for_each(), Aleph::tuple_for_each(), Aleph::tuple_to_array(), Aleph::tuple_to_container(), Aleph::tuple_to_dynlist(), Aleph::FFT< Real >::twiddle_at(), Aleph::Compiler_C_Backend::Emitter::type_comment(), Aleph::CA::ca_checkpoint_detail::type_hash(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST(), TYPED_TEST_P(), TYPED_TEST_P(), TYPED_TEST_P(), TYPED_TEST_P(), TYPED_TEST_P(), TYPED_TEST_P(), TYPED_TEST_P(), TYPED_TEST_P(), TYPED_TEST_P(), TYPED_TEST_P(), TYPED_TEST_P(), TYPED_TEST_P(), TYPED_TEST_P(), TYPED_TEST_P(), TYPED_TEST_P(), TYPED_TEST_P(), TYPED_TEST_P(), TYPED_TEST_P(), Aleph::tzip(), Aleph::tzip_longest(), Aleph::tzip_std(), Aleph::tzipEq(), Aleph::ArenaTreeAllocator< Node >::unalloc(), Aleph::uni_all(), Aleph::uni_compare(), Aleph::uni_concat(), Aleph::uni_count(), Aleph::uni_drop_while(), Aleph::uni_equal(), Aleph::uni_exists(), Aleph::uni_filter(), Aleph::uni_filteri(), Aleph::uni_find(), Aleph::uni_find_index(), Aleph::uni_find_mapi(), Aleph::uni_first(), Aleph::uni_flat_map(), Aleph::uni_flatten(), Aleph::uni_foldl(), Aleph::uni_for_each(), Aleph::uni_for_each_indexed(), Aleph::uni_group_by(), Aleph::uni_map(), Aleph::uni_mapi(), Aleph::uni_max(), Aleph::uni_min(), Aleph::uni_min_max(), Aleph::uni_none(), Aleph::uni_partition(), Aleph::uni_product(), Aleph::uni_scan_left(), Aleph::uni_take_while(), Aleph::uni_tally(), Aleph::uni_unzip(), Aleph::uni_unzip_tuple(), Aleph::uni_zip(), Aleph::uni_zip_all(), Aleph::uni_zip_all_eq(), Aleph::uni_zip_any(), Aleph::uni_zip_assoc(), Aleph::uni_zip_count(), Aleph::uni_zip_drop(), Aleph::uni_zip_drop_while(), Aleph::uni_zip_equal_by(), Aleph::uni_zip_equal_length(), Aleph::uni_zip_exists(), Aleph::uni_zip_filter(), Aleph::uni_zip_filteri(), Aleph::uni_zip_find_first(), Aleph::uni_zip_find_mapi(), Aleph::uni_zip_first(), Aleph::uni_zip_foldl(), Aleph::uni_zip_for_each(), Aleph::uni_zip_for_each_indexed(), Aleph::uni_zip_it(), Aleph::uni_zip_last(), Aleph::uni_zip_length(), Aleph::uni_zip_map(), Aleph::uni_zip_mapi(), Aleph::uni_zip_max(), Aleph::uni_zip_mem(), Aleph::uni_zip_min(), Aleph::uni_zip_min_max(), Aleph::uni_zip_none(), Aleph::uni_zip_nth(), Aleph::uni_zip_partition(), Aleph::uni_zip_reduce(), Aleph::uni_zip_scan_left(), Aleph::uni_zip_take(), Aleph::uni_zip_take_while(), Aleph::uni_zip_to_dynlist(), Aleph::uni_zip_to_vector(), Aleph::uni_zip_traverse(), Aleph::CA::uniform_int(), Aleph::CA::uniform_unit(), Aleph::Compiler_Type_Unifier::unify(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::uninit(), Aleph::Shortest_Path_Base< GT, Distance, Itor, SA, HeapT >::uninit(), Aleph::Dial_Min_Paths< GT, Distance, Itor, SA >::uninit_discard(), Aleph::Dial_Min_Paths< GT, Distance, Itor, SA >::uninit_paint(), Aleph::Zero_One_BFS< GT, Distance, Itor, SA >::uninit_paint(), Aleph::unique(), Aleph::unique(), Aleph::FunctionalMixin< Derived, Type >::unique_by(), Aleph::unique_copy(), Aleph::unique_copy(), Aleph::KDTreePointSearch::unique_points(), Aleph::DelaunayTriangulationBowyerWatson::unique_points(), Aleph::unique_sequential(), Aleph::RegularTriangulationBowyerWatson::unique_sites(), Aleph::Compiler_Dataflow_Detail::unit_constant(), UseMutex::unlock(), Aleph::Net_Graph< NodeT, ArcT >::unmake_super_sink(), Aleph::Net_Graph< NodeT, ArcT >::unmake_super_source(), Aleph::detail::Pid_File_Lock::unregister_path(), Aleph::FFT< Real >::unwrap_phase(), Aleph::unzip(), Aleph::HyperLogLog< T >::update(), Aleph::MinHash< T >::update(), Aleph::Reservoir_Sampler< T >::update(), Aleph::SimHash< T >::update(), Aleph::Count_Min_Sketch< T, CounterT >::update(), Aleph::MinHash< T >::update(), Aleph::SimHash< T >::update(), Aleph::Reservoir_Sampler< T >::update(), Aleph::Range_Fenwick_Tree< T >::update(), Aleph::ArrayHeap< T, Compare >::update(), Aleph::Karger_Min_Cut< GT, SA >::update_arcs(), Aleph::RevisedSimplex< T >::update_basis_inverse(), Aleph::CA::Parallel_Synchronous_Engine< Lattice, Rule, Neighborhood, Order >::update_cell(), Aleph::BinTreeXt_Iterator< TreeType, Node, Key, Compare >::update_curr(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::Iterator::update_curr(), Aleph::update_flow(), Aleph::Huffman_Encoder_Engine::update_freq(), Aleph::FFT< Real >::OverlapSave::update_history(), Aleph::Gen_Segment_Tree< T, Op >::update_impl(), Aleph::Gen_Lazy_Segment_Tree< Policy >::update_impl(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::update_max(), Aleph::TrapezoidalMapPointLocation::update_neighbor(), Aleph::Random_Graph< GT, Init_Node, Init_Arc >::update_parity_after_arc_insertion(), Aleph::Random_Digraph< GT, Init_Node, Init_Arc >::update_parity_after_arc_insertion(), Aleph::BinTreeXt_Iterator< TreeType, Node, Key, Compare >::update_pos(), Aleph::Gen_Treap_Rk< NodeType, Key, Compare >::Iterator::update_pos(), Aleph::Simplex< T >::update_rhs_and_reoptimize(), Aleph::CA::Parallel_Synchronous_Engine< Lattice, Rule, Neighborhood, Order >::update_slab_1d(), Aleph::CA::Parallel_Synchronous_Engine< Lattice, Rule, Neighborhood, Order >::update_slab_2d_row_major(), Aleph::CA::Parallel_Synchronous_Engine< Lattice, Rule, Neighborhood, Order >::update_slab_2d_tile(), Aleph::CA::Parallel_Synchronous_Engine< Lattice, Rule, Neighborhood, Order >::update_slab_3d_row_major(), Aleph::GenTdRbTreeRk< NodeType, Key, Compare >::updateCountRec(), Aleph::FFT< Real >::upfirdn(), Aleph::FFT< Real >::upfirdn(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::upper_bound(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::upper_bound(), Aleph::Gen_File_B_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::upper_bound(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::upper_bound(), Aleph::Gen_File_BPlus_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::upper_bound(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::upper_bound(), Aleph::upper_bound(), Aleph::upper_bound(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::upper_bound_index(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::upper_bound_index(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::upper_bound_index(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::upper_bound_index(), Aleph::lis_detail::upper_bound_pos(), Aleph::RangeTree2D::upper_bound_x(), Aleph::RangeTree2D::upper_bound_y(), Aleph::HalfPlaneIntersection::upper_half(), Aleph::Compiler_Backend_C_Detail::upper_identifier(), Aleph::FlatMap< Key, T, Compare >::upper_idx(), Aleph::FlatSet< Key, Compare >::upper_idx(), usage(), usage(), usage(), usage(), usage(), usage(), Aleph::parallel_detail::use_sequential_path(), Aleph::ODhashTable< Key, Cmp >::Bucket::valid(), Aleph::valid_day(), Aleph::valid_month(), Aleph::validate_bytecode_function(), Aleph::validate_bytecode_module(), Aleph::validate_cfg_function(), Aleph::validate_cfg_module(), Aleph::tree_decomposition_detail::Rooted_Tree_Topology< GT, SA >::validate_connected_acyclic(), Aleph::validate_dataflow_analysis(), Aleph::validate_dead_code_elimination(), Aleph::min_mean_cycle_detail::validate_finite_accumulator(), Aleph::Karger_Min_Cut< GT, SA >::validate_graph(), Aleph::hld_detail::HLD_Tree_Data< GT, SA >::validate_id(), Aleph::lca_detail::Rooted_Tree_Data< GT, SA >::validate_id(), Aleph::tree_decomposition_detail::Rooted_Tree_Topology< GT, SA >::validate_id(), Aleph::Compiler_C_Backend::Emitter::validate_input(), Aleph::NTTExact::validate_inputs(), Aleph::validate_ir_function(), Aleph::validate_ir_module(), Aleph::FFT< Real >::validate_istft_configuration(), Aleph::FFT< Real >::validate_no_near_pole_zero_cancellation(), Aleph::FFT< Real >::validate_no_near_pole_zero_cancellation(), Aleph::k_shortest_paths_detail::validate_non_negative_weights(), Aleph::validate_nonplanar_certificate(), Aleph::Alpha_Beta< Domain >::validate_ordering_configuration(), Aleph::FFT< Real >::validate_overlap_constraints(), RingFileCache< T >::Pointer::validate_position(), Aleph::Ellipse::validate_positive_radii(), Aleph::RotatedEllipse::validate_positive_radii(), Aleph::FFT< Real >::validate_real_spectrum(), Aleph::NTT< MOD, ROOT >::validate_root_order(), Aleph::validate_ssa_function(), Aleph::validate_ssa_module(), Aleph::FFT< Real >::validate_stable(), Aleph::FFT< Real >::validate_stable(), Aleph::FFT< Real >::validate_stable(), Aleph::FFT< Real >::validate_stable(), Aleph::FFT< Real >::validate_stable(), Aleph::FFT< Real >::validate_stable(), Aleph::FFT< Real >::validate_stable(), Aleph::FFT< Real >::validate_stable(), Aleph::FFT< Real >::validate_stable(), Aleph::NTT< MOD, ROOT >::validate_supported_size(), Aleph::Compiler_Line_Frontend::validate_top_level_calls(), Aleph::Compiler_Typed_Semantic_Analyzer::validate_unique_member_name(), Aleph::min_mean_cycle_detail::validate_weights(), Aleph::expected< T, E >::value(), Aleph::expected< void, E >::value(), Aleph::expected< T, E >::value(), Aleph::Convex_Hull_Trick< T >::Line::value_at(), Aleph::Li_Chao_Tree< T >::Line::value_at(), Aleph::Compiler_Dataflow_Detail::value_constant(), Aleph::Gen_Cartesian_Tree< T, Comp >::values(), Aleph::Gen_Disjoint_Sparse_Table< T, Op >::values(), Aleph::MapOpenHash< Key, Data, Cmp, HashTable >::values(), Aleph::DynMapTree< Key, Data, Tree, Compare >::values(), Aleph::DynMapHashTable< Key, Data, HashTable, Cmp >::values(), Aleph::Gen_Fenwick_Tree< T, Plus, Minus >::values(), Aleph::Range_Fenwick_Tree< T >::values(), Aleph::Gen_File_B_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::values(), Aleph::Gen_File_BPlus_Map< Key, Value, Compare, MinDegree, KeyCodec, ValueCodec >::values(), Aleph::FlatMap< Key, T, Compare >::values(), Aleph::Gen_Segment_Tree< T, Op >::values(), Aleph::Gen_Lazy_Segment_Tree< Policy >::values(), Aleph::Segment_Tree_Beats< T >::values(), Aleph::Gen_Sparse_Table< T, Op >::values(), Aleph::MapOpenHash< Key, Data, Cmp, HashTable >::values_ptr(), Aleph::DynMapTree< Key, Data, Tree, Compare >::values_ptr(), Aleph::DynMapHashTable< Key, Data, HashTable, Cmp >::values_ptr(), Aleph::MCF_LP_Solver< Net >::var_index(), Aleph::Gen_MultiPolynomial< Coefficient, MonomOrder >::variable(), Aleph::variadic_to_DynList(), Aleph::variadic_to_vector(), Aleph::variance(), Aleph::Matrix< Trow, Tcol, NumType >::vector_matrix_mult(), Aleph::vector_to_Array(), Aleph::vector_to_Array(), Aleph::vector_to_DynArray(), Aleph::vector_to_DynArray(), Aleph::vector_to_DynDlist(), Aleph::vector_to_DynDlist(), Aleph::vector_to_DynList(), Aleph::vector_to_DynList(), Aleph::vector_to_DynSetTree(), verify(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::verify(), Aleph::GenBinTree< NodeType, Key, Compare >::verify(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::verify(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::verify(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::verify(), Aleph::Gen_Interval_Tree< NodeType, T, Compare >::verify(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::verify(), Aleph::RadixTree< T, Char >::verify(), Aleph::PersistentVector< T >::verify(), Aleph::GenTdRbTree< NodeType, Key, Compare >::verify(), verify_assignment(), verify_bipartition(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingVerifier< WeightType >::verify_blossoms_and_calc_edge_duals(), Aleph::verify_container_and_iterator(), Aleph::verify_container_and_iterators(), Aleph::verify_container_and_iterators(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingVerifier< WeightType >::verify_edge_slack(), verify_flow_conservation(), Aleph::GenBinHeap< NodeType, Key, Compare >::verify_heap(), verify_heap_property(), Aleph::verify_iterators(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::verify_leaf_chain(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::verify_leaf_chain(), verify_matching(), Aleph::Gen_B_Tree< Key, Compare, MinDegree >::verify_node(), Aleph::Gen_BPlus_Tree< Key, Compare, MinDegree >::verify_node(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::verify_node(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::verify_node(), verify_permutation(), Pointer_Table::verify_pointer(), Aleph::RTree< Payload, MaxEntries, MinEntries, Variant >::verify_rec(), Aleph::Rope< Char, LeafSize >::verify_rec(), Aleph::RadixTree< T, Char >::verify_rec(), Aleph::detail::PersistentTreapNodeOps< Node, Key, Compare >::verify_rec(), Aleph::PersistentHashMap< Key, T, Cmp >::verify_rec(), Aleph::Simplex< T >::verify_solution(), verify_sort(), verify_sort(), Aleph::Random_Digraph< GT, Init_Node, Init_Arc >::verify_tables(), Aleph::Network_Simplex< Net >::verify_tree_integrity(), Aleph::Network_Simplex< Net >::verify_tree_reduced_costs(), Aleph::blossom_weighted_detail::mwmatching::impl::MatchingVerifier< WeightType >::verify_vertex_mate(), Aleph::GenBinTree< NodeType, Key, Compare >::verifyBin(), Aleph::vertex_connectivity(), Aleph::CA::Hashlife_Engine::visit_alive(), visitar_df(), visitar_low(), visual_demonstration(), Aleph::Tikz_Scene::visualize_aabb_tree(), Aleph::visualize_aabb_tree(), Aleph::Tikz_Scene::visualize_aabb_tree_query(), Aleph::visualize_aabb_tree_query(), Aleph::Tikz_Scene::visualize_alpha_shape(), Aleph::Tikz_Scene::visualize_boolean_operation(), Aleph::visualize_chaikin_smoothing(), Aleph::Tikz_Scene::visualize_closest_pair(), Aleph::Tikz_Scene::visualize_convex_decomposition(), Aleph::Tikz_Scene::visualize_convex_hull(), Aleph::visualize_convex_hull(), Aleph::Tikz_Scene::visualize_convex_intersection(), Aleph::Tikz_Scene::visualize_delaunay(), Aleph::Tikz_Scene::visualize_half_plane_intersection(), Aleph::Tikz_Scene::visualize_kdtree_partitions(), Aleph::visualize_kdtree_partitions(), Aleph::Tikz_Scene::visualize_line_sweep(), Aleph::Tikz_Scene::visualize_minkowski_sum(), Aleph::Tikz_Scene::visualize_monotone_triangulation(), Aleph::Tikz_Scene::visualize_power_diagram(), Aleph::Tikz_Scene::visualize_range_tree(), Aleph::visualize_range_tree(), Aleph::Tikz_Scene::visualize_range_tree_query(), Aleph::visualize_range_tree_query(), Aleph::Tikz_Scene::visualize_regular_triangulation(), Aleph::Tikz_Scene::visualize_rotating_calipers(), Aleph::visualize_rotating_calipers(), Aleph::visualize_rtree(), Aleph::visualize_rtree_query(), Aleph::Tikz_Scene::visualize_segment_arrangement(), Aleph::Tikz_Scene::visualize_shortest_path_in_polygon(), Aleph::Tikz_Scene::visualize_shortest_path_with_portals(), visualize_structure(), Aleph::visualize_trapezoidal_map(), Aleph::visualize_trapezoidal_map(), Aleph::Tikz_Scene::visualize_visibility_polygon(), Aleph::Tikz_Scene::visualize_voronoi(), Aleph::List_Graph< _Graph_Node, _Graph_Arc >::void_to_arc(), Aleph::CA::ca_neighborhood_detail::von_neumann_count(), Aleph::CA::ca_vtk_detail::vtk_scalar_type(), Aleph::ThreadPool::wait_all(), Aleph::ThreadPool::wait_all_until(), wait_for_status(), wait_until(), TimeoutQueue::wait_until_empty(), Aleph::Testing::Deterministic_Start_Gate::wait_until_ready(), Aleph::BoundedChannel< T >::wait_with_cancellation(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::wal_header_checksum(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::wal_header_checksum(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::wal_record_bytes(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::wal_record_bytes(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::wal_record_checksum_add(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::wal_record_checksum_add(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::wal_record_checksum_add_v2(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::wal_record_checksum_add_v2(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::wal_record_checksum_add_v3(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::wal_record_checksum_add_v3(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::wal_record_format_version(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::wal_record_format_version(), Aleph::warshall_compute_transitive_clausure(), Aleph::CA::Kernel2D< T, Rows, Cols >::weight_at_offset(), Aleph::welsh_powell_coloring(), Aleph::MinimumEnclosingCircle::welzl_iterative(), west_offset(), Aleph::FFT< Real >::window_coherent_gain(), Aleph::FFT< Real >::window_enbw(), Aleph::FFT< Real >::window_overlap_profile(), Aleph::with_clean_cookies(), Aleph::Synchronized< T, Mutex >::with_lock(), Aleph::Synchronized< T, Mutex >::with_lock(), Aleph::RwSynchronized< T, SharedMutex >::with_read_lock(), Aleph::with_saved_cookies(), Aleph::ConcurrentHashMap< Key, T, Cmp, Shards >::with_value(), Aleph::ConcurrentHashMap< Key, T, Cmp, Shards >::with_value_mut(), Aleph::RwSynchronized< T, SharedMutex >::with_write_lock(), Aleph::Prefix_Tree::words(), Aleph::Prefix_Tree_Map< T >::words(), Aleph::Cnode::words(), Aleph::Cnode::words_impl(), Aleph::Prefix_Tree_Map< T >::Node::words_impl(), Aleph::Prefix_Tree_Map< T >::words_with_prefix(), Aleph::Cnode::words_with_prefix(), Aleph::Prefix_Tree::words_with_prefix(), WorkersSet< WorkerFct >::worker_handler(), Aleph::ThreadPool::worker_loop(), Aleph::Dlink::wrap_header(), Aleph::CA::ca_lattice_detail::wrap_into_range(), write_avl(), write_bin(), Aleph::Byte::write_bit(), Aleph::CA::Multi_Field_Engine< Lattice, Rule, Neighborhood >::write_cell(), Aleph::CA::ca_png_detail::write_chunk(), write_colored_node(), write_coloring_dot(), write_df_low_tree(), write_freq(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::write_full_image(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::write_full_image(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::write_full_image_to_path(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::write_full_image_to_path(), Aleph::Compiler_Bytecode_VM::write_global(), Aleph::Xml_Graph< GT, Node_Reader, Arc_Reader, Node_Writer, Arc_Writer >::write_graph(), Aleph::CA::Reproductions::write_gray_scott_png(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::write_header_to_storage(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::write_header_to_storage(), Aleph::CA::Reproductions::write_histogram_csv(), Aleph::CA::ca_checkpoint_detail::write_le(), write_leaves(), Log_Manager::write_line(), Aleph::Compiler_Bytecode_VM::write_local(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::write_native_key(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::write_native_key(), Aleph::CA::write_npy(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::write_page_record(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::write_page_record(), Aleph::CA::ca_npy_detail::write_payload_rec(), Aleph::CA::ca_svg_detail::write_points(), write_polygon_wkt(), write_polygon_wkt(), write_polygon_wkt(), write_prefix(), write_rand(), write_rb(), Aleph::Compiler_Bytecode_VM::write_register(), Aleph::CA::ca_npy_detail::write_scalar(), Aleph::CA::ca_vtk_detail::write_scalar(), write_splay(), Aleph::CA::ca_svg_detail::write_style(), Aleph::CA::ca_svg_detail::write_svg_header(), Static_Event_Table< Signature >::write_table(), Dynamic_Event_Table< Signature >::write_table(), Aleph::CA::ca_io_detail::write_text_scalar(), Aleph::CA::Tile_Cache< State, TileSide >::write_tile_to_disk(), write_treap(), write_tree(), write_verse(), Aleph::Gen_File_B_Tree< Key, Compare, MinDegree, Codec >::write_wal_to_path(), Aleph::Gen_File_BPlus_Tree< Key, Compare, MinDegree, Codec >::write_wal_to_path(), Aleph::wyhash_hash(), Aleph::wyhash_hash(), Aleph::Gen_Polynomial< Coefficient >::x_to(), Aleph::Gen_Polynomial< Coefficient >::xgcd(), Aleph::TestVisual::xml_escape(), Aleph::planarity_detail::xml_escape_string(), Aleph::xxh64_merge_round(), Aleph::xxh64_round(), Aleph::xxhash64_hash(), Aleph::xxhash64_hash(), Aleph::yen_k_shortest_paths(), Aleph::Gen_Polynomial< Coefficient >::yun_sfd(), Aleph::z_algorithm(), Aleph::z_search(), Aleph::FFT< Real >::zero_pad_edges(), Aleph::FFT< Real >::zero_padded_copy(), Aleph::FFT< Real >::zero_padded_copy(), Aleph::FFT< Real >::PartitionedConvolver::zero_spectrum(), Aleph::FFT< Real >::zeros(), Aleph::FFT< Real >::zeros(), Aleph::FFT< Real >::zeros(), Aleph::zip(), Aleph::zip_all(), Aleph::zip_all_short(), Aleph::zip_any(), Aleph::zip_cmp(), Aleph::zip_count(), Aleph::zip_drop(), Aleph::zip_drop_while(), Aleph::zip_exists(), Aleph::zip_filter(), Aleph::zip_filter_eq(), Aleph::zip_find_first(), Aleph::zip_find_index(), Aleph::zip_find_last(), Aleph::zip_first(), Aleph::zip_foldl(), Aleph::zip_foldl_eq(), Aleph::zip_for_each(), Aleph::zip_for_each_eq(), Aleph::zip_for_each_indexed(), Aleph::zip_for_each_indexed_eq(), Aleph::zip_forall(), Aleph::zip_forall_short(), Aleph::zip_it(), Aleph::zip_it_pos(), Aleph::zip_length(), Aleph::zip_lists(), Aleph::zip_lists_eq(), Aleph::zip_longest(), Aleph::zip_longest_opt(), Aleph::zip_map(), Aleph::zip_map_eq(), Aleph::zip_maps(), Aleph::zip_maps_eq(), Aleph::zip_maps_if(), Aleph::zip_maps_if_eq(), Aleph::zip_none(), Aleph::zip_nth(), Aleph::zip_partition(), Aleph::zip_take(), Aleph::zip_take_while(), Aleph::zip_transform(), Aleph::zip_transform_eq(), Aleph::zip_traverse(), Aleph::zip_traverse_eq(), Aleph::FunctionalMixin< Derived, Type >::zip_with(), Aleph::zipEq(), and Aleph::CA::ca_png_detail::zlib_store().

blossom_maximum_weight_matching()

template<AlephGraph GT, class Weight = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

Blossom_Weighted_Result< long long > Aleph::blossom_maximum_weight_matching	(	const GT &	g,
		DynDlist< typename GT::Arc * > &	matching,
		Weight	weight = Weight(),
		SA	sa = SA(),
		const bool	max_cardinality = false
	)

Alias for compute_maximum_weight_general_matching().

Parameters

[in]	g	Graph (must be undirected).
[out]	matching	Output list where the selected matching arcs will be stored.
[in]	weight	Weight accessor functor. Defaults to Dft_Dist<GT>.
[in]	sa	Arc filter for graph traversal.
[in]	max_cardinality	If true, optimize lexicographically: maximum cardinality first, then maximum weight.

Returns

A Blossom_Weighted_Result structure containing the total weight and cardinality.

Exceptions

domain_error	If `g` is a digraph.
overflow_error	If weights exceed `long long` limits or the number of nodes exceeds the internal solver's limit.

Definition at line 374 of file Blossom_Weighted.H.

References Aleph::blossom_maximum_cardinality_matching().

Referenced by TEST().

blossom_minimum_cost_matching()

template<AlephGraph GT, class Cost = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

Min_Cost_Matching_Result< long long > Aleph::blossom_minimum_cost_matching	(	const GT &	g,
		DynDlist< typename GT::Arc * > &	matching,
		Cost	cost = Cost(),
		SA	sa = SA(),
		const bool	max_cardinality = false
	)

Alias for compute_minimum_cost_general_matching().

Keeps the explicit blossom naming at call sites.

Definition at line 285 of file Min_Cost_Matching.H.

References Aleph::blossom_maximum_cardinality_matching().

blossom_minimum_cost_perfect_matching()

template<AlephGraph GT, class Cost = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

Min_Cost_Perfect_Matching_Result< long long > Aleph::blossom_minimum_cost_perfect_matching	(	const GT &	g,
		DynDlist< typename GT::Arc * > &	matching,
		Cost	cost = Cost(),
		SA	sa = SA()
	)

Alias for compute_minimum_cost_perfect_general_matching().

Keeps the explicit blossom naming at call sites.

Definition at line 362 of file Min_Cost_Matching.H.

References Aleph::blossom_maximum_cardinality_matching().

breadth_first_traversal()

template<AlephGraph GT>

size_t Aleph::breadth_first_traversal ( const GT &  g, typename GT::Node *  start, bool(*)(const GT &, typename GT::Node *, typename GT::Arc *)  visit  )

inline

Breadth-first traversal starting from a given node.

Traverses the connected component reachable from start in breadth-first order.

The callback must have the following signature: bool visit(const GT& g, typename GT::Node* curr, typename GT::Arc* from).

from is the arc that discovered curr (nullptr for the start node). If visit returns true, the traversal stops early. If visit is nullptr, no callback is executed.

Template Parameters

GT	Graph type.

Parameters

[in]	g	Graph to traverse.
[in]	start	Starting node (must be non-null and belong to g).
[in]	visit	Optional visit callback (may be nullptr).

Returns

Number of discovered nodes.

Note

Resets the Breadth_First control bit on all nodes and arcs.

Uses the Breadth_First control bit on both nodes and arcs.

See also

breadth_first_traversal(const GT&, bool (*)(...)), depth_first_traversal, Breadth_First_Traversal

Definition at line 328 of file tpl_graph_utils.H.

References Aleph::and, ARC_BITS, Aleph::blossom_maximum_cardinality_matching(), Aleph::Breadth_First, Aleph::DynListQueue< T >::get(), GraphCommon< GT, Node, Arc >::get_arc_it(), GraphCommon< GT, Node, Arc >::get_num_nodes(), GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), IS_ARC_VISITED, Aleph::DynListQueue< T >::is_empty(), IS_NODE_VISITED, NODE_BITS, Aleph::DynListQueue< T >::put(), GraphCommon< GT, Node, Arc >::reset_bit_arcs(), and GraphCommon< GT, Node, Arc >::reset_bit_nodes().

Referenced by Aleph::breadth_first_traversal(), TEST(), TEST(), and TEST().

build_dominator_tree()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

void Aleph::build_dominator_tree	(	GT &	g,
		typename GT::Node *	root,
		GT &	tree,
		SA	sa = SA()
	)

Build the dominator tree of a digraph.

Convenience free function wrapping Lengauer_Tarjan_Dominators.

Template Parameters

GT	Graph type (must be directed).
SA	Arc filter type.

Parameters

	g	The directed graph.
	root	Root node.
[out]	tree	Output dominator tree (cleared first). Nodes are mapped to the original graph via GT::map_nodes.
	sa	Arc filter.

See also

Lengauer_Tarjan_Dominators

Definition at line 659 of file Dominators.H.

References Aleph::blossom_maximum_cardinality_matching(), and root().

Referenced by TEST(), TEST(), TEST(), and TEST().

build_planar_dual_graph() [1/2]

template<AlephGraph GT, class DGT = Default_Planar_Dual_Graph<GT>>

DGT Aleph::build_planar_dual_graph

(

const Planar_Dual_Metadata< GT > &

md

)

Build an Aleph dual graph from face/dual metadata.

Definition at line 2957 of file Planarity_Test.H.

References ah_runtime_error_unless, Aleph::blossom_maximum_cardinality_matching(), and Aleph::Array< T >::reserve().

build_planar_dual_graph() [2/2]

template<AlephGraph GT, class DGT = Default_Planar_Dual_Graph<GT>>

DGT Aleph::build_planar_dual_graph

(

const Planarity_Test_Result< GT > &

result

)

Build an Aleph dual graph directly from a planarity result.

Definition at line 2984 of file Planarity_Test.H.

References Aleph::blossom_maximum_cardinality_matching(), and Aleph::planar_dual_metadata().

build_post_dominator_tree()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

void Aleph::build_post_dominator_tree	(	const GT &	g,
		typename GT::Node *	exit_node,
		GT &	tree,
		SA	sa = SA()
	)

Build the post-dominator tree of a digraph.

Convenience free function wrapping Lengauer_Tarjan_Post_Dominators.

Template Parameters

GT	Graph type (must be directed).
SA	Arc filter type.

Parameters

	g	The directed graph.
	exit_node	Exit node.
[out]	tree	Output post-dominator tree (cleared first). Nodes are mapped to the original graph via GT::map_nodes.
	sa	Arc filter.

See also

Lengauer_Tarjan_Post_Dominators

Definition at line 1071 of file Dominators.H.

References Aleph::blossom_maximum_cardinality_matching().

Referenced by TEST().

build_spanning_tree()

template<AlephGraph GT>

GT Aleph::build_spanning_tree

(

const DynArray< typename GT::Arc * > &

arcs

)

Build a graph from a list of arcs (typically a spanning tree).

Builds a new graph ret containing every arc in arcs (skipping null entries). Nodes are created on demand.

Mapping:

• Each node created in ret stores the original node pointer in its cookie.
• Each arc created in ret stores the original arc pointer in its cookie.

Note

This is a one-way mapping (ret → original). The original graph is not modified.

Parameters

[in]

arcs

Dynamic array containing the arcs to insert.

Returns

A graph containing exactly the arcs provided in arcs.

Exceptions

bad_alloc

If there is not enough memory.

Definition at line 1241 of file tpl_graph_utils.H.

References ARC_COOKIE, arcs, Aleph::blossom_maximum_cardinality_matching(), FunctionalMethods< Container, T >::for_each(), Aleph::DynMapTree< Key, Data, Tree, Compare >::insert(), NODE_COOKIE, and Aleph::DynMapTree< Key, Data, Tree, Compare >::search().

build_subgraph()

template<AlephGraph GT>

void Aleph::build_subgraph ( const GT &  g, GT &  sg, typename GT::Node *  g_src, size_t &  node_count  )

inline

Forward declaration for build_subgraph().

Build a mapped subgraph from a starting node.

Traverses g in depth-first order starting at g_src, copying every reachable node and arc into sg.

node_count accumulates the number of visited nodes across repeated calls (useful when building all components).

Note

Uses the Build_Subtree control bit on both nodes and arcs.

Uses cookies to map nodes/arcs between g and sg.

Parameters

[in]	g	Original graph.
[out]	sg	Destination graph (expected to be initially empty).
[in]	g_src	Starting node in g (must be non-null and belong to g).
[in,out]	node_count	Visited node counter.

Exceptions

bad_alloc

If there is not enough memory.

See also

inconnected_components(), copy_graph()

Definition at line 999 of file tpl_graph_utils.H.

References Aleph::and, ARC_BITS, Aleph::blossom_maximum_cardinality_matching(), Aleph::build_subgraph(), Aleph::Build_Subtree, GraphCommon< GT, Node, Arc >::get_arc_it(), GTArcCommon< ArcInfo >::get_info(), GraphCommon< GT, Node, Arc >::get_num_nodes(), Aleph::List_Graph< _Graph_Node, _Graph_Arc >::insert_arc(), Aleph::List_Graph< _Graph_Node, _Graph_Arc >::insert_node(), IS_ARC_VISITED, IS_NODE_VISITED, GraphCommon< GT, Node, Arc >::map_arcs(), GraphCommon< GT, Node, Arc >::map_nodes(), and NODE_BITS.

Referenced by Aleph::build_subgraph(), Aleph::inconnected_components(), and TEST().

chromatic_number()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

size_t Aleph::chromatic_number	(	const GT &	g,
		DynMapTree< typename GT::Node *, size_t > &	colors
	)

Computes the exact chromatic number of a small graph.

Uses DSatur to obtain an upper bound, then performs binary search with backtracking to find the minimum \(k\)for which a valid \(k\)-coloring exists. Applicable only to graphs with at most 64 nodes.

Template Parameters

GT	Graph type (List_Graph, List_Digraph, Array_Graph, …).
SA	Arc-filter functor (defaults to Dft_Show_Arc<GT>).

Parameters

[in]	g	Input graph. Must have at most 64 nodes and no self-loops.
[out]	colors	Output map from GT::Node* to 0-based color index for an optimal coloring. Cleared and overwritten on entry.

Returns

The chromatic number \(\chi(G)\)(0 for an empty graph, 1 if the graph has no edges).

Exceptions

std::domain_error

if g has more than 64 nodes or contains a self-loop.

Precondition

g.get_num_nodes() <= 64 and no self-loops in g.

Note

Complexity: Exponential in the worst case (backtracking over all \(k\)-colorings). Practical for graphs up to ~30–40 nodes.

Thread safety: not thread-safe. Temporarily writes to NODE_COOKIE on every node; saved and restored via Cookie_Saver before the function returns.

See also

dsatur_coloring

Definition at line 508 of file Graph_Coloring.H.

References ah_domain_error_if, Aleph::and, Aleph::DynList< T >::append(), Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_arc_it(), LocateFunctions< Container, Type >::get_it(), GraphCommon< GT, Node, Arc >::get_node_it(), GraphCommon< GT, Node, Arc >::get_num_nodes(), GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), k, NODE_COOKIE, nodes, and Aleph::HTList::size().

Referenced by demo_algorithm_comparison(), demo_exam_scheduling(), demo_register_allocation(), main(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

clear_graph()

template<AlephGraph GT>

void Aleph::clear_graph ( GT &  g )

inlinenoexcept

Clean a graph: all its nodes and arcs are removed and freed.

Parameters

[in]

g

the graph

Definition at line 3659 of file tpl_graph.H.

References Aleph::List_Graph< _Graph_Node, _Graph_Arc >::remove_arc(), and Aleph::List_Graph< _Graph_Node, _Graph_Arc >::remove_node().

Referenced by Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::~Euclidian_Graph(), Aleph::List_Graph< _Graph_Node, _Graph_Arc >::~List_Graph(), Aleph::Net_Cap_Graph< NodeT, ArcT >::~Net_Cap_Graph(), Aleph::Karger_Min_Cut< GT, SA >::build_kgraph(), Aleph::Lengauer_Tarjan_Post_Dominators< GT, SA >::build_tree(), Aleph::Lengauer_Tarjan_Dominators< GT, SA >::build_tree(), Aleph::Find_Depth_First_Spanning_Tree< GT, SA >::build_tree(), Aleph::Find_Breadth_First_Spanning_Tree< GT, SA >::build_tree(), Aleph::Bellman_Ford< GT, Distance, Ait, NAit, SA >::build_tree(), Aleph::GraphCopyWithMapping< GT, Tree >::clear(), Aleph::IndexNode< GT, Compare, Tree, SN >::clear_graph(), Aleph::Net_Cap_Graph< NodeT, ArcT >::compute_aux_net(), Aleph::AStar_Min_Path< GT, Distance, Heuristic, Itor, SA, HeapT >::compute_min_paths_tree(), Aleph::Dijkstra_Min_Paths< GT, Distance, Itor, SA, HeapT >::compute_min_paths_tree(), Aleph::AStar_Min_Path< GT, Distance, Heuristic, Itor, SA, HeapT >::compute_partial_min_paths_tree(), Aleph::Dijkstra_Min_Paths< GT, Distance, Itor, SA, HeapT >::compute_partial_min_paths_tree(), Aleph::AStar_Min_Path< GT, Distance, Heuristic, Itor, SA, HeapT >::compute_partial_path(), Aleph::Copy_Graph< GT, SN, SA >::copy(), Aleph::copy_graph(), Aleph::Net_Cap_Graph< NodeT, ArcT >::free_aux_net(), Aleph::inter_copy_graph(), Aleph::Compute_Cut_Nodes< GT, SA >::map_cut_graph(), Aleph::Compute_Cut_Nodes< GT, SA >::map_subgraph(), Aleph::Prim_Min_Spanning_Tree< GT, Distance, SA >::min_spanning_tree(), Aleph::Build_Grid< GT, Operation_On_Node, Operation_On_Arc >::operator()(), Aleph::Kruskal_Min_Spanning_Tree< GT, Distance, SA >::paint_min_spanning_tree(), and TEST_F().

compute_bipartite()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

void Aleph::compute_bipartite	(	const GT &	g,
		DynDlist< typename GT::Node * > &	l,
		DynDlist< typename GT::Node * > &	r
	)

Computes the partition sets of a bipartite graph.

A graph is bipartite if it can be divided into two subsets l and r such that every node in l only has edges to nodes in r and vice versa.

compute_bipartite(g,l,r) takes a bipartite graph g and computes the bipartition sets named by parameters l and r, respectively.

Parameters

[in]	g	the bipartite graph.
[out]	l	one partition set.
[out]	r	the other partition set.

Exceptions

domain_error	if during computation it is determined that the graph is not bipartite.
bad_alloc	if there is not enough memory.

Definition at line 99 of file tpl_bipartite.H.

References ah_domain_error_if, Aleph::blossom_maximum_cardinality_matching(), Aleph::Bp_Blue, Aleph::Bp_Red, Aleph::List_Graph< _Graph_Node, _Graph_Arc >::get_first_node(), GraphCommon< GT, Node, Arc >::get_num_nodes(), l, Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne(), Aleph::DynList< T >::put(), r, GraphCommon< GT, Node, Arc >::reset_arcs(), and GraphCommon< GT, Node, Arc >::reset_nodes().

Referenced by Aleph::compute_maximum_cardinality_bipartite_matching(), demo_dating(), demo_definition(), demo_halls_theorem(), demo_matching(), and demo_testing().

compute_bipartite_all_components()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

bool Aleph::compute_bipartite_all_components	(	const GT &	g,
		DynDlist< typename GT::Node * > &	l,
		DynDlist< typename GT::Node * > &	r
	)

Computes the partition sets of a bipartite graph handling all connected components.

Unlike compute_bipartite(), this function processes disconnected graphs correctly by running BFS from each unvisited node.

Parameters

[in]	g	the graph to test.
[out]	l	one partition set (red nodes).
[out]	r	the other partition set (blue nodes).

Returns

true if the graph is bipartite, false otherwise.

Definition at line 330 of file tpl_bipartite.H.

References Aleph::DynList< T >::append(), Aleph::blossom_maximum_cardinality_matching(), Aleph::Bp_Blue, Aleph::Bp_Red, Aleph::Bp_White, Aleph::DynListQueue< T >::get(), Aleph::DynListQueue< T >::is_empty(), l, Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne(), Aleph::DynListQueue< T >::put(), r, GraphCommon< GT, Node, Arc >::reset_arcs(), and GraphCommon< GT, Node, Arc >::reset_nodes().

compute_cut_nodes()

template<AlephGraph GT>

Aleph::compute_cut_nodes	(	const GT &	g,
		typename GT::Node *	start
	)

Compute articulation points (cut vertices) of an undirected graph.

Uses a DFS-based algorithm (Tarjan-style) to compute the articulation points reachable from start.

Side effects:

• Resets arc control attributes via g.reset_arcs().
• Resets node counters and control bits (all node bit fields are cleared).
• Uses the Depth_First and Cut control bits on nodes, and Depth_First on arcs.
• Temporarily stores low-link values in node cookies and clears all node cookies to nullptr before returning.

Note

For a disconnected graph, only the connected component reachable from start is analyzed.

Parameters

[in]	g	Graph to analyze (must not be a digraph).
[in]	start	Starting node (must be non-null and belong to g).

Returns

List of articulation nodes (pointers into g).

Exceptions

domain_error	If g is a directed graph.
bad_alloc	If there is not enough memory.

See also

paint_subgraphs(), map_subgraph(), map_cut_graph()

Definition at line 1334 of file tpl_graph_utils.H.

References Aleph::Cookie_Guard< GT >::~Cookie_Guard(), Aleph::__compute_cut_nodes(), ah_domain_error_if, ah_invalid_argument_if, Aleph::and, Aleph::DynList< T >::append(), ARC_BITS, Aleph::blossom_maximum_cardinality_matching(), Aleph::Cut, Aleph::Depth_First, GraphCommon< GT, Node, Arc >::get_arc_it(), GraphCommon< GT, Node, Arc >::get_node_it(), GraphCommon< GT, Node, Arc >::get_num_nodes(), IS_ARC_VISITED, GraphCommon< GT, Node, Arc >::is_digraph(), IS_NODE_VISITED, NODE_BITS, NODE_COOKIE, NODE_COUNTER, nodes, and GraphCommon< GT, Node, Arc >::reset_arcs().

Referenced by Aleph::compute_cut_nodes(), demo_bridges(), TEST(), TEST(), TEST(), and write_df_low_tree().

compute_dominance_frontiers()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

DynMapTree< typename GT::Node *, DynSetTree< typename GT::Node * > > Aleph::compute_dominance_frontiers	(	GT &	g,
		typename GT::Node *	root,
		SA	sa = SA()
	)

Compute dominance frontiers of a digraph.

Convenience free function wrapping Lengauer_Tarjan_Dominators.

Template Parameters

GT	Graph type (must be directed).
SA	Arc filter type.

Parameters

g	The directed graph.
root	Root node.
sa	Arc filter.

Returns

Map from each reachable node to its dominance frontier.

See also

Lengauer_Tarjan_Dominators

Definition at line 681 of file Dominators.H.

References Aleph::blossom_maximum_cardinality_matching(), and root().

Referenced by TEST(), and TEST().

compute_dominators()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

DynList< std::pair< typename GT::Node *, typename GT::Node * > > Aleph::compute_dominators	(	GT &	g,
		typename GT::Node *	root,
		SA	sa = SA()
	)

Compute immediate dominators of a digraph from a root node.

Convenience free function wrapping Lengauer_Tarjan_Dominators.

Template Parameters

GT	Graph type (must be directed).
SA	Arc filter type.

Parameters

g	The directed graph.
root	Root node.
sa	Arc filter.

Returns

List of (node, idom) pairs. Root's idom is nullptr.

See also

Lengauer_Tarjan_Dominators

Definition at line 638 of file Dominators.H.

References Aleph::blossom_maximum_cardinality_matching(), and root().

Referenced by TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

compute_maximum_cardinality_bipartite_matching()

template<AlephGraph GT, template< class > class Max_Flow = Ford_Fulkerson_Maximum_Flow, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

void Aleph::compute_maximum_cardinality_bipartite_matching	(	const GT &	g,
		DynDlist< typename GT::Arc * > &	matching
	)

Computes the maximum cardinality matching of a bipartite graph.

compute_maximum_cardinality_bipartite_matching(g,matching) takes a bipartite graph g and computes the maximum bipartite matching in the list matching.

The procedure computes the bipartition sets, then constructs an equivalent unit-capacity flow network and invokes a maximum flow algorithm on it.

The routine handles two type parameters:

1. GT the bipartite graph type
2. Max_Flow the maximum flow algorithm to use for the computation

Parameters

[in]	g	the bipartite graph.
[out]	matching	list of arcs that form the matching.

Exceptions

bad_alloc

if there is not enough memory.

Definition at line 210 of file tpl_bipartite.H.

References Aleph::Dlink::append(), Aleph::blossom_maximum_cardinality_matching(), Aleph::compute_bipartite(), GraphCommon< GT, Node, Arc >::get_num_nodes(), GraphCommon< GT, Node, Arc >::get_tgt_node(), Aleph::Dlink::Iterator::has_curr(), l, Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne(), NODE_COOKIE, and r.

compute_maximum_cardinality_general_matching()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

size_t Aleph::compute_maximum_cardinality_general_matching	(	const GT &	g,
		DynDlist< typename GT::Arc * > &	matching,
		SA	sa = SA()
	)

Computes a maximum cardinality matching in a general graph.

Applies Edmonds' Blossom algorithm to an undirected graph. The resulting matching arcs are stored in the provided list.

Template Parameters

GT	Graph type (e.g., List_Graph).
SA	Arc filter type (defaults to show all arcs).

Parameters

[in]	g	The undirected graph to process.
[out]	matching	A list where the arcs of the maximum matching will be stored.
[in]	sa	An optional arc filter instance.

Returns

The cardinality of the maximum matching found ( \(|M|\)).

Exceptions

ah_domain_error	if g is a directed graph (digraph).
ah_bad_alloc	if memory allocation for internal structures fails.

Note

Self-loops and parallel arcs are handled correctly. Self-loops are ignored as they cannot participate in a matching.

Complexity: Time \(|M|\)#13, Space \(|M|\)#14.

Definition at line 433 of file Blossom.H.

References ah_domain_error_if, ah_runtime_error_unless, Aleph::and, Aleph::blossom_maximum_cardinality_matching(), and GraphCommon< GT, Node, Arc >::is_digraph().

compute_maximum_weight_general_matching()

template<AlephGraph GT, class Weight = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

Blossom_Weighted_Result< long long > Aleph::compute_maximum_weight_general_matching	(	const GT &	g,
		DynDlist< typename GT::Arc * > &	matching,
		Weight	weight = Weight(),
		SA	sa = SA(),
		const bool	max_cardinality = false
	)

Compute maximum-weight matching in a general undirected graph.

Finds a matching with the highest possible sum of edge weights. If max_cardinality is true, it finds a matching that first maximizes the number of edges, and among those, maximizes the total weight.

Template Parameters

GT	Aleph undirected graph type (List_Graph, List_SGraph, Array_Graph).
Weight	Weight accessor functor (must return an integral type).
SA	Arc filter.

Parameters

[in]	g	Graph (must be undirected).
[out]	matching	Output list where the selected matching arcs will be stored.
[in]	weight	Weight accessor functor. Defaults to Dft_Dist<GT>.
[in]	sa	Arc filter for graph traversal.
[in]	max_cardinality	If true, optimize lexicographically: maximum cardinality first, then maximum weight.

Returns

A Blossom_Weighted_Result structure containing the total weight and cardinality.

Exceptions

domain_error	If `g` is a digraph.
overflow_error	If weights exceed `long long` limits or the number of nodes exceeds the internal solver's limit.

Definition at line 178 of file Blossom_Weighted.H.

References Aleph::blossom_weighted_detail::mwmatching::adjust_weights_for_maximum_cardinality_matching(), ah_domain_error_if, ah_overflow_error_if, ah_runtime_error_unless, Aleph::and, Aleph::Array< T >::append(), Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_num_arcs(), GraphCommon< GT, Node, Arc >::get_num_nodes(), GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), Aleph::in_place_sort(), GraphCommon< GT, Node, Arc >::is_digraph(), Aleph::blossom_weighted_detail::mwmatching::maximum_weight_matching(), Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne(), NODE_COOKIE, num_nodes, Aleph::Array< T >::reserve(), Aleph::sum(), Aleph::blossom_weighted_detail::to_ll_checked(), and w.

compute_min_cut()

template<AlephGraph GT, template< class > class Max_Flow = Heap_Preflow_Maximum_Flow, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

long Aleph::compute_min_cut	(	GT &	g,
		DynSetTree< typename GT::Node * > &	l,
		DynSetTree< typename GT::Node * > &	r,
		DynDlist< typename GT::Arc * > &	cut
	)

Compute a minimum edge cut of an undirected graph.

Builds a unit-capacity auxiliary network and uses successive max-flow computations to obtain a minimum cut. The partition and cut arcs are returned through output parameters.

The arc filter SA is applied when computing degrees, connectivity, and when building the auxiliary network.

Output parameters are cleared on entry.

Note

If the graph is disconnected, returns 0, cut is empty, and the partition l/r corresponds to the component reachable from a minimum-degree node.

If the graph is connected and the minimum filtered degree is <= 1, the cut isolates a minimum-degree node.

Side effects:

• Uses the Depth_First control bit on nodes and arcs to test connectivity.
• Overwrites node cookies to map GT <-> Net nodes when the auxiliary network is built.
• Overwrites arc cookies on the auxiliary network to map back to GT arcs.

Template Parameters

GT	Graph type (undirected).
Max_Flow	Maximum flow functor.
SA	Arc filter functor.

Parameters

[in,out]	g	Graph to analyze.
[out]	l	Set of nodes on the source side of the cut.
[out]	r	Set of nodes on the sink side of the cut.
[out]	cut	List of cut arcs (arcs crossing between l and r).

Returns

Edge connectivity of g (minimum cut size).

Exceptions

std::domain_error	If g is a digraph.
std::bad_alloc	If there is not enough memory.

Definition at line 265 of file tpl_kgraph.H.

References ah_domain_error_if, Aleph::DynDlist< T >::append(), ARC_COOKIE, Aleph::blossom_maximum_cardinality_matching(), Aleph::Depth_First, Aleph::DynList< T >::empty(), Aleph::DynDlist< T >::empty(), GraphCommon< GT, Node, Arc >::get_connected_node(), GraphCommon< GT, Node, Arc >::get_num_nodes(), GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), Aleph::Dlink::Iterator::has_curr(), Aleph::HTList::Iterator::has_curr(), Aleph::DynList< T >::insert(), Aleph::Net_Graph< NodeT, ArcT >::insert_arc(), Aleph::Net_Graph< NodeT, ArcT >::insert_node(), GraphCommon< GT, Node, Arc >::is_digraph(), IS_NODE_VISITED, l, GraphCommon< GT, Node, Arc >::map_nodes(), Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne(), NODE_COOKIE, num_nodes, r, Aleph::Net_Graph< NodeT, ArcT >::remove_node(), and Aleph::Net_Graph< NodeT, ArcT >::reset().

compute_minimum_cost_general_matching()

template<AlephGraph GT, class Cost = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

Min_Cost_Matching_Result< long long > Aleph::compute_minimum_cost_general_matching	(	const GT &	g,
		DynDlist< typename GT::Arc * > &	matching,
		Cost	cost = Cost(),
		SA	sa = SA(),
		const bool	max_cardinality = false
	)

Compute minimum-cost matching in a general undirected graph.

Computes a matching that minimizes total cost. If max_cardinality is true, it first maximizes cardinality and then minimizes cost.

Template Parameters

GT	Aleph undirected graph type.
Cost	Cost accessor functor (must return integral type).
SA	Arc filter.

Parameters

[in]	g	Graph (must be undirected).
[out]	matching	Output list with matching arcs.
[in]	cost	Cost accessor (defaults to Dft_Dist<GT>).
[in]	sa	Arc filter.
[in]	max_cardinality	If true, optimize lexicographically: maximum cardinality first, then minimum cost.

Returns

A Min_Cost_Matching_Result<long long> with total cost and cardinality.

Exceptions

domain_error	If `g` is a digraph.
overflow_error	If costs cannot be represented or summed in long long.

Definition at line 227 of file Min_Cost_Matching.H.

References ah_domain_error_if, ah_overflow_error_if, ah_runtime_error_unless, Aleph::and, Aleph::blossom_maximum_cardinality_matching(), Aleph::Min_Cost_Matching_Result< Cost_Type >::cardinality, GraphCommon< GT, Node, Arc >::is_digraph(), Aleph::sum(), and Aleph::min_cost_matching_detail::to_ll_checked().

compute_minimum_cost_perfect_general_matching()

template<AlephGraph GT, class Cost = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

Min_Cost_Perfect_Matching_Result< long long > Aleph::compute_minimum_cost_perfect_general_matching	(	const GT &	g,
		DynDlist< typename GT::Arc * > &	matching,
		Cost	cost = Cost(),
		SA	sa = SA()
	)

Compute minimum-cost perfect matching in a general undirected graph.

This function searches for a perfect matching (all vertices matched) and minimizes total cost among perfect matchings.

Behavior:

• If a perfect matching exists, returns feasible = true and fills matching with a minimum-cost perfect matching.
• If it does not exist, returns feasible = false and leaves matching empty.

Template Parameters

GT	Aleph undirected graph type.
Cost	Cost accessor functor (must return integral type).
SA	Arc filter.

Parameters

[in]	g	Graph (must be undirected).
[out]	matching	Output list with matching arcs if feasible.
[in]	cost	Cost accessor (defaults to Dft_Dist<GT>).
[in]	sa	Arc filter.

Returns

A Min_Cost_Perfect_Matching_Result<long long>.

Exceptions

domain_error	If `g` is a digraph.
overflow_error	If costs cannot be represented or summed in long long.

Definition at line 324 of file Min_Cost_Matching.H.

References ah_domain_error_if, Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_num_nodes(), GraphCommon< GT, Node, Arc >::is_digraph(), num_nodes, and Aleph::Min_Cost_Perfect_Matching_Result< Cost_Type >::total_cost.

compute_post_dominance_frontiers()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

DynMapTree< typename GT::Node *, DynSetTree< typename GT::Node * > > Aleph::compute_post_dominance_frontiers	(	const GT &	g,
		typename GT::Node *	exit_node,
		SA	sa = SA()
	)

Compute post-dominance frontiers of a digraph.

Convenience-free function wrapping Lengauer_Tarjan_Post_Dominators.

Template Parameters

GT	Graph type (must be directed).
SA	Arc filter type.

Parameters

g	The directed graph.
exit_node	Exit node.
sa	Arc filter.

Returns

Map from each reachable node to its post-dominance frontier.

See also

Lengauer_Tarjan_Post_Dominators

Definition at line 1094 of file Dominators.H.

References Aleph::blossom_maximum_cardinality_matching().

Referenced by TEST().

compute_post_dominators()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

DynList< std::pair< typename GT::Node *, typename GT::Node * > > Aleph::compute_post_dominators	(	const GT &	g,
		typename GT::Node *	exit_node,
		SA	sa = SA()
	)

Compute immediate post-dominators of a digraph from an exit node.

Convenience free function wrapping Lengauer_Tarjan_Post_Dominators.

Template Parameters

GT	Graph type (must be directed).
SA	Arc filter type.

Parameters

g	The directed graph.
exit_node	Exit node.
sa	Arc filter.

Returns

List of (node, ipdom) pairs. Exit node's ipdom is nullptr.

See also

Lengauer_Tarjan_Post_Dominators

Definition at line 1048 of file Dominators.H.

References Aleph::blossom_maximum_cardinality_matching().

Referenced by TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

copy_graph()

template<AlephGraph GT>

void Aleph::copy_graph ( GT &  gtgt, const GT &  gsrc, bool  cookie_map = false  )

inline

Explicit copy of graph.

This function takes a source graph gsrc for copying to another target graph gtgt. First the function cleans gtgt; that is all its arc and nodes are removed and freed. Then gsrc is copied to gtgt- The resulting gtgt is isomorphic to gsrc.

Eventually, the copy can be mapped through the cookies. For that, a forth bool parameter is specified-

Parameters

[in]	gsrc	source graph
[in]	gtgt	target graph
[in]	cookie_map	boolean indicating if the result must be mapped through the nodes and arcs cookies.

Exceptions

bad_alloc

if there is no enough memory

Definition at line 3677 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), Aleph::clear_graph(), GTNodeCommon< NodeInfo >::get_info(), Aleph::DynMapTree< Key, Data, Tree, Compare >::insert(), GraphCommon< GT, Node, Arc >::map_arcs(), and GraphCommon< GT, Node, Arc >::map_nodes().

Referenced by Aleph::Digraph< BaseGraph >::Digraph(), Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::Euclidian_Graph(), Aleph::Net_Graph< NodeT, ArcT >::Net_Graph(), Aleph::Digraph< BaseGraph >::operator=(), and Aleph::Euclidian_Graph< __Euclidian_Node, __Euclidian_Arc >::operator=().

depth_first_traversal()

template<AlephGraph GT>

size_t Aleph::depth_first_traversal ( const GT &  g, typename GT::Node *  start_node, bool(*)(const GT &g, typename GT::Node *, typename GT::Arc *)  visit  )

inline

Depth-first traversal starting from a given node.

Recursively traverses the connected component reachable from start_node.

The callback must have the following signature: bool visit(const GT& g, typename GT::Node* curr, typename GT::Arc* from).

from is the arc that discovered curr (nullptr for the start node). If visit returns true, the traversal stops early. If visit is nullptr, no callback is executed.

Template Parameters

GT	Graph type.

Parameters

[in]	g	Graph to traverse.
[in]	start_node	Starting node (must be non-null and belong to g).
[in]	visit	Optional visit callback (may be nullptr).

Returns

Number of discovered nodes.

Note

Resets the Depth_First control bit on all nodes and arcs.

Uses the Depth_First control bit on both nodes and arcs.

See also

Depth_First_Traversal, breadth_first_traversal, test_connectivity

Definition at line 108 of file tpl_graph_utils.H.

References Aleph::__depth_first_traversal(), Aleph::blossom_maximum_cardinality_matching(), counter, Aleph::Depth_First, GraphCommon< GT, Node, Arc >::reset_bit_arcs(), and GraphCommon< GT, Node, Arc >::reset_bit_nodes().

Referenced by Aleph::depth_first_traversal(), TEST(), TEST(), TEST(), and write_df_low_tree().

digraph_graphviz()

template<AlephGraph GT, class Node_Attr , class Arc_Attr , NodeFilter< GT > SN, ArcFilter< GT > SA>

void Aleph::digraph_graphviz	(	const GT &	g,
		std::ostream &	out,
		Node_Attr	node_attr = Node_Attr(),
		Arc_Attr	arc_attr = Arc_Attr(),
		const std::string &	rankdir = "LR"
	)

Generate Graphviz DOT output specifically for digraphs.

Similar to generate_graphviz() but always outputs "digraph {}" regardless of the graph type. Useful when you want to force directed edge notation.

Template Parameters

GT	Graph type
Node_Attr	Node attribute generator
Arc_Attr	Arc attribute generator
SN	Node filter
SA	Arc filter

Parameters

g	Graph to visualize
out	Output stream
node_attr	Node attribute functor
arc_attr	Arc attribute functor
rankdir	Layout direction (default: "LR" for left-to-right)

See also

generate_graphviz() For automatic graph/digraph detection

Definition at line 450 of file generate_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne(), and out.

dsatur_coloring()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

size_t Aleph::dsatur_coloring	(	const GT &	g,
		DynMapTree< typename GT::Node *, size_t > &	colors
	)

DSatur graph coloring (saturation-degree heuristic).

At each step the uncolored node with the highest saturation degree (number of distinct colors among already-colored neighbors) is colored first, using the smallest available color. Ties are broken by choosing the node with the highest degree. This adaptive strategy frequently produces near-optimal or optimal colorings.

Template Parameters

GT	Graph type (List_Graph, List_Digraph, Array_Graph, …).
SA	Arc-filter functor (defaults to Dft_Show_Arc<GT>).

Parameters

[in]	g	Input graph. Must not contain self-loops.
[out]	colors	Output map from GT::Node* to 0-based color index. Cleared and overwritten on entry.

Returns

Number of distinct colors used (0 for an empty graph).

Exceptions

std::domain_error

if g contains a self-loop.

Precondition

No self-loops in g.

Note

Complexity: \(O(V^2 + E \log V)\).

Thread safety: not thread-safe. Temporarily writes to NODE_COOKIE on every node; saved and restored via Cookie_Saver before the function returns.

See also

chromatic_number, welsh_powell_coloring

Definition at line 348 of file Graph_Coloring.H.

References Aleph::and, Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_node_it(), GraphCommon< GT, Node, Arc >::get_num_nodes(), Aleph::DynSetTree< Key, Tree, Compare >::insert(), NODE_COOKIE, Aleph::DynSetTree< Key, Tree, Compare >::size(), and w.

Referenced by demo_algorithm_comparison(), demo_cookie_safety(), demo_exam_scheduling(), demo_map_coloring(), demo_register_allocation(), main(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

edge_connectivity()

template<AlephGraph GT, template< class > class Max_Flow = Random_Preflow_Maximum_Flow, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

long Aleph::edge_connectivity

(

GT &

g

)

Compute edge connectivity (arc connectivity) of an undirected graph.

Builds a unit-capacity auxiliary network and computes maximum flow from a fixed source to every other node. The minimum of those flow values equals the edge connectivity.

The arc filter SA is applied when computing degrees and when building the auxiliary network.

Template Parameters

GT	Graph type (undirected).
Max_Flow	Maximum flow functor to use.
SA	Arc filter functor.

Side effects:

• Uses the Depth_First control bit on nodes and arcs to test connectivity.
• Overwrites node cookies to store the GT -> Net mapping when the auxiliary network is built.

Parameters

[in,out]

g

Graph to analyze.

Returns

Edge connectivity of g (0 for empty or disconnected graphs).

Note

For connected graphs with minimum filtered degree <= 1, returns that degree without running max flow.

Exceptions

std::domain_error	If g is a digraph.
std::bad_alloc	If there is not enough memory.

Definition at line 112 of file tpl_kgraph.H.

References ah_domain_error_if, Aleph::DynDlist< T >::append(), Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_num_nodes(), GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), Aleph::Dlink::Iterator::has_curr(), Aleph::Net_Graph< NodeT, ArcT >::insert_arc(), Aleph::Net_Graph< NodeT, ArcT >::insert_node(), GraphCommon< GT, Node, Arc >::is_digraph(), Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne(), NODE_COOKIE, num_nodes, Aleph::Net_Graph< NodeT, ArcT >::remove_node(), and Aleph::Net_Graph< NodeT, ArcT >::reset().

eppstein_k_shortest_paths()

template<AlephGraph GT, ArcDistance< GT > Distance = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
requires std::is_arithmetic_v<typename Distance::Distance_Type>

DynList< K_Shortest_Path_Item< GT, typename Distance::Distance_Type > > Aleph::eppstein_k_shortest_paths	(	const GT &	g,
		typename GT::Node *	source,
		typename GT::Node *	target,
		const size_t	k,
		Distance	distance = Distance(),
		SA	sa = SA()
	)

Compute k shortest general (loopy) paths.

Returns up to k paths (allowing cycles) ordered by non-decreasing total cost. If fewer than k paths exist, all available paths are returned.

This algorithm uses an Eppstein-style approach: it builds a shortest path tree towards the target in the reversed graph, then explores path deviations ordered by cost.

Template Parameters

GT	Graph type.
Distance	Arc cost accessor (Distance::Distance_Type required).
SA	Arc filter.

Parameters

[in]	g	Graph.
[in]	source	Source node.
[in]	target	Target node.
[in]	k	Maximum number of paths to return.
[in]	distance	Arc cost accessor.
[in]	sa	Arc filter.

Returns

DynList<K_Shortest_Path_Item<GT, Cost_Type>> containing the paths found.

Exceptions

std::domain_error	If source or target is null.
std::domain_error	If negative arc weights are detected.

Complexity

O(E + V log V + k * log k) typically, depending on the number of deviations explored. Building the suffix tree dominates initially.

Note

This implementation is NOT thread-safe due to internal use of static thread-local storage for reverse graph traversal.

source == target limitation: when source and target are the same node the function returns exactly one result — the trivial zero-cost path — regardless of k. Loopy cycles through source are not enumerated because generate_general_deviation_candidates exits immediately on an empty-arc base path. If cycle enumeration from a self-loop origin is required, call the function with a distinct dummy source or implement a dedicated cycle-seeding pass.

Definition at line 1073 of file K_Shortest_Paths.H.

References ah_domain_error_if, Aleph::and, Aleph::DynList< T >::append(), Aleph::blossom_maximum_cardinality_matching(), Aleph::k_shortest_paths_detail::contains_path(), k, Aleph::Array< T >::reserve(), Aleph::k_shortest_paths_detail::state_to_path(), and Aleph::k_shortest_paths_detail::validate_non_negative_weights().

find_breadth_first_spanning_tree()

template<AlephGraph GT>

GT Aleph::find_breadth_first_spanning_tree ( GT &  g, typename GT::Node *  gp  )

inline

Build a breadth-first spanning tree (mapped to the original graph).

Returns a spanning tree of the connected component reachable from gp, visiting nodes in breadth-first order.

Side effects:

• Resets the Spanning_Tree control bit on all nodes and arcs.
• Uses the Spanning_Tree control bit on both nodes and arcs.
• Maps nodes and arcs between g and the returned tree via cookies.

Parameters

[in,out]	g	Graph to traverse.
[in]	gp	Start node (must be non-null and belong to g).

Returns

A mapped spanning tree of the reachable component.

Exceptions

bad_alloc

If there is not enough memory.

See also

find_depth_first_spanning_tree()

Definition at line 1160 of file tpl_graph_utils.H.

References Aleph::and, ARC_BITS, Aleph::blossom_maximum_cardinality_matching(), Aleph::DynListQueue< T >::get(), GraphCommon< GT, Node, Arc >::get_arc_it(), GraphCommon< GT, Node, Arc >::get_num_nodes(), GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), Aleph::List_Graph< _Graph_Node, _Graph_Arc >::insert_arc(), Aleph::List_Graph< _Graph_Node, _Graph_Arc >::insert_node(), IS_ARC_VISITED, Aleph::DynListQueue< T >::is_empty(), IS_NODE_VISITED, GraphCommon< GT, Node, Arc >::map_arcs(), GraphCommon< GT, Node, Arc >::map_nodes(), NODE_BITS, Aleph::DynListQueue< T >::put(), GraphCommon< GT, Node, Arc >::reset_bit_arcs(), GraphCommon< GT, Node, Arc >::reset_bit_nodes(), and Aleph::Spanning_Tree.

Referenced by TEST().

find_bridges()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

DynList< typename GT::Arc * > Aleph::find_bridges ( const GT &  g, typename GT::Node *  start, SA  sa = SA()  )

related

Find all bridge edges in a connected undirected graph.

Convenience free function wrapping Compute_Bridges<GT, SA>. A bridge is an arc whose removal disconnects the graph.

auto bridges = find_bridges(g, start_node);
for (auto * a : bridges)
  ...;

Template Parameters

GT	Graph type.
SA	Arc filter.

Parameters

[in]	g	Undirected connected graph.
[in]	start	Starting node for the DFS.
[in]	sa	Arc filter.

Returns

DynList of pointers to bridge arcs.

See also

Compute_Bridges

Definition at line 809 of file tpl_cut_nodes.H.

References Aleph::blossom_maximum_cardinality_matching().

Referenced by demo_bridges(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

find_depth_first_spanning_tree()

template<AlephGraph GT>

GT Aleph::find_depth_first_spanning_tree ( const GT &  g, typename GT::Node *  gnode  )

inline

Build a depth-first spanning tree (mapped to the original graph).

Returns a spanning tree of the connected component reachable from gnode, visiting nodes in depth-first order.

Side effects:

• Resets all node and arc control attributes via g.reset_nodes() and g.reset_arcs().
• Uses the Spanning_Tree control bit on both nodes and arcs.
• Maps nodes and arcs between g and the returned tree via cookies.

Parameters

[in]	g	Graph to traverse.
[in]	gnode	Start node (must be non-null and belong to g).

Returns

A mapped spanning tree of the reachable component.

Exceptions

bad_alloc

If there is not enough memory.

See also

find_breadth_first_spanning_tree()

Definition at line 1067 of file tpl_graph_utils.H.

References Aleph::__find_depth_first_spanning_tree(), Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_arc_it(), Aleph::List_Graph< _Graph_Node, _Graph_Arc >::insert_node(), IS_ARC_VISITED, IS_NODE_VISITED, GraphCommon< GT, Node, Arc >::map_nodes(), NODE_BITS, GraphCommon< GT, Node, Arc >::reset_arcs(), GraphCommon< GT, Node, Arc >::reset_nodes(), GraphCommon< GT, Node, Arc >::set_bit(), and Aleph::Spanning_Tree.

Referenced by Aleph::find_depth_first_spanning_tree(), TEST(), and write_df_low_tree().

find_min_path() [1/2]

template<class Mat >

void Aleph::find_min_path	(	Mat &	p,
		const long	src_index,
		const long	tgt_index,
		Path< typename Mat::Graph_Type > &	path
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Variant that accepts const indices.

Build a minimum path from Floyd-Warshall path matrix using indices.

See mat_path.H for the primary definition and full documentation. This overload is provided for compatibility with const index values.

See also

mat_path.H For the primary definition with non-const indices

Takes a path matrix computed by Floyd-Warshall algorithm and two matrix indices (source and target), then constructs the minimum path in the adjacency list representation.

The path is reconstructed by following the intermediate node indices stored in the path matrix until reaching the target.

Template Parameters

Mat	Matrix type from Map_Matrix_Graph (e.g., Ady_Mat<GT, long, ...>)

Parameters

[in]	p	Path index matrix from Floyd-Warshall. Entry p(i,j) contains the index of the next node after i on the shortest path to j.
[in]	src_index	Source node index in the path matrix (0-based).
[in]	tgt_index	Target node index in the path matrix (0-based).
[out]	path	The reconstructed minimum path in the adjacency list graph. The path is cleared and rebuilt from scratch.

Precondition

The path matrix p must have been computed by floyd_all_shortest_paths().

src_idx and tgt_idx must be valid indices (0 <= idx < n).

A path must exist between src_idx and tgt_idx (no infinite distance).

Warning

Results are undefined if:

• The path matrix is invalid or not properly computed
• There is no path between source and target
• The indices are out of range

Exceptions

std::bad_alloc

If insufficient memory to build the path.

Complexity

• Time: O(k) where k is the number of nodes in the path
• Space: O(k) for storing the path

See also

floyd_all_shortest_paths()

find_min_path(Mat&, typename Mat::Node*, typename Mat::Node*, Path<typename Mat::Graph_Type>&)

latex_floyd.H For variant with const indices

Definition at line 231 of file latex_floyd.H.

References Aleph::Path< GT >::append(), Aleph::blossom_maximum_cardinality_matching(), Aleph::find_min_path(), Aleph::next(), and Aleph::Path< GT >::set_graph().

Referenced by Aleph::find_min_path(), Aleph::find_min_path(), TEST_F(), TEST_F(), and TEST_F().

find_min_path() [2/2]

template<class Mat >

void Aleph::find_min_path	(	Mat &	p,
		typename Mat::Node *	src_node,
		typename Mat::Node *	tgt_node,
		Path< typename Mat::Graph_Type > &	path
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Reconstruct shortest path from path matrix using node pointers.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Build a minimum path using node pointers instead of indices.

Convenience overload that accepts node pointers instead of indices.

Template Parameters

Mat	Path matrix type

Parameters

[in]	p	The path matrix from Floyd-Warshall
[in]	src_node	Source node pointer
[in]	tgt_node	Target node pointer
[out]	path	The reconstructed path

See also

find_min_path(Mat&, const long, const long, Path<GT>&)

Convenience overload that accepts node pointers and converts them to matrix indices before calling the index-based version.

See also

find_min_path(Mat&, long, long, Path<typename Mat::Graph_Type>&)

Definition at line 268 of file latex_floyd.H.

References Aleph::blossom_maximum_cardinality_matching(), and Aleph::find_min_path().

find_path_breadth_first()

template<AlephGraph GT>

Path< GT > Aleph::find_path_breadth_first ( const GT &  g, typename GT::Node *  start, typename GT::Node *  end  )

inline

Breadth-first search of a (shortest-by-edges) path between two nodes.

Searches a path from start to end using breadth-first search (BFS). If a path exists, the returned path has the minimum number of arcs (ties depend on iteration order).

Side effects:

• Resets all node and arc control attributes via g.reset_nodes() and g.reset_arcs().
• Uses the Find_Path control bit on nodes and arcs.
• Stores predecessor pointers in node cookies while searching.

Template Parameters

GT	Graph type.

Parameters

[in]	g	Graph to search.
[in]	start	Start node (must be non-null and belong to g).
[in]	end	End node (must be non-null and belong to g).

Returns

A Path<GT> describing the found path; an empty path if no path exists.

Exceptions

bad_alloc

If there is not enough memory.

See also

find_path_depth_first(), test_for_path()

Definition at line 556 of file tpl_graph_utils.H.

References ah_invalid_argument_if, Aleph::and, ARC_BITS, Aleph::blossom_maximum_cardinality_matching(), Aleph::DynListQueue< T >::empty(), Aleph::Find_Path, Aleph::DynListQueue< T >::get(), GraphCommon< GT, Node, Arc >::get_arc_it(), GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), Aleph::Path< GT >::insert(), IS_ARC_VISITED, Aleph::DynListQueue< T >::is_empty(), IS_NODE_VISITED, NODE_BITS, NODE_COOKIE, Aleph::DynListQueue< T >::put(), GraphCommon< GT, Node, Arc >::reset_arcs(), and GraphCommon< GT, Node, Arc >::reset_nodes().

Referenced by TEST(), TEST(), TEST(), and TEST().

find_path_depth_first()

template<AlephGraph GT>

Path< GT > Aleph::find_path_depth_first ( const GT &  g, typename GT::Node *  start_node, typename GT::Node *  end_node  )

inline

Depth-first search of a path between two nodes.

find_path_depth_first() recursively searches a path between start_node y end_node

Parameters

[in]	g	the graph
[in]	start_node	pointer to the starting node of search
[in]	end_node	pointer to ending node of search

Returns

a Path object containing the path if this was found; an empty path otherwise

Exceptions

bad_alloc

if there is no enough memory

See also

find_path_breadth_first()

Definition at line 3578 of file tpl_graph.H.

References ARC_BITS, Aleph::blossom_maximum_cardinality_matching(), Aleph::Path< GT >::empty(), Aleph::Find_Path, GraphCommon< GT, Node, Arc >::get_arc_it(), IS_NODE_VISITED, NODE_BITS, GraphCommon< GT, Node, Arc >::reset_bit_arcs(), and GraphCommon< GT, Node, Arc >::reset_bit_nodes().

Referenced by TEST_F(), and TEST_F().

floyd_all_shortest_paths()

template<AlephGraph GT, class Compare , class Plus >

void Aleph::floyd_all_shortest_paths	(	GT &	g,
		Ady_Mat< GT, typename GT::Arc_Type::Distance_Type > &	dist,
		Ady_Mat< GT, long > &	path
	)

Compute all-pairs shortest paths using Floyd-Warshall algorithm.

Computes the shortest path between every pair of vertices in the graph. The algorithm runs in O(V³) time and O(V²) space.

Template Parameters

GT	Graph type (must have Arc_Type with Distance_Type, Max_Distance, Zero_Distance)
Compare	Comparison functor (default: less)
Plus	Addition functor for distances (default: plus)

Parameters

	g	The input graph
[out]	dist	Distance matrix - dist(i,j) = shortest distance from i to j
[out]	path	Path matrix - path(i,j) = next node on shortest path from i to j

Note

The path matrix can be used with find_min_path() to reconstruct paths.

Warning

Does not detect negative cycles.

Definition at line 173 of file latex_floyd.H.

References Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_num_nodes(), max(), and Aleph::Plus.

Referenced by TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

floyd_all_shortest_paths_latex()

template<AlephGraph GT, class Compare , class Plus , template< class > class P_i, template< class > class P_ij, template< class > class D_ij>

void Aleph::floyd_all_shortest_paths_latex	(	GT &	g,
		Ady_Mat< GT, typename GT::Arc_Type::Distance_Type > &	dist,
		Ady_Mat< GT, long > &	path,
		std::ofstream &	output
	)

Floyd-Warshall algorithm with LaTeX step-by-step output.

Computes all-pairs shortest paths while generating LaTeX output showing the distance and path matrices at each iteration step. Useful for educational purposes and algorithm visualization.

LaTeX Output Format

Generates figures with side-by-side D_k and P_k matrices for k = 0..n. Requires LaTeX packages: float (for [H] placement).

Template Parameters

GT	Graph type
Compare	Comparison functor
Plus	Addition functor
P_i	Row/column index formatter
P_ij	Path matrix entry formatter
D_ij	Distance matrix entry formatter

Parameters

	g	The input graph
[out]	dist	Distance matrix
[out]	path	Path matrix
[out]	output	Output stream for LaTeX code

See also

floyd_all_shortest_paths() For algorithm without LaTeX output

Definition at line 310 of file latex_floyd.H.

References Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_num_nodes(), max(), output, and Aleph::Plus.

Referenced by TEST_F(), TEST_F(), and TEST_F().

foldl_arcs() [1/2]

template<AlephGraph GT, typename T , ArcFilter< GT > SA = Dft_Show_Arc<GT>, class Op >
requires std::is_invocable_r_v<T, Op &, const T &, typename GT::Arc *>

T Aleph::foldl_arcs	(	GT &	g,
		const T &	init,
		Op	operation,
		SA	sa = SA()
	)

Fold the filtered arcs of a graph.

Parameters

[in]	g	the graph
[in]	init	initial value of folded result
[in]	operation	folding operation on the arc
[in]	sa	arc filter

Returns

the final folded result

Definition at line 1554 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), and Aleph::init.

foldl_arcs() [2/2]

template<AlephGraph GT, typename T , ArcFilter< GT > SA = Dft_Show_Arc<GT>, class Op >
requires std::is_invocable_r_v<T, Op &, const T &, typename GT::Arc *>

T Aleph::foldl_arcs	(	GT &	g,
		typename GT::Node *	p,
		const T &	init,
		Op	operation,
		SA	sa = SA()
	)

Fold the filtered adjacent arcs of a node.

Parameters

[in]	g	the graph
[in]	p	node pointer
[in]	init	initial value of folded result
[in]	operation	folding operation on the arc
[in]	sa	arc filter

Returns

the final folded result

Definition at line 1578 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), and Aleph::init.

foldl_nodes()

template<AlephGraph GT, typename T , NodeFilter< GT > SN = Dft_Show_Node<GT>, class Op >
requires std::is_invocable_r_v<T, Op &, const T &, typename GT::Node *>

T Aleph::foldl_nodes	(	GT &	g,
		const T &	init,
		Op	operation,
		SN	sn = SN()
	)

Fold the filtered nodes of a graph.

Parameters

[in]	g	the graph
[in]	init	initial value of folded result
[in]	operation	folding operation on the node
[in]	sn	node filter

Returns

the final folded result

Definition at line 1531 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), and Aleph::init.

for_each_arc() [1/3]

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>, class Op >
requires std::is_invocable_r_v<void, Op &, typename GT::Arc *>

void Aleph::for_each_arc	(	const GT &	g,
		Op	operation,
		SA	sa = SA()
	)

Traverse all the arcs of graph filtering some ones according to a condition and executing an operation on them.

Parameters

[in]	g	the graph
[in]	operation	to be executed on each seen arc
[in]	sa	an arc filter

Definition at line 1259 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), and Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne().

Referenced by TEST().

for_each_arc() [2/3]

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>, class Op >
requires std::is_invocable_r_v<void, Op &, typename GT::Arc *>

void Aleph::for_each_arc	(	const GT &	g,
		typename GT::Node *	p,
		Op	operation,
		SA	sa = SA()
	)

Traverse all the arcs adjacent to a node filtering some ones according to a condition and executing an operation on them.

Parameters

[in]	g	the graph
[in]	p	a node pointer
[in]	operation	to be executed on each seen arc
[in]	sa	an arc filter

Definition at line 1279 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), and Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne().

for_each_arc() [3/3]

template<AlephGraph GT, class Itor , class Operation >

void Aleph::for_each_arc ( typename GT::Node *  p, Operation  op = Operation()  )

inline

Execute an operation on each arc of a node.

This template function receives threes template parameters:

1. GT: the graph type.
2. Itor: the iterator type; it is intended to be _In_Iterator or _Out_Iterator.
3. Operation: an operation to be executed on each arc. This operation must have the following signature:

void operation(typename GT::Arc * arc)

Parameters

[in]	p	node pointer
[in]	op	operation to be performed on each arc

Definition at line 2119 of file tpl_graph.H.

for_each_in_arc()

template<AlephGraph GT, class Op >

void Aleph::for_each_in_arc ( typename GT::Node *  p, Op  op = Op()  )

inline

Traverse the incoming arcs of a node and executes an operation.

Parameters

[in]	p	node pointer
[in]	op	operation to perform on each node

Definition at line 2152 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching().

for_each_node()

template<AlephGraph GT, NodeFilter< GT > SN = Dft_Show_Node<GT>, class Op >
requires std::is_invocable_r_v<void, Op &, typename GT::Node *>

void Aleph::for_each_node	(	const GT &	g,
		Op	operation,
		SN	sn = SN()
	)

Traverse all the nodes of graph filtering some ones according to a condition and executing an operation on them.

Parameters

[in]	g	the graph
[in]	operation	to be executed on each seen node
[in]	sn	a node filter

Definition at line 1240 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), and Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne().

for_each_out_arc()

template<AlephGraph GT, class Op >

void Aleph::for_each_out_arc ( typename GT::Node *  p, Op  op = Op()  )

inline

Traverse the outcoming arcs of a node and executes an operation.

Parameters

[in]	p	node pointer
[in]	op	operation to perform on each node

Definition at line 2344 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching().

forall_arc() [1/2]

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>, class Op >
requires std::is_invocable_r_v<bool, Op &, typename GT::Arc *>

bool Aleph::forall_arc	(	const GT &	g,
		Op	cond,
		SA	sa = SA()
	)

Return true if condition cond is met on every filtered arc of the graph.

Parameters

[in]	g	the graph
[in]	cond	condition
[in]	sa	arc filter

Returns

true if all the arcs satisfy the condition; false otherwise

Definition at line 1323 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), and Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne().

Referenced by TEST().

forall_arc() [2/2]

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>, class Op >
requires std::is_invocable_r_v<bool, Op &, typename GT::Arc *>

bool Aleph::forall_arc	(	typename GT::Node *	p,
		Op	cond,
		SA	sa = SA()
	)

Return true if the condition cond is met on every filtered arc of a node.

Parameters

[in]	p	node pointer
[in]	cond	condition
[in]	sa	arc filter

Returns

true if all the arcs satisfy the condition; false otherwise

Definition at line 1345 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), and Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne().

forall_node()

template<AlephGraph GT, NodeFilter< GT > SN = Dft_Show_Node<GT>, class Op >
requires std::is_invocable_r_v<bool, Op &, typename GT::Node *>

bool Aleph::forall_node	(	const GT &	g,
		Op	cond,
		SN	sn = SN()
	)

Return true if condition cond is met on every filtered node of the graph.

Parameters

[in]	g	the graph
[in]	cond	condition
[in]	sn	node filter

Returns

true if all the nodes satisfy the condition; false otherwise

Definition at line 1301 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), and Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne().

generate_cross_graph()

template<AlephGraph GT, class Write_Node , class Write_Arc , class Shade_Node , class Shade_Arc , ArcFilter< GT > SA>

void Aleph::generate_cross_graph	(	GT &	g,
		const size_t &	nodes_by_level,
		const double &	xdist,
		const double &	ydist,
		std::ostream &	out
	)

Generate a cross-graph layout specification for graphpic.

Creates a graphpic specification with nodes arranged in a cross pattern. In this layout, even levels have (nodes_by_level - 1) nodes and odd levels have nodes_by_level nodes, creating a staggered pattern.

Template Parameters

GT	Graph type
Write_Node	Functor returning node label string
Write_Arc	Functor returning arc label string
Shade_Node	Functor returning shading command (e.g., "SHADOW-NODE")
Shade_Arc	Functor returning shading command (e.g., "SHADOW-ARC")
SA	Arc filter

Parameters

g	Graph to visualize
nodes_by_level	Nodes per level (last level may have fewer)
xdist	Horizontal distance between nodes
ydist	Vertical distance between levels
out	Output stream for graphpic specification

Definition at line 794 of file generate_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_num_nodes(), GraphCommon< GT, Node, Arc >::is_digraph(), and out.

Referenced by Aleph::generate_cross_graph(), and generate_cross_spanning_tree().

generate_cross_spanning_tree()

template<AlephGraph GT, class Write_Node , class Write_Arc , ArcFilter< GT > SA>

void generate_cross_spanning_tree	(	GT &	g,
		const size_t &	nodes_by_level,
		const double &	xdist,
		const double &	ydist,
		std::ofstream &	output
	)

Generate a cross-layout visualization of a spanning tree.

Creates a graphpic specification with nodes arranged in a cross pattern, with spanning tree edges highlighted.

Template Parameters

GT	Graph type
Write_Node	Functor to convert node content to string
Write_Arc	Functor to convert arc content to string
SA	Arc filter class

Parameters

g	The graph containing the spanning tree
nodes_by_level	Number of nodes per level in the layout
xdist	Horizontal distance between nodes
ydist	Vertical distance between levels
output	Output stream for the graphpic specification

See also

generate_cross_graph() For the underlying layout function

Definition at line 124 of file generate_spanning_tree_picture.H.

References Aleph::blossom_maximum_cardinality_matching(), Aleph::generate_cross_graph(), and output.

generate_dot_file()

void Aleph::generate_dot_file ( Digrafo &  g, std::ostream &  output  )

inline

Generate a DOT representation of the digraph.

Creates a DOT file suitable for rendering with Graphviz. The output includes:

• Node colors based on the "plazo" field (cp=Green, mp=Yellow, lp=Red)
• Optional labels showing power and NES values
• Optional shapes based on the "class" field
• Cycle detection with warning comments
• Topological ranking for acyclic graphs

The appearance is controlled by the global configuration variables: with_power, with_nes, only_num, with_class, font_size.

Parameters

g	The digraph to export.
output	Output stream for the DOT data.

Definition at line 280 of file load_digraph.H.

References Aleph::blossom_maximum_cardinality_matching(), Aleph::font_size, Aleph::generate_dot_file(), LocateFunctions< Container, Type >::get_it(), Aleph::Dlink::Iterator::has_curr(), Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne(), Aleph::only_num, output, Aleph::ranks(), Aleph::with_class, Aleph::with_nes, and Aleph::with_power.

Referenced by Aleph::generate_dot_file(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

generate_graphpic()

template<AlephGraph GT, class Write_Node , class Write_Arc , class Shade_Node , class Shade_Arc , ArcFilter< GT > SA>

void Aleph::generate_graphpic	(	const GT &	g,
		const double &	xdist,
		const double &	ydist,
		std::ostream &	output
	)

Generate a graphpic specification for graph visualization.

Creates a text specification for the graphpic drawing program. Handles both graphs and digraphs, with support for curved arcs when bidirectional edges exist.

Template Parameters

• GT: Graph or digraph type
• Write_Node: Functor returning node label as string
• Write_Arc: Functor returning arc label as string
  
• Shade_Node: Functor returning shading command (e.g., "SHADOW-NODE")
• Shade_Arc: Functor returning shading command (e.g., "SHADOW-ARC")
• SA: Arc filter class

Parameters

g	The graph or digraph to visualize
xdist	Horizontal distance between nodes
ydist	Vertical distance between levels (currently unused)
output	Output stream for the graphpic specification

See also

Filter_Iterator For arc filtering

Definition at line 161 of file generate_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne(), nodes, output, and Aleph::size().

generate_graphviz() [1/2]

template<AlephGraph GT, class Node_Attr , class Arc_Attr , NodeFilter< GT > SN, ArcFilter< GT > SA>

void Aleph::generate_graphviz	(	const GT &	g,
		std::ostream &	out,
		Node_Attr	node_attr = Node_Attr(),
		Arc_Attr	arc_attr = Arc_Attr(),
		const std::string &	rankdir = "TB"
	)

Generate Graphviz DOT output with custom attribute functors.

Creates a DOT specification using custom functors to generate node and arc attributes. This is the most flexible version, allowing complete control over the DOT output.

Attribute Functors

• Node_Attr: Called as node_attr(g, node, out) to write attributes
• Arc_Attr: Called as arc_attr(g, arc, out) to write attributes

Example attribute functor:

struct MyNodeAttr {
  void operator()(const Graph& g, Graph::Node* n, std::ostream& out) {
    out << "label=\"" << n->get_info() << "\" color=blue";
  }
};

Template Parameters

GT	Graph type
Node_Attr	Node attribute generator functor
Arc_Attr	Arc attribute generator functor
SN	Node filter class
SA	Arc filter class

Parameters

g	Graph to visualize
out	Output stream for DOT specification
node_attr	Functor for node attributes
arc_attr	Functor for arc attributes
rankdir	Layout direction: "TB", "BT", "LR", "RL"

See also

Filter_Iterator For filtering

Definition at line 365 of file generate_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), GraphCommon< GT, Node, Arc >::is_digraph(), Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne(), and out.

generate_graphviz() [2/2]

template<AlephGraph GT, class Write_Node , class Write_Arc , class Shade_Node , class Shade_Arc , class Dashed_Node , class Dashed_Arc , ArcFilter< GT > SA, NodeFilter< GT > SN>

void Aleph::generate_graphviz	(	const GT &	g,
		std::ostream &	output,
		const std::string &	rankdir = "TB",
		float	ranksep = 0.2,
		float	nodesep = 0.2
	)

Generate a Graphviz DOT specification for graph visualization.

Creates a DOT format specification for the Graphviz system (dot, neato, etc.). Supports both graphs and digraphs with configurable layout direction.

Template Parameters

• GT: Graph or digraph type
• Write_Node: Functor returning node label
• Write_Arc: Functor returning arc label
• Shade_Node: Returns true to apply bold style to node
• Shade_Arc: Returns true to apply bold style to arc
• Dashed_Node: (unused) For dashed node borders
• Dashed_Arc: (unused) For dashed arc lines
• SA: Arc filter class
• SN: Node filter class

Parameters

g	The graph or digraph to visualize
output	Output stream for the DOT specification
rankdir	Layout direction: "TB" (top-bottom), "BT", "LR", "RL"
ranksep	Separation between ranks (topological levels)
nodesep	Separation between nodes in the same rank

See also

Filter_Iterator For node/arc filtering

Definition at line 249 of file generate_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), GraphCommon< GT, Node, Arc >::is_digraph(), Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne(), nodes, and output.

Referenced by Aleph::Generate_Graphviz< GT, Write_Node, Write_Arc, Shade_Node, Shade_Arc, Dashed_Node, Dashed_Arc, SA, SN >::operator()().

generate_net_graph()

template<AlephGraph GT, class Write_Node , class Write_Arc , class Shade_Node , class Shade_Arc , ArcFilter< GT > SA>

void Aleph::generate_net_graph	(	GT &	g,
		const size_t &	nodes_by_level,
		const double &	xdist,
		const double &	ydist,
		std::ostream &	out
	)

Generate a net-graph layout specification for graphpic.

Creates a graphpic specification with nodes arranged in a regular grid (net) pattern. Each level has exactly nodes_by_level nodes.

Template Parameters

GT	Graph type
Write_Node	Functor returning node label string
Write_Arc	Functor returning arc label string
Shade_Node	Functor returning shading command (e.g., "SHADOW-NODE")
Shade_Arc	Functor returning shading command (e.g., "SHADOW-ARC")
SA	Arc filter

Parameters

g	Graph to visualize
nodes_by_level	Nodes per level (last level may have fewer)
xdist	Horizontal distance between nodes
ydist	Vertical distance between levels
out	Output stream for graphpic specification

Definition at line 850 of file generate_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_num_nodes(), GraphCommon< GT, Node, Arc >::is_digraph(), and out.

Referenced by Aleph::generate_net_graph(), and generate_net_spanning_tree().

generate_net_spanning_tree()

template<AlephGraph GT, class Write_Node , class Write_Arc , ArcFilter< GT > SA>

void generate_net_spanning_tree	(	GT &	g,
		const size_t &	nodes_by_level,
		const double &	xdist,
		const double &	ydist,
		std::ofstream &	output
	)

Generate a net-layout visualization of a spanning tree.

Creates a graphpic specification with nodes arranged in a regular grid (net) pattern, with spanning tree edges highlighted.

Template Parameters

GT	Graph type
Write_Node	Functor to convert node content to string
Write_Arc	Functor to convert arc content to string
SA	Arc filter class

Parameters

g	The graph containing the spanning tree
nodes_by_level	Number of nodes per level in the layout
xdist	Horizontal distance between nodes
ydist	Vertical distance between levels
output	Output stream for the graphpic specification

See also

generate_net_graph() For the underlying layout function

Definition at line 170 of file generate_spanning_tree_picture.H.

References Aleph::blossom_maximum_cardinality_matching(), Aleph::generate_net_graph(), and output.

graph_to_tree_node()

template<AlephGraph GT, typename Key , class Convert , ArcFilter< GT > SA = Dft_Show_Arc<GT>>

Tree_Node< Key > * Aleph::graph_to_tree_node ( GT &  g, typename GT::Node *  groot  )

inline

Convert a tree graph to a Tree_Node structure.

Takes a tree represented as an adjacency-list graph and converts it to a Tree_Node<Key> structure rooted at the specified node.

This enables the use of tree-specific algorithms and visualization tools on spanning trees extracted from graphs.

Conversion Process

The Convert class is invoked for each node:

void Convert::operator()(GT::Node* gnode, Tree_Node<Key>* tnode)

It should copy/transform data from the graph node to the tree node.

Limitations

• Tree_Node<Key> cannot store arc data (only node data)
• The Key type may differ from GT::Node's data type
• Requires the input graph to be acyclic (a tree)

Template Parameters

GT	Graph type (derived from List_Graph)
Key	Data type for tree nodes
Convert	Converter class with operator()(gnode, tnode)
SA	Arc filter (default: show all arcs)

Parameters

g	The tree graph to convert
groot	Node to use as the tree root

Returns

Root of the new Tree_Node<Key> tree

Exceptions

std::domain_error	If the graph is not acyclic
std::bad_alloc	If memory allocation fails

Note

Uses the Convert_Tree bit to mark visited arcs.

Performs an acyclicity check which adds O(V+E) overhead.

See also

Tree_Node Target tree structure

is_graph_acyclique() Acyclicity verification

Definition at line 162 of file graph_to_tree.H.

References ah_domain_error_if, and Aleph::blossom_maximum_cardinality_matching().

greedy_coloring()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

size_t Aleph::greedy_coloring	(	const GT &	g,
		DynMapTree< typename GT::Node *, size_t > &	colors
	)

Greedy graph coloring in iteration order.

Assigns each node the smallest 0-based color index not already used by any of its colored neighbors, visiting nodes in their natural graph- iteration order. Uses at most \(\Delta+1\)colors where \(\Delta\) is the maximum degree.

Template Parameters

GT	Graph type (List_Graph, List_Digraph, Array_Graph, …).
SA	Arc-filter functor (defaults to Dft_Show_Arc<GT>).

Parameters

[in]	g	Input graph. Must not contain self-loops.
[out]	colors	Output map from GT::Node* to 0-based color index. Cleared and overwritten on entry.

Returns

Number of distinct colors used ( \(\geq 1\)for non-empty graphs, 0 for an empty graph).

Exceptions

std::domain_error

if g contains a self-loop.

Precondition

No self-loops in g.

Note

Complexity: \(O((V+E) \log V)\).

Thread safety: not thread-safe. Temporarily writes to NODE_COOKIE on every node during execution; prior cookie values are saved and restored automatically via Cookie_Saver before the function returns (even under exceptions). Do not call concurrently with any other code that reads or writes node cookies.

Definition at line 197 of file Graph_Coloring.H.

References Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_node_it(), GraphCommon< GT, Node, Arc >::get_num_nodes(), Aleph::DynSetTree< Key, Tree, Compare >::insert(), NODE_COOKIE, and w.

Referenced by demo_algorithm_comparison(), demo_exam_scheduling(), main(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

has_cycle()

template<AlephGraph GT>

bool Aleph::has_cycle ( const GT &  g )

inline

Return true if an undirected graph has at least one cycle.

Parameters

[in]

g

Graph to test.

Returns

true if g contains a cycle; false otherwise.

See also

is_graph_acyclique()

Definition at line 853 of file tpl_graph_utils.H.

References Aleph::blossom_maximum_cardinality_matching(), and Aleph::is_graph_acyclique().

Referenced by TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

hopcroft_karp_matching()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

void Aleph::hopcroft_karp_matching	(	const GT &	g,
		DynDlist< typename GT::Arc * > &	matching
	)

Computes a maximum cardinality matching on a bipartite graph using the Hopcroft-Karp algorithm.

The Hopcroft-Karp algorithm runs in O(E * sqrt(V)) time, which is more efficient than the max-flow based approach for sparse bipartite graphs.

This implementation handles disconnected graphs correctly.

Parameters

[in]	g	the bipartite graph.
[out]	matching	list of arcs forming the maximum matching.

Exceptions

domain_error

if the graph is not bipartite.

Definition at line 434 of file tpl_bipartite.H.

References ah_domain_error_if, Aleph::and, Aleph::DynSetTree< Key, Tree, Compare >::append(), Aleph::blossom_maximum_cardinality_matching(), Aleph::DynListQueue< T >::get(), GraphCommon< GT, Node, Arc >::get_connected_node(), GraphCommon< GT, Node, Arc >::get_num_nodes(), Aleph::DynListQueue< T >::is_empty(), Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne(), NODE_COOKIE, NODE_COUNTER, and Aleph::DynListQueue< T >::put().

hungarian_assignment()

template<typename Cost_Type >

Hungarian_Result< Cost_Type > Aleph::hungarian_assignment

(

const DynMatrix< Cost_Type > &

cost

)

Compute minimum-cost assignment (free function).

Convenience free function that returns a Hungarian_Result.

Template Parameters

Cost_Type

Numeric type for costs.

Parameters

[in]

cost

The m x n cost matrix.

Returns

Hungarian_Result with optimal assignment.

Example

DynMatrix<int> cost(3, 3);
// ... fill ...
auto result = hungarian_assignment(cost);

Definition at line 470 of file Hungarian.H.

References Aleph::blossom_maximum_cardinality_matching(), Aleph::Hungarian_Result< Cost_Type >::col_to_row, Aleph::Hungarian_Result< Cost_Type >::orig_cols, Aleph::Hungarian_Result< Cost_Type >::orig_rows, Aleph::Hungarian_Result< Cost_Type >::row_to_col, and Aleph::Hungarian_Result< Cost_Type >::total_cost.

Referenced by Aleph::hungarian_max_assignment(), and TEST().

hungarian_max_assignment()

template<typename Cost_Type >

Hungarian_Result< Cost_Type > Aleph::hungarian_max_assignment

(

const DynMatrix< Cost_Type > &

cost

)

Compute maximum-profit assignment (free function).

Negates the cost matrix and solves the resulting minimization problem. The returned total_cost is the maximum profit (positive).

Template Parameters

Cost_Type

Numeric type for costs.

Parameters

[in]

cost

The m x n profit matrix.

Returns

Hungarian_Result with optimal assignment maximizing profit.

Example

DynMatrix<int> profit(3, 3);
// ... fill with profits ...
auto result = hungarian_max_assignment(profit);
// result.total_cost is the maximum total profit

Definition at line 508 of file Hungarian.H.

References ah_overflow_error_if, Aleph::and, Aleph::blossom_maximum_cardinality_matching(), Aleph::Hungarian_Result< Cost_Type >::col_to_row, cols, Aleph::DynMatrix< T >::cols(), Aleph::hungarian_assignment(), Aleph::Hungarian_Result< Cost_Type >::orig_cols, Aleph::Hungarian_Result< Cost_Type >::orig_rows, Aleph::DynMatrix< T >::read(), Aleph::Hungarian_Result< Cost_Type >::row_to_col, rows, Aleph::DynMatrix< T >::rows(), and Aleph::Hungarian_Result< Cost_Type >::total_cost.

Referenced by example_maximization(), TEST(), and TEST().

in_arcs()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

DynList< typename GT::Arc * > Aleph::in_arcs	(	typename GT::Node *	p,
		SA	sa = SA()
	)

Return the filtered incoming arcs of p.

Parameters

[in]	p	node pointer
[in]	sa	arc filter

Definition at line 1969 of file tpl_graph.H.

References Aleph::DynList< T >::append(), Aleph::blossom_maximum_cardinality_matching(), and Aleph::Digraph_Iterator< GT, Filter >::has_curr().

in_degree()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

size_t Aleph::in_degree	(	typename GT::Node *	p,
		SA	sa = SA()
	)

Compute the filtered in degree of node p.

Note

This function computes the degree, it does not retrieve it.

Parameters

[in]	p	node pointer
[in]	sa	arc filter (by default all the arcs are counted)

Returns

the incoming degree

Note

in_degree<GT>(p) counts every incoming arc.

Definition at line 2040 of file tpl_graph.H.

References Aleph::count(), and Aleph::Digraph_Iterator< GT, Filter >::has_curr().

Referenced by Aleph::Random_Digraph< GT, Init_Node, Init_Arc >::connect().

in_nodes()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

DynList< typename GT::Node * > Aleph::in_nodes	(	typename GT::Node *	p,
		SA	sa = SA()
	)

Return the nodes connected to the filtered incoming arcs to p.

Parameters

[in]	p	node pointer
[in]	sa	arc filter

Returns

A DynList<typename GT::Node*> with the pointer to the incoming nodes

Definition at line 1937 of file tpl_graph.H.

References Aleph::DynList< T >::append(), Aleph::blossom_maximum_cardinality_matching(), and Aleph::Digraph_Iterator< GT, Filter >::has_curr().

Referenced by TEST().

in_pairs()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

DynList< ArcPair< GT > > Aleph::in_pairs	(	typename GT::Node *	p,
		SA	sa = SA()
	)

Return the filtered incoming pairs of (arc,node) related to node p

Parameters

[in]	p	node pointer
[in]	sa	arc filter

Definition at line 1999 of file tpl_graph.H.

References Aleph::Dlink::append(), Aleph::blossom_maximum_cardinality_matching(), GTArcCommon< ArcInfo >::get_connected_node(), and Aleph::Digraph_Iterator< GT, Filter >::has_curr().

inconnected_components()

template<AlephGraph GT>

DynList< GT > Aleph::inconnected_components ( const GT &  g )

inline

Forward declaration for inconnected_components().

Compute the connected components as mapped subgraphs.

Builds a DynList<GT> where each element is a subgraph containing one connected component of g.

Side effects:

• Resets all node and arc control attributes via g.reset_nodes() and g.reset_arcs().
• Uses the Build_Subtree control bit on both nodes and arcs.
• Maps nodes and arcs between each subgraph and g via cookies.

Parameters

[in]

g

Graph to split.

Returns

List of mapped subgraphs, one per connected component.

Exceptions

bad_alloc

If there is not enough memory.

See also

build_subgraph(), copy_graph()

Definition at line 955 of file tpl_graph_utils.H.

References Aleph::and, Aleph::DynList< T >::append(), Aleph::blossom_maximum_cardinality_matching(), Aleph::build_subgraph(), Aleph::Build_Subtree, Aleph::count(), Aleph::DynList< T >::get_last(), GraphCommon< GT, Node, Arc >::get_node_it(), GraphCommon< GT, Node, Arc >::get_num_nodes(), IS_NODE_VISITED, GraphCommon< GT, Node, Arc >::reset_arcs(), and GraphCommon< GT, Node, Arc >::reset_nodes().

Referenced by TEST().

inter_copy_graph()

template<AlephGraph GTT, AlephGraph GTS, class Copy_Node = Dft_Copy_Node<GTT, GTS>, class Copy_Arc = Dft_Copy_Arc<GTT, GTS>>

void Aleph::inter_copy_graph	(	GTT &	gtgt,
		const GTS &	gsrc,
		const bool	cookie_map = false
	)

Copy between different types of graphs.

Parameters

[in]	gtgt	target graph
[in]	gsrc	source graph
[in]	cookie_map	if true ==> a mapping will be done through nodes and arcs cookies

Definition at line 3764 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), Aleph::clear_graph(), and Aleph::DynMapTree< Key, Data, Tree, Compare >::insert().

invert_digraph()

template<AlephGraph GT>

GT Aleph::invert_digraph

(

const GT &

g

)

Compute the transpose (arc-reversed) digraph.

Builds a new digraph containing the same nodes as g and every arc reversed.

Side effects:

• Resets all node and arc control attributes via g.reset_nodes() and g.reset_arcs().
• Maps nodes and arcs between g and the returned digraph via cookies.

Parameters

[in]

g

Input digraph.

Returns

The transposed digraph, mapped to g.

Exceptions

domain_error	If g is not a digraph.
bad_alloc	If there is not enough memory.

Definition at line 1834 of file tpl_graph_utils.H.

References ah_domain_error_unless, Aleph::and, Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_arc_it(), GTArcCommon< ArcInfo >::get_info(), GraphCommon< GT, Node, Arc >::get_node_it(), GraphCommon< GT, Node, Arc >::get_num_arcs(), GraphCommon< GT, Node, Arc >::get_num_nodes(), GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), Aleph::List_Graph< _Graph_Node, _Graph_Arc >::insert_node(), GraphCommon< GT, Node, Arc >::is_digraph(), GraphCommon< GT, Node, Arc >::map_arcs(), GraphCommon< GT, Node, Arc >::map_nodes(), GraphCommon< GT, Node, Arc >::reset_arcs(), and GraphCommon< GT, Node, Arc >::reset_nodes().

Referenced by Aleph::Lengauer_Tarjan_Post_Dominators< GT, SA >::ensure_computed(), Aleph::kosaraju_connected_components(), Aleph::kosaraju_connected_components(), TEST(), and TEST().

is_graph_acyclique() [1/2]

template<AlephGraph GT>

bool Aleph::is_graph_acyclique ( const GT &  g )

inline

Return true if an undirected graph is acyclic.

Equivalent to calling is_graph_acyclique(g, node) for every connected component of g.

Note

Uses the Test_Cycle control bit on both nodes and arcs.

Returns true for empty graphs.

Parameters

[in]

g

Graph to test.

Returns

true if g is acyclic; false otherwise.

Exceptions

domain_error

If g is a directed graph.

See also

has_cycle(), is_graph_acyclique(const GT&, typename GT::Node*)

Definition at line 812 of file tpl_graph_utils.H.

References Aleph::__is_graph_acyclique(), ah_domain_error_if, Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_node_it(), GraphCommon< GT, Node, Arc >::get_num_arcs(), GraphCommon< GT, Node, Arc >::get_num_nodes(), GraphCommon< GT, Node, Arc >::is_digraph(), IS_NODE_VISITED, num_nodes, GraphCommon< GT, Node, Arc >::reset_bit_arcs(), GraphCommon< GT, Node, Arc >::reset_bit_nodes(), and Aleph::Test_Cycle.

is_graph_acyclique() [2/2]

template<AlephGraph GT>

bool Aleph::is_graph_acyclique ( const GT &  g, typename GT::Node *  start_node  )

inline

Return true if an undirected graph is acyclic.

This is a cycle-detection routine for undirected graphs. It performs a DFS-like traversal while marking arcs to avoid immediately revisiting the parent edge.

Note

Uses the Test_Cycle control bit on both nodes and arcs.

Returns true for empty graphs.

Parameters

[in]	g	Graph to test.
[in]	start_node	Starting node (must be non-null and belong to g).

Returns

true if the component reachable from start_node is acyclic; false otherwise.

Exceptions

domain_error

If g is a directed graph.

See also

has_cycle(), is_graph_acyclique(const GT&)

Definition at line 772 of file tpl_graph_utils.H.

References Aleph::__is_graph_acyclique(), ah_domain_error_if, ah_invalid_argument_if, Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_num_arcs(), GraphCommon< GT, Node, Arc >::get_num_nodes(), GraphCommon< GT, Node, Arc >::is_digraph(), num_nodes, GraphCommon< GT, Node, Arc >::reset_bit_arcs(), GraphCommon< GT, Node, Arc >::reset_bit_nodes(), and Aleph::Test_Cycle.

Referenced by Aleph::has_cycle(), TEST(), TEST(), TEST(), and TEST().

is_planar_graph() [1/2]

template<AlephGraph GT>

bool Aleph::is_planar_graph	(	const GT &	g,
		const Planarity_Test_Options &	options
	)

Overload with default arc selector.

Definition at line 2698 of file Planarity_Test.H.

References Aleph::blossom_maximum_cardinality_matching(), and options.

is_planar_graph() [2/2]

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

bool Aleph::is_planar_graph	(	const GT &	g,
		SA	sa = SA(),
		const Planarity_Test_Options &	options = Planarity_Test_Options()
	)

High-level boolean check for graph planarity.

A convenience API that returns only the planarity status.

Parameters

[in]	g	The input graph.
[in]	sa	Arc filter.
[in]	options	Configuration (used if embedding is needed for check).

Returns

true if the graph is planar, false otherwise.

Definition at line 2686 of file Planarity_Test.H.

References Aleph::blossom_maximum_cardinality_matching(), Aleph::Planarity_Test_Result< GT >::is_planar, and options.

Referenced by TEST(), TEST(), TEST(), and TEST().

is_strongly_connected()

template<AlephGraph GT>

bool Aleph::is_strongly_connected ( const GT &  g )

inline

Check if a directed graph is strongly connected.

A directed graph is strongly connected if there is exactly one SCC containing all nodes.

Template Parameters

GT	Graph type (must be a directed graph).

Parameters

[in]

g

The directed graph.

Returns

true if the graph is strongly connected, false otherwise.

Note

An empty graph or a graph with a single node is considered strongly connected.

Author

Leandro Rabindranath León

Definition at line 404 of file kosaraju.H.

References GraphCommon< GT, Node, Arc >::get_num_nodes(), and Aleph::kosaraju_scc_count().

Referenced by TEST(), TEST(), TEST(), and TEST().

is_valid_coloring()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

bool Aleph::is_valid_coloring	(	const GT &	g,
		const DynMapTree< typename GT::Node *, size_t > &	colors
	)

Validates a graph coloring.

A coloring is valid iff every graph node has a color entry in colors and no arc connects two nodes of the same color. Self-loops are considered invalid regardless of color assignment.

A size match alone between colors and the graph is insufficient: the map could be keyed with foreign (non-graph) pointers of the same count. This function explicitly verifies that every GT::Node* in g has an entry before checking arc conflicts.

Template Parameters

GT	Graph type (List_Graph, List_Digraph, Array_Graph, …).
SA	Arc-filter functor (defaults to Dft_Show_Arc<GT>).

Parameters

[in]	g	Graph to validate against.
[in]	colors	Map from GT::Node* to 0-based color index.

Returns

true iff every node is present in colors and no arc connects same-colored endpoints; false otherwise (including self-loops and missing/foreign map entries).

Note

Complexity: \(O((V+E) \log V)\).

Does not modify any graph state. Thread-safe provided g and colors are not concurrently modified.

Definition at line 442 of file Graph_Coloring.H.

References Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_arc_it(), GraphCommon< GT, Node, Arc >::get_node_it(), GraphCommon< GT, Node, Arc >::get_src_node(), and GraphCommon< GT, Node, Arc >::get_tgt_node().

Referenced by demo_algorithm_comparison(), demo_cookie_safety(), demo_register_allocation(), print_coloring(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

karp_minimum_mean_cycle()

template<AlephGraph GT, ArcDistance< GT > Distance = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

Min_Mean_Cycle_Result< GT, typename Distance::Distance_Type > Aleph::karp_minimum_mean_cycle	(	const GT &	g,
		Distance	distance = Distance(),
		SA	sa = SA()
	)

Compute minimum mean cycle by Karp's algorithm.

Behavior:

• If the digraph has no directed cycle, has_cycle = false.
• Otherwise returns minimum_mean and a witness cycle extracted from predecessor chains.

Template Parameters

GT	Directed Aleph graph type.
Distance	Arc cost accessor (Distance::Distance_Type required).
SA	Arc filter.

Parameters

[in]	g	Graph (must be directed).
[in]	distance	Arc cost accessor.
[in]	sa	Arc filter.

Returns

Min_Mean_Cycle_Result<GT, Cost_Type>.

Exceptions

domain_error	If `g` is undirected.
domain_error	If floating weights are not finite.
overflow_error	If integer additions overflow.

Definition at line 186 of file Min_Mean_Cycle.H.

References ah_domain_error_if, ah_overflow_error_if, ah_runtime_error_if, Aleph::and, Aleph::DynMapTree< Key, Data, Tree, Compare >::append(), Aleph::blossom_maximum_cardinality_matching(), Aleph::shortest_path_detail::checked_add(), Aleph::DynMapTree< Key, Data, Tree, Compare >::find(), GraphCommon< GT, Node, Arc >::get_num_nodes(), GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), Aleph::Array_Iterator< T >::has_curr(), Aleph::DynMapTree< Key, Data, Tree, Compare >::insert(), GraphCommon< GT, Node, Arc >::is_digraph(), k, Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne(), nodes, pred, Aleph::Array< T >::reserve(), Aleph::min_mean_cycle_detail::validate_finite_accumulator(), and Aleph::min_mean_cycle_detail::validate_weights().

Referenced by main(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

karp_minimum_mean_cycle_value()

template<AlephGraph GT, ArcDistance< GT > Distance = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

Min_Mean_Cycle_Value_Result Aleph::karp_minimum_mean_cycle_value	(	const GT &	g,
		Distance	distance = Distance(),
		SA	sa = SA()
	)

Compute only the minimum mean value (without witness walk).

This variant avoids predecessor storage and witness reconstruction. It is useful when only the optimal mean value is required.

Definition at line 453 of file Min_Mean_Cycle.H.

References ah_domain_error_if, ah_overflow_error_if, Aleph::blossom_maximum_cardinality_matching(), Aleph::shortest_path_detail::checked_add(), Aleph::DynMapTree< Key, Data, Tree, Compare >::find(), GraphCommon< GT, Node, Arc >::get_num_nodes(), GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), Aleph::Array_Iterator< T >::has_curr(), Aleph::Min_Mean_Cycle_Value_Result::has_cycle, Aleph::DynMapTree< Key, Data, Tree, Compare >::insert(), GraphCommon< GT, Node, Arc >::is_digraph(), k, Aleph::Min_Mean_Cycle_Value_Result::minimum_mean, Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne(), Aleph::Array< T >::reserve(), Aleph::min_mean_cycle_detail::validate_finite_accumulator(), and Aleph::min_mean_cycle_detail::validate_weights().

Referenced by main(), TEST(), TEST(), TEST(), TEST(), and TEST().

kosaraju_connected_components() [1/2]

template<AlephGraph GT>

DynList< DynList< typename GT::Node * > > Aleph::kosaraju_connected_components ( const GT &  g )

inline

Compute strongly connected components as lists of nodes.

This is a lightweight version of Kosaraju's algorithm that returns the SCCs as lists of node pointers rather than full subgraphs. This is more efficient when you only need to know which nodes belong to which component, without needing the induced subgraphs.

Time complexity: O(V + E) Space complexity: O(V + E) for the transposed graph

Template Parameters

GT	Graph type (must be a directed graph).

Parameters

[in]

g

The directed graph.

Returns

A list of lists, where each inner list contains the nodes belonging to one SCC. The nodes are pointers to the original graph's nodes.

Note

This version is faster than the subgraph version because it doesn't need to build and map subgraphs.

Warning

This function modifies the control bits (Depth_First) on nodes and arcs. The bits are reset at the start.

See also

kosaraju_connected_components(g, blk_list, arc_list) for the version that builds mapped subgraphs

Author

Leandro Rabindranath León

Definition at line 301 of file kosaraju.H.

References Aleph::__dfp_phase1(), Aleph::__dfp_phase2_list(), Aleph::DynList< T >::append(), Aleph::blossom_maximum_cardinality_matching(), Aleph::Depth_First, Aleph::df(), GraphCommon< GT, Node, Arc >::get_node_it(), Aleph::invert_digraph(), IS_NODE_VISITED, GraphCommon< GT, Node, Arc >::reset_arcs(), and GraphCommon< GT, Node, Arc >::reset_nodes().

kosaraju_connected_components() [2/2]

template<AlephGraph GT>

void Aleph::kosaraju_connected_components ( const GT &  g, DynList< GT > &  blk_list, DynList< typename GT::Arc * > &  arc_list  )

inline

Compute strongly connected components using Kosaraju's algorithm.

This function computes the strongly connected components (SCCs) of a directed graph using Kosaraju's algorithm. The algorithm works in two phases:

1. First DFS: Traverse the original graph and compute finish times (nodes are ordered by when they finish, stored in postorder).
2. Second DFS: Create the transposed graph, then process nodes in decreasing order of finish time. Each DFS tree in this phase forms one SCC.

The resulting SCCs are returned as subgraphs, with nodes and arcs mapped to the original graph via cookies. Arcs that cross between different SCCs are collected in a separate list.

Time complexity: O(V + E) Space complexity: O(V + E) for the transposed graph

Template Parameters

GT	Graph type (must be a directed graph).

Parameters

[in]	g	The directed graph. Must not be modified during execution.
[out]	blk_list	List of subgraphs, one per SCC. Each subgraph is mapped to g via node and arc cookies.
[out]	arc_list	List of arcs that cross between different SCCs (inter-component arcs).

Note

If the graph is strongly connected, blk_list will contain a single subgraph with all nodes, and arc_list will be empty.

Warning

This function modifies the control bits (Depth_First) on nodes and arcs. The bits are reset at the start.

See also

tarjan_connected_components() for an alternative algorithm

invert_digraph() used internally to create the transposed graph

Author

Leandro Rabindranath León

Definition at line 212 of file kosaraju.H.

References Aleph::__dfp_phase1(), Aleph::__dfp_phase2_subgraph(), Aleph::DynArray< T >::access(), Aleph::DynList< T >::append(), Aleph::blossom_maximum_cardinality_matching(), Aleph::color(), Aleph::Depth_First, Aleph::df(), GraphCommon< GT, Node, Arc >::get_arc_it(), GraphCommon< GT, Node, Arc >::get_node_it(), GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), Aleph::invert_digraph(), IS_NODE_VISITED, GraphCommon< GT, Node, Arc >::map_arcs(), NODE_COLOR, GraphCommon< GT, Node, Arc >::reset_arcs(), and GraphCommon< GT, Node, Arc >::reset_nodes().

Referenced by example_basic_sccs(), example_dag(), example_lightweight_version(), example_strongly_connected(), Aleph::kosaraju_scc_count(), Aleph::Kosaraju_Connected_Components< GT >::operator()(), Aleph::Kosaraju_Connected_Components< GT >::operator()(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

kosaraju_scc_count()

template<AlephGraph GT>

size_t Aleph::kosaraju_scc_count ( const GT &  g )

inline

Count the number of strongly connected components.

Computes the number of SCCs in the graph without building the actual component lists.

Template Parameters

GT	Graph type (must be a directed graph).

Parameters

[in]

g

The directed graph.

Returns

The number of strongly connected components.

Author

Leandro Rabindranath León

Definition at line 383 of file kosaraju.H.

References Aleph::kosaraju_connected_components().

Referenced by Aleph::is_strongly_connected(), and TEST().

load_digraph()

void Aleph::load_digraph ( Digrafo &  g, std::istream &  nodes_input, std::istream &  arcs_input  )

inline

Load nodes and arcs from streams into the directed graph.

Reads nodes from a pipe-separated file and arcs from a space/comma separated file, populating the graph.

The nodes file format:

• First line is a header (ignored)
• Subsequent lines: field1|field2|...|fieldN
• Lines with fewer than MIN_NODE_FIELDS are skipped
• field[0] is used as the node ID

The arcs file format:

• Each line: source_id target_id (or source_id,target_id)
• Lines with fewer than 2 IDs are skipped
• If a referenced node doesn't exist, it's created with empty fields

Parameters

g	The digraph to populate.
nodes_input	Input stream for node data.
arcs_input	Input stream for arc data.

Definition at line 201 of file load_digraph.H.

References Aleph::blossom_maximum_cardinality_matching(), Aleph::load_digraph(), Aleph::MIN_NODE_FIELDS, Aleph::search_node(), Aleph::DynDlist< T >::size(), and Aleph::split().

Referenced by Aleph::load_digraph(), main(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

map_arcs()

template<AlephGraph GTS, AlephGraph GTT>

void Aleph::map_arcs ( typename GTS::Arc *  p, typename GTT::Arc *  q  )

noexcept

Map two arcs of different types of graphs through their cookies.

Note

It is intended that the mapping be done between at least homomorphic graphs

Parameters

[in]	p	pointer to the source arc
[in]	q	pointer to the target arc

Definition at line 3642 of file tpl_graph.H.

References Aleph::and, ARC_COOKIE, and Aleph::blossom_maximum_cardinality_matching().

map_cut_graph()

template<AlephGraph GT>

std::tuple< GT, DynList< typename GT::Arc * > > Aleph::map_cut_graph	(	const GT &	g,
		const DynList< typename GT::Node * > &	cut_node_list
	)

Extract the cut graph and cross-arc list.

Requires a graph previously processed by:

• compute_cut_nodes(): marks cut nodes with the Cut bit
• paint_subgraphs(): paints blocks and marks cross/cut arcs

The returned cut graph contains:

• all cut nodes
• all cut arcs (arcs between cut nodes; marked with the Cut bit on arcs)

Cross arcs (cut → non-cut) are returned separately in cross_arc_list.

Parameters

[in]	g	Painted graph.
[in]	cut_node_list	Cut nodes list.

Returns

{cut_graph, cross_arc_list}.

Exceptions

bad_alloc

If there is not enough memory.

See also

map_subgraph(), compute_cut_nodes(), paint_subgraphs()

Definition at line 1751 of file tpl_graph_utils.H.

References Aleph::and, Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_arc_it(), GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), GraphCommon< GT, Node, Arc >::map_arcs(), and GraphCommon< GT, Node, Arc >::map_nodes().

Referenced by TEST(), and TEST().

map_in_arcs()

template<AlephGraph GT, typename T >

auto Aleph::map_in_arcs ( typename GT::Node *  p, std::function< T(typename GT::Arc *)>  op  )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Compatibility overload deducing T from an actual std::function<T (typename GT::Arc *)> argument; see the equivalent nodes_map overload for why the generic one above cannot deduce it.

Definition at line 2261 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching().

map_nodes()

template<AlephGraph GTS, AlephGraph GTT>

void Aleph::map_nodes ( typename GTS::Node *  p, typename GTT::Node *  q  )

noexcept

Map two nodes of different types of graphs through their cookies.

Note

It is intended that the mapping be done between at least homomorphic graphs

Parameters

[in]	p	pointer to the source node
[in]	q	pointer to the target node

Definition at line 3614 of file tpl_graph.H.

References Aleph::and, Aleph::blossom_maximum_cardinality_matching(), and NODE_COOKIE.

map_out_arcs()

template<AlephGraph GT, typename T >

auto Aleph::map_out_arcs ( typename GT::Node *  p, std::function< T(typename GT::Arc *)>  op  )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Compatibility overload deducing T from an actual std::function<T (typename GT::Arc *)> argument; see the equivalent nodes_map overload for why the generic one above cannot deduce it.

Definition at line 2453 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching().

map_subgraph()

template<AlephGraph GT>

GT Aleph::map_subgraph	(	const GT &	g,
		const long	color
	)

Extract a mapped subgraph containing a given color.

Assumes g has been painted (e.g., via paint_subgraphs()) and extracts the connected block whose nodes/arcs have the given positive color.

Side effects:

• Resets the Build_Subtree control bit on all nodes and arcs.
• Uses the Build_Subtree control bit during extraction.
• Maps nodes and arcs between g and the returned subgraph via cookies.

Parameters

[in]	g	Painted graph.
[in]	color	Color value to extract.

Returns

A mapped subgraph containing only nodes/arcs with color.

Exceptions

domain_error	If color does not exist in g.
bad_alloc	If there is not enough memory.

See also

paint_subgraphs(), compute_cut_nodes(), map_cut_graph()

Definition at line 1702 of file tpl_graph_utils.H.

References Aleph::__map_subgraph(), ah_domain_error_if, Aleph::blossom_maximum_cardinality_matching(), Aleph::Build_Subtree, Aleph::color(), GraphCommon< GT, Node, Arc >::get_node_it(), Aleph::List_Graph< _Graph_Node, _Graph_Arc >::insert_node(), GraphCommon< GT, Node, Arc >::map_nodes(), NODE_BITS, GraphCommon< GT, Node, Arc >::reset_bit_arcs(), and GraphCommon< GT, Node, Arc >::reset_bit_nodes().

Referenced by TEST().

mapped_node()

template<AlephGraph GT>

Aleph::mapped_node ( typename GT::Node *  p )

noexcept

Return the mapped node through the cookie of p

Definition at line 2571 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), and NODE_COOKIE.

minimum_mean_cycle()

template<AlephGraph GT, ArcDistance< GT > Distance = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

Min_Mean_Cycle_Result< GT, typename Distance::Distance_Type > Aleph::minimum_mean_cycle	(	const GT &	g,
		Distance	distance = Distance(),
		SA	sa = SA()
	)

Alias for karp_minimum_mean_cycle().

Definition at line 607 of file Min_Mean_Cycle.H.

References Aleph::blossom_maximum_cardinality_matching().

Referenced by TEST().

minimum_mean_cycle_value()

template<AlephGraph GT, ArcDistance< GT > Distance = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

Min_Mean_Cycle_Value_Result Aleph::minimum_mean_cycle_value	(	const GT &	g,
		Distance	distance = Distance(),
		SA	sa = SA()
	)

Alias for karp_minimum_mean_cycle_value().

Definition at line 590 of file Min_Mean_Cycle.H.

References Aleph::blossom_maximum_cardinality_matching().

Referenced by TEST().

nodes_map() [1/2]

template<AlephGraph GT, typename T , template< typename > class Container = DynList, NodeFilter< GT > SN = Dft_Show_Node<GT>, class Op >
requires std::is_invocable_r_v<T, Op &, typename GT::Node *>

Container< T > Aleph::nodes_map	(	GT &	g,
		Op	transformation,
		SN	sn = SN()
	)

Map the filtered nodes of a graph to a transformed type.

Template Parameters

GT	Graph type
T	Result type
Container	Container type (default: DynList)
SN	Node filter type (default: Dft_Show_Node<GT>)

Parameters

[in]	g	the graph
[in]	transformation	function Node* -> T that transforms each node
[in]	sn	node filter functor (default: Dft_Show_Node<GT>)

Returns

a Container<T> object with all the nodes mapped through the transformation

Definition at line 1373 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching().

nodes_map() [2/2]

template<AlephGraph GT, typename T , template< typename > class Container = DynList, NodeFilter< GT > SN = Dft_Show_Node<GT>>

Container< T > Aleph::nodes_map	(	GT &	g,
		std::function< T(typename GT::Node *)>	transformation,
		SN	sn = SN()
	)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.Compatibility overload for callers that pass an actual std::function<T (typename GT::Node *)> (rather than a lambda or other callable) and rely on T being deduced from it, as the generic overload above cannot: T appears only in its return type and requires clause, never in a parameter, so it is not a deduced context there.

Definition at line 1398 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching().

nonplanar_certificate_is_valid()

template<AlephGraph GT>

bool Aleph::nonplanar_certificate_is_valid

(

const Planarity_Test_Result< GT > &

result

)

Convenience predicate over validate_nonplanar_certificate().

Definition at line 3858 of file Planarity_Test.H.

References Aleph::validate_nonplanar_certificate().

Referenced by TEST().

nonplanar_certificate_to_dot()

template<AlephGraph GT, class Node_Label = Dft_Certificate_Node_Label<GT>>

std::string Aleph::nonplanar_certificate_to_dot	(	const Planarity_Test_Result< GT > &	result,
		Node_Label	node_label = Node_Label(),
		const NonPlanar_Certificate_Export_Options &	options = NonPlanar_Certificate_Export_Options()
	)

Export non-planar certificate as GraphViz DOT.

Requires result.has_nonplanar_certificate.

Definition at line 3636 of file Planarity_Test.H.

References ah_runtime_error_unless, Aleph::and, Aleph::blossom_maximum_cardinality_matching(), Aleph::Planarity_Test_Result< GT >::certificate_branch_nodes, Aleph::Planarity_Test_Result< GT >::certificate_obstruction_edges, Aleph::Planarity_Test_Result< GT >::certificate_paths, Aleph::Planarity_Test_Result< GT >::certificate_type, Aleph::planarity_detail::collect_certificate_nodes(), Aleph::color(), Aleph::planarity_detail::dot_escape_string(), Aleph::Planarity_Test_Result< GT >::has_nonplanar_certificate, Aleph::DynSetTree< Key, Tree, Compare >::insert(), k, nodes, options, out, palette_size(), and Aleph::to_string().

Referenced by main(), TEST(), and TEST().

nonplanar_certificate_to_gexf()

template<AlephGraph GT, class Node_Label = Dft_Certificate_Node_Label<GT>>

std::string Aleph::nonplanar_certificate_to_gexf	(	const Planarity_Test_Result< GT > &	result,
		Node_Label	node_label = Node_Label(),
		const NonPlanar_Certificate_Export_Options &	options = NonPlanar_Certificate_Export_Options()
	)

Export non-planar certificate as GEXF.

Requires result.has_nonplanar_certificate.

Definition at line 3974 of file Planarity_Test.H.

References ah_runtime_error_unless, Aleph::and, Aleph::blossom_maximum_cardinality_matching(), Aleph::Planarity_Test_Result< GT >::certificate_branch_nodes, Aleph::Planarity_Test_Result< GT >::certificate_obstruction_edges, Aleph::Planarity_Test_Result< GT >::certificate_paths, Aleph::planarity_detail::collect_certificate_nodes(), Aleph::Planarity_Test_Result< GT >::has_nonplanar_certificate, Aleph::DynSetTree< Key, Tree, Compare >::insert(), k, nodes, options, out, Aleph::planarity_detail::pointer_to_string(), and Aleph::planarity_detail::xml_escape_string().

Referenced by main(), TEST(), TEST(), TEST(), and TEST().

nonplanar_certificate_to_graphml()

template<AlephGraph GT, class Node_Label = Dft_Certificate_Node_Label<GT>>

std::string Aleph::nonplanar_certificate_to_graphml	(	const Planarity_Test_Result< GT > &	result,
		Node_Label	node_label = Node_Label(),
		const NonPlanar_Certificate_Export_Options &	options = NonPlanar_Certificate_Export_Options()
	)

Export non-planar certificate as GraphML.

Requires result.has_nonplanar_certificate.

Definition at line 3870 of file Planarity_Test.H.

References ah_runtime_error_unless, Aleph::and, Aleph::blossom_maximum_cardinality_matching(), Aleph::Planarity_Test_Result< GT >::certificate_branch_nodes, Aleph::Planarity_Test_Result< GT >::certificate_obstruction_edges, Aleph::Planarity_Test_Result< GT >::certificate_paths, Aleph::planarity_detail::collect_certificate_nodes(), Aleph::Planarity_Test_Result< GT >::has_nonplanar_certificate, Aleph::DynSetTree< Key, Tree, Compare >::insert(), k, nodes, options, out, Aleph::planarity_detail::pointer_to_string(), and Aleph::planarity_detail::xml_escape_string().

Referenced by main(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

nonplanar_certificate_to_json()

template<AlephGraph GT, class Node_Label = Dft_Certificate_Node_Label<GT>>

std::string Aleph::nonplanar_certificate_to_json	(	const Planarity_Test_Result< GT > &	result,
		Node_Label	node_label = Node_Label(),
		const NonPlanar_Certificate_Export_Options &	options = NonPlanar_Certificate_Export_Options()
	)

Export non-planar certificate as JSON.

Requires result.has_nonplanar_certificate.

Definition at line 3484 of file Planarity_Test.H.

References ah_runtime_error_unless, Aleph::blossom_maximum_cardinality_matching(), Aleph::Planarity_Test_Result< GT >::certificate_branch_nodes, Aleph::Planarity_Test_Result< GT >::certificate_obstruction_edges, Aleph::Planarity_Test_Result< GT >::certificate_paths, Aleph::Planarity_Test_Result< GT >::certificate_search_truncated, Aleph::Planarity_Test_Result< GT >::certificate_type, Aleph::planarity_detail::collect_certificate_nodes(), Aleph::Planarity_Test_Result< GT >::has_nonplanar_certificate, Aleph::planarity_detail::json_escape_string(), k, nodes, options, out, Aleph::planarity_detail::pointer_to_string(), Aleph::Array< T >::size(), and Aleph::to_string().

Referenced by main(), TEST(), and TEST().

out_arcs()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

DynList< typename GT::Arc * > Aleph::out_arcs	(	typename GT::Node *	p,
		SA	sa = SA()
	)

Return the filtered incoming arcs of p.

Parameters

[in]	p	node pointer
[in]	sa	arc filter

Definition at line 1953 of file tpl_graph.H.

References Aleph::DynList< T >::append(), Aleph::blossom_maximum_cardinality_matching(), and Aleph::Digraph_Iterator< GT, Filter >::has_curr().

out_degree()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

size_t Aleph::out_degree	(	typename GT::Node *	p,
		SA	sa = SA()
	)

Compute the filtered out degree of node p

Note

This function computes the degree, it does not retrieve it.

Parameters

[in]	p	node pointer
[in]	sa	arc filter (by default all the arcs are counted)

Returns

the outcoming degree

Note

out_degree<GT>(p) counts every outgoing arc.

Definition at line 2060 of file tpl_graph.H.

References Aleph::count(), and Aleph::Digraph_Iterator< GT, Filter >::has_curr().

out_nodes()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

DynList< typename GT::Node * > Aleph::out_nodes	(	typename GT::Node *	p,
		SA	sa = SA()
	)

Return the nodes connected to the filtered outcoming arcs of p.

Parameters

[in]	p	node pointer
[in]	sa	arc filter

Returns

A DynList<typename GT::Node*> with the pointer to the outcoming nodes

Definition at line 1920 of file tpl_graph.H.

References Aleph::DynList< T >::append(), Aleph::blossom_maximum_cardinality_matching(), and Aleph::Digraph_Iterator< GT, Filter >::has_curr().

out_pairs()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

DynList< ArcPair< GT > > Aleph::out_pairs	(	typename GT::Node *	p,
		SA	sa = SA()
	)

Return the filtered outcoming pairs of (arc,node) related to node p

Parameters

[in]	p	node pointer
[in]	sa	arc filter

Returns

a DynList<ArcPair<GT>> containing the outcoming pairs

Definition at line 2018 of file tpl_graph.H.

References Aleph::Dlink::append(), Aleph::blossom_maximum_cardinality_matching(), GTArcCommon< ArcInfo >::get_connected_node(), and Aleph::Digraph_Iterator< GT, Filter >::has_curr().

paint_subgraphs()

template<AlephGraph GT>

long Aleph::paint_subgraphs ( const GT &  g, const DynList< typename GT::Node * > &  cut_node_list  )

inline

Paint connected blocks around articulation points.

Given a list of cut nodes (typically computed with compute_cut_nodes()), paints the graph so that each biconnected block around the cut nodes gets a distinct positive "color".

Color storage:

• Node colors are stored in NODE_COUNTER(node).
• Arc colors are stored in ARC_COUNTER(arc).

Special markers:

• Cut nodes keep color 0.
• Cross arcs (cut → non-cut) are marked with ARC_COUNTER(arc) == Cross_Arc.
• Cut arcs (cut → cut) are marked by setting the Cut control bit on arcs.

Return value:

• The first used color is 1.
• The function returns the next unused color value (so valid colors are in the range [1, return_value - 1]).

Protocol:

• The Cut bit on nodes must already mark cut nodes.
• Do not reset/alter node/arc control bits between computing cut nodes and calling this function.

Side effects:

• Resets all node and arc counters (colors) to 0 before painting.

Parameters

[in]	g	Graph to paint.
[in]	cut_node_list	Cut nodes list (as returned by compute_cut_nodes()).

Returns

Next unused color id (one past the last used color).

See also

compute_cut_nodes(), map_subgraph(), map_cut_graph()

Definition at line 1629 of file tpl_graph_utils.H.

References Aleph::__paint_from_cut_node(), Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::reset_counter_arcs(), and GraphCommon< GT, Node, Arc >::reset_counter_nodes().

Referenced by TEST(), and TEST().

planar_dual_metadata()

template<AlephGraph GT>

Planar_Dual_Metadata< GT > Aleph::planar_dual_metadata

(

const Planarity_Test_Result< GT > &

result

)

Build face and dual-edge metadata from a planar embedding result.

Requires result.is_planar and result.has_combinatorial_embedding.

Definition at line 2710 of file Planarity_Test.H.

References ah_runtime_error_if, ah_runtime_error_unless, Aleph::and, OhashCommon< HashTbl, Key >::append(), Aleph::Array< T >::append(), Aleph::blossom_maximum_cardinality_matching(), Aleph::DynMapTree< Key, Data, Tree, Compare >::contains(), Aleph::Planar_Dual_Metadata< GT >::Face_Boundary::darts, Aleph::Planarity_Test_Result< GT >::embedding_rotation, Aleph::Planar_Dual_Edge_Info< GT >::face_a, Aleph::DynMapTree< Key, Data, Tree, Compare >::find(), Aleph::Planarity_Test_Result< GT >::has_combinatorial_embedding, Aleph::Array_Iterator< T >::has_curr(), Aleph::Planar_Dual_Metadata< GT >::has_embedding, Aleph::DynMapTree< Key, Data, Tree, Compare >::insert(), Aleph::Array< T >::is_empty(), Aleph::Planarity_Test_Result< GT >::is_planar, m, Aleph::next(), Aleph::planarity_detail::Null_Edge, Aleph::Array< T >::remove_last(), Aleph::Array< T >::reserve(), Aleph::Planarity_Test_Result< GT >::simplified_num_edges, Aleph::Planarity_Test_Result< GT >::simplified_num_nodes, Aleph::DynSetTree< Key, Tree, Compare >::size(), OhashCommon< HashTbl, Key >::size(), and Aleph::Planar_Dual_Metadata< GT >::Face_Dart::src.

Referenced by Aleph::build_planar_dual_graph(), main(), Aleph::planar_geometric_drawing(), TEST(), TEST(), TEST(), and TEST().

planar_geometric_drawing()

template<AlephGraph GT>

Planar_Geometric_Drawing< GT > Aleph::planar_geometric_drawing	(	const Planarity_Test_Result< GT > &	result,
		const Planar_Geometric_Drawing_Options &	options = Planar_Geometric_Drawing_Options()
	)

Build embedding-aware 2D node coordinates from a planar result.

The drawing uses combinatorial embedding information. For each component, it places a candidate outer-face boundary on a circle and applies harmonic relaxation to interior nodes. Multiple deterministic outer-face candidates are evaluated to reduce crossings.

Requires result.is_planar and result.has_combinatorial_embedding.

Definition at line 3001 of file Planarity_Test.H.

References ah_runtime_error_if, ah_runtime_error_unless, Aleph::and, Aleph::Array< T >::append(), Aleph::blossom_maximum_cardinality_matching(), Aleph::DynMapTree< Key, Data, Tree, Compare >::contains(), Aleph::Planarity_Test_Result< GT >::embedding_rotation, Aleph::Array< T >::empty(), Aleph::DynMapTree< Key, Data, Tree, Compare >::find(), Aleph::Planarity_Test_Result< GT >::has_combinatorial_embedding, Aleph::Array_Iterator< T >::has_curr(), Aleph::Planar_Geometric_Drawing< GT >::has_embedding, Aleph::DynMapTree< Key, Data, Tree, Compare >::insert(), Aleph::Array< T >::is_empty(), Aleph::Planarity_Test_Result< GT >::is_planar, Aleph::Planar_Geometric_Drawing< GT >::Node_Position::node, options, Aleph::planar_dual_metadata(), Aleph::Array< T >::remove_last(), Aleph::Array< T >::reserve(), Aleph::planarity_detail::segments_properly_intersect(), Aleph::Planarity_Test_Result< GT >::simplified_num_edges, Aleph::Planarity_Test_Result< GT >::simplified_num_nodes, Aleph::Array< T >::size(), Aleph::Planar_Geometric_Drawing< GT >::Node_Position::x, and Aleph::Planar_Geometric_Drawing< GT >::Node_Position::y.

Referenced by main(), TEST(), TEST(), TEST(), TEST(), and TEST().

planarity_test() [1/2]

template<AlephGraph GT>

Planarity_Test_Result< GT > Aleph::planarity_test	(	const GT &	g,
		const Planarity_Test_Options &	options
	)

Overload with default arc selector.

Definition at line 2669 of file Planarity_Test.H.

References Aleph::blossom_maximum_cardinality_matching(), and options.

planarity_test() [2/2]

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

Planarity_Test_Result< GT > Aleph::planarity_test	(	const GT &	g,
		SA	sa = SA(),
		const Planarity_Test_Options &	options = Planarity_Test_Options()
	)

Execute a comprehensive planarity test on an Aleph graph.

Performs the Left-Right planarity test on the underlying simple undirected representation of the graph. Depending on the options, it can also compute a planar embedding or a non-planarity witness.

Template Parameters

GT	Graph type.
SA	Arc filter type (default: show all arcs).

Parameters

[in]	g	The input graph (can be directed or undirected).
[in]	sa	Arc filter instance.
[in]	options	Configuration for optional advanced outputs.

Returns

A Planarity_Test_Result containing the planarity status and requested diagnostic data.

Note

The algorithm automatically simplifies the input:

• Digraph arcs are treated as undirected edges.
• Self-loops are ignored.
• Parallel arcs are collapsed into a single edge.

Complexity:

Time \(O(V + E)\) for the core test. Advanced outputs may increase this (see Planarity_Test_Options).

Definition at line 2656 of file Planarity_Test.H.

References options, and Aleph::planarity_detail::LR_Planarity_Checker< GT, SA >::run().

Referenced by main(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

rank_graphviz()

template<AlephGraph GT, class Node_Attr , class Arc_Attr , NodeFilter< GT > SN, ArcFilter< GT > SA>

size_t Aleph::rank_graphviz	(	const GT &	g,
		std::ostream &	out,
		Node_Attr	node_attr = Node_Attr(),
		Arc_Attr	arc_attr = Arc_Attr(),
		const std::string &	rankdir = "LR"
	)

Generate Graphviz DOT output with topological ranking.

Creates a DOT specification that groups nodes by their topological rank (level in DAG). Each rank is placed in a separate subgraph for visual grouping.

This is useful for visualizing DAGs where the vertical position should reflect dependencies.

Template Parameters

GT	Graph type (must be a DAG)
Node_Attr	Node attribute generator
Arc_Attr	Arc attribute generator
SN	Node filter
SA	Arc filter

Parameters

g	Graph to visualize (should be a DAG)
out	Output stream
node_attr	Node attribute functor
arc_attr	Arc attribute functor
rankdir	Layout direction (default: "LR")

Returns

Number of topological ranks

See also

Q_Topological_Sort For rank computation

Definition at line 538 of file generate_graph.H.

References Aleph::blossom_maximum_cardinality_matching(), LocateFunctions< Container, Type >::get_it(), GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), Aleph::Array< T >::insert(), Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne(), out, and Aleph::ranks().

Referenced by TEST().

search_arc()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

GT::Arc * Aleph::search_arc ( const GT &  g, typename GT::Node *  src, typename GT::Node *  tgt, SA  sa = SA()  )

noexcept

Arc filtered searching given two nodes.

This function receives two nodes and returns the first arc linking them. The arc sense is irrelevant for this function. Simply, it searches an arc linking the nodes

Parameters

[in]	g	the graph
[in]	src	a node
[in]	tgt	another node
[in]	sa	filtering condition

Returns

pointer to found node; nullptr otherwise

Definition at line 2524 of file tpl_graph.H.

References Aleph::and, Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::is_digraph(), Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne(), and GTNodeCommon< NodeInfo >::num_arcs.

Referenced by Aleph::Path< GT >::append(), Aleph::Path< GT >::insert(), Aleph::Initialize_Dist< AM >::operator()(), parse_arc_definition(), parse_arc_text_definition(), TEST(), TEST(), TEST(), TEST_F(), and TEST_F().

search_directed_arc()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

GT::Arc * Aleph::search_directed_arc ( const GT &  g, typename GT::Node *  src, typename GT::Node *  tgt, SA  sa = SA()  )

noexcept

Searching of directed arc linking two nodes.

Parameters

[in]	g	the graph
[in]	src	source node pointer
[in]	tgt	target node pointer
[in]	sa	arc filter (default: Dft_Show_Arc)

Returns

a pointer to a directed linking arc if this is found; nullptr otherwise.

Definition at line 2552 of file tpl_graph.H.

References Aleph::and, Aleph::blossom_maximum_cardinality_matching(), and Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne().

Referenced by Aleph::Path< GT >::append_directed(), Aleph::Path< GT >::insert_directed(), TEST(), TEST(), and TEST_F().

search_node()

Digrafo::Node * Aleph::search_node ( Digrafo &  g, const std::string &  s  )

inline

Find or create a node by ID.

Searches for a node with the given ID in the graph. If not found, creates a new node with empty fields.

Parameters

g	The digraph to search.
s	The node ID to find.

Returns

Pointer to the found or created node.

Note

This performs a linear search. For large graphs, consider using a hash index.

Definition at line 162 of file load_digraph.H.

References Aleph::blossom_maximum_cardinality_matching(), and Aleph::search_node().

Referenced by Aleph::load_digraph(), Aleph::search_node(), TEST(), TEST(), TEST(), TEST(), and TEST().

split()

void Aleph::split ( const std::string &  text, const std::string &  separators, DynDlist< std::string > &  words  )

inline

Split a text into tokens using a separator set.

Tokenizes the input text by splitting on any character in the separators set. Empty tokens are not included.

Parameters

text	The text to split.
separators	String containing separator characters.
words	Output list to receive the tokens.

Definition at line 115 of file load_digraph.H.

References Aleph::DynDlist< T >::append(), Aleph::blossom_maximum_cardinality_matching(), and Aleph::split().

sufficient_hamiltonian() [1/2]

template<AlephGraph GT, class Init_Node , class Init_Arc >

GT Aleph::Random_Graph_Base< GT, Init_Node, Init_Arc >::sufficient_hamiltonian ( const size_t &  __num_nodes, const double &  p = 0.5  )

inline

Create a random Hamiltonian graph.

This version builds a random graph that is guaranteed to satisfy sufficient conditions for being Hamiltonian.

The process first generates a random graph, then examines the result and creates new arcs so that the output satisfies the Ore/Dirac theorems for Hamiltonian graphs.

Warning

The procedure can be extremely slow and memory-intensive as __num_nodes increases.

The graph is ensured to be Hamiltonian by the Ore and Dirac theorems. Note that this is a sufficiency condition, meaning the graph is not necessarily minimal. In fact, the generated graph tends to be dense.

Parameters

[in]	__num_nodes	Number of nodes the graph should have.
[in]	p	Probability of an arc existing between any pair of nodes. Defaults to 0.5, which empirically tends to produce fewer arcs and consume less time.

Returns

The randomly created graph.

Exceptions

bad_alloc	if there is not enough memory.
domain_error	if p is not in the range (0, 1].

Definition at line 312 of file random_graph.H.

References Aleph::Random_Graph_Base< GT, Init_Node, Init_Arc >::create_p(), Aleph::Random_Graph_Base< GT, Init_Node, Init_Arc >::g, and Aleph::Random_Graph_Base< GT, Init_Node, Init_Arc >::make_hamiltonian().

sufficient_hamiltonian() [2/2]

template<AlephGraph GT, class Init_Node = Dft_Init_Rand_Node<GT>, class Init_Arc = Dft_Init_Rand_Arc<GT>>

GT Aleph::Random_Graph< GT, Init_Node, Init_Arc >::sufficient_hamiltonian ( const size_t &  __num_nodes, const double &  p = 0.5  )

inline

Create a random Hamiltonian graph.

This version builds a random graph that is guaranteed to satisfy sufficient conditions for being Hamiltonian.

The process first generates a random graph, then examines the result and creates new arcs so that the output satisfies the Ore/Dirac theorems for Hamiltonian graphs.

Warning

The procedure can be extremely slow and memory-intensive as __num_nodes increases.

The graph is ensured to be Hamiltonian by the Ore and Dirac theorems. Note that this is a sufficiency condition, meaning the graph is not necessarily minimal. In fact, the generated graph tends to be dense.

Parameters

[in]	__num_nodes	Number of nodes the graph should have.
[in]	p	Probability of an arc existing between any pair of nodes. Defaults to 0.5, which empirically tends to produce fewer arcs and consume less time.

Returns

The randomly created graph.

Exceptions

bad_alloc	if there is not enough memory.
domain_error	if p is not in the range (0, 1].

Definition at line 709 of file random_graph.H.

References Aleph::Random_Graph< GT, Init_Node, Init_Arc >::create_p(), Aleph::Random_Graph_Base< GT, Init_Node, Init_Arc >::g, and Aleph::Random_Graph< GT, Init_Node, Init_Arc >::make_hamiltonian().

test_connectivity()

template<AlephGraph GT>

bool Aleph::test_connectivity ( const GT &  g )

inline

Connectivity test for undirected graphs.

Parameters

[in]

g

Graph to test.

Returns

true if g is connected; false otherwise.

Note

Returns false for an empty graph.

This function is not intended for multigraphs.

Exceptions

domain_error

If g is a directed graph.

See also

depth_first_traversal()

Definition at line 643 of file tpl_graph_utils.H.

References ah_domain_error_if, Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_num_arcs(), GraphCommon< GT, Node, Arc >::get_num_nodes(), GraphCommon< GT, Node, Arc >::is_digraph(), and num_nodes.

Referenced by TEST(), TEST(), test_random_graph_eulerian_probability(), test_random_graph_eulerian_sparse(), test_random_graph_hamiltonian(), test_random_graph_sparse_connected(), and test_two_node_graph().

test_for_cycle()

template<AlephGraph GT>

bool Aleph::test_for_cycle ( const GT &  g, typename GT::Node *  src  )

inline

Search for a cycle reachable from a given node.

Performs a depth-first exploration starting at src and returns true if a cycle that returns to src is found.

Note

This is a single-source cycle check. If you only need to know whether the graph has any cycle at all, prefer has_cycle().

Uses the Test_Cycle control bit on both nodes and arcs.

Parameters

[in]	g	Graph to search.
[in]	src	Source node (must be non-null and belong to g).

Returns

true if a cycle returning to src is found; false otherwise.

See also

has_cycle(), is_graph_acyclique()

Definition at line 681 of file tpl_graph_utils.H.

References Aleph::__test_cycle(), ah_invalid_argument_if, ARC_BITS, GraphCommon< GT, Node, Arc >::get_arc_it(), IS_ARC_VISITED, GraphCommon< GT, Node, Arc >::reset_bit_arcs(), GraphCommon< GT, Node, Arc >::reset_bit_nodes(), and Aleph::Test_Cycle.

Referenced by TEST().

test_for_path()

template<AlephGraph GT>

bool Aleph::test_for_path ( const GT &  g, typename GT::Node *  start_node, typename GT::Node *  end_node  )

inline

Return true if there is a path between two nodes.

Performs a depth-first reachability test from start_node to end_node.

Note

Uses the Find_Path control bit on both nodes and arcs.

Parameters

[in]	g	Graph to test.
[in]	start_node	Start node (must be non-null and belong to g).
[in]	end_node	End node (must be non-null and belong to g).

Returns

true if end_node is reachable from start_node; false otherwise.

See also

find_path_depth_first(), find_path_breadth_first()

Definition at line 875 of file tpl_graph_utils.H.

References Aleph::__test_for_path(), ah_invalid_argument_if, ARC_BITS, Aleph::blossom_maximum_cardinality_matching(), Aleph::Find_Path, GraphCommon< GT, Node, Arc >::get_arc_it(), GraphCommon< GT, Node, Arc >::reset_bit_arcs(), and GraphCommon< GT, Node, Arc >::reset_bit_nodes().

Referenced by TEST().

to_string()

const char * Aleph::to_string ( const Planarity_Certificate_Type  type )

inlinenoexcept

Return readable name for certificate type.

Definition at line 123 of file Planarity_Test.H.

References Aleph::K33_Subdivision, Aleph::K5_Subdivision, Aleph::Minimal_NonPlanar_Obstruction, and Aleph::None.

traverse_arcs()

template<AlephGraph GT, class Itor , class Operation >

bool Aleph::traverse_arcs ( typename GT::Node *  p, Operation  op = Operation()  )

inline

Generic arcs traverse of a node.

This template function receives threes template parameters:

1. GT: the graph type.
2. Itor: the iterator type; it is intended to be _In_Iterator or _Out_Iterator.
3. Operation: an operation to be executed on each arc. This operation must have the following signature:

bool operation(typename GT::Arc * arc)

If operation returns true then the traversal continues to the next arc; otherwise the traversal stops and the result of traverse() is false. If all the arcs are traversed, then the result is true.

Parameters

[in]	p	node pointer
[in]	op	operation to be performed on each arc

Returns

true if all the arcs were traversed: false otherwise

Definition at line 2092 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching().

Referenced by TEST().

traverse_in_arcs()

template<AlephGraph GT, class Op >

bool Aleph::traverse_in_arcs ( typename GT::Node *  p, Op  op = Op()  )

inline

Conditioned traversal of incoming arcs of a node.

Parameters

[in]	p	node pointer
[in]	op	operation whose result must be bool. Si the result is false, then the traversal stops and the traverse returns false; otherwise, all the ars are traversed and it returns true

Returns

true is all the arcs were traversed: false otherwise

Definition at line 2139 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching().

traverse_out_arcs()

template<AlephGraph GT, class Op >

bool Aleph::traverse_out_arcs ( typename GT::Node *  p, Op  op = Op()  )

inline

Conditioned traversal of outcoming arcs of a node.

Parameters

[in]	p	node pointer
[in]	op	operation whose result must be bool. Si the result is false, then the traversal stops and the traverse returns false; otherwise, all the ars are traversed and it returns true

Returns

true is all the arcs were traversed: false otherwise

Definition at line 2331 of file tpl_graph.H.

References Aleph::blossom_maximum_cardinality_matching().

validate_nonplanar_certificate()

template<AlephGraph GT>

NonPlanar_Certificate_Validation< GT > Aleph::validate_nonplanar_certificate

(

const Planarity_Test_Result< GT > &

result

)

Validate structural consistency of a non-planar certificate.

This function checks internal witness invariants (node/edge references, path chaining and obstruction/path coherence). It does not re-run planarity.

Definition at line 3724 of file Planarity_Test.H.

References Aleph::and, Aleph::blossom_maximum_cardinality_matching(), Aleph::Planarity_Test_Result< GT >::certificate_branch_nodes, Aleph::Planarity_Test_Result< GT >::certificate_obstruction_edges, Aleph::Planarity_Test_Result< GT >::certificate_paths, Aleph::Planarity_Test_Result< GT >::certificate_type, Aleph::planarity_detail::collect_certificate_nodes(), Aleph::DynSetTree< Key, Tree, Compare >::find(), Aleph::NonPlanar_Certificate_Validation< GT >::has_certificate, Aleph::Array_Iterator< T >::has_curr(), Aleph::Planarity_Test_Result< GT >::has_nonplanar_certificate, Aleph::K33_Subdivision, Aleph::K5_Subdivision, nodes, Aleph::None, and Aleph::Array< T >::size().

Referenced by main(), Aleph::nonplanar_certificate_is_valid(), TEST(), and TEST().

vertex_connectivity()

template<AlephGraph GT, template< class > class Max_Flow = Random_Preflow_Maximum_Flow, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

long Aleph::vertex_connectivity

(

GT &

g

)

Compute vertex connectivity of an undirected graph.

Uses a max-flow node-splitting reduction to compute the minimum number of vertices whose removal disconnects the graph.

The arc filter SA is applied when computing degrees, connectivity, and when building the auxiliary network.

Side effects:

• Uses the Depth_First control bit on nodes and arcs to test connectivity.
• Overwrites node cookies to store the GT -> Net mapping (and auxiliary mappings during the reduction) when the auxiliary network is built.

Template Parameters

GT	Graph type (undirected).
Max_Flow	Maximum flow functor.
SA	Arc filter functor.

Parameters

[in,out]

g

Graph to analyze.

Returns

Vertex connectivity of g (0 for empty or disconnected graphs).

Note

For connected graphs with minimum filtered degree <= 1, returns that degree without running max flow.

Exceptions

std::domain_error	If g is a digraph.
std::bad_alloc	If there is not enough memory.

Definition at line 499 of file tpl_kgraph.H.

References ah_domain_error_if, Aleph::and, Aleph::DynDlist< T >::append(), Aleph::blossom_maximum_cardinality_matching(), Aleph::Net_Graph< NodeT, ArcT >::connect_arc(), Aleph::Net_Graph< NodeT, ArcT >::disconnect_arc(), Aleph::DynMapTree< Key, Data, Tree, Compare >::find(), GraphCommon< GT, Node, Arc >::get_num_nodes(), GraphCommon< GT, Node, Arc >::get_src_node(), GraphCommon< GT, Node, Arc >::get_tgt_node(), Aleph::Dlink::Iterator::has_curr(), Aleph::Digraph_Iterator< GT, Filter >::has_curr(), Aleph::DynMapTree< Key, Data, Tree, Compare >::insert(), Aleph::Net_Graph< NodeT, ArcT >::insert_arc(), Aleph::Net_Graph< NodeT, ArcT >::insert_node(), GraphCommon< GT, Node, Arc >::is_digraph(), k, Aleph::Filter_Iterator< Container, It, Show_Item >::next(), Aleph::Filter_Iterator< Container, It, Show_Item >::next_ne(), NODE_COOKIE, num_nodes, and Aleph::Net_Graph< NodeT, ArcT >::reset().

warshall_compute_transitive_clausure()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

void Aleph::warshall_compute_transitive_clausure	(	GT &	g,
		Bit_Mat_Graph< GT, SA > &	mat
	)

Computes the transitive closure of a graph using Warshall's algorithm.

This function computes the transitive closure of graph g by means of Warshall's algorithm. The result is stored in the bit matrix mat.

Each entry mat(i,j) indicates whether there exists a path from the source node with index i to the destination node with index j. A value of 0 indicates there is no path; a value of 1 indicates there exists at least one path.

The procedure uses two bit matrices: an internal temporary one (freed when the procedure ends) and the output matrix mat.

Parameters

[in]	g	The graph represented by a List_Graph variant.
[out]	mat	Bit matrix where the result is stored.

Exceptions

std::bad_alloc

if there is not enough memory.

See also

List_Graph Bit_Mat_Graph

Definition at line 82 of file warshall.H.

References Aleph::and, Aleph::blossom_maximum_cardinality_matching(), Aleph::Bit_Mat_Graph< GT, SA >::get_list_graph(), Aleph::Bit_Mat_Graph< GT, SA >::get_num_nodes(), k, and Aleph::Bit_Mat_Graph< GT, SA >::set_list_graph().

Referenced by TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

welsh_powell_coloring()

template<AlephGraph GT, ArcFilter< GT > SA = Dft_Show_Arc<GT>>

size_t Aleph::welsh_powell_coloring	(	const GT &	g,
		DynMapTree< typename GT::Node *, size_t > &	colors
	)

Welsh-Powell graph coloring.

Applies first-fit greedy coloring after sorting nodes in decreasing order of degree. Typically uses fewer colors than plain greedy but is still a heuristic.

Template Parameters

GT	Graph type (List_Graph, List_Digraph, Array_Graph, …).
SA	Arc-filter functor (defaults to Dft_Show_Arc<GT>).

Parameters

[in]	g	Input graph. Must not contain self-loops.
[out]	colors	Output map from GT::Node* to 0-based color index. Cleared and overwritten on entry.

Returns

Number of distinct colors used (0 for an empty graph).

Exceptions

std::domain_error

if g contains a self-loop.

Precondition

No self-loops in g.

Note

Complexity: \(O((V+E) \log V)\)(sort step dominates for dense graphs: \(O(V \log V)\)).

Thread safety: not thread-safe. Temporarily writes to NODE_COOKIE on every node; saved and restored via Cookie_Saver before the function returns.

Definition at line 265 of file Graph_Coloring.H.

References Aleph::DynList< T >::append(), Aleph::blossom_maximum_cardinality_matching(), GraphCommon< GT, Node, Arc >::get_node_it(), GraphCommon< GT, Node, Arc >::get_num_nodes(), Aleph::DynSetTree< Key, Tree, Compare >::insert(), Aleph::mergesort(), NODE_COOKIE, nodes, Aleph::DynSetTree< Key, Tree, Compare >::size(), Aleph::size(), and w.

Referenced by demo_algorithm_comparison(), demo_exam_scheduling(), main(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

with_clean_cookies()

template<class GT , class Func >

auto Aleph::with_clean_cookies	(	GT &	g,
		Func &&	func
	)		-> decltype(func())

Convenience function to run an algorithm with automatic cookie cleanup.

Executes the given callable with automatic cookie cleanup on exit (whether normal return or exception).

Template Parameters

GT	Graph type.
Func	Callable type.

Parameters

g	Graph to operate on.
func	Function/lambda to execute.

Returns

Result of func().

Example

auto result = with_clean_cookies(g, [&]() {
  // Algorithm that uses cookies...
  return compute_something(g);
});

Author

Leandro Rabindranath León

Definition at line 492 of file cookie_guard.H.

References Aleph::blossom_maximum_cardinality_matching().

Referenced by TEST_F().

with_saved_cookies()

template<class GT , class Func >

auto Aleph::with_saved_cookies	(	GT &	g,
		Func &&	func
	)		-> decltype(func())

Convenience function to run an algorithm preserving existing cookies.

Executes the given callable, automatically saving cookies before and restoring them after (whether normal return or exception).

Template Parameters

GT	Graph type.
Func	Callable type.

Parameters

g	Graph to operate on.
func	Function/lambda to execute.

Returns

Result of func().

Example

// Cookies already contain important data from previous algorithm
auto result = with_saved_cookies(g, [&]() {
  // Temporary algorithm that uses cookies...
  return compute_temporary(g);
});
// Original cookies are restored

Author

Leandro Rabindranath León

Definition at line 524 of file cookie_guard.H.

References Aleph::blossom_maximum_cardinality_matching().

Referenced by TEST_F().

write_df_low_tree()

template<AlephGraph GT, class Key >

void write_df_low_tree	(	GT &	g,
		typename GT::Node *	src,
		std::ofstream &	f
	)

Generate a DFS tree picture with low-link values.

Computes and visualizes a depth-first spanning tree with:

• DFS discovery numbers
• Low-link values (for cut-vertex detection)
• Non-tree arcs (back edges)

The output is suitable for tree visualization tools.

Template Parameters

GT	Graph type (must be derived from List_Graph)
Key	Key type for tree nodes (typically Clave)

Parameters

g	The input graph
src	Starting node for DFS traversal
f	Output stream for the tree specification

Note

This function also computes cut-vertices as a side effect.

Warning

Uses global state (global_counter) - NOT thread-safe.

See also

compute_cut_nodes() For cut-vertex computation

generate_tree() For tree output format

Definition at line 220 of file generate_df_tree.H.

References Aleph::blossom_maximum_cardinality_matching(), Aleph::compute_cut_nodes(), Aleph::depth_first_traversal(), Aleph::find_depth_first_spanning_tree(), NODE_COOKIE, visitar_df(), and visitar_low().

yen_k_shortest_paths()

template<AlephGraph GT, ArcDistance< GT > Distance = Dft_Dist<GT>, ArcFilter< GT > SA = Dft_Show_Arc<GT>>
requires std::is_arithmetic_v<typename Distance::Distance_Type>

DynList< K_Shortest_Path_Item< GT, typename Distance::Distance_Type > > Aleph::yen_k_shortest_paths	(	const GT &	g,
		typename GT::Node *	source,
		typename GT::Node *	target,
		const size_t	k,
		Distance	distance = Distance(),
		SA	sa = SA()
	)

Compute k shortest loopless paths using Yen's algorithm.

Returns up to k simple paths ordered by non-decreasing total cost. If fewer than k paths exist, all available paths are returned.

Template Parameters

GT	Graph type.
Distance	Arc cost accessor (Distance::Distance_Type required).
SA	Arc filter.

Parameters

[in]	g	Graph.
[in]	source	Source node.
[in]	target	Target node.
[in]	k	Maximum number of paths to return.
[in]	distance	Arc cost accessor.
[in]	sa	Arc filter.

Returns

DynList<K_Shortest_Path_Item<GT, Cost_Type>>.

Exceptions

domain_error

If `source` or `target` is null, or if negative weights are detected.

Complexity

O(k * V * (E + V log V)) in the worst case: at each of the k iterations up to V spur nodes are tried, each requiring a Dijkstra run on the filtered graph.

Note

This implementation is NOT thread-safe due to internal use of const_cast and Cookie_Saver that mutate node/arc cookies on the graph object passed as g. Concurrent access to the same graph from multiple threads will cause data races.

Definition at line 895 of file K_Shortest_Paths.H.

References ah_domain_error_if, Aleph::and, Aleph::DynList< T >::append(), Aleph::blossom_maximum_cardinality_matching(), Aleph::k_shortest_paths_detail::compose_candidate(), Aleph::k_shortest_paths_detail::contains_path(), Aleph::DynSetTree< Key, Tree, Compare >::insert(), k, Aleph::Array< T >::reserve(), Aleph::k_shortest_paths_detail::same_prefix_nodes(), Aleph::k_shortest_paths_detail::state_to_path(), and Aleph::k_shortest_paths_detail::validate_non_negative_weights().

Variable Documentation

font_size

size_t Aleph::font_size = 6

inline

Font size for the DOT output.

Definition at line 255 of file load_digraph.H.

Referenced by FlagReset::FlagReset(), FlagReset::~FlagReset(), Aleph::generate_dot_file(), TEST(), TEST(), TEST(), and TEST().

only_num

bool Aleph::only_num = false

inline

If true, show only the node number, not the full label.

Definition at line 249 of file load_digraph.H.

Referenced by FlagReset::FlagReset(), FlagReset::~FlagReset(), Aleph::generate_dot_file(), TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().

Processed

const unsigned char Aleph::Processed = 2

The node or arc has already been processed.

Definition at line 39 of file aleph-graph.C.

Referenced by Aleph::Directed_Find_Path< GT, Itor, SA >::find(), and Aleph::Find_Aumenting_Path< Net, Q >::search().

Processing

const unsigned char Aleph::Processing = 1

The node are being processed; probably it is inside a queue, stack or heap.

Definition at line 38 of file aleph-graph.C.

Referenced by Aleph::Directed_Find_Path< GT, Itor, SA >::find(), and Aleph::Find_Aumenting_Path< Net, Q >::search().

Unprocessed

const unsigned char Aleph::Unprocessed = 0

The node have not bees processed.

This must be the initial state before general processing

Definition at line 37 of file aleph-graph.C.

Referenced by Aleph::min_cut(), and Aleph::Find_Aumenting_Path< Net, Q >::search().

vertical

bool Aleph::vertical = true

inline

If true, use vertical layout (default).

Definition at line 258 of file load_digraph.H.

Referenced by Aleph::SegmentArrangement::operator()(), TEST(), TEST(), TEST(), TEST_F(), and TEST_F().

with_class

bool Aleph::with_class = false

inline

If true, set node shapes based on class field.

Definition at line 252 of file load_digraph.H.

Referenced by FlagReset::FlagReset(), FlagReset::~FlagReset(), Aleph::generate_dot_file(), TEST(), TEST(), TEST(), and TEST().

with_nes

bool Aleph::with_nes = false

inline

If true, include NES percentage in node labels.

Definition at line 246 of file load_digraph.H.

Referenced by FlagReset::FlagReset(), FlagReset::~FlagReset(), Aleph::generate_dot_file(), TEST(), TEST(), TEST(), and TEST().

with_power

bool Aleph::with_power = false

inline

Configuration options for DOT file generation.

These variables control the appearance of the generated DOT output. They are inline variables to avoid ODR violations while maintaining the original API.

Note

Consider using a configuration struct instead of global variables in new code. If true, include power value in node labels.

Definition at line 243 of file load_digraph.H.

Referenced by FlagReset::FlagReset(), FlagReset::~FlagReset(), Aleph::generate_dot_file(), TEST(), TEST(), TEST(), and TEST().