alchemist-euclidean-geometry/it.unibo.alchemist.model.environments/Euclidean2DEnvironment

Euclidean2DEnvironment

interface Euclidean2DEnvironment<T> : EuclideanEnvironment<T, Euclidean2DPosition> (source)

A bidimensional Euclidean space with any concentration type T.

Inheritors

Continuous2DEnvironment

Environment2DWithObstacles

Euclidean2DEnvironmentWithObstacles

Types

Companion

object Companion

Constant values and utility methods for Euclidean2DEnvironment.

Properties

currentPosition

open val Node<T>.currentPosition: Euclidean2DPosition

dimensions

abstract val dimensions: Int

incarnation

abstract val incarnation: Incarnation<T, Euclidean2DPosition>

isTerminated

abstract val isTerminated: Boolean

layers

abstract val layers: Map<Molecule, Layer<T, Euclidean2DPosition>>

neighborhood

open val Node<T>.neighborhood: Observable<Neighborhood<T>>

networkModel

abstract var networkModel: NetworkModel<T>

nodeCount

abstract val nodeCount: Observable<Int>

nodes

abstract val nodes: ObservableList<Node<T>>

offset

abstract val offset: DoubleArray

origin

open override val origin: Euclidean2DPosition

position

open val Node<T>.position: Observable<Euclidean2DPosition>

reactions

abstract val reactions: ObservableList<Reaction<T>>

simulation

abstract var simulation: Simulation<T, Euclidean2DPosition>

simulationOrNull

abstract val simulationOrNull: Simulation<T, Euclidean2DPosition>?

size

abstract val size: DoubleArray

sizeInDistanceUnits

abstract val sizeInDistanceUnits: DoubleArray

Functions

addLayer

abstract fun addLayer(molecule: Molecule, layer: Layer<T, Euclidean2DPosition>)

addNode

abstract fun addNode(node: Node<T>, position: Euclidean2DPosition): Boolean

addReaction

abstract fun addReaction(reaction: Reaction<T>)

addTerminator

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

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

contains

open operator fun contains(node: Node<T>): Boolean

currentPositionOf

open fun currentPositionOf(node: Node<T>): Euclidean2DPosition

distanceBetween

abstract fun distanceBetween(n1: Node<T>, n2: Node<T>): Double

distanceTo

open fun Node<T>.distanceTo(other: Node<T>): Double

farthestReachablePosition

open fun farthestReachablePosition(node: Node<T>, desired: Euclidean2DPosition): Euclidean2DPosition

layerFor

abstract fun layerFor(molecule: Molecule): Layer<T, Euclidean2DPosition>?

makePosition

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

open override fun makePosition(vararg coordinates: Number): Euclidean2DPosition

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

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

Creates a new Euclidean2DPosition.

open override fun makePosition(vararg coordinates: Double): Euclidean2DPosition

moveBy

open fun Node<T>.moveBy(displacement: Euclidean2DPosition)

moveNodeBy

open fun moveNodeBy(node: Node<T>, displacement: Euclidean2DPosition)

moveNodeTo

abstract fun moveNodeTo(node: Node<T>, position: Euclidean2DPosition)

moveTo

open fun Node<T>.moveTo(position: Euclidean2DPosition)

neighborhoodOf

abstract fun neighborhoodOf(node: Node<T>): Observable<Neighborhood<T>>

nodesAround

abstract fun nodesAround(position: Euclidean2DPosition, range: Double): List<Node<T>>

abstract fun nodesAround(node: Node<T>, range: Double): List<Node<T>>

nodesInRange

open fun Euclidean2DPosition.nodesInRange(range: Double): List<Node<T>>

open fun Node<T>.nodesInRange(range: Double): List<Node<T>>

nodeWithId

abstract fun nodeWithId(id: Int): Node<T>

observeLayerValue

abstract fun observeLayerValue(molecule: Molecule, node: Node<T>): Observable<T?>

observeNodesAround

abstract fun observeNodesAround(position: Euclidean2DPosition, range: Double): ObservableSet<Node<T>>

abstract fun observeNodesAround(node: Node<T>, range: Double): ObservableSet<Node<T>>

observeNodesInRange

open fun Euclidean2DPosition.observeNodesInRange(range: Double): ObservableSet<Node<T>>

open fun Node<T>.observeNodesInRange(range: Double): ObservableSet<Node<T>>

positionOf

abstract fun positionOf(node: Node<T>): Observable<Euclidean2DPosition>

remove

open fun Node<T>.remove()

open fun Reaction<T>.remove()

removeNode

abstract fun removeNode(node: Node<T>)

removeReaction

abstract fun removeReaction(reaction: Reaction<T>)

toPosition

open fun DoubleArray.toPosition(): Euclidean2DPosition