package p3order

Import Path
	github.com/d2lang/elk-go/internal/layered/p3order (on go.dev)

Dependency Relation
	imports 9 packages, and imported by one package

Involved Source Files

	    all_crossings_counter.go
	    barycenter_heuristic.go
	    binary_indexed_tree.go
	    cross_min_util.go
	    crossing_matrix_filler.go
	    crossings_counter.go
	    forster_constraint_resolver.go
	    graph_info_holder.go
	    greedy_port_distributor.go
	    greedy_switch_heuristic.go
	    greedy_switch_processor.go
	    hyperedge_crossings_counter.go
	    interactive.go
	    layer_sweep_crossing_minimizer.go
	    layer_sweep_type_decider.go
	    model_order_barycenter_heuristic.go
	    no_crossing.go
	    north_south_edge_neighbouring_node_crossings_counter.go
	    port_distributor.go
	    sweep_copy.go
	    switch_decider.go
Package-Level Type Names (total 21)

	/* sort by: alphabet | popularity */
	 type AllCrossingsCounter (struct)
		AllCrossingsCounter coordinates the specialized counters and implements
		ELK's IInitializable traversal callbacks explicitly.

		Methods (total 5)
			(*AllCrossingsCounter) CountAllCrossings(arena *layered.LGraphArena, currentOrder [][]layered.LNodeID) int
			(*AllCrossingsCounter) InitAfterTraversal()
			(*AllCrossingsCounter) InitAtEdgeLevel(arena *layered.LGraphArena, layerIndex, nodeIndex, portIndex int, edgeID layered.LEdgeID, nodeOrder [][]layered.LNodeID)
			(*AllCrossingsCounter) InitAtNodeLevel(arena *layered.LGraphArena, layerIndex, nodeIndex int, nodeOrder [][]layered.LNodeID)
			(*AllCrossingsCounter) InitAtPortLevel(arena *layered.LGraphArena, layerIndex, nodeIndex, portIndex int, nodeOrder [][]layered.LNodeID)
		As Outputs Of (at least one exported)
			func NewAllCrossingsCounter(numberOfLayers int) *AllCrossingsCounter
		As Inputs Of (at least one exported)
			func InitializeAllCrossingsCounter(counter *AllCrossingsCounter, arena *layered.LGraphArena, nodeOrder [][]layered.LNodeID)

	 type BarycenterHeuristic (struct)

		Fields (total 5)
			Arena *layered.LGraphArena
			Distributor *BarycenterPortDistributor
			ModelOrder *ModelOrderBarycenterHeuristic
			Random *javacompat.Random
			Resolver *ForsterConstraintResolver
		Methods (total 3)
			(*BarycenterHeuristic) MinimizeCrossings(order [][]layered.LNodeID, freeLayerIndex int, forwardSweep, firstSweep bool) bool
			(*BarycenterHeuristic) MinimizeLayer(layer *[]layered.LNodeID, preordered, randomize, forward bool)
			(*BarycenterHeuristic) SetFirstLayerOrder(order [][]layered.LNodeID, forward bool) bool
		As Outputs Of (at least one exported)
			func NewBarycenterHeuristic(arena *layered.LGraphArena, resolver *ForsterConstraintResolver, random *javacompat.Random, distributor *BarycenterPortDistributor) *BarycenterHeuristic

	 type BarycenterPortDistributor (struct)

		Fields (total 2)
			Kind PortDistributorKind
			PortRanks []float32
		Methods (total 6)
			(*BarycenterPortDistributor) CalculatePortRanks(arena *layered.LGraphArena, layer []layered.LNodeID, portType layered.PortType)
			(*BarycenterPortDistributor) DistributePortsWhileSweeping(arena *layered.LGraphArena, nodeOrder [][]layered.LNodeID, currentIndex int, forward bool) bool
			(*BarycenterPortDistributor) InitAfterTraversal()
			(*BarycenterPortDistributor) InitAtLayerLevel(layerIndex int, order [][]layered.LNodeID)
			(*BarycenterPortDistributor) InitAtNodeLevel(arena *layered.LGraphArena, layerIndex, nodeIndex int, order [][]layered.LNodeID)
			(*BarycenterPortDistributor) InitAtPortLevel(arena *layered.LGraphArena, layerIndex, nodeIndex, portIndex int, order [][]layered.LNodeID)
		As Outputs Of (at least one exported)
			func NewBarycenterPortDistributor(kind PortDistributorKind, numberOfLayers int) *BarycenterPortDistributor
		As Inputs Of (at least 2)
			func InitializeBarycenterPortDistributor(distributor *BarycenterPortDistributor, arena *layered.LGraphArena, order [][]layered.LNodeID)
			func NewBarycenterHeuristic(arena *layered.LGraphArena, resolver *ForsterConstraintResolver, random *javacompat.Random, distributor *BarycenterPortDistributor) *BarycenterHeuristic

	 type BarycenterState (struct)

		Fields (total 5)
			Barycenter *float64
			Degree int
			Node layered.LNodeID
			SummedWeight float64
			Visited bool

	 type CrossingCountSide uint8 (basic type)

		As Inputs Of (at least one exported)
			func NewCrossingMatrixFiller(arena *layered.LGraphArena, crossMinType CrossMinType, order [][]layered.LNodeID, freeLayerIndex int, side CrossingCountSide) *CrossingMatrixFiller
		As Types Of (total 2)
			const CrossingsEast
			const CrossingsWest

	 type CrossingMatrixFiller (struct)
		CrossingMatrixFiller lazily caches both orders of each node pair. Node.ID
		is the immutable identity assigned by GraphInfoHolder initialization; it is
		deliberately not changed when the current order swaps nodes.

		Methods (only one)
			(*CrossingMatrixFiller) GetCrossingMatrixEntry(arena *layered.LGraphArena, upper, lower layered.LNodeID) int
		As Outputs Of (at least one exported)
			func NewCrossingMatrixFiller(arena *layered.LGraphArena, crossMinType CrossMinType, order [][]layered.LNodeID, freeLayerIndex int, side CrossingCountSide) *CrossingMatrixFiller
		As Inputs Of (at least one exported)
			func NewSwitchDecider(arena *layered.LGraphArena, freeLayerIndex int, order [][]layered.LNodeID, filler *CrossingMatrixFiller, portPositions []int, holder *GraphInfoHolder, oneSided bool) *SwitchDecider

	 type CrossingsCounter (struct)
		CrossingsCounter is the exact ELK 0.8.1 reduction of between-layer,
		in-layer, and north/south crossings to inversion counting. Port IDs are
		scratch indices into PortPositions; AllCrossingsCounter assigns them in
		Java traversal order.

		Fields (only one)
			PortPositions []int
		Methods (total 9)
			(*CrossingsCounter) CountCrossingsBetweenLayers(arena *layered.LGraphArena, leftLayerNodes, rightLayerNodes []layered.LNodeID) int
			(*CrossingsCounter) CountCrossingsBetweenPortsInBothOrders(arena *layered.LGraphArena, upperPort, lowerPort layered.LPortID) (int, int)
			(*CrossingsCounter) CountInLayerCrossingsBetweenNodesInBothOrders(arena *layered.LGraphArena, upperNode, lowerNode layered.LNodeID, side layered.PortSide) (int, int)
			(*CrossingsCounter) CountInLayerCrossingsOnSide(arena *layered.LGraphArena, nodes []layered.LNodeID, side layered.PortSide) int
			(*CrossingsCounter) CountNorthSouthPortCrossingsInLayer(arena *layered.LGraphArena, nodes []layered.LNodeID) int
			(*CrossingsCounter) InitForCountingBetween(arena *layered.LGraphArena, leftLayerNodes, rightLayerNodes []layered.LNodeID)
			(*CrossingsCounter) InitPortPositionsForInLayerCrossings(arena *layered.LGraphArena, nodes []layered.LNodeID, side layered.PortSide) []layered.LPortID
			(*CrossingsCounter) SwitchNodes(arena *layered.LGraphArena, wasUpperNode, wasLowerNode layered.LNodeID, side layered.PortSide)
			(*CrossingsCounter) SwitchPorts(arena *layered.LGraphArena, topPort, bottomPort layered.LPortID)
		As Outputs Of (at least one exported)
			func NewCrossingsCounter(portPositions []int) *CrossingsCounter

	 type CrossMinType uint8 (basic type)
		CrossMinType is LayerSweepCrossingMinimizer.CrossMinType. Declaration
		order follows ELK 0.8.1 and is observable through the zero value used by the
		phase-three provider.

		As Inputs Of (at least 4)
			func NewCrossingMatrixFiller(arena *layered.LGraphArena, crossMinType CrossMinType, order [][]layered.LNodeID, freeLayerIndex int, side CrossingCountSide) *CrossingMatrixFiller
			func NewGraphInfoHolder(arena *layered.LGraphArena, graphID layered.LGraphID, crossMinType CrossMinType, graphs []*GraphInfoHolder, random *javacompat.Random) (*GraphInfoHolder, error)
			func NewGreedySwitchHeuristic(arena *layered.LGraphArena, crossMinType CrossMinType, holder *GraphInfoHolder) *GreedySwitchHeuristic
			func NewLayerSweepCrossingMinimizer(crossMinType CrossMinType) *LayerSweepCrossingMinimizer
		As Types Of (total 3)
			const CrossMinBarycenter
			const CrossMinOneSidedGreedySwitch
			const CrossMinTwoSidedGreedySwitch

	 type ForsterConstraintResolver (struct)

		Fields (only one)
			BarycenterStates [][]BarycenterState
		Methods (total 3)
			(*ForsterConstraintResolver) InitAtLayerLevel(layerIndex int, order [][]layered.LNodeID)
			(*ForsterConstraintResolver) InitAtNodeLevel(arena *layered.LGraphArena, layerIndex, nodeIndex int, order [][]layered.LNodeID)
			(*ForsterConstraintResolver) ProcessConstraints(arena *layered.LGraphArena, nodes *[]layered.LNodeID)
		As Outputs Of (at least one exported)
			func NewForsterConstraintResolver(arena *layered.LGraphArena, order [][]layered.LNodeID) *ForsterConstraintResolver
		As Inputs Of (at least 2)
			func InitializeForsterConstraintResolver(resolver *ForsterConstraintResolver, arena *layered.LGraphArena, order [][]layered.LNodeID)
			func NewBarycenterHeuristic(arena *layered.LGraphArena, resolver *ForsterConstraintResolver, random *javacompat.Random, distributor *BarycenterPortDistributor) *BarycenterHeuristic

	 type GraphInfoHolder (struct)
		GraphInfoHolder collects all state initialized by a single IInitializable
		traversal of one graph.

		Fields (total 15)
			BestNodeAndPortOrder *SweepCopy
			ChildGraphs []layered.LGraphID
			CrossMinType CrossMinType
			CrossMinimizer crossingMinimizationHeuristic
			CrossingsCounter *AllCrossingsCounter
			CurrentNodeOrder [][]layered.LNodeID
			CurrentlyBestNodeAndPortOrder *SweepCopy
			HasExternalPorts bool
			HasParent bool
			LGraph layered.LGraphID
			Parent *layered.LNodeID
			ParentGraphData *GraphInfoHolder
			PortDistributor sweepPortDistributor
			PortPositions []int
			UseBottomUp bool
		Methods (total 4)
			(*GraphInfoHolder) CrossMinAlwaysImproves() bool
			(*GraphInfoHolder) CrossMinDeterministic() bool
			(*GraphInfoHolder) DontSweepInto() bool
			(*GraphInfoHolder) GetBestSweep() *SweepCopy
		As Outputs Of (at least one exported)
			func NewGraphInfoHolder(arena *layered.LGraphArena, graphID layered.LGraphID, crossMinType CrossMinType, graphs []*GraphInfoHolder, random *javacompat.Random) (*GraphInfoHolder, error)
		As Inputs Of (at least 3)
			func NewGraphInfoHolder(arena *layered.LGraphArena, graphID layered.LGraphID, crossMinType CrossMinType, graphs []*GraphInfoHolder, random *javacompat.Random) (*GraphInfoHolder, error)
			func NewGreedySwitchHeuristic(arena *layered.LGraphArena, crossMinType CrossMinType, holder *GraphInfoHolder) *GreedySwitchHeuristic
			func NewSwitchDecider(arena *layered.LGraphArena, freeLayerIndex int, order [][]layered.LNodeID, filler *CrossingMatrixFiller, portPositions []int, holder *GraphInfoHolder, oneSided bool) *SwitchDecider

	 type GreedyPortDistributor (struct)
		GreedyPortDistributor is the distributor used by ELK's two-sided greedy
		switch. It repeatedly swaps adjacent ports whenever the swap strictly
		decreases crossings.

		Methods (total 3)
			(*GreedyPortDistributor) DistributePortsWhileSweeping(arena *layered.LGraphArena, order [][]layered.LNodeID, currentIndex int, forward bool) bool
			(*GreedyPortDistributor) InitAfterTraversal()
			(*GreedyPortDistributor) InitAtNodeLevel(arena *layered.LGraphArena, layerIndex, nodeIndex int, order [][]layered.LNodeID)
		As Outputs Of (at least one exported)
			func NewGreedyPortDistributor() *GreedyPortDistributor
		As Inputs Of (at least one exported)
			func InitializeGreedyPortDistributor(distributor *GreedyPortDistributor, arena *layered.LGraphArena, order [][]layered.LNodeID)

	 type GreedySwitchHeuristic (struct)
		GreedySwitchHeuristic switches adjacent nodes whenever doing so strictly
		reduces the selected one- or two-sided crossing count.

		Fields (total 4)
			Arena *layered.LGraphArena
			GraphData *GraphInfoHolder
			PortPositions []int
			Type CrossMinType
		Methods (total 5)
			(*GreedySwitchHeuristic) InitAfterTraversal()
			(*GreedySwitchHeuristic) InitAtLayerLevel(arena *layered.LGraphArena, layerIndex int, order [][]layered.LNodeID)
			(*GreedySwitchHeuristic) InitAtPortLevel()
			(*GreedySwitchHeuristic) MinimizeCrossings(order [][]layered.LNodeID, freeLayerIndex int, forwardSweep, _ bool) bool
			(*GreedySwitchHeuristic) SetFirstLayerOrder(order [][]layered.LNodeID, forward bool) bool
		As Outputs Of (at least one exported)
			func NewGreedySwitchHeuristic(arena *layered.LGraphArena, crossMinType CrossMinType, holder *GraphInfoHolder) *GreedySwitchHeuristic

	 type InteractiveCrossingMinimizer (struct)
		InteractiveCrossingMinimizer orders nodes by their previous vertical
		positions and reconstructs previous long-edge positions at each layer.

		Methods (total 2)
			(*InteractiveCrossingMinimizer) Process(arena *layered.LGraphArena, graphID layered.LGraphID) error
			(*InteractiveCrossingMinimizer) ProcessorConfiguration(arena *layered.LGraphArena, graphID layered.LGraphID) layered.ProcessorConfiguration
		Implements (at least 2)
			*InteractiveCrossingMinimizer : github.com/d2lang/elk-go/internal/layered.ConfiguredProcessor
			*InteractiveCrossingMinimizer : github.com/d2lang/elk-go/internal/layered.LayoutProcessor

	 type LayerSweepCrossingMinimizer (struct)
		LayerSweepCrossingMinimizer is ELK Layered's phase-three layer sweep. Its
		zero value is the BARYCENTER phase implementation used by the provider.

		Fields (only one)
			Type CrossMinType
		Methods (total 4)
			(*LayerSweepCrossingMinimizer) HierarchyAware()
				HierarchyAware is a marker used by the layered executor. In an
				INCLUDE_CHILDREN layout this processor must be paused on child graphs and
				invoked once on the root after every graph has completed all processors
				preceding phase three.

			(*LayerSweepCrossingMinimizer) Process(arena *layered.LGraphArena, graphID layered.LGraphID) error
			(*LayerSweepCrossingMinimizer) ProcessHierarchy(arena *layered.LGraphArena, graphID layered.LGraphID) error
				ProcessHierarchy is the source-shaped hierarchy-aware entry point. graphID
				must be the hierarchy root; initialization then discovers every child graph
				breadth-first and assigns GraphInfoHolder indices before sweeping bottom-up
				or through nested graphs as decided by LayerSweepTypeDecider.

			(*LayerSweepCrossingMinimizer) ProcessorConfiguration(_ *layered.LGraphArena, _ layered.LGraphID) layered.ProcessorConfiguration
		Implements (at least 2)
			*LayerSweepCrossingMinimizer : github.com/d2lang/elk-go/internal/layered.ConfiguredProcessor
			*LayerSweepCrossingMinimizer : github.com/d2lang/elk-go/internal/layered.LayoutProcessor
		As Outputs Of (at least 2)
			func NewGreedySwitchPostprocessor(strategy layered.IntermediateProcessorStrategy) (*LayerSweepCrossingMinimizer, error)
			func NewLayerSweepCrossingMinimizer(crossMinType CrossMinType) *LayerSweepCrossingMinimizer

	 type LayerSweepTypeDecider (struct)
		LayerSweepTypeDecider chooses between bottom-up and cross-hierarchical
		sweeping for one graph. InitAtLayerLevel and InitAtNodeLevel must be called
		in IInitializable traversal order before UseBottomUp.

		Fields (only one)
			NodeInfo [][]layerSweepNodeInfo
		Methods (total 3)
			(*LayerSweepTypeDecider) InitAtLayerLevel(arena *layered.LGraphArena, layerIndex int, order [][]layered.LNodeID)
			(*LayerSweepTypeDecider) InitAtNodeLevel(arena *layered.LGraphArena, layerIndex, nodeIndex int, order [][]layered.LNodeID)
			(*LayerSweepTypeDecider) UseBottomUp(arena *layered.LGraphArena, graphID layered.LGraphID, parent *layered.LNodeID, crossMinDeterministic bool, order [][]layered.LNodeID) bool
		As Outputs Of (at least one exported)
			func NewLayerSweepTypeDecider(numberOfLayers int) *LayerSweepTypeDecider

	 type ModelOrderBarycenterHeuristic (struct)
		ModelOrderBarycenterHeuristic is ELK 0.8.1's partial-order comparator used
		when model order is considered during crossing minimization.

		Fields (only one)
			ForceNodeModelOrder bool
		Methods (only one)
			(*ModelOrderBarycenterHeuristic) ClearTransitiveOrdering()
		As Outputs Of (at least one exported)
			func NewModelOrderBarycenterHeuristic(force bool) *ModelOrderBarycenterHeuristic

	 type NoCrossingMinimizer (struct)
		NoCrossingMinimizer deliberately preserves the node and port order produced
		by layering and the required long-edge preprocessing.

		Methods (total 2)
			(*NoCrossingMinimizer) Process(*layered.LGraphArena, layered.LGraphID) error
			(*NoCrossingMinimizer) ProcessorConfiguration(_ *layered.LGraphArena, _ layered.LGraphID) layered.ProcessorConfiguration
		Implements (at least 2)
			*NoCrossingMinimizer : github.com/d2lang/elk-go/internal/layered.ConfiguredProcessor
			*NoCrossingMinimizer : github.com/d2lang/elk-go/internal/layered.LayoutProcessor

	 type NorthSouthEdgeNeighbouringNodeCrossingsCounter (struct)
		NorthSouthEdgeNeighbouringNodeCrossingsCounter accounts for north/south
		port dummies and their crossings with long-edge dummies.

		Fields (total 2)
			LowerUpperCrossings int
			UpperLowerCrossings int
		Methods (only one)
			(*NorthSouthEdgeNeighbouringNodeCrossingsCounter) CountCrossings(arena *layered.LGraphArena, upper, lower layered.LNodeID)
		As Outputs Of (at least one exported)
			func NewNorthSouthEdgeNeighbouringNodeCrossingsCounter(arena *layered.LGraphArena, layer []layered.LNodeID) *NorthSouthEdgeNeighbouringNodeCrossingsCounter

	 type PortDistributorKind uint8 (basic type)

		As Inputs Of (at least one exported)
			func NewBarycenterPortDistributor(kind PortDistributorKind, numberOfLayers int) *BarycenterPortDistributor
		As Types Of (total 2)
			const LayerTotalPortDistributor
			const NodeRelativePortDistributor

	 type SweepCopy (struct)
		SweepCopy stores the node order and each node's current port order. Port
		orders are indexed by layer and position, just as in ELK 0.8.1; this means
		they travel with a candidate sweep order rather than with arena IDs.

		Methods (total 3)
			(*SweepCopy) Clone() *SweepCopy
			(*SweepCopy) Nodes() [][]layered.LNodeID
				Nodes returns the saved order. Callers must treat it as read-only, matching
				SweepCopy.nodes()'s contract in Java.

			(*SweepCopy) TransferNodeAndPortOrdersToGraph(arena *layered.LGraphArena, graphID layered.LGraphID, setPortConstraints bool)
		As Outputs Of (at least 3)
			func NewSweepCopy(arena *layered.LGraphArena, nodeOrder [][]layered.LNodeID) *SweepCopy
			func (*GraphInfoHolder).GetBestSweep() *SweepCopy
			func (*SweepCopy).Clone() *SweepCopy

	 type SwitchDecider (struct)
		SwitchDecider compares the crossing count of two adjacent nodes in their
		current and switched orders.

		Methods (total 2)
			(*SwitchDecider) DoesSwitchReduceCrossings(arena *layered.LGraphArena, upperIndex, lowerIndex int) bool
			(*SwitchDecider) NotifyOfSwitch(arena *layered.LGraphArena, upper, lower layered.LNodeID)
		As Outputs Of (at least one exported)
			func NewSwitchDecider(arena *layered.LGraphArena, freeLayerIndex int, order [][]layered.LNodeID, filler *CrossingMatrixFiller, portPositions []int, holder *GraphInfoHolder, oneSided bool) *SwitchDecider


Package-Level Functions (total 22)

	 func GreedySwitchIntermediateForGraph(arena *layered.LGraphArena, graphID layered.LGraphID) (layered.IntermediateProcessorStrategy, bool)
		GreedySwitchIntermediateForGraph implements GraphConfigurator's exact
		activation decision. It must be called while the graph is still layerless,
		since the threshold is compared to LGraph.layerlessNodes.size().

	 func InitializeAllCrossingsCounter(counter *AllCrossingsCounter, arena *layered.LGraphArena, nodeOrder [][]layered.LNodeID)
		InitializeAllCrossingsCounter performs IInitializable.init's exact
		layer/node/port/edge nesting and connected-edge order.

	 func InitializeBarycenterPortDistributor(distributor *BarycenterPortDistributor, arena *layered.LGraphArena, order [][]layered.LNodeID)
	 func InitializeForsterConstraintResolver(resolver *ForsterConstraintResolver, arena *layered.LGraphArena, order [][]layered.LNodeID)
	 func InitializeGreedyPortDistributor(distributor *GreedyPortDistributor, arena *layered.LGraphArena, order [][]layered.LNodeID)
	 func NewAllCrossingsCounter(numberOfLayers int) *AllCrossingsCounter
	 func NewBarycenterHeuristic(arena *layered.LGraphArena, resolver *ForsterConstraintResolver, random *javacompat.Random, distributor *BarycenterPortDistributor) *BarycenterHeuristic
	 func NewBarycenterPortDistributor(kind PortDistributorKind, numberOfLayers int) *BarycenterPortDistributor
	 func NewCrossingMatrixFiller(arena *layered.LGraphArena, crossMinType CrossMinType, order [][]layered.LNodeID, freeLayerIndex int, side CrossingCountSide) *CrossingMatrixFiller
	 func NewCrossingsCounter(portPositions []int) *CrossingsCounter
	 func NewForsterConstraintResolver(arena *layered.LGraphArena, order [][]layered.LNodeID) *ForsterConstraintResolver
	 func NewGraphInfoHolder(arena *layered.LGraphArena, graphID layered.LGraphID, crossMinType CrossMinType, graphs []*GraphInfoHolder, random *javacompat.Random) (*GraphInfoHolder, error)
	 func NewGreedyPortDistributor() *GreedyPortDistributor
	 func NewGreedySwitchHeuristic(arena *layered.LGraphArena, crossMinType CrossMinType, holder *GraphInfoHolder) *GreedySwitchHeuristic
	 func NewGreedySwitchPostprocessor(strategy layered.IntermediateProcessorStrategy) (*LayerSweepCrossingMinimizer, error)
		NewGreedySwitchPostprocessor constructs IntermediateProcessorStrategy's
		exact LayerSweepCrossingMinimizer variant.

	 func NewLayerSweepCrossingMinimizer(crossMinType CrossMinType) *LayerSweepCrossingMinimizer
	 func NewLayerSweepTypeDecider(numberOfLayers int) *LayerSweepTypeDecider
	 func NewModelOrderBarycenterHeuristic(force bool) *ModelOrderBarycenterHeuristic
	 func NewNorthSouthEdgeNeighbouringNodeCrossingsCounter(arena *layered.LGraphArena, layer []layered.LNodeID) *NorthSouthEdgeNeighbouringNodeCrossingsCounter
	 func NewSweepCopy(arena *layered.LGraphArena, nodeOrder [][]layered.LNodeID) *SweepCopy
	 func NewSwitchDecider(arena *layered.LGraphArena, freeLayerIndex int, order [][]layered.LNodeID, filler *CrossingMatrixFiller, portPositions []int, holder *GraphInfoHolder, oneSided bool) *SwitchDecider
	 func ProcessGreedySwitchIntermediate(arena *layered.LGraphArena, graphID layered.LGraphID, strategy layered.IntermediateProcessorStrategy) error
Package-Level Constants (total 7)

	const CrossingsEast CrossingCountSide = 1
	const CrossingsWest CrossingCountSide = 0
	const CrossMinBarycenter CrossMinType = 0
	const CrossMinOneSidedGreedySwitch CrossMinType = 1
	const CrossMinTwoSidedGreedySwitch CrossMinType = 2
	const LayerTotalPortDistributor PortDistributorKind = 1
	const NodeRelativePortDistributor PortDistributorKind = 0

The pages are generated with Golds v0.8.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.