Softanza
StartFrançais
Softanza
StartFrançais
The library documents itself · Diagramming & graphs

stzGraph

292 own methods · 50 forms written with extensions, listed under their method

the source: base/graph/stzGraph.ring(opens in a new tab) · All classes · The area reference: Diagramming & graphs

Under each method, its extensions (Q CS XT Z ZZ IB W U): bold and ticked, it exists; struck, it does not. The extensions and what they mean

Examples: 3 come from the library's tests; 108 were composed from each method's signature and run for this page, on a fresh object, for example o1 = new stzGraph("g") o1.AddNode("A") o1.AddNode("B") o1.AddNode("C") o1.AddNode("D") o1.AddEdge("A", "B") o1.AddEdge("A", "C") o1.AddEdge("B", "D"). 181 methods have none yet. Examples run on 2026-10-03 20:34 inside the library at commit 0e72e2e2c.

Method
Explanation, as the source carries it
init
(no comment in the source: the name reads as a sentence) initno extension
HasEngine
Public doorway to the engine-resident graph, so a collaborator (the graphics face, a future analytics face) can hand the HANDLE to an engine metric instead of marshalling a copy of the adjacency.
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.HasEngine()
#--> 1
composed from the signature, run for this page
no extension
EngineHandle
(no comment in the source: the name reads as a sentence) engine handlein the section engine adapter layerno extension
Copy
(no comment in the source: the name reads as a sentence) copyin the section engine adapter layerno extension
Id
(no comment in the source: the name reads as a sentence) idin the section engine adapter layer
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.Id()
#--> g
composed from the signature, run for this page
no extension
Name
(no comment in the source: the name reads as a sentence) namein the section engine adapter layer
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.Name()
#--> g
composed from the signature, run for this page
no extension
GraphType
(no comment in the source: the name reads as a sentence) graph typein the section engine adapter layer
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.GraphType()
#--> structural
composed from the signature, run for this page
no extension
SetGraphType
(no comment in the source: the name reads as a sentence) set graph typein the section engine adapter layerno extension
IsGraph
(no comment in the source: the name reads as a sentence) is graphin the section engine adapter layer
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.IsGraph()
#--> 1
composed from the signature, run for this page
no extension
IsAGraph
(no comment in the source: the name reads as a sentence) is a graphin the section engine adapter layer
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.IsAGraph()
#--> 1
composed from the signature, run for this page
no extension
IsStzGraph
(no comment in the source: the name reads as a sentence) is stz graphin the section engine adapter layer
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.IsStzGraph()
#--> 1
composed from the signature, run for this page
no extension
IsAStzGraph
(no comment in the source: the name reads as a sentence) is a stz graphin the section engine adapter layer
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.IsAStzGraph()
#--> 1
composed from the signature, run for this page
no extension
IsStzGraphObject
(no comment in the source: the name reads as a sentence) is stz graph objectin the section engine adapter layer
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.IsStzGraphObject()
#--> 1
composed from the signature, run for this page
no extension
IsAStzGraphObject
(no comment in the source: the name reads as a sentence) is a stz graph objectin the section engine adapter layer
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.IsAStzGraphObject()
#--> 1
composed from the signature, run for this page
no extension
IsGraphObject
(no comment in the source: the name reads as a sentence) is graph objectin the section engine adapter layer
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.IsGraphObject()
#--> 1
composed from the signature, run for this page
no extension
IsAGraphObject
(no comment in the source: the name reads as a sentence) is a graph objectin the section engine adapter layer
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.IsAGraphObject()
#--> 1
composed from the signature, run for this page
no extension
AddNode
(no comment in the source: the name reads as a sentence) add node 3 examples runin the section node operationsQCSXTZZZIBWUXTT
Node
(no comment in the source: the name reads as a sentence) nodealso written: NodeByIdin the section node operations
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.Node("A") )
#--> [ [ "id", "a" ], [ "label", "A" ], [ "properties", [ ] ] ]
composed from the signature, run for this page
QCSXTZZZIBWU
NodeExists
(no comment in the source: the name reads as a sentence) node existsalso written: HasNodein the section node operations
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.NodeExists("A")
#--> 1
composed from the signature, run for this page
no extension
SetNodes
(no comment in the source: the name reads as a sentence) set nodesin the section node operationsno extension
SetEdges
(no comment in the source: the name reads as a sentence) set edgesin the section node operationsno extension
Nodes
(no comment in the source: the name reads as a sentence) nodesin the section node operationsQCSXTZZZIBWUWF
NodesIds
(no comment in the source: the name reads as a sentence) nodes idsalso written: NodesNamesin the section node operations
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.NodesIds() )
#--> [ "a", "b", "c", "d" ]
composed from the signature, run for this page
no extension
NodesCount
(no comment in the source: the name reads as a sentence) nodes countin the section node operations
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.NodesCount()
#--> 4
composed from the signature, run for this page
no extension
NodeCount
(no comment in the source: the name reads as a sentence) node count 1 examples runin the section node operations
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.NodeCount()
#--> 4
composed from the signature, run for this page
no extension
HowManyNodes
(no comment in the source: the name reads as a sentence) how many nodesin the section node operations
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.HowManyNodes()
#--> 4
composed from the signature, run for this page
no extension
HowManyNode
(no comment in the source: the name reads as a sentence) how many nodein the section node operations
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.HowManyNode()
#--> 4
composed from the signature, run for this page
no extension
NumberOfNodes
(no comment in the source: the name reads as a sentence) number of nodesin the section node operations
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.NumberOfNodes()
#--> 4
composed from the signature, run for this page
no extension
AddNodes
(no comment in the source: the name reads as a sentence) add nodesin the section node operationsno extension
InsertNodeBefore
insert node beforeQCSXTZZZIBWUXTT
InsertNodeAfter
insert node afterQCSXTZZZIBWUXTT
InsertNodesBefore
insert multiple nodesno extension
InsertNodesAfter
insert multiple nodesno extension
RemoveNodes
(no comment in the source: the name reads as a sentence) remove nodesin the section node removalno extension
RemoveAllNodes
(no comment in the source: the name reads as a sentence) remove all nodesin the section node removalno extension
Clear
(no comment in the source: the name reads as a sentence) clearin the section node removalno extension
RemoveTheseNodes
(no comment in the source: the name reads as a sentence) remove these nodesin the section node removalno extension
RemoveThisNode
(no comment in the source: the name reads as a sentence) remove this nodein the section node removalno extension
RemoveNode
(no comment in the source: the name reads as a sentence) remove nodein the section node removalno extension
RemoveNodeAt
(no comment in the source: the name reads as a sentence) remove node atin the section node removalno extension
RemoveNodeAtPath
(no comment in the source: the name reads as a sentence) remove node at pathin the section node removalno extension
RemoveNodesAt
(no comment in the source: the name reads as a sentence) remove nodes atin the section node removalno extension
RemoveNodesAtPaths
(no comment in the source: the name reads as a sentence) remove nodes at pathsin the section node removalno extension
RemoveEdges
edge removalno extension
RemoveAllEdges
edge removalno extension
ClearEdges
edge removalno extension
RemoveThisEdge
edge removalno extension
RemoveEdge
edge removalno extension
Disconnect
edge removalno extension
RemoveEdgesConnectedTo
edge removalno extension
EnableConstraints
Control flagsno extension
EnforceConstraints
enabling or disabling checksno extension
DisableConstraints
enabling or disabling checksno extension
ConstraintsEnabled
enabling or disabling checks
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.ConstraintsEnabled()
#--> 1
composed from the signature, run for this page
no extension
EnableAutoDerive
enabling or disabling checksno extension
EnforceAutoDerive
enabling or disabling checksno extension
DisableAutoDerive
enabling or disabling checksno extension
AutoDeriveEnabled
enabling or disabling checks
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.AutoDeriveEnabled()
#--> 0
composed from the signature, run for this page
no extension
WithoutConstraints
Temporarily bypass rulesno extension
BypassingConstraints
Same as WithoutConstraints: Temporarily bypass rulesno extension
CanAddEdge
Pre-flight checks (non-mutating)
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.CanAddEdge("A", "D", "a")
#--> 1
composed from the signature, run for this page
no extension
WhyCannotAddEdge
pre-flight methodsalso written: WhyCannotConnect
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.WhyCannotAddEdge("a", "a", "a")
#--> Edge can be added
composed from the signature, run for this page
no extension
AddEdge
(no comment in the source: the name reads as a sentence) add edge 2 examples runin the section edge operationsQCSXTZZZIBWUXTT
Connect
(no comment in the source: the name reads as a sentence) connectin the section edge operationsQCSXTZZZIBWUXTTMany
ConnectIfAbsent
But "connect these two if they aren't connected yet" is an ordinary thing to want, and it forced every caller to write the EdgeExists() guard by hand -- or to wrap the call in a try/catch that also swallows the two failures that DO matter here. So the duplicate case, and only the duplicate case, is answered instead of raised: a missing node still raises, and a constraint violation still raises.also written: AddEdgeIfAbsent · ConnectIfNotConnected
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.ConnectIfAbsent("a", "a")
#--> 1
composed from the signature, run for this page
no extension
ConnectSequence
(no comment in the source: the name reads as a sentence) connect sequencein the section edge operationsQCSXTZZZIBWU
ConnectInSequence
(no comment in the source: the name reads as a sentence) connect in sequencein the section edge operationsQCSXTZZZIBWU
AddEdges
(no comment in the source: the name reads as a sentence) add edgesin the section edge operationsQCSXTZZZIBWUXTT
ConnectToMany
(no comment in the source: the name reads as a sentence) connect to manyin the section edge operationsno extension
ConnectEdgesXTT
(no comment in the source: the name reads as a sentence) connect edges xttin the section edge operationsno extension
Edge
(no comment in the source: the name reads as a sentence) edgein the section edge operationsno extension
EdgeExists
(no comment in the source: the name reads as a sentence) edge existsalso written: HasEdgein the section edge operations
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.EdgeExists("a", "a")
#--> 0
composed from the signature, run for this page
no extension
Edges
(no comment in the source: the name reads as a sentence) edgesin the section edge operationsQCSXTZZZIBWUWF
EdgesCount
(no comment in the source: the name reads as a sentence) edges countin the section edge operations
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.EdgesCount()
#--> 3
composed from the signature, run for this page
no extension
EdgeCount
(no comment in the source: the name reads as a sentence) edge countin the section edge operations
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.EdgeCount()
#--> 3
composed from the signature, run for this page
no extension
HowManyEdges
(no comment in the source: the name reads as a sentence) how many edgesin the section edge operations
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.HowManyEdges()
#--> 3
composed from the signature, run for this page
no extension
HowManyEdge
(no comment in the source: the name reads as a sentence) how many edgein the section edge operations
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.HowManyEdge()
#--> 3
composed from the signature, run for this page
no extension
NumberOfEdges
(no comment in the source: the name reads as a sentence) number of edgesin the section edge operations
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.NumberOfEdges()
#--> 3
composed from the signature, run for this page
no extension
EdgeCountBetween
(no comment in the source: the name reads as a sentence) edge count betweenalso written: EdgesBetweenCountin the section edge operations
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.EdgeCountBetween("a", "a")
#--> 0
composed from the signature, run for this page
no extension
EdgesBetween
(no comment in the source: the name reads as a sentence) edges betweenalso written: AllEdgesBetweenin the section edge operationsno extension
RemoveEdgeByLabel
(no comment in the source: the name reads as a sentence) remove edge by labelin the section edge operationsno extension
RemoveEdgeWithLabel
(no comment in the source: the name reads as a sentence) remove edge with labelin the section edge operationsno extension
DisconnectByLabel
(no comment in the source: the name reads as a sentence) disconnect by labelin the section edge operationsno extension
RemoveAllEdgesBetween
(no comment in the source: the name reads as a sentence) remove all edges betweenin the section edge operationsno extension
RemoveEdgesBetween
(no comment in the source: the name reads as a sentence) remove edges betweenin the section edge operationsno extension
DisconnectAll
(no comment in the source: the name reads as a sentence) disconnect allin the section edge operationsno extension
UpdateNodes
batch update operations using functionsQCSXTZZZIBWUF
UpdateEdges
batch update operations using functionsQCSXTZZZIBWUF
CopyNode
copy operations
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.CopyNode("A") )
#--> [ [ "id", "a" ], [ "label", "A" ], [ "properties", [ ] ] ]
composed from the signature, run for this page
no extension
DuplicateNode
copy operationsno extension
CloneNode
copy operationsno extension
DuplicateNodeWithEdges
copy operationsno extension
MergeNodes
merge operationsQCSXTZZZIBWU
CombineNodes
merge operationsno extension
SplitNode
merge operationsno extension
Properties
(no comment in the source: the name reads as a sentence) propertiesalso written: Propsin the section managing node propertiesQCSXTZZZIBWU
PropsAndTheirValues
(no comment in the source: the name reads as a sentence) props and their valuesin the section managing node propertiesno extension
SetNodeLabel
A node could only ever be labelled at birth, via AddNodeXT(id, label); there was no way to say it afterwards, and no way to ask. So a format that reads a node first and learns its label a line later (.stzsim's `add node X` / `label: "..."`) had nowhere to put it.no extension
NodeLabel
(no comment in the source: the name reads as a sentence) node labelin the section managing node propertiesno extension
SetNodeProperty
(no comment in the source: the name reads as a sentence) set node propertyin the section managing node propertiesno extension
SetNodeProp
(no comment in the source: the name reads as a sentence) set node propin the section managing node propertiesno extension
UpdateNodeProperty
(no comment in the source: the name reads as a sentence) update node propertyin the section managing node propertiesno extension
UpdateNodeProp
(no comment in the source: the name reads as a sentence) update node propin the section managing node propertiesno extension
SetNodeProperties
(no comment in the source: the name reads as a sentence) set node propertiesin the section managing node propertiesno extension
SetNodeProps
(no comment in the source: the name reads as a sentence) set node propsin the section managing node propertiesno extension
NodeProperties
(no comment in the source: the name reads as a sentence) node propertiesalso written: NodePropsin the section managing node propertiesQCSXTZZZIBWU
NodePropertiesAndTheirValues
(no comment in the source: the name reads as a sentence) node properties and their valuesin the section managing node propertiesno extension
NodePropsAndTheirValues
(no comment in the source: the name reads as a sentence) node props and their valuesin the section managing node propertiesno extension
NodeProperty
(no comment in the source: the name reads as a sentence) node property 1 examples runalso written: NodePropin the section managing node propertiesno extension
RemoveNodeProperties
(no comment in the source: the name reads as a sentence) remove node propertiesin the section managing node propertiesno extension
ClearNodeProperties
(no comment in the source: the name reads as a sentence) clear node propertiesin the section managing node propertiesno extension
RemoveNodeProps
(no comment in the source: the name reads as a sentence) remove node propsin the section managing node propertiesno extension
ClearNodeProps
(no comment in the source: the name reads as a sentence) clear node propsin the section managing node propertiesno extension
RemoveAllProperties
(no comment in the source: the name reads as a sentence) remove all propertiesin the section managing node propertiesno extension
ClearAllProperties
(no comment in the source: the name reads as a sentence) clear all propertiesin the section managing node propertiesno extension
SetEdgeProperty
(no comment in the source: the name reads as a sentence) set edge propertyalso written: SetEdgePropin the section managing node propertiesno extension
UpdateEdgeProperty
(no comment in the source: the name reads as a sentence) update edge propertyin the section managing node propertiesno extension
UpdateEdgeProp
(no comment in the source: the name reads as a sentence) update edge propin the section managing node propertiesno extension
EdgeProperty
(no comment in the source: the name reads as a sentence) edge propertyalso written: EdgePropin the section managing node propertiesno extension
SetEdgeProperties
(no comment in the source: the name reads as a sentence) set edge propertiesin the section managing node propertiesno extension
SetEdgeProps
(no comment in the source: the name reads as a sentence) set edge propsin the section managing node propertiesno extension
EdgeProperties
(no comment in the source: the name reads as a sentence) edge propertiesalso written: EdgePropsin the section managing node propertiesQCSXTZZZIBWU
ToCanvas
The doorway to the graphics plane: a graph hands back a CANVAS whose node sizes and colours are computed from the graph's own shape. oG.ToCanvasQ([ :Layout = :Hierarchical, :SizeBy = :Impact ]) It answers an stzCanvas, so ToSVG() and ToPNG() come with it.QCSXTZZZIBWU
GraphCanvas
The face itself, when a caller wants the metrics or the positions rather than only the drawing.no extension
PathExists
(no comment in the source: the name reads as a sentence) path existsin the section traversal & pathfindingno extension
FirstNode
(no comment in the source: the name reads as a sentence) first nodein the section traversal & pathfinding
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.FirstNode() )
#--> [ [ "id", "a" ], [ "label", "A" ], [ "properties", [ ] ] ]
composed from the signature, run for this page
no extension
FirstNodeId
(no comment in the source: the name reads as a sentence) first node idin the section traversal & pathfinding
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.FirstNodeId()
#--> a
composed from the signature, run for this page
no extension
LastNode
(no comment in the source: the name reads as a sentence) last nodein the section traversal & pathfinding
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.LastNode() )
#--> [ [ "id", "d" ], [ "label", "D" ], [ "properties", [ ] ] ]
composed from the signature, run for this page
no extension
LastNodeId
(no comment in the source: the name reads as a sentence) last node idin the section traversal & pathfinding
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.LastNodeId()
#--> d
composed from the signature, run for this page
no extension
NthNode
(no comment in the source: the name reads as a sentence) nth nodealso written: NodeAt · NodeAtPositionin the section traversal & pathfinding
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.NthNode(2) )
#--> [ [ "id", "b" ], [ "label", "B" ], [ "properties", [ ] ] ]
composed from the signature, run for this page
no extension
NodePosition
(no comment in the source: the name reads as a sentence) node positionin the section traversal & pathfinding
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.NodePosition("A")
#--> 1
composed from the signature, run for this page
no extension
FindNode
(no comment in the source: the name reads as a sentence) find nodealso written: PathsToNodein the section traversal & pathfindingno extension
PathsTo
(no comment in the source: the name reads as a sentence) paths toin the section traversal & pathfindingno extension
Paths
(no comment in the source: the name reads as a sentence) pathsin the section traversal & pathfindingQCSXTZZZIBWUWF
PathsBetweenXT
(no comment in the source: the name reads as a sentence) paths between xtin the section traversal & pathfindingno extension
Path
(no comment in the source: the name reads as a sentence) pathalso written: FirstPath · PathBetween · FirstPathBetweenin the section traversal & pathfindingQCSXTZZZIBWU
Neighbors
(no comment in the source: the name reads as a sentence) neighborsalso written: NeighborsOf · NeighborsToin the section traversal & pathfinding
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.Neighbors("A") )
#--> [ "b", "c" ]
composed from the signature, run for this page
no extension
Incoming
(no comment in the source: the name reads as a sentence) incomingalso written: IncomingToin the section traversal & pathfindingno extension
HasCyclicDependencies
cycle detection
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.HasCyclicDependencies()
#--> 0
composed from the signature, run for this page
no extension
ReachableFrom
Both implementations below now agree on that definition AND on the order of the result (node-insertion order). They did not: the engine excluded the start node while the pure-Haro fallback INCLUDED it and returned BFS-discovery order, so the same call answered ["b"] or ["a","b"] depending on whether the graph DLL happened to be loaded (measured 2026-08-07). The engine is the shipped path, so it defines the contract.also written: ReachableFromNode
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.ReachableFrom("A") )
#--> [ "b", "c", "d" ]
composed from the signature, run for this page
no extension
BottleneckNodes
(no comment in the source: the name reads as a sentence) bottleneck nodesin the section analysis metrics
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.BottleneckNodes() )
#--> [ "a", "b" ]
composed from the signature, run for this page
no extension
NodeDensity
(no comment in the source: the name reads as a sentence) node densityalso written: Density · Density01 · NodeDensity01 · DirectedDensity · DirectedDensity01 · DirectedNodeDensity · DirectedNodeDensity01in the section analysis metrics
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.NodeDensity()
#--> 0.25
composed from the signature, run for this page
no extension
NodeDensity100
(no comment in the source: the name reads as a sentence) node density100also written: Density100 · DirectedDensity100 · NodeDensityPercent · NodeDensityInPercent · DirectedNodeDensity100 · NodeDensityInPercentage · DirectedNodeDensityPercent · DirectedNodeDensityInPercent · DirectedNodeDensityInPercentagein the section analysis metrics
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.NodeDensity100()
#--> 25
composed from the signature, run for this page
no extension
UndirectedNodeDensity
(no comment in the source: the name reads as a sentence) undirected node densityalso written: UndirectedDensity · UndirectedDensity01 · UndirectedNodeDensity01in the section analysis metrics
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.UndirectedNodeDensity()
#--> 0.50
composed from the signature, run for this page
no extension
UndirectedNodeDensity100
(no comment in the source: the name reads as a sentence) undirected node density100also written: UndirectedDensity100 · UndirectedNodeDensityPercent · UndirectedNodeDensityInPercent · UndirectedNodeDensityInPercentagein the section analysis metrics
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.UndirectedNodeDensity100()
#--> 50
composed from the signature, run for this page
no extension
IsSparse
(no comment in the source: the name reads as a sentence) is sparsein the section analysis metrics
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.IsSparse()
#--> 1
composed from the signature, run for this page
no extension
IsDense
(no comment in the source: the name reads as a sentence) is densein the section analysis metrics
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.IsDense()
#--> 0
composed from the signature, run for this page
no extension
DensityCategory
(no comment in the source: the name reads as a sentence) density categoryalso written: DensityLevelin the section analysis metrics
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.DensityCategory()
#--> sparse
composed from the signature, run for this page
no extension
LongestPath
(no comment in the source: the name reads as a sentence) longest pathin the section analysis metricsno extension
CyclicNodes
(no comment in the source: the name reads as a sentence) cyclic nodesin the section analysis metricsno extension
ParallelizableBranches
1. independence and parallelizationalso written: ParaBranches
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.ParallelizableBranches() )
#--> [ [ "b", "c" ] ]
composed from the signature, run for this page
no extension
DependencyFreeNodes
1. independence and parallelization
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.DependencyFreeNodes() )
#--> [ "a" ]
composed from the signature, run for this page
no extension
ImpactOf
2. criticality and impact
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.ImpactOf("A")
#--> 3
composed from the signature, run for this page
no extension
FailureScope
2. criticality and impact
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.FailureScope("A") )
#--> [ "b", "c", "d" ]
composed from the signature, run for this page
no extension
NodeCriticality
2. criticality and impact
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.NodeCriticality() )
#--> [ [ [ "id", "a" ], [ "criticality", 2 ] ], [ [ "id", "b" ], [ "criticality", 2 ] ], [ [ "id", "c" ], [ "criticality", 1 ] ], [ [ "id", "d" ], [ "criticality", 1 ] ] ]
composed from the signature, run for this page
no extension
MostCriticalNodes
2. criticality and impact
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.MostCriticalNodes(2) )
#--> [ "a", "b" ]
composed from the signature, run for this page
no extension
FindQ
Opens a rich query on the graph. The finder is an OBJECT, so it carries the Q -- there is no data-shaped twin of a query builder.no extension
NodesByType
(no comment in the source: the name reads as a sentence) nodes by typein the section rich querying - based on stzgraphfinder classno extension
NodesWhere
(no comment in the source: the name reads as a sentence) nodes wherein the section rich querying - based on stzgraphfinder classQCSXTZZZIBWUF
NodesByProperty
(no comment in the source: the name reads as a sentence) nodes by propertyin the section rich querying - based on stzgraphfinder classno extension
EdgesWhere
(no comment in the source: the name reads as a sentence) edges wherein the section rich querying - based on stzgraphfinder classQCSXTZZZIBWUF
EdgesByProperty
(no comment in the source: the name reads as a sentence) edges by propertyin the section rich querying - based on stzgraphfinder classno extension
PathsWhereF
(no comment in the source: the name reads as a sentence) paths where fin the section rich querying - based on stzgraphfinder classno extension
QueryQ
advanced quryies - based on stzgraphquery classno extension
ShortestPath
graph algorithmsno extension
BFS
Breadth-first visit order from a node (engine-backed).also written: BreadthFirst
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.BFS("A") )
#--> [ "a", "b", "c", "d" ]
composed from the signature, run for this page
no extension
DFS
Depth-first visit order from a node (engine-backed).also written: DepthFirst
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.DFS("A") )
#--> [ "a", "b", "d", "c" ]
composed from the signature, run for this page
no extension
IsBipartite
TRUE if the graph is 2-colourable (bipartite). Engine-backed. 1 examples run
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.IsBipartite()
#--> 1
composed from the signature, run for this page
no extension
StronglyConnectedComponents
Strongly connected components (directed) as a list of node-id groups. Two nodes share a group iff each is reachable from the other. Engine (Kosaraju). Returns [] if the engine is unavailable.also written: SCC
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.StronglyConnectedComponents() )
#--> [ [ "a" ], [ "c" ], [ "b" ], [ "d" ] ]
composed from the signature, run for this page
no extension
NumberOfStronglyConnectedComponents
Number of strongly connected components. Engine-backed.also written: NumberOfSCC
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.NumberOfStronglyConnectedComponents()
#--> 4
composed from the signature, run for this page
no extension
MSTWeight
Total weight of a minimum spanning tree over the undirected version of the graph (-1 if empty or not connected). Engine (Kruskal). 1 examples runalso written: MinimumSpanningTreeWeight
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.MSTWeight()
#--> 3
composed from the signature, run for this page
no extension
MSTEdges
Minimum spanning tree as a list of [fromNode, toNode, weight] edges. Engine (Kruskal); built Zig-side. [] if not connected/empty.also written: MinimumSpanningTreeEdges
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.MSTEdges() )
#--> [ [ "a", "b", 1 ], [ "a", "c", 1 ], [ "b", "d", 1 ] ]
composed from the signature, run for this page
no extension
ArticulationPoints
Articulation points (cut vertices) -- nodes whose removal disconnects the (undirected) graph. Engine (Tarjan low-link). List of node ids.also written: CutVertices
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.ArticulationPoints() )
#--> [ "a", "b" ]
composed from the signature, run for this page
no extension
Bridges
Bridges (cut edges) -- edges whose removal disconnects the (undirected) graph. Engine (Tarjan low-link). List of [u, v] node-id pairs.also written: CutEdges
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.Bridges() )
#--> [ [ "b", "d" ], [ "a", "b" ], [ "a", "c" ] ]
composed from the signature, run for this page
no extension
WeightedShortestPath
Weighted shortest path (Dijkstra over edge :weight properties, default 1.0). Returns the node-id path; [] if unreachable.also written: DijkstraPathno extension
WeightedShortestPathLength
Total weight of the minimum-weight path (-1 if unreachable).also written: DijkstraDistance
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.DijkstraDistance("a", "a")
#--> 0
composed from the signature, run for this page
no extension
ShortestPathLength
graph algorithmsno extension
ConnectedComponents
graph algorithms
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.ConnectedComponents() )
#--> [ [ "a", "b", "d", "c" ] ]
composed from the signature, run for this page
no extension
TopologicalSort
engine-backed graph methods
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.TopologicalSort() )
#--> [ "a", "b", "c", "d" ]
composed from the signature, run for this page
no extension
InDegree
engine-backed graph methods
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.InDegree("A")
#--> 0
composed from the signature, run for this page
no extension
OutDegree
engine-backed graph methods
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.OutDegree("A")
#--> 2
composed from the signature, run for this page
no extension
NumberOfConnectedComponents
engine-backed graph methods
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.NumberOfConnectedComponents()
#--> 1
composed from the signature, run for this page
no extension
IsConnected
engine-backed graph methods
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.IsConnected()
#--> 1
composed from the signature, run for this page
no extension
BetweennessCentrality
(ArticulationPoints is now engine-backed -- see the def above.) Betweenness centrality (Brandes, unweighted) -- computed entirely in the Zig engine. Returns the value for pcNodeId (0 if absent).
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.BetweennessCentrality("A")
#--> 0
composed from the signature, run for this page
no extension
BetweennessCentralityAll
Betweenness for every node as a list of [ id, value ] pairs.
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.BetweennessCentralityAll() )
#--> [ [ "a", 0 ], [ "b", 1 ], [ "c", 0 ], [ "d", 0 ] ]
composed from the signature, run for this page
no extension
ClosenessCentrality
Closeness centrality (engine-backed): reachable / sum(distances). Returns the value for pcNodeId (0 if absent or isolated).
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.ClosenessCentrality("A")
#--> 0.75
composed from the signature, run for this page
no extension
ClosenessCentralityAll
Closeness for every node as a list of [ id, value ] pairs.
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.ClosenessCentralityAll() )
#--> [ [ "a", 0.75 ], [ "b", 1 ], [ "c", 0 ], [ "d", 0 ] ]
composed from the signature, run for this page
no extension
CoreNumber
k-core: core number of pcNodeId -- the largest k for which the node survives in the k-core of the undirected view. Engine (Batagelj-Zaversnik).also written: KCoreNumber
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.CoreNumber("A")
#--> 1
composed from the signature, run for this page
no extension
CoreNumbers
Core number for every node as a list of [ id, value ] pairs.also written: CoreNumbersAll
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.CoreNumbers() )
#--> [ [ "a", 1 ], [ "b", 1 ], [ "c", 1 ], [ "d", 1 ] ]
composed from the signature, run for this page
no extension
PageRank
PageRank (power iteration, damping 0.85) of pcNodeId. Engine-backed.
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.PageRank("A")
#--> 0.16
composed from the signature, run for this page
no extension
PageRankAll
PageRank for every node as a list of [ id, value ] pairs.
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.PageRankAll() )
#--> [ [ "a", 0.16 ], [ "b", 0.24 ], [ "c", 0.24 ], [ "d", 0.36 ] ]
composed from the signature, run for this page
no extension
AStarPath
A* shortest path (engine-backed). Uses edge weights plus a coordinate heuristic when nodes carry :x and :y properties (Euclidean by default); with no coordinates it degrades gracefully to a Dijkstra-equivalent. Returns the path as a list of node ids ([] if none).also written: AStar · AStarShortestPath
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.AStar("A", "a") )
#--> [ "a" ]
composed from the signature, run for this page
no extension
AStarPathManhattan
A* with the Manhattan (taxicab) heuristic.no extension
AStarPathWeighted
A* with an auto-scaled ADMISSIBLE coordinate heuristic -- use when edge weights are not unit geometric distance (the heuristic is scaled by the minimum edge cost-per-distance ratio so the path stays optimal). nMode 1 = Euclidean coords, 2 = Manhattan.no extension
SetEdgeWeight
Override the (engine) weight of a directed edge. Used by stzGraphPlanner to push per-optimisation transition costs before an engine A* search. Returns 1 on success, 0 if the edge is unknown.
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.SetEdgeWeight("A", "D", 2)
#--> 0
composed from the signature, run for this page
no extension
AStarPlan
Engine A* for planners: one search returns [ routeList, exploredList ] (the explored/closed order powers explainability metrics). nMode 0 is Dijkstra/UCS -- optimal for any non-negative edge cost.
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.AStarPlan("A", "a", 2) )
#--> [ [ "a" ], [ "a" ] ]
composed from the signature, run for this page
no extension
Diameter
Diameter = longest shortest path over all reachable pairs (engine, all-pairs BFS). Replaces the old O(V^2 * BFS) pure-Haro double loop.
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.Diameter()
#--> 2
composed from the signature, run for this page
no extension
Radius
Radius = smallest eccentricity among nodes that reach others.
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.Radius()
#--> 1
composed from the signature, run for this page
no extension
Eccentricity
Eccentricity of a node = its longest shortest path to any reachable node.
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.Eccentricity("A")
#--> 2
composed from the signature, run for this page
no extension
Eccentricities
Eccentricity for every node as a list of [ id, value ] pairs.
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.Eccentricities() )
#--> [ [ "a", 2 ], [ "b", 1 ], [ "c", 0 ], [ "d", 0 ] ]
composed from the signature, run for this page
no extension
AveragePathLength
Mean shortest-path length over all reachable pairs (engine, all-pairs BFS).no extension
MaxFlow
Maximum flow from pcSource to pcSink (Edmonds-Karp, engine). Edge :weight is the capacity (default 1). Returns the flow value.also written: MaximumFlow
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.MaxFlow("A", "a")
#--> 0
composed from the signature, run for this page
no extension
MinCut
Minimum cut between pcSource and pcSink: the saturated edges crossing the cut, as a list of [from, to] id pairs (max-flow / min-cut). Engine.also written: MinimumCutno extension
Communities
Community detection (label propagation, engine, undirected view). Returns a list of communities, each a list of node ids.also written: DetectCommunities
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.Communities() )
#--> [ [ "a", "c" ], [ "b", "d" ] ]
composed from the signature, run for this page
no extension
NumberOfCommunities
engine-backed graph methods
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.NumberOfCommunities()
#--> 2
composed from the signature, run for this page
no extension
MinCostMaxFlow
Min-cost max-flow from pcSource to pcSink. Edge :weight is capacity, edge :cost is per-unit cost. Returns [ flowValue, totalCost ]. Engine (successive shortest paths).also written: MinCostFlow
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.MinCostMaxFlow("A", "a") )
#--> [ 0, 0 ]
composed from the signature, run for this page
no extension
ClusteringCoefficient
Local clustering coefficient (engine, undirected view): edges among a node's neighbours / possible such edges. Replaces the old O(k^2) pure-Haro EdgeExists double loop.also written: ClusteringCoeff
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.ClusteringCoefficient("A")
#--> 0
composed from the signature, run for this page
no extension
ClusteringCoefficients
Local clustering coefficient for every node as [ id, value ] pairs.
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.ClusteringCoefficients() )
#--> [ [ "a", 0 ], [ "b", 0 ], [ "c", 0 ], [ "d", 0 ] ]
composed from the signature, run for this page
no extension
PathWeight
engine-backed graph methodsno extension
ToHashlist
(no comment in the source: the name reads as a sentence) to hashlistin the section export and interoperabilityno extension
ExportToDOT
(no comment in the source: the name reads as a sentence) export to dotalso written: Dot · ToDotin the section export and interoperabilityQCSXTZZZIBWU
ExportToJSON
(no comment in the source: the name reads as a sentence) export to jsonalso written: Json · ToJsonin the section export and interoperabilityno extension
ExportToYAML
(no comment in the source: the name reads as a sentence) export to yamlalso written: Yaml · ToYamlin the section export and interoperabilityno extension
ExportToGraphML
(no comment in the source: the name reads as a sentence) export to graph mlalso written: AsGraphML · ToGraphMLin the section graphml formatno extension
SaveToGraphML
(no comment in the source: the name reads as a sentence) save to graph mlin the section graphml formatno extension
SaveAsGraphML
(no comment in the source: the name reads as a sentence) save as graph mlin the section graphml formatno extension
LoadFromGraphML
(no comment in the source: the name reads as a sentence) load from graph mlin the section graphml formatno extension
LoadGraphML
(no comment in the source: the name reads as a sentence) load graph mlin the section graphml formatno extension
ImportFromGraphML
(no comment in the source: the name reads as a sentence) import from graph mlin the section graphml formatno extension
ImportGraphML
(no comment in the source: the name reads as a sentence) import graph mlin the section graphml formatno extension
Show
(no comment in the source: the name reads as a sentence) showin the section visualising in asciino extension
Shwo
(no comment in the source: the name reads as a sentence) shwoin the section visualising in asciino extension
AsciiArt
The same picture as DATA, for a file, a report, or a test. Show() prints it; these hand it back.no extension
AsciiArtHorizontal
... and the horizontal one.
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.AsciiArtHorizontal()
#--> ╭─────╮     ╭─────╮     ╭───╮
#--> │ !A! │---->│ !B! │---->│ D │
#--> ╰─────╯     ╰─────╯     ╰───╯
composed from the signature, run for this page
no extension
Rendition
DISPLAY, not View -- the same correction as stzDiagram's, and for the same reason: `View` is a NOUN in this module (stzGraphView, ToView(), IsView()) meaning a filtered projection of the graph. Using it as a verb for "open a window" made one word mean two things in one namespace. Both older spellings are kept as alternative forms, since stzOrgChart and stzWorkflow call View() internally. -- A VALUE THAT SAYS WHAT IT IS (DN9g) --------------------------------- A GRAPH HANDS OVER ITS NODES AND EDGES AND LETS THE CONSUMER LAY THEM OUT, which is exactly what the display contract's first consumer asked a graph to do. Note that Display(), just below, does something else entirely: it opens an external viewer and returns nothing.no extension
RenditionKinds
(no comment in the source: the name reads as a sentence) rendition kindsin the section visualising in ascii
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.RenditionKinds() )
#--> [ "graph", "text" ]
composed from the signature, run for this page
no extension
RenditionAs
(no comment in the source: the name reads as a sentence) rendition asin the section visualising in asciino extension
Display
(no comment in the source: the name reads as a sentence) displayin the section visualising in asciino extension
View
(no comment in the source: the name reads as a sentence) viewin the section visualising in asciino extension
Veiw
(no comment in the source: the name reads as a sentence) veiwin the section visualising in asciino extension
ShowHorizontal
(no comment in the source: the name reads as a sentence) show horizontalin the section visualising in asciino extension
ShowH
(no comment in the source: the name reads as a sentence) show hin the section visualising in asciino extension
ShowVertical
(no comment in the source: the name reads as a sentence) show verticalin the section visualising in asciino extension
ShowV
(no comment in the source: the name reads as a sentence) show vin the section visualising in asciino extension
Explain
Telling the story of the graphno extension
ExplainPath
Telling the story of a particular pathno extension
UseRulesFrom
rule managementno extension
ApplyDerivationRules
rule managementQCSXTZZZIBWU
CheckConstraintRules
rule management
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.CheckConstraintRules([ 2, 3 ]) )
#--> [ 1, [ ] ]
composed from the signature, run for this page
no extension
RulesApplied
rule managementno extension
AddRule
Attach one rule. Plain does the act; the Q form chains (Q convention).QCSXTZZZIBWU
UseRuleSet
Attach every rule of a set (e.g. a domain rule set) to this graph.QCSXTZZZIBWU
CheckRules
The graph checks ITSELF against its attached rules. Returns unified findings [ :rule, :subject, :where, :severity, :message ].no extension
RulesAreSound
SOUND IS NO ERROR, not no finding -- StzFindingsAreSound is the house's one answer, and this line counted findings until 2026-09-11. A code graph carrying only warning-severity findings (thirteen of stzCodeRules' rules are warnings) read as not sound, which is the opposite of what setting a rule to warning means.
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.RulesAreSound()
#--> 1
composed from the signature, run for this page
no extension
AttachedRules
(no comment in the source: the name reads as a sentence) attached rulesin the section the graph owns its rules (softanza orientation)no extension
NumberOfAttachedRules
(no comment in the source: the name reads as a sentence) number of attached rulesin the section the graph owns its rules (softanza orientation)
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.NumberOfAttachedRules()
#--> 0
composed from the signature, run for this page
no extension
AttachedRuleNamed
(no comment in the source: the name reads as a sentence) attached rule namedin the section the graph owns its rules (softanza orientation)no extension
RulesReport
Print the graph's own rule findings, grouped and gated -- via stzRuleReport (the graph collects itself into it, then shows it).no extension
ClearAttachedRules
(no comment in the source: the name reads as a sentence) clear attached rulesin the section the graph owns its rules (softanza orientation)no extension
Rules
(no comment in the source: the name reads as a sentence) rulesin the section the graph owns its rules (softanza orientation)no extension
NumberOfRules
(no comment in the source: the name reads as a sentence) number of rules 1 examples runin the section the graph owns its rules (softanza orientation)
oGraph = new stzGraph("org")
oGraph.LoadFromStzRulz("../_data/bceao_banking.stzrulz")
? "Rules loaded: " + oGraph.NumberOfRules()
? @@( oGraph.RulesSummary()[:Validation] )
? @@( oGraph.RulesSummary()[:Constraint] )
#--> Rules loaded: 2
#--> [ "board_required", "audit_independence" ]
#--> [ ]
library testno extension
RulesSummary
(no comment in the source: the name reads as a sentence) rules summary 1 examples runin the section the graph owns its rules (softanza orientation)
oGraph = new stzGraph("org")
oGraph.LoadFromStzRulz("../_data/bceao_banking.stzrulz")
? "Rules loaded: " + oGraph.NumberOfRules()
? @@( oGraph.RulesSummary()[:Validation] )
? @@( oGraph.RulesSummary()[:Constraint] )
#--> Rules loaded: 2
#--> [ "board_required", "audit_independence" ]
#--> [ ]
library testno extension
ClearRules
(no comment in the source: the name reads as a sentence) clear rulesin the section the graph owns its rules (softanza orientation)no extension
ClearConstraintRules
Clear specific typeno extension
ClearDerivationRules
(no comment in the source: the name reads as a sentence) clear derivation rulesin the section the graph owns its rules (softanza orientation)no extension
ClearValidationRules
(no comment in the source: the name reads as a sentence) clear validation rulesin the section the graph owns its rules (softanza orientation)no extension
RemoveRule
Remove specific ruleno extension
HasRule
Check if rule loadedalso written: ContainsRule
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.HasRule("a")
#--> 0
composed from the signature, run for this page
no extension
ActiveRules
List active rulesno extension
Validators
(no comment in the source: the name reads as a sentence) validatorsin the section validation
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.Validators() )
#--> [ "dag", "reachability", "completeness", "bottleneck" ]
composed from the signature, run for this page
no extension
Validate
(no comment in the source: the name reads as a sentence) validatein the section validationQCSXTZZZIBWU
ValidateDAG
(no comment in the source: the name reads as a sentence) validate dagin the section validation
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.ValidateDAG() )
#--> [ [ "status", "pass" ], [ "rulegroup", "dag" ], [ "domain", "dag" ], [ "issuecount", 0 ], [ "issues", [ ] ], [ "affectednodes", [ ] ] ]
composed from the signature, run for this page
no extension
ValidateReachability
(no comment in the source: the name reads as a sentence) validate reachabilityin the section validation
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.ValidateReachability() )
#--> [ [ "status", "pass" ], [ "rulegroup", "reachability" ], [ "domain", "reachability" ], [ "issuecount", 0 ], [ "issues", [ ] ], [ "affectednodes", [ ] ] ]
composed from the signature, run for this page
no extension
ValidateCompleteness
(no comment in the source: the name reads as a sentence) validate completenessin the section validation
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.ValidateCompleteness() )
#--> [ [ "status", "pass" ], [ "rulegroup", "completeness" ], [ "domain", "completeness" ], [ "issuecount", 0 ], [ "issues", [ ] ], [ "affectednodes", [ ] ] ]
composed from the signature, run for this page
no extension
ValidationSummary
(no comment in the source: the name reads as a sentence) validation summaryalso written: Validation · LastValidation · ValidationResultin the section validation
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.ValidationSummary() )
#--> [ [ "status", "not_run" ], [ "message", "No validation run yet" ] ]
composed from the signature, run for this page
QCSXTZZZIBWU
Anomalies
(no comment in the source: the name reads as a sentence) anomaliesalso written: Issues · Violationsin the section validationno extension
CompareWith
graph comparisonalso written: Diff · DiffWithQCSXTZZZIBWUMany
CompareWithManyQR
(no comment in the source: the name reads as a sentence) compare with many qralso written: DiffManyQR · CompareManyQR · diffManyWithQRin the section multiple graph comparisonno extension
CompareMany
(no comment in the source: the name reads as a sentence) compare manyin the section multiple graph comparisonQCSXTZZZIBWU
LoadFrom
serialization - file format supportno extension
SaveTo
serialization - file format supportno extension
ExportToStzGraf
.stzgraf formatalso written: AsStzGraf · ToStzGrafno extension
SaveToStzGraf
.stzgraf formatno extension
SaveAsStzGraf
.stzgraf formatno extension
LoadFromStzGraf
.stzgraf formatno extension
LoadStzGraf
.stzgraf formatno extension
ExportToStzRulz
.stzrulz formatalso written: AsStzRulz · ToStzRulz
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.AsStzRulz()
#--> ruleset "g Rules"
#-->     ruleGroup: structural
#-->     version: 1.0
#--> rules
composed from the signature, run for this page
no extension
SaveToStzRulz
.stzrulz formatno extension
SaveAsStzRulz
.stzrulz formatno extension
LoadFromStzRulz
.stzrulz format 1 examples run
oGraph = new stzGraph("org")
oGraph.LoadFromStzRulz("../_data/bceao_banking.stzrulz")
? "Rules loaded: " + oGraph.NumberOfRules()
? @@( oGraph.RulesSummary()[:Validation] )
? @@( oGraph.RulesSummary()[:Constraint] )
#--> Rules loaded: 2
#--> [ "board_required", "audit_independence" ]
#--> [ ]
library testno extension
LoadStzRulz
.stzrulz formatno extension
LoadRuleFunctionsFrom
.stzrulf formatno extension
LoadStzRulf
.stzrulf formatno extension
ExportToStzSim
.stzsim formatalso written: AsStzSim · ToStzSimno extension
SaveToStzSim
.stzsim formatno extension
SaveAsStzSim
.stzsim formatno extension
ApplySimulation
.stzsim formatno extension
ApplyStzSim
.stzsim formatno extension
CyclesAllowed
NOTE// I added those methods after including the GraphType attribute So we can use it in a practical way to enforce the beahvir of some features depending on the graph type (see examples at the end of stzGraphTest.ring file)
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.CyclesAllowed()
#--> 0
composed from the signature, run for this page
no extension
ShouldAutoDerive
misc.
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? o1.ShouldAutoDerive()
#--> 0
composed from the signature, run for this page
no extension
ValidateByType
misc.
composed example
o1 = new stzGraph("g")
o1.AddNode("A") o1.AddNode("B") o1.AddNode("C")
o1.AddNode("D")
o1.AddEdge("A", "B") o1.AddEdge("A", "C")
o1.AddEdge("B", "D")
? @@( o1.ValidateByType() )
#--> [ 1, "" ]
composed from the signature, run for this page
no extension
UseDefaultDerivations
misc.no extension