Utils

java.lang.Object
- water.util.Utils

public class Utils
extends java.lang.Object

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Utils.AtomicDoubleArray`
`static class`	`Utils.AtomicFloatArray`
`static class`	`Utils.AtomicIntArray`
`static class`	`Utils.AtomicLongArray`
`static class`	`Utils.ExpectedExceptionForDebug`
`static class`	`Utils.IcedArrayList<T extends Iced>` Simple wrapper around ArrayList with support for H2O serialization
`static class`	`Utils.IcedDouble`
`static class`	`Utils.IcedHashMap<K extends Iced,V extends Iced>` Simple wrapper around HashMap with support for H2O serialization
`static class`	`Utils.IcedInt`
`static class`	`Utils.IcedLong`

Field Summary

Fields
Modifier and Type	Field and Description
`static java.util.regex.Pattern[]`	`ILLEGAL_CHARACTERS` Java-string illegal characters which need to be escaped
`static java.lang.String[]`	`REPLACEMENTS`

Constructor Summary

Constructors
Constructor and Description

Utils()

Constructors
Constructor and Description
`Utils()`

Method Summary

Methods
Modifier and Type	Method and Description
`static byte[]`	`add(byte[] a, byte[] b)`
`static double[][]`	`add(double[][] a, double[][] b)`
`static double[]`	`add(double[] a, double[] b)`
`static float[][]`	`add(float[][] a, float[][] b)`
`static float[]`	`add(float[] a, float[] b)`
`static int[][]`	`add(int[][] a, int[][] b)`
`static int[]`	`add(int[] a, int[] b)`
`static long[][]`	`add(long[][] a, long[][] b)`
`static long[]`	`add(long[] a, long[] b)`
`static double[][]`	`append(double[][] a, double[][] b)`
`static double[]`	`append(double[] a, double e)`
`static int[]`	`append(int[] a, int[] b)`
`static long[][][]`	`append(long[][][] a, long[][] e)`
`static java.lang.String[]`	`append(java.lang.String[] a, java.lang.String[] b)`
`static <T> T[]`	`append(T[] a, T... b)`
`static double`	`approxExp(double x)` Fast approximate exp
`static double`	`approxInvSqrt(double x)` Fast approximate 1./sqrt
`static float`	`approxInvSqrt(float x)` Fast approximate 1./sqrt
`static double`	`approxLog(double x)` Fast approximate log for values greater than 1, otherwise exact
`static double`	`approxSqrt(double x)` Fast approximate sqrt
`static float`	`approxSqrt(float x)` Fast approximate sqrt
`static float`	`approxSumSquares(float[] a, int from, int to)` Approximate sumSquares
`static double`	`avg(double[] nums)`
`static double`	`avg(long[] nums)`
`static java.lang.String`	`className(java.lang.String path)`
`static void`	`clearFolder(java.io.File folder)`
`static void`	`clearFolder(java.lang.String folder)`
`static void`	`close(java.io.Closeable... closeable)`
`static void`	`close(java.net.Socket s)`
`static int[][]`	`compose(int[][] first, int[][] second)`
`static int[]`	`compose(int[] first, int[] transf)`
`static boolean`	`contains(int[] a, int d)`
`static boolean`	`contains(java.lang.String[] names, java.lang.String name)`
`static boolean`	`contains(java.lang.String s, java.lang.CharSequence cs)` Returns true if given string contains at least on of character of given sequence.
`static java.lang.String[]`	`createConfusionMatrixHeader(long[] xs, java.lang.String[] ds)`
`static int[]`	`difference(int[] a, int[] b)`
`static double[]`	`div(double[] nums, double n)`
`static float[]`	`div(float[] nums, float n)`
`static float[]`	`div(float[] nums, int n)`
`static java.lang.String[]`	`domainUnion(java.lang.String[] a, java.lang.String[] b)` Clever union of String arrays.
`static float`	`entropy(byte[] f)`
`static boolean`	`equalsWithinOneSmallUlp(double a, double b)`
`static boolean`	`equalsWithinOneSmallUlp(float a, float b)` Compare two numbers to see if they are within one ulp of the smaller decade.
`static java.lang.String`	`escapeJava(java.lang.String s)` Escape all " and \ characters to provide a proper Java-like string Does not escape unicode characters.
`static int[]`	`filter(int[] values, boolean[] filter, int fcnt)`
`static Key[]`	`generateNumKeys(Key mk, int num)` Generate given numbers of keys by suffixing key by given numbered suffix.
`static Key[]`	`generateNumKeys(Key mk, int num, java.lang.String delim)`
`static Key`	`generateShuffledKey(Key mk)`
`static int`	`get4(byte[] buf, int off)`
`static double`	`get8d(byte[] buf, int off)`
`static java.util.Random`	`getDeterRNG(long seed)`
`static byte[]`	`getFirstUnzipedBytes(Key k)`
`static byte[]`	`getFirstUnzipedBytes(Value v)`
`static int`	`getPoisson(double lambda, java.util.Random rng)` Poisson-distributed RNG
`static java.util.Random`	`getRNG(long... seed)`
`static java.lang.String`	`getStackAsString(java.lang.Throwable t)`
`static H2ORandomRNG.RNGKind`	`getUsedRNGKind()`
`static H2ORandomRNG.RNGType`	`getUsedRNGType()`
`static ParseDataset.Compression`	`guessCompressionMethod(byte[] bits)`
`static boolean`	`hasNaNsOrInfs(double[] arr)`
`static boolean`	`isEmpty(int[] a)`
`static boolean`	`isInt(java.lang.String s)`
`static java.lang.String`	`join(char sep, java.lang.Iterable it)`
`static java.lang.String`	`join(char sep, java.lang.Object[] array)`
`static <T> T[]`	`join(T[] a, T[] b)`
`static double`	`lnF(double what)`
`static ValueArray`	`loadAndParseKey(Key okey, java.lang.String path)`
`static ValueArray`	`loadAndParseKey(java.lang.String path)`
`static int[]`	`mapping(int[] dom)` Returns a mapping of given domain to values (0, ...
`static int`	`maxIndex(float[] from)`
`static int`	`maxIndex(float[] from, java.util.Random rand)`
`static int`	`maxIndex(int[] from)`
`static int`	`maxIndex(int[] from, java.util.Random rand)` Returns the index of the largest value in the array.
`static double`	`maxValue(double[] from)`
`static float`	`maxValue(float[] from)`
`static long`	`maxValue(long[] from)`
`static int`	`minIndex(float[] from)`
`static int`	`minIndex(int[] from)`
`static float`	`minValue(float[] from)`
`static long`	`minValue(long[] from)`
`static double[]`	`mult(double[] nums, double n)`
`static float[]`	`mult(float[] nums, float n)`
`static int`	`numInts(java.lang.String... a)` Returns number of strings which represents a number.
`static byte[]`	`or(byte[] a, byte[] b)`
`static int[]`	`or(int[] a, int[] b)`
`static java.lang.String`	`p2d(double d)`
`static java.lang.String`	`p5d(double d)`
`static int[][]`	`pack(int[] values, boolean[] usemap)`
`static int[]`	`partitione(int len, float[] ratio)` Divide given size into partitions based on given ratios.
`static long[]`	`partitione(long len, float[] ratio)`
`static java.lang.String`	`pprint(double[][] arr)`
`static java.lang.String`	`pprint(double[][] arr, java.text.DecimalFormat dformat)`
`static void`	`printConfusionMatrix(java.lang.StringBuilder sb, long[][] cm, java.lang.String[] domain, boolean html)`
`static java.lang.String`	`readConsole()`
`static java.lang.String`	`readFile(java.io.File file)`
`static void`	`readFile(java.io.File file, java.io.OutputStream out)`
`static int[]`	`remove(int[] a, int i)`
`static <T> T[]`	`remove(T[] a, int i)`
`static java.lang.StringBuilder`	`replace(java.lang.StringBuilder sb, java.lang.CharSequence from, java.lang.CharSequence to)` Replace given characters in a given string builder.
`static java.lang.String`	`sampleToString(double[] val, int max)`
`static java.lang.String`	`sampleToString(int[] val, int max)`
`static int[]`	`seq(int start, int stop)` Generates sequence (start, stop) of integers: (start, start+1, ...., stop-1)
`static int`	`set4(byte[] buf, int off, int x)`
`static int`	`set8d(byte[] buf, int off, double d)`
`static void`	`setUsedRNGKind(H2ORandomRNG.RNGKind kind)`
`static void`	`setUsedRNGType(H2ORandomRNG.RNGType rngType)`
`static int[]`	`shuffleArray(int[] a, int n, int[] result, long seed, int startIndex)` Extract a shuffled array of integers
`static void`	`shuffleArray(long[] a, long seed)`
`static float[]`	`sortAccording(float[] ary, java.lang.Integer[] sortOrder)` Create a new sorted array according to given sort order
`static int[]`	`sortAccording(int[] ary, java.lang.Integer[] sortOrder)`
`static java.lang.String[]`	`sortAccording(java.lang.String[] ary, java.lang.Integer[] sortOrder)`
`static void`	`sortAccording2(boolean[] ary, java.lang.Integer[] sortOrder)` Sort given array according given sort order.
`static void`	`sortAccording2(int[] ary, java.lang.Integer[] sortOrder)` Sort given array according given sort order.
`static void`	`sortWith(int[] ary, int[] ary2)` Sort two arrays - the second one is sorted according the first one.
`static <T> T[]`	`subarray(T[] a, int off, int len)`
`static double`	`sum(double[] from)`
`static float`	`sum(float[] from)`
`static int`	`sum(int[] from)`
`static long`	`sum(long[] from)`
`static float`	`sumSquares(float[] a)`
`static float`	`sumSquares(float[] a, int from, int to)`
`static java.io.File`	`tmp()` Returns the system temporary folder, e.g.
`static int[]`	`toInt(java.lang.String[] a, int off, int len)`
`static java.lang.String[]`	`toString(int[] dom)`
`static java.lang.String[]`	`toString(long[] dom)`
`static java.lang.String[]`	`toStringMap(int first, int last)`
`static int[]`	`union(int[] a, int[] b)` Returns a union of given sorted arrays.
`static java.lang.String[]`	`union(java.lang.String[] a, java.lang.String[] b, boolean lexo)` Union of given String arrays.
`static java.lang.String[]`	`union(java.lang.String[] a, java.lang.String[] b, int aoff, int alen, int boff, int blen, boolean lexo)`
`static int[]`	`unpackInts(long... longs)`
`static byte[]`	`unzipBytes(byte[] bs, ParseDataset.Compression cmp)`
`static java.io.File`	`writeFile(java.io.File file, java.lang.String content)`
`static java.io.File`	`writeFile(java.lang.String content)`
`static void`	`writeFileAndClose(java.io.File file, java.io.InputStream in)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

ILLEGAL_CHARACTERS
```
public static final java.util.regex.Pattern[] ILLEGAL_CHARACTERS
```
Java-string illegal characters which need to be escaped

REPLACEMENTS

public static final java.lang.String[] REPLACEMENTS

Constructor Detail
- Utils
```
public Utils()
```

Method Detail

maxIndex
```
public static int maxIndex(int[] from,
           java.util.Random rand)
```
Returns the index of the largest value in the array. In case of a tie, an the index is selected randomly.

maxIndex

public static int maxIndex(float[] from,
           java.util.Random rand)

maxIndex

public static int maxIndex(int[] from)

maxIndex

public static int maxIndex(float[] from)

minIndex

public static int minIndex(int[] from)

minIndex

public static int minIndex(float[] from)

maxValue

public static double maxValue(double[] from)

maxValue

public static float maxValue(float[] from)

minValue

public static float minValue(float[] from)

maxValue

public static long maxValue(long[] from)

minValue

public static long minValue(long[] from)

equalsWithinOneSmallUlp
```
public static boolean equalsWithinOneSmallUlp(float a,
                              float b)
```
Compare two numbers to see if they are within one ulp of the smaller decade. Order of the arguments does not matter.

Parameters:
a - First number
b - Second number

Returns:
true if a and b are essentially equal, false otherwise.

equalsWithinOneSmallUlp

public static boolean equalsWithinOneSmallUlp(double a,
                              double b)

lnF

public static double lnF(double what)

p2d

public static java.lang.String p2d(double d)

p5d

public static java.lang.String p5d(double d)

set4

public static int set4(byte[] buf,
       int off,
       int x)

get4

public static int get4(byte[] buf,
       int off)

set8d

public static int set8d(byte[] buf,
        int off,
        double d)

get8d

public static double get8d(byte[] buf,
           int off)

sum
```
public static long sum(long[] from)
```

sum
```
public static int sum(int[] from)
```

sum

public static float sum(float[] from)

sum

public static double sum(double[] from)

sumSquares

public static float sumSquares(float[] a)

approxSumSquares
```
public static float approxSumSquares(float[] a,
                     int from,
                     int to)
```
Approximate sumSquares

Parameters:
a - Array with numbers
from - starting index (inclusive)
to - ending index (exclusive)

Returns:
approximate sum of squares based on a sample somewhere in the middle of the array (pos determined by bits of a[0])

sumSquares

public static float sumSquares(float[] a,
               int from,
               int to)

sampleToString

public static java.lang.String sampleToString(int[] val,
                              int max)

sampleToString

public static java.lang.String sampleToString(double[] val,
                              int max)

getDeterRNG

public static java.util.Random getDeterRNG(long seed)

setUsedRNGKind

public static void setUsedRNGKind(H2ORandomRNG.RNGKind kind)

getRNG

public static java.util.Random getRNG(long... seed)

setUsedRNGType

public static void setUsedRNGType(H2ORandomRNG.RNGType rngType)

getUsedRNGType

public static H2ORandomRNG.RNGType getUsedRNGType()

getUsedRNGKind

public static H2ORandomRNG.RNGKind getUsedRNGKind()

entropy

public static float entropy(byte[] f)

unpackInts

public static int[] unpackInts(long... longs)

shuffleArray

public static void shuffleArray(long[] a,
                long seed)

shuffleArray
```
public static int[] shuffleArray(int[] a,
                 int n,
                 int[] result,
                 long seed,
                 int startIndex)
```
Extract a shuffled array of integers

Parameters:
a - input array
n - number of elements to extract
result - array to store the results into (will be of size n)
seed - random number seed
startIndex - offset into a

Returns:
result

close

public static void close(java.io.Closeable... closeable)

close

public static void close(java.net.Socket s)

readConsole

public static java.lang.String readConsole()

writeFile

public static java.io.File writeFile(java.lang.String content)

writeFile

public static java.io.File writeFile(java.io.File file,
                     java.lang.String content)

writeFileAndClose

public static void writeFileAndClose(java.io.File file,
                     java.io.InputStream in)

readFile

public static java.lang.String readFile(java.io.File file)

readFile

public static void readFile(java.io.File file,
            java.io.OutputStream out)

join

public static java.lang.String join(char sep,
                    java.lang.Object[] array)

join

public static java.lang.String join(char sep,
                    java.lang.Iterable it)

or

public static byte[] or(byte[] a,
        byte[] b)

or

public static int[] or(int[] a,
       int[] b)

add

public static byte[] add(byte[] a,
         byte[] b)

add

public static int[] add(int[] a,
        int[] b)

add

public static int[][] add(int[][] a,
          int[][] b)

add

public static long[] add(long[] a,
         long[] b)

add

public static long[][] add(long[][] a,
           long[][] b)

add

public static float[] add(float[] a,
          float[] b)

add

public static float[][] add(float[][] a,
            float[][] b)

add

public static double[] add(double[] a,
           double[] b)

add

public static double[][] add(double[][] a,
             double[][] b)

append

public static double[][] append(double[][] a,
                double[][] b)

append

public static int[] append(int[] a,
           int[] b)

append

public static java.lang.String[] append(java.lang.String[] a,
                        java.lang.String[] b)

append

public static double[] append(double[] a,
              double e)

append

public static long[][][] append(long[][][] a,
                long[][] e)

append

public static <T> T[] append(T[] a,
             T... b)

remove

public static <T> T[] remove(T[] a,
             int i)

remove

public static int[] remove(int[] a,
           int i)

subarray

public static <T> T[] subarray(T[] a,
               int off,
               int len)

clearFolder

public static void clearFolder(java.lang.String folder)

clearFolder

public static void clearFolder(java.io.File folder)

tmp
```
public static java.io.File tmp()
```
Returns the system temporary folder, e.g. /tmp

loadAndParseKey

public static ValueArray loadAndParseKey(java.lang.String path)

loadAndParseKey

public static ValueArray loadAndParseKey(Key okey,
                         java.lang.String path)

getFirstUnzipedBytes

public static byte[] getFirstUnzipedBytes(Key k)

getFirstUnzipedBytes

public static byte[] getFirstUnzipedBytes(Value v)

guessCompressionMethod

public static ParseDataset.Compression guessCompressionMethod(byte[] bits)

unzipBytes

public static byte[] unzipBytes(byte[] bs,
                ParseDataset.Compression cmp)

hasNaNsOrInfs

public static final boolean hasNaNsOrInfs(double[] arr)

getStackAsString

public static java.lang.String getStackAsString(java.lang.Throwable t)

mapping
```
public static int[] mapping(int[] dom)
```
Returns a mapping of given domain to values (0, ... max(dom)). Unused domain items has mapping to -1. precondition - dom is sorted dom[0] contains minimal value, dom[dom.length-1] represents max. value.

toString

public static java.lang.String[] toString(long[] dom)

toString

public static java.lang.String[] toString(int[] dom)

toStringMap

public static java.lang.String[] toStringMap(int first,
                             int last)

compose

public static int[] compose(int[] first,
            int[] transf)

compose

public static int[][] compose(int[][] first,
              int[][] second)

pprint

public static java.lang.String pprint(double[][] arr)

pprint

public static java.lang.String pprint(double[][] arr,
                      java.text.DecimalFormat dformat)

isEmpty

public static boolean isEmpty(int[] a)

contains

public static boolean contains(int[] a,
               int d)

difference

public static int[] difference(int[] a,
               int[] b)

seq
```
public static int[] seq(int start,
        int stop)
```
Generates sequence (start, stop) of integers: (start, start+1, ...., stop-1)

className

public static java.lang.String className(java.lang.String path)

avg

public static double avg(double[] nums)

avg

public static double avg(long[] nums)

div

public static float[] div(float[] nums,
          int n)

div

public static float[] div(float[] nums,
          float n)

div

public static double[] div(double[] nums,
           double n)

mult

public static float[] mult(float[] nums,
           float n)

mult

public static double[] mult(double[] nums,
            double n)

approxSqrt
```
public static final double approxSqrt(double x)
```
Fast approximate sqrt

Parameters:
x -

Returns:
sqrt(x) with up to 5% relative error

approxSqrt
```
public static final float approxSqrt(float x)
```
Fast approximate sqrt

Parameters:
x -

Returns:
sqrt(x) with up to 5% relative error

approxInvSqrt
```
public static final double approxInvSqrt(double x)
```
Fast approximate 1./sqrt

Parameters:
x -

Returns:
1./sqrt(x) with up to 2% relative error

approxInvSqrt
```
public static final float approxInvSqrt(float x)
```
Fast approximate 1./sqrt

Parameters:
x -

Returns:
1./sqrt(x) with up to 2% relative error

approxExp
```
public static final double approxExp(double x)
```
Fast approximate exp

Parameters:
x -

Returns:
exp(x) with up to 5% relative error

approxLog
```
public static final double approxLog(double x)
```
Fast approximate log for values greater than 1, otherwise exact

Parameters:
x -

Returns:
log(x) with up to 0.1% relative error

replace
```
public static java.lang.StringBuilder replace(java.lang.StringBuilder sb,
                              java.lang.CharSequence from,
                              java.lang.CharSequence to)
```
Replace given characters in a given string builder. The number of characters to replace has to match to number of characters serving as a replacement.

Parameters:
sb - string builder containing a string to be modified
from - characters to replaced
to - replacement characters

Returns:
original string builder with replaced characters.

contains
```
public static boolean contains(java.lang.String s,
               java.lang.CharSequence cs)
```
Returns true if given string contains at least on of character of given sequence.

Parameters:
s - string
cs - a sequence of character

Returns:
true if s contains at least one of character from given sequence, else false

contains

public static boolean contains(java.lang.String[] names,
               java.lang.String name)

escapeJava
```
public static java.lang.String escapeJava(java.lang.String s)
```
Escape all " and \ characters to provide a proper Java-like string Does not escape unicode characters.

domainUnion
```
public static java.lang.String[] domainUnion(java.lang.String[] a,
                             java.lang.String[] b)
```
Clever union of String arrays. For union of numeric arrays (strings represent integers) it is expecting numeric ordering. For pure string domains it is expecting lexicographical ordering. For mixed domains it always expects lexicographical ordering since such a domain were produce by a parser which sort string with Array.sort(). PRECONDITION - string domain was sorted by Array.sort(String[]), integer domain by Array.sort(int[]) and switched to Strings !!!

Parameters:
a - a set of strings
b - a set of strings

Returns:
union of arrays

union
```
public static java.lang.String[] union(java.lang.String[] a,
                       java.lang.String[] b,
                       boolean lexo)
```
Union of given String arrays. The method expects ordering of domains in given order (lexicographical, numeric)

Parameters:
a - first array
b - second array
lexo - - true if domains are sorted in lexicographical order or false for numeric domains

Returns:
union of values in given arrays. precondition lexo ? a,b are lexicographically sorted : a,b are sorted numerically precondition a!=null && b!=null

union

public static java.lang.String[] union(java.lang.String[] a,
                       java.lang.String[] b,
                       int aoff,
                       int alen,
                       int boff,
                       int blen,
                       boolean lexo)

union

public static int[] union(int[] a,
          int[] b)

Returns a union of given sorted arrays.

join

public static <T> T[] join(T[] a,
           T[] b)

numInts
```
public static int numInts(java.lang.String... a)
```
Returns number of strings which represents a number.

isInt

public static boolean isInt(java.lang.String s)

toInt

public static int[] toInt(java.lang.String[] a,
          int off,
          int len)

filter

public static int[] filter(int[] values,
           boolean[] filter,
           int fcnt)

pack

public static int[][] pack(int[] values,
           boolean[] usemap)

getPoisson
```
public static int getPoisson(double lambda,
             java.util.Random rng)
```
Poisson-distributed RNG

Parameters:
lambda - Lambda parameter

Returns:
Poisson-distributed random number in [0,inf)

sortAccording

public static float[] sortAccording(float[] ary,
                    java.lang.Integer[] sortOrder)

Create a new sorted array according to given sort order

sortAccording

public static java.lang.String[] sortAccording(java.lang.String[] ary,
                               java.lang.Integer[] sortOrder)

sortAccording

public static int[] sortAccording(int[] ary,
                  java.lang.Integer[] sortOrder)

sortWith
```
public static void sortWith(int[] ary,
            int[] ary2)
```
Sort two arrays - the second one is sorted according the first one.

sortAccording2

public static void sortAccording2(int[] ary,
                  java.lang.Integer[] sortOrder)

Sort given array according given sort order. Sort is implemented in-place.

sortAccording2

public static void sortAccording2(boolean[] ary,
                  java.lang.Integer[] sortOrder)

Sort given array according given sort order. Sort is implemented in-place.

createConfusionMatrixHeader

public static java.lang.String[] createConfusionMatrixHeader(long[] xs,
                                             java.lang.String[] ds)

printConfusionMatrix

public static void printConfusionMatrix(java.lang.StringBuilder sb,
                        long[][] cm,
                        java.lang.String[] domain,
                        boolean html)

partitione
```
public static final int[] partitione(int len,
               float[] ratio)
```
Divide given size into partitions based on given ratios.

Parameters:
len - number to be split into partitions
ratio - split ratio of each partition

Returns:
array of sizes based on given ratios, the size of the last segment is len-sum(ratio)*len.

partitione

public static final long[] partitione(long len,
                float[] ratio)

generateNumKeys
```
public static Key[] generateNumKeys(Key mk,
                    int num)
```
Generate given numbers of keys by suffixing key by given numbered suffix.

generateNumKeys

public static Key[] generateNumKeys(Key mk,
                    int num,
                    java.lang.String delim)

generateShuffledKey

public static Key generateShuffledKey(Key mk)

Class Utils

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ILLEGAL_CHARACTERS

REPLACEMENTS

Constructor Detail

Utils

Method Detail

maxIndex

maxIndex

maxIndex

maxIndex

minIndex

minIndex

maxValue

maxValue

minValue

maxValue

minValue

equalsWithinOneSmallUlp

equalsWithinOneSmallUlp

lnF

p2d

p5d

set4

get4

set8d

get8d

sum

sum

sum

sum

sumSquares

approxSumSquares

sumSquares

sampleToString

sampleToString

getDeterRNG

setUsedRNGKind

getRNG

setUsedRNGType

getUsedRNGType

getUsedRNGKind

entropy

unpackInts

shuffleArray

shuffleArray

close

close

readConsole

writeFile

writeFile

writeFileAndClose

readFile

readFile

join

join

or

or

add

add

add

add

add

add

add

add

add

append

append

append

append

append

append

remove

remove