dither 0.2.2 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b2f3f8fa861ae290b01ece8edf0150480d7b3cf
-  data.tar.gz: 3c00e98cf8b3b8a80b4327f2418068d07e871db5
+  metadata.gz: d71e5bd41e308d0224d6902f1c0698739e1ea399
+  data.tar.gz: adef3f1c923b2611da8ed6cf47f3d7dec5ffb8d3
 SHA512:
-  metadata.gz: 62e73bc1bf276f26aab2d0115fb6125fb01871695a57823078401a3475a102bffbeb588d3c48552f5094f4a1ec339112053c657329b27f9bac068d4b04400644
-  data.tar.gz: 0154292ff25b831fc39acd29388efb5e0520e7434db8282942ab5f7e1b8bdd00db4215b3a71e2ee83fd1f2f2f07a38b75139b830b745e6af55efc0cc3c4a2a92
+  metadata.gz: d1ca534cc0dfe49379470dfda625d115ae6af9a0e7bf1ed9ca9a4dca784b095a55e5dfcc7d290f45aeea3723797426df6a69da1ffafa43877c9a7cb010e29c7a
+  data.tar.gz: 4333165dad0c5a001e58acea7b3c421e691e5c90c52ae10baaf3c4a67b43acf6ef43d1ae2f20805c29b086a71a179a3137e1d12b74ec08f06c07f0fa054cbd8e

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;
+    }
+}