it.unibo.alchemist.model.deployments.Grid.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of alchemist-loading Show documentation
Alchemist Machinery to load from files
The newest version!
/*
 * Copyright (C) 2010-2022, Danilo Pianini and contributors
 * listed, for each module, in the respective subproject's build.gradle.kts file.
 *
 * This file is part of Alchemist, and is distributed under the terms of the
 * GNU General Public License, with a linking exception,
 * as described in the file LICENSE in the Alchemist distribution's top directory.
 */
package it.unibo.alchemist.model.deployments

import it.unibo.alchemist.model.Deployment
import it.unibo.alchemist.model.Environment
import it.unibo.alchemist.model.Position
import org.apache.commons.math3.random.RandomGenerator
import java.util.stream.Stream
import java.util.stream.StreamSupport
import kotlin.math.abs
import kotlin.math.ceil

/**
 * A (possibly randomized) grid of nodes.
 *
 * @param environment
 *            the {@link Environment}
 * @param randomGenerator
 *            the {@link RandomGenerator}
 * @param xStart
 *            the start x position
 * @param yStart
 *            the start y position
 * @param xEnd
 *            the end x position
 * @param yEnd
 *            the end y position
 * @param xStep
 *            how distant on the x axis (on average) nodes should be
 * @param yStep
 *            how distant on the y axis (on average) nodes should be
 * @param xRand
 *            how randomized should be positions along the x axis
 * @param yRand
 *            how randomized should be positions along the y axis
 * @param xShift
 *            how shifted should be positions between lines
 * @param yShift
 *            how shifted should be positions along columns
 */
open class Grid @JvmOverloads constructor(
    private val environment: Environment<*, *>,
    private val randomGenerator: RandomGenerator,
    private val xStart: Double,
    private val yStart: Double,
    private val xEnd: Double,
    private val yEnd: Double,
    private val xStep: Double,
    private val yStep: Double,
    private val xRand: Double = 0.0,
    private val yRand: Double = 0.0,
    private val xShift: Double = 0.0,
    private val yShift: Double = 0.0,
) : Deployment> {

    override fun stream(): Stream> {
        val positions = (0 until stepCount(yStart, yEnd, yStep)).map { yn ->
            val y = yStart + yStep * yn
            (0 until stepCount(xStart, xEnd, xStep)).map { xn ->
                val x = xStart + xStep * xn
                val dx = xRand * (randomGenerator.nextDouble() - 0.5) + yn * xShift % xStep
                val dy = yRand * (randomGenerator.nextDouble() - 0.5) + xn * yShift % yStep
                environment.makePosition(x + dx, y + dy)
            }
        }.flatten()
        return StreamSupport.stream(positions.spliterator(), false)
    }

    private fun stepCount(min: Double, max: Double, step: Double): Int =
        ceil(abs((max - min) / step)).toInt()
}