42.0.5

alchemist-implementationbase/it.unibo.alchemist.model.environments/AbstractEnvironment

AbstractEnvironment

abstract class AbstractEnvironment<T, P : Position<P>> : Environment<T, P> (source)

Very generic and basic implementation for an environment. Basically, only manages an internal set of nodes and their position.

Parameters

[it.unibo.alchemist.model.Position] type

Inheritors

Abstract2DEnvironment

Properties

abstract val dimensions: Int

globalReactions

open override val globalReactions: ListSet<GlobalReaction<T>>

override var incarnation: Incarnation<T, P>

open override val isTerminated: Boolean

open override val layers: ListSet<Layer<T, P>>

override var linkingRule: LinkingRule<T, P>

override val nodeCount: Int

open override val nodes: ListSet<Node<T>>

abstract val offset: DoubleArray

override var simulation: Simulation<T, P>

simulationOrNull

override var simulationOrNull: Simulation<T, P>?

abstract val size: DoubleArray

sizeInDistanceUnits

open override val sizeInDistanceUnits: DoubleArray

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.

Functions

addGlobalReaction

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

open override fun addLayer(molecule: Molecule, layer: Layer<T, P>)

open override fun addNode(node: Node<T>, position: P): Boolean

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

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

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

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.

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

getDistanceBetweenNodes

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

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

getNeighborhood

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

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

getNodesWithinRange

open override fun getNodesWithinRange(position: P, range: Double): ListSet<Node<T>>

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

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

isNetworkSegmented

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

Returns true the network is segmented, false otherwise.

open operator override fun iterator(): MutableIterator<Node<T>>

abstract fun makePosition(vararg coordinates: Number): P

abstract fun makePosition(coordinates: DoubleArray): P

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

moveNodeToPosition

abstract fun moveNodeToPosition(node: Node<T>, newPosition: P)

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.

fun <R> Iterable<R>.randomElement(randomGenerator: RandomGenerator): R

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

removeGlobalReaction

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

open override fun removeNode(node: Node<T>)

fun <R> Iterable<R>.shuffled(randomGenerator: RandomGenerator): Iterable<R>

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

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

open override fun toString(): String

Not used internally. Override as you please.