dither 0.2.2-java → 0.2.5-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c4f7b41b32e5ea6f96a929e5ffe96bb822c1810
-  data.tar.gz: 3cf78c076a39e9031bb4009f51c5e676da3c8589
+  metadata.gz: 70b7f18273e2e2f9f75673c656887486d4bcbe48
+  data.tar.gz: 037da612c8c844b3e6c10e6931c95f76e9c284f5
 SHA512:
-  metadata.gz: e113ff89775611ac9624a6ebaf9c230e176b2b10904333c82134953a2ecb8f9222147e626ff2e48a5c7d6d26747d1639c5309cf748c99bc256be6aa46f6d1d45
-  data.tar.gz: 6b405fa6986676656ec3da84808b7b85453e9a8f94bd8b081b6025cb7349c182e6c5c91e36e468cda5ce01f84f3eb3deda7f3f8a19dc48510fd6636293355fce
+  metadata.gz: 13d7a1918fe9fbcef6213aeafab6a6d71cd6aa1320554c219fd2751a3d3542852c7c5b792897c6d2fe4bedd6fe89806692d9112c353c8976fa0aa82dfe4158df
+  data.tar.gz: 78d47ad277c884cbf6450151f2532ff4311c86809857e0c358a138c688ed7b0c762c7961a44ac72b75607e7e4a8b2083508d21999006de788cf798aafccf4264

data/Rakefile

@@ -5,7 +5,13 @@ Bundler::GemHelper.install_tasks
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new
 
-require 'rake/extensiontask'
-Rake::ExtensionTask.new('dither')
+if RUBY_PLATFORM =~ /java/
+  require 'rake/javaextensiontask'
+  Rake::JavaExtensionTask.new('dither')
+else
+  require 'rake/extensiontask'
+  Rake::ExtensionTask.new('dither')
+end
 
 task :default => :spec
+

data/dither.gemspec

@@ -23,9 +23,7 @@ Gem::Specification.new do |s|
 
   if RUBY_PLATFORM =~ /java/
     s.platform = "java"
-    # compile dither-java on jdk 8
-    files << "lib/dither-0.1.5.jar"
-    files << "lib/choco-solver-3.3.1-with-dependencies.jar"
+    files << "lib/dither.jar"
 	else
 		s.add_dependency "ffi", "~> 1.0"
 		s.extensions = 'ext/dither/extconf.rb'

data/ext/dither/Aetg.java

@@ -0,0 +1,51 @@
+package com.github.jesg.dither;
+
+/*
+ * #%L
+ * dither
+ * %%
+ * Copyright (C) 2015 Jason Gowan
+ * %%
+ * 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
+ *
+ *      http://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.
+ * #L%
+ */
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public abstract class Aetg implements Iterator<Object[]> {
+
+    public abstract boolean hasNext();
+    public abstract Object[] next();
+
+    public List<Object[]> toList() {
+        final List<Object[]> results = new LinkedList<Object[]>();
+
+        while(hasNext()) {
+            final Object[] result = next();
+            if(result != null) {
+                results.add(result);
+            }
+        }
+
+        return results;
+    }
+
+    public Object[][] toArray() {
+        return toList().toArray(new Object[][]{});
+    }
+
+    public void remove() {}
+
+}

data/ext/dither/AetgPairwise.java

@@ -0,0 +1,258 @@
+package com.github.jesg.dither;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Random;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.ThreadLocalRandom;
+
+/*
+ * #%L
+ * dither
+ * %%
+ * Copyright (C) 2015 Jason Gowan
+ * %%
+ * 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
+ *
+ *      http://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.
+ * #L%
+ True*/
+
+class AetgPairwise extends Aetg {
+
+    private final int n = 50;
+    private final int[][] scratch = new int[n][];
+    private final int[] fitness = new int[n];
+    private final Object[][] params;
+    private final Pair[][] pairCache;
+    private final List<Pair[]> coverage;
+    private final AtegRandom random;
+    private final ExecutorService executor;
+    private final Semaphore barrier;
+    private final List<Callable<Void>> tasks = new ArrayList<Callable<Void>>(n);
+    private final Pair[][] constraints;
+
+    public AetgPairwise(final int t, final Integer seed, final Object[][] params, final Integer[][] constraintsParam, final Object[][] previouslyTested, final ExecutorService executor) {
+        this.params = params;
+        this.executor = executor;
+        this.barrier = new Semaphore(0);
+
+        for(int i = 0; i < n; i++) {
+            final int index = i;
+            final Semaphore localBarrier = this.barrier;
+            tasks.add(new Callable<Void>() {
+                public Void call() {
+                    try {
+                        generate(index);
+                        fitness(index);
+                    } finally {
+                        localBarrier.release();
+                    }
+                    return null;
+                }
+            });
+        }
+
+        if(seed == null) {
+            this.random = new AtegRandom() {
+                public int nextInt(final int i) { return ThreadLocalRandom.current().nextInt(0, i); }
+            };
+        } else {
+            this.random = new AtegRandom() {
+                final Random random = new Random(seed);
+                public int nextInt(final int i) { return random.nextInt(i); }
+            };
+        }
+
+        this.pairCache = new Pair[params.length][];
+        for(int i = 0; i < params.length; i++) {
+            this.pairCache[i] = new Pair[params[i].length];
+
+            for(int j = 0; j < params[i].length; j++) {
+                this.pairCache[i][j] = new Pair(i, j);
+            }
+        }
+
+        this.constraints = new Pair[constraintsParam.length + previouslyTested.length][];
+        int constraintIndex = 0;
+        for(final Integer[] constraint : constraintsParam) {
+            final List<Pair> pairs = new ArrayList<Pair>();
+            for(int i = 0; i < constraint.length; i++) {
+                if(constraint[i] == null) {
+                    continue;
+                }
+                pairs.add(pairCache[i][constraint[i]]);
+            }
+            constraints[constraintIndex++] = pairs.toArray(new Pair[]{});
+        }
+
+        for(final Object[] testCase : previouslyTested) {
+            final Pair[] pairs = new Pair[testCase.length];
+            for(int i = 0; i < pairs.length; i++) {
+                final Object currentObject = testCase[i];
+                for(int j = 0; j < params[i].length; j++) {
+                    if(currentObject.equals(params[i][j])) {
+                        pairs[i] = pairCache[i][j];
+                        break;
+                    }
+                }
+            }
+            constraints[constraintIndex++] = pairs;
+        }
+
+
+        for(int u = 0; u < n; u++) {
+            scratch[u] = new int[params.length];
+        }
+
+        final int[] arr = new int[params.length];
+        for(int k = 0; k < params.length; k++) {
+            arr[k] = k;
+        }
+
+        this.coverage = new LinkedList<Pair[]>();
+        final int[] lengths = new int[t];
+        for(final int[] tmp : CombinatoricHelper.getCombinations(t, arr)) {
+
+            for(int i = 0; i < lengths.length; i++) {
+                lengths[i] = params[tmp[i]].length;
+            }
+
+            final Pair[][] pairs = new Pair[tmp.length][];
+            for(int i = 0; i < pairs.length; i++) {
+                pairs[i] = this.pairCache[tmp[i]];
+            }
+
+outer:
+            for(final List<Pair> innerPairs : CombinatoricHelper.product(pairs)) {
+                final Pair[] innerComb = innerPairs.toArray(new Pair[innerPairs.size()]);
+
+                for(final Pair[] constraint : constraints) {
+                    int count = 0;
+                    for(final Pair pair : constraint) {
+                        for(final Pair innerCombPair : innerComb) {
+                            if(pair.equals(innerCombPair)) {
+                                count++;
+                                break;
+                            }
+                        }
+                    }
+                    if(count == constraint.length) {
+                        continue outer;
+                    }
+                }
+                coverage.add(innerComb);
+            }
+        }
+    }
+
+
+    public boolean hasNext() {
+        return !coverage.isEmpty();
+    }
+
+    public Object[] next() {
+        try {
+            executor.invokeAll(tasks);
+            barrier.acquire(n);
+        } catch(InterruptedException e) {
+            Thread.currentThread().interrupt();
+            return null;
+        }
+        final int i = bestFit();
+        if(fitness[i] <= 0) {
+            return null;
+        }
+        final int[] best = scratch[i];
+        final Object[] result = new Object[params.length];
+        for(int k = 0; k < result.length; k++) {
+            result[k] = params[k][best[k]];
+        }
+        removeMatches(i);
+        return result;
+    }
+
+    private void removeMatches(final int i) {
+        final int[] cases = scratch[i];
+        final ListIterator<Pair[]> iter = coverage.listIterator(0);
+        while(iter.hasNext()) {
+            if(match(iter.next(), cases)) {
+                iter.remove();
+            }
+        }
+    }
+
+    private void generate(final int i) {
+        for(int j = 0; j < params.length; j++) {
+            scratch[i][j] = random.nextInt(params[j].length);
+        }
+    }
+
+    private void fitness(final int i) {
+        final int[] cases = scratch[i];
+        if(constraints.length > 0) {
+            for(final Pair pair : coverage.get(0)) {
+                cases[pair.i] = pair.j;
+            }
+        }
+        for(final Pair[] constraint : constraints) {
+            int count = 0;
+            for(final Pair pair : constraint) {
+                if(pair.j == cases[pair.i]) {
+                    count++;
+                }
+            }
+            if(count == constraint.length) {
+                fitness[i] = -1;
+                return;
+            }
+        }
+        int count = 0;
+        for(final Pair[] pairs : coverage) {
+            if(match(pairs, cases)) {
+                count++;
+            }
+        }
+        fitness[i] = count;
+    }
+
+    private int bestFit() {
+        int index = 0;
+        int max = 0;
+        for(int i = 0; i < fitness.length; i++) {
+            final int value = fitness[i];
+            if(value > max) {
+                max = value;
+                index = i;
+            }
+        }
+        return index;
+    }
+
+    private interface AtegRandom {
+        int nextInt(int a);
+    }
+
+    private static boolean match(final Pair[] pairs, final int[] cases) {
+        boolean flag = true;
+        for(final Pair pair : pairs) {
+            if(cases[pair.i] != pair.j) {
+                flag = false;
+                break;
+            }
+        }
+        return flag;
+    }
+}

data/ext/dither/ArrayLengthComparator.java

@@ -0,0 +1,30 @@
+package com.github.jesg.dither;
+
+/*
+ * #%L
+ * dither
+ * %%
+ * Copyright (C) 2015 Jason Gowan
+ * %%
+ * 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
+ *
+ *      http://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.
+ * #L%
+ */
+
+import java.util.Comparator;
+
+class ArrayLengthComparator implements Comparator<IndexArrayPair> {
+
+    public int compare(IndexArrayPair arg1, IndexArrayPair arg2) {
+        return -Integer.compare(arg1.getArr().length, arg2.getArr().length);
+    }
+}

data/ext/dither/CombinatoricHelper.java

@@ -0,0 +1,143 @@
+package com.github.jesg.dither;
+
+/*
+ * #%L
+ * dither
+ * %%
+ * Copyright (C) 2015 Jason Gowan
+ * %%
+ * 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
+ *
+ *      http://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.
+ * #L%
+ */
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+class CombinatoricHelper {
+
+    public static List<int[]> getCombinations(final int n, final int[] input) {
+        final List<int[]> result = new ArrayList<int[]>();
+        final int[] scratch = new int[n];
+
+        if (n <= input.length) {
+            for (int i = 0; (scratch[i] = i) < n - 1; i++)
+                ;
+            result.add(_getCombinations(input, scratch));
+            for (;;) {
+                int i;
+                for (i = n - 1; i >= 0 && scratch[i] == input.length - n + i; i--)
+                    ;
+                if (i < 0) {
+                    break;
+                } else {
+                    scratch[i]++;
+                    for (++i; i < n; i++) {
+                        scratch[i] = scratch[i - 1] + 1;
+                    }
+                    result.add(_getCombinations(input, scratch));
+                }
+            }
+        }
+
+        return result;
+    }
+
+    private static int[] _getCombinations(final int[] input, final int[] scratch) {
+        final int[] result = new int[scratch.length];
+        for (int i = 0; i < scratch.length; i++) {
+            result[i] = input[scratch[i]];
+        }
+        return result;
+    }
+
+
+    public static <T> List<List<T>> product(final T[][] args) {
+        final int[] tmp = new int[args.length];
+        for(int i = 0; i < tmp.length; i++) {
+            tmp[i] = args[i].length;
+        }
+
+        final int[][] solution = product(tmp);
+        final List<List<T>> results = new ArrayList<List<T>>(solution.length);
+        for(int i = 0; i < solution.length; i++) {
+            final List<T> inner = new ArrayList<T>(args.length);
+            results.add(i, inner);
+            for(int j = 0; j < args.length; j++) {
+                results.get(i).add(j, args[j][solution[i][j]]);
+            }
+        }
+        return results;
+    }
+
+    public static int[][] product(final int[] ranges) {
+        int length = 1;
+        for(int i = 0; i < ranges.length; i++) {
+            length *= ranges[i];
+            --ranges[i];
+        }
+
+        final int[][] results = new int[length][ranges.length];
+        final int[] scratch = new int[ranges.length];
+
+        int k = 0;
+        final int max = ranges.length - 1;
+        for(int i = max;;) {
+
+            if(i == max) {
+                for(int val = 0; val <= ranges[i]; val++) {
+                    for(int j = 0; j < scratch.length; j++) {
+                        results[k][j] = scratch[j];
+                    }
+                    k++;
+                    scratch[i]++;
+                }
+                scratch[i] = 0;
+                i--;
+            } else if(i == 0 && scratch[i] >= ranges[i]) {
+                return results;
+            } else if(scratch[i] < ranges[i]) {
+                scratch[i]++;
+                i++;
+            } else {
+                scratch[i] = -1;
+                i--;
+            }
+        }
+    }
+
+    private static int[][] _product(final int left, final int right) {
+        final int[][] result = new int[left * right][];
+        int k = 0;
+        for (int i = 0; i < left; i++) {
+            for (int j = 0; j < right; j++) {
+                result[k] = new int[] { i, j };
+                k++;
+            }
+        }
+        return result;
+    }
+
+    private static int[][] _product(final int[][] left, final int right) {
+        final int[][] result = new int[left.length * right][];
+        int k = 0;
+        for (int i = 0; i < left.length; i++) {
+            for (int j = 0; j < right; j++) {
+                result[k] = Arrays.copyOf(left[i], left[i].length + 1);
+                result[k][left[i].length] = j;
+                k++;
+            }
+        }
+        return result;
+    }
+}

data/ext/dither/ConstraintHandler.java

@@ -0,0 +1,120 @@
+package com.github.jesg.dither;
+
+import java.util.Arrays;
+
+/*
+ * #%L
+ * dither
+ * %%
+ * Copyright (C) 2015 Jason Gowan
+ * %%
+ * 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
+ *
+ *      http://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.
+ * #L%
+ */
+
+import java.util.Comparator;
+
+class ConstraintHandler {
+
+    private final Pair[][] constraints;
+    private final int[] bounds;
+    private final int[] scratch;
+
+    ConstraintHandler(final Pair[][] constraints, final int[] bounds) {
+        this.constraints = constraints;
+        this.bounds = new int[bounds.length];
+        this.scratch = new int[bounds.length];
+        for(int i = 0; i < bounds.length; i++) {
+            this.bounds[i] = bounds[i] - 1;
+        }
+        Arrays.fill(scratch, -1);
+        Arrays.sort(this.constraints, new Comparator<Pair[]>() {
+            public int compare(final Pair[] a, final Pair[] b) { return a.length - b.length; }
+        });
+    }
+
+    boolean violateConstraints_(final int[] testCase) {
+outer:
+        for(final Pair[] pairs : constraints) {
+            for(final Pair pair : pairs) {
+                final int value = testCase[pair.i];
+                if(value == -1 || value != pair.j) {
+                    continue outer;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    boolean violateConstraints(final int[] solution) {
+        if(violateConstraints_(solution)) {
+            return true;
+        }
+        for(int i = 0; i < solution.length; i++) {
+            scratch[i] = solution[i];
+        }
+        return groundSolution(scratch) == null;
+    }
+
+    boolean violateConstraints(final Pair[] pairs) {
+        Arrays.fill(scratch, -1);
+        for(int i = 0; i < pairs.length; i++) {
+            final Pair pair = pairs[i];
+            scratch[pair.i] = pair.j;
+        }
+        if(violateConstraints_(scratch)) {
+            return true;
+        }
+        return groundSolution(scratch) == null;
+    }
+
+    // return null if unable to find a solution
+    int[] groundSolution(final int[] solution) {
+        final int[] indexes = new int[solution.length];
+        int last_index = 0;
+        for(int i = 0; i < solution.length; i++) {
+            if(solution[i] == -1) {
+                indexes[last_index] = i;
+                ++last_index;
+            }
+        }
+        final int[] bound_values = new int[last_index + 1];
+        Arrays.fill(bound_values, -1);
+        int i = 0;
+
+outer:
+        while(i < bound_values.length) {
+            final int max = bounds[indexes[i]];
+            for(int value = bound_values[i] + 1; value <= max; value++) {
+                solution[indexes[i]] = value;
+                if(violateConstraints_(solution)) {
+                    continue;
+                }
+                bound_values[i] = value;
+                ++i;
+                continue outer;
+            }
+
+            if(i == 0) {
+                return null;
+            }
+
+            // unwind
+            bound_values[i] = -1;
+            solution[indexes[i]] = -1;
+            --i;
+        }
+        return solution;
+    }
+}