diff options
Diffstat (limited to 'BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java')
| -rw-r--r-- | BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java | 326 |
1 files changed, 163 insertions, 163 deletions
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java index b0c30b3..ea15a78 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java @@ -21,119 +21,51 @@ public class ListUtils { private static final int MAX_NTRIESPART = 50; /** - * Partition a list into a list of lists, where each element can count - * for more than one element in a partition - * - * @param <E> - * The type of elements in the list to partition + * Collapse a string of tokens into a single string without adding any + * spaces * * @param input - * The list to partition - * @param elementCounter - * The function to determine the count for each element for - * @param numberPerPartition - * The number of elements to put in each partition - * @return A list partitioned according to the above rules + * The list of tokens to collapse + * @return The collapsed string of tokens */ - public static <E> IFunctionalList<IFunctionalList<E>> groupPartition( - IFunctionalList<E> input, Function<E, Integer> elementCounter, - int numberPerPartition) { + public static String collapseTokens(IFunctionalList<String> input) { if (input == null) { - throw new NullPointerException("Input list must not be null"); - } else if (elementCounter == null) { - throw new NullPointerException("Counter must not be null"); - } else if (numberPerPartition < 1 - || numberPerPartition > input.getSize()) { - throw new IllegalArgumentException( - "" + numberPerPartition + " is not a valid" - + " partition size. Must be between 1 and " - + input.getSize()); - } - - /* - * List that holds our results - */ - IFunctionalList<IFunctionalList<E>> returnedList = new FunctionalList<>(); - - /* - * List that holds current partition - */ - IHolder<IFunctionalList<E>> currentPartition = new Identity<>( - new FunctionalList<>()); - /* - * List that holds elements rejected during current pass - */ - IFunctionalList<E> rejectedElements = new FunctionalList<>(); - - /* - * The effective number of elements in the current partitition - */ - IHolder<Integer> numberInCurrentPartition = new Identity<>(0); - - /* - * Run up to a certain number of passes - */ - for (int numberOfIterations = 0; numberOfIterations < MAX_NTRIESPART - && !rejectedElements.isEmpty(); numberOfIterations++) { - input.forEach(new GroupPartIteration<>(returnedList, - currentPartition, rejectedElements, - numberInCurrentPartition, numberPerPartition, - elementCounter)); - - if (rejectedElements.isEmpty()) { - // Nothing was rejected, so we're done - return returnedList; - } + throw new NullPointerException("Input must not be null"); } - throw new IllegalArgumentException( - "Heuristic (more than " + MAX_NTRIESPART - + " iterations of partitioning) detected unpartitionable list " - + input.toString() - + "\nThe following elements were not partitioned: " - + rejectedElements.toString() - + "\nCurrent group in formation: " - + currentPartition.unwrap((vl) -> vl.toString()) - + "\nPreviously formed groups: " - + returnedList.toString()); + return collapseTokens(input, ""); } /** - * Split tokens in a list of tokens into multiple tokens. - * - * The intended use is for expression parsers so that you can enter - * something like 1+1 instead of 1 + 1. + * Collapse a string of tokens into a single string, adding the desired + * seperator after each token * * @param input - * The tokens to split - * @param operators - * Pairs of operators to split on and regexes that match - * those operators - * @return A list of tokens split on all the operators - * + * The list of tokens to collapse + * @param seperator + * The seperator to use for seperating tokens + * @return The collapsed string of tokens */ - public static IFunctionalList<String> splitTokens( - IFunctionalList<String> input, - Deque<IPair<String, String>> operators) { + public static String collapseTokens(IFunctionalList<String> input, + String seperator) { if (input == null) { throw new NullPointerException("Input must not be null"); - } else if (operators == null) { - throw new NullPointerException( - "Set of operators must not be null"); + } else if (seperator == null) { + throw new NullPointerException("Seperator must not be null"); } - IHolder<IFunctionalList<String>> returnedList = new Identity<>( - input); - - operators.forEach((operator) -> { - returnedList.transform((oldReturn) -> { - return oldReturn.flatMap((token) -> { - return operator.merge(new TokenSplitter(token)); - }); + if (input.getSize() < 1) { + return ""; + } else if (input.getSize() == 1) { + return input.first(); + } else { + return input.reduceAux("", (currentString, state) -> { + return state + currentString + seperator; + }, (strang) -> { + return strang.substring(0, + strang.length() - seperator.length()); }); - }); - - return returnedList.getValue(); + } } /** @@ -168,51 +100,42 @@ public class ListUtils { } /** - * Collapse a string of tokens into a single string without adding any - * spaces + * Select a number of random items from the list without replacement * - * @param input - * The list of tokens to collapse - * @return The collapsed string of tokens + * @param <E> + * The type of items to select + * @param list + * The list to select from + * @param numberOfItems + * The number of items to selet + * @param rng + * A function that creates a random number from 0 to the + * desired number + * @return A new list containing the desired number of items randomly + * selected from the specified list without replacement */ - public static String collapseTokens(IFunctionalList<String> input) { - if (input == null) { - throw new NullPointerException("Input must not be null"); - } - return collapseTokens(input, ""); - } + public static <E> IFunctionalList<E> drawWithoutReplacement( + IFunctionalList<E> list, int numberOfItems, + Function<Integer, Integer> rng) { + IFunctionalList<E> selectedItems = new FunctionalList<>( + new ArrayList<>(numberOfItems)); - /** - * Collapse a string of tokens into a single string, adding the desired - * seperator after each token - * - * @param input - * The list of tokens to collapse - * @param seperator - * The seperator to use for seperating tokens - * @return The collapsed string of tokens - */ - public static String collapseTokens(IFunctionalList<String> input, - String seperator) { - if (input == null) { - throw new NullPointerException("Input must not be null"); - } else if (seperator == null) { - throw new NullPointerException("Seperator must not be null"); - } + int totalItems = list.getSize(); - if (input.getSize() < 1) { - return ""; - } else if (input.getSize() == 1) { - return input.first(); - } else { - return input.reduceAux("", (currentString, state) -> { - return state + currentString + seperator; - }, (strang) -> { - return strang.substring(0, - strang.length() - seperator.length()); - }); - } + list.forEachIndexed((index, element) -> { + int winningChance = numberOfItems - selectedItems.getSize(); + // n - m + int totalChance = totalItems - (index - 1); + // N - t + + // Probability of selecting the t+1'th element + if (NumberUtils.isProbable(winningChance, totalChance, rng)) { + selectedItems.add(element); + } + }); + + return selectedItems; } /** @@ -244,42 +167,81 @@ public class ListUtils { } /** - * Select a number of random items from the list without replacement + * Partition a list into a list of lists, where each element can count + * for more than one element in a partition * * @param <E> - * The type of items to select - * @param list - * The list to select from - * @param numberOfItems - * The number of items to selet - * @param rng - * A function that creates a random number from 0 to the - * desired number - * @return A new list containing the desired number of items randomly - * selected from the specified list without replacement + * The type of elements in the list to partition + * + * @param input + * The list to partition + * @param elementCounter + * The function to determine the count for each element for + * @param numberPerPartition + * The number of elements to put in each partition + * @return A list partitioned according to the above rules */ + public static <E> IFunctionalList<IFunctionalList<E>> groupPartition( + IFunctionalList<E> input, Function<E, Integer> elementCounter, + int numberPerPartition) { + if (input == null) { + throw new NullPointerException("Input list must not be null"); + } else if (elementCounter == null) { + throw new NullPointerException("Counter must not be null"); + } else if (numberPerPartition < 1 + || numberPerPartition > input.getSize()) { + throw new IllegalArgumentException( + "" + numberPerPartition + " is not a valid" + + " partition size. Must be between 1 and " + + input.getSize()); + } - public static <E> IFunctionalList<E> drawWithoutReplacement( - IFunctionalList<E> list, int numberOfItems, - Function<Integer, Integer> rng) { - IFunctionalList<E> selectedItems = new FunctionalList<>( - new ArrayList<>(numberOfItems)); + /* + * List that holds our results + */ + IFunctionalList<IFunctionalList<E>> returnedList = new FunctionalList<>(); - int totalItems = list.getSize(); + /* + * List that holds current partition + */ + IHolder<IFunctionalList<E>> currentPartition = new Identity<>( + new FunctionalList<>()); + /* + * List that holds elements rejected during current pass + */ + IFunctionalList<E> rejectedElements = new FunctionalList<>(); - list.forEachIndexed((index, element) -> { - int winningChance = numberOfItems - selectedItems.getSize(); - // n - m - int totalChance = totalItems - (index - 1); - // N - t + /* + * The effective number of elements in the current partitition + */ + IHolder<Integer> numberInCurrentPartition = new Identity<>(0); - // Probability of selecting the t+1'th element - if (NumberUtils.isProbable(winningChance, totalChance, rng)) { - selectedItems.add(element); + /* + * Run up to a certain number of passes + */ + for (int numberOfIterations = 0; numberOfIterations < MAX_NTRIESPART + && !rejectedElements.isEmpty(); numberOfIterations++) { + input.forEach(new GroupPartIteration<>(returnedList, + currentPartition, rejectedElements, + numberInCurrentPartition, numberPerPartition, + elementCounter)); + + if (rejectedElements.isEmpty()) { + // Nothing was rejected, so we're done + return returnedList; } - }); + } - return selectedItems; + throw new IllegalArgumentException( + "Heuristic (more than " + MAX_NTRIESPART + + " iterations of partitioning) detected unpartitionable list " + + input.toString() + + "\nThe following elements were not partitioned: " + + rejectedElements.toString() + + "\nCurrent group in formation: " + + currentPartition.unwrap((vl) -> vl.toString()) + + "\nPreviously formed groups: " + + returnedList.toString()); } /** @@ -302,4 +264,42 @@ public class ListUtils { return returnedList; } + + /** + * Split tokens in a list of tokens into multiple tokens. + * + * The intended use is for expression parsers so that you can enter + * something like 1+1 instead of 1 + 1. + * + * @param input + * The tokens to split + * @param operators + * Pairs of operators to split on and regexes that match + * those operators + * @return A list of tokens split on all the operators + * + */ + public static IFunctionalList<String> splitTokens( + IFunctionalList<String> input, + Deque<IPair<String, String>> operators) { + if (input == null) { + throw new NullPointerException("Input must not be null"); + } else if (operators == null) { + throw new NullPointerException( + "Set of operators must not be null"); + } + + IHolder<IFunctionalList<String>> returnedList = new Identity<>( + input); + + operators.forEach((operator) -> { + returnedList.transform((oldReturn) -> { + return oldReturn.flatMap((token) -> { + return operator.merge(new TokenSplitter(token)); + }); + }); + }); + + return returnedList.getValue(); + } }
\ No newline at end of file |