From a9c08fde34e133efff86d575fa3a56faa6ffb3fa Mon Sep 17 00:00:00 2001 From: Michiel Meeuwissen Date: Mon, 21 Oct 2024 01:09:45 +0200 Subject: [PATCH] DiHedral group --- mihxil-algebra/src/main/java/module-info.java | 1 + .../dihedral/DiHedralGroup.java | 38 +++- .../dihedral/DiHedralSymmetry.java | 72 +++++-- .../abstractalgebra/dihedral/Symmetry.java | 3 + .../math/abstractalgebra/dim2/Matrix2.java | 189 ++++++++++++++++++ .../abstractalgebra/dim2/Matrix2Group.java | 77 +++++++ .../math/abstractalgebra/dim2/Vector2.java | 165 +++++++++++++++ .../abstractalgebra/dim2/Vector2Space.java | 67 +++++++ .../dihedral/DiHedralGroupTest.java | 47 ++++- 9 files changed, 635 insertions(+), 24 deletions(-) create mode 100644 mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dim2/Matrix2.java create mode 100644 mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dim2/Matrix2Group.java create mode 100644 mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dim2/Vector2.java create mode 100644 mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dim2/Vector2Space.java diff --git a/mihxil-algebra/src/main/java/module-info.java b/mihxil-algebra/src/main/java/module-info.java index b3c05fae..16fc19e7 100644 --- a/mihxil-algebra/src/main/java/module-info.java +++ b/mihxil-algebra/src/main/java/module-info.java @@ -45,6 +45,7 @@ exports org.meeuw.math.abstractalgebra.linear; exports org.meeuw.math.abstractalgebra.klein; exports org.meeuw.math.abstractalgebra.dihedral; + exports org.meeuw.math.abstractalgebra.dim2; uses AlgebraicElementFormatProvider; diff --git a/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dihedral/DiHedralGroup.java b/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dihedral/DiHedralGroup.java index aa2418db..de80ad44 100644 --- a/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dihedral/DiHedralGroup.java +++ b/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dihedral/DiHedralGroup.java @@ -6,10 +6,11 @@ import java.util.stream.Stream; import org.meeuw.math.abstractalgebra.*; +import org.meeuw.math.text.TextUtils; -import static org.meeuw.math.abstractalgebra.dihedral.Symmetry.r; -import static org.meeuw.math.abstractalgebra.dihedral.Symmetry.s; - +/** + * @since 0.14 + */ public class DiHedralGroup implements Group, Streamable { public static Map CACHE = new ConcurrentHashMap<>(); @@ -22,9 +23,24 @@ public static DiHedralGroup of(int n) { return CACHE.computeIfAbsent(n, DiHedralGroup::new); } + + public DiHedralSymmetry r(int k) { + if (k >= n) { + throw new IllegalArgumentException(); + } + return DiHedralSymmetry.r(k, this); + } + + public DiHedralSymmetry s(int k) { + if (k >= n) { + throw new IllegalArgumentException(); + } + return DiHedralSymmetry.s(k, this); + } + @Override public DiHedralSymmetry unity() { - return new DiHedralSymmetry(r, 0, this); + return DiHedralSymmetry.r(0, this); } @Override @@ -41,9 +57,19 @@ public Class getElementClass() { public Stream stream() { return Stream.concat( IntStream.range(0, n) - .mapToObj(i -> new DiHedralSymmetry(r, i, this)), + .mapToObj(i -> DiHedralSymmetry.r(i, this)), IntStream.range(0, n) - .mapToObj(i -> new DiHedralSymmetry(s, i, this)) + .mapToObj(i -> DiHedralSymmetry.s(i, this)) ); } + + @Override + public boolean operationIsCommutative() { + return n <= 2; + } + + @Override + public String toString() { + return "D" + TextUtils.subscript(n); + } } diff --git a/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dihedral/DiHedralSymmetry.java b/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dihedral/DiHedralSymmetry.java index 596627b0..63d1efb5 100644 --- a/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dihedral/DiHedralSymmetry.java +++ b/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dihedral/DiHedralSymmetry.java @@ -2,29 +2,51 @@ import lombok.EqualsAndHashCode; +import java.util.function.UnaryOperator; + import org.meeuw.math.abstractalgebra.GroupElement; +import org.meeuw.math.abstractalgebra.dim2.Matrix2; +import org.meeuw.math.abstractalgebra.dim2.Vector2; import org.meeuw.math.text.TextUtils; import static org.meeuw.math.abstractalgebra.dihedral.Symmetry.r; import static org.meeuw.math.abstractalgebra.dihedral.Symmetry.s; +/** + * @since 0.14 + */ @EqualsAndHashCode -public class DiHedralSymmetry implements GroupElement { +public class DiHedralSymmetry implements GroupElement, UnaryOperator { private final Symmetry symmetry; - private final int i; + private final int k; private final DiHedralGroup group; - public DiHedralSymmetry(Symmetry symmetry, int i, DiHedralGroup diHedralGroup) { + static DiHedralSymmetry r(int k,DiHedralGroup diHedralGroup) { + return new DiHedralSymmetry(r, k, diHedralGroup); + } + static DiHedralSymmetry s(int k,DiHedralGroup diHedralGroup) { + return new DiHedralSymmetry(s, k, diHedralGroup); + } + + public static DiHedralSymmetry r(int k, int n) { + return DiHedralGroup.of(n).r(k); + } + + public static DiHedralSymmetry s(int k, int n) { + return DiHedralGroup.of(n).s(k); + } + + + private DiHedralSymmetry(Symmetry symmetry, int k, DiHedralGroup diHedralGroup) { this.symmetry = symmetry; - this.i = i; + this.k = k; this.group = diHedralGroup; - } - public DiHedralSymmetry(Symmetry symmetry, int i, int n) { - this(symmetry, i, DiHedralGroup.of(n)); + private DiHedralSymmetry(Symmetry symmetry, int k, int n) { + this(symmetry, k, DiHedralGroup.of(n)); } @Override @@ -36,15 +58,15 @@ public DiHedralGroup getStructure() { public DiHedralSymmetry operate(DiHedralSymmetry operand) { if (symmetry == r) { if (operand.symmetry == r) { - return new DiHedralSymmetry(r, (i + operand.i) % group.n, group); + return new DiHedralSymmetry(r, (k + operand.k) % group.n, group); } else { - return new DiHedralSymmetry(s, (i + operand.i) % group.n, group); + return new DiHedralSymmetry(s, (k + operand.k) % group.n, group); } } else { if (operand.symmetry == r) { - return new DiHedralSymmetry(s, (group.n + i - operand.i) % group.n, group); + return new DiHedralSymmetry(s, (group.n + k - operand.k) % group.n, group); } else { - return new DiHedralSymmetry(r, (group.n + i - operand.i) % group.n, group); + return new DiHedralSymmetry(r, (group.n + k - operand.k) % group.n, group); } } } @@ -52,15 +74,37 @@ public DiHedralSymmetry operate(DiHedralSymmetry operand) { @Override public DiHedralSymmetry inverse() { if (symmetry == r) { - return new DiHedralSymmetry(r, (group.n - i) % group.n, group); + return new DiHedralSymmetry(r, (group.n - k) % group.n, group); } else { - return new DiHedralSymmetry(s, (group.n - i) % group.n, group); + return new DiHedralSymmetry(s, k % group.n, group); } } @Override public String toString() { - return symmetry + TextUtils.subscript(i); + return symmetry + TextUtils.subscript(k); + } + + public Matrix2 asMatrix2() { + double phi = 2 * Math.PI * k / group.n; + double cos = Math.cos(phi); + double sin = Math.sin(phi); + if (symmetry == r) { + return Matrix2.of( + cos, -1 * sin, + sin, cos + ); + } else { + return Matrix2.of( + cos, sin, + sin, -1 * cos + ); + } + } + + @Override + public Vector2 apply(Vector2 realNumbers) { + return realNumbers.times(asMatrix2()); } } diff --git a/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dihedral/Symmetry.java b/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dihedral/Symmetry.java index 9ecb1d21..00386d96 100644 --- a/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dihedral/Symmetry.java +++ b/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dihedral/Symmetry.java @@ -1,5 +1,8 @@ package org.meeuw.math.abstractalgebra.dihedral; +/** + * @since 0.14 + */ public enum Symmetry { /** * Rotation diff --git a/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dim2/Matrix2.java b/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dim2/Matrix2.java new file mode 100644 index 00000000..cbad7e82 --- /dev/null +++ b/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dim2/Matrix2.java @@ -0,0 +1,189 @@ +/* + * Copyright 2022 Michiel Meeuwissen + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.meeuw.math.abstractalgebra.dim2; + +import java.util.Arrays; +import java.util.stream.Collectors; + +import org.meeuw.math.*; +import org.meeuw.math.abstractalgebra.MultiplicativeGroupElement; +import org.meeuw.math.abstractalgebra.reals.RealNumber; +import org.meeuw.math.exceptions.DivisionByZeroException; +import org.meeuw.math.uncertainnumbers.UncertainDouble; +import org.meeuw.math.validation.Square; + +import static org.meeuw.math.ArrayUtils.determinant2x2; + +/** + * A square 2x2 matrix of {@code double}s + *

+ * Note this does not use {@link UncertainDouble} to back the matrix, but simple 'doubles' + * This means that rounding errors are not considered, and theory testing may involve some fiddling. + * + * @author Michiel Meeuwissen + * @since 0.14 + */ +public strictfp class Matrix2 implements + MultiplicativeGroupElement, WithScalarOperations, WithDoubleOperations { + + + final double[][] values; + + public static Matrix2 of( + double v11, double v12, + double v21, double v22 + ) { + return new Matrix2(new double[][] { + {v11, v12}, + {v21, v22} + }); + } + + + private static Matrix2 of(@Square(2) double[] value) { + return of( + value[0], value[1], + value[2], value[3] + ); + } + + Matrix2(double[][] values) { + this.values = values; + } + + @Override + public Matrix2 times(Matrix2 multiplier) { + return of(timesDouble(multiplier.values)); + } + + public Vector2[] asVectors() { + return new Vector2[] { + Vector2.of(values[0][0], values[0][1]), + Vector2.of(values[1][0], values[1][1]) + }; + } + + @Override + public Matrix2Group getStructure() { + return Matrix2Group.INSTANCE; + } + + double[] timesDouble(@Square(2) double[][] matrix2) { + double[] result = new double[4]; + for (int i = 0; i < 2; i++) { + for (int j = 0; j < 2; j++) { + double v = 0; + for (int k = 0; k < 2; k++) { + v += values[i][k] * matrix2[k][j]; + } + result[i * 2 + j] = v; + } + } + return result; + } + + double[] timesDouble(double multiplier) { + double[] result = new double[4]; + for (int i = 0; i < 2; i++) { + for (int j = 0; j < 2; j++) { + result[i * 2 + j] = multiplier * values[i][j]; + } + } + return result; + } + + @Override + public Matrix2 times(double multiplier) { + return Matrix2.of(timesDouble(multiplier)); + } + + @Override + public Matrix2 dividedBy(double multiplier) { + return Matrix2.of(timesDouble(1d / multiplier)); + } + + @Override + public Matrix2 times(RealNumber multiplier) { + return times(multiplier.doubleValue()); + } + + @Override + public Matrix2 dividedBy(RealNumber divisor) { + if (divisor.isZero()) { + throw new DivisionByZeroException(this, divisor); + } + return dividedBy(divisor.doubleValue()); + } + + public double determinant() { + double a = values[0][0]; + double b = values[0][1]; + double c = values[1][0]; + double d = values[1][1]; + return determinant2x2(a, b, c, 2); + } + + @Override + // https://www.mathsisfun.com/algebra/matrix-inverse-minors-cofactors-adjugate.html + public Matrix2 reciprocal() { + return adjugate().dividedBy(determinant()); + } + + public Matrix2 adjugate() { + return new Matrix2(adjugateMatrix()); + } + + double[][] adjugateMatrix() { + double a = values[0][0]; + double b = values[0][1]; + double c = values[1][0]; + double d = values[1][1]; + final double[][] adjugate = new double[2][2]; + adjugate[0][0] = d; + adjugate[0][1] = -1 * b; + adjugate[1][0] = -1 * c; + adjugate[1][1] = a; + return adjugate; + } + + private int skip(int i, int skip) { + return i < skip ? i : i + 1; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Matrix2 matrix3 = (Matrix2) o; + return getStructure().getEquivalence().test(this, matrix3); + } + + @Override + public int hashCode() { + return 0; + } + + @Override + public String toString() { + return "(" + Arrays.stream(asVectors()).map(Vector2::toString).collect(Collectors.joining(", ")) + ")"; + } + + @Square(3) + public double[][] getValues() { + return Arrays.stream(values).map(double[]::clone).toArray(double[][]::new); + } +} diff --git a/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dim2/Matrix2Group.java b/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dim2/Matrix2Group.java new file mode 100644 index 00000000..c31dfb3c --- /dev/null +++ b/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dim2/Matrix2Group.java @@ -0,0 +1,77 @@ +/* + * Copyright 2022 Michiel Meeuwissen + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.meeuw.math.abstractalgebra.dim2; + +import org.meeuw.math.Equivalence; +import org.meeuw.math.abstractalgebra.*; + +/** + * @author Michiel Meeuwissen + * @since 0.14 + * @see org.meeuw.math.abstractalgebra.linear.GeneralLinearGroup + */ +public class Matrix2Group extends AbstractAlgebraicStructure + implements MultiplicativeGroup { + + public static final Matrix2Group INSTANCE = new Matrix2Group(); + + @FunctionalInterface + public interface DoubleEquivalence { + boolean test(double t, double u); + } + + final ThreadLocal doubleEquivalence = ThreadLocal.withInitial(() -> (t, u) -> t == u); + + + private Matrix2Group() { + super(Matrix2.class); + } + + @Override + public Matrix2 one() { + return new Matrix2(new double[][] { + {1, 0}, + {0, 1} + }); + } + + @Override + public Cardinality getCardinality() { + return Cardinality.C; + } + + @Override + public Equivalence getEquivalence() { + return (m1, m2 ) -> { + DoubleEquivalence equivalence = this.doubleEquivalence.get(); + for (int i = 0; i < 2; i++) { + for (int j = 0; j < 2; j++) { + if (!equivalence.test(m1.values[i][j], m2.values[i][j])) { + return false; + } + } + } + return true; + }; + } + + public void setDoubleEquivalence(DoubleEquivalence doubleEquivalence) { + this.doubleEquivalence.set(doubleEquivalence); + } + public void clearDoubleEquivalence() { + this.doubleEquivalence.remove(); + } +} diff --git a/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dim2/Vector2.java b/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dim2/Vector2.java new file mode 100644 index 00000000..eaad64c5 --- /dev/null +++ b/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dim2/Vector2.java @@ -0,0 +1,165 @@ +/* + * Copyright 2022 Michiel Meeuwissen + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.meeuw.math.abstractalgebra.dim2; + +import lombok.With; + +import java.util.Iterator; +import java.util.stream.Stream; + +import org.meeuw.math.WithDoubleOperations; +import org.meeuw.math.WithScalarOperations; +import org.meeuw.math.abstractalgebra.*; +import org.meeuw.math.abstractalgebra.reals.RealNumber; +import org.meeuw.math.exceptions.DivisionByZeroException; + +import static org.meeuw.math.DoubleUtils.uncertaintyForDouble; + +/** + * A two-dimensional {@link Vector}, backed by {@code double}s. + * @author Michiel Meeuwissen + * @since 0.14 + */ +public class Vector2 implements + Vector, + WithScalarOperations, + WithDoubleOperations { + + @With + final double x; + + @With + final double y; + + + + public static Vector2 of(double x, double y) { + return new Vector2(x, y); + } + + public Vector2(double x, double y) { + this.x = x; + this.y = y; + } + + public Vector2 times(Matrix2 matrix2) { + return of( + matrix2.values[0][0] * x + matrix2.values[0][1] * y, + matrix2.values[1][0] * x + matrix2.values[1][1] * y + ); + } + + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Vector2 vector3 = (Vector2) o; + + if (Math.abs(vector3.x - x) > 2 * uncertaintyForDouble(x)) return false; + if (Math.abs(vector3.y - y) > 2 * uncertaintyForDouble(y)) return false; + return true; + } + + @Override + public int hashCode() { + int result; + long temp; + temp = Double.doubleToLongBits(x); + result = (int) (temp ^ (temp >>> 32)); + temp = Double.doubleToLongBits(y); + result = 31 * result + (int) (temp ^ (temp >>> 32)); + return result; + } + + + @Override + public String toString() { + return "(" + get(0) + ", " + get(1) + ")"; + } + + + @Override + public Vector2 times(double multiplier) { + return of(x * multiplier, y * multiplier); + } + + @Override + public Vector2 dividedBy(double divisor) { + if (divisor == 0) { + throw new DivisionByZeroException(this, divisor); + } + return of(x / divisor, y / divisor); + } + + @Override + public Vector2 times(RealNumber multiplier) { + return times(multiplier.doubleValue()); + } + + @Override + public Vector2 dividedBy(RealNumber divisor) { + return dividedBy(divisor.doubleValue()); + } + + @Override + public Vector2 plus(Vector2 summand) { + return of(x + summand.x, y + summand.y); + } + + @Override + public RealNumber dot(Vector2 multiplier) { + return RealNumber.of(x * multiplier.x + y * multiplier.y); + } + + @Override + public Vector2 negation() { + return of(-1 * x, -1 * y); + } + + @Override + public RealNumber get(int i) { + switch(i) { + case 0: + return RealNumber.of(x); + case 1: + return RealNumber.of(y); + default: + throw new ArrayIndexOutOfBoundsException(); + } + } + + @Override + public VectorSpace getSpace() { + return Vector2Space.INSTANCE; + } + + @Override + public Iterator iterator() { + return Stream.of(x, y).map(RealNumber::of).iterator(); + } + + @Override + public AbelianRing getStructure() { + return getSpace(); + } + + @Override + public Vector2 times(Vector2 multiplier) { + return of(x * multiplier.x, y * multiplier.y); + } +} diff --git a/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dim2/Vector2Space.java b/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dim2/Vector2Space.java new file mode 100644 index 00000000..d1d918c3 --- /dev/null +++ b/mihxil-algebra/src/main/java/org/meeuw/math/abstractalgebra/dim2/Vector2Space.java @@ -0,0 +1,67 @@ +/* + * Copyright 2022 Michiel Meeuwissen + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.meeuw.math.abstractalgebra.dim2; + +import org.meeuw.math.Example; +import org.meeuw.math.abstractalgebra.*; +import org.meeuw.math.abstractalgebra.reals.RealField; +import org.meeuw.math.abstractalgebra.reals.RealNumber; +import org.meeuw.math.text.TextUtils; + +/** + * @author Michiel Meeuwissen + * @since 0.14 + */ +@Example(VectorSpace.class) +public class Vector2Space implements VectorSpace, AbelianRing { + + public static final Vector2Space INSTANCE = new Vector2Space(); + + @Override + public int getDimension() { + return 2; + } + + @Override + public Vector2 zero() { + return Vector2.of(0, 0); + } + + @Override + public RealField getField() { + return RealField.INSTANCE; + } + + @Override + public Vector2 one() { + return Vector2.of(1, 1); + } + + @Override + public Cardinality getCardinality() { + return Cardinality.ALEPH_1; + } + + @Override + public Class getElementClass() { + return Vector2.class; + } + + @Override + public String toString() { + return getField() + TextUtils.superscript(3); + } +} diff --git a/mihxil-algebra/src/test/java/org/meeuw/test/math/abstractalgebra/dihedral/DiHedralGroupTest.java b/mihxil-algebra/src/test/java/org/meeuw/test/math/abstractalgebra/dihedral/DiHedralGroupTest.java index 3dc3e6ec..638be5b3 100644 --- a/mihxil-algebra/src/test/java/org/meeuw/test/math/abstractalgebra/dihedral/DiHedralGroupTest.java +++ b/mihxil-algebra/src/test/java/org/meeuw/test/math/abstractalgebra/dihedral/DiHedralGroupTest.java @@ -1,16 +1,55 @@ package org.meeuw.test.math.abstractalgebra.dihedral; +import lombok.extern.log4j.Log4j2; + import net.jqwik.api.Arbitraries; import net.jqwik.api.Arbitrary; +import org.junit.jupiter.api.Test; import org.meeuw.math.abstractalgebra.dihedral.DiHedralGroup; import org.meeuw.math.abstractalgebra.dihedral.DiHedralSymmetry; +import org.meeuw.math.abstractalgebra.dim2.Vector2; import org.meeuw.theories.abstractalgebra.GroupTheory; -public class DiHedralGroupTest implements GroupTheory { +@Log4j2 +public class DiHedralGroupTest { + + @Test + public void apply() { + DiHedralSymmetry r1 = DiHedralSymmetry.r(1, 4); + + Vector2 v2 = r1.apply(Vector2.of(0, 1)); + + + log.info("{}", v2); + } + + public static class TriangleSymmetryTests implements GroupTheory { + @Override + public Arbitrary elements() { + return Arbitraries.of(DiHedralGroup.of(3).stream().toList()); + } + } + + public static class SquareSymmetryTests implements GroupTheory { + @Override + public Arbitrary elements() { + return Arbitraries.of(DiHedralGroup.of(4).stream().toList()); + } + } + + + public static class HeptagonSymmetryTests implements GroupTheory { + @Override + public Arbitrary elements() { + return Arbitraries.of(DiHedralGroup.of(5).stream().toList()); + } + } - @Override - public Arbitrary elements() { - return Arbitraries.of(DiHedralGroup.of(3).stream().toList()); + public static class HexagonSymmetryTests implements GroupTheory { + @Override + public Arbitrary elements() { + return Arbitraries.of(DiHedralGroup.of(6).stream().toList()); + } } }