trait EdgeOps[N, E[X] <: EdgeLikeIn[X], +This[X, Y[X] <: EdgeLikeIn[X]] <: GraphLike[X, Y[X], This] with Graph[X, Y[X]]] extends AnyRef
This trait contains mutating edge addition methods that don't require an outer edge.
These methods are kept separately from mutable.GraphLike
solely for convenience.
 Self Type
 GraphLike[N, E, This]
 Alphabetic
 By Inheritance
 EdgeOps
 AnyRef
 Any
 by any2stringadd
 by StringFormat
 by Ensuring
 by ArrowAssoc
 Hide All
 Show All
 Public
 All
Type Members
 trait InnerNodeOps extends AnyRef
Value Members

final
def
!=(arg0: Any): Boolean
 Definition Classes
 AnyRef → Any

final
def
##(): Int
 Definition Classes
 AnyRef → Any
 def +(other: String): String

final
def
+~%+=[EE[X] <: E[X] with EdgeLikeIn[X] with WLHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(weight: Double, label: L)(implicit edgeFactory: WLHyperEdgeCompanion[EE], endpointsKind: CollectionKind = Bag): EdgeOps.this.type
Same as
addWLEdge(node_1, node_2, nodes)(weight, label)
except for the returned result.Same as
addWLEdge(node_1, node_2, nodes)(weight, label)
except for the returned result. returns
This mutable graph containing the hyperedge that has been created or found. to be created
equals
to an already existing hyperedge.
 Annotations
 @inline()

final
def
+~%+=[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](node_1: N, node_2: N)(weight: Double, label: L)(implicit edgeFactory: WLEdgeCompanion[EE]): EdgeOps.this.type
Same as
addWLEdge(node_1, node_2)(weight, label)
except for the returned result.Same as
addWLEdge(node_1, node_2)(weight, label)
except for the returned result. returns
This mutable graph containing the edge that has been created or found.
 Annotations
 @inline()

final
def
+~%=[EE[X] <: E[X] with EdgeLikeIn[X] with WHyperEdgeBound[_, EE]](node_1: N, node_2: N, nodes: N*)(weight: Double)(implicit edgeFactory: WHyperEdgeCompanion[EE], endpointsKind: CollectionKind = Bag): EdgeOps.this.type
Same as
addWEdge(node_1, node_2, nodes)(weight)
except for the returned result.Same as
addWEdge(node_1, node_2, nodes)(weight)
except for the returned result. returns
This mutable graph containing the hyperedge that has been created or found. to be created
equals
to an already existing hyperedge.
 Annotations
 @inline()

final
def
+~%=[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](node_1: N, node_2: N)(weight: Double)(implicit edgeFactory: WEdgeCompanion[EE]): EdgeOps.this.type
Same as
addWEdge(node_1, node_2)(weight)
except for the returned result.Same as
addWEdge(node_1, node_2)(weight)
except for the returned result. returns
This mutable graph containing the edge that has been created or found.
 Annotations
 @inline()

final
def
+~+=[EE[X] <: E[X] with EdgeLikeIn[X] with LHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(label: L)(implicit edgeFactory: LHyperEdgeCompanion[EE]): EdgeOps.this.type
Same as
addLEdge(node_1, node_2, nodes)(label)
except for the returned result.Same as
addLEdge(node_1, node_2, nodes)(label)
except for the returned result. returns
This mutable graph containing the hyperedge that has been created or found. to be created
equals
to an already existing hyperedge.
 Annotations
 @inline()

final
def
+~+=[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](node_1: N, node_2: N)(label: L)(implicit edgeFactory: LEdgeCompanion[EE]): EdgeOps.this.type
Same as
addLEdge(node_1, node_2)(label)
except for the returned result.Same as
addLEdge(node_1, node_2)(label)
except for the returned result. returns
This mutable graph containing the edge that has been created or found.
 Annotations
 @inline()

final
def
+~=(node_1: N, node_2: N, nodes: N*)(implicit edgeFactory: HyperEdgeCompanion[E], endpointsKind: CollectionKind = Bag): EdgeOps.this.type
Same as
addEdge(node_1, node_2, nodes)
except for the returned result.Same as
addEdge(node_1, node_2, nodes)
except for the returned result. returns
This mutable graph containing the hyperedge that has been created or found. to be created
equals
to an already existing hyperedge.
 Annotations
 @inline()

final
def
+~=(node_1: N, node_2: N)(implicit edgeFactory: EdgeCompanion[E]): EdgeOps.this.type
Same as
addEdge(node_1, node_2)
except for the returned result.Same as
addEdge(node_1, node_2)
except for the returned result. returns
This mutable graph containing the edge that has been created or found.
 Annotations
 @inline()
 def >[B](y: B): (EdgeOps[N, E, This], B)

final
def
==(arg0: Any): Boolean
 Definition Classes
 AnyRef → Any

def
addAndGetEdge(node_1: N, node_2: N, nodes: N*)(implicit edgeFactory: HyperEdgeCompanion[E], endpointsKind: CollectionKind = Bag): GraphLike.EdgeT
Same as
addEdge(node_1, node_2, nodes)
except for the returned result.Same as
addEdge(node_1, node_2, nodes)
except for the returned result. returns
The new hyperedge or the corresponding contained hyperedge if the hyperedge to be created
equals
to an already existing hyperedge.

final
def
addAndGetEdge(node_1: N, node_2: N)(implicit edgeFactory: EdgeCompanion[E]): GraphLike.EdgeT
Same as
addEdge(node_1, node_2)
except for the returned result.Same as
addEdge(node_1, node_2)
except for the returned result. returns
The new edge or the corresponding contained edge if the edge to be created
equals
to an already existing edge.
 Annotations
 @inline()

def
addAndGetLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with LHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(label: L)(implicit edgeFactory: LHyperEdgeCompanion[EE]): GraphLike.EdgeT
Same as
addLEdge(node_1, node_2, nodes)(label)
except for the returned result.Same as
addLEdge(node_1, node_2, nodes)(label)
except for the returned result. returns
The new hyperedge or the corresponding contained hyperedge if the hyperedge to be created
equals
to an already existing hyperedge.

final
def
addAndGetLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](node_1: N, node_2: N)(label: L)(implicit edgeFactory: LEdgeCompanion[EE]): GraphLike.EdgeT
Same as
addLEdge(node_1, node_2)(label)
except for the returned result.Same as
addLEdge(node_1, node_2)(label)
except for the returned result. returns
The new edge or the corresponding contained edge if the edge to be created
equals
to an already existing edge.
 Annotations
 @inline()

def
addAndGetWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WHyperEdgeBound[_, EE]](node_1: N, node_2: N, nodes: N*)(weight: Double)(implicit edgeFactory: WHyperEdgeCompanion[EE], endpointsKind: CollectionKind = Bag): GraphLike.EdgeT
Same as
addWEdge(node_1, node_2, nodes)(weight)
except for the returned result.Same as
addWEdge(node_1, node_2, nodes)(weight)
except for the returned result. returns
The new hyperedge or the corresponding contained hyperedge if the hyperedge to be created
equals
to an already existing hyperedge.

final
def
addAndGetWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](node_1: N, node_2: N)(weight: Double)(implicit edgeFactory: WEdgeCompanion[EE]): GraphLike.EdgeT
Same as
addWEdge(node_1, node_2)(weight)
except for the returned result.Same as
addWEdge(node_1, node_2)(weight)
except for the returned result. returns
The new edge or the corresponding contained edge if the edge to be created
equals
to an already existing edge.
 Annotations
 @inline()

def
addAndGetWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(weight: Double, label: L)(implicit edgeFactory: WLHyperEdgeCompanion[EE], endpointsKind: CollectionKind = Bag): GraphLike.EdgeT
Same as
addWLEdge(node_1, node_2, nodes)(weight, label)
except for the returned result.Same as
addWLEdge(node_1, node_2, nodes)(weight, label)
except for the returned result. returns
The new hyperedge or the corresponding contained hyperedge if the hyperedge to be created
equals
to an already existing hyperedge.

final
def
addAndGetWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](node_1: N, node_2: N)(weight: Double, label: L)(implicit edgeFactory: WLEdgeCompanion[EE]): GraphLike.EdgeT
Same as
addWLEdge(node_1, node_2)(weight, label)
except for the returned result.Same as
addWLEdge(node_1, node_2)(weight, label)
except for the returned result. returns
The new edge or the corresponding contained edge if the edge to be created
equals
to an already existing edge.
 Annotations
 @inline()

final
def
addEdge(node_1: N, node_2: N, nodes: N*)(implicit edgeFactory: HyperEdgeCompanion[E], endpointsKind: CollectionKind = Bag): Boolean
Creates a new inner hyperedge between
node_1
,node_2
andnodes
usingedgeFactory
and adds it to the edge set of this graph.Creates a new inner hyperedge between
node_1
,node_2
andnodes
usingedgeFactory
and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set. node_1
The first outer node to be incident with the edge to be created. In case of a directed edge, this becomes the source.
 node_2
The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.
 nodes
The third and possibly more inner or outer nodes to be incident with the hyperedge to be created. In case of a directed edge, these become targets.
 edgeFactory
An edge companion who's
from
is to serve as the edge factory. returns
true
if a new hyperedge has been created.false
if no new hyperedge could be created because there exists a corresponding equaling hyperedge.
 Annotations
 @inline()

final
def
addEdge(node_1: N, node_2: N)(implicit edgeFactory: EdgeCompanion[E]): Boolean
Creates a new inner edge between
node_1
andnode_2
usingedgeFactory
and adds it to the edge set of this graph.Creates a new inner edge between
node_1
andnode_2
usingedgeFactory
and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set. node_1
The first outer node to be incident with the edge to be created. In case of a directed edge, this becomes the source.
 node_2
The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.
 edgeFactory
An edge companion who's
from
is to serve as the edge factory. returns
true
if a new edge has been created.false
if no new edge could be created because there exists a corresponding equaling edge.
 Annotations
 @inline()

final
def
addLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with LHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(label: L)(implicit edgeFactory: LHyperEdgeCompanion[EE]): Boolean
Creates a new weighted and labeled inner hyperedge between
node_1
,node_2
andnodes
usingedgeFactory
and adds it to the edge set of this graph.Creates a new weighted and labeled inner hyperedge between
node_1
,node_2
andnodes
usingedgeFactory
and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set. node_1
The first outer node to be incident with the edge to be created. In case of a directed edge, this becomes the source.
 node_2
The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.
 nodes
The third and possibly more inner or outer nodes to be incident with the hyperedge to be created. In case of a directed edge, these become targets.
 label
The value the labeled edge to be created should have as its label.
 edgeFactory
An edge companion who's
from
is to serve as the edge factory. returns
true
if a new hyperedge has been created.false
if no new hyperedge could be created because there exists a corresponding equaling hyperedge.
 Annotations
 @inline()

final
def
addLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](node_1: N, node_2: N)(label: L)(implicit edgeFactory: LEdgeCompanion[EE]): Boolean
Creates a new labeled inner edge between
node_1
andnode_2
usingedgeFactory
and adds it to the edge set of this graph.Creates a new labeled inner edge between
node_1
andnode_2
usingedgeFactory
and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set. node_1
The first outer node to be incident with the edge to be created. In case of a directed edge, this becomes the source.
 node_2
The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.
 label
The value the labeled edge to be created should have as its label.
 edgeFactory
An edge companion who's
from
is to serve as the edge factory. returns
true
if a new edge has been created.false
if no new edge could be created because there exists a corresponding equaling edge.
 Annotations
 @inline()

final
def
addWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WHyperEdgeBound[_, EE]](node_1: N, node_2: N, nodes: N*)(weight: Double)(implicit edgeFactory: WHyperEdgeCompanion[EE], endpointsKind: CollectionKind = Bag): Boolean
Creates a new weighted inner hyperedge between
node_1
,node_2
andnodes
usingedgeFactory
and adds it to the edge set of this graph.Creates a new weighted inner hyperedge between
node_1
,node_2
andnodes
usingedgeFactory
and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set. node_1
The first outer node to be incident with the edge to be created. In case of a directed edge, this becomes the source.
 node_2
The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.
 nodes
The third and possibly more inner or outer nodes to be incident with the hyperedge to be created. In case of a directed edge, these become targets.
 weight
The number the weighted edge to be created should have as its weight.
 edgeFactory
An edge companion who's
from
is to serve as the edge factory. returns
true
if a new hyperedge has been created.false
if no new hyperedge could be created because there exists a corresponding equaling hyperedge.
 Annotations
 @inline()

final
def
addWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](node_1: N, node_2: N)(weight: Double)(implicit edgeFactory: WEdgeCompanion[EE]): Boolean
Creates a new weighted inner edge between
node_1
andnode_2
usingedgeFactory
and adds it to the edge set of this graph.Creates a new weighted inner edge between
node_1
andnode_2
usingedgeFactory
and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set. node_1
The first outer node to be incident with the edge to be created. In case of a directed edge, this becomes the source.
 node_2
The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.
 weight
The number the weighted edge to be created should have as its weight.
 edgeFactory
An edge companion who's
from
is to serve as the edge factory. returns
true
if a new edge has been created.false
if no new edge could be created because there exists a corresponding equaling edge.
 Annotations
 @inline()

final
def
addWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLHyperEdgeBound[_, EE], L](node_1: N, node_2: N, nodes: N*)(weight: Double, label: L)(implicit edgeFactory: WLHyperEdgeCompanion[EE], endpointsKind: CollectionKind = Bag): Boolean
Creates a new weighted and labeled inner hyperedge between
node_1
,node_2
andnodes
usingedgeFactory
and adds it to the edge set of this graph.Creates a new weighted and labeled inner hyperedge between
node_1
,node_2
andnodes
usingedgeFactory
and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set. node_1
The first outer node to be incident with the edge to be created. In case of a directed edge, this becomes the source.
 node_2
The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.
 nodes
The third and possibly more inner or outer nodes to be incident with the hyperedge to be created. In case of a directed edge, these become targets.
 weight
The number the weighted edge to be created should have as its weight.
 label
The value the labeled edge to be created should have as its label.
 edgeFactory
An edge companion who's
from
is to serve as the edge factory. returns
true
if a new hyperedge has been created.false
if no new hyperedge could be created because there exists a corresponding equaling hyperedge.
 Annotations
 @inline()

final
def
addWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](node_1: N, node_2: N)(weight: Double, label: L)(implicit edgeFactory: WLEdgeCompanion[EE]): Boolean
Creates a new weighted and labeled inner edge between
node_1
andnode_2
usingedgeFactory
and adds it to the edge set of this graph.Creates a new weighted and labeled inner edge between
node_1
andnode_2
usingedgeFactory
and adds it to the edge set of this graph. Node arguments not yet contained in this graph will be added to the node set. node_1
The first outer node to be incident with the edge to be created. In case of a directed edge, this becomes the source.
 node_2
The second outer node to be incident with the edge to be created. In case of a directed edge, this becomes the target.
 weight
The number the weighted edge to be created should have as its weight.
 label
The value the labeled edge to be created should have as its label.
 edgeFactory
An edge companion who's
from
is to serve as the edge factory. returns
true
if a new edge has been created.false
if no new edge could be created because there exists a corresponding equaling edge.
 Annotations
 @inline()

final
def
asInstanceOf[T0]: T0
 Definition Classes
 Any

def
clone(): AnyRef
 Attributes
 protected[java.lang]
 Definition Classes
 AnyRef
 Annotations
 @throws( ... )
 def ensuring(cond: (EdgeOps[N, E, This]) ⇒ Boolean, msg: ⇒ Any): EdgeOps[N, E, This]
 def ensuring(cond: (EdgeOps[N, E, This]) ⇒ Boolean): EdgeOps[N, E, This]
 def ensuring(cond: Boolean, msg: ⇒ Any): EdgeOps[N, E, This]
 def ensuring(cond: Boolean): EdgeOps[N, E, This]

final
def
eq(arg0: AnyRef): Boolean
 Definition Classes
 AnyRef

def
equals(arg0: Any): Boolean
 Definition Classes
 AnyRef → Any

def
finalize(): Unit
 Attributes
 protected[java.lang]
 Definition Classes
 AnyRef
 Annotations
 @throws( classOf[java.lang.Throwable] )
 def formatted(fmtstr: String): String

final
def
getClass(): Class[_]
 Definition Classes
 AnyRef → Any

def
hashCode(): Int
 Definition Classes
 AnyRef → Any

final
def
isInstanceOf[T0]: Boolean
 Definition Classes
 Any

final
def
ne(arg0: AnyRef): Boolean
 Definition Classes
 AnyRef

def
nodesToCEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with CHyperEdgeBound[_, EE]](factory: CHyperEdgeCompanion[EE], attrib: Product, node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind): E[NodeT]
Creates a new custom inner hyperedge without modifying the node or edge set .
Creates a new custom inner hyperedge without modifying the node or edge set .
 Attributes
 protected[scalax.collection]

def
nodesToCEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with CEdgeBound[_, EE]](factory: CEdgeCompanion[EE], attrib: Product, node_1: N, node_2: N): E[NodeT]
Creates a new custom inner edge without modifying the node or edge set .
Creates a new custom inner edge without modifying the node or edge set .
 Attributes
 protected[scalax.collection]

final
def
nodesToEdge(edgeFactory: HyperEdgeCompanion[E], node_1: N, node_2: N, nodes: N*)(implicit endpointsKind: CollectionKind): GraphLike.EdgeT
 Attributes
 protected
 Annotations
 @inline()

final
def
nodesToEdge(edgeFactory: EdgeCompanion[E], node_1: N, node_2: N): GraphLike.EdgeT
 Attributes
 protected
 Annotations
 @inline()

def
nodesToEdgeCont(factory: EdgeCompanion[E], node_1: N, node_2: N): E[NodeT]
Creates a new simple inner edge without modifying the node or edge set .
Creates a new simple inner edge without modifying the node or edge set .
 Attributes
 protected[scalax.collection]

def
nodesToEdgeCont(factory: HyperEdgeCompanion[E], node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind): E[NodeT]
Creates a new simple inner hyperedge without modifying the node or edge set .
Creates a new simple inner hyperedge without modifying the node or edge set .
 Attributes
 protected[scalax.collection]

final
def
nodesToLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with LHyperEdgeBound[_, EE], L](edgeFactory: LHyperEdgeCompanion[EE], label: L, node_1: N, node_2: N, nodes: N*): GraphLike.EdgeT
 Attributes
 protected
 Annotations
 @inline()

final
def
nodesToLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](edgeFactory: LEdgeCompanion[EE], label: L, node_1: N, node_2: N): GraphLike.EdgeT
 Attributes
 protected
 Annotations
 @inline()

def
nodesToLEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with LEdgeBound[_, EE], L](factory: LEdgeCompanion[EE], label: L, node_1: N, node_2: N): E[NodeT]
Creates a new labeled inner edge without modifying the node or edge set .
Creates a new labeled inner edge without modifying the node or edge set .
 Attributes
 protected[scalax.collection]

def
nodesToLEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with LHyperEdgeBound[_, EE], L](factory: LHyperEdgeCompanion[EE], label: L, node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind = Bag): E[NodeT]
Creates a new labeled inner hyperedge without modifying the node or edge set .
Creates a new labeled inner hyperedge without modifying the node or edge set .
 Attributes
 protected[scalax.collection]

final
def
nodesToWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WHyperEdgeBound[_, EE]](edgeFactory: WHyperEdgeCompanion[EE], weight: Double, node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind): GraphLike.EdgeT
 Attributes
 protected
 Annotations
 @inline()

final
def
nodesToWEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](edgeFactory: WEdgeCompanion[EE], weight: Double, node_1: N, node_2: N): GraphLike.EdgeT
 Attributes
 protected
 Annotations
 @inline()

def
nodesToWEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with WEdgeBound[_, EE]](factory: WEdgeCompanion[EE], weight: Double, node_1: N, node_2: N): E[NodeT]
Creates a new weighted inner edge without modifying the node or edge set .
Creates a new weighted inner edge without modifying the node or edge set .
 Attributes
 protected[scalax.collection]

def
nodesToWEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with WHyperEdgeBound[_, EE]](factory: WHyperEdgeCompanion[EE], weight: Double, node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind): E[NodeT]
Creates a new weighted inner hyperedge without modifying the node or edge set .
Creates a new weighted inner hyperedge without modifying the node or edge set .
 Attributes
 protected[scalax.collection]

final
def
nodesToWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLHyperEdgeBound[_, EE], L](edgeFactory: WLHyperEdgeCompanion[EE], weight: Double, label: L, node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind): GraphLike.EdgeT
 Attributes
 protected
 Annotations
 @inline()

final
def
nodesToWLEdge[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](edgeFactory: WLEdgeCompanion[EE], weight: Double, label: L, node_1: N, node_2: N): GraphLike.EdgeT
 Attributes
 protected
 Annotations
 @inline()

def
nodesToWLEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with WLEdgeBound[_, EE], L](factory: WLEdgeCompanion[EE], weight: Double, label: L, node_1: N, node_2: N): E[NodeT]
Creates a new weighted and labeled inner edge without modifying the node or edge set .
Creates a new weighted and labeled inner edge without modifying the node or edge set .
 Attributes
 protected[scalax.collection]

def
nodesToWLEdgeCont[EE[X] <: E[X] with EdgeLikeIn[X] with WLHyperEdgeBound[_, EE], L](factory: WLHyperEdgeCompanion[EE], weight: Double, label: L, node_1: N, node_2: N, nodes: N*)(implicit kind: CollectionKind): E[NodeT]
Creates a new weighted and labeled inner hyperedge without modifying the node or edge set .
Creates a new weighted and labeled inner hyperedge without modifying the node or edge set .
 Attributes
 protected[scalax.collection]

final
def
notify(): Unit
 Definition Classes
 AnyRef

final
def
notifyAll(): Unit
 Definition Classes
 AnyRef

final
def
synchronized[T0](arg0: ⇒ T0): T0
 Definition Classes
 AnyRef

def
toString(): String
 Definition Classes
 AnyRef → Any

final
def
wait(): Unit
 Definition Classes
 AnyRef
 Annotations
 @throws( ... )

final
def
wait(arg0: Long, arg1: Int): Unit
 Definition Classes
 AnyRef
 Annotations
 @throws( ... )

final
def
wait(arg0: Long): Unit
 Definition Classes
 AnyRef
 Annotations
 @throws( ... )
 def →[B](y: B): (EdgeOps[N, E, This], B)
Welcome to the Graph for Scala API reference. Some suggested navigation entry points:
Graph
mutable.Graph
and its inner nodes.GraphEdge
objectedge
packageGraphPredef
object andImplicits
object.GraphTraversal
andTraverserInnerNode
.RandomGraph
.GraphGen
.