Merge pull request #1 from ZoftWhere/feature/release-2.0.0

Release v2.0.0

Author: osmundf

.idea/codeStyles/Project.xml

@@ -3,49 +3,130 @@
 import java.util.Arrays;
 import java.util.List;
 
-public abstract class AbstractPermutation<T> {
+import static app.zoftwhere.combinatoric.Generator.empty;
+
+abstract class AbstractPermutation<T> implements Permutation<T> {
 
     private final int[] index;
 
     private final int size;
 
+    private final int kSize;
+
+    private final List<T> list;
+
     /**
      * User PermutationBuilder to initialize a new permutation.
-     *
-     * @param index the index array for permutations.
      */
-    AbstractPermutation(int[] index) {
+    AbstractPermutation(int[] index, List<T> list, int kSize) {
         this.index = index;
         this.size = index.length;
+        this.list = list;
+        this.kSize = kSize;
     }
 
-    public int getSize() {
+    /**
+     * Returns an immutable instance with the values in the clone.
+     */
+    protected abstract Permutation<T> newInstance(int[] index, List<T> list, int kSize);
+
+    /**
+     * {@inheritDoc}
+     */
+    public int size() {
         return size;
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    public int kSize() {
+        return kSize;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
     public boolean isEmpty() {
         return size == 0;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public boolean isPresent() {
         return size != 0;
     }
 
-    public int[] getIndex() {
+    /**
+     * {@inheritDoc}
+     */
+    public int[] index() {
         int[] push = new int[size];
         System.arraycopy(index, 0, push, 0, size);
         return push;
     }
 
-    public int getIndex(int position) {
+    /**
+     * {@inheritDoc}
+     */
+    public int index(int position) {
         return index[position];
     }
 
-    public abstract List<T> getValue();
+    /**
+     * {@inheritDoc}
+     */
+    public abstract List<T> value();
 
-    public abstract T getValue(int position);
+    /**
+     * {@inheritDoc}
+     */
+    public abstract T value(int position);
+
+    /**
+     * {@inheritDoc}
+     */
+    public Permutation<T> next() {
+        if (size < 2) {
+            return empty();
+        }
+        return next(Math.min(size - 2, kSize - 1));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public Permutation<T> next(int position) {
+        checkPosition(position);
+
+        int current = Math.min(position, kSize - 1);
+        Permutation<T> next;
 
-    public abstract AbstractPermutation<T> next(int position);
+        while (current >= 0) {
+            next = progress(current);
+            current--;
+
+            if (next.isPresent()) {
+                return next;
+            }
+        }
+
+        return progress(0);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public abstract Permutation<T> progress(int position);
+
+    boolean checkPosition(int position) {
+        if (position < 0 || position >= size) {
+            throw new ArrayIndexOutOfBoundsException(String.format("Index %d out of bounds for length %d", position, size));
+        }
+
+        return (position < size - 1) && (position < kSize);
+    }
 
     /**
      * Helper method for advancing at a give index, and resetting (sorting) trailing positions.
@@ -55,7 +136,7 @@ public int getIndex(int position) {
      * @param right the replacement position index array index
      * @return the index array after advancement
      */
-    int[] next(int[] index, int left, int right) {
+    int[] advance(int[] index, int left, int right) {
         int[] push = new int[size];
         System.arraycopy(index, 0, push, 0, size);
         push[left] = index[right];
@@ -64,4 +145,18 @@ int[] next(int[] index, int left, int right) {
         return push;
     }
 
+    /**
+     * Creates an ordered index array for the permutation.
+     *
+     * @param size the size of the array
+     * @return an ordered index array
+     */
+    static int[] orderedArray(int size) {
+        final int[] index = new int[size];
+        for (int i = 0; i < size; i++) {
+            index[i] = i;
+        }
+        return index;
+    }
+
 }

main-java/app/zoftwhere/combinatoric/AbstractPermutation.java

@@ -0,0 +1,173 @@
+package app.zoftwhere.combinatoric;
+
+abstract class AbstractSequence<T, L> implements Sequence<T, L>, Cloneable {
+
+    private final T base;
+
+    private final int exponent;
+
+    private final T increment;
+
+    private final L length;
+
+    AbstractSequence(T base, T increment, int exponent, L length) {
+        this.base = base;
+        this.increment = increment;
+        this.exponent = exponent;
+        this.length = length;
+    }
+
+    public T base() {
+        return base;
+    }
+
+    public T increment() {
+        return increment;
+    }
+
+    public int exponent() {
+        return exponent;
+    }
+
+    public L length() {
+        return length;
+    }
+
+    public abstract T sum();
+
+    /**
+     * Returns an immutable instance with the values in the clone.
+     *
+     * @param base      base value
+     * @param increment increment value
+     * @param exponent  exponent value
+     * @param length    sequence length
+     * @return immutable instance
+     */
+    protected abstract Sequence<T, L> newInstance(T base, T increment, int exponent, L length);
+
+    /**
+     * @param value the value to convert
+     * @return the converted value of type <code>T</code>
+     */
+    protected abstract T convertValue(int value);
+
+    /**
+     * @param value the value to convert
+     * @return the converted value of type <code>T</code>
+     */
+    protected abstract T convertValue(long value);
+
+    /**
+     * @param length the value to convert
+     * @return the converted value of type <code>L</code>
+     */
+    protected abstract L convertLength(int length);
+
+    /**
+     * @param length the value to convert
+     * @return the converted value of type <code>L</code>
+     */
+    protected abstract L convertLength(long length);
+
+    /**
+     * Create a sequence, based on the current, with a different base value.
+     *
+     * @param base the base value
+     * @return a new immutable instance with the new base
+     */
+    public Sequence<T, L> base(int base) {
+        return newInstance(convertValue(base), increment(), exponent(), length());
+    }
+
+    /**
+     * Create a sequence, based on the current, with a different base value.
+     *
+     * @param base the base value
+     * @return a new immutable instance with the new base
+     */
+    public Sequence<T, L> base(long base) {
+        return newInstance(convertValue(base), increment(), exponent(), length());
+    }
+
+    /**
+     * Create a sequence, based on the current, with a different base value.
+     *
+     * @param base the base value
+     * @return a new immutable instance with the new base
+     */
+    public Sequence<T, L> base(T base) {
+        return newInstance(base, increment(), exponent(), length());
+    }
+
+    /**
+     * Create a sequence, based on the current, with a different increment value.
+     *
+     * @param increment the increment value
+     * @return a new immutable instance with the new increment
+     */
+    public Sequence<T, L> increment(int increment) {
+        return newInstance(base(), convertValue(increment), exponent(), length());
+    }
+
+    /**
+     * Create a sequence, based on the current, with a different increment value.
+     *
+     * @param increment the increment value
+     * @return a new immutable instance with the new increment
+     */
+    public Sequence<T, L> increment(long increment) {
+        return newInstance(base(), convertValue(increment), exponent(), length());
+    }
+
+    /**
+     * Create a sequence, based on the current, with a different increment value.
+     *
+     * @param increment the increment value
+     * @return a new immutable instance with the new increment
+     */
+    public Sequence<T, L> increment(T increment) {
+        return newInstance(base(), increment, exponent(), length());
+    }
+
+    /**
+     * Create a sequence, based on the current, with a different exponent value.
+     *
+     * @param exponent the increment value
+     * @return a new immutable instance with the new exponent
+     */
+    public Sequence<T, L> exponent(int exponent) {
+        return newInstance(base(), increment(), exponent, length());
+    }
+
+    /**
+     * Create a sequence, based on the current, with a different length.
+     *
+     * @param length the increment value
+     * @return a new immutable instance with the new length
+     */
+    public Sequence<T, L> length(int length) {
+        return newInstance(base(), increment(), exponent(), convertLength(length));
+    }
+
+    /**
+     * Create a sequence, based on the current, with a different length.
+     *
+     * @param length the increment value
+     * @return a new immutable instance with the new length
+     */
+    public Sequence<T, L> length(long length) {
+        return newInstance(base(), increment(), exponent(), convertLength(length));
+    }
+
+    /**
+     * Create a sequence, based on the current, with a different length.
+     *
+     * @param length the increment value
+     * @return a new immutable instance with the new length
+     */
+    public Sequence<T, L> length(L length) {
+        return newInstance(base(), increment(), exponent(), length);
+    }
+
+}