Mekanism-tilera-Edition/src/main/java/mekanism/api/util/ListUtils.java

package mekanism.api.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;

public class ListUtils {
    public static <V> List<V> inverse(List<V> list) {
        List<V> toReturn = new ArrayList<V>();

        for (int i = list.size() - 1; i >= 0; i--) {
            toReturn.add(list.get(i));
        }

        return toReturn;
    }

    public static <V> List<V> cap(List<V> list, int cap) {
        List<V> toReturn = new ArrayList<V>();

        if (list.size() <= cap) {
            toReturn = copy(list);
        } else {
            int count = 0;

            for (V obj : list) {
                count++;

                toReturn.add(obj);

                if (count == cap) {
                    break;
                }
            }
        }

        return toReturn;
    }

    public static <V> List<V> copy(List<V> list) {
        List<V> toReturn = new ArrayList<V>();

        for (V obj : list) {
            toReturn.add(obj);
        }

        return toReturn;
    }

    public static <V> List<V> merge(List<V> listOne, List<V> listTwo) {
        List<V> newList = new ArrayList<V>();

        for (V obj : listOne) {
            newList.add(obj);
        }

        for (V obj : listTwo) {
            newList.add(obj);
        }

        return newList;
    }

    public static <V> List<V> capRemains(List<V> list, int cap) {
        List<V> toReturn = new ArrayList<V>();

        if (list.size() <= cap) {
            return toReturn;
        } else {
            List<V> inverse = inverse(list);

            int iterNeeded = list.size() - cap;
            int count = 0;

            for (V obj : list) {
                count++;

                toReturn.add(obj);

                if (count == iterNeeded) {
                    break;
                }
            }

            return toReturn;
        }
    }

    public static <V> ArrayList<List<V>> split(List<V> list, int divide) {
        int remain = list.size() % divide;
        int size = (list.size() - remain) / divide;

        ArrayList<List<V>> toReturn = new ArrayList<List<V>>();

        for (int i = 0; i < divide; i++) {
            toReturn.add(i, new ArrayList<V>());
        }

        for (List<V> iterSet : toReturn) {
            List<V> removed = new ArrayList<V>();

            int toAdd = size;

            if (remain > 0) {
                remain--;
                toAdd++;
            }

            for (V obj : list) {
                if (toAdd == 0) {
                    break;
                }

                iterSet.add(obj);
                removed.add(obj);
                toAdd--;
            }

            for (V obj : removed) {
                list.remove(obj);
            }
        }

        return toReturn;
    }

    public static <V> V getTop(List<V> list) {
        for (V obj : list) {
            return obj;
        }

        return null;
    }

    public static <V> List<V> asList(Set<V> set) {
        return (List<V>) Arrays.asList(set.toArray());
    }

    public static <V> List<V> asList(V... values) {
        return (List<V>) Arrays.asList(values);
    }

    public static double[] splitDouble(int size, double num) {
        double[] split = new double[size];

        for (int i = 0; i < size; i++) {
            double remain = num % size;
            double ret = (num - remain) / size;
            ret += remain;

            split[i] = ret;
            num -= remain;
        }

        return split;
    }

    public static double[] percent(double[] values) {
        double[] ret = new double[values.length];
        double total = 0;

        for (double d : values)
            total += d;

        for (int i = 0; i < values.length; i++) {
            ret[i] = values[i] / total;
        }

        return ret;
    }

    public static int[] calcPercentInt(double[] percent, int val) {
        int[] ret = new int[percent.length];

        for (int i = 0; i < percent.length; i++) {
            ret[i] = (int) Math.round(val * percent[i]);
        }

        int newTotal = 0;
        for (int i : ret)
            newTotal += i;

        int diff = val - newTotal;

        if (diff != val) {
            for (int i = 0; i < ret.length; i++) {
                int num = ret[i];

                if (diff < 0 && num == 0) {
                    continue;
                }

                if (diff > 0) {
                    ret[i]++;
                    diff--;
                } else if (diff < 0) {
                    ret[i]--;
                    diff++;
                }

                if (diff == 0) {
                    return ret;
                }
            }
        }

        return ret;
    }

    public static int[] splitInt(int size, int num) {
        int[] split = new int[size];

        for (int i = 0; i < size; i++) {
            int remain = num % size;
            int ret = (num - remain) / size;
            ret += remain;

            split[i] = ret;
            num -= remain;
        }

        return split;
    }

    public static double[] percent(int[] values) {
        double[] ret = new double[values.length];
        double total = 0;

        for (double d : values)
            total += d;

        for (int i = 0; i < values.length; i++) {
            ret[i] = values[i] / total;
        }

        return ret;
    }
}