alchemist/it.unibo.alchemist.boundary.extractors

Package-level declarations

Types

abstract class AbstractAggregatingDoubleExporter(filter: ExportFilter = CommonFilters.NOFILTER.filteringPolicy, aggregatorNames: List<String>, val precision: Int? = null) : AbstractDoubleExporter

Aggregation of data extracted from the environment. The data is filtered and then aggregated using the provided aggregators. Provided a filter and a list of aggregatorNames and a precision, extracts data from the environment, filters it, and then aggregates it. Available aggregators can be found at this site.

AbstractDoubleExporter

abstract class AbstractDoubleExporter(val precision: Int? = null) : Extractor<Double>

Double-formatting utility. Provided a precision representing the significant digits, formats doubles accordingly, using Locale.ENGLISH. If null is provided, returns the default conversion to string.

ExecutionTime

class ExecutionTime(val precision: Int? = null) : AbstractDoubleExporter

An extractor which provides informations about the running time of the simulation. Optionally, a precision (significant digits) can be provided.

MeanSquaredError

class MeanSquaredError<T>(incarnation: Incarnation<T, *>, localCorrectValueMolecule: String, localCorrectValueProperty: String = "", statistics: String, localValueMolecule: String, localValueProperty: String = "", val precision: Int? = null) : AbstractDoubleExporter

Exports the Mean Squared Error for the concentration of some molecule, given another molecule that carries the correct result. The correct value is extracted from every node, then the provided {@link UnivariateStatistic} is applied to get a single, global correct value. Then, the actual value is extracted from every node, its value is compared (subtracted) to the computed correct value, it gets squared, and then logged.

MoleculeReader

class MoleculeReader(moleculeName: String, property: String?, incarnation: Incarnation<*, *>, filter: ExportFilter, aggregatorNames: List<String>, val precision: Int? = null) : AbstractAggregatingDoubleExporter

Reads the value of a molecule and logs it.

NetworkCentroid

class NetworkCentroid : Extractor<Double>

Exporter for the network centroid coordinates. The x and y coordinates are the average of the x and y coordinates of all the nodes in the network, note that negative coordinates are possible.

NetworkDensity

class NetworkDensity : Extractor<Double>

Extractor for the network density of the environment. The network density is the average number of nodes per unit area. The area is the rectangle given by the outermost nodes in the network.

NetworkDiameter

class NetworkDiameter : Extractor<Double>

Extractor for the networkDiameter by using the Euclidean distance within the simulation. The network is assumed to be unsegmented, otherwise use SubnetworksDiameter.

NetworkHopDiameter

class NetworkHopDiameter : Extractor<Double>

Extracts the diameter of the network by hop distance.

NodeDegree

class NodeDegree(filter: ExportFilter, aggregators: List<String>, val precision: Int = 2) : AbstractAggregatingDoubleExporter

Extract the degree of the nodes in the network. The degree of a node is the number of neighbors it has. The result can be aggregated by the given aggregators and filtered by the given filter.

NodesPositions

class NodesPositions<T, P : Position<P>>(environment: Environment<T, P>) : AbstractDoubleExporter

Exports the positions of all nodes in the environment. The output is a table where, for each node, there is a column per dimension.

NumberOfNodes

class NumberOfNodes : Extractor<Int>

Logs the number of nodes in the scenario.

SubnetworksDiameter

class SubnetworksDiameter(filter: ExportFilter, aggregators: List<String>, val precision: Int = 2) : AbstractAggregatingDoubleExporter

Extract the diameter of the subnetworks in the network, by using the Euclidean distance within the environment. The result can be aggregated by the given aggregators and filtered by the given filter.

Time

class Time(val precision: Int? = null) : AbstractDoubleExporter

Exports a column with the current time.