Adds a new node to this environment in a specific position. The environment is responsible for calling the right method of the simulation to ensure that the reaction is properly scheduled. The function returns true if the node is added to the environment.

addTerminator

open fun addTerminator(terminator: (Environment<T, Euclidean2DPosition>) -> Boolean)

Add a terminator indicating whether the simulation should be considered finished.

open override fun addTerminator(terminator: TerminationPredicate<T, Euclidean2DPosition>)

Add a terminator indicating whether the simulation should be considered finished.

allShortestHopPaths

fun <T> Environment<T, *>.allShortestHopPaths(): Map<Environments.UndirectedEdge<T>, Double>

Calculates the shortest paths using the Floyd-Warshall algorithm calculating the Hop Distance between nodes.

allShortestPaths

fun <T> Environment<T, *>.allShortestPaths(computeDistance: (Node<T>, Node<T>) -> Double = neighborDistanceMetric { n1, n2 -> getDistanceBetweenNodes(n1, n2) }): Map<Environments.UndirectedEdge<T>, Double>

Computes all the minimum distances with the provided metric using the Floyd–Warshall algorithm.

allSubNetworks

fun <T> Environment<T, *>.allSubNetworks(computeDistance: (Node<T>, Node<T>) -> Double = environmentMetricDistance()): Set<Network<T>>

Computes the diameter of all subnetworks in the environment. The diameter is the longest shortest path between any two nodes. Returns a Set containing the SubNetworks.

allSubNetworksByNode

fun <T> Environment<T, *>.allSubNetworksByNode(computeDistance: (Node<T>, Node<T>) -> Double = environmentMetricDistance()): Map<Node<T>, Network<T>>

Computes the diameter of all subnetworks in the environment. The diameter is the longest shortest path between any two nodes. Returns a Set containing the SubNetworks.

allSubNetworksByNodeWithHopDistance

fun <T> Environment<T, *>.allSubNetworksByNodeWithHopDistance(): Map<Node<T>, Network<T>>

Computes the diameter of all subnetworks in the environment. The diameter is the longest shortest path between any two nodes, evaluated using the allShortestHopPaths method. Returns a Set containing the SubNetworks.

allSubNetworksWithHopDistance

fun <T> Environment<T, *>.allSubNetworksWithHopDistance(): Set<Network<T>>

forEach

override fun forEach(action: Consumer<in Node<T>>)

getDistanceBetweenNodes

override fun getDistanceBetweenNodes(n1: Node<T>, n2: Node<T>): Double

Measures the distance between two nodes (n1, n2) in the environment.

getLayer

override fun getLayer(molecule: Molecule): Layer<T, Euclidean2DPosition>?

Get the Layer associate to the given molecule. If no Layer is associated with the given molecule, return null.

getNeighborhood

override fun getNeighborhood(node: Node<T>): Neighborhood<T>

Given a node, this method returns its neighborhood.

getNodeByID

override fun getNodeByID(id: Int): Node<T>

Allows accessing a Node in this Environment known its id. Depending on the implementation, this method may or may not be optimized (namely, id could run in constant or linear time with the number of nodes).

getNodesWithinRange

override fun getNodesWithinRange(node: Node<T>, range: Double): ListSet

Given a node this method returns a list of all the surrounding nodes within the given range. Note that this method (depending on the implementation) might be not optimized, and it's consequently much better to use Environment.getNeighborhood and filter the neighborhood if you are sure that all the nodes within the range are connected to the center.

override fun getNodesWithinRange(position: Euclidean2DPosition, range: Double): ListSet

Given a position this method returns a list of all the surrounding nodes within the given range. Note that this method (depending on the implementation) might be not optimized.

getPosition

override fun getPosition(node: Node<T>): Euclidean2DPosition

Calculates the position of a node.

isNetworkSegmented

fun <T> Environment<T, *>.isNetworkSegmented(): Boolean

Returns true the network is segmented, false otherwise.

iterator

operator override fun iterator(): Iterator<Node<T>>

makePosition

abstract fun makePosition(vararg coordinates: Number): Euclidean2DPosition

abstract fun makePosition(coordinates: DoubleArray): Euclidean2DPosition

open fun makePosition(coordinates: List<Number>): Euclidean2DPosition

Given the coordinates of the point, returns a Position compatible with this environment.

open fun makePosition(x: Double, y: Double): Euclidean2DPosition

open fun makePosition(x: Number, y: Number): Euclidean2DPosition

Creates a new Euclidean2DPosition.

moveNode

open fun moveNode(node: Node<T>, direction: Euclidean2DPosition)

This method moves a node in the environment toward some direction. If node move is unsupported, it does nothing. Subclasses may override this method if they want to change the way a node moves towards some direction. The current implementation internally calls {@link #moveNodeToPosition(Node, Position2D)}, as such, overriding that method may suffice.

moveNodeToPosition

open override fun moveNodeToPosition(node: Node<T>, position: Euclidean2DPosition)

This method moves a node in the environment to some position. If node movement is unsupported, it does nothing.

networkDiameter

fun Environment<*, *>.networkDiameter(): Double

Returns the diameter of the network in environment units if it is not segmented, and NaN otherwise.

networkDiameterByHopDistance

fun Environment<*, *>.networkDiameterByHopDistance(): Double

Returns the hop-distance diameter of the network if it is not segmented, and NaN otherwise.

fun <T> Environment<T, *>.networkDiameterByHopDistance(node: Node<T>): Double

Computes the network diameter of the segment containing node.

randomElement

fun <R> Iterable<R>.randomElement(randomGenerator: <Error class: unknown class>): R

Returns a random element of the Iterable using the provided randomGenerator.

removeGlobalReaction

open override fun removeGlobalReaction(reaction: GlobalReaction<T>)

Remove a GlobalReaction from the Environment.

removeNode

override fun removeNode(node: Node<T>)

Removes node. If node removal is unsupported, it does nothing.

shuffled

fun <R> Iterable<R>.shuffled(randomGenerator: <Error class: unknown class>): Iterable<R>

Fisher–Yates shuffle algorithm using a RandomGenerator. More information on Wikipedia.

spliterator

override fun spliterator(): Spliterator<Node<T>>

subscriptionMonitor

fun <T, P : Position<out P>> Environment<T, P>.subscriptionMonitor(): EnvironmentSubscriptionMonitor<T, P>

Returns the EnvironmentSubscriptionMonitor of this Environment.

toEnvironmentSurrogate

fun <T, P : Position<out P>, TS : Any> Environment<T, P>.toEnvironmentSurrogate(toConcentrationSurrogate: (T) -> TS): EnvironmentSurrogate<TS, PositionSurrogate>

A function that maps an Environment to its surrogate class (EnvironmentSurrogate). Use the toSuitablePositionSurrogate strategy for PositionSurrogate mapping.

fun <T, P : Position<out P>, TS : Any, PS : PositionSurrogate> Environment<T, P>.toEnvironmentSurrogate(toConcentrationSurrogate: (T) -> TS, toPositionSurrogate: (P) -> PS): EnvironmentSurrogate<TS, PS>

A function that maps an Environment to its surrogate class (EnvironmentSurrogate).

toGraphQLEnvironmentSurrogate

fun <T, P : Position<out P>> Environment<T, P>.toGraphQLEnvironmentSurrogate(): EnvironmentSurrogate<T, P>

Converts an Environment to a EnvironmentSurrogate.

toString

open override fun toString(): String

Not used internally. Override as you please.