simple

package
v0.8.14 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Dec 2, 2023 License: BSD-3-Clause Imports: 8 Imported by: 0

Documentation

Overview

Package simple provides a suite of simple graph implementations satisfying the gonum/graph interfaces.

All types in simple return the graph.Empty value for empty iterators.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type DirectedGraph

type DirectedGraph struct {
	// contains filtered or unexported fields
}

DirectedGraph implements a generalized directed graph.

func NewDirectedGraph

func NewDirectedGraph() *DirectedGraph

NewDirectedGraph returns a DirectedGraph.

func (*DirectedGraph) AddNode

func (g *DirectedGraph) AddNode(n graph.Node)

AddNode adds n to the graph. It panics if the added node ID matches an existing node ID.

func (*DirectedGraph) Edge

func (g *DirectedGraph) Edge(uid, vid int64) graph.Edge

Edge returns the edge from u to v if such an edge exists and nil otherwise. The node v must be directly reachable from u as defined by the From method.

func (*DirectedGraph) Edges

func (g *DirectedGraph) Edges() graph.Edges

Edges returns all the edges in the graph.

func (*DirectedGraph) From

func (g *DirectedGraph) From(id int64) graph.Nodes

From returns all nodes in g that can be reached directly from n.

The returned graph.Nodes is only valid until the next mutation of the receiver.

func (*DirectedGraph) HasEdgeBetween

func (g *DirectedGraph) HasEdgeBetween(xid, yid int64) bool

HasEdgeBetween returns whether an edge exists between nodes x and y without considering direction.

func (*DirectedGraph) HasEdgeFromTo

func (g *DirectedGraph) HasEdgeFromTo(uid, vid int64) bool

HasEdgeFromTo returns whether an edge exists in the graph from u to v.

func (*DirectedGraph) NewEdge

func (g *DirectedGraph) NewEdge(from, to graph.Node) graph.Edge

NewEdge returns a new Edge from the source to the destination node.

func (*DirectedGraph) NewNode

func (g *DirectedGraph) NewNode() graph.Node

NewNode returns a new unique Node to be added to g. The Node's ID does not become valid in g until the Node is added to g.

func (*DirectedGraph) Node

func (g *DirectedGraph) Node(id int64) graph.Node

Node returns the node with the given ID if it exists in the graph, and nil otherwise.

func (*DirectedGraph) Nodes

func (g *DirectedGraph) Nodes() graph.Nodes

Nodes returns all the nodes in the graph.

The returned graph.Nodes is only valid until the next mutation of the receiver.

func (*DirectedGraph) RemoveEdge

func (g *DirectedGraph) RemoveEdge(fid, tid int64)

RemoveEdge removes the edge with the given end point IDs from the graph, leaving the terminal nodes. If the edge does not exist it is a no-op.

func (*DirectedGraph) RemoveNode

func (g *DirectedGraph) RemoveNode(id int64)

RemoveNode removes the node with the given ID from the graph, as well as any edges attached to it. If the node is not in the graph it is a no-op.

func (*DirectedGraph) SetEdge

func (g *DirectedGraph) SetEdge(e graph.Edge)

SetEdge adds e, an edge from one node to another. If the nodes do not exist, they are added and are set to the nodes of the edge otherwise. It will panic if the IDs of the e.From and e.To are equal.

func (*DirectedGraph) To

func (g *DirectedGraph) To(id int64) graph.Nodes

To returns all nodes in g that can reach directly to n.

The returned graph.Nodes is only valid until the next mutation of the receiver.

type DirectedMatrix

type DirectedMatrix struct {
	// contains filtered or unexported fields
}

DirectedMatrix represents a directed graph using an adjacency matrix such that all IDs are in a contiguous block from 0 to n-1. Edges are stored implicitly as an edge weight, so edges stored in the graph are not recoverable.

func NewDirectedMatrix

func NewDirectedMatrix(n int, init, self, absent float64) *DirectedMatrix

NewDirectedMatrix creates a directed dense graph with n nodes. All edges are initialized with the weight given by init. The self parameter specifies the cost of self connection, and absent specifies the weight returned for absent edges.

func NewDirectedMatrixFrom

func NewDirectedMatrixFrom(nodes []graph.Node, init, self, absent float64) *DirectedMatrix

NewDirectedMatrixFrom creates a directed dense graph with the given nodes. The IDs of the nodes must be contiguous from 0 to len(nodes)-1, but may be in any order. If IDs are not contiguous NewDirectedMatrixFrom will panic. All edges are initialized with the weight given by init. The self parameter specifies the cost of self connection, and absent specifies the weight returned for absent edges.

func (*DirectedMatrix) Edge

func (g *DirectedMatrix) Edge(uid, vid int64) graph.Edge

Edge returns the edge from u to v if such an edge exists and nil otherwise. The node v must be directly reachable from u as defined by the From method.

func (*DirectedMatrix) Edges

func (g *DirectedMatrix) Edges() graph.Edges

Edges returns all the edges in the graph.

func (*DirectedMatrix) From

func (g *DirectedMatrix) From(id int64) graph.Nodes

From returns all nodes in g that can be reached directly from n.

func (*DirectedMatrix) HasEdgeBetween

func (g *DirectedMatrix) HasEdgeBetween(xid, yid int64) bool

HasEdgeBetween returns whether an edge exists between nodes x and y without considering direction.

func (*DirectedMatrix) HasEdgeFromTo

func (g *DirectedMatrix) HasEdgeFromTo(uid, vid int64) bool

HasEdgeFromTo returns whether an edge exists in the graph from u to v.

func (*DirectedMatrix) Matrix

func (g *DirectedMatrix) Matrix() mat.Matrix

Matrix returns the mat.Matrix representation of the graph. The orientation of the matrix is such that the matrix entry at G_{ij} is the weight of the edge from node i to node j.

func (*DirectedMatrix) Node

func (g *DirectedMatrix) Node(id int64) graph.Node

Node returns the node with the given ID if it exists in the graph, and nil otherwise.

func (*DirectedMatrix) Nodes

func (g *DirectedMatrix) Nodes() graph.Nodes

Nodes returns all the nodes in the graph.

func (*DirectedMatrix) RemoveEdge

func (g *DirectedMatrix) RemoveEdge(fid, tid int64)

RemoveEdge removes the edge with the given end point nodes from the graph, leaving the terminal nodes. If the edge does not exist it is a no-op.

func (*DirectedMatrix) SetEdge

func (g *DirectedMatrix) SetEdge(e graph.Edge)

SetEdge sets e, an edge from one node to another with unit weight. If the ends of the edge are not in g or the edge is a self loop, SetEdge panics. SetEdge will store the nodes of e in the graph if it was initialized with NewDirectedMatrixFrom.

func (*DirectedMatrix) SetWeightedEdge

func (g *DirectedMatrix) SetWeightedEdge(e graph.WeightedEdge)

SetWeightedEdge sets e, an edge from one node to another. If the ends of the edge are not in g or the edge is a self loop, SetWeightedEdge panics. SetWeightedEdge will store the nodes of e in the graph if it was initialized with NewDirectedMatrixFrom.

func (*DirectedMatrix) To

func (g *DirectedMatrix) To(id int64) graph.Nodes

To returns all nodes in g that can reach directly to n.

func (*DirectedMatrix) Weight

func (g *DirectedMatrix) Weight(xid, yid int64) (w float64, ok bool)

Weight returns the weight for the edge between x and y if Edge(x, y) returns a non-nil Edge. If x and y are the same node or there is no joining edge between the two nodes the weight value returned is either the graph's absent or self value. Weight returns true if an edge exists between x and y or if x and y have the same ID, false otherwise.

func (*DirectedMatrix) WeightedEdge

func (g *DirectedMatrix) WeightedEdge(uid, vid int64) graph.WeightedEdge

WeightedEdge returns the weighted edge from u to v if such an edge exists and nil otherwise. The node v must be directly reachable from u as defined by the From method.

func (*DirectedMatrix) WeightedEdges

func (g *DirectedMatrix) WeightedEdges() graph.WeightedEdges

WeightedEdges returns all the edges in the graph.

type Edge

type Edge struct {
	F, T graph.Node
}

Edge is a simple graph edge.

func (Edge) From

func (e Edge) From() graph.Node

From returns the from-node of the edge.

func (Edge) ReversedEdge

func (e Edge) ReversedEdge() graph.Edge

ReversedLine returns a new Edge with the F and T fields swapped.

func (Edge) To

func (e Edge) To() graph.Node

To returns the to-node of the edge.

type Node

type Node int64

Node is a simple graph node.

func (Node) ID

func (n Node) ID() int64

ID returns the ID number of the node.

type UndirectedGraph

type UndirectedGraph struct {
	// contains filtered or unexported fields
}

UndirectedGraph implements a generalized undirected graph.

func NewUndirectedGraph

func NewUndirectedGraph() *UndirectedGraph

NewUndirectedGraph returns an UndirectedGraph.

func (*UndirectedGraph) AddNode

func (g *UndirectedGraph) AddNode(n graph.Node)

AddNode adds n to the graph. It panics if the added node ID matches an existing node ID.

func (*UndirectedGraph) Edge

func (g *UndirectedGraph) Edge(uid, vid int64) graph.Edge

Edge returns the edge from u to v if such an edge exists and nil otherwise. The node v must be directly reachable from u as defined by the From method.

func (*UndirectedGraph) EdgeBetween

func (g *UndirectedGraph) EdgeBetween(xid, yid int64) graph.Edge

EdgeBetween returns the edge between nodes x and y.

func (*UndirectedGraph) Edges

func (g *UndirectedGraph) Edges() graph.Edges

Edges returns all the edges in the graph.

func (*UndirectedGraph) From

func (g *UndirectedGraph) From(id int64) graph.Nodes

From returns all nodes in g that can be reached directly from n.

The returned graph.Nodes is only valid until the next mutation of the receiver.

func (*UndirectedGraph) HasEdgeBetween

func (g *UndirectedGraph) HasEdgeBetween(xid, yid int64) bool

HasEdgeBetween returns whether an edge exists between nodes x and y.

func (*UndirectedGraph) NewEdge

func (g *UndirectedGraph) NewEdge(from, to graph.Node) graph.Edge

NewEdge returns a new Edge from the source to the destination node.

func (*UndirectedGraph) NewNode

func (g *UndirectedGraph) NewNode() graph.Node

NewNode returns a new unique Node to be added to g. The Node's ID does not become valid in g until the Node is added to g.

func (*UndirectedGraph) Node

func (g *UndirectedGraph) Node(id int64) graph.Node

Node returns the node with the given ID if it exists in the graph, and nil otherwise.

func (*UndirectedGraph) Nodes

func (g *UndirectedGraph) Nodes() graph.Nodes

Nodes returns all the nodes in the graph.

The returned graph.Nodes is only valid until the next mutation of the receiver.

func (*UndirectedGraph) RemoveEdge

func (g *UndirectedGraph) RemoveEdge(fid, tid int64)

RemoveEdge removes the edge with the given end IDs from the graph, leaving the terminal nodes. If the edge does not exist it is a no-op.

func (*UndirectedGraph) RemoveNode

func (g *UndirectedGraph) RemoveNode(id int64)

RemoveNode removes the node with the given ID from the graph, as well as any edges attached to it. If the node is not in the graph it is a no-op.

func (*UndirectedGraph) SetEdge

func (g *UndirectedGraph) SetEdge(e graph.Edge)

SetEdge adds e, an edge from one node to another. If the nodes do not exist, they are added and are set to the nodes of the edge otherwise. It will panic if the IDs of the e.From and e.To are equal.

type UndirectedMatrix

type UndirectedMatrix struct {
	// contains filtered or unexported fields
}

UndirectedMatrix represents an undirected graph using an adjacency matrix such that all IDs are in a contiguous block from 0 to n-1. Edges are stored implicitly as an edge weight, so edges stored in the graph are not recoverable.

func NewUndirectedMatrix

func NewUndirectedMatrix(n int, init, self, absent float64) *UndirectedMatrix

NewUndirectedMatrix creates an undirected dense graph with n nodes. All edges are initialized with the weight given by init. The self parameter specifies the cost of self connection, and absent specifies the weight returned for absent edges.

func NewUndirectedMatrixFrom

func NewUndirectedMatrixFrom(nodes []graph.Node, init, self, absent float64) *UndirectedMatrix

NewUndirectedMatrixFrom creates an undirected dense graph with the given nodes. The IDs of the nodes must be contiguous from 0 to len(nodes)-1, but may be in any order. If IDs are not contiguous NewUndirectedMatrixFrom will panic. All edges are initialized with the weight given by init. The self parameter specifies the cost of self connection, and absent specifies the weight returned for absent edges.

func (*UndirectedMatrix) Edge

func (g *UndirectedMatrix) Edge(uid, vid int64) graph.Edge

Edge returns the edge from u to v if such an edge exists and nil otherwise. The node v must be directly reachable from u as defined by the From method.

func (*UndirectedMatrix) EdgeBetween

func (g *UndirectedMatrix) EdgeBetween(uid, vid int64) graph.Edge

EdgeBetween returns the edge between nodes x and y.

func (*UndirectedMatrix) Edges

func (g *UndirectedMatrix) Edges() graph.Edges

Edges returns all the edges in the graph.

func (*UndirectedMatrix) From

func (g *UndirectedMatrix) From(id int64) graph.Nodes

From returns all nodes in g that can be reached directly from n.

func (*UndirectedMatrix) HasEdgeBetween

func (g *UndirectedMatrix) HasEdgeBetween(uid, vid int64) bool

HasEdgeBetween returns whether an edge exists between nodes x and y.

func (*UndirectedMatrix) Matrix

func (g *UndirectedMatrix) Matrix() mat.Matrix

Matrix returns the mat.Matrix representation of the graph.

func (*UndirectedMatrix) Node

func (g *UndirectedMatrix) Node(id int64) graph.Node

Node returns the node with the given ID if it exists in the graph, and nil otherwise.

func (*UndirectedMatrix) Nodes

func (g *UndirectedMatrix) Nodes() graph.Nodes

Nodes returns all the nodes in the graph.

func (*UndirectedMatrix) RemoveEdge

func (g *UndirectedMatrix) RemoveEdge(fid, tid int64)

RemoveEdge removes the edge with the given end point IDs from the graph, leaving the terminal nodes. If the edge does not exist it is a no-op.

func (*UndirectedMatrix) SetEdge

func (g *UndirectedMatrix) SetEdge(e graph.Edge)

SetEdge sets e, an edge from one node to another with unit weight. If the ends of the edge are not in g or the edge is a self loop, SetEdge panics. SetEdge will store the nodes of e in the graph if it was initialized with NewUndirectedMatrixFrom.

func (*UndirectedMatrix) SetWeightedEdge

func (g *UndirectedMatrix) SetWeightedEdge(e graph.WeightedEdge)

SetWeightedEdge sets e, an edge from one node to another. If the ends of the edge are not in g or the edge is a self loop, SetWeightedEdge panics. SetWeightedEdge will store the nodes of e in the graph if it was initialized with NewUndirectedMatrixFrom.

func (*UndirectedMatrix) Weight

func (g *UndirectedMatrix) Weight(xid, yid int64) (w float64, ok bool)

Weight returns the weight for the edge between x and y if Edge(x, y) returns a non-nil Edge. If x and y are the same node or there is no joining edge between the two nodes the weight value returned is either the graph's absent or self value. Weight returns true if an edge exists between x and y or if x and y have the same ID, false otherwise.

func (*UndirectedMatrix) WeightedEdge

func (g *UndirectedMatrix) WeightedEdge(uid, vid int64) graph.WeightedEdge

WeightedEdge returns the weighted edge from u to v if such an edge exists and nil otherwise. The node v must be directly reachable from u as defined by the From method.

func (*UndirectedMatrix) WeightedEdgeBetween

func (g *UndirectedMatrix) WeightedEdgeBetween(uid, vid int64) graph.WeightedEdge

WeightedEdgeBetween returns the weighted edge between nodes x and y.

func (*UndirectedMatrix) WeightedEdges

func (g *UndirectedMatrix) WeightedEdges() graph.WeightedEdges

WeightedEdges returns all the edges in the graph.

type WeightedDirectedGraph

type WeightedDirectedGraph struct {
	// contains filtered or unexported fields
}

WeightedDirectedGraph implements a generalized weighted directed graph.

func NewWeightedDirectedGraph

func NewWeightedDirectedGraph(self, absent float64) *WeightedDirectedGraph

NewWeightedDirectedGraph returns a WeightedDirectedGraph with the specified self and absent edge weight values.

func (*WeightedDirectedGraph) AddNode

func (g *WeightedDirectedGraph) AddNode(n graph.Node)

AddNode adds n to the graph. It panics if the added node ID matches an existing node ID.

func (*WeightedDirectedGraph) Edge

func (g *WeightedDirectedGraph) Edge(uid, vid int64) graph.Edge

Edge returns the edge from u to v if such an edge exists and nil otherwise. The node v must be directly reachable from u as defined by the From method.

func (*WeightedDirectedGraph) Edges

func (g *WeightedDirectedGraph) Edges() graph.Edges

Edges returns all the edges in the graph.

func (*WeightedDirectedGraph) From

func (g *WeightedDirectedGraph) From(id int64) graph.Nodes

From returns all nodes in g that can be reached directly from n.

The returned graph.Nodes is only valid until the next mutation of the receiver.

func (*WeightedDirectedGraph) HasEdgeBetween

func (g *WeightedDirectedGraph) HasEdgeBetween(xid, yid int64) bool

HasEdgeBetween returns whether an edge exists between nodes x and y without considering direction.

func (*WeightedDirectedGraph) HasEdgeFromTo

func (g *WeightedDirectedGraph) HasEdgeFromTo(uid, vid int64) bool

HasEdgeFromTo returns whether an edge exists in the graph from u to v.

func (*WeightedDirectedGraph) NewNode

func (g *WeightedDirectedGraph) NewNode() graph.Node

NewNode returns a new unique Node to be added to g. The Node's ID does not become valid in g until the Node is added to g.

func (*WeightedDirectedGraph) NewWeightedEdge

func (g *WeightedDirectedGraph) NewWeightedEdge(from, to graph.Node, weight float64) graph.WeightedEdge

NewWeightedEdge returns a new weighted edge from the source to the destination node.

func (*WeightedDirectedGraph) Node

func (g *WeightedDirectedGraph) Node(id int64) graph.Node

Node returns the node with the given ID if it exists in the graph, and nil otherwise.

func (*WeightedDirectedGraph) Nodes

func (g *WeightedDirectedGraph) Nodes() graph.Nodes

Nodes returns all the nodes in the graph.

The returned graph.Nodes is only valid until the next mutation of the receiver.

func (*WeightedDirectedGraph) RemoveEdge

func (g *WeightedDirectedGraph) RemoveEdge(fid, tid int64)

RemoveEdge removes the edge with the given end point IDs from the graph, leaving the terminal nodes. If the edge does not exist it is a no-op.

func (*WeightedDirectedGraph) RemoveNode

func (g *WeightedDirectedGraph) RemoveNode(id int64)

RemoveNode removes the node with the given ID from the graph, as well as any edges attached to it. If the node is not in the graph it is a no-op.

func (*WeightedDirectedGraph) SetWeightedEdge

func (g *WeightedDirectedGraph) SetWeightedEdge(e graph.WeightedEdge)

SetWeightedEdge adds a weighted edge from one node to another. If the nodes do not exist, they are added and are set to the nodes of the edge otherwise. It will panic if the IDs of the e.From and e.To are equal.

func (*WeightedDirectedGraph) To

To returns all nodes in g that can reach directly to n.

The returned graph.Nodes is only valid until the next mutation of the receiver.

func (*WeightedDirectedGraph) Weight

func (g *WeightedDirectedGraph) Weight(xid, yid int64) (w float64, ok bool)

Weight returns the weight for the edge between x and y if Edge(x, y) returns a non-nil Edge. If x and y are the same node or there is no joining edge between the two nodes the weight value returned is either the graph's absent or self value. Weight returns true if an edge exists between x and y or if x and y have the same ID, false otherwise.

func (*WeightedDirectedGraph) WeightedEdge

func (g *WeightedDirectedGraph) WeightedEdge(uid, vid int64) graph.WeightedEdge

WeightedEdge returns the weighted edge from u to v if such an edge exists and nil otherwise. The node v must be directly reachable from u as defined by the From method.

func (*WeightedDirectedGraph) WeightedEdges

func (g *WeightedDirectedGraph) WeightedEdges() graph.WeightedEdges

WeightedEdges returns all the weighted edges in the graph.

type WeightedEdge

type WeightedEdge struct {
	F, T graph.Node
	W    float64
}

WeightedEdge is a simple weighted graph edge.

func (WeightedEdge) From

func (e WeightedEdge) From() graph.Node

From returns the from-node of the edge.

func (WeightedEdge) ReversedEdge

func (e WeightedEdge) ReversedEdge() graph.Edge

ReversedLine returns a new Edge with the F and T fields swapped. The weight of the new Edge is the same as the weight of the receiver.

func (WeightedEdge) To

func (e WeightedEdge) To() graph.Node

To returns the to-node of the edge.

func (WeightedEdge) Weight

func (e WeightedEdge) Weight() float64

Weight returns the weight of the edge.

type WeightedUndirectedGraph

type WeightedUndirectedGraph struct {
	// contains filtered or unexported fields
}

WeightedUndirectedGraph implements a generalized weighted undirected graph.

func NewWeightedUndirectedGraph

func NewWeightedUndirectedGraph(self, absent float64) *WeightedUndirectedGraph

NewWeightedUndirectedGraph returns an WeightedUndirectedGraph with the specified self and absent edge weight values.

func (*WeightedUndirectedGraph) AddNode

func (g *WeightedUndirectedGraph) AddNode(n graph.Node)

AddNode adds n to the graph. It panics if the added node ID matches an existing node ID.

func (*WeightedUndirectedGraph) Edge

func (g *WeightedUndirectedGraph) Edge(uid, vid int64) graph.Edge

Edge returns the edge from u to v if such an edge exists and nil otherwise. The node v must be directly reachable from u as defined by the From method.

func (*WeightedUndirectedGraph) EdgeBetween

func (g *WeightedUndirectedGraph) EdgeBetween(xid, yid int64) graph.Edge

EdgeBetween returns the edge between nodes x and y.

func (*WeightedUndirectedGraph) Edges

func (g *WeightedUndirectedGraph) Edges() graph.Edges

Edges returns all the edges in the graph.

func (*WeightedUndirectedGraph) From

From returns all nodes in g that can be reached directly from n.

func (*WeightedUndirectedGraph) HasEdgeBetween

func (g *WeightedUndirectedGraph) HasEdgeBetween(xid, yid int64) bool

HasEdgeBetween returns whether an edge exists between nodes x and y.

func (*WeightedUndirectedGraph) NewNode

func (g *WeightedUndirectedGraph) NewNode() graph.Node

NewNode returns a new unique Node to be added to g. The Node's ID does not become valid in g until the Node is added to g.

func (*WeightedUndirectedGraph) NewWeightedEdge

func (g *WeightedUndirectedGraph) NewWeightedEdge(from, to graph.Node, weight float64) graph.WeightedEdge

NewWeightedEdge returns a new weighted edge from the source to the destination node.

func (*WeightedUndirectedGraph) Node

Node returns the node with the given ID if it exists in the graph, and nil otherwise.

func (*WeightedUndirectedGraph) Nodes

func (g *WeightedUndirectedGraph) Nodes() graph.Nodes

Nodes returns all the nodes in the graph.

The returned graph.Nodes is only valid until the next mutation of the receiver.

func (*WeightedUndirectedGraph) RemoveEdge

func (g *WeightedUndirectedGraph) RemoveEdge(fid, tid int64)

RemoveEdge removes the edge with the given end point IDs from the graph, leaving the terminal nodes. If the edge does not exist it is a no-op.

func (*WeightedUndirectedGraph) RemoveNode

func (g *WeightedUndirectedGraph) RemoveNode(id int64)

RemoveNode removes the node with the given ID from the graph, as well as any edges attached to it. If the node is not in the graph it is a no-op.

func (*WeightedUndirectedGraph) SetWeightedEdge

func (g *WeightedUndirectedGraph) SetWeightedEdge(e graph.WeightedEdge)

SetWeightedEdge adds a weighted edge from one node to another. If the nodes do not exist, they are added and are set to the nodes of the edge otherwise. It will panic if the IDs of the e.From and e.To are equal.

func (*WeightedUndirectedGraph) Weight

func (g *WeightedUndirectedGraph) Weight(xid, yid int64) (w float64, ok bool)

Weight returns the weight for the edge between x and y if Edge(x, y) returns a non-nil Edge. If x and y are the same node or there is no joining edge between the two nodes the weight value returned is either the graph's absent or self value. Weight returns true if an edge exists between x and y or if x and y have the same ID, false otherwise.

func (*WeightedUndirectedGraph) WeightedEdge

func (g *WeightedUndirectedGraph) WeightedEdge(uid, vid int64) graph.WeightedEdge

WeightedEdge returns the weighted edge from u to v if such an edge exists and nil otherwise. The node v must be directly reachable from u as defined by the From method.

func (*WeightedUndirectedGraph) WeightedEdgeBetween

func (g *WeightedUndirectedGraph) WeightedEdgeBetween(xid, yid int64) graph.WeightedEdge

WeightedEdgeBetween returns the weighted edge between nodes x and y.

func (*WeightedUndirectedGraph) WeightedEdges

func (g *WeightedUndirectedGraph) WeightedEdges() graph.WeightedEdges

WeightedEdges returns all the weighted edges in the graph.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL