class TemporalGraph extends TemporalGraphBase[TemporalGraph, RaphtoryGraph] with ReducedGraphViewImplementation[TemporalGraph, MultilayerTemporalGraph]
A graph with an underlying timeline with a start time and, optionally, an end time.
It offers methods to modify this timeline.
There are also methods to create one or a sequence of temporal epochs over the timeline,
producing a DottedGraph. This can be further used to create a set of perspectives over the timeline of the graph to work with.
This class supports all the graph operations defined in GraphOperations
.
If any graph operation is invoked from this instance, it is applied over only the elements of the graph within
the timeline.
- Note
All the strings expressing intervals need to be in the format
"<number> <unit> [<number> <unit> [...]]"
, where numbers must be integers and units must be one of {'year', 'month', 'week', 'day', 'hour', 'min'/'minute', 'sec'/'second', 'milli'/'millisecond'} using the plural when the number is different than 1. Commas and the construction 'and' are omitted to allow natural text. For instance, the interval "1 month 1 week 3 days" can be rewritten as "1 month, 1 week, and 3 days"- See also
- Alphabetic
- By Inheritance
- TemporalGraph
- ReducedGraphViewImplementation
- GraphViewImplementation
- GraphView
- ConcreteReducedGraphPerspective
- ConcreteGraphPerspective
- ReducedGraphPerspective
- GraphPerspective
- TemporalGraphBase
- Graph
- GraphBase
- FixedGraph
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
- Private
Instance Constructors
Type Members
- type Graph = TemporalGraph
The actual type of this graph
The actual type of this graph
- Definition Classes
- ConcreteGraphPerspective → GraphPerspective
- type MultilayerGraph = MultilayerTemporalGraph
Return type for calling
multilayerView
on this graphReturn type for calling
multilayerView
on this graph- Definition Classes
- ConcreteGraphPerspective → GraphPerspective
- type ReducedGraph = TemporalGraph
Return type for calling
reducedView
on this graphReturn type for calling
reducedView
on this graph- Definition Classes
- ConcreteGraphPerspective → GraphPerspective
- type Vertex = ReducedVertex
The actual vertex type of this graph
The actual vertex type of this graph
- Definition Classes
- ConcreteGraphPerspective → GraphPerspective
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def addDynamicPath(name: String*): TemporalGraph
- Definition Classes
- GraphViewImplementation → GraphView
- def addEdge(updateTime: Long, srcId: Long, dstId: Long, posTypeArg: Type): Unit
Adds a new edge to the graph or updates an existing edge
Adds a new edge to the graph or updates an existing edge
- updateTime
timestamp for edge update
- srcId
ID of source vertex of the edge
- dstId
ID of destination vertex of the edge
- posTypeArg
specify a Type for the edge
- Definition Classes
- Graph
- def addEdge(updateTime: Long, srcId: Long, dstId: Long, properties: Properties = Properties(), edgeType: MaybeType = NoType, secondaryIndex: Long = index): Unit
Adds a new edge to the graph or updates an existing edge
Adds a new edge to the graph or updates an existing edge
- updateTime
timestamp for edge update
- srcId
ID of source vertex of the edge
- dstId
ID of destination vertex of the edge
- properties
edge properties for the update (see Properties for the available property types)
- edgeType
specify a Type for the edge
- secondaryIndex
Optionally specify a secondary index that is used to determine the order of updates with the same
updateTime
- Definition Classes
- Graph
- def addVertex(updateTime: Long, srcId: Long, properties: Properties = Properties(), vertexType: MaybeType = NoType, secondaryIndex: Long = index): Unit
Adds a new vertex to the graph or updates an existing vertex
Adds a new vertex to the graph or updates an existing vertex
- updateTime
timestamp for vertex update
- srcId
ID of vertex to add/update
- properties
Optionally specify vertex properties for the update (see Properties for the available property types)
- vertexType
Optionally specify a Type for the vertex
- secondaryIndex
Optionally specify a secondary index that is used to determine the order of updates with the same
updateTime
- Definition Classes
- Graph
- def addVertex(updateTime: Long, srcId: Long, posTypeArg: Type): Unit
Adds a new vertex to the graph or updates an existing vertex
Adds a new vertex to the graph or updates an existing vertex
- updateTime
timestamp for vertex update
- srcId
ID of vertex to add/update
- posTypeArg
specify a Type for the vertex
- Definition Classes
- Graph
- def aggregate(defaultMergeStrategy: PropertyMerge[_, _], mergeStrategyMap: Map[String, PropertyMerge[_, _]]): TemporalGraph
Reduce view and delete exploded vertices permanently
Reduce view and delete exploded vertices permanently
This function has the same effect as
reducedView
, except that the exploded vertices are deleted and no longer available for subsequent calls ofmultilayerView
.- defaultMergeStrategy
Merge strategy for state not included in
mergeStrategyMap
- mergeStrategyMap
Map from state key to merge strategy (used to override
defaultMergeStrategy
).
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def assignID(uniqueChars: String): Long
Convenience method for generating unique IDs based on vertex names
Convenience method for generating unique IDs based on vertex names
Use of this method is optional. A
GraphBuilder
is free to assign vertex IDs in different ways, provided that each vertex is assigned a unique ID of typeLong
.- uniqueChars
Vertex name
- Definition Classes
- Graph
- def at(time: String, timeFormat: String = "yyyy[-MM[-dd[ HH[:mm[:ss[.SSS]]]]]]"): DottedGraph[RaphtoryGraph]
Create a
DottedGraph
with a temporal epoch attime
.Create a
DottedGraph
with a temporal epoch attime
.- time
A timestamp in datetime format
- timeFormat
the format of time, defaulting to yyyy-MM-dd HH:mm:ss.SSS.
- Definition Classes
- TemporalGraphBase
- def at(time: Long): DottedGraph[RaphtoryGraph]
Create a
DottedGraph
with a temporal epoch attime
.Create a
DottedGraph
with a temporal epoch attime
.- time
the temporal epoch to be added to the timeline
- Definition Classes
- TemporalGraphBase
- def clearMessages(): TemporalGraph
Clear messages from previous operations.
Clear messages from previous operations. This function is predominantly used internally and shouldn't be called by the user unless they know what they are doing.
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def climb(end: String, increment: String, timeFormat: String = "yyyy[-MM[-dd[ HH[:mm[:ss[.SSS]]]]]]"): DottedGraph[RaphtoryGraph]
Create a DottedGraph with a sequence of temporal epochs with a separation of
increment
from the start of the timeline ending atend
.Create a DottedGraph with a sequence of temporal epochs with a separation of
increment
from the start of the timeline ending atend
.- end
the point to create the last epoch
- increment
the step size
- timeFormat
the format of end, defaulting to yyyy-MM-dd HH:mm:ss.SSS.
- Definition Classes
- TemporalGraphBase
- def climb(end: Long, increment: Long): DottedGraph[RaphtoryGraph]
Create a DottedGraph with a sequence of temporal epochs with a separation of
increment
from the start of the timeline ending atend
.Create a DottedGraph with a sequence of temporal epochs with a separation of
increment
from the start of the timeline ending atend
.- end
the point to create the last epoch
- increment
the step size
- Definition Classes
- TemporalGraphBase
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
- val conf: Config
- Attributes
- private[api]
- Definition Classes
- TemporalGraph → TemporalGraphBase
- def depart(start: String, increment: String, timeFormat: String = "yyyy[-MM[-dd[ HH[:mm[:ss[.SSS]]]]]]"): DottedGraph[RaphtoryGraph]
Create a DottedGraph with a sequence of temporal epochs with a separation of
increment
starting atstart
.Create a DottedGraph with a sequence of temporal epochs with a separation of
increment
starting atstart
. These epochs get generated until the end of the available timeline.- start
the timestamp to create the first epoch
- increment
the interval expressing the step size
- timeFormat
the format of start, defaulting to yyyy-MM-dd HH:mm:ss.SSS.
- Definition Classes
- TemporalGraphBase
- def depart(start: Long, increment: Long): DottedGraph[RaphtoryGraph]
Create a DottedGraph with a sequence of temporal epochs with a separation of
increment
starting atstart
.Create a DottedGraph with a sequence of temporal epochs with a separation of
increment
starting atstart
. These epochs get generated until the end of the available timeline.- start
the point to create the first epoch
- increment
the step size
- Definition Classes
- TemporalGraphBase
- def directedView: TemporalGraph
View the graph as a directed network (duplicated edges created by a previous call to
undirectedView
are removed and bi-directional edges un-merged)View the graph as a directed network (duplicated edges created by a previous call to
undirectedView
are removed and bi-directional edges un-merged)- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def edgeFilter(f: (Edge, GraphState) => Boolean, pruneNodes: Boolean): TemporalGraph
Filter edges of the graph with global graph state
Filter edges of the graph with global graph state
- f
filter function with access to graph state (only edges for which
f
returnstrue
are kept)- pruneNodes
if this is
true
then vertices which become isolated (have no incoming or outgoing edges) after this filtering are also removed.
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def edgeFilter(f: (Edge) => Boolean, pruneNodes: Boolean): TemporalGraph
Filter edges of the graph
Filter edges of the graph
- f
filter function (only edges for which
f
returnstrue
are kept)- pruneNodes
if this is
true
then vertices which become isolated (have no incoming or outgoing edges) after this filtering are also removed.
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def edgeStep(f: (Edge, GraphState) => Unit): TemporalGraph
Execute algorithm step with global graph state (has access to accumulated state from previous steps and allows for accumulation of new values)
Execute algorithm step with global graph state (has access to accumulated state from previous steps and allows for accumulation of new values)
- f
algorithm step (run on each edge)
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def edgeStep(f: (Edge) => Unit): TemporalGraph
Execute algorithm step
Execute algorithm step
- f
algorithm step (run on each edge)
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def execute(algorithm: GenericallyApplicable): Table
Run a GenericallyApplicable algorithm on the graph and return results
Run a GenericallyApplicable algorithm on the graph and return results
- algorithm
Algorithm to run
- returns
Table with algorithm results
- Definition Classes
- GraphViewImplementation → GraphView
- Note
execute
keeps track of the name of the applied algorithm
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def globalSelect(values: String*): Table
Returns a table with a single row from the global grah state and one column per key in
values
Returns a table with a single row from the global grah state and one column per key in
values
- values
the keys to be extracted from the graph state
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def handleGraphUpdate(update: GraphUpdate): Unit
- Attributes
- protected
- Definition Classes
- TemporalGraphBase → Graph
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def identity: Graph
Return the graph unchanged
Return the graph unchanged
This is used to obtain the correct return type without performing any operations
- Definition Classes
- ConcreteGraphPerspective → GraphPerspective
- def index: Long
- Definition Classes
- TemporalGraphBase → Graph
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def iterate(f: (ReducedVertex, GraphState) => Unit, iterations: Int, executeMessagedOnly: Boolean): TemporalGraph
Execute algorithm step with global graph state repeatedly for given number of iterations or until all vertices have voted to halt.
Execute algorithm step with global graph state repeatedly for given number of iterations or until all vertices have voted to halt.
- f
algorithm step (run once for each vertex per iteration)
- iterations
maximum number of iterations
- executeMessagedOnly
If
true
, only run step for vertices which received new messages
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def iterate(f: (ReducedVertex) => Unit, iterations: Int, executeMessagedOnly: Boolean): TemporalGraph
Execute algorithm step repeatedly for given number of iterations or until all vertices have voted to halt.
Execute algorithm step repeatedly for given number of iterations or until all vertices have voted to halt.
- f
algorithm step (run once for each vertex per iteration)Ï
- iterations
maximum number of iterations
- executeMessagedOnly
If
true
, only run step for vertices which received new messages
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def load(sources: Source*): TemporalGraph
- Definition Classes
- TemporalGraphBase
- def loadPythonScript(script: String): TemporalGraph
- Definition Classes
- GraphViewImplementation
- def multilayerView(interlayerEdgeBuilder: (visitor.Vertex) => Seq[InterlayerEdge]): MultilayerTemporalGraph
Switch to multilayer view and add interlayer edges.
Switch to multilayer view and add interlayer edges.
- interlayerEdgeBuilder
Interlayer edge builder to create interlayer edges for each vertex. See InterlayerEdgeBuilders for predefined options. Existing ExplodedVertex instances are preserved but all interlayer edges are recreated using the supplied
interlayerEdgeBuilder
.
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def multilayerView: MultilayerTemporalGraph
Switch to multilayer view
Switch to multilayer view
After calling
multilayerView
, subsequent methods that manipulate vertices act on ExplodedVertices instead. If ExplodedVertex instances were already created by a previous call tomultilayerView
, they are preserved. Otherwise, this method creates an ExplodedVertex instance for each time point that a vertex is active.- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def newFixedGraph(query: Query, querySender: QuerySender): RaphtoryGraph
- Attributes
- private[api]
- Definition Classes
- TemporalGraph → TemporalGraphBase
- def newGraph(query: Query, querySender: QuerySender): TemporalGraph
- Attributes
- private[api]
- Definition Classes
- ReducedGraphViewImplementation → FixedGraph
- def newMGraph(query: Query, querySender: QuerySender): MultilayerTemporalGraph
- Attributes
- private[api]
- Definition Classes
- TemporalGraphBase → GraphBase
- def newRGraph(query: Query, querySender: QuerySender): TemporalGraph
- Attributes
- private[api]
- Definition Classes
- TemporalGraphBase → GraphBase
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def parseDatetime(dateTime: String, format: String = "yyyy-MM-dd[ HH:mm:ss[.SSS]]"): Long
Convenience method for converting dates into epochs to be used internally by Raphtory.
Convenience method for converting dates into epochs to be used internally by Raphtory. This is the same function used by the
add vertex
andadd edge
functions, so can be called explicitly in a graph builder to reduce the number of conversions when performing multiple updates per tuple.- dateTime
The date string you wish to convert
- format
The format of the date string. The default being "yyyy-MM-dd[ HH:mm:ss[.SSS]]." .
- Definition Classes
- Graph
- val query: Query
- Attributes
- private[api]
- Definition Classes
- TemporalGraph → GraphViewImplementation → TemporalGraphBase → FixedGraph
- val querySender: QuerySender
- Attributes
- private[api]
- Definition Classes
- TemporalGraph → GraphViewImplementation → TemporalGraphBase → FixedGraph
- def range(start: String, end: String, increment: String, timeFormat: String = "yyyy[-MM[-dd[ HH[:mm[:ss[.SSS]]]]]]"): DottedGraph[RaphtoryGraph]
Create a DottedGraph with a sequence of temporal epochs with a separation of
increment
starting atstart
and ending atend
(with a smaller step at the end if necessary).Create a DottedGraph with a sequence of temporal epochs with a separation of
increment
starting atstart
and ending atend
(with a smaller step at the end if necessary).- start
the timestamp to create the first epoch
- end
the timestamp to create the first epoch
- increment
the interval expressing the step size
- timeFormat
the format of start and end, defaulting to yyyy-MM-dd HH:mm:ss.SSS.
- Definition Classes
- TemporalGraphBase
- def range(start: Long, end: Long, increment: Long): DottedGraph[RaphtoryGraph]
Create a DottedGraph with a sequence of temporal epochs with a separation of
increment
starting atstart
and ending atend
(with a smaller step at the end if necessary).Create a DottedGraph with a sequence of temporal epochs with a separation of
increment
starting atstart
and ending atend
(with a smaller step at the end if necessary).- start
the point to create the first epoch
- end
the point to create the last epoch
- increment
the step size
- Definition Classes
- TemporalGraphBase
- def reducedView(defaultMergeStrategy: PropertyMerge[_, _], mergeStrategyMap: Map[String, PropertyMerge[_, _]]): TemporalGraph
Reduce view and merge all exploded vertex state
Reduce view and merge all exploded vertex state
- defaultMergeStrategy
Merge strategy for state not included in
mergeStrategyMap
- mergeStrategyMap
Map from state key to merge strategy (used to override
defaultMergeStrategy
).
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def reducedView(mergeStrategy: PropertyMerge[_, _]): TemporalGraph
Reduce view and apply the same merge strategy to convert each exploded state to vertex state
Reduce view and apply the same merge strategy to convert each exploded state to vertex state
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def reducedView(mergeStrategyMap: Map[String, PropertyMerge[_, _]]): TemporalGraph
Reduce view and merge selected exploded state to vertex state
Reduce view and merge selected exploded state to vertex state
- mergeStrategyMap
Map from state key to merge strategy. Only state included in
mergeStrategyMap
will be reduced and made available on the Vertex.
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def reducedView: TemporalGraph
Switch computation to act on Vertex, inverse of
multilayerView
Switch computation to act on Vertex, inverse of
multilayerView
This operation does nothing if the view is already reduced. Otherwise it switches back to running computations on vertices but preserves any existing ExplodedVertex instances created by previous calls to
multilayerView
to allow switching back-and-forth between views while preserving computational state. Computational state on ExplodedVertex instances is not accessible from theVertex
unless a merge strategy is supplied (see below).- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def reversedView: TemporalGraph
Reverse the direction of each edge in the graph.
Reverse the direction of each edge in the graph.
Note that if the graph is currently viewed as undirected, this method has no immediate effect, however, edges will be reversed on a subsequent call to
directedView
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def select(values: String*): Table
Returns a table with one row per vertex and one column per key in
values
Returns a table with one row per vertex and one column per key in
values
If no values are provided, all of the values from the properties and the state are extracted.
- values
the keys to be extracted from every vertex state and properties
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def setGlobalState(f: (GraphState) => Unit): TemporalGraph
Add a function to manipulate global graph state, mainly used to initialise accumulators before the next algorithm step
Add a function to manipulate global graph state, mainly used to initialise accumulators before the next algorithm step
- f
function to set graph state (runs exactly once)
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def setOutputAsDatetime(): TemporalGraph
Creates a new
TemporalGraph
where the output timestamp for all queries will be in the default raphtory datetime format (yyyy-MM-dd HH:mm:ss.SSS).Creates a new
TemporalGraph
where the output timestamp for all queries will be in the default raphtory datetime format (yyyy-MM-dd HH:mm:ss.SSS).- Definition Classes
- TemporalGraphBase
- def setOutputAsEpoch(): TemporalGraph
Creates a new
TemporalGraph
where the output timestamp for all queries will be in epoch (long) format.Creates a new
TemporalGraph
where the output timestamp for all queries will be in epoch (long) format. This is the default mode when aTemporalGraph
is created.- Definition Classes
- TemporalGraphBase
- def slice(startTime: String, endTime: String, timeFormat: String = "yyyy[-MM[-dd[ HH[:mm[:ss[.SSS]]]]]]"): TemporalGraph
Creates a new
TemporalGraph
which includes all activity betweenstartTime
(inclusive) andendTime
(exclusive)graph.slice(startTime, endTime)
is equivalent tograph.from(startTime).until(endTime)
.Creates a new
TemporalGraph
which includes all activity betweenstartTime
(inclusive) andendTime
(exclusive)graph.slice(startTime, endTime)
is equivalent tograph.from(startTime).until(endTime)
.- startTime
A timestamp in datetime format
- endTime
A timestamp in datetime format
- timeFormat
the format of the start and end times, defaulting to yyyy-MM-dd HH:mm:ss.SSS.
- Definition Classes
- TemporalGraphBase
- def slice(startTime: Long, endTime: Long): TemporalGraph
Creates a new
TemporalGraph
which includes all activity betweenstartTime
(inclusive) andendTime
(exclusive)graph.slice(startTime, endTime)
is equivalent tograph.from(startTime).until(endTime)
Creates a new
TemporalGraph
which includes all activity betweenstartTime
(inclusive) andendTime
(exclusive)graph.slice(startTime, endTime)
is equivalent tograph.from(startTime).until(endTime)
- Definition Classes
- TemporalGraphBase
- def startingFrom(startTime: String, timeFormat: String = "yyyy[-MM[-dd[ HH[:mm[:ss[.SSS]]]]]]"): TemporalGraph
Creates a new
TemporalGraph
which includes all activity after startTime (inclusive).Creates a new
TemporalGraph
which includes all activity after startTime (inclusive).- startTime
A timestamp in datetime format
- timeFormat
the format of the start time, defaulting to yyyy-MM-dd HH:mm:ss.SSS
- Definition Classes
- TemporalGraphBase
- def startingFrom(startTime: Long): TemporalGraph
Creates a new
TemporalGraph
which includes all activity after startTime (inclusive).Creates a new
TemporalGraph
which includes all activity after startTime (inclusive).- startTime
time interpreted in milliseconds by default
- Definition Classes
- TemporalGraphBase
- def step(f: (ReducedVertex, GraphState) => Unit): TemporalGraph
Execute algorithm step with global graph state (has access to accumulated state from previous steps and allows for accumulation of new values)
Execute algorithm step with global graph state (has access to accumulated state from previous steps and allows for accumulation of new values)
- f
algorithm step (run once for each vertex)
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def step(f: (ReducedVertex) => Unit): TemporalGraph
Execute algorithm step
Execute algorithm step
- f
algorithm step (run once for each vertex)
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def to(endTime: String, timeFormat: String = "yyyy[-MM[-dd[ HH[:mm[:ss[.SSS]]]]]]"): TemporalGraph
Creates a new
TemporalGraph
which includes all activity before endTime (inclusive).Creates a new
TemporalGraph
which includes all activity before endTime (inclusive).- endTime
A timestamp in datetime format
- timeFormat
the format of the end time, defaulting to yyyy-MM-dd HH:mm:ss.SSS
- Definition Classes
- TemporalGraphBase
- def to(endTime: Long): TemporalGraph
Creates a new
TemporalGraph
which includes all activity before endTime (inclusive).Creates a new
TemporalGraph
which includes all activity before endTime (inclusive).- endTime
time interpreted in milliseconds by default
- Definition Classes
- TemporalGraphBase
- def toString(): String
- Definition Classes
- AnyRef → Any
- def totalPartitions: Int
- Definition Classes
- TemporalGraphBase
- def transform(algorithm: GenericReduction): TemporalGraph
Apply a GenericReduction algorithm to the graph
Apply a GenericReduction algorithm to the graph
- algorithm
Algorithm to apply to the graph
- returns
Transformed graph
- Definition Classes
- GraphViewImplementation → GraphView
- Note
transform
keeps track of the name of the applied algorithm and clears the message queues at the end of the algorithm
- def transform(algorithm: MultilayerProjection): MultilayerTemporalGraph
Apply a MultilayerProjection algorithm to the graph
Apply a MultilayerProjection algorithm to the graph
- algorithm
Algorithm to apply to the graph
- returns
Transformed graph
- Definition Classes
- GraphViewImplementation → GraphView
- Note
transform
keeps track of the name of the applied algorithm and clears the message queues at the end of the algorithm
- def transform(algorithm: Generic): TemporalGraph
Apply a Generic algorithm to the graph
- def undirectedView: TemporalGraph
View the graph as an undirected network (edges that exist only in one direction are duplicated and edges that exist in both directions are merged)
View the graph as an undirected network (edges that exist only in one direction are duplicated and edges that exist in both directions are merged)
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def until(endTime: String, timeFormat: String = "yyyy[-MM[-dd[ HH[:mm[:ss[.SSS]]]]]]"): TemporalGraph
Creates a new
TemporalGraph
which includes all activity before endTime (exclusive)Creates a new
TemporalGraph
which includes all activity before endTime (exclusive)- endTime
A timestamp in datetime format
- timeFormat
the format of the end time, defaulting to yyyy-MM-dd HH:mm:ss.SSS.
- Definition Classes
- TemporalGraphBase
- def until(endTime: Long): TemporalGraph
Creates a new
TemporalGraph
which includes all activity before endTime (exclusive).Creates a new
TemporalGraph
which includes all activity before endTime (exclusive).- endTime
time interpreted in milliseconds by default
- Definition Classes
- TemporalGraphBase
- def vertexFilter(f: (ReducedVertex, GraphState) => Boolean): TemporalGraph
Filter vertices of the graph with global graph state
Filter vertices of the graph with global graph state
- f
filter function with access to graph state (only vertices for which
f
returnstrue
are kept). All associated edges of filtered vertices are also removed.
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- def vertexFilter(f: (ReducedVertex) => Boolean): TemporalGraph
Filter vertices of the graph
Filter vertices of the graph
- f
filter function (only vertices for which
f
returnstrue
are kept). All associated edges of filtered vertices are also removed.
- Definition Classes
- GraphViewImplementation → ConcreteGraphPerspective → GraphPerspective
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- def walk(increment: String): DottedGraph[RaphtoryGraph]
Create a
DottedGraph
with a sequence of temporal epochs with a separation ofincrement
covering the whole timeline.Create a
DottedGraph
with a sequence of temporal epochs with a separation ofincrement
covering the whole timeline. These epochs get generated until the end of the current timeline.- increment
the interval to use as the step size
- Definition Classes
- TemporalGraphBase
- def walk(increment: Long): DottedGraph[RaphtoryGraph]
Create a
DottedGraph
with a sequence of temporal epochs with a separation ofincrement
covering all the timeline aligned with 0.Create a
DottedGraph
with a sequence of temporal epochs with a separation ofincrement
covering all the timeline aligned with 0.- increment
the step size
- Definition Classes
- TemporalGraphBase
- def withTransformedName(name: String): TemporalGraph
- Definition Classes
- GraphViewImplementation
- def withTransformedName(algorithm: BaseAlgorithm): TemporalGraph
- Attributes
- private[api]
- Definition Classes
- GraphViewImplementation
Deprecated Value Members
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable]) @Deprecated
- Deprecated