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.

addObstacle

open fun addObstacle(obstacle: RectObstacle2D<Euclidean2DPosition>)

Adds an obstacle to this environment.

addTerminator

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

Adds to the simulation a predicate that determines whether a simulation should be terminated.

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>>

farthestPositionReachable

abstract fun farthestPositionReachable(node: Node<T>, desiredPosition: P, hitboxRadius: Double): P

Computes the farthest position reachable by a node towards a desiredPosition, avoiding node overlapping. If no node is located in between, desiredPosition is returned. Otherwise, the first position where the node collides with someone else is returned. For collision purposes, hitboxes are used: each node is given a circular hitbox of radius equal to its shape's radius (shapeless nodes can't cause overlapping). The client can specify a different radius for the hitbox of the moving node.

open fun farthestPositionReachable(node: Node<T>, desiredPosition: Euclidean2DPosition, hitboxRadius: Double): Euclidean2DPosition

forEach

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

open fun forEach(p: Consumer<in T>)

getDimensions

abstract fun getDimensions(): Int

The number of dimensions of this environment.

fun getDimensions(): Int

The number of dimensions of this environment.

getDistanceBetweenNodes

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

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

getGlobalReactions

open fun getGlobalReactions(): NonExistentClass

Get the Environment's GlobalReactions.

getHeading

abstract fun getHeading(node: Node<T>): P

open fun getHeading(node: Node<T>): NonExistentClass

Gets the heading of a node as a direction vector.

getLayer

open fun getLayer(molecule: Molecule): Layer<T, P>

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

getLayers

open fun getLayers(): NonExistentClass

Return all the Layers in this Environment.

getNeighborhood

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

Given a node, this method returns its neighborhood.

getNodeByID

open 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).

getNodeCount

fun getNodeCount(): Int

Returns the number of Nodes currently in the Environment.

getNodesWithin

open fun getNodesWithin(shape: Shape<Euclidean2DPosition, Euclidean2DTransformation>): List<Node<T>>

Gets all nodes whose shape.intersect is true for the given shape.

getNodesWithinRange

open fun getNodesWithinRange(node: Node<T>, range: Double): NonExistentClass

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.

getObstacles

abstract fun getObstacles(): List<W>

open fun getObstacles(): List<RectObstacle2D<Euclidean2DPosition>>

A list of all the obstacles in this environment.

getObstaclesInRange

abstract fun getObstaclesInRange(center: Euclidean2DPosition, range: Double): List<W>

open fun getObstaclesInRange(center: Euclidean2DPosition, range: Double): List<RectObstacle2D<Euclidean2DPosition>>

Given a point and a range, retrieves all the obstacles within.

getOffset

abstract fun getOffset(): Array<Double>

This method allows to know which are the smallest coordinates represented. Return an array of length dimensions containing the smallest coordinates for each dimension.

fun getOffset(): Array<Double>

This method allows to know which are the smallest coordinates represented.

getOrigin

open fun getOrigin(): P

open fun getOrigin(): Euclidean2DPosition

Create a position corresponding to the origin of this environment.

getPosition

open fun getPosition(node: Node<T>): P

Calculates the position of a node.

getShape

abstract fun getShape(node: Node<T>): Shape<P, A>

open fun getShape(node: Node<T>): Shape<Euclidean2DPosition, Euclidean2DTransformation>

Gets the shape of a node relatively to its position and heading in the environment.

getShapeFactory

abstract fun getShapeFactory(): F

A factory of shapes compatible with this environment.

getSimulation

fun getSimulation(): Simulation<T, P>

Return the current Simulation, if present, or throws an IllegalStateException otherwise.

getSize

abstract fun getSize(): Array<Double>

The size of the environment as an array of length getDimensions(). This method must return distance measured with the same unit used by the positions. No non-euclidean distance metrics are allowed.

fun getSize(): Array<Double>

The size of the environment as an array of length getDimensions().

getSizeInDistanceUnits

open fun getSizeInDistanceUnits(): Array<Double>

Override this property if units measuring distance do not match with units used for coordinates. For instance, if your space is non-Euclidean, or if you are using polar coordinates. A notable example is using geographical latitude-longitude as y-x coordinates and meters as distance measure.

hasMobileObstacles

open fun hasMobileObstacles(): Boolean

intersectsObstacle

open fun intersectsObstacle(start: Euclidean2DPosition, end: Euclidean2DPosition): Boolean

Checks whether there is at least an obstacle intersecting the line connecting start and end.

isNetworkSegmented

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

Returns true the network is segmented, false otherwise.

isTerminated

open fun isTerminated(): Boolean

Return true if all the terminators are true.

iterator

open fun iterator(): Iterator<Node<T>>

abstract fun iterator(): Iterator<T>

makePosition

abstract fun makePosition(coordinates: Array<Number>): P

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

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

Creates a new Euclidean2DPosition.

open fun makePosition(coordinates: Array<Number>): NonExistentClass

Creates an euclidean position from the given coordinates.

moveNode

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

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 fun moveNodeToPosition(node: Node<T>, newPosition: P)

Subclasses may override this method if they want to change the way a node moves towards some absolute position.

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

Moves the node to the farthestPositionReachable towards the desired newPosition. If the node is shapeless, it is simply moved to newPosition.

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.

abstract fun next(current: P, desired: P): P

open fun next(current: Euclidean2DPosition, desired: Euclidean2DPosition): Euclidean2DPosition

This method must calculate the ABSOLUTE next allowed position given the current position and the position in which the node wants to move. For example, if your node is in position 2,3, wants to move to 3,4 but the next allowed position (because, e.g., of physical obstacles) is 2.5,3.5, the result must be a Position containing coordinates 2.5,3.5.

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 fun removeGlobalReaction(reaction: GlobalReaction<T>)

Remove a GlobalReaction from the Environment.

removeNode

open fun removeNode(node: Node<T>)

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

removeObstacle

open fun removeObstacle(obstacle: RectObstacle2D<Euclidean2DPosition>): Boolean

Removes an obstacle from this environment.

setHeading

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

Sets the heading of a node.

setSimulation

fun setSimulation(value: Simulation<T, P>)

Return the current Simulation, if present, or throws an IllegalStateException otherwise.

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

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

open fun spliterator(): Spliterator<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 fun toString(): String

Not used internally. Override as you please.