xacid

import java.util.Objects;

public interface Untyped {

    interface Lambda {
        Lambda $(Lambda f);
( Read more... )


    Lambda I = x -> x;
    Lambda K = x -> y -> x;
    Lambda S = x -> y -> z -> x.$(z).$(y.$(z));

    Lambda pair = p -> a -> b -> p.$(a).$(b);
    Lambda first = p -> p.$(a -> b -> a);
    Lambda second = p -> p.$(a -> b -> b);

    static void main(String[] args) {

        print(S.$(K).$(K).$("x").equals(I.$("x")));

        pair.$("x").$("y").$(first).$(print);

        second.$("x").$("y").$(print);

        $("x").$("y").$(first).$(print);

        $("x").$("y").$(K.$(print));
    }
}

public class JavaCartesianDualism {

    // Morphism proposition is exponent

    interface Arrow<A, B extends A> {
    }

    // Sum proposition is dependent product

    interface Sum<S, A extends S, B extends S> {
    }

    // Presumably, exponent proposition is some arrow 
    // and product proposition is some sum?

    interface Prod<A, B> extends
            Prod1<A, B>, Prod2<A, B> {
    }

    interface Prod1<A, B> {
        A _1(Prod<A, B> p);
    }

    interface Prod2<A, B> {
        B _2(Prod<A, B> p);
    }

    interface _Prod1<A, B> extends
            Arrow<Prod1<A, B>, Prod<A, B>> {
    }

    interface _Prod2<A, B> extends
            Arrow<Prod2<A, B>, Prod<A, B>> {
    }

    interface _Prod<A, B, T extends Prod<A, B>>
            extends Arrow<Prod<A, B>, T> {
    }

    interface Exp<A, B> {
        A eval(B b);
    }

    interface Curry<C, A, B> extends Exp<C, Prod<A, B>> {
        Exp<C, B> curry(A a);
    }

    interface _Curry<A, B, C> extends
            Arrow<Exp<C, Prod<A, B>>, Curry<C, A, B>> {
    }

}

public interface JCat {

    interface Arrow<A, B extends A> {
    }

    interface Id<A> extends Arrow<A, A> {
    }

    interface o<A, B extends A, C extends B> 
        extends Arrow<A, C> {
    }

}

search size = 2097151

data size = 10
arrayBinary : 30 .. 47
arrayLinear : 13 .. 27
hashSet     : 13 .. 27
treeSet     : 44 .. 63
listBinary  : 43 .. 70

data size = 20
arrayBinary : 40 .. 51
arrayLinear : 26 .. 36
hashSet     : 14 .. 19
treeSet     : 60 .. 71
listBinary  : 57 .. 77

data size = 30
arrayBinary : 50 .. 74
arrayLinear : 32 .. 58
hashSet     : 12 .. 18
treeSet     : 67 .. 81
listBinary  : 71 .. 85

data size = 40
arrayBinary : 54 .. 69
arrayLinear : 44 .. 56
hashSet     : 15 .. 21
treeSet     : 75 .. 91
listBinary  : 78 .. 91

data size = 50
arrayBinary : 54 .. 67
arrayLinear : 50 .. 64
hashSet     : 11 .. 15
treeSet     : 78 .. 93
listBinary  : 79 .. 94

data size = 60
arrayBinary : 59 .. 70
arrayLinear : 62 .. 91
hashSet     : 12 .. 18
treeSet     : 85 .. 111
listBinary  : 88 .. 101

data size = 70
arrayBinary : 59 .. 71
arrayLinear : 69 .. 84
hashSet     : 14 .. 19
treeSet     : 85 .. 101
listBinary  : 86 .. 101

data size = 80
arrayBinary : 68 .. 83
arrayLinear : 81 .. 102
hashSet     : 15 .. 24
treeSet     : 90 .. 107
listBinary  : 93 .. 110

data size = 90
arrayBinary : 77 .. 95
arrayLinear : 87 .. 108
hashSet     : 17 .. 28
treeSet     : 99 .. 118
listBinary  : 115 .. 137

data size = 100
arrayBinary : 85 .. 108
arrayLinear : 95 .. 293
hashSet     : 11 .. 16
treeSet     : 104 .. 119
listBinary  : 121 .. 152

import java.util.*;
import java.util.function.*;
import java.util.stream.*;

public class SearchInts {

    private static final int times = Byte.MAX_VALUE;
    private static final int sizeSearch = Integer.MAX_VALUE / 1024;

    private static long time() {
        return System.currentTimeMillis();
    }

    private static final Random random = new Random();

    private static int[] randoms(final int size) {
        final Set<Integer> set = new HashSet<>();
        while (set.size() < size)
            set.add(new Integer(random.nextInt()));
        final Integer[] integers = set.toArray(new Integer[]{});
        final int[] xs = new int[size];
        for (int x = 0; x < size; x++)
            xs[x] = integers[x].intValue();
        return xs;
    }

    private static long arrayBinary(final int[] randoms, final int[] search) {
        final int[] xs = new int[randoms.length];
        System.arraycopy(randoms, 0, xs, 0, randoms.length);
        final long start = time();
        Arrays.sort(xs);
        for (final int x : search)
            Arrays.binarySearch(xs, x);
        return time() - start;
    }

    private static long arrayLinear(final int[] randoms, final int[] search) {
        final int[] xs = new int[randoms.length];
        System.arraycopy(randoms, 0, xs, 0, randoms.length);
        final long start = time();
        Arrays.sort(xs);
        for (final int x : search)
            for (final int xx : xs)
                if (xx == x) break;
        return time() - start;
    }

    private static long listBinary(final int[] randoms, final int[] search) {
        final List<Integer> xs = new ArrayList(randoms.length);
        for (final int x : randoms) xs.add(new Integer(x));
        final long start = time();
        Collections.sort(xs);
        for (final int x : search)
            Collections.binarySearch(xs, new Integer(x));
        return time() - start;
    }

    private static long hashSet(final int[] randoms, final int[] search) {
        final Set<Integer> xs = new HashSet<>();
        for (final int x : randoms) xs.add(new Integer(x));
        final long start = time();
        for (final int x : search) xs.contains(new Integer(x));
        return time() - start;
    }

    private static long treeSet(final int[] randoms, final int[] search) {
        final Set<Integer> xs = new TreeSet<>();
        for (final int x : randoms) xs.add(new Integer(x));
        final long start = time();
        for (final int x : search) xs.contains(new Integer(x));
        return time() - start;
    }

    private static void test(final String name, final Supplier<Long> test) {
        final List<Long> results = Stream.generate(() -> test.get())
                .limit(times).sorted().collect(Collectors.toList());
        System.out.println(name + " : " + results.get(0) + " .. " +
                results.get(times - 1));
    }

    public static void main(String[] args) {
        final int[] search = randoms(sizeSearch);
        System.out.println("search size = " + search.length);
        System.out.println();
        Stream.iterate(10, x -> x + 10).limit(10).forEach(sizeData -> {
            final int[] randoms = randoms(sizeData);
            System.out.println("data size = " + randoms.length);
            test("arrayBinary", () -> arrayBinary(randoms, search));
            test("arrayLinear", () -> arrayLinear(randoms, search));
            test("hashSet    ", () -> hashSet(randoms, search));
            test("treeSet    ", () -> treeSet(randoms, search));
            test("listBinary ", () -> listBinary(randoms, search));
            System.out.println();
        });
    }
}

data size = 2097151
search size = 32767

arrayBinary
  best  202
  worst 621

hashSet    
  best  1
  worst 9

treeSet    
  best  25
  worst 60

listBinary 
  best  803
  worst 991

    private static final int probes = Byte.MAX_VALUE;
    private static final int times = Integer.MAX_VALUE / 1024;

    private static long time() {
        return System.currentTimeMillis();
    }

    private static final Random random = new Random();

    private static int[] randoms(final int size) {
        final int[] xs = new int[size];
        for (int x = 0; x < size; x++)
            xs[x] = random.nextInt();
        return xs;
    }

    private static void arrayBinary(final int[] randoms) {
        final int size = randoms.length;
        final int[] xs = new int[size];
        for (int x = 0; x < size; x++)
            xs[x] = randoms[x];
        Arrays.sort(xs);
        for (int x = 0; x < times; x++)
            Arrays.binarySearch(xs, random.nextInt());
    }

    private static void listBinary(final int[] randoms) {
        final List<Integer> xs = new ArrayList(randoms.length);
        for (final int x : randoms) xs.add(new Integer(x));
        Collections.sort(xs);
        for (int x = 0; x < times; x++)
            Collections.binarySearch(xs, 
                new Integer(random.nextInt()));
    }

    private static void listLinear(final int[] randoms) {
        final List<Integer> xs = new ArrayList(randoms.length);
        for (final int x : randoms) xs.add(new Integer(x));
        for (int x = 0; x < times; x++)
            xs.contains(new Integer(random.nextInt()));
    }

    private static void hashSet(final int[] randoms) {
        final Set<Integer> xs = new HashSet<>();
        for (final int x : randoms) xs.add(new Integer(x));
        for (int x = 0; x < times; x++)
            xs.contains(new Integer(random.nextInt()));
    }

    private static long probe(final Runnable test) {
        final long start = time();
        test.run();
        return time() - start;
    }

    private static void test(final String name,
                             final Runnable test) {
        Stream.generate(() -> probe(test))
                .limit(probes).sorted().findFirst()
                .map(x -> name + " : " + x)
                .ifPresent(System.out::println);
    }

    public static void main(String[] args) {
        Stream.iterate(10, x -> x + 10).limit(10)
                .forEach(size -> {
                    System.out.println("size = " + size);
                    final int[] randoms = randoms(size);
                    test("arrayBinary", () -> arrayBinary(randoms));
                    test("listBinary ", () -> listBinary(randoms));
                    test("listLinear ", () -> listLinear(randoms));
                    test("hashSet    ", () -> hashSet(randoms));
                    System.out.println();
                });
    }

size = 10
arrayBinary : 41
listBinary  : 56
listLinear  : 33
hashSet     : 33

size = 20
arrayBinary : 51
listBinary  : 69
listLinear  : 58
hashSet     : 31

size = 30
arrayBinary : 58
listBinary  : 80
listLinear  : 76
hashSet     : 30

size = 40
arrayBinary : 67
listBinary  : 89
listLinear  : 100
hashSet     : 32

size = 50
arrayBinary : 71
listBinary  : 91
listLinear  : 120
hashSet     : 30

size = 60
arrayBinary : 78
listBinary  : 103
listLinear  : 145
hashSet     : 30

size = 70
arrayBinary : 85
listBinary  : 107
listLinear  : 163
hashSet     : 31

size = 80
arrayBinary : 84
listBinary  : 109
listLinear  : 194
hashSet     : 32

size = 90
arrayBinary : 90
listBinary  : 108
listLinear  : 211
hashSet     : 33

size = 100
arrayBinary : 90
listBinary  : 113
listLinear  : 239
hashSet     : 29

public class EscapeBoxing {
    private static final int fromInt = 128;
    private static final int toInt = Integer.MAX_VALUE;
    private static final long fromLong = 128;
    private static final long toLong = Integer.MAX_VALUE;

    private int xi;
    private long xl;

    private void set(final int x) {
        this.xi = x;
    }

    private void set(final long x) {
        this.xl = x;
    }

    private void setAny(final Object x) {
        if (x instanceof Long) set((Long) x);
        else if (x instanceof Integer) set((Integer) x);
    }

    private void testPrimInt() {
        for (int i = fromInt; i < toInt; i++) set(i);
    }

    private void testEscapeInt() {
        for (int i = fromInt; i < toInt; i++) setAny(new Integer(i));
    }

    private void testBoxingInt() {
        for (int i = fromInt; i < toInt; i++) setAny(i);
    }

    private void testPrimLong() {
        for (long i = fromLong; i < toLong; i++) set(i);
    }

    private void testEscapeLong() {
        for (long i = fromLong; i < toLong; i++) setAny(new Long(i));
    }

    private void testBoxingLong() {
        for (long i = fromLong; i < toLong; i++) setAny(i);
    }

    private static long time() {
        return System.currentTimeMillis();
    }

    private static final int warm = 10;

    private void test() {
        for (int i = 0; i < warm; i++) {
            testPrimInt();
            testEscapeInt();
            testBoxingInt();
        }
        {
            final long start = time();
            testPrimInt();
            final long time = time() - start;
            System.out.println("prim int: " + time);
        }
        {
            final long start = time();
            testEscapeInt();
            final long time = time() - start;
            System.out.println("escape int: " + time);
        }
        {
            final long start = time();
            testBoxingInt();
            final long time = time() - start;
            System.out.println("boxing int: " + time);
        }

        for (int i = 0; i < warm; i++) {
            testPrimLong();
            testEscapeLong();
            testBoxingLong();
        }
        {
            final long start = time();
            testPrimLong();
            final long time = time() - start;
            System.out.println("prim long: " + time);
        }
        {
            final long start = time();
            testEscapeLong();
            final long time = time() - start;
            System.out.println("escape long: " + time);
        }
        {
            final long start = time();
            testBoxingLong();
            final long time = time() - start;
            System.out.println("boxing long: " + time);
        }
    }

    public static void main(String[] args) {
        new EscapeBoxing().test();
    }
}

java version "1.8.0_102"
Java(TM) SE Runtime Environment (build 1.8.0_102-b14)
Java HotSpot(TM) 64-Bit Server VM (build 25.102-b14, mixed mode)

prim int: 98
escape int: 96
boxing int: 91
prim long: 1900
escape long: 1909
boxing long: 2347