package net.heteroclinic.experiment.lambdatest; import java.util.ArrayList; import java.util.List; /** * * @author zhikai * * Basic lambda test and pointer guard, need Java 8. */ public class Test1Simple { public interface ConcatEEs { String op(String a, String b); } public static int howManyArgs (Object ... ol) { return ol.length; } public static void trySomeCooldon (List<?> l) { for (Object o: l==null?new ArrayList<Object>(): l ) ;//O lala. } public static int weMeasureElipse (String ... s) { return weTakeElipse(s); } public static int weTakeElipse (String [] s) { return s.length; } public static void main(String[] args) { ConcatEEs concat2e = (a, b) -> a + b; System.out.println(concat2e.op("a", "b")); System.out.println( howManyArgs (1,2,3,4,5)); trySomeCooldon (null); System.out.println(weMeasureElipse("a","b","c")); //System.out.println(weTakeElipse("a","b","c")); } }

package net.heteroclinic.experiment.lambdatest; /** * * @author zhikai * * Use lambda to compute composite functions */ public class Test3 { public interface FunctionOfX { public double f (double x); } public static double compositeFunction (FunctionOfX f, FunctionOfX g, double x) { return f.f(g.f(x)); } public static void main(String[] args) { System.out.println ( compositeFunction ( x-> x*x , x->x+x, 12.3d) ); System.out.println( (2.0d*12.3d) * (2.0d*12.3d) ); } } //605.1600000000001 //605.1600000000001

package net.heteroclinic.experiment.lambdatest; import java.util.ArrayList; import java.util.Arrays; /** * * @author zhikai * * Passing arbitary number of functors * */ public class Test4 { public interface FunctionOfX { public double f (double x); } public static double compositeFunctions (double x, FunctionOfX ... functors) { if (functors==null) throw new NullPointerException(); double result = 0.0; int i = 0; for (FunctionOfX f : Arrays.asList( functors) ) { if (i == 0) result = f.f(x); else result = f.f(result); } return result; } public static void main(String[] args) { System.out.println( compositeFunctions( 1.123d, x-> x + 2.0d, x-> x * x * x, x -> 3.0d * Math.exp(x) + Math.sin(x) ) ); } }

package net.heteroclinic.experiment.lambdatest; /** * * @author zhikai * Given third party license acknowledged and this header kept or quoted, you can utilize this program at will. */ public class LoopPerm { public static void perm(int[] a, int segmentLength) { if (segmentLength <= 1) { for (int i : a) System.out.print(i + " "); System.out.println(); return; } for (int i = segmentLength - 1; i >= 0; i--) { int tmp = a[segmentLength - 1]; a[segmentLength - 1] = a[i]; a[i] = tmp; perm(a, segmentLength - 1); tmp = a[segmentLength - 1]; a[segmentLength - 1] = a[i]; a[i] = tmp; } } public static void main(String[] args) { int[] a = { 1 }; perm(a, a.length); a = new int[] { 1, 2 }; perm(a, a.length); a = new int[] { 1, 2 ,3}; perm(a, a.length); } }

package net.heteroclinic.experiment.lambdatest; import java.util.ArrayList; import java.util.List; /** * @author Zhikai Wang/www.heteroclinic.net * This class is an example/exercise to provide a code base to compute k-combinations of a set. * Given third party license acknowledged and this header kept or quoted, you can utilize this program at will. * Juggling elements among: * [spared][selected][remaining] */ public class KCombinationByChooseSpare { // Print a List public static void printList (List<Integer> l) { for (int i:l) System.out.print(i+ " "); System.out.println(); } // Moving the elements frequently at random positions proves in-line array impractical. public static void choose ( List<Integer> spared, List<Integer> choices, List<Integer> remaining, int K) { // END conditions for the recursion // 1. The choices suffice // 2. The remaining choices do not allow more sparing // May check always. if ( choices.size() >= K ) { // Print choices printList (choices); return; } else if ( remaining.size() <= K - choices.size()) { // Print remaining + choices List<Integer> pl = new ArrayList<Integer>(); pl.addAll(choices); pl.addAll(remaining); printList (pl); return; } // For the first element of the remaining if ( remaining.size() <= 0) return; int firstOfRemaining = remaining.get(0); // Choose it, call choose to pick one more choices.add(firstOfRemaining); remaining.remove(new Integer(firstOfRemaining)); List<Integer> ns = new ArrayList<Integer>(); ns.addAll(spared); List<Integer> nc = new ArrayList<Integer>(); nc.addAll(choices); List<Integer> nr = new ArrayList<Integer>(); nr.addAll(remaining); choose ( ns,nc, nr, K); // Spare it, call choose to pick one more spared.add(firstOfRemaining); choices.remove(new Integer(firstOfRemaining)); ns = new ArrayList<Integer>(); ns.addAll(spared); nc = new ArrayList<Integer>(); nc.addAll(choices); nr = new ArrayList<Integer>(); nr.addAll(remaining); choose ( ns,nc, nr, K); } public static void main(String[] args) { List<Integer> a = new ArrayList<Integer>(); for (int i = 1; i<=5 ; i++) { a.add(i); } choose (new ArrayList<Integer>(),new ArrayList<Integer>(), a,2); } }

package net.heteroclinic.experiment.lambdatest; import java.util.ArrayList; import java.util.List; /** * @author Zhikai Wang/www.heteroclinic.net * This class is an example/exercise to provide a code base to compute all k-combinations of a set. * Given third party license acknowledged and this header kept or quoted, you can utilize this program at will. */ public class ComputeAllKCombinationOfASet { // Print a List public static void printList (List<Integer> l) { for (int i:l) System.out.print(i+ " "); System.out.println(); } // Moving the elements frequently at random positions proves in-line array impractical. public static void choose ( List<Integer> spared, List<Integer> choices, List<Integer> remaining, int K) { // END conditions for the recursion // 1. The choices suffice // 2. The remaining choices do not allow more sparing // May check always. if ( choices.size() >= K ) { // Print choices printList (choices); return; } else if ( remaining.size() <= K - choices.size()) { // Print remaining + choices List<Integer> pl = new ArrayList<Integer>(); pl.addAll(choices); pl.addAll(remaining); printList (pl); return; } // For the first element of the remaining if ( remaining.size() <= 0) return; int firstOfRemaining = remaining.get(0); // Choose it, call choose to pick one more choices.add(firstOfRemaining); remaining.remove(new Integer(firstOfRemaining)); List<Integer> ns = new ArrayList<Integer>(); ns.addAll(spared); List<Integer> nc = new ArrayList<Integer>(); nc.addAll(choices); List<Integer> nr = new ArrayList<Integer>(); nr.addAll(remaining); choose ( ns,nc, nr, K); // Spare it, call choose to pick one more spared.add(firstOfRemaining); choices.remove(new Integer(firstOfRemaining)); ns = new ArrayList<Integer>(); ns.addAll(spared); nc = new ArrayList<Integer>(); nc.addAll(choices); nr = new ArrayList<Integer>(); nr.addAll(remaining); choose ( ns,nc, nr, K); } public static void computeAllKCombinationOfASet (List<Integer> l ) { for (int i = 0; i <=l.size(); i++) { List<Integer> b = new ArrayList<Integer>(); b.addAll(l); choose (new ArrayList<Integer>(),new ArrayList<Integer>(), b,i); } } public static void main(String[] args) { List<Integer> a = new ArrayList<Integer>(); for (int i = 1; i<=3 ; i++) { a.add(i); } computeAllKCombinationOfASet (a ); } }

package net.heteroclinic.experiment.lambdatest; import java.util.ArrayList; import java.util.List; /** * @author Zhikai Wang/www.heteroclinic.net * This class is an example/exercise to provide a code base to compute k-permutation of a set by permute k-combination. * Why we do this, it looks like subset operation destroy the permutation group. So guess the swap subgroup and one element is not reflective. * Given third party license acknowledged and this header kept or quoted, you can utilize this program at will. */ public class ComuteKPermutation { public static void perm(int[] a, int segmentLength) { if (segmentLength <= 1) { for (int i : a) System.out.print(i + " "); System.out.println(); return; } for (int i = segmentLength - 1; i >= 0; i--) { int tmp = a[segmentLength - 1]; a[segmentLength - 1] = a[i]; a[i] = tmp; perm(a, segmentLength - 1); tmp = a[segmentLength - 1]; a[segmentLength - 1] = a[i]; a[i] = tmp; } } // Moving the elements frequently at random positions proves in-line array impractical. public static void chooseForPermutation ( List<Integer> spared, List<Integer> choices, List<Integer> remaining, int K) { // END conditions for the recursion // 1. The choices suffice // 2. The remaining choices do not allow more sparing // May check always. if ( choices.size() >= K ) { // Permute choices int [] array = new int[choices.size()]; for (int i = 0; i< array.length; i++) { array[i] = choices.get(i); } perm(array, array.length); return; } else if ( remaining.size() <= K - choices.size()) { // Permute remaining + choices List<Integer> pl = new ArrayList<Integer>(); pl.addAll(choices); pl.addAll(remaining); // Permute pl int [] array = new int[pl.size()]; for (int i = 0; i< array.length; i++) { array[i] = pl.get(i); } perm(array, array.length); return; } // For the first element of the remaining if ( remaining.size() <= 0) return; int firstOfRemaining = remaining.get(0); // Choose it, call choose to pick one more choices.add(firstOfRemaining); remaining.remove(new Integer(firstOfRemaining)); List<Integer> ns = new ArrayList<Integer>(); ns.addAll(spared); List<Integer> nc = new ArrayList<Integer>(); nc.addAll(choices); List<Integer> nr = new ArrayList<Integer>(); nr.addAll(remaining); chooseForPermutation ( ns,nc, nr, K); // Spare it, call choose to pick one more spared.add(firstOfRemaining); choices.remove(new Integer(firstOfRemaining)); ns = new ArrayList<Integer>(); ns.addAll(spared); nc = new ArrayList<Integer>(); nc.addAll(choices); nr = new ArrayList<Integer>(); nr.addAll(remaining); chooseForPermutation ( ns,nc, nr, K); } public static void main(String[] args) { List<Integer> a = new ArrayList<Integer>(); for (int i = 1; i<=5 ; i++) { a.add(i); } chooseForPermutation (new ArrayList<Integer>(),new ArrayList<Integer>(), a,3); } }

package net.heteroclinic.experiment.lambdatest; /** * @author Zhikai Wang/www.heteroclinic.net * */ public class LambdaPermutation { public interface PrintArray { public boolean print (int[] a, int segmentLength); } public interface SwapArrayElements { public void swap (int [] a, int index1, int index2); } public interface Permutation { public void permute (int [] a,int segmentLength, PrintArray p,SwapArrayElements s); } public static void main(String[] args) { int []arr = new int[] { 1, 2 ,3}; //perm(a, a.length); PrintArray printArray = (a, b) -> new Object () { public boolean run (int[] a, int segmentLength ){for (int i : a) System.out.print(i + " "); return true;}}.run(a,b) && new Object () { public boolean feedLine () {System.out.println (); return true;}}.feedLine(); printArray.print(arr,3); System.out.println("Phase II"); SwapArrayElements swapElements = (a,i1,i2) ->new Object () { public void run (int [] a, int index1, int index2) {int tmp = a[i1]; a[i1] = a[i2]; a[i2]=tmp;}}.run(a, i1, i2); swapElements.swap(arr,0,2); printArray.print(arr,3); System.out.println("Phase III"); Permutation permutator = (a,b,c,d)-> new Object () { public void run (int [] a,int segmentLength, PrintArray p,SwapArrayElements s) { if (segmentLength <= 1) { p.print(a, a.length); return; }; for (int i = segmentLength - 1; i >= 0; i--) { s.swap(a,segmentLength - 1, i); run(a,segmentLength - 1,p,s); s.swap(a,segmentLength - 1, i); } }}.run(a, b, c,d); int []arr2 = new int[] { 1, 2 ,3}; permutator.permute(arr2, arr2.length, printArray ,swapElements); } }

package net.heteroclinic.experiment.lambdatest; import java.util.ArrayList; import java.util.List; /** * @author Zhikai Wang/www.heteroclinic.net * This class is an example/exercise to provide a code base to compute k-combinations of a set, using functional programming features. * Given third party license acknowledged and this header kept or quoted, you can utilize this program at will. * Juggling elements among: * [spared][selected][remaining] */ public class LambdaChooseSpareCombination { public interface ListPrintor { public boolean print (List<Integer> l, int segmentLength); } public interface Reeper { public boolean harvest(ListPrintor listPrintor, List<Integer> spared, List<Integer> choices, List<Integer> remaining, int K); } public interface KCombination { // Juggling elements among: [spared][selected][remaining] public void juggle ( Reeper r,ListPrintor listPrintor,List<Integer> spared, List<Integer> choices, List<Integer> remaining, int K); } public static void main(String[] args) { List<Integer> a = new ArrayList<Integer>(); for (int i = 1; i<=5 ; i++) { a.add(i); } ListPrintor lPrintor = (l,s)-> new Object () { public boolean run (List<Integer> l, int segmentLength) { for (int i:l) System.out.print(i+ " "); System.out.println(); return true; } }.run(l,s); Reeper reeper = (l,s,c,r,k) -> new Object () { public boolean run (ListPrintor listPrintor,List<Integer> spared, List<Integer> choices, List<Integer> remaining, int K ) { if ( choices.size() >= K ) { // Print choices listPrintor.print(choices,K); return true; } else if ( remaining.size() <= K - choices.size()) { // Print remaining + choices List<Integer> pl = new ArrayList<Integer>(); pl.addAll(choices); pl.addAll(remaining); listPrintor.print(pl,K); return true; } return false; } }.run(l,s,c,r,k); KCombination kComb = (r,p,s,c,m,k) -> new Object () { public void choose ( Reeper r,ListPrintor listPrintor,List<Integer> spared, List<Integer> choices, List<Integer> remaining, int K) { if (r.harvest(listPrintor, spared, choices, remaining, K)) return; // For the first element of the remaining if ( remaining.size() <= 0) return; int firstOfRemaining = remaining.get(0); // Choose it, call choose to pick one more choices.add(firstOfRemaining); remaining.remove(new Integer(firstOfRemaining)); List<Integer> ns = new ArrayList<Integer>(); ns.addAll(spared); List<Integer> nc = new ArrayList<Integer>(); nc.addAll(choices); List<Integer> nr = new ArrayList<Integer>(); nr.addAll(remaining); choose ( r, listPrintor,ns,nc, nr, K); // Spare it, call choose to pick one more spared.add(firstOfRemaining); choices.remove(new Integer(firstOfRemaining)); ns = new ArrayList<Integer>(); ns.addAll(spared); nc = new ArrayList<Integer>(); nc.addAll(choices); nr = new ArrayList<Integer>(); nr.addAll(remaining); choose ( r, listPrintor, ns,nc, nr, K); } }.choose(r,p,s,c,m,k); kComb.juggle(reeper, lPrintor, new ArrayList<Integer> (), new ArrayList<Integer> (),a, 3); } }

package net.heteroclinic.experiment.lambdatest; import java.util.ArrayList; import java.util.List; /** * @author Zhikai Wang/www.heteroclinic.net * This class is an example/exercise to provide a code base to compute all k-combinations of a set, plus Lambda FP. * Given third party license acknowledged and this header kept or quoted, you can utilize this program at will. */ public class LambdaAllKCombination { public interface ListPrintor { public boolean print (List<Integer> l, int segmentLength); } public interface Reeper { public boolean harvest(ListPrintor listPrintor, List<Integer> spared, List<Integer> choices, List<Integer> remaining, int K); } public interface KCombination { // Juggling elements among: [spared][selected][remaining] public void juggle ( Reeper r,ListPrintor listPrintor,List<Integer> spared, List<Integer> choices, List<Integer> remaining, int K); } public interface CombinatorAK { public void combAll(KCombination kComb, Reeper reeper, ListPrintor lPrintor, List<Integer> l); } public static ListPrintor lPrintor = (l,s)-> new Object () { public boolean run (List<Integer> l, int segmentLength) { for (int i:l) System.out.print(i+ " "); System.out.println(); return true; } }.run(l,s); public static Reeper reeper = (l,s,c,r,k) -> new Object () { public boolean run (ListPrintor listPrintor,List<Integer> spared, List<Integer> choices, List<Integer> remaining, int K ) { if ( choices.size() >= K ) { // Print choices listPrintor.print(choices,K); return true; } else if ( remaining.size() <= K - choices.size()) { // Print remaining + choices List<Integer> pl = new ArrayList<Integer>(); pl.addAll(choices); pl.addAll(remaining); listPrintor.print(pl,K); return true; } return false; } }.run(l,s,c,r,k); public static KCombination kComb = (r,p,s,c,m,k) -> new Object () { public void choose ( Reeper r,ListPrintor listPrintor,List<Integer> spared, List<Integer> choices, List<Integer> remaining, int K) { if (r.harvest(listPrintor, spared, choices, remaining, K)) return; // For the first element of the remaining if ( remaining.size() <= 0) return; int firstOfRemaining = remaining.get(0); // Choose it, call choose to pick one more choices.add(firstOfRemaining); remaining.remove(new Integer(firstOfRemaining)); List<Integer> ns = new ArrayList<Integer>(); ns.addAll(spared); List<Integer> nc = new ArrayList<Integer>(); nc.addAll(choices); List<Integer> nr = new ArrayList<Integer>(); nr.addAll(remaining); choose ( r, listPrintor,ns,nc, nr, K); // Spare it, call choose to pick one more spared.add(firstOfRemaining); choices.remove(new Integer(firstOfRemaining)); ns = new ArrayList<Integer>(); ns.addAll(spared); nc = new ArrayList<Integer>(); nc.addAll(choices); nr = new ArrayList<Integer>(); nr.addAll(remaining); choose ( r, listPrintor, ns,nc, nr, K); } }.choose(r,p,s,c,m,k); public static void main(String[] args) { List<Integer> a = new ArrayList<Integer>(); for (int i = 1; i<=5 ; i++) { a.add(i); } CombinatorAK cak = (k,r,p,l)-> new Object () { public void run(KCombination kComb, Reeper reeper, ListPrintor lPrintor, List<Integer> l) { for (int i = 0; i <=l.size(); i++) { List<Integer> b = new ArrayList<Integer>(); b.addAll(l); kComb.juggle(reeper, lPrintor, new ArrayList<Integer> (), new ArrayList<Integer> (),b,i ); } } }.run(k,r,p,l); cak.combAll(kComb, reeper, lPrintor, a); } }

package net.heteroclinic.experiment.lambdatest; import java.util.ArrayList; import java.util.List; /** * @author Zhikai Wang/www.heteroclinic.net * This class is an example/exercise to provide a code base to compute k-permutation of a set by permute k-combination, using Lambda FP. * Why we do this, it looks like subset operation destroy the permutation group. So guess the swap subgroup and one element is not reflective. * Given third party license acknowledged and this header kept or quoted, you can utilize this program at will. */ public class LambdaKPermutation { public interface PrintArray { public boolean print (int[] a, int segmentLength); } public interface SwapArrayElements { public void swap (int [] a, int index1, int index2); } public interface Permutation { public void permute (int [] a,int segmentLength, SwapArrayElements s,PrintArray printor); } static public SwapArrayElements swapElements = (a,i1,i2) ->new Object () { public void run (int [] a, int index1, int index2) {int tmp = a[i1]; a[i1] = a[i2]; a[i2]=tmp;}}.run(a, i1, i2); static public Permutation permutator = (a,b,c,p)-> new Object () { public void run (int [] a,int segmentLength, SwapArrayElements s,PrintArray p) { if (segmentLength <= 1) { p.print(a, segmentLength); return; }; for (int i = segmentLength - 1; i >= 0; i--) { s.swap(a,segmentLength - 1, i); run(a,segmentLength - 1,s,p); s.swap(a,segmentLength - 1, i); } } }.run(a, b, c,p); static public PrintArray printArray = (a, b) -> new Object () { public boolean run (int[] a, int segmentLength ){for (int i : a) System.out.print(i + " "); return true;}}.run(a,b) && new Object () { public boolean feedLine () {System.out.println (); return true;}}.feedLine(); public interface ListPrintor { public boolean print (List<Integer> l, int segmentLength); } public interface Reeper { public List<Integer> harvest(List<Integer> spared, List<Integer> choices, List<Integer> remaining, int K,PrintArray p); } public interface KPermutator { public void permuteJuggle ( Reeper r,List<Integer> spared, List<Integer> choices, List<Integer> remaining, int K,PrintArray p,Permutation permutator,SwapArrayElements swapElements); } public static Reeper reeper = (s,c,r,k,p) -> new Object () { public List<Integer> run (List<Integer> spared, List<Integer> choices, List<Integer> remaining, int K,PrintArray p ) { if ( choices.size() >= K ) { return new ArrayList<Integer> ( choices); } else if ( remaining.size() <= K - choices.size()) { List<Integer> pl = new ArrayList<Integer>(); pl.addAll(choices); pl.addAll(remaining); return pl; } return null; } }.run(s,c,r,k,p); public static KPermutator kPerm = (r,s,c,m,k,p,t,w) -> new Object () { public void choose ( Reeper r,List<Integer> spared, List<Integer> choices, List<Integer> remaining, int K,PrintArray p,Permutation permutator,SwapArrayElements swapElements) { List<Integer> l; if ( (l = r.harvest( spared, choices, remaining, K,p))!= null) { int [] array = new int[l.size()]; for (int i = 0; i< array.length; i++) { array[i] = l.get(i); } // TODO permutator. permute ( array,array.length, swapElements, p); //p.print (array, array.length); return; } // For the first element of the remaining if ( remaining.size() <= 0) return; int firstOfRemaining = remaining.get(0); // Choose it, call choose to pick one more choices.add(firstOfRemaining); remaining.remove(new Integer(firstOfRemaining)); List<Integer> ns = new ArrayList<Integer>(); ns.addAll(spared); List<Integer> nc = new ArrayList<Integer>(); nc.addAll(choices); List<Integer> nr = new ArrayList<Integer>(); nr.addAll(remaining); choose ( r,ns,nc, nr, K,p,t,swapElements); // Spare it, call choose to pick one more spared.add(firstOfRemaining); choices.remove(new Integer(firstOfRemaining)); ns = new ArrayList<Integer>(); ns.addAll(spared); nc = new ArrayList<Integer>(); nc.addAll(choices); nr = new ArrayList<Integer>(); nr.addAll(remaining); choose ( r, ns,nc, nr, K,p,t,swapElements); } }.choose(r,s,c,m,k,p,t,w); public static void main(String[] args) { List<Integer> a = new ArrayList<Integer>(); for (int i = 1; i<=5 ; i++) { a.add(i); } kPerm.permuteJuggle(reeper, new ArrayList<Integer>(), new ArrayList<Integer>(), a, 3, printArray,permutator,swapElements); } }