Minor stress test

4 files changed, 302 insertions, 0 deletions

diff --git a/core/src/main/java/coffee/liz/ecs/math/Mat2.java b/core/src/main/java/coffee/liz/ecs/math/Mat2.java
new file mode 100644
index 0000000..ed9493c
--- /dev/null
+++ b/core/src/main/java/coffee/liz/ecs/math/Mat2.java
@@ -0,0 +1,88 @@
+package coffee.liz.ecs.math;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public final class Mat2 {
+    private Mat2() {
+    }
+
+    /**
+     * Initializes a mutable 2d matrix of given type.
+     *
+     * @param dimensions
+     *            the dimensions
+     * @param constructor
+     *            the constructor
+     * @return row-indexed 2d matrix of {@param dimensions}
+     */
+    public static <T> List<List<T>> init(final Vec2<Integer> dimensions, final Function<Vec2<Integer>, T> constructor) {
+        final List<List<T>> rows = new ArrayList<>();
+        for (int y = 0; y < dimensions.getY(); y++) {
+            final List<T> row = new ArrayList<>(dimensions.getX());
+            for (int x = 0; x < dimensions.getX(); x++)
+                row.add(constructor.apply(Vec2i.builder().y(y).x(x).build()));
+            rows.add(row);
+        }
+        return rows;
+    }
+
+    /**
+     * Convolves a {@link Convolver} across a matrix reaching neighbors around the
+     * grid like a torus.
+     *
+     * @param mat
+     *            is the row-indexed 2d matrix to convolve.
+     * @param axes
+     *            are the x/y major/minor axes.
+     * @param init
+     *            is the initial value of the convolution.
+     * @param convolver
+     *            is the {@link Convolver}.
+     * @param finalReduction
+     *            to apply after {@param convolver}.
+     * @return result of {@param convolver} applied along axes at each cell.
+     * @param <T>
+     *            is the type of the matrix to convolve.
+     * @param <R>
+     *            is the type of the resulting type of each convolution.
+     */
+    public static <T, R, U> List<List<U>> convolveTorus(final List<List<T>> mat, final Vec2<Integer> axes,
+            final Supplier<R> init, final Convolver<T, R> convolver, final BiFunction<T, R, U> finalReduction) {
+        final List<List<R>> rows = new ArrayList<>();
+        for (int y = 0; y < mat.size(); y++) {
+            final List<R> row = new ArrayList<>(mat.get(y).size());
+            for (int x = 0; x < mat.get(y).size(); x++) {
+                final T center = mat.get(y).get(x);
+                R result = init.get();
+                for (int dy = -axes.getY(); dy <= axes.getY(); dy++) {
+                    final int ry = Math.floorMod(y + dy, mat.size());
+                    for (int dx = -axes.getX(); dx <= axes.getX(); dx++) {
+                        final int rx = Math.floorMod(x + dx, mat.get(ry).size());
+                        result = convolver.convolve(mat.get(ry).get(rx), Vec2i.builder().x(dx).y(dy).build(), result);
+                    }
+                }
+                row.add(result);
+            }
+            rows.add(row);
+        }
+
+        final List<List<U>> reductions = new ArrayList<>();
+        for (int y = 0; y < mat.size(); y++) {
+            final List<U> reduction = new ArrayList<>(mat.get(y).size());
+            for (int x = 0; x < mat.get(y).size(); x++) {
+                reduction.add(finalReduction.apply(mat.get(y).get(x), rows.get(y).get(x)));
+            }
+            reductions.add(reduction);
+        }
+        return reductions;
+    }
+
+    @FunctionalInterface
+    public interface Convolver<T, R> {
+        R convolve(final T center, final Vec2<Integer> rel, final R reduction);
+    }
+}
diff --git a/core/src/main/java/coffee/liz/ecs/math/Vec2.java b/core/src/main/java/coffee/liz/ecs/math/Vec2.java
new file mode 100644
index 0000000..dde6e51
--- /dev/null
+++ b/core/src/main/java/coffee/liz/ecs/math/Vec2.java
@@ -0,0 +1,88 @@
+package coffee.liz.ecs.math;
+
+import java.util.function.Function;
+
+/**
+ * Cartesian vectors.
+ *
+ * @param <T>
+ *            the numeric type of vector components
+ */
+public interface Vec2<T> {
+    /**
+     * @return the x coordinate
+     */
+    T getX();
+
+    /**
+     * @return the y coordinate
+     */
+    T getY();
+
+    /**
+     * Adds another vector to this vector.
+     *
+     * @param other
+     *            the vector to add
+     * @return a new vector with the result
+     */
+    Vec2<T> plus(final Vec2<T> other);
+
+    /**
+     * Subtracts another vector from this vector.
+     *
+     * @param other
+     *            the vector to subtract
+     * @return a new vector with the result
+     */
+    Vec2<T> minus(final Vec2<T> other);
+
+    /**
+     * Scales this vector by the given factors.
+     *
+     * @param scaleX
+     *            the x scale factor
+     * @param scaleY
+     *            the y scale factor
+     * @return a new scaled vector
+     */
+    Vec2<T> scale(final T scaleX, final T scaleY);
+
+    /**
+     * Scales this vector by the given vector.
+     *
+     * @param scale
+     *            scale vec.
+     * @return a new scaled vector
+     */
+    default Vec2<T> scale(final Vec2<T> scale) {
+        return scale(scale.getX(), scale.getY());
+    }
+
+    /**
+     * Length of the vector.
+     *
+     * @return length.
+     */
+    float length();
+
+    /**
+     * @return Vec2<Integer> components of {@link Vec2<T>}
+     */
+    Vec2<Integer> intValue();
+
+    /**
+     * @return Vec2<Float> components of {@link Vec2<T>}
+     */
+    Vec2<Float> floatValue();
+
+    /**
+     * @param xTransform
+     *            transform of x component.
+     * @param yTransform
+     *            transform of y component.
+     * @return transformed vec applying {@param xTransform} to x component,
+     *         {@param yTransform} to y component.
+     */
+    Vec2<T> transform(final Function<T, T> xTransform, final Function<T, T> yTransform);
+}
diff --git a/core/src/main/java/coffee/liz/ecs/math/Vec2f.java b/core/src/main/java/coffee/liz/ecs/math/Vec2f.java
new file mode 100644
index 0000000..42b73e7
--- /dev/null
+++ b/core/src/main/java/coffee/liz/ecs/math/Vec2f.java
@@ -0,0 +1,61 @@
+package coffee.liz.ecs.math;
+
+import static java.lang.Math.sqrt;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import java.util.function.Function;
+
+/** Float impl of {@link Vec2}. */
+@Getter
+@RequiredArgsConstructor
+@Data
+@Builder
+public final class Vec2f implements Vec2<Float> {
+    /** X coordinate. */
+    private final Float x;
+
+    /** Y coordinate. */
+    private final Float y;
+
+    @Override
+    public Vec2<Float> plus(final Vec2<Float> other) {
+        return new Vec2f(x + other.getX(), y + other.getY());
+    }
+
+    @Override
+    public Vec2<Float> minus(final Vec2<Float> other) {
+        return new Vec2f(x - other.getX(), y - other.getY());
+    }
+
+    @Override
+    public Vec2<Float> scale(final Float scaleX, final Float scaleY) {
+        return new Vec2f(x * scaleX, y * scaleY);
+    }
+
+    @Override
+    public float length() {
+        return (float) sqrt(x * x + y * y);
+    }
+
+    @Override
+    public Vec2<Float> floatValue() {
+        return this;
+    }
+
+    @Override
+    public Vec2<Float> transform(final Function<Float, Float> xTransform, final Function<Float, Float> yTransform) {
+        return new Vec2f(xTransform.apply(getX()), yTransform.apply(getY()));
+    }
+
+    @Override
+    public Vec2<Integer> intValue() {
+        return Vec2i.builder().x(this.x.intValue()).y(this.y.intValue()).build();
+    }
+
+    /** Zero float vec */
+    public static Vec2<Float> ZERO = Vec2f.builder().x(0f).y(0f).build();
+}
diff --git a/core/src/main/java/coffee/liz/ecs/math/Vec2i.java b/core/src/main/java/coffee/liz/ecs/math/Vec2i.java
new file mode 100644
index 0000000..326a5df
--- /dev/null
+++ b/core/src/main/java/coffee/liz/ecs/math/Vec2i.java
@@ -0,0 +1,65 @@
+package coffee.liz.ecs.math;
+
+import static java.lang.Math.sqrt;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import java.util.function.Function;
+
+/** Integer impl of {@link Vec2}. */
+@Getter
+@RequiredArgsConstructor
+@Builder
+@Data
+public final class Vec2i implements Vec2<Integer> {
+    /** X coordinate. */
+    private final Integer x;
+
+    /** Y coordinate. */
+    private final Integer y;
+
+    @Override
+    public Vec2<Integer> plus(final Vec2<Integer> other) {
+        return new Vec2i(x + other.getX(), y + other.getY());
+    }
+
+    @Override
+    public Vec2<Integer> minus(final Vec2<Integer> other) {
+        return new Vec2i(x - other.getX(), y - other.getY());
+    }
+
+    @Override
+    public Vec2<Integer> scale(final Integer scaleX, final Integer scaleY) {
+        return new Vec2i(x * scaleX, y * scaleY);
+    }
+
+    @Override
+    public Vec2<Float> floatValue() {
+        return Vec2f.builder().x(this.x.floatValue()).y(this.y.floatValue()).build();
+    }
+
+    @Override
+    public Vec2<Integer> transform(final Function<Integer, Integer> xTransform,
+            final Function<Integer, Integer> yTransform) {
+        return new Vec2i(xTransform.apply(getX()), yTransform.apply(getY()));
+    }
+
+    @Override
+    public Vec2<Integer> intValue() {
+        return this;
+    }
+
+    @Override
+    public float length() {
+        return (float) sqrt(x * x + y * y);
+    }
+
+    public static final Vec2<Integer> NORTH = new Vec2i(0, 1);
+    public static final Vec2<Integer> SOUTH = new Vec2i(0, -1);
+    public static final Vec2<Integer> EAST = new Vec2i(1, 0);
+    public static final Vec2<Integer> WEST = new Vec2i(-1, 0);
+    public static final Vec2<Integer> ZERO = new Vec2i(0, 0);
+}