public static boolean equalsWithinOneSmallUlp(double a, double b) {
double ulp_a = Math.ulp(a);
double ulp_b = Math.ulp(b);
double small_ulp = Math.min(ulp_a, ulp_b);
double absdiff_a_b = Math.abs(a - b); // subtraction order does not matter, due to IEEE 754 spec
return absdiff_a_b <= small_ulp;
}
// pretty print Matrix(2D array of doubles)
public static String pprint(double[][] arr,DecimalFormat dformat) {
int colDim = 0;
for( double[] line : arr )
colDim = Math.max(colDim, line.length);
StringBuilder sb = new StringBuilder();
int max_width = 0;
int[] ilengths = new int[colDim];
Arrays.fill(ilengths, -1);
for( double[] line : arr ) {
for( int c = 0; c < line.length; ++c ) {
double d = line[c];
String dStr = dformat.format(d);
if( dStr.indexOf('.') == -1 ) dStr += ".0";
ilengths[c] = Math.max(ilengths[c], dStr.indexOf('.'));
int prefix = (d >= 0 ? 1 : 2);
max_width = Math.max(dStr.length() + prefix, max_width);
}
}
for( double[] line : arr ) {
for( int c = 0; c < line.length; ++c ) {
double d = line[c];
String dStr = dformat.format(d);
if( dStr.indexOf('.') == -1 ) dStr += ".0";
for( int x = dStr.indexOf('.'); x < ilengths[c] + 1; ++x )
sb.append(' ');
sb.append(dStr);
if( dStr.indexOf('.') == -1 ) sb.append('.');
for( int i = dStr.length() - Math.max(0, dStr.indexOf('.')); i <= 5; ++i )
sb.append('0');
}
sb.append("\n");
}
return sb.toString();
}
/*
* Compute entropy value for an array of bytes.
*
* The returned number represents entropy per bit!
* For good long number seed (8bytes seed) it should be in range <2.75,3> (higher is better)
*
* For large set of bytes (>100) it should be almost 8 (means almost 8 random bits per byte).
*/
public static float entropy(byte[] f) {
int counts[] = new int[256];
float entropy = 0;
float total = f.length;
for (byte b : f) counts[b+128]++;
for (int c : counts) {
if (c == 0) continue;
float p = c / total;
/* Compute entropy per bit in byte.
*
* To compute entropy per byte compute log with base 256 = log(p)/log(256).
*/
entropy -= p * Math.log(p)/Math.log(2);
}
return entropy;
}
public static double lnF(double what) {
return (what < 1e-06) ? 0 : what * Math.log(what);
}
