`goblin`

. This library root object serves as as a factory of graph objects and mixed integer programs. And generating a library object implies generating the respective Tcl object command.For the time being, this Tcl command reference is not complete but, at least, covers all graph object commands. Descriptions for the missing LP / MIP commands will be added after some necessary interface cleanup steps.

`goblin`

root object:`mixedGraph`

: Mixed graph, represented by incidence lists`-nodes <number of graph nodes>`

(mandatory)

`sparseGraph`

: Undirected graph, represented by incidence lists`-nodes <number of graph nodes>`

(mandatory)

`sparseDiGraph`

: Directed graph, represented by incidence lists`-nodes <number of graph nodes>`

(mandatory)

`sparseBiGraph`

: Bipartite graph, represented by incidence lists`-nodes <number of graph nodes>`

(mandatory)

`denseGraph`

: Undirected graph, represented by an adjacency matrix`-nodes <number of graph nodes>`

(mandatory)

`denseDiGraph`

: Directed graph, represented by an adjacency matrix`-nodes <number of graph nodes>`

(mandatory)

`denseBiGraph`

: Bipartite graph, represented by an adjacency matrix`-nodes <number of graph nodes>`

(mandatory)

`openGrid`

: Plane graph with regular interior faces`-rows <number of horizontal grid lines>`

(mandatory)`-columns <Number of vertical grid lines>`

(mandatory)`-square`

: Square interior faces (default)`-triangular`

: Triangular interior faces (optional)`-hexagonal`

: Hexagonal interior faces (optional)

`gridCompletion`

: Grid graph with cliques of nodes on the same grid line`-rows <number of horizontal grid lines>`

(mandatory)`-columns <Number of vertical grid lines>`

(mandatory)`-square`

: Square interior faces (default)`-triangular`

: Triangular interior faces (optional)`-hexagonal`

: Hexagonal interior faces (optional)

`polarGrid`

: Plane or spheric graph with radial grid lines`-rows <number of horizontal grid lines`

(mandatory)`-columns <number of vertical grid lines`

(mandatory)`-poles <number of vertical grid lines`

(0,1 or 2, default: 0)`-quadrilateral`

: Quadrilateral faces (default)`-triangular`

: Triangular faces (optional)`-disc`

: 2D drawing on a disc (optional)`-sphere`

: 3D drawing on a sphere (optional)`-hemisphere`

: 3D drawing on a hemisphere (optional)`-tube`

: 3D drawing on a cylinder (optional)`-cone`

: 3D drawing on a cone (optional)

`toroidalGrid`

: 2D or 3D grid graph with (almost) regular faces`-girth <>`

(mandatory)`-perimeter <>`

(mandatory)`-quadrilateral`

: Quadrilateral faces (default)`-triangular`

: Triangular faces (optional)`-hexagonal`

: Hexagonal faces (optional)

`moebiusLadder`

: Projective, but non-planar graph`-nodes <number of graph nodes>`

(mandatory)

`generalizedPetersen`

: 3-node regular, non-planar graphs with high girth`-perimeter <number of exterior graph nodes>`

(mandatory)`-skew <connectivity parameter for interior nodes>`

(mandatory)

`intersectionGraph`

: Intersection graph on the k-element subsets of a ground set`-groundSet <ground set cardinality>`

(mandatory)`-subset <subset cardinality>`

(mandatory)`-meet <lower meet cardinality bound>`

<upper meet cardinality bound> (optional, default: 0)

`regularTree`

: Regular tree`-nodes <number of graph nodes>`

(optional)`-depth <tree depth>`

(mandatory)`-deg <maximal node out degree>`

(mandatory)

`butterflyGraph`

: Layered graph with "butterfly" bicliques`-length <word length>`

(mandatory)`-base <alphabnet cardinality>`

(mandatory)

`cyclicButterfly`

: Regular digraph with a cyclic layering`-length <word length>`

(mandatory)`-base <alphabnet cardinality>`

(mandatory)

`sierpinskiTriangle`

: Plane, recursive construction from triangles`-depth <recursion depth>`

(mandatory)

`mycielskianGraph`

: Graphs with low clique number, but large chromatic number`-depth <recursion depth>`

(mandatory)

`triangularGraph`

: Graph on the 2-element subsets of a ground set`-cardinality <ground set cardinality>`

(mandatory)

`permutationGraph`

: Random permutation graph`-nodes <number of graph nodes>`

(mandatory)

`thresholdGraph`

: Threshold graph with random node weights`-nodes <number of graph nodes>`

(mandatory)`-threshold <minimum edge weight>`

(optional, default: 0)`-min <lower bound on the node weights>`

(optional, default: 0)`-max <upper bound on the node weights>`

(mandatory)

`intervalGraph`

: Interval graph with random node intervals`-nodes <number of graph nodes>`

(mandatory)`-range <total value range>`

(mandatory)

The general command structure is `goblin <class_name> <options> <object_name>`

. The results are a GOBLIN library object and a new Tcl command `<object_name>`

to address the library object. Example:

goblin regularTree -depth 5 -deg 2 myTree

`myTree`

. A regular tree is a special case of a `goblin sparseDiGraph <options> myTree`

.

`<object_name> info -<class_specifier>`

:`-graphObject`

: Returns true if the object is some kind of graph object`-mipObject`

: Returns true if the object is a (mixed integer) linear program

By the same syntax, graph object can be classified more detailed:

`-sparse`

: Returns true if this is a graph object, implemented by incidence lists`-directed`

: Returns true if this is a digraph object`-undirected`

: Returns true if this is an undirected graph object`-bipartite`

: Returns true if this is a bigraph object`-balanced`

: Returns true if this is a balanced (skew-symmetric) digraph object

The preceding commands only evaluate the type of the C++ core library object. For example, if a graph object has been instanciated as a mixedGraph, both `<object_name> info -directed`

and `<object_name> info -undirected`

return false, irrespective of the actual arc orientations.

The following options are different in that a high-level recognition method is called:

`-planar`

: Returns true if this is a planar graph object`-chordal`

: Returns true if this is a chordal graph object`-co-chordal`

: Returns true if the complementary graph is chordal

`*`

applies. For example, goblin polarGrid -rows 4 -columns 4 myGraph myGraph spanningTree -rootNode *

goblin polarGrid -rows 4 -columns 4 myGraph myGraph spanningTree

myGraph configure -rootNode $r myGraph spanningTree

myGraph spanningTree -rootNode $r

myGraph configure -rootNode $r myGraph spanningTree -rootNode [myGraph info -rootNode]

`configure`

command makes the root node selection persistent. That is, subsequent vertex routing method calls apply the configured root node, even if the graph object is written to and reread from file.
With a few exceptions, this substitution of missing `-rootNode`

, `-sourceNode`

and `-targetNode`

parameters applies to all optimization and layout commands:

`shortestPath`

allows to omit a`-targetNode`

and occasionally determines a full shortest path tree`connectivity`

selects a missing`-sourceNode`

or`-targetNode`

such that the cut capacity becomes minimal`layout orthogonal -tree -binary`

determines a missing`-rootNode`

by inspection of the node degrees or the predecessor arcs

The default rules and its exceptions even apply when the C++ interface is used.

`<original_object> <derived_class> <options> <derived_object> `

and some of the following options apply:`explicitSubgraph`

: Generate an incidence structure for the subgraph encoded into the flow labels`lineGraph`

: Generate a graph whose nodes are the edges of the original graph`-planar`

: Generate edges only for adjacent edges in the original regions`-directed`

: Assign arc orientations

`dualGraph`

: For planar graphs, generate a graph whose nodes are the regions of the original graph`-directed`

: Assign arc orientations due to a given a bipolar orientation

`spreadOutRegular`

: For planar graphs, generate an outerplanar graph by unrolling the faces of regular convex polyhedra`vertexTruncation`

: For planar graphs, replace every original node by a face`facetSeparation`

: For planar graphs, replace every edge by one quadrilateral (default) or two triangular faces`-turnLeft`

: Replace by two triangular faces, as if the original faces would be rotated clockwise`-turnRight`

: Replace by two triangular faces, as if the original faces would be rotated counter-clockwise

`mycielskianGraph`

: Generate a graph which results from once applying the Mycielski recursion rule`complementaryGraph`

: Generate an undirected graph in which nodes are adjacent if they are not adjacent in the original graph`underlyingGraph`

: Generate an undirected graph which differs from the original only by the missing arc orientations`inducedSubgraph`

: Generate an explicit subgraph, induced by the specified colour classes`-nodeColour <colour index>`

(optional, default 0)`-edgeColour <colour index>`

(optional. By default, edge colours are not considered)

`inducedOrientation`

: Generate an orientation of the original graph such that arcs are running from lower to higher node colour indices`inducedBigraph`

: Generate the bipartite subgraph w`-nodeColours <colour index> <colour index>`

`colourContraction`

: Generate a mixed graph by identifying all equal coloured nodes`nodeSplitting`

: For a digraph, generate another digraph in which every node of the original graph is replaced by an arc with the original node demand as the upper capacity bound`completeOrientation`

: Generate a digraph in which every undirected edge of the original graph is replaced by an antiparallel arc pair`explicitSubdivision`

: For graphs with a poly-line drawing, replace all bend points by regular graph nodes`distanceGraph`

: Generate the complete digraph whose edge lengths are the node distances in the original graph object`integerStableSetModel`

: Generate an integer program which is equivalent with finding a maximum stable set

For undirected graphs only:

`metricGraph`

: Generate the complete graph whose edge lengths are the node distances in the original graph object

For digraphs only:

`linearFlowModel`

: Generate a linear program which is equivalent with finding a minimum-cost flow`transitiveClosure`

: For a DAG, generate the minimal transitive supergraph`intransitiveReduction`

: From a DAG, export the maximal subgraph without transitive arcs`splitGraph`

: Generate a balanced digraph, consisting of two disjoint copies of the given digraph

`shortestPath`

: Determine a shortest path (tree) from a given source node`-sourceNode <source node index>`

(optional)`-targetNode <target node index>`

(optional)`-residual`

: Search the residual graph with reduced length labels

`networkFlow`

: Determine a (minimum-cost) network flow`-sourceNode <source node index>`

(optional)`-targetNode <target node index>`

(optional)`-feasible`

: Only find a flow which satisfies the node demands`-maximize`

: Determine a maximum st-flow

`connectivity`

: Determine a minimum edge cut or separating vertex set`-edge`

: Only the edges, but not the nodes impose capacity restrictions`-strong`

: Directed arcs count in forward direction only`-vertex`

: Apply unit node capacities`-sourceNode <source node index>`

(optional): A node on the left-hand side`-targetNode <target node index>`

(optional): A node on the right-hand side

`components`

: Determine the edge connected components`-kappa <degree of connectivity>`

(default value: 1)`-strong`

: Determine strong components

`bipolarOrientation`

: For biconnected graphs, determine a bipolar numbering and implicit arc orientations`-sourceNode <source node index>`

(optional): The desired minimal node`-targetNode <target node index>`

(optional): The desired maximal node`-rootArc <arc index>`

(optional): The desired return arc`-decompose`

: Export an ear decomposition instead of the implicit arc orientations

`eulerianCycle`

: Determine a closed walk which covers all edges`chinesePostman`

: Determine a maximum weight Eulerian subgraph`-adjust`

: Make the original graph Eulerian by increasing the capacity bounds

`maximumEdgeCut`

: Determine a maximum edge cut`-sourceNode <source node index>`

(optional): A node on the left-hand side`-targetNode <target node index>`

(optional): A node on the right-hand side

`spanningTree`

: Determine a minimum-cost spanning tree`-rootNode <root node index>`

(optional in the undirected case)`-maximize`

: Reverse the optimization direction`-cycle`

: Determine a one-cycle tree

`steinerTree`

: Determine a minimum-cost tree which spans all demand nodes`-rootNode <root node index>`

(optional in the undirected case)

`hamiltonianCycle`

: Determine a minimum-cost Hamiltonian cycle`-rootNode <root node index>`

(optional): Used in spanning tree heuristics

`stableSet`

: Determine a maximum cardinality stable set (void induced subgraph)`maximumClique`

: Determine a maximum cardinality clique (complete induced subgraph)`vertexCover`

: Determine a minimum cardinality node which is incident with all edges`nodeColouring`

: Split the node set into a minimum number of stable sets`-threshold <accepted number of stable sets>`

(optional)

`cliqueCover`

: Split the node set into a minimum number of cliques`-threshold <accepted number of cliques>`

(optional)

`edgeColouring`

: Split the edge set into a minimum number of 1-matchings`-threshold <accepted number of matchings>`

(optional)

`feedbackArcSet`

: Determine a minimum cardinality feedback arc set

For digraphs only:

`topSort`

: Check if this digraph is acyclic. Assign node colours such that colour indices are increasing from tail to head nodes`criticalPath`

: If this digraph is acyclic, determine a maximum length path starting at the given root node`treePacking`

: Packing with arborescences`-rootNode <root node index>`

(optional)

For undirected graphs only:

`maximumMatching`

: Determine a maximum capacity subgraph such that the node degrees do not exceed the node demands`minimumCostMatching`

: Determine a minimum-cost f-factor (a subgraph such that node degrees and the node demands are all equal)`tJoin`

: Determine a minimum-cost T-join (a collection of paths starting and ending at demand nodes`edgeCover`

: Determine a mimimum length edge cover (a set of edges which covers all nodes)

For balanced digraphs only:

`balancedFlow`

: Determine a (minimum-cost) balanced network flow`-sourceNode <source node index>`

(optional)`-maximize`

: Determine a maximum st-flow

`<object_name> layout ...`

and the following options:`configure -<parameter_name> <parameter_value>`

: For any layout parmater in the layout data pool`info`

`-exists`

: True is the graph is visualized anyway`-<parameter_name>`

: For any layout parameter in the layout data pool

`point <layout point index>`

`placeAt <coordinate values>`

: Set a layout point position`insertSuccessor`

: Insert a new layout point into a sequence of control points`info`

: See Section Retrieving layout point attribute values

`tree`

: Layered drawing of predecessor trees`-spacing <minimum node distance>`

(optional)`-dx <minimum node distance on the x-coordinate>`

(optional)`-dy <minimum node distance on the y-coordinate>`

(optional)`-left`

: Parent nodes are placed atop the left-most child node`-right`

: Parent nodes are placed atop with the left-most child node`-center`

: Parent nodes are horizontally aligned in the center of their child nodes`-fdp`

: Nodes are horizontally aligned according to a force model

`fdp`

: Straight line drawing, node placement according to a force model`-spacing <recommended node distance>`

`-preserve`

: Do not allow changes of the edge crossing properties`-layered`

: Allow horizontal node movements only`-unrestricted`

: Explicitly allow for changes of the edge crossing properties

`layered`

: Layered drawing of general graphs`-spacing <minimum node distance>`

(optional)`-dx <minimum node distance on the x-coordinate>`

(optional)`-dy <minimum node distance on the y-coordinate>`

(optional)`-vertical`

Apply the default set of rules for vertical node placement`-span`

Determine an edge span minimal node layer assignment`-colours`

The node layer assignment is determined by the node colours`-horizontal`

Apply the default set of rules for horizontal node placement`-sweep`

Reduce the number of edge crossings by changing the horizontal node order`-align`

For the given horizontal node order, align the nodes by an LP model`-fdp`

For the given horizontal node order, align the nodes due to a force model

`circular`

: All nodes are placed on the same circle`-spacing <minimum node distance>`

(optional)`-outerplanar`

Expose the current incidence list order (graph must be embedded)`-predecessors`

Expose the predecessor arcs`-colours`

Expose the order given by the node colours

`plane`

: Plane straight line drawing`-grid <minimum node distance>`

(optional)`-convex`

: Determine a convex drawing (graph must be triconnected)`-basis <arc index>`

: Put the specified arc on the bottom line

`orthogonal`

: Ortogonal drawing with nodes represented by squares`-grid <minimum node distance>`

(optional)`-tree`

: Input graph is a rooted tree`-rootNode <root node index>`

(optional)`-binary`

: HV tree layout with small nodes and without bends (nodes degrees must be two or less)

`-small`

: Drawing with small nodes, plane drawing of planar graphs (graph must be biconnected, node degrees must be 4 or less)`-staircase`

Plane Kandinsky drawing with big nodes (graph must be triconnected)`-planar`

Plane Kandinsky drawing with big nodes

`visibility`

: Visibility representation without bends and nodes represented by line segments (graph must be planar)`-grid <minimum node distance>`

(optional)`-raw`

: Results as for the original method, with overshooting node segments`-giotto`

: Reduce node size to the minimum, without generating edge-edge overlap`-seriesParallel`

: Expose an intrinsic series-parallel ordering

`equilateral`

: Draw all edges with the same edge length (graph must be outerplanar)`-spacing <minimum node distance>`

(optional)

`arcRouting`

: Draw ordinary edges by straight lines, but loops and parallels with bends`-spacing <minimum node distance>`

(optional)

`alignWithOrigin`

: Shift all nodes by a constant amount to obtain small non-negative coordinate values`boundingBox`

`freeze`

: Freeze the current bounding box`release`

: Revert to the dynamic bounding box determination`default`

: Freeze the bounding box currently obtained by the dynamic rule`transform`

: Move all nodes to a specified bounding interval`-coordinate <coordinate index>`

(mandatory)`-range <minimum coordinate value> <maximum coordinate value>`

(mandatory)

`info`

: Retrieve a current bounding box coordinate value`-coordinate <coordinate index>`

(mandatory)`-max`

: Return the maximum coordinate value`-min`

: Return the minimum coordinate value

As an example,

goblin polarGrid -rows 4 -columns 4 myGraph myGraph layout orthogonal -small

`#nodes`

: The number of graph nodes`#edges`

: The number of edges, not accouting for arc directions`layout #points`

: The number of layout points, including the actual graph nodes

For bigraphs objects only:

`#leftHand`

: The number of left-hand nodes`#rightHand`

: The number of right-hand nodes

Most attributes are associated with graph nodes and edges, and the access to particular attribute values is described later. What follows is a list of commands which refer to node or arc attributes, but not to a specific node or arc entity:

`constant`

`-upperBound`

: 1, if the upper arc capacity bounds all coincide`-lowerBound`

: 1, if the lower arc capacity bounds all coincide`-edgeLength`

: 1, if the arc length labels all coincide`-nodeDemand`

: 1, if the node demands / capacitys all coincide

`max`

`-upperBound`

: Return the maximum absolute upper arc capacity bound`-lowerBound`

: Return the maximum absolute lower arc capacity bound`-edgeLength`

: Return the maximum absolute arc length label`-nodeDemand`

: Return the maximum absolute node demand / capacity

`info`

`-sourceNode`

: Return the default source node`-targetNode`

: Return the default target node`-rootNode`

: Return the default root node`-metricType`

: Return the (integer) type of edge length determination`-cardinality`

: Return the sum of subgraph edge multiplicities`-edgeLength`

: Return the sum of edge lengths, counting all predecessor arcs`-subgraphWeight`

: Return the sum of edge lengths, weighted by the subgraph edge multiplicities

`adjacency <start node index> <end node index>`

: Returns an arc connecting the two specified nodes, or`*`

if the nodes are non-adjacent

`<object_name> arc <arc index> info ...`

. Most messages do not actually depend on the arc direction, but all expect arc indices including the direction bit:`-upperBound`

: The upper capacity bound of this arc`-lowerBound`

: The lower capacity bound of this arc`-edgeLength`

: The length label of this arc`-startNode`

: The start node (tail) of this arc`-endNode`

: The end node (head) of this arc`-righthandArc`

: The successor in the start node's incidence list`-directed`

: Returns 1, if the arc is directed`-labelAnchorPoint`

: The index of the layout point, at which the arc label is displayed`-portNode`

: The control point of this arc, attached to the start node`-hidden`

: True, if this edge is completely invisible`-subgraph`

: The subgraph multiplicity of this edge`-edgeColour`

: The colour index of this edge

`<object_name> node <node index> info ...`

:`-firstIncidence`

: The "first" arc in the node's cyclic incidence list`-nodeDemand`

: The node demand`-hidden`

: True, if this node is invisible`-distance`

: The node distance label`-potential`

: The node potential`-nodeColour`

: The node colour`-predecessorArc`

: The predecessor arc ending at this node`-degree`

: The node degree in the current subgraph

`<object_name> layout point <point index> info ...`

:`-successor`

: The successor in a sequence of layout control points or`*`

`-cx`

: The x-coordinate value in the current drawing`-cy`

: The y-coordinate value in the current drawing`-hidden`

: True, if this layout point is invisible

`delete`

: Delete this graph object`node insert`

: Generate a graph node and return its index`node <node index> delete`

: Delete the specified node

`configure`

:`-upperBound <capacity value>`

: Assign a constant upper arc capacity bound`-lowerBound <capacity value>`

: Assign a constant lower arc capacity bound`-edgeLength <arc length value>`

: Assign a constant arc length label`-nodeDemand <capacity value>`

: Assign a constant node demand`-sourceNode <node index>`

: Assign a default source node`-targetNode <node index>`

: Assign a default target node`-rootNode <node index>`

: Assign a default root node`-metricType <edge length mode>`

: Specify the mode of edge length determination, either`disabled`

,`manhattan`

,`euclidian`

,`maximum`

or`spheric`

`-exteriorArc <arc index>`

: Assign an exterior face, specified by one of its arcs

`random`

`edges`

: Generate a specified number of equally distributed edges`-numEdges <number of egdes to be generated>`

`eulerian`

: Generate a random closed walk with a specified number of edge`-numEdges< <number of egdes to be generated>`

`regular`

: Generate a regular graph by adding ranodm arcs`-degree <desired node degree>`

`-upperBound`

: Generate equally distributed upper edge capacity bounds`-lowerBound`

: Generate equally distributed lower edge capacity bounds`-edgeLength`

: Generate equally distributed edge length labels`-geometry`

: Generate equally distributed node positions

`extract`

`tree`

: Load the predecessor arcs with a tree subgraph`-rootNode <node index>`

`path`

: Load the predecessor arcs with a path subgraph`-sourceNode <node index>`

`-targetNode <node index>`

`cycles`

: Load the predecessor arcs with a disjoint cycle subgraph`matching`

: Load the predecessor arcs with a 1-matching subgraph`edgeCover`

: Load the edge colours with an edge cover obtained from a 1-matching subgraph`trees`

: Load the predecessor arcs with a 1-matching subgraph`cut`

: Load the node colours with a bipartition given by the finite distance labels`bipartition`

: Load the node colours with a bipartition given by the odd distance labels`colours`

: Load the node colours with a partition

`release`

: Release the specified register attributes`-subgraph`

`-distance`

`-predecessorArc`

`-nodeColour`

`-edgeColour`

`-potential`

`-partition`

For sparse graph objects only:

`arc insert`

: Generate a graph edge and return its index (excluding the arc orintation bit)`arc <arc index> delete`

: Delete the specified edge`arc <arc index> contract`

: Identify both end nodes and then delete the arc`reorder`

`incidences`

: Manipulate the node incidence lists`-planar`

: If possible, achieve a planar representation`-shuffle`

: Random ordering`-geometric`

: Adopt from the current drawing`-outerplanar`

: From a given planar representation, increase the exterior face length

`nodeIndices`

: Manipulate the node indices`-colours`

: Order by the colour index values`-demands`

: Order by the node demand values`-shuffle`

: Random ordering

`edgeIndices`

:Manipulate the edge indices`-colours`

: Order by the colour index values`-lengths`

: Order by the edge length labels`-shuffle`

: Random ordering

`seriesParallel`

: Apply the edge series-parallel decomposition method`-embedding`

: If the graph is series-parallel, determine respective node incidence orders`-orient`

: If the graph is series-parallel, assign respective arc orientations`-undirected`

: Ignore the arc orientations`-layout`

: Determine a visibility representation`-minor`

: If the graph is not series-parallel, find a forbidden minor`-sourceNode <source node index>`

(optional)`-targetNode <target node index>`

(optional)

`merge <option> <object handle>`

: Merge another graph into this object`-right`

: Disjoint merge, added graph is displayed on the right-hand side`-below`

: Disjoint merge, added graph is displayed below`-facets`

: FacetIdentification() method

`explicitParallels`

: Replace high-capacity edges by couples of parallel edges,

`<object_name> arc <arc index> ...`

. Most messages do not actually depend on the arc direction, but all expect arc indices including the direction bit.

`configure`

`-upperBound <capacity value>`

: Assign an upper capacity bound to this edge`-lowerBound <capacity value>`

: Assign a lower capacity bound to this edge`-edgeLength <arc length value>`

: Assign a length label to this edge`-righthandArc <arc index>`

:`-directed <binary number>`

: Mark this edge as directed (1) or undirected (0)`-subgraph <subgraph mulitplicity>`

: Assign a subgraph mulitplicity to this edge`-edgeColour <arc index>`

: Assign a colour index to this edge

`provide`

:`-labelAnchorPoint`

: If not yet present, reserve an arc label anchor point, and return its index`-portNode`

: If not yet present, reserve a port node, and return its index

`straightLine`

: Release all control points for this edge`reverse`

: Reverse the orientation of this arc

`<object_name> node <node index> ...`

`configure`

`-firstIncidence <arc index>`

: Select the first arc in the node's cyclic incidence list`-nodeDemand <capacity value>`

: Assign a node demand / capacity`-distance`

: Assign a node distance label`-potential`

: Assign a node potential`-nodeColour <node index>`

: Assign a node colour index`-predecessorArc <arc index>`

: Select a predecessor arc pointing to this node

For sparse bigraphs objects only:

`swap`

: Move this node to the other component

`<object_name> layout point <point index> ...`

`insertSuccessor`

: Add a control point right after this layout point, and return its index`placeAt <sequence of coordinate values>`

`write <file name>`

applies to all library data objects. The output depends, however, on the concrete data object type. For the time being, only the proprietary formats are supported.