edu.emory.mathcs.backport.java.util.Arrays Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of virtdata-lib-curves4 Show documentation
Show all versions of virtdata-lib-curves4 Show documentation
Statistical sampling library for use in virtdata libraries, based
on apache commons math 4
/*
* Written by Dawid Kurzyniec, based on code written by Doug Lea with assistance
* from members of JCP JSR-166 Expert Group. Released to the public domain,
* as explained at http://creativecommons.org/licenses/publicdomain.
*/
package edu.emory.mathcs.backport.java.util;
import java.lang.reflect.Array;
import java.util.List;
import java.util.ArrayList;
import java.util.Comparator;
public class Arrays {
private Arrays() {}
public static void sort(long[] a) {
java.util.Arrays.sort(a);
}
public static void sort(long[] a, int fromIndex, int toIndex) {
java.util.Arrays.sort(a, fromIndex, toIndex);
}
public static void sort(int[] a) {
java.util.Arrays.sort(a);
}
public static void sort(int[] a, int fromIndex, int toIndex) {
java.util.Arrays.sort(a, fromIndex, toIndex);
}
public static void sort(short[] a) {
java.util.Arrays.sort(a);
}
public static void sort(short[] a, int fromIndex, int toIndex) {
java.util.Arrays.sort(a, fromIndex, toIndex);
}
public static void sort(char[] a) {
java.util.Arrays.sort(a);
}
public static void sort(char[] a, int fromIndex, int toIndex) {
java.util.Arrays.sort(a, fromIndex, toIndex);
}
public static void sort(byte[] a) {
java.util.Arrays.sort(a);
}
public static void sort(byte[] a, int fromIndex, int toIndex) {
java.util.Arrays.sort(a, fromIndex, toIndex);
}
public static void sort(double[] a) {
java.util.Arrays.sort(a);
}
public static void sort(double[] a, int fromIndex, int toIndex) {
java.util.Arrays.sort(a, fromIndex, toIndex);
}
public static void sort(float[] a) {
java.util.Arrays.sort(a);
}
public static void sort(float[] a, int fromIndex, int toIndex) {
java.util.Arrays.sort(a, fromIndex, toIndex);
}
public static void sort(Object[] a) {
java.util.Arrays.sort(a);
}
public static void sort(Object[] a, int fromIndex, int toIndex) {
java.util.Arrays.sort(a, fromIndex, toIndex);
}
public static void sort(Object[] a, Comparator c) {
java.util.Arrays.sort(a, c);
}
public static void sort(Object[] a, int fromIndex, int toIndex, Comparator c) {
java.util.Arrays.sort(a, fromIndex, toIndex, c);
}
// Searching
public static int binarySearch(long[] a, long key) {
return java.util.Arrays.binarySearch(a, key);
}
public static int binarySearch(int[] a, int key) {
return java.util.Arrays.binarySearch(a, key);
}
public static int binarySearch(short[] a, short key) {
return java.util.Arrays.binarySearch(a, key);
}
public static int binarySearch(char[] a, char key) {
return java.util.Arrays.binarySearch(a, key);
}
public static int binarySearch(byte[] a, byte key) {
return java.util.Arrays.binarySearch(a, key);
}
public static int binarySearch(double[] a, double key) {
return java.util.Arrays.binarySearch(a, key);
}
public static int binarySearch(float[] a, float key) {
return java.util.Arrays.binarySearch(a, key);
}
public static int binarySearch(Object[] a, Object key) {
return java.util.Arrays.binarySearch(a, key);
}
public static int binarySearch(Object[] a, Object key, Comparator c) {
return java.util.Arrays.binarySearch(a, key, c);
}
// Equality Testing
public static boolean equals(long[] a, long[] a2) {
return java.util.Arrays.equals(a, a2);
}
public static boolean equals(int[] a, int[] a2) {
return java.util.Arrays.equals(a, a2);
}
public static boolean equals(short[] a, short a2[]) {
return java.util.Arrays.equals(a, a2);
}
public static boolean equals(char[] a, char[] a2) {
return java.util.Arrays.equals(a, a2);
}
public static boolean equals(byte[] a, byte[] a2) {
return java.util.Arrays.equals(a, a2);
}
public static boolean equals(boolean[] a, boolean[] a2) {
return java.util.Arrays.equals(a, a2);
}
public static boolean equals(double[] a, double[] a2) {
return java.util.Arrays.equals(a, a2);
}
public static boolean equals(float[] a, float[] a2) {
return java.util.Arrays.equals(a, a2);
}
public static boolean equals(Object[] a, Object[] a2) {
return java.util.Arrays.equals(a, a2);
}
// Filling
public static void fill(long[] a, long val) {
java.util.Arrays.fill(a, val);
}
public static void fill(long[] a, int fromIndex, int toIndex, long val) {
java.util.Arrays.fill(a, fromIndex, toIndex, val);
}
public static void fill(int[] a, int val) {
java.util.Arrays.fill(a, val);
}
public static void fill(int[] a, int fromIndex, int toIndex, int val) {
java.util.Arrays.fill(a, fromIndex, toIndex, val);
}
public static void fill(short[] a, short val) {
java.util.Arrays.fill(a, val);
}
public static void fill(short[] a, int fromIndex, int toIndex, short val) {
java.util.Arrays.fill(a, fromIndex, toIndex, val);
}
public static void fill(char[] a, char val) {
java.util.Arrays.fill(a, val);
}
public static void fill(char[] a, int fromIndex, int toIndex, char val) {
java.util.Arrays.fill(a, fromIndex, toIndex, val);
}
public static void fill(byte[] a, byte val) {
java.util.Arrays.fill(a, val);
}
public static void fill(byte[] a, int fromIndex, int toIndex, byte val) {
java.util.Arrays.fill(a, fromIndex, toIndex, val);
}
public static void fill(boolean[] a, boolean val) {
java.util.Arrays.fill(a, val);
}
public static void fill(boolean[] a, int fromIndex, int toIndex,
boolean val) {
java.util.Arrays.fill(a, fromIndex, toIndex, val);
}
public static void fill(double[] a, double val) {
java.util.Arrays.fill(a, val);
}
public static void fill(double[] a, int fromIndex, int toIndex,double val) {
java.util.Arrays.fill(a, fromIndex, toIndex, val);
}
public static void fill(float[] a, float val) {
java.util.Arrays.fill(a, val);
}
public static void fill(float[] a, int fromIndex, int toIndex, float val) {
java.util.Arrays.fill(a, fromIndex, toIndex, val);
}
public static void fill(Object[] a, Object val) {
java.util.Arrays.fill(a, val);
}
public static void fill(Object[] a, int fromIndex, int toIndex, Object val) {
java.util.Arrays.fill(a, fromIndex, toIndex, val);
}
// Cloning
/**
* @since 1.6
*/
public static Object[] copyOf(Object[] original, int newLength) {
return copyOf(original, newLength, original.getClass());
}
/**
* @since 1.6
*/
public static Object[] copyOf(Object[] original, int newLength, Class newType) {
Object[] arr = (newType == Object[].class) ? new Object[newLength] :
(Object[])Array.newInstance(newType.getComponentType(), newLength);
int len = (original.length < newLength ? original.length : newLength);
System.arraycopy(original, 0, arr, 0, len);
return arr;
}
/**
* @since 1.6
*/
public static byte[] copyOf(byte[] original, int newLength) {
byte[] arr = new byte[newLength];
int len = (original.length < newLength ? original.length : newLength);
System.arraycopy(original, 0, arr, 0, len);
return arr;
}
/**
* @since 1.6
*/
public static short[] copyOf(short[] original, int newLength) {
short[] arr = new short[newLength];
int len = (original.length < newLength ? original.length : newLength);
System.arraycopy(original, 0, arr, 0, len);
return arr;
}
/**
* @since 1.6
*/
public static int[] copyOf(int[] original, int newLength) {
int[] arr = new int[newLength];
int len = (original.length < newLength ? original.length : newLength);
System.arraycopy(original, 0, arr, 0, len);
return arr;
}
/**
* @since 1.6
*/
public static long[] copyOf(long[] original, int newLength) {
long[] arr = new long[newLength];
int len = (original.length < newLength ? original.length : newLength);
System.arraycopy(original, 0, arr, 0, len);
return arr;
}
/**
* @since 1.6
*/
public static char[] copyOf(char[] original, int newLength) {
char[] arr = new char[newLength];
int len = (original.length < newLength ? original.length : newLength);
System.arraycopy(original, 0, arr, 0, len);
return arr;
}
/**
* @since 1.6
*/
public static float[] copyOf(float[] original, int newLength) {
float[] arr = new float[newLength];
int len = (original.length < newLength ? original.length : newLength);
System.arraycopy(original, 0, arr, 0, len);
return arr;
}
/**
* @since 1.6
*/
public static double[] copyOf(double[] original, int newLength) {
double[] arr = new double[newLength];
int len = (original.length < newLength ? original.length : newLength);
System.arraycopy(original, 0, arr, 0, len);
return arr;
}
/**
* @since 1.6
*/
public static boolean[] copyOf(boolean[] original, int newLength) {
boolean[] arr = new boolean[newLength];
int len = (original.length < newLength ? original.length : newLength);
System.arraycopy(original, 0, arr, 0, len);
return arr;
}
/**
* @since 1.6
*/
public static Object[] copyOfRange(Object[] original, int from, int to) {
return copyOfRange(original, from, to, original.getClass());
}
/**
* @since 1.6
*/
public static Object[] copyOfRange(Object[] original, int from, int to, Class newType) {
int newLength = to - from;
if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
Object[] arr = (newType == Object[].class) ? new Object[newLength] :
(Object[])Array.newInstance(newType.getComponentType(), newLength);
int ceil = original.length-from;
int len = (ceil < newLength) ? ceil : newLength;
System.arraycopy(original, from, arr, 0, len);
return arr;
}
/**
* @since 1.6
*/
public static byte[] copyOfRange(byte[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
byte[] arr = new byte[newLength];
int ceil = original.length-from;
int len = (ceil < newLength) ? ceil : newLength;
System.arraycopy(original, from, arr, 0, len);
return arr;
}
/**
* @since 1.6
*/
public static short[] copyOfRange(short[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
short[] arr = new short[newLength];
int ceil = original.length-from;
int len = (ceil < newLength) ? ceil : newLength;
System.arraycopy(original, from, arr, 0, len);
return arr;
}
/**
* @since 1.6
*/
public static int[] copyOfRange(int[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
int[] arr = new int[newLength];
int ceil = original.length-from;
int len = (ceil < newLength) ? ceil : newLength;
System.arraycopy(original, from, arr, 0, len);
return arr;
}
/**
* @since 1.6
*/
public static long[] copyOfRange(long[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
long[] arr = new long[newLength];
int ceil = original.length-from;
int len = (ceil < newLength) ? ceil : newLength;
System.arraycopy(original, from, arr, 0, len);
return arr;
}
/**
* @since 1.6
*/
public static char[] copyOfRange(char[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
char[] arr = new char[newLength];
int ceil = original.length-from;
int len = (ceil < newLength) ? ceil : newLength;
System.arraycopy(original, from, arr, 0, len);
return arr;
}
/**
* @since 1.6
*/
public static float[] copyOfRange(float[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
float[] arr = new float[newLength];
int ceil = original.length-from;
int len = (ceil < newLength) ? ceil : newLength;
System.arraycopy(original, from, arr, 0, len);
return arr;
}
/**
* @since 1.6
*/
public static double[] copyOfRange(double[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
double[] arr = new double[newLength];
int ceil = original.length-from;
int len = (ceil < newLength) ? ceil : newLength;
System.arraycopy(original, from, arr, 0, len);
return arr;
}
/**
* @since 1.6
*/
public static boolean[] copyOfRange(boolean[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
boolean[] arr = new boolean[newLength];
int ceil = original.length-from;
int len = (ceil < newLength) ? ceil : newLength;
System.arraycopy(original, from, arr, 0, len);
return arr;
}
public static List asList(Object[] a) {
return java.util.Arrays.asList(a);
}
/**
* @since 1.5
*/
public static int hashCode(long a[]) {
if (a == null) return 0;
int hash = 1;
for (int i=0; i>> 32));
}
return hash;
}
/**
* @since 1.5
*/
public static int hashCode(int a[]) {
if (a == null) return 0;
int hash = 1;
for (int i=0; i>> 32));
}
return hash;
}
/**
* @since 1.5
*/
public static int hashCode(Object a[]) {
if (a == null) return 0;
int hash = 1;
for (int i=0; i0) buf.append(", ");
Object e = a[i];
if (e == null) {
buf.append("null");
}
else if (!e.getClass().isArray()) {
buf.append(e.toString());
}
else if (e instanceof Object[]) {
if (seen.contains(e)) buf.append("[...]");
else deepToString((Object[])e, buf, seen);
}
else {
// primitive arr
buf.append(
(e instanceof byte[]) ? toString( (byte[]) e) :
(e instanceof short[]) ? toString( (short[]) e) :
(e instanceof int[]) ? toString( (int[]) e) :
(e instanceof long[]) ? toString( (long[]) e) :
(e instanceof char[]) ? toString( (char[]) e) :
(e instanceof boolean[]) ? toString( (boolean[]) e) :
(e instanceof float[]) ? toString( (float[]) e) :
(e instanceof double[]) ? toString( (double[]) e) : "");
}
}
buf.append(']');
seen.remove(seen.size()-1);
}
}