src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
FloatArrays { public static float dotProduct(float[] a1, float[] a2) { return sum(multiply(a1, a2)); } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testDotProduct() { float[] da = {1, 2, 0, -1, -3}; float[] da2 = {0.5f, -2, 30, 1, -30}; Assert.assertTrue(inDelta(FloatArrays.dotProduct(da, da2), 85.5f)); }
|
FloatArrays { public static float[] appendZeros(float[] darray, int zeroAmountToAppend) { if (zeroAmountToAppend < 0) { throw new IllegalArgumentException( "Cannot append negative amount of zeros. Amount:" + zeroAmountToAppend); } return Arrays.copyOf(darray, darray.length + zeroAmountToAppend); } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testAppendZeros() { float[] da = {1, 2, 0, -1, -3}; float[] da2 = {1, 2, 0, -1, -3, 0, 0, 0, 0, 0, 0}; Assert.assertTrue(inDelta(FloatArrays.appendZeros(da, 6), da2)); Assert.assertTrue(inDelta(FloatArrays.appendZeros(da2, 0), da2)); }
@Test(expected = IllegalArgumentException.class) public void testAppendZerosExc() { float[] da = {1, 2, 0, -1, -3}; FloatArrays.appendZeros(da, -10); }
|
WordGenerator { public List<Result> generate(String stem, List<String> morphemeIds) { List<Morpheme> morphemes = new ArrayList<>(); for (String morphemeId : morphemeIds) { Morpheme morpheme = TurkishMorphotactics.getMorpheme(morphemeId); morphemes.add(morpheme); } List<StemTransition> candidates = stemTransitions.getPrefixMatches(stem, false); return generate(stem, candidates, morphemes); } WordGenerator(TurkishMorphotactics morphotactics); static WordGenerator forDebug(TurkishMorphotactics morphotactics); AnalysisDebugData getDebugData(); List<Result> generate(String stem, List<String> morphemeIds); List<Result> generate(DictionaryItem item, List<Morpheme> morphemes); List<Result> generate(DictionaryItem item, Morpheme... morphemes); List<Result> generate(DictionaryItem item, String... morphemeIds); }
|
@Test public void testGeneration2() { WordGenerator wordGenerator = new WordGenerator(getMorphotactics("elma")); List<String> morphemes = Lists.newArrayList("Noun", "A3pl", "P1pl"); List<Result> results = wordGenerator.generate( "elma", morphemes ); Assert.assertTrue(results.size() > 0); Assert.assertEquals("elmalarımız", results.get(0).surface); }
@Test public void testGeneration3() { WordGenerator wordGenerator = new WordGenerator(getMorphotactics("elma")); List<String> morphemes = Lists.newArrayList("Noun", "With"); List<Result> results = wordGenerator.generate( "elma", morphemes ); Assert.assertTrue(results.size() > 0); Assert.assertEquals("elmalı", results.get(0).surface); }
@Test public void testGeneration4() { TurkishMorphotactics mo = getMorphotactics("elma"); WordGenerator wordGenerator = new WordGenerator(mo); List<String> morphemes = Lists.newArrayList("Noun", "A3pl", "P1pl"); List<Result> results = wordGenerator.generate( mo.getRootLexicon().getItemById("elma_Noun"), TurkishMorphotactics.getMorphemes(morphemes) ); Assert.assertTrue(results.size() > 0); Assert.assertEquals("elmalarımız", results.get(0).surface); }
@Test public void testGeneration5() { TurkishMorphotactics mo = getMorphotactics("yapmak"); WordGenerator wordGenerator = new WordGenerator(mo); List<String> morphemes = Lists.newArrayList("Verb", "Opt", "A1pl"); DictionaryItem item = mo.getRootLexicon().getItemById("yapmak_Verb"); List<Result> results = wordGenerator.generate( item, TurkishMorphotactics.getMorphemes(morphemes) ); Assert.assertTrue(results.size() > 0); Assert.assertEquals("yapalım", results.get(0).surface); }
@Test public void testGeneration1() { WordGenerator wordGenerator = new WordGenerator(getMorphotactics("elma")); List<String> morphemes = Lists.newArrayList("A3pl", "P1pl"); List<Result> results = wordGenerator.generate( "elma", morphemes ); Assert.assertTrue(results.size() > 0); Assert.assertEquals("elmalarımız", results.get(0).surface); }
|
FloatArrays { public static float[] square(float... input) { float[] res = new float[input.length]; for (int i = 0; i < input.length; i++) { res[i] = input[i] * input[i]; } return res; } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testSquare() { float[] da = {1, 2, 0, -1, -3}; Assert.assertTrue(inDelta(FloatArrays.square(da), new float[]{1, 4, 0, 1, 9})); }
|
FloatArrays { public static float squaredSum(float[] array) { float result = 0; validateArray(array); for (float a : array) { result += a * a; } return result; } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testSquaredSum() { float[] da = {1, 2, 0, -1, -3}; Assert.assertTrue(inDelta(FloatArrays.squaredSum(da), 15)); float[] da2 = {0, 1, 1, -2, 1}; Assert.assertTrue(inDelta(FloatArrays.squaredSumOfDifferences(da, da2), 20)); Assert.assertTrue(inDelta(FloatArrays.absoluteDifference(da, da2), new float[]{1, 1, 1, 1, 4})); }
|
FloatArrays { public static float mean(float... input) { validateArray(input); return sum(input) / input.length; } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testMean() { float[] da = {1, 2, 0, -1, -3}; Assert.assertTrue(inDelta(FloatArrays.mean(da), -1f / 5f)); }
|
FloatArrays { public static boolean inRange(float d1, float d2, float range) { return Math.abs(d1 - d2) <= range; } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testInRange() { float d = 3; float d2 = 2.5f; float d3 = 7; Assert.assertTrue(FloatArrays.inRange(d, d2, 1)); Assert.assertFalse(FloatArrays.inRange(d2, d3, 4)); Assert.assertTrue(FloatArrays.inRange(d, d2, 0.5f)); }
|
FloatArrays { public static float[] reverse(float[] input) { float[] result = new float[input.length]; for (int i = 0; i < input.length; i++) { result[input.length - i - 1] = input[i]; } return result; } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testReverse() { float[] da = {1, 3, 7, 2.5f, 0}; float[] da2 = FloatArrays.reverse(FloatArrays.reverse(da)); Assert.assertNotNull(da2); Assert.assertEquals(da.length, da2.length); Assert.assertTrue(inDelta(da, da2)); }
|
FloatArrays { public static float[] convert(int[] input) { float[] data = new float[input.length]; int k = 0; for (int i : input) { data[k++] = i; } return data; } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testConvertInt() { int[] ia = {1, 3, -1, 0, 9, 12}; float[] da2 = {1, 3, -1, 0, 9.0f, 12.0f}; float[] da = FloatArrays.convert(ia); Assert.assertNotNull(da); Assert.assertTrue(inDelta(da, da2)); }
@Test public void testConvert2f() { int[][] ia = {{1, 2}, {4, 3}, {-1, 5}}; float[][] da = {{1, 2}, {4, 3}, {-1, 5}}; float[][] da2 = FloatArrays.convert(ia); Assert.assertEquals(ia.length, da2.length); Assert.assertNotNull(da2); int k = 0; for (float[] i : da) { int j = 0; for (float ii : i) { Assert.assertEquals(da2[k][j++], ii, 0.0001); } k++; } }
|
FloatArrays { public static boolean arrayEqualsInRange(float[] d1, float[] d2, float range) { validateArrays(d1, d2); for (int i = 0; i < d1.length; i++) { if (Math.abs(d1[i] - d2[i]) > range) { return false; } } return true; } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testArrayEqualsInRange() { float[] da = {0, 3.5f, 7, -2, 19}; float[] da2 = {0, 4.5f, 4, 2, -18}; Assert.assertTrue(FloatArrays.arrayEqualsInRange(da, da2, 37)); Assert.assertFalse(FloatArrays.arrayEqualsInRange(da, da2, 15)); Assert.assertTrue(FloatArrays.arrayEqualsInRange(da, da2, 45)); }
|
FloatArrays { public static boolean arrayEquals(float[] d1, float[] d2) { validateArrays(d1, d2); return Arrays.equals(d1, d2); } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testArrayEquals() { float[] da = {-1, 0, 3.4f, 7}; float[] da2 = {-1, 0.0f, 3.4f, 7}; float[] da3 = {7, 9.0f, 12.3f, -5.6f}; Assert.assertTrue(FloatArrays.arrayEquals(da, da2)); Assert.assertFalse(FloatArrays.arrayEquals(da2, da3)); }
|
FloatArrays { public static float[] multiply(float[] a1, float[] a2) { validateArrays(a1, a2); float[] mul = new float[a1.length]; for (int i = 0; i < a1.length; i++) { mul[i] = a1[i] * a2[i]; } return mul; } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testMultiply() { float[] da = {-1, 1.3f, 8.2f, 10, 90}; float[] da2 = {-1, 3, 2, 2, -1}; Assert.assertTrue(inDelta(FloatArrays.multiply(da, da2), new float[]{1, 3.9f, 16.4f, 20, -90})); FloatArrays.multiplyToFirst(da, da2); Assert.assertTrue(inDelta(da, new float[]{1, 3.9f, 16.4f, 20, -90})); }
|
FloatArrays { public static float[] scale(float[] a1, float b) { validateArray(a1); float[] mul = new float[a1.length]; for (int i = 0; i < a1.length; i++) { mul[i] = a1[i] * b; } return mul; } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testScale() { float[] da = {1, -1, 3.1f, 0.0f, 0}; Assert.assertTrue(inDelta(FloatArrays.scale(da, 0), new float[]{0, 0, 0, 0, 0})); Assert.assertTrue(inDelta(FloatArrays.scale(da, -1), new float[]{-1, 1, -3.1f, 0, 0.0f})); Assert.assertTrue(inDelta(FloatArrays.scale(da, 4), new float[]{4, -4, 12.4f, 0.0f, 0.0f})); FloatArrays.scaleInPlace(da, 4); Assert.assertTrue(inDelta(da, new float[]{4, -4, 12.4f, 0.0f, 0.0f})); FloatArrays.scaleInPlace(da, 0); Assert.assertTrue(inDelta(da, new float[]{0, 0, 0, 0, 0})); }
|
FloatArrays { public static float[] absoluteDifference(float[] a, float[] b) { validateArrays(a, b); float[] diff = new float[a.length]; for (int i = 0; i < a.length; i++) { diff[i] += abs(a[i] - b[i]); } return diff; } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testAbsoluteDifference() { float[] da = {1, 2, 4.5f, -2, 4}; float[] da2 = {1, 1, 2.5f, 5, -15.2f}; Assert.assertTrue( inDelta(FloatArrays.absoluteDifference(da, da2), new float[]{0, 1, 2, 7, 19.2f})); Assert.assertEquals(FloatArrays.absoluteSumOfDifferences(da, da2), 29.2f, 0.0001); }
|
FloatArrays { public static float variance(float[] input) { float sigmaSquare = 0; float mean = mean(input); for (float a : input) { float meanDiff = a - mean; sigmaSquare += meanDiff * meanDiff; } return sigmaSquare / (input.length - 1); } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testVariance() { float[] da = {0, 2, 4}; Assert.assertEquals(FloatArrays.variance(da), 4f, 0.0001); Assert.assertEquals(FloatArrays.standardDeviation(da), 2f, 0.0001); }
|
FloatArrays { public static boolean containsNaN(float[] a) { for (float v : a) { if (Float.isNaN(v)) { return true; } } return false; } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testContainsNaN() { float[] da = {-1, 1, 3, 5, 7, 9, Float.NaN}; Assert.assertTrue(FloatArrays.containsNaN(da)); float[] da2 = {-1, 1, 3, 5, 7, 9}; Assert.assertFalse(FloatArrays.containsNaN(da2)); }
|
FloatArrays { public static void floorInPlace(float[] var, float minValue) { for (int k = 0; k < var.length; k++) { if (var[k] < minValue) { var[k] = minValue; } } } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testFloorInPlace() { float[] da = {0, -7, 2, 1.1123f, -10, -22, 56}; FloatArrays.floorInPlace(da, -7); Assert.assertTrue(inDelta(da, new float[]{0, -7, 2, 1.1123f, -7, -7, 56})); }
|
FloatArrays { public static void nonZeroFloorInPlace(float[] data, float floor) { for (int i = 0; i < data.length; i++) { if (data[i] != 0.0f && data[i] < floor) { data[i] = floor; } } } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testNonZeroFloorInPlace() { float[] da = {0, -7, 2, 1.1123f, -10, -22, 56}; FloatArrays.nonZeroFloorInPlace(da, 3); Assert.assertTrue(inDelta(da, new float[]{0, 3, 3, 3, 3, 3, 56})); }
|
FloatArrays { public static void normalizeInPlace(float[] data) { float sum = sum(data); scaleInPlace(data, 1f / sum); } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testNormalizeInPlace() { float[] da = {1, 5.6f, 2.4f, -1, -3.0f, 5}; FloatArrays.normalizeInPlace(da); Assert.assertTrue(inDelta(da, new float[]{0.1f, 0.56f, 0.24f, -0.1f, -0.3f, 0.5f})); }
|
FloatArrays { public static void addToAll(float[] data, float valueToAdd) { validateArray(data); for (int i = 0; i < data.length; i++) { data[i] += valueToAdd; } } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testAddToAll() { float[] da = {1, 2, 0, -1, -3}; float[] expected = {2, 3, 1, 0, -2}; FloatArrays.addToAll(da, 1); Assert.assertTrue(Arrays.equals(expected, da)); }
|
FloatArrays { public static void validateArray(float... input) { if (input == null) { throw new IllegalArgumentException("array is null!"); } else if (input.length == 0) { throw new IllegalArgumentException("array is empty!"); } } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testValidateArray() { float[] da = null; try { FloatArrays.validateArray(da); } catch (IllegalArgumentException e) { Assert.assertTrue(true); } da = new float[0]; try { FloatArrays.validateArray(da); } catch (IllegalArgumentException e) { Assert.assertTrue(true); } }
@Test(expected = IllegalArgumentException.class) public void testValidateArrayExc() { float[] da1 = new float[0]; FloatArrays.validateArray(da1); }
|
FloatArrays { public static void validateArrays(float[] a1, float[] a2) { if (a1 == null) { throw new NullPointerException("first array is null!"); } if (a2 == null) { throw new NullPointerException("second array is null!"); } if (a1.length != a2.length) { throw new IllegalArgumentException("Array sizes must be equal. But, first:" + a1.length + ", and second:" + a2.length); } } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testValidateArrays() { float[] da1 = {1, 2, 3}; float[] da2 = null; try { FloatArrays.validateArrays(da1, da2); } catch (NullPointerException e) { Assert.assertTrue(true); } float[] da3 = {5, 6, 2.33f, 2}; try { FloatArrays.validateArrays(da1, da3); } catch (IllegalArgumentException e) { Assert.assertTrue(true); } }
@Test(expected = NullPointerException.class) public void testValidateArraysNullExc() { float[] da1 = null; float[] da2 = null; FloatArrays.validateArrays(da1, da2); }
@Test(expected = IllegalArgumentException.class) public void testValidateArraysArgExc() { float[] da1 = new float[2]; float[] da2 = new float[3]; FloatArrays.validateArrays(da1, da2); }
|
FloatArrays { public static float[] normalize16bitLittleEndian(byte[] bytez) { return normalize16bitLittleEndian(bytez, bytez.length); } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testNormalize16bitLittleEndian() { byte[] ba = {0x10, 0x71, 0x18, 0x54}; float[] da = FloatArrays.normalize16bitLittleEndian(ba); Assert.assertEquals(da[0] * Short.MAX_VALUE, 28944f, 0.0001); Assert.assertEquals(da[1] * Short.MAX_VALUE, 21528f, 0.0001); byte[] ba2 = FloatArrays.denormalize16BitLittleEndian(da); Assert.assertEquals(ba2[0], 0x10); Assert.assertEquals(ba2[3], 0x54); byte[] ba3 = FloatArrays.denormalizeLittleEndian(da, 16); Assert.assertEquals(ba3[0], 0x10); Assert.assertEquals(ba3[3], 0x54); byte[] ba4 = {(byte) 0xCC, (byte) 0xAB}; da = FloatArrays.normalize16bitLittleEndian(ba4); Assert.assertEquals(da[0] * Short.MIN_VALUE, 21556f, 0.0001); }
@Test(expected = IllegalArgumentException.class) public void testNormalize16bitExc() { byte[] ba = {-10, 45, 120}; FloatArrays.normalize16bitLittleEndian(ba); }
|
FloatArrays { public static int[] toUnsignedInteger(float[] input, int max) { if (max < 1) { throw new IllegalArgumentException("Maximum int value must be positive. But it is:" + max); } int[] arr = new int[input.length]; float divider = (float) ((double) max / 2.0); for (int i = 0; i < input.length; i++) { float d = input[i]; if (d < -1.0 || d > 1.0) { throw new IllegalArgumentException( "Array value should be between -1.0 and 1.0. But it is: " + d); } arr[i] = (int) (input[i] * divider); } return arr; } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testToUnsignedInteger() { float[] da = {0.2f, -0.4f, 0.6f}; int[] ia = FloatArrays.toUnsignedInteger(da, 6); Assert.assertEquals((int) (0.2f * 3.0f), ia[0]); Assert.assertEquals((int) (-0.4f * 3.0f), ia[1]); }
|
FloatArrays { public static String format(float... input) { return format(10, 3, " ", input); } private FloatArrays(); static boolean inRange(float d1, float d2, float range); static float[] reverse(float[] input); static float[] convert(int[] input); static float[][] convert(int[][] input); static float[] convert(double[] input); static boolean arrayEqualsInRange(float[] d1, float[] d2, float range); static boolean arrayEquals(float[] d1, float[] d2); static float[] appendZeros(float[] darray, int zeroAmountToAppend); static float[] normalize16bitLittleEndian(byte[] bytez); static float[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(float[] input); static int[] toUnsignedInteger(float[] input, int max); static int[] toInteger(float[] input, int min, int max); static float max(float... input); static void trimValues(float[] input, float minVal, float maxVal); static float absMax(float... input); static String format(float... input); static String format(int fractionDigits, float... input); static String format(int fractionDigits, String delimiter, float... input); static String format(int rightPad, int fractionDigits, String delimiter, float... input); static float min(float... input); static float absMin(float... input); static void validateArray(float... input); static int maxIndex(float... input); static int minIndex(float... input); static float sum(float... input); static float[] sum(float[] a1, float[] a2); static void addToFirst(float[] first, float[] second); static void addToAll(float[] data, float valueToAdd); static void addToFirstScaled(float[] first, float[] second, float scale); static float[] square(float... input); static void squareInPlace(float... input); static float[] subtract(float[] a1, float[] a2); static void subtractFromFirst(float[] first, float[] second); static float[] multiply(float[] a1, float[] a2); static float dotProduct(float[] a1, float[] a2); static void multiplyToFirst(float[] first, float[] second); static float[] scale(float[] a1, float b); static void scaleInPlace(float[] a1, float b); static float mean(float... input); static float absoluteSumOfDifferences(float[] a, float[] b); static float[] absoluteDifference(float[] a, float[] b); static void validateArrays(float[] a1, float[] a2); static float squaredSum(float[] array); static float squaredSumOfDifferences(float[] a, float[] b); static float variance(float[] input); static float standardDeviation(float[] a); static boolean containsNaN(float[] a); static boolean containsNanOrInfinite(float[] a); static void floorInPlace(float[] var, float minValue); static void nonZeroFloorInPlace(float[] data, float floor); static void normalizeInPlace(float[] data); static float[] fromString(String str, String delimiter); static void serialize(DataOutputStream dos, float[] data); static void serializeRaw(DataOutputStream dos, float[] data); static void serialize(DataOutputStream dos, float[][] data); static void serializeRaw(DataOutputStream dos, float[][] data); static float[] deserialize(DataInputStream dis); static float[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, float[] result); static float[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, float[][] result); static float[][] clone2D(float[][] result); static float[] to1D(float[][] matrix); static float[][] toMatrix(float[] vector, int dimension); static float[][] loadFromText(File input); static final float[] ZERO_LENGTH_ARRAY; static final float[][] ZERO_LENGTH_MATRIX; static final Pattern FEATURE_LINES_PATTERN; }
|
@Test public void testFormat() { float[] da = {0.2f, -0.45f, 0.6f}; Assert.assertEquals("0.2 -0.4 0.6", FloatArrays.format(1, " ", da)); Assert.assertEquals("0.20 -0.45 0.60", FloatArrays.format(2, " ", da)); Assert.assertEquals("0.20, -0.45, 0.60", FloatArrays.format(2, ", ", da)); Assert.assertEquals("0.20-0.450.60", FloatArrays.format(2, "", da)); Assert.assertEquals("0.2 -0.4 0.6", FloatArrays.format(5, 1, " ", da)); }
|
DoubleArrays { public static double sum(double... input) { double sum = 0; for (double v : input) { sum += v; } return sum; } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testSum() { double[] da = {1, 2, 0, -1, -3}; double[] da2 = {0.5, -2, 30, 1, -30}; Assert.assertTrue(inDelta(DoubleArrays.sum(da), -1)); Assert.assertTrue(inDelta(DoubleArrays.sum(da, da2), new double[]{1.5, 0, 30, 0, -33})); DoubleArrays.addToFirst(da, da2); Assert.assertTrue(inDelta(da, new double[]{1.5, 0, 30, 0, -33})); }
|
DoubleArrays { public static void addToFirstScaled(double[] first, double[] second, double scale) { validateArrays(first, second); for (int i = 0; i < first.length; i++) { first[i] = first[i] + second[i] * scale; } } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void addToFirstScaledTest() { double[] da1 = {1, 2, 0, -1, -30}; double[] da2 = {-0.5, -1, 0, 0.5, 15}; DoubleArrays.addToFirstScaled(da1, da2, 2); Assert.assertEquals(DoubleArrays.max(da1), 0d, 0.0001); Assert.assertEquals(DoubleArrays.min(da1), 0d, 0.0001); }
|
DoubleArrays { public static double dotProduct(double[] a1, double[] a2) { return sum(multiply(a1, a2)); } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testDotProduct() { double[] da = {1, 2, 0, -1, -3}; double[] da2 = {0.5, -2, 30, 1, -30}; Assert.assertTrue(inDelta(DoubleArrays.dotProduct(da, da2), 85.5)); }
|
DoubleArrays { public static double[] appendZeros(double[] darray, int zeroAmountToAppend) { if (zeroAmountToAppend < 0) { throw new IllegalArgumentException( "Cannot append negative amount of zeros. Amount:" + zeroAmountToAppend); } return Arrays.copyOf(darray, darray.length + zeroAmountToAppend); } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testAppendZeros() { double[] da = {1, 2, 0, -1, -3}; double[] da2 = {1, 2, 0, -1, -3, 0, 0, 0, 0, 0, 0}; Assert.assertTrue(inDelta(DoubleArrays.appendZeros(da, 6), da2)); Assert.assertTrue(inDelta(DoubleArrays.appendZeros(da2, 0), da2)); }
@Test(expected = IllegalArgumentException.class) public void testAppendZerosExc() { double[] da = {1, 2, 0, -1, -3}; DoubleArrays.appendZeros(da, -10); }
|
DoubleArrays { public static double[] square(double... input) { double[] res = new double[input.length]; for (int i = 0; i < input.length; i++) { res[i] = input[i] * input[i]; } return res; } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testSquare() { double[] da = {1, 2, 0, -1, -3}; Assert.assertTrue(inDelta(DoubleArrays.square(da), new double[]{1, 4, 0, 1, 9})); }
|
DoubleArrays { public static double squaredSum(double[] array) { double result = 0; validateArray(array); for (double a : array) { result += a * a; } return result; } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testSquaredSum() { double[] da = {1, 2, 0, -1, -3}; Assert.assertTrue(inDelta(DoubleArrays.squaredSum(da), 15)); double[] da2 = {0, 1, 1, -2, 1}; Assert.assertTrue(inDelta(DoubleArrays.squaredSumOfDifferences(da, da2), 20)); Assert .assertTrue(inDelta(DoubleArrays.absoluteDifference(da, da2), new double[]{1, 1, 1, 1, 4})); }
|
DoubleArrays { public static void addToAll(double[] data, double valueToAdd) { validateArray(data); for (int i = 0; i < data.length; i++) { data[i] += valueToAdd; } } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testAddToAll() { double[] da = {1, 2, 0, -1, -3}; double[] expected = {2, 3, 1, 0, -2}; DoubleArrays.addToAll(da, 1); Assert.assertTrue(Arrays.equals(expected, da)); }
|
DoubleArrays { public static double mean(double... input) { validateArray(input); return sum(input) / input.length; } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testMean() { double[] da = {1, 2, 0, -1, -3}; Assert.assertTrue(inDelta(DoubleArrays.mean(da), -1d / 5d)); }
|
DoubleArrays { public static boolean inRange(double d1, double d2, double range) { return Math.abs(d1 - d2) <= range; } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testInRange() { double d = 3; double d2 = 2.5; double d3 = 7; Assert.assertTrue(DoubleArrays.inRange(d, d2, 1)); Assert.assertFalse(DoubleArrays.inRange(d2, d3, 4)); Assert.assertTrue(DoubleArrays.inRange(d, d2, 0.5)); }
|
DoubleArrays { public static double[] reverse(double[] input) { double[] result = new double[input.length]; for (int i = 0; i < input.length; i++) { result[input.length - i - 1] = input[i]; } return result; } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testReverse() { double[] da = {1, 3, 7, 2.5, 0}; double[] da2 = DoubleArrays.reverse(DoubleArrays.reverse(da)); Assert.assertNotNull(da2); Assert.assertEquals(da.length, da2.length); Assert.assertTrue(inDelta(da, da2)); }
|
DoubleArrays { public static double[] convert(int[] input) { double[] data = new double[input.length]; int k = 0; for (int i : input) { data[k++] = i; } return data; } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testConvertInt() { int[] ia = {1, 3, -1, 0, 9, 12}; double[] da2 = {1, 3, -1, 0, 9.0, 12.0}; double[] da = DoubleArrays.convert(ia); Assert.assertNotNull(da); Assert.assertTrue(inDelta(da, da2)); }
@Test public void testConvert2d() { int[][] ia = {{1, 2}, {4, 3}, {-1, 5}}; double[][] da = {{1, 2}, {4, 3}, {-1, 5}}; double[][] da2 = DoubleArrays.convert(ia); Assert.assertEquals(ia.length, da2.length); Assert.assertNotNull(da2); int k = 0; for (double[] i : da) { int j = 0; for (double ii : i) { Assert.assertEquals(da2[k][j++], ii, 0.0001); } k++; } }
@Test public void testConvertFloat() { float[] fa = {1, 3, -1, 0, 9, 12}; double[] da2 = {1, 3, -1, 0, 9.0, 12.0}; double[] da = DoubleArrays.convert(fa); Assert.assertNotNull(da); Assert.assertTrue(inDelta(da, da2)); }
|
TurkishDictionaryLoader { public static RootLexicon load(File input) throws IOException { return Files.asCharSource(input, Charsets.UTF_8).readLines(new TextLexiconProcessor()); } static RootLexicon loadDefaultDictionaries(); static RootLexicon loadFromResources(String... resourcePaths); static RootLexicon loadFromResources(Collection<String> resourcePaths); static RootLexicon load(File input); static RootLexicon loadInto(RootLexicon lexicon, File input); static DictionaryItem loadFromString(String dictionaryLine); static RootLexicon load(String... dictionaryLines); static RootLexicon load(Iterable<String> dictionaryLines); static final List<String> DEFAULT_DICTIONARY_RESOURCES; }
|
@Test public void loadNounsFromFileTest() throws IOException { RootLexicon items = TurkishDictionaryLoader .load(new File(Resources.getResource("test-lexicon-nouns.txt").getFile())); Assert.assertFalse(items.isEmpty()); for (DictionaryItem item : items) { Assert.assertSame(item.primaryPos, Noun); } }
@Test public void referenceTest1() { String[] ref = {"ad", "ad [A:Doubling,InverseHarmony]", "soy", "soyadı [A:CompoundP3sg; Roots:soy-ad]"}; RootLexicon lexicon = TurkishDictionaryLoader.load(ref); DictionaryItem item = lexicon.getItemById("soyadı_Noun"); Assert.assertNotNull(item); Assert.assertFalse(item.attributes.contains(RootAttribute.Doubling)); }
@Test public void referenceTest2() { String[] ref = {"ad", "ad [A:Doubling,InverseHarmony;Index:1]", "soy", "soyadı [A:CompoundP3sg; Roots:soy-ad]"}; RootLexicon lexicon = TurkishDictionaryLoader.load(ref); DictionaryItem item = lexicon.getItemById("soyadı_Noun"); Assert.assertNotNull(item); Assert.assertFalse(item.attributes.contains(RootAttribute.Doubling)); }
@Test public void pronunciation1() { String[] ref = { "VST [P:Noun, Abbrv; Pr:viesti]", "VST [P:Noun, Abbrv; Pr:vesete; Ref:VST_Noun_Abbrv; Index:2]"}; RootLexicon lexicon = TurkishDictionaryLoader.load(ref); DictionaryItem item = lexicon.getItemById("VST_Noun_Abbrv"); Assert.assertNotNull(item); DictionaryItem item2 = lexicon.getItemById("VST_Noun_Abbrv_2"); Assert.assertNotNull(item2); Assert.assertEquals(item, item2.getReferenceItem()); }
@Test public void implicitP3sgTest() { String[] lines = { "üzeri [A:CompoundP3sg;Roots:üzer]"}; RootLexicon lexicon = TurkishDictionaryLoader.load(lines); Assert.assertEquals(2, lexicon.size()); }
@Test @Ignore("Not a unit test") public void shouldPrintItemsInDevlDictionary() throws IOException { RootLexicon items = TurkishDictionaryLoader .load(new File(Resources.getResource("dev-lexicon.txt").getFile())); for (DictionaryItem item : items) { System.out.println(item); } }
|
DoubleArrays { public static boolean arrayEqualsInRange(double[] d1, double[] d2, double range) { validateArrays(d1, d2); for (int i = 0; i < d1.length; i++) { if (Math.abs(d1[i] - d2[i]) > range) { return false; } } return true; } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testArrayEqualsInRange() { double[] da = {0, 3.5, 7, -2, 19}; double[] da2 = {0, 4.5, 4, 2, -18}; Assert.assertTrue(DoubleArrays.arrayEqualsInRange(da, da2, 37)); Assert.assertFalse(DoubleArrays.arrayEqualsInRange(da, da2, 15)); Assert.assertTrue(DoubleArrays.arrayEqualsInRange(da, da2, 45)); }
|
DoubleArrays { public static boolean arrayEquals(double[] d1, double[] d2) { validateArrays(d1, d2); return Arrays.equals(d1, d2); } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testArrayEquals() { double[] da = {-1, 0, 3.4, 7}; double[] da2 = {-1, 0.0, 3.4, 7}; double[] da3 = {7, 9.0, 12.3, -5.6}; Assert.assertTrue(DoubleArrays.arrayEquals(da, da2)); Assert.assertFalse(DoubleArrays.arrayEquals(da2, da3)); }
|
DoubleArrays { public static double[] multiply(double[] a1, double[] a2) { validateArrays(a1, a2); double[] mul = new double[a1.length]; for (int i = 0; i < a1.length; i++) { mul[i] = a1[i] * a2[i]; } return mul; } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testMultiply() { double[] da = {-1, 1.3, 8.2, 10, 90}; double[] da2 = {-1, 3, 2, 2, -1}; Assert.assertTrue(inDelta(DoubleArrays.multiply(da, da2), new double[]{1, 3.9, 16.4, 20, -90})); DoubleArrays.multiplyToFirst(da, da2); Assert.assertTrue(inDelta(da, new double[]{1, 3.9, 16.4, 20, -90})); }
|
DoubleArrays { public static double[] scale(double[] a1, double b) { validateArray(a1); double[] mul = new double[a1.length]; for (int i = 0; i < a1.length; i++) { mul[i] = a1[i] * b; } return mul; } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testScale() { double[] da = {1, -1, 3.1, 0.0, 0}; Assert.assertTrue(inDelta(DoubleArrays.scale(da, 0), new double[]{0, 0, 0, 0, 0})); Assert.assertTrue(inDelta(DoubleArrays.scale(da, -1), new double[]{-1, 1, -3.1, 0, 0.0})); Assert.assertTrue(inDelta(DoubleArrays.scale(da, 4), new double[]{4, -4, 12.4, 0.0, 0.0})); DoubleArrays.scaleInPlace(da, 4); Assert.assertTrue(inDelta(da, new double[]{4, -4, 12.4, 0.0, 0.0})); DoubleArrays.scaleInPlace(da, 0); Assert.assertTrue(inDelta(da, new double[]{0, 0, 0, 0, 0})); }
|
DoubleArrays { public static double[] absoluteDifference(double[] a, double[] b) { validateArrays(a, b); double[] diff = new double[a.length]; for (int i = 0; i < a.length; i++) { diff[i] += abs(a[i] - b[i]); } return diff; } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testAbsoluteDifference() { double[] da = {1, 2, 4.5, -2, 4}; double[] da2 = {1, 1, 2.5, 5, -15.2}; Assert.assertTrue( inDelta(DoubleArrays.absoluteDifference(da, da2), new double[]{0, 1, 2, 7, 19.2})); Assert.assertEquals(DoubleArrays.absoluteSumOfDifferences(da, da2), 29.2, 0.0001); }
|
DoubleArrays { public static double variance(double[] input) { double sigmaSquare = 0; double mean = mean(input); for (double a : input) { final double meanDiff = a - mean; sigmaSquare += meanDiff * meanDiff; } return sigmaSquare / (input.length - 1); } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testVariance() { double[] da = {0, 2, 4}; Assert.assertEquals(DoubleArrays.variance(da), 4d, 0.0001); Assert.assertEquals(DoubleArrays.standardDeviation(da), 2d, 0.0001); }
|
DoubleArrays { public static boolean containsNaN(double[] a) { for (double v : a) { if (Double.isNaN(v)) { return true; } } return false; } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testContainsNaN() { double[] da = {-1, 1, 3, 5, 7, 9, Double.NaN}; Assert.assertTrue(DoubleArrays.containsNaN(da)); double[] da2 = {-1, 1, 3, 5, 7, 9}; Assert.assertFalse(DoubleArrays.containsNaN(da2)); }
|
DoubleArrays { public static void floorInPlace(double[] var, double minValue) { for (int k = 0; k < var.length; k++) { if (var[k] < minValue) { var[k] = minValue; } } } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testFloorInPlace() { double[] da = {0, -7, 2, 1.1123, -10, -22, 56}; DoubleArrays.floorInPlace(da, -7); Assert.assertTrue(inDelta(da, new double[]{0, -7, 2, 1.1123, -7, -7, 56})); }
|
TurkishDictionaryLoader { public static DictionaryItem loadFromString(String dictionaryLine) { String lemma = dictionaryLine; if (dictionaryLine.contains(" ")) { lemma = dictionaryLine.substring(0, dictionaryLine.indexOf(" ")); } return load(dictionaryLine).getMatchingItems(lemma).get(0); } static RootLexicon loadDefaultDictionaries(); static RootLexicon loadFromResources(String... resourcePaths); static RootLexicon loadFromResources(Collection<String> resourcePaths); static RootLexicon load(File input); static RootLexicon loadInto(RootLexicon lexicon, File input); static DictionaryItem loadFromString(String dictionaryLine); static RootLexicon load(String... dictionaryLines); static RootLexicon load(Iterable<String> dictionaryLines); static final List<String> DEFAULT_DICTIONARY_RESOURCES; }
|
@Test public void voicingInferenceTest() { DictionaryItem item = TurkishDictionaryLoader.loadFromString("aort [A:NoVoicing]"); Assert.assertEquals("aort", item.root); Assert.assertEquals(Noun, item.primaryPos); Assert.assertTrue(item.hasAttribute(RootAttribute.NoVoicing)); Assert.assertFalse(item.hasAttribute(RootAttribute.Voicing)); item = TurkishDictionaryLoader.loadFromString("at"); Assert.assertEquals("at", item.root); Assert.assertEquals(Noun, item.primaryPos); Assert.assertTrue(item.hasAttribute(RootAttribute.NoVoicing)); Assert.assertFalse(item.hasAttribute(RootAttribute.Voicing)); }
@Test public void punctuationTest() { DictionaryItem item = TurkishDictionaryLoader.loadFromString("… [P:Punc]"); Assert.assertEquals("…", item.root); Assert.assertEquals(Punctuation, item.primaryPos); }
@Test public void properNounsShouldNotHaveVoicingAutomaticallyTest() { DictionaryItem item = TurkishDictionaryLoader.loadFromString("Tokat"); Assert.assertEquals("tokat", item.root); Assert.assertEquals(Noun, item.primaryPos); Assert.assertEquals(SecondaryPos.ProperNoun, item.secondaryPos); Assert.assertFalse(item.hasAttribute(RootAttribute.Voicing)); item = TurkishDictionaryLoader.loadFromString("Dink"); Assert.assertEquals("dink", item.root); Assert.assertEquals(Noun, item.primaryPos); Assert.assertEquals(SecondaryPos.ProperNoun, item.secondaryPos); Assert.assertFalse(item.hasAttribute(RootAttribute.Voicing)); }
@Test public void nounVoicingTest() { String[] voicing = {"kabak", "kabak [A:Voicing]", "psikolog", "havuç", "turp [A:Voicing]", "galip", "nohut", "cenk", "kükürt"}; for (String s : voicing) { DictionaryItem item = TurkishDictionaryLoader.loadFromString(s); Assert.assertEquals(Noun, item.primaryPos); Assert.assertTrue("error in:" + s, item.hasAttribute(RootAttribute.Voicing)); } String[] novoicing = {"kek", "link [A:NoVoicing]", "top", "kulp", "takat [A:NoVoicing]"}; for (String s : novoicing) { DictionaryItem item = TurkishDictionaryLoader.loadFromString(s); Assert.assertEquals(Noun, item.primaryPos); Assert.assertTrue("error in:" + s, item.hasAttribute(NoVoicing)); } }
@Test public void nounAttributesTest() { List<ItemAttrPair> testList = Lists.newArrayList( testPair("takat [A:NoVoicing, InverseHarmony]", NoVoicing, InverseHarmony), testPair("nakit [A: LastVowelDrop]", Voicing, LastVowelDrop), testPair("ret [A:Voicing, Doubling]", Voicing, Doubling) ); for (ItemAttrPair pair : testList) { DictionaryItem item = TurkishDictionaryLoader.loadFromString(pair.str); Assert.assertEquals(Noun, item.primaryPos); Assert.assertEquals("error in:" + pair.str, pair.attrs, item.attributes); } }
|
DoubleArrays { public static void nonZeroFloorInPlace(double[] data, double floor) { for (int i = 0; i < data.length; i++) { if (data[i] != 0.0 && data[i] < floor) { data[i] = floor; } } } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testNonZeroFloorInPlace() { double[] da = {0, -7, 2, 1.1123, -10, -22, 56}; DoubleArrays.nonZeroFloorInPlace(da, 3); Assert.assertTrue(inDelta(da, new double[]{0, 3, 3, 3, 3, 3, 56})); }
|
DoubleArrays { public static void normalizeInPlace(double[] data) { double sum = sum(data); scaleInPlace(data, 1d / sum); } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testNormalizeInPlace() { double[] da = {1, 5.6, 2.4, -1, -3.0, 5}; DoubleArrays.normalizeInPlace(da); Assert.assertTrue(inDelta(da, new double[]{0.1, 0.56, 0.24, -0.1, -0.3, 0.5})); }
|
DoubleArrays { public static void validateArray(double... input) { if (input == null) { throw new IllegalArgumentException("array is null!"); } else if (input.length == 0) { throw new IllegalArgumentException("array is empty!"); } } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testValidateArray() { double[] da = null; try { DoubleArrays.validateArray(da); } catch (IllegalArgumentException e) { Assert.assertTrue(true); } da = new double[0]; try { DoubleArrays.validateArray(da); } catch (IllegalArgumentException e) { Assert.assertTrue(true); } }
@Test(expected = IllegalArgumentException.class) public void testValidateArrayExc() { double[] da1 = new double[0]; DoubleArrays.validateArray(da1); }
|
DoubleArrays { public static void validateArrays(double[] a1, double[] a2) { if (a1 == null) { throw new NullPointerException("first array is null!"); } if (a2 == null) { throw new NullPointerException("second array is null!"); } if (a1.length != a2.length) { throw new IllegalArgumentException("Array sizes must be equal. But, first:" + a1.length + ", and second:" + a2.length); } } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testValidateArrays() { double[] da1 = {1, 2, 3}; double[] da2 = null; try { DoubleArrays.validateArrays(da1, da2); } catch (NullPointerException e) { Assert.assertTrue(true); } double[] da3 = {5, 6, 2.33, 2}; try { DoubleArrays.validateArrays(da1, da3); } catch (IllegalArgumentException e) { Assert.assertTrue(true); } }
@Test(expected = NullPointerException.class) public void testValidateArraysNullExc() { double[] da1 = null; double[] da2 = null; DoubleArrays.validateArrays(da1, da2); }
@Test(expected = IllegalArgumentException.class) public void testValidateArraysArgExc() { double[] da1 = new double[2]; double[] da2 = new double[3]; DoubleArrays.validateArrays(da1, da2); }
|
DoubleArrays { public static double[] normalize16bitLittleEndian(byte[] bytez) { return normalize16bitLittleEndian(bytez, bytez.length); } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testNormalize16bitLittleEndian() { byte[] ba = {0x10, 0x71, 0x18, 0x54}; double[] da = DoubleArrays.normalize16bitLittleEndian(ba); Assert.assertEquals(da[0] * Short.MAX_VALUE, 28944d, 0.0001); Assert.assertEquals(da[1] * Short.MAX_VALUE, 21528d, 0.0001); byte[] ba2 = DoubleArrays.denormalize16BitLittleEndian(da); Assert.assertEquals(ba2[0], 0x10); Assert.assertEquals(ba2[3], 0x54); byte[] ba3 = DoubleArrays.denormalizeLittleEndian(da, 16); Assert.assertEquals(ba3[0], 0x10); Assert.assertEquals(ba3[3], 0x54); byte[] ba4 = {(byte) 0xCC, (byte) 0xAB}; da = DoubleArrays.normalize16bitLittleEndian(ba4); Assert.assertEquals(da[0] * Short.MIN_VALUE, 21556d, 0.0001); }
@Test(expected = IllegalArgumentException.class) public void testNormalize16bitExc() { byte[] ba = {-10, 45, 120}; DoubleArrays.normalize16bitLittleEndian(ba); }
|
DoubleArrays { public static int[] toUnsignedInteger(double[] input, int max) { if (max < 1) { throw new IllegalArgumentException("Maximum int value must be positive. But it is:" + max); } int[] iarr = new int[input.length]; double divider = (double) max / 2.0; for (int i = 0; i < input.length; i++) { double d = input[i]; if (d < -1.0 || d > 1.0) { throw new IllegalArgumentException( "Array value should be between -1.0 and 1.0. But it is: " + d); } iarr[i] = (int) (input[i] * divider); } return iarr; } private DoubleArrays(); static boolean inRange(double d1, double d2, double range); static double[] reverse(double[] input); static double[] convert(int[] input); static double[][] convert(int[][] input); static double[] convert(float[] input); static boolean arrayEqualsInRange(double[] d1, double[] d2, double range); static boolean arrayEquals(double[] d1, double[] d2); static double[] appendZeros(double[] darray, int zeroAmountToAppend); static double[] normalize16bitLittleEndian(byte[] bytez); static double[] normalize16bitLittleEndian(byte[] bytez, int amount); static byte[] denormalize16BitLittleEndian(double[] input); static int[] toUnsignedInteger(double[] input, int max); static double max(double... input); static double min(double... input); static void validateArray(double... input); static int maxIndex(double... input); static int minIndex(double... input); static double sum(double... input); static double[] sum(double[] a1, double[] a2); static void addToFirst(double[] first, double[] second); static void addToAll(double[] data, double valueToAdd); static void addToFirstScaled(double[] first, double[] second, double scale); static double[] square(double... input); static void squareInPlace(double... input); static double[] subtract(double[] a1, double[] a2); static void subtractFromFirst(double[] first, double[] second); static double[] multiply(double[] a1, double[] a2); static double dotProduct(double[] a1, double[] a2); static void multiplyToFirst(double[] first, double[] second); static double[] scale(double[] a1, double b); static void scaleInPlace(double[] a1, double b); static double mean(double... input); static double absoluteSumOfDifferences(double[] a, double[] b); static double[] absoluteDifference(double[] a, double[] b); static void validateArrays(double[] a1, double[] a2); static double squaredSum(double[] array); static double squaredSumOfDifferences(double[] a, double[] b); static double variance(double[] input); static double standardDeviation(double[] a); static boolean containsNaN(double[] a); static void floorInPlace(double[] var, double minValue); static void nonZeroFloorInPlace(double[] data, double floor); static void normalizeInPlace(double[] data); static void serialize(DataOutputStream dos, double[] data); static void serializeRaw(DataOutputStream dos, double[] data); static void serialize(DataOutputStream dos, double[][] data); static void serializeRaw(DataOutputStream dos, double[][] data); static double[] deserialize(DataInputStream dis); static double[] deserializeRaw(DataInputStream dis, int amount); static void deserializeRaw(DataInputStream dis, double[] result); static double[][] deserialize2d(DataInputStream dis); static void deserialize2DRaw(DataInputStream dis, double[][] result); static double[][] clone2D(double[][] result); static double[] fromString(String str, String delimiter); static String format(double... input); static String format(int fractionDigits, String delimiter, double... input); static String format(int rightPad, int fractionDigits, String delimiter, double... input); static double[] reduceFractionDigits(double[] arr, int digitCount); static float[] fromDelimitedString(String input, String delimiter); static final double[] ZERO_LENGTH_ARRAY; }
|
@Test public void testToUnsignedInteger() { double[] da = {0.2, -0.4, 0.6}; int[] ia = DoubleArrays.toUnsignedInteger(da, 6); Assert.assertEquals((int) (0.2 * 3.0), ia[0]); Assert.assertEquals((int) (-0.4 * 3.0), ia[1]); }
|
BlockTextLoader implements Iterable<TextChunk> { public static BlockTextLoader fromPath(Path corpus, int blockSize) { return new BlockTextLoader(Collections.singletonList(corpus), blockSize); } BlockTextLoader(List<Path> corpusPaths, int blockSize); List<Path> getCorpusPaths(); int getBlockSize(); int pathCount(); static BlockTextLoader fromPaths(List<Path> corpora); static BlockTextLoader fromDirectory(Path directoryPath); static BlockTextLoader fromPaths(List<Path> corpora, int blockSize); static BlockTextLoader fromPath(Path corpus, int blockSize); static BlockTextLoader fromDirectoryRoot(
Path corporaRoot,
Path folderListFile,
int blockSize); @Override Iterator<TextChunk> iterator(); static Iterator<TextChunk> singlePathIterator(Path path, int blockSize); static Iterator<TextChunk> iteratorFromCharIndex(
Path path,
int blockSize,
long charIndex); }
|
@Test public void loadTest1() throws IOException { List<String> lines = new ArrayList<>(); for (int i = 0; i < 10000; i++) { lines.add(String.valueOf(i)); } Path path = TestUtil.tempFileWithData(lines); BlockTextLoader loader = BlockTextLoader.fromPath(path, 1000); int i = 0; List<String> read = new ArrayList<>(); for (TextChunk block : loader) { i++; read.addAll(block.getData()); } Assert.assertEquals(i, 10); Assert.assertEquals(lines, read); loader = BlockTextLoader.fromPath(path, 1001); i = 0; read = new ArrayList<>(); for (TextChunk block : loader) { i++; read.addAll(block.getData()); } Assert.assertEquals(i, 10); Assert.assertEquals(lines, read); loader = BlockTextLoader.fromPath(path, 100000); i = 0; read = new ArrayList<>(); for (TextChunk block : loader) { i++; read.addAll(block.getData()); } Assert.assertEquals(i, 1); Assert.assertEquals(lines, read); Files.delete(path); }
|
Histogram implements Iterable<T> { public void remove(T t) { map.remove(t); } Histogram(int initialSize); Histogram(Map<T, Integer> countMap); Histogram(); static Histogram<String> loadFromLines(List<String> lines, char delimiter); static Histogram<String> loadFromLines(
List<String> lines,
char delimiter,
boolean keyComesFirst); static Histogram<String> loadFromUtf8File(Path path, char delimiter); static Histogram<String> loadFromUtf8File(
Path path,
char delimiter,
boolean keyComesFirst); static void serializeStringHistogram(Histogram<String> h, DataOutputStream dos); static Histogram<String> deserializeStringHistogram(DataInputStream dis); void saveSortedByCounts(Path path, String delimiter); void saveSortedByKeys(Path path, String delimiter, Comparator<T> comparator); int add(T t); int add(T t, int count); void add(Histogram<T> otherSet); T lookup(T item); void add(Collection<T> collection); @SafeVarargs final void add(T... array); int size(); void set(T t, int c); int decrementIfPositive(T t); int getCount(T t); boolean contains(T t); List<T> getTop(int n); int removeSmaller(int minCount); int removeLarger(int maxCount); int sizeSmaller(int amount); void remove(T t); void removeAll(Iterable<T> items); int sizeLarger(int amount); long totalCount(int minValue, int maxValue); int maxValue(); int minValue(); List<T> getItemsWithCount(int value); List<T> getItemsWithCount(int min, int max); double countPercent(int min, int max); List<T> getSortedList(); Set<T> getIntersectionOfKeys(Histogram<T> other); List<IntValueMap.Entry<T>> getSortedEntryList(); List<IntValueMap.Entry<T>> getEntryList(); long totalCount(Iterable<T> it); List<T> getSortedList(Comparator<T> comp); Set<T> getKeySet(); Iterator<T> iterator(); long totalCount(); }
|
@Test public void testRemove() { Histogram<String> histogram = new Histogram<>(); histogram.add("Apple", "Pear", "Plum", "Apple", "Apple", "Grape", "Pear"); histogram.remove("Apple"); Assert.assertEquals(0, histogram.getCount("Apple")); Assert.assertEquals(2, histogram.getCount("Pear")); Assert.assertEquals(1, histogram.getCount("Plum")); Assert.assertFalse(histogram.contains("Apple")); }
|
Histogram implements Iterable<T> { public int add(T t) { return add(t, 1); } Histogram(int initialSize); Histogram(Map<T, Integer> countMap); Histogram(); static Histogram<String> loadFromLines(List<String> lines, char delimiter); static Histogram<String> loadFromLines(
List<String> lines,
char delimiter,
boolean keyComesFirst); static Histogram<String> loadFromUtf8File(Path path, char delimiter); static Histogram<String> loadFromUtf8File(
Path path,
char delimiter,
boolean keyComesFirst); static void serializeStringHistogram(Histogram<String> h, DataOutputStream dos); static Histogram<String> deserializeStringHistogram(DataInputStream dis); void saveSortedByCounts(Path path, String delimiter); void saveSortedByKeys(Path path, String delimiter, Comparator<T> comparator); int add(T t); int add(T t, int count); void add(Histogram<T> otherSet); T lookup(T item); void add(Collection<T> collection); @SafeVarargs final void add(T... array); int size(); void set(T t, int c); int decrementIfPositive(T t); int getCount(T t); boolean contains(T t); List<T> getTop(int n); int removeSmaller(int minCount); int removeLarger(int maxCount); int sizeSmaller(int amount); void remove(T t); void removeAll(Iterable<T> items); int sizeLarger(int amount); long totalCount(int minValue, int maxValue); int maxValue(); int minValue(); List<T> getItemsWithCount(int value); List<T> getItemsWithCount(int min, int max); double countPercent(int min, int max); List<T> getSortedList(); Set<T> getIntersectionOfKeys(Histogram<T> other); List<IntValueMap.Entry<T>> getSortedEntryList(); List<IntValueMap.Entry<T>> getEntryList(); long totalCount(Iterable<T> it); List<T> getSortedList(Comparator<T> comp); Set<T> getKeySet(); Iterator<T> iterator(); long totalCount(); }
|
@Test @Ignore("Not a test.") public void testMergePerformance() throws IOException { Histogram<String> first = new Histogram<>(); Histogram<String> second = new Histogram<>(); Set<String> c1 = uniqueStrings(1000000, 5); Set<String> c2 = uniqueStrings(1000000, 5); Stopwatch sw = Stopwatch.createStarted(); first.add(c1); second.add(c2); System.out.println("Elapsed:" + sw.elapsed(TimeUnit.MILLISECONDS)); sw.reset().start(); first.add(second); System.out.println("Elapsed:" + sw.elapsed(TimeUnit.MILLISECONDS)); }
|
UIntValueMap extends HashBase<T> implements Iterable<T> { public int incrementByAmount(T key, int amount) { if (key == null) { throw new IllegalArgumentException("Key cannot be null."); } if (keyCount + removeCount == threshold) { expand(); } int l = locate(key); if (l < 0) { l = -l - 1; values[l] = amount; keys[l] = key; keyCount++; if (values[l] < 0) { throw new IllegalStateException("Value reached to negative."); } return values[l]; } else { values[l] += amount; if (values[l] < 0) { throw new IllegalStateException("Value reached to negative."); } return values[l]; } } UIntValueMap(); UIntValueMap(int size); int get(T key); void put(T key, int value); int increment(T key); void incrementAll(Iterable<T> keys); int decrement(T key); int incrementByAmount(T key, int amount); List<IntValueMap.Entry<T>> getAsEntryList(); Iterator<IntValueMap.Entry<T>> entryIterator(); Iterable<IntValueMap.Entry<T>> iterableEntries(); int sizeLarger(int amount); int sizeSmaller(int amount); int maxValue(); int minValue(); long sumOfValues(int minValue, int maxValue); int[] valueArray(); long sumOfValues(); }
|
@Test public void stressTest() { List<String> stringSet = randomNumberStrings(100_000); UIntValueMap<String> a = new UIntValueMap<>(); UIntValueMap<String> b = new UIntValueMap<>(); for (int i = 0; i < 20; i++) { for (String s : stringSet) { char c = s.charAt(s.length() - 1); if (a.contains(s)) { a.incrementByAmount(s, 1); continue; } if (b.contains(s)) { b.incrementByAmount(s, 1); continue; } if (c % 2 == 0) { a.incrementByAmount(s, 1); } else { b.incrementByAmount(s, 1); } } } Log.info("[a] key count = %d ", a.size()); Log.info("[b] key count = %d ", b.size()); for (String k : a) { Assert.assertFalse(b.contains(k)); } }
|
IntVector { public void add(int i) { if (size == data.length) { expand(); } data[size] = i; size++; } IntVector(); IntVector(int initialCapacity); IntVector(int[] values); void add(int i); void addAll(int[] arr); void addAll(IntVector vec); int get(int index); void set(int index, int value); void safeSet(int index, int value); int size(); int capacity(); void sort(); int[] copyOf(); void shuffle(Random random); boolean contains(int i); void shuffle(); void trimToSize(); boolean isempty(); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void testAdd() { IntVector darray = new IntVector(); for (int i = 0; i < 10000; i++) { darray.add(i); } Assert.assertEquals(10000, darray.size()); for (int i = 0; i < 10000; i++) { Assert.assertEquals(i, darray.get(i)); } }
|
IntVector { public void addAll(int[] arr) { if (size + arr.length >= data.length) { expand(arr.length); } System.arraycopy(arr, 0, data, size, arr.length); size += arr.length; } IntVector(); IntVector(int initialCapacity); IntVector(int[] values); void add(int i); void addAll(int[] arr); void addAll(IntVector vec); int get(int index); void set(int index, int value); void safeSet(int index, int value); int size(); int capacity(); void sort(); int[] copyOf(); void shuffle(Random random); boolean contains(int i); void shuffle(); void trimToSize(); boolean isempty(); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void testAddAll() { int[] d1 = {2, 4, 5, 17, -1, -2, 5, -123}; IntVector darray = new IntVector(); IntVector i = new IntVector(d1); darray.addAll(i); Assert.assertEquals(i, darray); }
|
IntVector { public void trimToSize() { data = Arrays.copyOf(data, size); } IntVector(); IntVector(int initialCapacity); IntVector(int[] values); void add(int i); void addAll(int[] arr); void addAll(IntVector vec); int get(int index); void set(int index, int value); void safeSet(int index, int value); int size(); int capacity(); void sort(); int[] copyOf(); void shuffle(Random random); boolean contains(int i); void shuffle(); void trimToSize(); boolean isempty(); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void testTrimToSize() { IntVector darray = new IntVector(); for (int i = 0; i < 10000; i++) { darray.add(i); } Assert.assertEquals(10000, darray.size()); Assert.assertNotEquals(darray.size(), darray.capacity()); darray.trimToSize(); Assert.assertEquals(10000, darray.size()); Assert.assertEquals(10000, darray.copyOf().length); Assert.assertEquals(darray.size(), darray.capacity()); }
|
LongBitVector { public void fill(boolean bitValue) { if (bitValue) { Arrays.fill(words, 0xffffffffffffffffL); int last = (int) (size / 64); words[last] &= cutMasks[(int) (size & mod64Mask)] >>> 1; } else { Arrays.fill(words, 0); } } LongBitVector(); LongBitVector(long initialCapcity); LongBitVector(long[] words, long size); LongBitVector(long initialCapcity, int capacityInterval); static LongBitVector deserialize(DataInputStream dis); long getLastBitIndex(boolean bitValue); void fill(boolean bitValue); long[] getLongArray(); long[] zeroIndexes(); int[] zeroIntIndexes(); long size(); void add(boolean b); void addFast(boolean b); long getLong(long start, int bitAmount); void add(int a, int bitLength); void add(int amount, boolean bit); void add(long a, int bitLength); long numberOfOnes(); long numberOfZeros(); void checkAndEnsureCapacity(int bitAmount); boolean get(long n); void set(long n); void set(long[] n); void clear(long n); void clear(long[] n); void serialize(DataOutputStream dos); static final long MAX_ARRAY_SIZE; }
|
@Test public void fillTest() { LongBitVector vector = new LongBitVector(128); vector.add(128, false); for (int i = 0; i < 128; i++) { Assert.assertTrue(!vector.get(i)); } vector.fill(true); for (int i = 0; i < 128; i++) { Assert.assertTrue(vector.get(i)); } vector.fill(false); for (int i = 0; i < 128; i++) { Assert.assertTrue(!vector.get(i)); } vector = new LongBitVector(3); vector.add(3, false); vector.fill(true); assertEquals(vector.getLongArray()[0], 7); }
|
UIntMap extends UIntKeyHashBase implements Iterable<T> { public T get(int key) { if (key < 0) { throw new IllegalArgumentException("Key cannot be negative: " + key); } int slot = hash(key) & modulo; while (true) { final int t = keys[slot]; if (t == EMPTY) { return null; } if (t == DELETED) { slot = (slot + 1) & modulo; continue; } if (t == key) { return values[slot]; } slot = (slot + 1) & modulo; } } UIntMap(); UIntMap(int size); T get(int key); boolean containsKey(int key); void put(int key, T value); List<T> getValues(); @Override Iterator<T> iterator(); List<T> getValuesSortedByKey(); }
|
@Test public void getTest() { UIntMap<String> map = new UIntMap<>(1); map.put(1, "2"); Assert.assertEquals("2", map.get(1)); Assert.assertNull(map.get(2)); map.put(1, "3"); Assert.assertEquals("3", map.get(1)); map = new UIntMap<>(); for (int i = 0; i < 100000; i++) { map.put(i, String.valueOf(i + 1)); } for (int i = 0; i < 100000; i++) { Assert.assertEquals(String.valueOf(i + 1), map.get(i)); } }
|
UIntMap extends UIntKeyHashBase implements Iterable<T> { public List<T> getValues() { List<T> result = new ArrayList<>(); for (int i = 0; i < keys.length; i++) { int key = keys[i]; if (key >= 0) { result.add(values[i]); } } return result; } UIntMap(); UIntMap(int size); T get(int key); boolean containsKey(int key); void put(int key, T value); List<T> getValues(); @Override Iterator<T> iterator(); List<T> getValuesSortedByKey(); }
|
@Test public void getValuesTest() { UIntMap<String> map = new UIntMap<>(); int size = 1000; List<String> expected = new ArrayList<>(); for (int i = 0; i < size; i++) { String value = String.valueOf(i + 1); map.put(i, value); expected.add(value); } Assert.assertEquals(expected, map.getValuesSortedByKey()); }
|
IntIntMap extends CompactIntMapBase { public int get(int key) { checkKey(key); int slot = firstProbe(key); while (true) { final long entry = entries[slot]; final int t = (int) (entry & 0xFFFF_FFFFL); if (t == key) { return (int) (entry >>> 32); } if (t == EMPTY) { return NO_RESULT; } slot = probe(slot); } } IntIntMap(); IntIntMap(int capacity); void put(int key, int value); void increment(int key, int value); int get(int key); int[] getValues(); IntPair[] getAsPairs(); }
|
@Test public void removeSpansWorksCorrectly2() { IntIntMap im = createMap(); int limit = 9999; insertSpan(im, 0, limit); int[] r = TestUtils.createRandomUintArray(1000, limit); for (int i : r) { im.remove(i); } for (int i : r) { assertEquals(im.get(i), IntIntMap.NO_RESULT); } insertSpan(im, 0, limit); checkSpan(im, 0, limit); removeSpan(im, 0, limit); assertEquals(im.size(), 0); insertSpan(im, -limit, limit); checkSpan(im, -limit, limit); }
|
IntIntMap extends CompactIntMapBase { public void put(int key, int value) { checkKey(key); expandIfNecessary(); int loc = locate(key); if (loc >= 0) { setValue(loc, value); } else { setKeyValue(-loc - 1, key, value); keyCount++; } } IntIntMap(); IntIntMap(int capacity); void put(int key, int value); void increment(int key, int value); int get(int key); int[] getValues(); IntPair[] getAsPairs(); }
|
@Test public void removeTest2() { IntIntMap map = createMap(); for (int i = 0; i < 10000; i++) { map.put(i, i + 1); } for (int i = 0; i < 10000; i += 3) { map.remove(i); } for (int i = 0; i < 10000; i += 3) { Assert.assertTrue(!map.containsKey(i)); } for (int i = 0; i < 10000; i++) { map.put(i, i + 1); } for (int i = 0; i < 10000; i += 3) { Assert.assertTrue(map.containsKey(i)); } }
|
IntValueMap extends HashBase<T> implements Iterable<T> { public int addOrIncrement(T key) { return incrementByAmount(key, 1); } IntValueMap(); IntValueMap(int size); int addOrIncrement(T key); void addOrIncrementAll(Iterable<T> keys); int get(T key); int decrement(T key); int incrementByAmount(T key, int amount); void put(T key, int value); int[] copyOfValues(); List<Entry<T>> getAsEntryList(); Iterator<Entry<T>> entryIterator(); Iterable<Entry<T>> iterableEntries(); }
|
@Test public void constructorTest2() { IntValueMap<String> set = new IntValueMap<>(1); set.addOrIncrement("foo"); Assert.assertEquals(1, set.size()); set.remove("foo"); Assert.assertEquals(0, set.size()); Assert.assertFalse(set.contains("foo")); }
|
IntValueMap extends HashBase<T> implements Iterable<T> { public void put(T key, int value) { if (key == null) { throw new IllegalArgumentException("Key cannot be null."); } if (keyCount + removeCount == threshold) { expand(); } int loc = locate(key); if (loc >= 0) { values[loc] = value; } else { loc = -loc - 1; keys[loc] = key; values[loc] = value; keyCount++; } } IntValueMap(); IntValueMap(int size); int addOrIncrement(T key); void addOrIncrementAll(Iterable<T> keys); int get(T key); int decrement(T key); int incrementByAmount(T key, int amount); void put(T key, int value); int[] copyOfValues(); List<Entry<T>> getAsEntryList(); Iterator<Entry<T>> entryIterator(); Iterable<Entry<T>> iterableEntries(); }
|
@Test public void putTest() { IntValueMap<String> table = new IntValueMap<>(); table.put("foo", 1); Assert.assertEquals(1, table.size()); table.put("foo", 2); Assert.assertEquals(1, table.size()); table = new IntValueMap<>(); for (int i = 0; i < 1000; i++) { table.put(String.valueOf(i), i + 1); Assert.assertEquals(i + 1, table.size()); } table = new IntValueMap<>(); for (int i = 0; i < 1000; i++) { table.put(String.valueOf(i), i + 1); table.put(String.valueOf(i), i + 1); Assert.assertEquals(i + 1, table.size()); } }
|
IntValueMap extends HashBase<T> implements Iterable<T> { private void expand() { IntValueMap<T> h = new IntValueMap<>(newSize()); for (int i = 0; i < keys.length; i++) { if (hasValidKey(i)) { h.put(keys[i], values[i]); } } expandCopyParameters(h); this.values = h.values; } IntValueMap(); IntValueMap(int size); int addOrIncrement(T key); void addOrIncrementAll(Iterable<T> keys); int get(T key); int decrement(T key); int incrementByAmount(T key, int amount); void put(T key, int value); int[] copyOfValues(); List<Entry<T>> getAsEntryList(); Iterator<Entry<T>> entryIterator(); Iterable<Entry<T>> iterableEntries(); }
|
@Test public void expandTest() { IntValueMap<String> table = new IntValueMap<>(); for (int i = 0; i < 10000; i++) { table.put(String.valueOf(i), i + 1); Assert.assertEquals(i + 1, table.size()); } for (int i = 0; i < 5000; i++) { table.remove(String.valueOf(i)); Assert.assertEquals(10000 - i - 1, table.size()); } for (int i = 5000; i < 10000; i++) { Assert.assertEquals(i + 1, table.get(String.valueOf(i))); } }
|
IntValueMap extends HashBase<T> implements Iterable<T> { public int get(T key) { if (key == null) { throw new IllegalArgumentException("Key cannot be null."); } int slot = hash(key) & modulo; while (true) { final T t = keys[slot]; if (t == null) { return 0; } if (t == TOMB_STONE) { slot = (slot + 1) & modulo; continue; } if (t.equals(key)) { return values[slot]; } slot = (slot + 1) & modulo; } } IntValueMap(); IntValueMap(int size); int addOrIncrement(T key); void addOrIncrementAll(Iterable<T> keys); int get(T key); int decrement(T key); int incrementByAmount(T key, int amount); void put(T key, int value); int[] copyOfValues(); List<Entry<T>> getAsEntryList(); Iterator<Entry<T>> entryIterator(); Iterable<Entry<T>> iterableEntries(); }
|
@Test public void getTest() { IntValueMap<Integer> table = new IntValueMap<>(); table.put(1, 2); Assert.assertEquals(2, table.get(1)); Assert.assertEquals(0, table.get(2)); table.put(1, 3); Assert.assertEquals(3, table.get(1)); table = new IntValueMap<>(); for (int i = 0; i < 1000; i++) { table.put(i, i + 1); } for (int i = 0; i < 1000; i++) { Assert.assertEquals(i + 1, table.get(i)); } }
|
IntValueMap extends HashBase<T> implements Iterable<T> { public int[] copyOfValues() { int[] result = new int[keyCount]; int k = 0; for (int i = 0; i < keys.length; i++) { if (hasValidKey(i)) { result[k] = values[i]; k++; } } return result; } IntValueMap(); IntValueMap(int size); int addOrIncrement(T key); void addOrIncrementAll(Iterable<T> keys); int get(T key); int decrement(T key); int incrementByAmount(T key, int amount); void put(T key, int value); int[] copyOfValues(); List<Entry<T>> getAsEntryList(); Iterator<Entry<T>> entryIterator(); Iterable<Entry<T>> iterableEntries(); }
|
@Test public void copyOfValuesTest() { IntValueMap<String> set = new IntValueMap<>(); for (int i = 0; i < 1000; i++) { set.put(String.valueOf(i), i + 1); } int[] values = set.copyOfValues(); Assert.assertEquals(1000, values.length); Arrays.sort(values); for (int i = 0; i < 1000; i++) { Assert.assertEquals(i + 1, values[i]); } set.remove("768"); set.remove("0"); set.remove("999"); values = set.copyOfValues(); Assert.assertEquals(997, values.length); Arrays.sort(values); Assert.assertTrue(Arrays.binarySearch(values, 769) < 0); Assert.assertTrue(Arrays.binarySearch(values, 1) < 0); Assert.assertTrue(Arrays.binarySearch(values, 1000) < 0); }
|
IntValueMap extends HashBase<T> implements Iterable<T> { public void addOrIncrementAll(Iterable<T> keys) { for (T t : keys) { incrementByAmount(t, 1); } } IntValueMap(); IntValueMap(int size); int addOrIncrement(T key); void addOrIncrementAll(Iterable<T> keys); int get(T key); int decrement(T key); int incrementByAmount(T key, int amount); void put(T key, int value); int[] copyOfValues(); List<Entry<T>> getAsEntryList(); Iterator<Entry<T>> entryIterator(); Iterable<Entry<T>> iterableEntries(); }
|
@Test @Ignore("Not a unit test") public void perfStrings() { for (int i = 0; i < 5; i++) { Set<String> strings = uniqueStrings(1000000, 7); Stopwatch sw = Stopwatch.createStarted(); Set<String> newSet = new HashSet<>(strings); System.out.println("Java Set : " + sw.elapsed(TimeUnit.MILLISECONDS)); System.out.println("Size = " + newSet.size()); sw.reset().start(); IntValueMap<String> cs = new IntValueMap<>(strings.size() * 2); cs.addOrIncrementAll(strings); System.out.println("Count Add : " + sw.elapsed(TimeUnit.MILLISECONDS)); } }
|
FixedBitVector { public boolean safeGet(int n) { check(n); return (words[n >> 5] & setMasks[n & 31]) != 0; } FixedBitVector(int length); boolean get(int n); boolean safeGet(int n); void set(int n); void safeSet(int n); void clear(int n); void safeClear(int n); int numberOfOnes(); int numberOfNewOneBitCount(FixedBitVector other); int differentBitCount(FixedBitVector other); int numberOfZeroes(); int[] zeroIndexes(); final int length; }
|
@Test(expected = IllegalArgumentException.class) public void safeGet() { FixedBitVector vector = new FixedBitVector(10); vector.safeGet(10); }
|
FixedBitVector { public void safeSet(int n) { check(n); words[n >> 5] |= setMasks[n & 31]; } FixedBitVector(int length); boolean get(int n); boolean safeGet(int n); void set(int n); void safeSet(int n); void clear(int n); void safeClear(int n); int numberOfOnes(); int numberOfNewOneBitCount(FixedBitVector other); int differentBitCount(FixedBitVector other); int numberOfZeroes(); int[] zeroIndexes(); final int length; }
|
@Test(expected = IllegalArgumentException.class) public void safeSet() { FixedBitVector vector = new FixedBitVector(10); vector.safeSet(10); }
|
FixedBitVector { public void safeClear(int n) { check(n); words[n >> 5] &= resetMasks[n & 31]; } FixedBitVector(int length); boolean get(int n); boolean safeGet(int n); void set(int n); void safeSet(int n); void clear(int n); void safeClear(int n); int numberOfOnes(); int numberOfNewOneBitCount(FixedBitVector other); int differentBitCount(FixedBitVector other); int numberOfZeroes(); int[] zeroIndexes(); final int length; }
|
@Test(expected = IllegalArgumentException.class) public void safeClear() { FixedBitVector vector = new FixedBitVector(10); vector.safeClear(10); }
|
FloatValueMap extends HashBase<T> implements Iterable<T> { public float[] values() { float[] result = new float[size()]; int j = 0; for (int i = 0; i < keys.length; i++) { if (hasValidKey(i)) { result[j++] = values[i]; } } return result; } FloatValueMap(); FloatValueMap(int size); private FloatValueMap(FloatValueMap<T> other, T[] keys, float[] values); float get(T key); float incrementByAmount(T key, float amount); void set(T key, float value); float[] values(); List<Entry<T>> getAsEntryList(); FloatValueMap<T> copy(); Iterator<Entry<T>> entryIterator(); Iterable<Entry<T>> iterableEntries(); }
|
@Test public void testValues() { FloatValueMap<String> set = new FloatValueMap<>(); set.set("a", 7); set.set("b", 2); set.set("c", 3); set.set("d", 4); set.set("d", 5); Assert.assertEquals(4, set.size()); float[] values = set.values(); Arrays.sort(values); Assert.assertTrue(Arrays.equals(new float[]{2f, 3f, 5f, 7f}, values)); }
|
LookupSet extends HashBase<T> implements Iterable<T> { public boolean add(T key) { if (key == null) { throw new IllegalArgumentException("Key cannot be null."); } if (keyCount + removeCount == threshold) { expand(); } int loc = locate(key); if (loc >= 0) { return false; } else { loc = -loc - 1; keys[loc] = key; keyCount++; return true; } } LookupSet(); LookupSet(int size); T set(T key); @SafeVarargs final void addAll(T... t); void addAll(Iterable<T> it); boolean add(T key); T getOrAdd(T key); }
|
@Test public void addTest() { Foo f1 = new Foo("abc", 1); Foo f2 = new Foo("abc", 2); LookupSet<Foo> fooSet = new LookupSet<>(); Assert.assertTrue(fooSet.add(f1)); Assert.assertFalse(fooSet.add(f2)); }
@Test public void lookupTest() { Foo f1 = new Foo("abc", 1); Foo f2 = new Foo("abc", 2); LookupSet<Foo> fooSet = new LookupSet<>(); Assert.assertNull(fooSet.lookup(f1)); Assert.assertNull(fooSet.lookup(f2)); fooSet.add(f1); Assert.assertEquals(1, fooSet.lookup(f1).b); Assert.assertEquals(1, fooSet.lookup(f2).b); fooSet.add(f2); Assert.assertEquals(1, fooSet.lookup(f1).b); Assert.assertEquals(1, fooSet.lookup(f2).b); }
|
LookupSet extends HashBase<T> implements Iterable<T> { public T getOrAdd(T key) { if (key == null) { throw new IllegalArgumentException("Key cannot be null."); } if (keyCount + removeCount == threshold) { expand(); } int loc = locate(key); if (loc >= 0) { return keys[loc]; } else { loc = -loc - 1; keys[loc] = key; keyCount++; return key; } } LookupSet(); LookupSet(int size); T set(T key); @SafeVarargs final void addAll(T... t); void addAll(Iterable<T> it); boolean add(T key); T getOrAdd(T key); }
|
@Test public void getOrAddTest() { Foo f1 = new Foo("abc", 1); Foo f2 = new Foo("abc", 2); LookupSet<Foo> fooSet = new LookupSet<>(); Assert.assertEquals(1, fooSet.getOrAdd(f1).b); Assert.assertEquals(1, fooSet.getOrAdd(f2).b); }
@Test public void removeTest() { Foo f1 = new Foo("abc", 1); Foo f2 = new Foo("abc", 2); LookupSet<Foo> fooSet = new LookupSet<>(); Assert.assertEquals(1, fooSet.getOrAdd(f1).b); Assert.assertEquals(1, fooSet.getOrAdd(f2).b); Assert.assertEquals(1, fooSet.remove(f2).b); Assert.assertEquals(2, fooSet.getOrAdd(f2).b); }
|
IntFloatMap extends CompactIntMapBase { public float get(int key) { checkKey(key); int slot = firstProbe(key); while (true) { final long entry = entries[slot]; final int t = (int) (entry & 0xFFFF_FFFFL); if (t == key) { return Float.intBitsToFloat((int) (entry >>> 32)); } if (t == EMPTY) { return NO_RESULT; } slot = probe(slot); } } IntFloatMap(); IntFloatMap(int capacity); void put(int key, float value); void increment(int key, float value); float get(int key); float[] getValues(); }
|
@Test public void removeSpansWorksCorrectly2() { IntFloatMap im = createMap(); int limit = 9999; insertSpan(im, 0, limit); int[] r = TestUtils.createRandomUintArray(1000, limit); for (int i : r) { im.remove(i); } for (int i : r) { assertEqualsF(im.get(i), IntIntMap.NO_RESULT); } insertSpan(im, 0, limit); checkSpan(im, 0, limit); removeSpan(im, 0, limit); assertEqualsF(im.size(), 0); insertSpan(im, -limit, limit); checkSpan(im, -limit, limit); }
|
IntFloatMap extends CompactIntMapBase { public void put(int key, float value) { checkKey(key); expandIfNecessary(); int loc = locate(key); if (loc >= 0) { setValue(loc, value); } else { setKeyValue(-loc - 1, key, value); keyCount++; } } IntFloatMap(); IntFloatMap(int capacity); void put(int key, float value); void increment(int key, float value); float get(int key); float[] getValues(); }
|
@Test public void removeTest2() { IntFloatMap map = createMap(); for (int i = 0; i < 10000; i++) { map.put(i, i + 1); } for (int i = 0; i < 10000; i += 3) { map.remove(i); } for (int i = 0; i < 10000; i += 3) { Assert.assertTrue(!map.containsKey(i)); } for (int i = 0; i < 10000; i++) { map.put(i, i + 1); } for (int i = 0; i < 10000; i += 3) { Assert.assertTrue(map.containsKey(i)); } }
|
Trie { public List<T> getAll() { List<T> items = new ArrayList<>(size); List<Node<T>> toWalk = Lists.newArrayList(root); while (toWalk.size() > 0) { List<Node<T>> n = new ArrayList<>(); for (Node<T> tNode : toWalk) { if (tNode.hasItem()) { items.addAll(tNode.items); } if (tNode.children != null && tNode.children.size() > 0) { n.addAll(tNode.children.getValues()); } } toWalk = n; } return items; } void add(String s, T item); void remove(String s, T item); int size(); boolean containsItem(String s, T item); List<T> getItems(String s); List<T> getAll(); List<T> getPrefixMatchingItems(String input); String toString(); }
|
@Test public void getAllTest() { List<Item> items = createitems("elma", "el", "arm", "armut", "a", "elmas"); additems(items); List<Item> all = lt.getAll(); Assert.assertEquals(6, all.size()); }
|
Trie { public void remove(String s, T item) { Node node = walkToNode(s); if (node != null && node.hasItem()) { node.items.remove(item); size--; } } void add(String s, T item); void remove(String s, T item); int size(); boolean containsItem(String s, T item); List<T> getItems(String s); List<T> getAll(); List<T> getPrefixMatchingItems(String input); String toString(); }
|
@Test public void removeStems() { List<Item> items = createitems("el", "elmas", "elma", "ela"); additems(items); checkitemsExist(items); checkitemsMatches("el", createitems("el")); checkitemsMatches("el", createitems()); lt.remove(items.get(1).surfaceForm, items.get(1)); checkitemsMatches("elmas", createitems()); checkitemsMatches("e", createitems()); checkitemsMatches("ela", createitems("ela")); checkitemsMatches("elastik", createitems("ela")); checkitemsMatches("elmas", createitems("el", "elma")); checkitemsMatches("elmaslar", createitems("el", "elma")); }
|
TurkishAlphabet { public boolean isVowel(char c) { return lookup(vowelLookup, c); } private TurkishAlphabet(); String toAscii(String in); String foreignDiacriticsToTurkish(String in); boolean containsAsciiRelated(String s); IntIntMap getTurkishToAsciiMap(); char getAsciiEqual(char c); boolean isAsciiEqual(char c1, char c2); boolean allCapital(String input); String normalize(String input); char normalizeCircumflex(char c); boolean containsCircumflex(String s); boolean isTurkishSpecific(char c); boolean containsApostrophe(String s); boolean containsForeignDiacritics(String s); String getAllLetters(); String getLowercaseLetters(); String getUppercaseLetters(); String normalizeCircumflex(String s); String normalizeApostrophe(String s); char voice(char c); char devoice(char c); TurkicLetter getLetter(char c); TurkicLetter getLastLetter(CharSequence s); char lastChar(CharSequence s); TurkicLetter getFirstLetter(CharSequence s); boolean isVowel(char c); boolean isDictionaryLetter(char c); boolean isStopConsonant(char c); boolean isVoicelessConsonant(char c); TurkicLetter getLastVowel(CharSequence s); TurkicLetter getFirstVowel(CharSequence s); boolean checkVowelHarmonyA(CharSequence source, CharSequence target); boolean checkVowelHarmonyI(CharSequence source, CharSequence target); boolean checkVowelHarmonyA(TurkicLetter source, TurkicLetter target); boolean checkVowelHarmonyI(TurkicLetter source, TurkicLetter target); boolean containsVowel(CharSequence s); int vowelCount(String s); boolean containsDigit(String s); boolean equalsIgnoreDiacritics(String s1, String s2); boolean startsWithIgnoreDiacritics(String s1, String s2); static final Locale TR; static TurkishAlphabet INSTANCE; }
|
@Test public void isVowelTest() { TurkishAlphabet alphabet = TurkishAlphabet.INSTANCE; String vowels = "aeiuüıoöâîû"; for (char c : vowels.toCharArray()) { Assert.assertTrue(alphabet.isVowel(c)); } String nonvowels = "bcçdfgğjklmnprştvxwzq."; for (char c : nonvowels.toCharArray()) { Assert.assertFalse(alphabet.isVowel(c)); } }
|
TurkishAlphabet { public int vowelCount(String s) { int result = 0; for (int i = 0; i < s.length(); i++) { if (isVowel(s.charAt(i))) { result++; } } return result; } private TurkishAlphabet(); String toAscii(String in); String foreignDiacriticsToTurkish(String in); boolean containsAsciiRelated(String s); IntIntMap getTurkishToAsciiMap(); char getAsciiEqual(char c); boolean isAsciiEqual(char c1, char c2); boolean allCapital(String input); String normalize(String input); char normalizeCircumflex(char c); boolean containsCircumflex(String s); boolean isTurkishSpecific(char c); boolean containsApostrophe(String s); boolean containsForeignDiacritics(String s); String getAllLetters(); String getLowercaseLetters(); String getUppercaseLetters(); String normalizeCircumflex(String s); String normalizeApostrophe(String s); char voice(char c); char devoice(char c); TurkicLetter getLetter(char c); TurkicLetter getLastLetter(CharSequence s); char lastChar(CharSequence s); TurkicLetter getFirstLetter(CharSequence s); boolean isVowel(char c); boolean isDictionaryLetter(char c); boolean isStopConsonant(char c); boolean isVoicelessConsonant(char c); TurkicLetter getLastVowel(CharSequence s); TurkicLetter getFirstVowel(CharSequence s); boolean checkVowelHarmonyA(CharSequence source, CharSequence target); boolean checkVowelHarmonyI(CharSequence source, CharSequence target); boolean checkVowelHarmonyA(TurkicLetter source, TurkicLetter target); boolean checkVowelHarmonyI(TurkicLetter source, TurkicLetter target); boolean containsVowel(CharSequence s); int vowelCount(String s); boolean containsDigit(String s); boolean equalsIgnoreDiacritics(String s1, String s2); boolean startsWithIgnoreDiacritics(String s1, String s2); static final Locale TR; static TurkishAlphabet INSTANCE; }
|
@Test public void vowelCountTest() { TurkishAlphabet alphabet = TurkishAlphabet.INSTANCE; String[] entries = {"a", "aa", "", "bb", "bebaba"}; int[] expCounts = {1, 2, 0, 0, 3}; int i = 0; for (String entry : entries) { Assert.assertEquals(expCounts[i++], alphabet.vowelCount(entry)); } }
|
TurkishAlphabet { public char voice(char c) { int res = voicingMap.get(c); return res == IntIntMap.NO_RESULT ? c : (char) res; } private TurkishAlphabet(); String toAscii(String in); String foreignDiacriticsToTurkish(String in); boolean containsAsciiRelated(String s); IntIntMap getTurkishToAsciiMap(); char getAsciiEqual(char c); boolean isAsciiEqual(char c1, char c2); boolean allCapital(String input); String normalize(String input); char normalizeCircumflex(char c); boolean containsCircumflex(String s); boolean isTurkishSpecific(char c); boolean containsApostrophe(String s); boolean containsForeignDiacritics(String s); String getAllLetters(); String getLowercaseLetters(); String getUppercaseLetters(); String normalizeCircumflex(String s); String normalizeApostrophe(String s); char voice(char c); char devoice(char c); TurkicLetter getLetter(char c); TurkicLetter getLastLetter(CharSequence s); char lastChar(CharSequence s); TurkicLetter getFirstLetter(CharSequence s); boolean isVowel(char c); boolean isDictionaryLetter(char c); boolean isStopConsonant(char c); boolean isVoicelessConsonant(char c); TurkicLetter getLastVowel(CharSequence s); TurkicLetter getFirstVowel(CharSequence s); boolean checkVowelHarmonyA(CharSequence source, CharSequence target); boolean checkVowelHarmonyI(CharSequence source, CharSequence target); boolean checkVowelHarmonyA(TurkicLetter source, TurkicLetter target); boolean checkVowelHarmonyI(TurkicLetter source, TurkicLetter target); boolean containsVowel(CharSequence s); int vowelCount(String s); boolean containsDigit(String s); boolean equalsIgnoreDiacritics(String s1, String s2); boolean startsWithIgnoreDiacritics(String s1, String s2); static final Locale TR; static TurkishAlphabet INSTANCE; }
|
@Test public void voiceTest() { TurkishAlphabet alphabet = TurkishAlphabet.INSTANCE; String iStr = "çÇgGkKpPtTaAbB"; String oStr = "cCğĞğĞbBdDaAbB"; for (int i = 0; i < iStr.length(); i++) { char in = iStr.charAt(i); char outExpected = oStr.charAt(i); Assert.assertEquals("", String.valueOf(outExpected), String.valueOf(alphabet.voice(in))); } }
|
TurkishAlphabet { public char devoice(char c) { int res = devoicingMap.get(c); return res == IntIntMap.NO_RESULT ? c : (char) res; } private TurkishAlphabet(); String toAscii(String in); String foreignDiacriticsToTurkish(String in); boolean containsAsciiRelated(String s); IntIntMap getTurkishToAsciiMap(); char getAsciiEqual(char c); boolean isAsciiEqual(char c1, char c2); boolean allCapital(String input); String normalize(String input); char normalizeCircumflex(char c); boolean containsCircumflex(String s); boolean isTurkishSpecific(char c); boolean containsApostrophe(String s); boolean containsForeignDiacritics(String s); String getAllLetters(); String getLowercaseLetters(); String getUppercaseLetters(); String normalizeCircumflex(String s); String normalizeApostrophe(String s); char voice(char c); char devoice(char c); TurkicLetter getLetter(char c); TurkicLetter getLastLetter(CharSequence s); char lastChar(CharSequence s); TurkicLetter getFirstLetter(CharSequence s); boolean isVowel(char c); boolean isDictionaryLetter(char c); boolean isStopConsonant(char c); boolean isVoicelessConsonant(char c); TurkicLetter getLastVowel(CharSequence s); TurkicLetter getFirstVowel(CharSequence s); boolean checkVowelHarmonyA(CharSequence source, CharSequence target); boolean checkVowelHarmonyI(CharSequence source, CharSequence target); boolean checkVowelHarmonyA(TurkicLetter source, TurkicLetter target); boolean checkVowelHarmonyI(TurkicLetter source, TurkicLetter target); boolean containsVowel(CharSequence s); int vowelCount(String s); boolean containsDigit(String s); boolean equalsIgnoreDiacritics(String s1, String s2); boolean startsWithIgnoreDiacritics(String s1, String s2); static final Locale TR; static TurkishAlphabet INSTANCE; }
|
@Test public void devoiceTest() { TurkishAlphabet alphabet = TurkishAlphabet.INSTANCE; String iStr = "bBcCdDgGğĞaAkK"; String oStr = "pPçÇtTkKkKaAkK"; for (int i = 0; i < iStr.length(); i++) { char in = iStr.charAt(i); char outExpected = oStr.charAt(i); Assert.assertEquals("", String.valueOf(outExpected), String.valueOf(alphabet.devoice(in))); } }
|
TurkishAlphabet { public char normalizeCircumflex(char c) { int res = circumflexMap.get(c); return res == IntIntMap.NO_RESULT ? c : (char) res; } private TurkishAlphabet(); String toAscii(String in); String foreignDiacriticsToTurkish(String in); boolean containsAsciiRelated(String s); IntIntMap getTurkishToAsciiMap(); char getAsciiEqual(char c); boolean isAsciiEqual(char c1, char c2); boolean allCapital(String input); String normalize(String input); char normalizeCircumflex(char c); boolean containsCircumflex(String s); boolean isTurkishSpecific(char c); boolean containsApostrophe(String s); boolean containsForeignDiacritics(String s); String getAllLetters(); String getLowercaseLetters(); String getUppercaseLetters(); String normalizeCircumflex(String s); String normalizeApostrophe(String s); char voice(char c); char devoice(char c); TurkicLetter getLetter(char c); TurkicLetter getLastLetter(CharSequence s); char lastChar(CharSequence s); TurkicLetter getFirstLetter(CharSequence s); boolean isVowel(char c); boolean isDictionaryLetter(char c); boolean isStopConsonant(char c); boolean isVoicelessConsonant(char c); TurkicLetter getLastVowel(CharSequence s); TurkicLetter getFirstVowel(CharSequence s); boolean checkVowelHarmonyA(CharSequence source, CharSequence target); boolean checkVowelHarmonyI(CharSequence source, CharSequence target); boolean checkVowelHarmonyA(TurkicLetter source, TurkicLetter target); boolean checkVowelHarmonyI(TurkicLetter source, TurkicLetter target); boolean containsVowel(CharSequence s); int vowelCount(String s); boolean containsDigit(String s); boolean equalsIgnoreDiacritics(String s1, String s2); boolean startsWithIgnoreDiacritics(String s1, String s2); static final Locale TR; static TurkishAlphabet INSTANCE; }
|
@Test public void circumflexTest() { TurkishAlphabet alphabet = TurkishAlphabet.INSTANCE; String iStr = "abcâîûÂÎÛ fg12"; String oStr = "abcaiuAİU fg12"; Assert.assertEquals(oStr, alphabet.normalizeCircumflex(iStr)); }
|
TurkishAlphabet { public String toAscii(String in) { StringBuilder sb = new StringBuilder(in.length()); for (int i = 0; i < in.length(); i++) { char c = in.charAt(i); int res = turkishToAsciiMap.get(c); char map = res == IntIntMap.NO_RESULT ? c : (char) res; sb.append(map); } return sb.toString(); } private TurkishAlphabet(); String toAscii(String in); String foreignDiacriticsToTurkish(String in); boolean containsAsciiRelated(String s); IntIntMap getTurkishToAsciiMap(); char getAsciiEqual(char c); boolean isAsciiEqual(char c1, char c2); boolean allCapital(String input); String normalize(String input); char normalizeCircumflex(char c); boolean containsCircumflex(String s); boolean isTurkishSpecific(char c); boolean containsApostrophe(String s); boolean containsForeignDiacritics(String s); String getAllLetters(); String getLowercaseLetters(); String getUppercaseLetters(); String normalizeCircumflex(String s); String normalizeApostrophe(String s); char voice(char c); char devoice(char c); TurkicLetter getLetter(char c); TurkicLetter getLastLetter(CharSequence s); char lastChar(CharSequence s); TurkicLetter getFirstLetter(CharSequence s); boolean isVowel(char c); boolean isDictionaryLetter(char c); boolean isStopConsonant(char c); boolean isVoicelessConsonant(char c); TurkicLetter getLastVowel(CharSequence s); TurkicLetter getFirstVowel(CharSequence s); boolean checkVowelHarmonyA(CharSequence source, CharSequence target); boolean checkVowelHarmonyI(CharSequence source, CharSequence target); boolean checkVowelHarmonyA(TurkicLetter source, TurkicLetter target); boolean checkVowelHarmonyI(TurkicLetter source, TurkicLetter target); boolean containsVowel(CharSequence s); int vowelCount(String s); boolean containsDigit(String s); boolean equalsIgnoreDiacritics(String s1, String s2); boolean startsWithIgnoreDiacritics(String s1, String s2); static final Locale TR; static TurkishAlphabet INSTANCE; }
|
@Test public void toAsciiTest() { TurkishAlphabet alphabet = TurkishAlphabet.INSTANCE; String iStr = "abcçğıiİIoöüşâîûÂÎÛz"; String oStr = "abccgiiIIoousaiuAIUz"; Assert.assertEquals(oStr, alphabet.toAscii(iStr)); }
|
TurkishAlphabet { public boolean equalsIgnoreDiacritics(String s1, String s2) { if (s1 == null || s2 == null) { return false; } if (s1.length() != s2.length()) { return false; } for (int i = 0; i < s1.length(); i++) { char c1 = s1.charAt(i); char c2 = s2.charAt(i); if (!isAsciiEqual(c1, c2)) { return false; } } return true; } private TurkishAlphabet(); String toAscii(String in); String foreignDiacriticsToTurkish(String in); boolean containsAsciiRelated(String s); IntIntMap getTurkishToAsciiMap(); char getAsciiEqual(char c); boolean isAsciiEqual(char c1, char c2); boolean allCapital(String input); String normalize(String input); char normalizeCircumflex(char c); boolean containsCircumflex(String s); boolean isTurkishSpecific(char c); boolean containsApostrophe(String s); boolean containsForeignDiacritics(String s); String getAllLetters(); String getLowercaseLetters(); String getUppercaseLetters(); String normalizeCircumflex(String s); String normalizeApostrophe(String s); char voice(char c); char devoice(char c); TurkicLetter getLetter(char c); TurkicLetter getLastLetter(CharSequence s); char lastChar(CharSequence s); TurkicLetter getFirstLetter(CharSequence s); boolean isVowel(char c); boolean isDictionaryLetter(char c); boolean isStopConsonant(char c); boolean isVoicelessConsonant(char c); TurkicLetter getLastVowel(CharSequence s); TurkicLetter getFirstVowel(CharSequence s); boolean checkVowelHarmonyA(CharSequence source, CharSequence target); boolean checkVowelHarmonyI(CharSequence source, CharSequence target); boolean checkVowelHarmonyA(TurkicLetter source, TurkicLetter target); boolean checkVowelHarmonyI(TurkicLetter source, TurkicLetter target); boolean containsVowel(CharSequence s); int vowelCount(String s); boolean containsDigit(String s); boolean equalsIgnoreDiacritics(String s1, String s2); boolean startsWithIgnoreDiacritics(String s1, String s2); static final Locale TR; static TurkishAlphabet INSTANCE; }
|
@Test public void equalsIgnoreDiacritics() { TurkishAlphabet alphabet = TurkishAlphabet.INSTANCE; String[] a = {"siraci", "ağac", "ağaç"}; String[] b = {"şıracı", "ağaç", "agac"}; for (int i = 0; i < a.length; i++) { Assert.assertTrue(alphabet.equalsIgnoreDiacritics(a[i], b[i])); } }
|
TurkishAlphabet { public boolean checkVowelHarmonyA(CharSequence source, CharSequence target) { TurkicLetter sourceLastVowel = getLastVowel(source); TurkicLetter targetFirstVowel = getLastVowel(target); return checkVowelHarmonyA(sourceLastVowel, targetFirstVowel); } private TurkishAlphabet(); String toAscii(String in); String foreignDiacriticsToTurkish(String in); boolean containsAsciiRelated(String s); IntIntMap getTurkishToAsciiMap(); char getAsciiEqual(char c); boolean isAsciiEqual(char c1, char c2); boolean allCapital(String input); String normalize(String input); char normalizeCircumflex(char c); boolean containsCircumflex(String s); boolean isTurkishSpecific(char c); boolean containsApostrophe(String s); boolean containsForeignDiacritics(String s); String getAllLetters(); String getLowercaseLetters(); String getUppercaseLetters(); String normalizeCircumflex(String s); String normalizeApostrophe(String s); char voice(char c); char devoice(char c); TurkicLetter getLetter(char c); TurkicLetter getLastLetter(CharSequence s); char lastChar(CharSequence s); TurkicLetter getFirstLetter(CharSequence s); boolean isVowel(char c); boolean isDictionaryLetter(char c); boolean isStopConsonant(char c); boolean isVoicelessConsonant(char c); TurkicLetter getLastVowel(CharSequence s); TurkicLetter getFirstVowel(CharSequence s); boolean checkVowelHarmonyA(CharSequence source, CharSequence target); boolean checkVowelHarmonyI(CharSequence source, CharSequence target); boolean checkVowelHarmonyA(TurkicLetter source, TurkicLetter target); boolean checkVowelHarmonyI(TurkicLetter source, TurkicLetter target); boolean containsVowel(CharSequence s); int vowelCount(String s); boolean containsDigit(String s); boolean equalsIgnoreDiacritics(String s1, String s2); boolean startsWithIgnoreDiacritics(String s1, String s2); static final Locale TR; static TurkishAlphabet INSTANCE; }
|
@Test public void vowelHarmonyA() { TurkishAlphabet alphabet = TurkishAlphabet.INSTANCE; String[] a = {"elma", "kedi", "turp"}; String[] b= {"lar", "cik", "un"}; for (int i = 0; i < a.length; i++) { Assert.assertTrue(alphabet.checkVowelHarmonyA(a[i], b[i])); } }
@Test public void vowelHarmonyA2() { TurkishAlphabet alphabet = TurkishAlphabet.INSTANCE; String[] a = {"elma", "kedi", "turp"}; String[] b = {"ler", "cık", "in"}; for (int i = 0; i < a.length; i++) { Assert.assertFalse(alphabet.checkVowelHarmonyA(a[i], b[i])); } }
|
TurkishAlphabet { public boolean checkVowelHarmonyI(CharSequence source, CharSequence target) { TurkicLetter sourceLastVowel = getLastVowel(source); TurkicLetter targetFirstVowel = getLastVowel(target); return checkVowelHarmonyI(sourceLastVowel, targetFirstVowel); } private TurkishAlphabet(); String toAscii(String in); String foreignDiacriticsToTurkish(String in); boolean containsAsciiRelated(String s); IntIntMap getTurkishToAsciiMap(); char getAsciiEqual(char c); boolean isAsciiEqual(char c1, char c2); boolean allCapital(String input); String normalize(String input); char normalizeCircumflex(char c); boolean containsCircumflex(String s); boolean isTurkishSpecific(char c); boolean containsApostrophe(String s); boolean containsForeignDiacritics(String s); String getAllLetters(); String getLowercaseLetters(); String getUppercaseLetters(); String normalizeCircumflex(String s); String normalizeApostrophe(String s); char voice(char c); char devoice(char c); TurkicLetter getLetter(char c); TurkicLetter getLastLetter(CharSequence s); char lastChar(CharSequence s); TurkicLetter getFirstLetter(CharSequence s); boolean isVowel(char c); boolean isDictionaryLetter(char c); boolean isStopConsonant(char c); boolean isVoicelessConsonant(char c); TurkicLetter getLastVowel(CharSequence s); TurkicLetter getFirstVowel(CharSequence s); boolean checkVowelHarmonyA(CharSequence source, CharSequence target); boolean checkVowelHarmonyI(CharSequence source, CharSequence target); boolean checkVowelHarmonyA(TurkicLetter source, TurkicLetter target); boolean checkVowelHarmonyI(TurkicLetter source, TurkicLetter target); boolean containsVowel(CharSequence s); int vowelCount(String s); boolean containsDigit(String s); boolean equalsIgnoreDiacritics(String s1, String s2); boolean startsWithIgnoreDiacritics(String s1, String s2); static final Locale TR; static TurkishAlphabet INSTANCE; }
|
@Test public void vowelHarmonyI1() { TurkishAlphabet alphabet = TurkishAlphabet.INSTANCE; String[] a = {"elma", "kedi", "turp"}; String[] b = {"yı", "yi", "u"}; for (int i = 0; i < a.length; i++) { Assert.assertTrue(alphabet.checkVowelHarmonyI(a[i], b[i])); } }
@Test public void vowelHarmonyI2() { TurkishAlphabet alphabet = TurkishAlphabet.INSTANCE; String[] a = {"elma", "kedi", "turp"}; String[] b = {"yu", "yü", "ı"}; for (int i = 0; i < a.length; i++) { Assert.assertFalse(alphabet.checkVowelHarmonyI(a[i], b[i])); } }
|
TurkishAlphabet { public boolean startsWithIgnoreDiacritics(String s1, String s2) { if (s1 == null || s2 == null) { return false; } if (s1.length() < s2.length()) { return false; } for (int i = 0; i < s2.length(); i++) { char c1 = s1.charAt(i); char c2 = s2.charAt(i); if (!isAsciiEqual(c1, c2)) { return false; } } return true; } private TurkishAlphabet(); String toAscii(String in); String foreignDiacriticsToTurkish(String in); boolean containsAsciiRelated(String s); IntIntMap getTurkishToAsciiMap(); char getAsciiEqual(char c); boolean isAsciiEqual(char c1, char c2); boolean allCapital(String input); String normalize(String input); char normalizeCircumflex(char c); boolean containsCircumflex(String s); boolean isTurkishSpecific(char c); boolean containsApostrophe(String s); boolean containsForeignDiacritics(String s); String getAllLetters(); String getLowercaseLetters(); String getUppercaseLetters(); String normalizeCircumflex(String s); String normalizeApostrophe(String s); char voice(char c); char devoice(char c); TurkicLetter getLetter(char c); TurkicLetter getLastLetter(CharSequence s); char lastChar(CharSequence s); TurkicLetter getFirstLetter(CharSequence s); boolean isVowel(char c); boolean isDictionaryLetter(char c); boolean isStopConsonant(char c); boolean isVoicelessConsonant(char c); TurkicLetter getLastVowel(CharSequence s); TurkicLetter getFirstVowel(CharSequence s); boolean checkVowelHarmonyA(CharSequence source, CharSequence target); boolean checkVowelHarmonyI(CharSequence source, CharSequence target); boolean checkVowelHarmonyA(TurkicLetter source, TurkicLetter target); boolean checkVowelHarmonyI(TurkicLetter source, TurkicLetter target); boolean containsVowel(CharSequence s); int vowelCount(String s); boolean containsDigit(String s); boolean equalsIgnoreDiacritics(String s1, String s2); boolean startsWithIgnoreDiacritics(String s1, String s2); static final Locale TR; static TurkishAlphabet INSTANCE; }
|
@Test public void startsWithDiacriticsIgnoredTest() { TurkishAlphabet alphabet = TurkishAlphabet.INSTANCE; String[] a = {"siraci", "çağlayan"}; String[] b = {"şıracı", "cag"}; for (int i = 0; i < a.length; i++) { Assert.assertTrue(alphabet.startsWithIgnoreDiacritics(a[i], b[i])); } }
|
LmVocabulary { public boolean containsAll(int... indexes) { for (int index : indexes) { if (!contains(index)) { return false; } } return true; } LmVocabulary(String... vocabulary); LmVocabulary(List<String> vocabulary); private LmVocabulary(RandomAccessFile raf); private LmVocabulary(DataInputStream dis); static LmVocabulary loadFromBinary(File binaryVocabularyFile); static LmVocabulary loadFromBinary(Path binaryVocabularyFilePath); static LmVocabulary loadFromRandomAccessFile(RandomAccessFile raf); static LmVocabulary loadFromDataInputStream(DataInputStream dis); static LmVocabulary loadFromUtf8File(File utfVocabularyFile); static Builder builder(); static LmVocabulary intersect(LmVocabulary v1, LmVocabulary v2); void saveBinary(File file); void saveBinary(DataOutputStream dos); int size(); boolean containsUnknown(int... gramIds); boolean containsSuffix(); boolean containsPrefix(); String getWord(int index); int indexOf(String word); int getSentenceStartIndex(); int getSentenceEndIndex(); int getUnknownWordIndex(); String getUnknownWord(); String getSentenceStart(); String getSentenceEnd(); Iterable<Integer> alphabeticallySortedWordsIds(Locale locale); Iterable<Integer> alphabeticallySortedWordsIds(); Iterable<String> words(); Iterable<String> wordsSorted(); Iterable<String> wordsSorted(Locale locale); String getWordsString(int... indexes); boolean containsAll(int... indexes); boolean contains(int index); boolean containsAll(String... words); boolean contains(String word); long encodeTrigram(int g0, int g1, int g2); long encodeTrigram(int... triGram); int[] toIndexes(String... words); int[] toIndexes(String[] history, String word); int[] toIndexes(int[] history, String word); String[] toWords(int... indexes); static final String DEFAULT_SENTENCE_BEGIN_MARKER; static final String DEFAULT_SENTENCE_END_MARKER; static final String DEFAULT_UNKNOWN_WORD; }
|
@Test public void specialWordsTest() throws IOException { LmVocabulary vocabulary = new LmVocabulary("<S>", "Hello", "</S>"); vocabulary.containsAll("<S>", "Hello", "</S>", "<unk>"); }
|
LmVocabulary { public static LmVocabulary loadFromBinary(File binaryVocabularyFile) throws IOException { try (DataInputStream dis = new DataInputStream( new BufferedInputStream(new FileInputStream(binaryVocabularyFile)))) { return new LmVocabulary(dis); } } LmVocabulary(String... vocabulary); LmVocabulary(List<String> vocabulary); private LmVocabulary(RandomAccessFile raf); private LmVocabulary(DataInputStream dis); static LmVocabulary loadFromBinary(File binaryVocabularyFile); static LmVocabulary loadFromBinary(Path binaryVocabularyFilePath); static LmVocabulary loadFromRandomAccessFile(RandomAccessFile raf); static LmVocabulary loadFromDataInputStream(DataInputStream dis); static LmVocabulary loadFromUtf8File(File utfVocabularyFile); static Builder builder(); static LmVocabulary intersect(LmVocabulary v1, LmVocabulary v2); void saveBinary(File file); void saveBinary(DataOutputStream dos); int size(); boolean containsUnknown(int... gramIds); boolean containsSuffix(); boolean containsPrefix(); String getWord(int index); int indexOf(String word); int getSentenceStartIndex(); int getSentenceEndIndex(); int getUnknownWordIndex(); String getUnknownWord(); String getSentenceStart(); String getSentenceEnd(); Iterable<Integer> alphabeticallySortedWordsIds(Locale locale); Iterable<Integer> alphabeticallySortedWordsIds(); Iterable<String> words(); Iterable<String> wordsSorted(); Iterable<String> wordsSorted(Locale locale); String getWordsString(int... indexes); boolean containsAll(int... indexes); boolean contains(int index); boolean containsAll(String... words); boolean contains(String word); long encodeTrigram(int g0, int g1, int g2); long encodeTrigram(int... triGram); int[] toIndexes(String... words); int[] toIndexes(String[] history, String word); int[] toIndexes(int[] history, String word); String[] toWords(int... indexes); static final String DEFAULT_SENTENCE_BEGIN_MARKER; static final String DEFAULT_SENTENCE_END_MARKER; static final String DEFAULT_UNKNOWN_WORD; }
|
@Test public void binaryFileGenerationTest() throws IOException { File tmp = getBinaryVocFile(); LmVocabulary vocabulary = LmVocabulary.loadFromBinary(tmp); simpleCheck(vocabulary); }
|
LmVocabulary { public static LmVocabulary loadFromUtf8File(File utfVocabularyFile) throws IOException { return new LmVocabulary(SimpleTextReader.trimmingUTF8Reader(utfVocabularyFile).asStringList()); } LmVocabulary(String... vocabulary); LmVocabulary(List<String> vocabulary); private LmVocabulary(RandomAccessFile raf); private LmVocabulary(DataInputStream dis); static LmVocabulary loadFromBinary(File binaryVocabularyFile); static LmVocabulary loadFromBinary(Path binaryVocabularyFilePath); static LmVocabulary loadFromRandomAccessFile(RandomAccessFile raf); static LmVocabulary loadFromDataInputStream(DataInputStream dis); static LmVocabulary loadFromUtf8File(File utfVocabularyFile); static Builder builder(); static LmVocabulary intersect(LmVocabulary v1, LmVocabulary v2); void saveBinary(File file); void saveBinary(DataOutputStream dos); int size(); boolean containsUnknown(int... gramIds); boolean containsSuffix(); boolean containsPrefix(); String getWord(int index); int indexOf(String word); int getSentenceStartIndex(); int getSentenceEndIndex(); int getUnknownWordIndex(); String getUnknownWord(); String getSentenceStart(); String getSentenceEnd(); Iterable<Integer> alphabeticallySortedWordsIds(Locale locale); Iterable<Integer> alphabeticallySortedWordsIds(); Iterable<String> words(); Iterable<String> wordsSorted(); Iterable<String> wordsSorted(Locale locale); String getWordsString(int... indexes); boolean containsAll(int... indexes); boolean contains(int index); boolean containsAll(String... words); boolean contains(String word); long encodeTrigram(int g0, int g1, int g2); long encodeTrigram(int... triGram); int[] toIndexes(String... words); int[] toIndexes(String[] history, String word); int[] toIndexes(int[] history, String word); String[] toWords(int... indexes); static final String DEFAULT_SENTENCE_BEGIN_MARKER; static final String DEFAULT_SENTENCE_END_MARKER; static final String DEFAULT_UNKNOWN_WORD; }
|
@Test public void utf8FileGenerationTest() throws IOException { File tmp = getUtf8VocFile(); LmVocabulary vocabulary = LmVocabulary.loadFromUtf8File(tmp); simpleCheck(vocabulary); }
|
LmVocabulary { public static LmVocabulary loadFromDataInputStream(DataInputStream dis) throws IOException { return new LmVocabulary(dis); } LmVocabulary(String... vocabulary); LmVocabulary(List<String> vocabulary); private LmVocabulary(RandomAccessFile raf); private LmVocabulary(DataInputStream dis); static LmVocabulary loadFromBinary(File binaryVocabularyFile); static LmVocabulary loadFromBinary(Path binaryVocabularyFilePath); static LmVocabulary loadFromRandomAccessFile(RandomAccessFile raf); static LmVocabulary loadFromDataInputStream(DataInputStream dis); static LmVocabulary loadFromUtf8File(File utfVocabularyFile); static Builder builder(); static LmVocabulary intersect(LmVocabulary v1, LmVocabulary v2); void saveBinary(File file); void saveBinary(DataOutputStream dos); int size(); boolean containsUnknown(int... gramIds); boolean containsSuffix(); boolean containsPrefix(); String getWord(int index); int indexOf(String word); int getSentenceStartIndex(); int getSentenceEndIndex(); int getUnknownWordIndex(); String getUnknownWord(); String getSentenceStart(); String getSentenceEnd(); Iterable<Integer> alphabeticallySortedWordsIds(Locale locale); Iterable<Integer> alphabeticallySortedWordsIds(); Iterable<String> words(); Iterable<String> wordsSorted(); Iterable<String> wordsSorted(Locale locale); String getWordsString(int... indexes); boolean containsAll(int... indexes); boolean contains(int index); boolean containsAll(String... words); boolean contains(String word); long encodeTrigram(int g0, int g1, int g2); long encodeTrigram(int... triGram); int[] toIndexes(String... words); int[] toIndexes(String[] history, String word); int[] toIndexes(int[] history, String word); String[] toWords(int... indexes); static final String DEFAULT_SENTENCE_BEGIN_MARKER; static final String DEFAULT_SENTENCE_END_MARKER; static final String DEFAULT_UNKNOWN_WORD; }
|
@Test public void streamGenerationTest() throws IOException { File tmp = getBinaryVocFile(); try (DataInputStream dis = new DataInputStream(new FileInputStream(tmp))) { LmVocabulary vocabulary = LmVocabulary.loadFromDataInputStream(dis); simpleCheck(vocabulary); } }
|
LmVocabulary { public static LmVocabulary loadFromRandomAccessFile(RandomAccessFile raf) throws IOException { return new LmVocabulary(raf); } LmVocabulary(String... vocabulary); LmVocabulary(List<String> vocabulary); private LmVocabulary(RandomAccessFile raf); private LmVocabulary(DataInputStream dis); static LmVocabulary loadFromBinary(File binaryVocabularyFile); static LmVocabulary loadFromBinary(Path binaryVocabularyFilePath); static LmVocabulary loadFromRandomAccessFile(RandomAccessFile raf); static LmVocabulary loadFromDataInputStream(DataInputStream dis); static LmVocabulary loadFromUtf8File(File utfVocabularyFile); static Builder builder(); static LmVocabulary intersect(LmVocabulary v1, LmVocabulary v2); void saveBinary(File file); void saveBinary(DataOutputStream dos); int size(); boolean containsUnknown(int... gramIds); boolean containsSuffix(); boolean containsPrefix(); String getWord(int index); int indexOf(String word); int getSentenceStartIndex(); int getSentenceEndIndex(); int getUnknownWordIndex(); String getUnknownWord(); String getSentenceStart(); String getSentenceEnd(); Iterable<Integer> alphabeticallySortedWordsIds(Locale locale); Iterable<Integer> alphabeticallySortedWordsIds(); Iterable<String> words(); Iterable<String> wordsSorted(); Iterable<String> wordsSorted(Locale locale); String getWordsString(int... indexes); boolean containsAll(int... indexes); boolean contains(int index); boolean containsAll(String... words); boolean contains(String word); long encodeTrigram(int g0, int g1, int g2); long encodeTrigram(int... triGram); int[] toIndexes(String... words); int[] toIndexes(String[] history, String word); int[] toIndexes(int[] history, String word); String[] toWords(int... indexes); static final String DEFAULT_SENTENCE_BEGIN_MARKER; static final String DEFAULT_SENTENCE_END_MARKER; static final String DEFAULT_UNKNOWN_WORD; }
|
@Test public void randomAccessGenerationTest() throws IOException { File tmp = getBinaryVocFile(); try (RandomAccessFile raf = new RandomAccessFile(tmp, "r")) { LmVocabulary vocabulary = LmVocabulary.loadFromRandomAccessFile(raf); simpleCheck(vocabulary); } }
|
LmVocabulary { public boolean contains(int index) { return index >= 0 && index < vocabulary.size(); } LmVocabulary(String... vocabulary); LmVocabulary(List<String> vocabulary); private LmVocabulary(RandomAccessFile raf); private LmVocabulary(DataInputStream dis); static LmVocabulary loadFromBinary(File binaryVocabularyFile); static LmVocabulary loadFromBinary(Path binaryVocabularyFilePath); static LmVocabulary loadFromRandomAccessFile(RandomAccessFile raf); static LmVocabulary loadFromDataInputStream(DataInputStream dis); static LmVocabulary loadFromUtf8File(File utfVocabularyFile); static Builder builder(); static LmVocabulary intersect(LmVocabulary v1, LmVocabulary v2); void saveBinary(File file); void saveBinary(DataOutputStream dos); int size(); boolean containsUnknown(int... gramIds); boolean containsSuffix(); boolean containsPrefix(); String getWord(int index); int indexOf(String word); int getSentenceStartIndex(); int getSentenceEndIndex(); int getUnknownWordIndex(); String getUnknownWord(); String getSentenceStart(); String getSentenceEnd(); Iterable<Integer> alphabeticallySortedWordsIds(Locale locale); Iterable<Integer> alphabeticallySortedWordsIds(); Iterable<String> words(); Iterable<String> wordsSorted(); Iterable<String> wordsSorted(Locale locale); String getWordsString(int... indexes); boolean containsAll(int... indexes); boolean contains(int index); boolean containsAll(String... words); boolean contains(String word); long encodeTrigram(int g0, int g1, int g2); long encodeTrigram(int... triGram); int[] toIndexes(String... words); int[] toIndexes(String[] history, String word); int[] toIndexes(int[] history, String word); String[] toWords(int... indexes); static final String DEFAULT_SENTENCE_BEGIN_MARKER; static final String DEFAULT_SENTENCE_END_MARKER; static final String DEFAULT_UNKNOWN_WORD; }
|
@Test public void contains() throws IOException { LmVocabulary vocabulary = new LmVocabulary("Hello", "World"); int helloIndex = vocabulary.indexOf("Hello"); int worldIndex = vocabulary.indexOf("World"); Assert.assertTrue(vocabulary.contains(helloIndex)); Assert.assertTrue(vocabulary.contains(worldIndex)); int unkIndex = vocabulary.indexOf("Foo"); Assert.assertEquals(vocabulary.getUnknownWordIndex(), unkIndex); Assert.assertTrue(vocabulary.containsAll(helloIndex, worldIndex)); Assert.assertFalse(vocabulary.containsAll(-1, 2)); Assert.assertTrue(vocabulary.contains("Hello")); Assert.assertTrue(vocabulary.contains("World")); Assert.assertFalse(vocabulary.contains("Foo")); Assert.assertFalse(vocabulary.containsAll("Hello", "Foo")); Assert.assertTrue(vocabulary.containsAll("Hello", "World")); }
|
LmVocabulary { public long encodeTrigram(int g0, int g1, int g2) { long encoded = g2; encoded = (encoded << 21) | g1; return (encoded << 21) | g0; } LmVocabulary(String... vocabulary); LmVocabulary(List<String> vocabulary); private LmVocabulary(RandomAccessFile raf); private LmVocabulary(DataInputStream dis); static LmVocabulary loadFromBinary(File binaryVocabularyFile); static LmVocabulary loadFromBinary(Path binaryVocabularyFilePath); static LmVocabulary loadFromRandomAccessFile(RandomAccessFile raf); static LmVocabulary loadFromDataInputStream(DataInputStream dis); static LmVocabulary loadFromUtf8File(File utfVocabularyFile); static Builder builder(); static LmVocabulary intersect(LmVocabulary v1, LmVocabulary v2); void saveBinary(File file); void saveBinary(DataOutputStream dos); int size(); boolean containsUnknown(int... gramIds); boolean containsSuffix(); boolean containsPrefix(); String getWord(int index); int indexOf(String word); int getSentenceStartIndex(); int getSentenceEndIndex(); int getUnknownWordIndex(); String getUnknownWord(); String getSentenceStart(); String getSentenceEnd(); Iterable<Integer> alphabeticallySortedWordsIds(Locale locale); Iterable<Integer> alphabeticallySortedWordsIds(); Iterable<String> words(); Iterable<String> wordsSorted(); Iterable<String> wordsSorted(Locale locale); String getWordsString(int... indexes); boolean containsAll(int... indexes); boolean contains(int index); boolean containsAll(String... words); boolean contains(String word); long encodeTrigram(int g0, int g1, int g2); long encodeTrigram(int... triGram); int[] toIndexes(String... words); int[] toIndexes(String[] history, String word); int[] toIndexes(int[] history, String word); String[] toWords(int... indexes); static final String DEFAULT_SENTENCE_BEGIN_MARKER; static final String DEFAULT_SENTENCE_END_MARKER; static final String DEFAULT_UNKNOWN_WORD; }
|
@Test public void encodedTrigramTest() throws IOException { LmVocabulary vocabulary = new LmVocabulary("a", "b", "c", "d", "e"); long k = ((1L << 21 | 2L) << 21) | 3L; Assert.assertEquals(k, vocabulary.encodeTrigram(3, 2, 1)); Assert.assertEquals(k, vocabulary.encodeTrigram(3, 2, 1)); }
|
LmVocabulary { public String[] toWords(int... indexes) { String[] words = new String[indexes.length]; int k = 0; for (int index : indexes) { if (contains(index)) { words[k++] = vocabulary.get(index); } else { Log.warn("Out of bounds word index is used:" + index); words[k++] = unknownWord; } } return words; } LmVocabulary(String... vocabulary); LmVocabulary(List<String> vocabulary); private LmVocabulary(RandomAccessFile raf); private LmVocabulary(DataInputStream dis); static LmVocabulary loadFromBinary(File binaryVocabularyFile); static LmVocabulary loadFromBinary(Path binaryVocabularyFilePath); static LmVocabulary loadFromRandomAccessFile(RandomAccessFile raf); static LmVocabulary loadFromDataInputStream(DataInputStream dis); static LmVocabulary loadFromUtf8File(File utfVocabularyFile); static Builder builder(); static LmVocabulary intersect(LmVocabulary v1, LmVocabulary v2); void saveBinary(File file); void saveBinary(DataOutputStream dos); int size(); boolean containsUnknown(int... gramIds); boolean containsSuffix(); boolean containsPrefix(); String getWord(int index); int indexOf(String word); int getSentenceStartIndex(); int getSentenceEndIndex(); int getUnknownWordIndex(); String getUnknownWord(); String getSentenceStart(); String getSentenceEnd(); Iterable<Integer> alphabeticallySortedWordsIds(Locale locale); Iterable<Integer> alphabeticallySortedWordsIds(); Iterable<String> words(); Iterable<String> wordsSorted(); Iterable<String> wordsSorted(Locale locale); String getWordsString(int... indexes); boolean containsAll(int... indexes); boolean contains(int index); boolean containsAll(String... words); boolean contains(String word); long encodeTrigram(int g0, int g1, int g2); long encodeTrigram(int... triGram); int[] toIndexes(String... words); int[] toIndexes(String[] history, String word); int[] toIndexes(int[] history, String word); String[] toWords(int... indexes); static final String DEFAULT_SENTENCE_BEGIN_MARKER; static final String DEFAULT_SENTENCE_END_MARKER; static final String DEFAULT_UNKNOWN_WORD; }
|
@Test public void toWordsTest() throws IOException { LmVocabulary vocabulary = new LmVocabulary("a", "b", "c", "d", "e"); int[] indexes = vocabulary.toIndexes("a", "e", "b"); Assert.assertEquals("a e b", Joiner.on(" ").join(vocabulary.toWords(indexes))); indexes = vocabulary.toIndexes("a", "e", "foo"); Assert.assertEquals("a e <unk>", Joiner.on(" ").join(vocabulary.toWords(indexes))); }
|
LmVocabulary { public static Builder builder() { return new Builder(); } LmVocabulary(String... vocabulary); LmVocabulary(List<String> vocabulary); private LmVocabulary(RandomAccessFile raf); private LmVocabulary(DataInputStream dis); static LmVocabulary loadFromBinary(File binaryVocabularyFile); static LmVocabulary loadFromBinary(Path binaryVocabularyFilePath); static LmVocabulary loadFromRandomAccessFile(RandomAccessFile raf); static LmVocabulary loadFromDataInputStream(DataInputStream dis); static LmVocabulary loadFromUtf8File(File utfVocabularyFile); static Builder builder(); static LmVocabulary intersect(LmVocabulary v1, LmVocabulary v2); void saveBinary(File file); void saveBinary(DataOutputStream dos); int size(); boolean containsUnknown(int... gramIds); boolean containsSuffix(); boolean containsPrefix(); String getWord(int index); int indexOf(String word); int getSentenceStartIndex(); int getSentenceEndIndex(); int getUnknownWordIndex(); String getUnknownWord(); String getSentenceStart(); String getSentenceEnd(); Iterable<Integer> alphabeticallySortedWordsIds(Locale locale); Iterable<Integer> alphabeticallySortedWordsIds(); Iterable<String> words(); Iterable<String> wordsSorted(); Iterable<String> wordsSorted(Locale locale); String getWordsString(int... indexes); boolean containsAll(int... indexes); boolean contains(int index); boolean containsAll(String... words); boolean contains(String word); long encodeTrigram(int g0, int g1, int g2); long encodeTrigram(int... triGram); int[] toIndexes(String... words); int[] toIndexes(String[] history, String word); int[] toIndexes(int[] history, String word); String[] toWords(int... indexes); static final String DEFAULT_SENTENCE_BEGIN_MARKER; static final String DEFAULT_SENTENCE_END_MARKER; static final String DEFAULT_UNKNOWN_WORD; }
|
@Test public void builderTest() throws IOException { LmVocabulary.Builder builder = LmVocabulary.builder(); String[] words = {"elma", "çilek", "karpuz", "armut", "elma", "armut"}; for (String word : words) { builder.add(word); } Assert.assertEquals(4, builder.size()); Assert.assertEquals(0, builder.indexOf("elma")); Assert.assertEquals(1, builder.indexOf("çilek")); Assert.assertEquals(2, builder.indexOf("karpuz")); Assert.assertEquals(-1, builder.indexOf("mango")); List<Integer> list = Lists.newArrayList(builder.alphabeticallySortedWordsIds()); Assert.assertEquals(Lists.newArrayList(3, 0, 2, 1), list); list = Lists.newArrayList(builder.alphabeticallySortedWordsIds(new Locale("tr"))); Assert.assertEquals(Lists.newArrayList(3, 1, 0, 2), list); LmVocabulary vocab = builder.generate(); Assert.assertEquals(7, vocab.size()); }
|
SmoothLm extends BaseLanguageModel implements NgramLanguageModel { @Override public int getOrder() { return order; } private SmoothLm(
DataInputStream dis,
float logBase,
float unigramWeight,
float unknownBackoffPenalty,
boolean useStupidBackoff,
float stupidBackoffAlpha,
File ngramKeyFileDir); private SmoothLm(DataInputStream dis); static Builder builder(InputStream is); static Builder builder(File modelFile); static Builder builder(Path modelFile); String info(); double getStupidBackoffLogAlpha(); int getVersion(); @Override float getUnigramProbability(int id); @Override int getOrder(); @Override LmVocabulary getVocabulary(); LookupCache getCache(); LookupCache getCache(int bits); int getGramCount(int n); @Override boolean ngramExists(int... wordIndexes); double getProbabilityValue(int... wordIndexes); float getBigramProbabilityValue(int w0, int w1); double getBackoffValue(int... wordIndexes); float getBigramBackoffValue(int w0, int w1); double getProbability(String... words); void countFalsePositives(int... wordIndexes); boolean ngramIdsAvailable(); int getFalsePositiveCount(); float getProbability(int... wordIndexes); float getBigramProbability(int w0, int w1); float getTriGramProbability(int w0, int w1, int w2); float getTriGramProbability(int w0, int w1, int w2, int fingerPrint); float getTriGramProbability(int... w); int getBackoffCount(String... tokens); int getBackoffCount(int... wordIndexes); String explain(int... wordIndexes); double getLogBase(); static final float DEFAULT_LOG_BASE; static final float DEFAULT_UNIGRAM_WEIGHT; static final float DEFAULT_UNKNOWN_BACKOFF_PENALTY; static final float DEFAULT_STUPID_BACKOFF_ALPHA; static final int DEFAULT_UNKNOWN_TOKEN_PROBABILITY; }
|
@Test public void testGeneration() throws IOException { SmoothLm lm = getTinyLm(); Assert.assertEquals(3, lm.getOrder()); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.