method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
SimpleTextReader implements AutoCloseable { public LineIterator getLineIterator() throws IOException { return new LineIterator(getReader(), trim, filters); } SimpleTextReader(InputStream is, Template template); SimpleTextReader(File file); SimpleTextReader(File file, String encoding); SimpleTextReader(String fileName); SimpleTextReader(String fileName, String encoding); SimpleTextReader(InputStream is); SimpleTextReader(InputStream is, String encoding); static SimpleTextReader trimmingUTF8Reader(File file); static LineIterator trimmingUTF8LineIterator(File file); static IterableLineReader trimmingUTF8IterableLineReader(File file); static SimpleTextReader trimmingReader(InputStream is, String encoding); static LineIterator trimmingLineIterator(InputStream is, String encoding); static IterableLineReader trimmingIterableLineReader(InputStream is, String encoding); String getEncoding(); SimpleTextReader cloneForStream(InputStream is); SimpleTextReader cloneForFile(File file); byte[] asByteArray(); String asString(); List<String> asStringList(); IterableLineReader getIterableReader(); LineIterator getLineIterator(); long countLines(); void close(); }### Answer:
@Test public void lineIteratorTest2() throws IOException { try (LineIterator li = new SimpleTextReader(multi_line_text_file.getFile()).getLineIterator()) { while (li.hasNext()) { out.println(li.next().toUpperCase()); } } }
@Test public void lineIteratorWithConstraint() throws IOException { try (LineIterator li = new SimpleTextReader .Builder(multi_line_text_file.getFile()) .ignoreWhiteSpaceLines() .trim() .build().getLineIterator()) { int i = 0; while (li.hasNext()) { String s = li.next(); if (i == 0) { assertEquals(s, "uno"); } if (i == 1) { assertEquals(s, "dos"); } i++; } } } |
### Question:
LogMath { public static double logSum(double logA, double logB) { if (Double.isInfinite(logA)) { return logB; } if (Double.isInfinite(logB)) { return logA; } if (logA > logB) { double dif = logA - logB; return dif >= 30d ? logA : logA + Math.log(1 + Math.exp(-dif)); } else { double dif = logB - logA; return dif >= 30d ? logB : logB + Math.log(1 + Math.exp(-dif)); } } private LogMath(); static double logSum(double logA, double logB); static double logSum10(double log10A, double log10B); static double logSum(double... logValues); static double log(double base, double val); static double log2(double input); static double log10ToLog(double log10Value); static double toLogSphinx(double logValue); static void main(String[] args); static final double LOG_ZERO; static final double LOG_ONE; static final double LOG_TEN; static final double LOG_TWO; static final double INVERSE_LOG_TWO; static final float LOG_ZERO_FLOAT; static final float LOG_ONE_FLOAT; static final float LOG_TEN_FLOAT; static final float LOG_TWO_FLOAT; static final LogSumLookup LOG_SUM; static final LogSumLookupFloat LOG_SUM_FLOAT; static final LinearToLogConverter LINEAR_TO_LOG; static final LinearToLogConverterFloat LINEAR_TO_LOG_FLOAT; }### Answer:
@Test public void logSumTest() throws IOException { double[] aLinear = new double[1000]; double[] bLinear = new double[1000]; for (int i = 0; i < bLinear.length; i++) { aLinear[i] = (double) i / 1000d; bLinear[i] = aLinear[i]; } LogMath.LogSumLookup logSumE = LogMath.LOG_SUM; for (double a : aLinear) { for (double b : bLinear) { double logSumExpected = Math.log(a + b); Assert.assertEquals(logSumExpected, logSumE.lookup(Math.log(a), Math.log(b)), 0.001); } } } |
### Question:
LogMath { public static double log(double base, double val) { return Math.log(val) / Math.log(base); } private LogMath(); static double logSum(double logA, double logB); static double logSum10(double log10A, double log10B); static double logSum(double... logValues); static double log(double base, double val); static double log2(double input); static double log10ToLog(double log10Value); static double toLogSphinx(double logValue); static void main(String[] args); static final double LOG_ZERO; static final double LOG_ONE; static final double LOG_TEN; static final double LOG_TWO; static final double INVERSE_LOG_TWO; static final float LOG_ZERO_FLOAT; static final float LOG_ONE_FLOAT; static final float LOG_TEN_FLOAT; static final float LOG_TWO_FLOAT; static final LogSumLookup LOG_SUM; static final LogSumLookupFloat LOG_SUM_FLOAT; static final LinearToLogConverter LINEAR_TO_LOG; static final LinearToLogConverterFloat LINEAR_TO_LOG_FLOAT; }### Answer:
@Test public void logSumFloatTest() throws IOException { float[] aLinear = new float[1000]; float[] bLinear = new float[1000]; for (int i = 0; i < bLinear.length; i++) { aLinear[i] = (float) i / 1000f; bLinear[i] = aLinear[i]; } for (float a : aLinear) { for (float b : bLinear) { float logSumExpected = (float) Math.log(a + b); Assert .assertEquals(logSumExpected, LogMath.LOG_SUM.lookup(Math.log(a), Math.log(b)), 0.001); } } }
@Test public void linearToLogTest() { LogMath.LinearToLogConverter converter = new LogMath.LinearToLogConverter(Math.E); Assert.assertEquals(Math.log(2), converter.convert(2), 0.00000001d); converter = new LogMath.LinearToLogConverter(10d); Assert.assertEquals(Math.log10(2), converter.convert(2), 0.00000001d); } |
### Question:
LogMath { public static double log2(double input) { return Math.log(input) * INVERSE_LOG_TWO; } private LogMath(); static double logSum(double logA, double logB); static double logSum10(double log10A, double log10B); static double logSum(double... logValues); static double log(double base, double val); static double log2(double input); static double log10ToLog(double log10Value); static double toLogSphinx(double logValue); static void main(String[] args); static final double LOG_ZERO; static final double LOG_ONE; static final double LOG_TEN; static final double LOG_TWO; static final double INVERSE_LOG_TWO; static final float LOG_ZERO_FLOAT; static final float LOG_ONE_FLOAT; static final float LOG_TEN_FLOAT; static final float LOG_TWO_FLOAT; static final LogSumLookup LOG_SUM; static final LogSumLookupFloat LOG_SUM_FLOAT; static final LinearToLogConverter LINEAR_TO_LOG; static final LinearToLogConverterFloat LINEAR_TO_LOG_FLOAT; }### Answer:
@Test public void testLog2() { Assert.assertEquals(2, LogMath.log2(4), 0.0001); Assert.assertEquals(3, LogMath.log2(8), 0.0001); Assert.assertEquals(10, LogMath.log2(1024), 0.0001); Assert.assertEquals(-1, LogMath.log2(0.5), 0.0001); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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; }### Answer:
@Test public void testMean() { float[] da = {1, 2, 0, -1, -3}; Assert.assertTrue(inDelta(FloatArrays.mean(da), -1f / 5f)); } |
### Question:
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; }### Answer:
@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})); } |
### Question:
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; }### Answer:
@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); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@Test public void testSquare() { double[] da = {1, 2, 0, -1, -3}; Assert.assertTrue(inDelta(DoubleArrays.square(da), new double[]{1, 4, 0, 1, 9})); } |
### Question:
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; }### Answer:
@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})); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@Test public void testMean() { double[] da = {1, 2, 0, -1, -3}; Assert.assertTrue(inDelta(DoubleArrays.mean(da), -1d / 5d)); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@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); } } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@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); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@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})); } |
### Question:
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; }### Answer:
@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); } } |
### Question:
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; }### Answer:
@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})); } |
### Question:
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; }### Answer:
@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})); } |
### Question:
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; }### Answer:
@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); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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")); } |
### Question:
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(); }### Answer:
@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)); } |
### Question:
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(); }### Answer:
@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)); } } |
### Question:
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(); }### Answer:
@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)); } } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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()); } |
### Question:
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; }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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)); } } |
### Question:
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(); }### Answer:
@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()); } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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)); } } |
### Question:
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(); }### Answer:
@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")); } |
### Question:
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(); }### Answer:
@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()); } } |
### Question:
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(); }### Answer:
@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))); } } |
### Question:
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(); }### Answer:
@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)); } } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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)); } } |
### Question:
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; }### Answer:
@Test(expected = IllegalArgumentException.class) public void safeGet() { FixedBitVector vector = new FixedBitVector(10); vector.safeGet(10); } |
### Question:
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; }### Answer:
@Test(expected = IllegalArgumentException.class) public void safeSet() { FixedBitVector vector = new FixedBitVector(10); vector.safeSet(10); } |
### Question:
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; }### Answer:
@Test(expected = IllegalArgumentException.class) public void safeClear() { FixedBitVector vector = new FixedBitVector(10); vector.safeClear(10); } |
### Question:
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(); }### Answer:
@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)); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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); } |
### Question:
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(); }### Answer:
@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)); } } |
### Question:
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(); }### Answer:
@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()); } |
### Question:
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(); }### Answer:
@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")); } |
### Question:
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; }### Answer:
@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)); } } |
### Question:
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; }### Answer:
@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)); } } |
### Question:
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; }### Answer:
@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))); } } |
### Question:
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; }### Answer:
@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))); } } |
### Question:
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; }### Answer:
@Test public void circumflexTest() { TurkishAlphabet alphabet = TurkishAlphabet.INSTANCE; String iStr = "abcâîûÂÎÛ fg12"; String oStr = "abcaiuAİU fg12"; Assert.assertEquals(oStr, alphabet.normalizeCircumflex(iStr)); } |
### Question:
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; }### Answer:
@Test public void toAsciiTest() { TurkishAlphabet alphabet = TurkishAlphabet.INSTANCE; String iStr = "abcçğıiİIoöüşâîûÂÎÛz"; String oStr = "abccgiiIIoousaiuAIUz"; Assert.assertEquals(oStr, alphabet.toAscii(iStr)); } |
### Question:
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; }### Answer:
@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])); } } |
### Question:
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; }### Answer:
@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])); } } |
### Question:
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; }### Answer:
@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])); } } |
### Question:
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; }### Answer:
@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])); } } |
### Question:
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; }### Answer:
@Test public void specialWordsTest() throws IOException { LmVocabulary vocabulary = new LmVocabulary("<S>", "Hello", "</S>"); vocabulary.containsAll("<S>", "Hello", "</S>", "<unk>"); } |
### Question:
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; }### Answer:
@Test public void binaryFileGenerationTest() throws IOException { File tmp = getBinaryVocFile(); LmVocabulary vocabulary = LmVocabulary.loadFromBinary(tmp); simpleCheck(vocabulary); } |
### Question:
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; }### Answer:
@Test public void utf8FileGenerationTest() throws IOException { File tmp = getUtf8VocFile(); LmVocabulary vocabulary = LmVocabulary.loadFromUtf8File(tmp); simpleCheck(vocabulary); } |
### Question:
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; }### Answer:
@Test public void streamGenerationTest() throws IOException { File tmp = getBinaryVocFile(); try (DataInputStream dis = new DataInputStream(new FileInputStream(tmp))) { LmVocabulary vocabulary = LmVocabulary.loadFromDataInputStream(dis); simpleCheck(vocabulary); } } |
### Question:
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; }### Answer:
@Test public void randomAccessGenerationTest() throws IOException { File tmp = getBinaryVocFile(); try (RandomAccessFile raf = new RandomAccessFile(tmp, "r")) { LmVocabulary vocabulary = LmVocabulary.loadFromRandomAccessFile(raf); simpleCheck(vocabulary); } } |
### Question:
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; }### Answer:
@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")); } |
### Question:
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; }### Answer:
@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)); } |
### Question:
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; }### Answer:
@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))); } |
### Question:
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; }### Answer:
@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()); } |
### Question:
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; }### Answer:
@Test public void testGeneration() throws IOException { SmoothLm lm = getTinyLm(); Assert.assertEquals(3, lm.getOrder()); } |
### Question:
SmoothLm extends BaseLanguageModel implements NgramLanguageModel { @Override public LmVocabulary getVocabulary() { return vocabulary; } 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; }### Answer:
@Test public void testVocabulary() throws IOException { SmoothLm lm = getTinyLm(); LmVocabulary vocab = lm.getVocabulary(); Assert.assertTrue(vocab.contains("Ahmet")); int i1 = vocab.indexOf("Ahmet"); Assert.assertTrue(vocab.contains("elma")); int i2 = vocab.indexOf("elma"); Assert.assertTrue(i1 != i2); Assert.assertEquals("Ahmet", vocab.getWord(i1)); Assert.assertEquals("elma", vocab.getWord(i2)); } |
### Question:
SmoothLm extends BaseLanguageModel implements NgramLanguageModel { public String explain(int... wordIndexes) { return explain(new Explanation(), wordIndexes).sb.toString(); } 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; }### Answer:
@Test public void testExplain() throws IOException { SmoothLm lm = getTinyLm(); LmVocabulary vocabulary = lm.getVocabulary(); int[] is = {vocabulary.indexOf("<s>")}; System.out.println(lm.explain(is)); int[] is2 = vocabulary.toIndexes("<s>", "kedi"); System.out.println(lm.explain(is2)); int[] is3 = vocabulary.toIndexes("Ahmet", "dondurma", "yedi"); System.out.println(lm.explain(is3)); int[] is4 = vocabulary.toIndexes("Ahmet", "yemez"); System.out.println(lm.explain(is4)); int[] is5 = vocabulary.toIndexes("Ahmet", "yemez", "kırmızı"); System.out.println(lm.explain(is5)); } |
### Question:
NerDataSet { public static NerDataSet load(Path path, AnnotationStyle style) throws IOException { switch (style) { case BRACKET: return loadBracketStyle(path); case ENAMEX: return loadEnamexStyle(path); case OPEN_NLP: return loadOpenNlpStyle(path); } throw new IOException(String.format("Cannot load data from %s with style %s", path, style)); } NerDataSet(List<NerSentence> sentences); List<NerSentence> getSentences(); void shuffle(); static NerDataSet load(Path path, AnnotationStyle style); static String normalizeForNer(String input); void addSet(NerDataSet set); NerDataSet getSubSet(int from, int to); String info(); static final String OUT_TOKEN_TYPE; }### Answer:
@Test public void testOpenNlpStyle() throws IOException { Path p = TestUtil.tempFileWithData( "<Start:ABC> Foo Bar <End> ivir zivir <Start:DEF> haha <End> . "); NerDataSet set = NerDataSet.load(p, AnnotationStyle.OPEN_NLP); System.out.println("types= " + set.types); Assert.assertTrue(TestUtil.containsAll(set.types, "ABC", "DEF", "OUT")); }
@Test public void testBracketStyle() throws IOException { Path p = TestUtil.tempFileWithData( "[ABC Foo Bar] ivir zivir [DEF haha] . "); NerDataSet set = NerDataSet.load(p, AnnotationStyle.BRACKET); System.out.println("types= " + set.types); Assert.assertTrue(TestUtil.containsAll(set.types, "ABC", "DEF", "OUT")); } |
### Question:
TurkishTokenizer { public static Builder builder() { return new Builder(); } private TurkishTokenizer(long acceptedTypeBits); static Builder builder(); boolean isTypeAccepted(Token.Type i); boolean isTypeIgnored(Token.Type i); List<Token> tokenize(File file); List<Token> tokenize(String input); List<Token> tokenize(Reader reader); List<String> tokenizeToStrings(String input); Iterator<Token> getTokenIterator(String input); Iterator<Token> getTokenIterator(File file); Iterator<Token> getTokenIterator(Reader reader); static Token convert(org.antlr.v4.runtime.Token token); static Token convert(org.antlr.v4.runtime.Token token, Token.Type type); static Token.Type convertType(org.antlr.v4.runtime.Token token); static final TurkishTokenizer ALL; static final TurkishTokenizer DEFAULT; }### Answer:
@Test public void testInstances() { TurkishTokenizer t = TurkishTokenizer.DEFAULT; matchToken(t, "a b \t c \n \r", "a", "b", "c"); t = TurkishTokenizer.ALL; matchToken(t, " a b\t\n\rc", " ", "a", " ", "b", "\t", "\n", "\r", "c"); t = TurkishTokenizer.builder().ignoreAll().acceptTypes(Type.Number).build(); matchToken(t, "www.foo.bar 12,4'ü [email protected] ; ^% 2 adf 12 \r \n ", "12,4'ü", "2", "12"); } |
### Question:
TurkishTokenizer { public List<Token> tokenize(File file) throws IOException { return getAllTokens(lexerInstance(CharStreams.fromPath(file.toPath()))); } private TurkishTokenizer(long acceptedTypeBits); static Builder builder(); boolean isTypeAccepted(Token.Type i); boolean isTypeIgnored(Token.Type i); List<Token> tokenize(File file); List<Token> tokenize(String input); List<Token> tokenize(Reader reader); List<String> tokenizeToStrings(String input); Iterator<Token> getTokenIterator(String input); Iterator<Token> getTokenIterator(File file); Iterator<Token> getTokenIterator(Reader reader); static Token convert(org.antlr.v4.runtime.Token token); static Token convert(org.antlr.v4.runtime.Token token, Token.Type type); static Token.Type convertType(org.antlr.v4.runtime.Token token); static final TurkishTokenizer ALL; static final TurkishTokenizer DEFAULT; }### Answer:
@Test public void testTokenBoundaries() { TurkishTokenizer t = TurkishTokenizer.ALL; List<Token> tokens = t.tokenize("bir av. geldi."); Token t0 = tokens.get(0); Assert.assertEquals("bir", t0.getText()); Assert.assertEquals(0, t0.getStart()); Assert.assertEquals(2, t0.getEnd()); Token t1 = tokens.get(1); Assert.assertEquals(" ", t1.getText()); Assert.assertEquals(3, t1.getStart()); Assert.assertEquals(3, t1.getEnd()); Token t2 = tokens.get(2); Assert.assertEquals("av.", t2.getText()); Assert.assertEquals(4, t2.getStart()); Assert.assertEquals(6, t2.getEnd()); Token t3 = tokens.get(3); Assert.assertEquals(" ", t3.getText()); Assert.assertEquals(7, t3.getStart()); Assert.assertEquals(7, t3.getEnd()); Token t4 = tokens.get(4); Assert.assertEquals("geldi", t4.getText()); Assert.assertEquals(8, t4.getStart()); Assert.assertEquals(12, t4.getEnd()); Token t5 = tokens.get(5); Assert.assertEquals(".", t5.getText()); Assert.assertEquals(13, t5.getStart()); Assert.assertEquals(13, t5.getEnd()); }
@Test @Ignore("Not an actual test. Requires external data.") public void performance() throws IOException { TurkishTokenizer tokenizer = TurkishTokenizer.DEFAULT; for (int it = 0; it < 5; it++) { List<String> lines = Files.readAllLines( Paths.get("/media/aaa/Data/aaa/corpora/dunya.100k")); Stopwatch clock = Stopwatch.createStarted(); long tokenCount = 0; for (String line : lines) { List<Token> tokens = tokenizer.tokenize(line); tokenCount += tokens.size(); } long elapsed = clock.elapsed(TimeUnit.MILLISECONDS); Log.info("Token count = %d ", tokenCount); Log.info("Speed (tps) = %.1f", tokenCount * 1000d / elapsed); } } |
### Question:
Span { public String getSubstring(String input) { return input.substring(start, end); } Span(int start, int end); int length(); int middleValue(); Span copy(int offset); String getSubstring(String input); boolean inSpan(int i); final int start; final int end; }### Answer:
@Test public void substringTest() { Assert.assertEquals("", new Span(0, 0).getSubstring("hello")); Assert.assertEquals("h", new Span(0, 1).getSubstring("hello")); Assert.assertEquals("ello", new Span(1, 5).getSubstring("hello")); } |
### Question:
Span { public int length() { return end - start; } Span(int start, int end); int length(); int middleValue(); Span copy(int offset); String getSubstring(String input); boolean inSpan(int i); final int start; final int end; }### Answer:
@Test public void lengthTest() { Assert.assertEquals(0, new Span(0, 0).length()); Assert.assertEquals(1, new Span(0, 1).length()); Assert.assertEquals(4, new Span(1, 5).length()); } |
### Question:
TurkishSentenceExtractor extends PerceptronSegmenter { public List<String> fromParagraph(String paragraph) { List<Span> spans = extractToSpans(paragraph); List<String> sentences = new ArrayList<>(spans.size()); for (Span span : spans) { String sentence = span.getSubstring(paragraph).trim(); if (sentence.length() > 0) { sentences.add(sentence); } } return sentences; } private TurkishSentenceExtractor(FloatValueMap<String> weights); private TurkishSentenceExtractor(FloatValueMap<String> weights,
boolean doNotSplitInDoubleQuotes); static Builder builder(); List<String> fromParagraphs(Collection<String> paragraphs); List<String> fromParagraph(String paragraph); List<String> fromDocument(String document); char[] getBoundaryCharacters(); static final TurkishSentenceExtractor DEFAULT; }### Answer:
@Test public void singletonAccessShouldNotThrowException() throws IOException { TurkishSentenceExtractor.DEFAULT.fromParagraph("hello"); }
@Test public void shouldExtractSentences1() throws IOException { String test = "Merhaba Dünya.| Nasılsın?"; List<String> expected = getSentences(test); Assert.assertEquals(expected, TurkishSentenceExtractor.DEFAULT.fromParagraph(test.replace("|", ""))); }
@Test public void shouldExtractSingleSentences() throws IOException { String test = "Merhaba Dünya."; List<String> expected = getSentences(test); Assert.assertEquals(expected, TurkishSentenceExtractor.DEFAULT.fromParagraph(test.replace("|", ""))); }
@Test public void shouldExtractSentencesSecondDoesNotEndWithDot() throws IOException { String test = "Merhaba Dünya.| Nasılsın"; List<String> expected = getSentences(test); Assert.assertEquals(expected, TurkishSentenceExtractor.DEFAULT.fromParagraph(test.replace("|", ""))); }
@Test public void shouldReturnDotForDot() throws IOException { List<String> expected = getSentences("."); Assert.assertEquals(expected, TurkishSentenceExtractor.DEFAULT.fromParagraph(".")); }
@Test public void shouldReturn0ForEmpty() throws IOException { Assert.assertEquals(0, TurkishSentenceExtractor.DEFAULT.fromParagraph("").size()); }
@Test public void shouldReturn0ForEmptyff() { List<String> sentences = TurkishSentenceExtractor.DEFAULT.fromParagraph(""); Assert.assertEquals(0, sentences.size()); } |
### Question:
TurkishSentenceExtractor extends PerceptronSegmenter { public static Builder builder() { return new Builder(); } private TurkishSentenceExtractor(FloatValueMap<String> weights); private TurkishSentenceExtractor(FloatValueMap<String> weights,
boolean doNotSplitInDoubleQuotes); static Builder builder(); List<String> fromParagraphs(Collection<String> paragraphs); List<String> fromParagraph(String paragraph); List<String> fromDocument(String document); char[] getBoundaryCharacters(); static final TurkishSentenceExtractor DEFAULT; }### Answer:
@Test public void testDoubleQuotes() throws IOException { TurkishSentenceExtractor e = TurkishSentenceExtractor .builder() .doNotSplitInDoubleQuotes() .useDefaultModel().build(); Assert.assertEquals( "\"Merhaba! Bugün hava çok güzel. Ne dersin?\" dedi tavşan.|Havucu kemirirken.", markBoundariesParagraph( e, "\"Merhaba! Bugün hava çok güzel. Ne dersin?\" dedi tavşan. Havucu kemirirken.")); Assert.assertEquals( "\"Buna hakkı yok!\" diye öfkeyle konuşmaya başladı Baba Kurt.", markBoundariesParagraph( e, "\"Buna hakkı yok!\" diye öfkeyle konuşmaya başladı Baba Kurt.")); } |
### Question:
TurkishDictionaryLoader { public static RootLexicon loadDefaultDictionaries() throws IOException { return loadFromResources(DEFAULT_DICTIONARY_RESOURCES); } 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; }### Answer:
@Test @Ignore("Not a unit test") public void saveFullAttributes() throws IOException { RootLexicon items = TurkishDictionaryLoader.loadDefaultDictionaries(); PrintWriter p = new PrintWriter(new File("dictionary-all-attributes.txt"), "utf-8"); for (DictionaryItem item : items) { p.println(item.toString()); } } |
### Question:
TurkishNumbers { public static String convertToString(long input) { if (input == 0) { return "sıfır"; } if (input < MIN_NUMBER || input > MAX_NUMBER) { throw new IllegalArgumentException("number is out of bounds:" + input); } String result = ""; long girisPos = Math.abs(input); int sayac = 0; while (girisPos > 0) { int uclu = (int) (girisPos % 1000); if (uclu != 0) { if (uclu == 1 && sayac == 1) { result = thousands[sayac] + " " + result; } else { result = convertThreeDigit(uclu) + " " + thousands[sayac] + " " + result; } } sayac++; girisPos /= 1000; } if (input < 0) { return "eksi " + result.trim(); } else { return result.trim(); } } static Map<String, String> getOrdinalMap(); static String convertToString(long input); static String convertNumberToString(String input); static long singleWordNumberValue(String word); static List<String> replaceNumberStrings(List<String> inputSequence); static List<String> seperateConnectedNumbers(List<String> inputSequence); static List<String> seperateConnectedNumbers(String input); static long convertToNumber(String... words); static long convertToNumber(String text); static String convertOrdinalNumberString(String input); static List<String> separateNumbers(String s); static String getOrdinal(String input); static boolean hasNumber(String s); static boolean hasOnlyNumber(String s); static int romanToDecimal(String s); static final long MAX_NUMBER; static final long MIN_NUMBER; }### Answer:
@Test public void cardinalTest() { Assert.assertEquals("sıfır", TurkishNumbers.convertToString(0)); Assert.assertEquals("bin", TurkishNumbers.convertToString(1000)); Assert.assertEquals("bir", TurkishNumbers.convertToString(1)); Assert.assertEquals("on bir", TurkishNumbers.convertToString(11)); Assert.assertEquals("yüz on bir", TurkishNumbers.convertToString(111)); Assert.assertEquals("yüz on bir bin", TurkishNumbers.convertToString(111000)); Assert.assertEquals( "bir milyon iki yüz otuz dört bin beş yüz altmış yedi", TurkishNumbers.convertToString(1_234_567)); Assert.assertEquals( "bir milyar iki yüz otuz dört milyon beş yüz altmış yedi bin sekiz yüz doksan", TurkishNumbers.convertToString(1_234_567_890)); } |
### Question:
TurkishNumbers { public static String convertNumberToString(String input) { if (input.startsWith("+")) { input = input.substring(1); } List<String> sb = new ArrayList<>(); int i; for (i = 0; i < input.length(); i++) { if (input.charAt(i) == '0') { sb.add("sıfır"); } else { break; } } String rest = input.substring(i); if (rest.length() > 0) { sb.add(convertToString(Long.parseLong(rest))); } return String.join(" ", sb); } static Map<String, String> getOrdinalMap(); static String convertToString(long input); static String convertNumberToString(String input); static long singleWordNumberValue(String word); static List<String> replaceNumberStrings(List<String> inputSequence); static List<String> seperateConnectedNumbers(List<String> inputSequence); static List<String> seperateConnectedNumbers(String input); static long convertToNumber(String... words); static long convertToNumber(String text); static String convertOrdinalNumberString(String input); static List<String> separateNumbers(String s); static String getOrdinal(String input); static boolean hasNumber(String s); static boolean hasOnlyNumber(String s); static int romanToDecimal(String s); static final long MAX_NUMBER; static final long MIN_NUMBER; }### Answer:
@Test public void cardinalTest2() { Assert.assertEquals("sıfır", TurkishNumbers.convertNumberToString("0")); Assert.assertEquals("sıfır sıfır", TurkishNumbers.convertNumberToString("00")); Assert.assertEquals("sıfır sıfır sıfır", TurkishNumbers.convertNumberToString("000")); Assert.assertEquals("sıfır sıfır sıfır bir", TurkishNumbers.convertNumberToString("0001")); Assert.assertEquals("bin", TurkishNumbers.convertNumberToString("1000")); Assert.assertEquals("bir", TurkishNumbers.convertNumberToString("1")); Assert.assertEquals("on bir", TurkishNumbers.convertNumberToString("11")); Assert.assertEquals("yüz on bir", TurkishNumbers.convertNumberToString("111")); Assert.assertEquals("yüz on bir bin", TurkishNumbers.convertNumberToString("111000")); Assert.assertEquals("sıfır yüz on bir bin", TurkishNumbers.convertNumberToString("0111000")); Assert.assertEquals("sıfır sıfır yüz on bir bin", TurkishNumbers.convertNumberToString("00111000")); } |
### Question:
TurkishNumbers { public static String convertOrdinalNumberString(String input) { String numberPart = input; if (input.endsWith(".")) { numberPart = Strings.subStringUntilFirst(input, "."); } long number = Long.parseLong(numberPart); String text = convertToString(number); String[] words = text.trim().split("[ ]+"); String lastNumber = words[words.length - 1]; if (ordinalMap.containsKey(lastNumber)) { lastNumber = ordinalMap.get(lastNumber); } else { throw new RuntimeException("Cannot find ordinal reading for:" + lastNumber); } StringBuilder sb = new StringBuilder(); for (int i = 0; i < words.length - 1; i++) { sb.append(words[i]).append(" "); } sb.append(lastNumber); return sb.toString(); } static Map<String, String> getOrdinalMap(); static String convertToString(long input); static String convertNumberToString(String input); static long singleWordNumberValue(String word); static List<String> replaceNumberStrings(List<String> inputSequence); static List<String> seperateConnectedNumbers(List<String> inputSequence); static List<String> seperateConnectedNumbers(String input); static long convertToNumber(String... words); static long convertToNumber(String text); static String convertOrdinalNumberString(String input); static List<String> separateNumbers(String s); static String getOrdinal(String input); static boolean hasNumber(String s); static boolean hasOnlyNumber(String s); static int romanToDecimal(String s); static final long MAX_NUMBER; static final long MIN_NUMBER; }### Answer:
@Test public void ordinalTest() { Assert.assertEquals("sıfırıncı", TurkishNumbers.convertOrdinalNumberString("0.")); } |
### Question:
TurkishNumbers { public static List<String> separateNumbers(String s) { return Regexps.allMatches(NUMBER_SEPARATION, s); } static Map<String, String> getOrdinalMap(); static String convertToString(long input); static String convertNumberToString(String input); static long singleWordNumberValue(String word); static List<String> replaceNumberStrings(List<String> inputSequence); static List<String> seperateConnectedNumbers(List<String> inputSequence); static List<String> seperateConnectedNumbers(String input); static long convertToNumber(String... words); static long convertToNumber(String text); static String convertOrdinalNumberString(String input); static List<String> separateNumbers(String s); static String getOrdinal(String input); static boolean hasNumber(String s); static boolean hasOnlyNumber(String s); static int romanToDecimal(String s); static final long MAX_NUMBER; static final long MIN_NUMBER; }### Answer:
@Test public void separateNumbersTest() { Assert.assertEquals(Lists.newArrayList("H", "12", "A", "5") , TurkishNumbers.separateNumbers("H12A5")); Assert.assertEquals(Lists.newArrayList("F", "16", "'ya") , TurkishNumbers.separateNumbers("F16'ya")); } |
### Question:
TurkishNumbers { public static List<String> seperateConnectedNumbers(List<String> inputSequence) { List<String> output = new ArrayList<>(inputSequence.size()); for (String s : inputSequence) { if (stringToNumber.containsKey(s)) { output.add(valueOf(stringToNumber.get(s))); continue; } output.addAll(seperateConnectedNumbers(s)); } return output; } static Map<String, String> getOrdinalMap(); static String convertToString(long input); static String convertNumberToString(String input); static long singleWordNumberValue(String word); static List<String> replaceNumberStrings(List<String> inputSequence); static List<String> seperateConnectedNumbers(List<String> inputSequence); static List<String> seperateConnectedNumbers(String input); static long convertToNumber(String... words); static long convertToNumber(String text); static String convertOrdinalNumberString(String input); static List<String> separateNumbers(String s); static String getOrdinal(String input); static boolean hasNumber(String s); static boolean hasOnlyNumber(String s); static int romanToDecimal(String s); static final long MAX_NUMBER; static final long MIN_NUMBER; }### Answer:
@Test public void separateConnectedNumbersTest() { Assert.assertEquals(Lists.newArrayList("on") , TurkishNumbers.seperateConnectedNumbers("on")); Assert.assertEquals(Lists.newArrayList("on", "iki", "bin", "altı", "yüz") , TurkishNumbers.seperateConnectedNumbers("onikibinaltıyüz")); Assert.assertEquals(Lists.newArrayList("bir", "iki", "üç") , TurkishNumbers.seperateConnectedNumbers("birikiüç")); } |
### Question:
TurkishNumbers { public static long convertToNumber(String... words) { return textToNumber.convert(words); } static Map<String, String> getOrdinalMap(); static String convertToString(long input); static String convertNumberToString(String input); static long singleWordNumberValue(String word); static List<String> replaceNumberStrings(List<String> inputSequence); static List<String> seperateConnectedNumbers(List<String> inputSequence); static List<String> seperateConnectedNumbers(String input); static long convertToNumber(String... words); static long convertToNumber(String text); static String convertOrdinalNumberString(String input); static List<String> separateNumbers(String s); static String getOrdinal(String input); static boolean hasNumber(String s); static boolean hasOnlyNumber(String s); static int romanToDecimal(String s); static final long MAX_NUMBER; static final long MIN_NUMBER; }### Answer:
@Test public void testTextToNumber1() { Assert.assertEquals(11, TurkishNumbers.convertToNumber("on bir")); Assert.assertEquals(111, TurkishNumbers.convertToNumber("yüz on bir")); Assert.assertEquals(101, TurkishNumbers.convertToNumber("yüz bir")); Assert.assertEquals(1000_000, TurkishNumbers.convertToNumber("bir milyon")); Assert.assertEquals(-1, TurkishNumbers.convertToNumber("bir bin")); } |
### Question:
TurkishNumbers { public static int romanToDecimal(String s) { if (s == null || s.isEmpty() || !romanNumeralPattern.matcher(s).matches()) { return -1; } final Matcher matcher = Pattern.compile("M|CM|D|CD|C|XC|L|XL|X|IX|V|IV|I").matcher(s); final int[] decimalValues = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1}; final String[] romanNumerals = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"}; int result = 0; while (matcher.find()) { for (int i = 0; i < romanNumerals.length; i++) { if (romanNumerals[i].equals(matcher.group(0))) { result += decimalValues[i]; } } } return result; } static Map<String, String> getOrdinalMap(); static String convertToString(long input); static String convertNumberToString(String input); static long singleWordNumberValue(String word); static List<String> replaceNumberStrings(List<String> inputSequence); static List<String> seperateConnectedNumbers(List<String> inputSequence); static List<String> seperateConnectedNumbers(String input); static long convertToNumber(String... words); static long convertToNumber(String text); static String convertOrdinalNumberString(String input); static List<String> separateNumbers(String s); static String getOrdinal(String input); static boolean hasNumber(String s); static boolean hasOnlyNumber(String s); static int romanToDecimal(String s); static final long MAX_NUMBER; static final long MIN_NUMBER; }### Answer:
@Test public void romanNumberTest() { Assert.assertEquals(-1, TurkishNumbers.romanToDecimal("foo")); Assert.assertEquals(-1, TurkishNumbers.romanToDecimal("IIIIIII")); Assert.assertEquals(1987, TurkishNumbers.romanToDecimal("MCMLXXXVII")); } |
### Question:
SingleAnalysis { public PrimaryPos getPos() { return getGroup(groupCount() - 1).getPos(); } SingleAnalysis(
DictionaryItem item,
List<MorphemeData> morphemeDataList,
int[] groupBoundaries); static SingleAnalysis unknown(String input); static SingleAnalysis dummy(String input, DictionaryItem item); String surfaceForm(); boolean containsInformalMorpheme(); String getEnding(); String getStem(); boolean containsMorpheme(Morpheme morpheme); StemAndEnding getStemAndEnding(); DictionaryItem getDictionaryItem(); boolean isUnknown(); boolean isRuntime(); List<MorphemeData> getMorphemeDataList(); List<Morpheme> getMorphemes(); MorphemeGroup getGroup(int groupIndex); MorphemeGroup getLastGroup(); MorphemeGroup[] getGroups(); static SingleAnalysis fromSearchPath(SearchPath searchPath); boolean containsAnyMorpheme(Morpheme... morphemes); List<String> getStems(); List<String> getLemmas(); @Override String toString(); String formatLexical(); String formatMorphemesLexical(); PrimaryPos getPos(); String formatLong(); int groupCount(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void getPosTest() { RuleBasedAnalyzer analyzer = getAnalyzer("görmek"); List<SingleAnalysis> analyses = analyzer.analyze("görmek"); Assert.assertEquals(1, analyses.size()); SingleAnalysis analysis = analyses.get(0); Assert.assertEquals(analysis.getDictionaryItem(), analyzer.getLexicon().getItemById("görmek_Verb")); Assert.assertEquals(PrimaryPos.Noun, analysis.getPos()); } |
### Question:
SingleAnalysis { public List<String> getStems() { List<String> stems = Lists.newArrayListWithCapacity(2); stems.add(getStem()); String previousStem = getGroup(0).surfaceForm(); if (groupBoundaries.length > 1) { for (int i = 1; i < groupBoundaries.length; i++) { MorphemeGroup ig = getGroup(i); MorphemeData suffixData = ig.morphemes.get(0); String surface = suffixData.surface; String stem = previousStem + surface; if (!stems.contains(stem)) { stems.add(stem); } previousStem = previousStem + ig.surfaceForm(); } } return stems; } SingleAnalysis(
DictionaryItem item,
List<MorphemeData> morphemeDataList,
int[] groupBoundaries); static SingleAnalysis unknown(String input); static SingleAnalysis dummy(String input, DictionaryItem item); String surfaceForm(); boolean containsInformalMorpheme(); String getEnding(); String getStem(); boolean containsMorpheme(Morpheme morpheme); StemAndEnding getStemAndEnding(); DictionaryItem getDictionaryItem(); boolean isUnknown(); boolean isRuntime(); List<MorphemeData> getMorphemeDataList(); List<Morpheme> getMorphemes(); MorphemeGroup getGroup(int groupIndex); MorphemeGroup getLastGroup(); MorphemeGroup[] getGroups(); static SingleAnalysis fromSearchPath(SearchPath searchPath); boolean containsAnyMorpheme(Morpheme... morphemes); List<String> getStems(); List<String> getLemmas(); @Override String toString(); String formatLexical(); String formatMorphemesLexical(); PrimaryPos getPos(); String formatLong(); int groupCount(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void getStemsTest() { RuleBasedAnalyzer analyzer = getAnalyzer("kitap"); SingleAnalysis analysis = analyzer.analyze("kitap").get(0); Assert.assertEquals(toList("kitap"), analysis.getStems()); analysis = analyzer.analyze("kitaplı").get(0); Assert.assertEquals(toList("kitap", "kitaplı"), analysis.getStems()); analysis = analyzer.analyze("kitaplarda").get(0); Assert.assertEquals(toList("kitap"), analysis.getStems()); analysis = analyzer.analyze("kitabımmış").get(0); Assert.assertEquals(toList("kitab", "kitabım"), analysis.getStems()); analysis = analyzer.analyze("kitapçığa").get(0); Assert.assertEquals(toList("kitap", "kitapçığ"), analysis.getStems()); analyzer = getAnalyzer("okumak"); analysis = analyzer.analyze("okut").get(0); Assert.assertEquals(toList("oku", "okut"), analysis.getStems()); analysis = analyzer.analyze("okuttur").get(0); Assert.assertEquals(toList("oku", "okut", "okuttur"), analysis.getStems()); analysis = analyzer.analyze("okutturuluyor").get(0); Assert.assertEquals(toList("oku", "okut", "okuttur", "okutturul"), analysis.getStems()); analysis = analyzer.analyze("okutturamıyor").get(0); Assert.assertEquals(toList("oku", "okut", "okuttur"), analysis.getStems()); analysis = analyzer.analyze("okutturabiliyor").get(0); Assert.assertEquals(toList("oku", "okut", "okuttur", "okutturabil"), analysis.getStems()); } |
### Question:
SingleAnalysis { public List<String> getLemmas() { List<String> lemmas = Lists.newArrayListWithCapacity(2); lemmas.add(item.root); String previousStem = getGroup(0).surfaceForm(); if (!previousStem.equals(item.root)) { if (previousStem.endsWith("ğ")) { previousStem = previousStem.substring(0, previousStem.length() - 1) + "k"; } } if (groupBoundaries.length > 1) { for (int i = 1; i < groupBoundaries.length; i++) { MorphemeGroup ig = getGroup(i); MorphemeData suffixData = ig.morphemes.get(0); String surface = suffixData.surface; String stem = previousStem + surface; if (stem.endsWith("ğ")) { stem = stem.substring(0, stem.length() - 1) + "k"; } if (!lemmas.contains(stem)) { lemmas.add(stem); } previousStem = previousStem + ig.surfaceForm(); } } return lemmas; } SingleAnalysis(
DictionaryItem item,
List<MorphemeData> morphemeDataList,
int[] groupBoundaries); static SingleAnalysis unknown(String input); static SingleAnalysis dummy(String input, DictionaryItem item); String surfaceForm(); boolean containsInformalMorpheme(); String getEnding(); String getStem(); boolean containsMorpheme(Morpheme morpheme); StemAndEnding getStemAndEnding(); DictionaryItem getDictionaryItem(); boolean isUnknown(); boolean isRuntime(); List<MorphemeData> getMorphemeDataList(); List<Morpheme> getMorphemes(); MorphemeGroup getGroup(int groupIndex); MorphemeGroup getLastGroup(); MorphemeGroup[] getGroups(); static SingleAnalysis fromSearchPath(SearchPath searchPath); boolean containsAnyMorpheme(Morpheme... morphemes); List<String> getStems(); List<String> getLemmas(); @Override String toString(); String formatLexical(); String formatMorphemesLexical(); PrimaryPos getPos(); String formatLong(); int groupCount(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void getLemmasTest() { RuleBasedAnalyzer analyzer = getAnalyzer("kitap"); SingleAnalysis analysis = analyzer.analyze("kitap").get(0); Assert.assertEquals(toList("kitap"), analysis.getLemmas()); analysis = analyzer.analyze("kitaplı").get(0); Assert.assertEquals(toList("kitap", "kitaplı"), analysis.getLemmas()); analysis = analyzer.analyze("kitaplarda").get(0); Assert.assertEquals(toList("kitap"), analysis.getLemmas()); analysis = analyzer.analyze("kitabımmış").get(0); Assert.assertEquals(toList("kitap", "kitabım"), analysis.getLemmas()); analysis = analyzer.analyze("kitapçığa").get(0); Assert.assertEquals(toList("kitap", "kitapçık"), analysis.getLemmas()); analyzer = getAnalyzer("okumak"); analysis = analyzer.analyze("okut").get(0); Assert.assertEquals(toList("oku", "okut"), analysis.getLemmas()); analysis = analyzer.analyze("okuttur").get(0); Assert.assertEquals(toList("oku", "okut", "okuttur"), analysis.getLemmas()); analysis = analyzer.analyze("okutturuluyor").get(0); Assert.assertEquals(toList("oku", "okut", "okuttur", "okutturul"), analysis.getLemmas()); analysis = analyzer.analyze("okutturamıyor").get(0); Assert.assertEquals(toList("oku", "okut", "okuttur"), analysis.getLemmas()); analysis = analyzer.analyze("okutturabiliyor").get(0); Assert.assertEquals(toList("oku", "okut", "okuttur", "okutturabil"), analysis.getLemmas()); } |
### Question:
SingleAnalysis { public String formatLong() { return AnalysisFormatters.DEFAULT.format(this); } SingleAnalysis(
DictionaryItem item,
List<MorphemeData> morphemeDataList,
int[] groupBoundaries); static SingleAnalysis unknown(String input); static SingleAnalysis dummy(String input, DictionaryItem item); String surfaceForm(); boolean containsInformalMorpheme(); String getEnding(); String getStem(); boolean containsMorpheme(Morpheme morpheme); StemAndEnding getStemAndEnding(); DictionaryItem getDictionaryItem(); boolean isUnknown(); boolean isRuntime(); List<MorphemeData> getMorphemeDataList(); List<Morpheme> getMorphemes(); MorphemeGroup getGroup(int groupIndex); MorphemeGroup getLastGroup(); MorphemeGroup[] getGroups(); static SingleAnalysis fromSearchPath(SearchPath searchPath); boolean containsAnyMorpheme(Morpheme... morphemes); List<String> getStems(); List<String> getLemmas(); @Override String toString(); String formatLexical(); String formatMorphemesLexical(); PrimaryPos getPos(); String formatLong(); int groupCount(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void getLemmasAfterZeroMorphemeTest_Issue_175() { RuleBasedAnalyzer analyzer = getAnalyzer("gün"); List<SingleAnalysis> analyses = analyzer.analyze("günlüğüm"); boolean found = false; for (SingleAnalysis analysis : analyses) { if (analysis.formatLong().contains("Ness→Noun+A3sg|Zero→Verb")) { found = true; Assert.assertEquals(toList("gün", "günlük"), analysis.getLemmas()); } } if (!found) { Assert.fail("Counld not found an analysis with `Ness→Noun+A3sg|Zero→Verb` in it"); } } |
### Question:
WordAnalysisSurfaceFormatter { public String format(SingleAnalysis analysis, String apostrophe) { DictionaryItem item = analysis.getDictionaryItem(); String ending = analysis.getEnding(); if (apostrophe != null || apostropheRequired(analysis)) { if (apostrophe == null) { apostrophe = "'"; } return ending.length() > 0 ? item.normalizedLemma() + apostrophe + ending : item.normalizedLemma(); } else { if (item.attributes.contains(RootAttribute.NoQuote)) { return item.normalizedLemma() + ending; } else { return analysis.getStem() + ending; } } } String format(SingleAnalysis analysis, String apostrophe); String format(SingleAnalysis analysis); String formatToCase(SingleAnalysis analysis, CaseType type, String apostrophe); String formatToCase(SingleAnalysis analysis, CaseType type); boolean canBeFormatted(SingleAnalysis analysis, CaseType type); CaseType guessCase(String input); }### Answer:
@Test public void formatNonProperNoun() { TurkishMorphology morphology = TurkishMorphology.builder() .disableCache() .setLexicon("elma", "kitap", "demek", "evet") .build(); String[] inputs = {"elmamadaki", "elma", "kitalarımdan", "kitabımızsa", "diyebileceğimiz", "dedi", "evet"}; WordAnalysisSurfaceFormatter formatter = new WordAnalysisSurfaceFormatter(); for (String input : inputs) { WordAnalysis results = morphology.analyze(input); for (SingleAnalysis result : results) { Assert.assertEquals(input, formatter.format(result, null)); } } }
@Test public void formatNumerals() { TurkishMorphology morphology = TurkishMorphology.builder().disableCache().build(); String[] inputs = {"1e", "4ten", "123ü", "12,5ten"}; String[] expected = {"1'e", "4'ten", "123'ü", "12,5ten"}; WordAnalysisSurfaceFormatter formatter = new WordAnalysisSurfaceFormatter(); int i = 0; for (String input : inputs) { WordAnalysis results = morphology.analyze(input); for (SingleAnalysis result : results) { if (result.getDictionaryItem().primaryPos == PrimaryPos.Numeral) { Assert.assertEquals(expected[i], formatter.format(result, "'")); } } i++; } } |
### Question:
WordAnalysisSurfaceFormatter { public String formatToCase(SingleAnalysis analysis, CaseType type, String apostrophe) { String formatted = format(analysis, apostrophe); Locale locale = analysis.getDictionaryItem().hasAttribute(RootAttribute.LocaleEn) ? Locale.ENGLISH : Turkish.LOCALE; switch (type) { case DEFAULT_CASE: return formatted; case LOWER_CASE: return formatted.toLowerCase(locale); case UPPER_CASE: return formatted.toUpperCase(locale); case TITLE_CASE: return Turkish.capitalize(formatted); case UPPER_CASE_ROOT_LOWER_CASE_ENDING: String ending = analysis.getEnding(); String lemmaUpper = analysis.getDictionaryItem().normalizedLemma().toUpperCase(locale); if (ending.length() == 0) { return lemmaUpper; } if (apostrophe != null || apostropheRequired(analysis)) { if (apostrophe == null) { apostrophe = "'"; } return lemmaUpper + apostrophe + ending; } else { return lemmaUpper + ending; } default: return ""; } } String format(SingleAnalysis analysis, String apostrophe); String format(SingleAnalysis analysis); String formatToCase(SingleAnalysis analysis, CaseType type, String apostrophe); String formatToCase(SingleAnalysis analysis, CaseType type); boolean canBeFormatted(SingleAnalysis analysis, CaseType type); CaseType guessCase(String input); }### Answer:
@Test public void formatToCase() { TurkishMorphology morphology = TurkishMorphology.builder() .disableCache() .setLexicon("kış", "şiir", "Aydın", "Google [Pr:gugıl]") .build(); String[] inputs = {"aydında", "googledan", "Google", "şiirde", "kışçığa", "kış"}; String[] expectedDefaultCase = {"Aydın'da", "Google'dan", "Google", "şiirde", "kışçığa", "kış"}; String[] expectedLowerCase = {"aydın'da", "google'dan", "google", "şiirde", "kışçığa", "kış"}; String[] expectedUpperCase = {"AYDIN'DA", "GOOGLE'DAN", "GOOGLE", "ŞİİRDE", "KIŞÇIĞA", "KIŞ"}; String[] expectedCapitalCase = {"Aydın'da", "Google'dan", "Google", "Şiirde", "Kışçığa", "Kış"}; String[] expectedUpperRootLowerEndingCase = {"AYDIN'da", "GOOGLE'dan", "GOOGLE", "ŞİİRde", "KIŞçığa", "KIŞ"}; testCaseType(morphology, inputs, expectedDefaultCase, DEFAULT_CASE); testCaseType(morphology, inputs, expectedLowerCase, LOWER_CASE); testCaseType(morphology, inputs, expectedUpperCase, UPPER_CASE); testCaseType(morphology, inputs, expectedCapitalCase, TITLE_CASE); testCaseType(morphology, inputs, expectedUpperRootLowerEndingCase, UPPER_CASE_ROOT_LOWER_CASE_ENDING); } |
### Question:
TurkishSpellChecker { public List<String> suggestForWord(String word, NgramLanguageModel lm) { List<String> unRanked = getUnrankedSuggestions(word); return rankWithUnigramProbability(unRanked, lm); } TurkishSpellChecker(TurkishMorphology morphology); TurkishSpellChecker(TurkishMorphology morphology, CharacterGraph graph); TurkishSpellChecker(
TurkishMorphology morphology,
CharacterGraphDecoder decoder,
CharMatcher matcher); NgramLanguageModel getUnigramLanguageModel(); void setAnalysisPredicate(Predicate<SingleAnalysis> analysisPredicate); static List<String> tokenizeForSpelling(String sentence); boolean check(String input); List<String> suggestForWord(String word, NgramLanguageModel lm); List<String> suggestForWord(
String word,
String leftContext,
String rightContext,
NgramLanguageModel lm); List<String> suggestForWord(String word); CharacterGraphDecoder getDecoder(); List<String> rankWithUnigramProbability(List<String> strings, NgramLanguageModel lm); }### Answer:
@Test public void suggestVerb1() { TurkishMorphology morphology = TurkishMorphology.builder().setLexicon("okumak").build(); List<String> endings = Lists.newArrayList("dum"); StemEndingGraph graph = new StemEndingGraph(morphology, endings); TurkishSpellChecker spellChecker = new TurkishSpellChecker(morphology, graph.stemGraph); List<String> res = spellChecker.suggestForWord("okudm"); Assert.assertTrue(res.contains("okudum")); } |
### Question:
WordAnalysisSurfaceFormatter { public CaseType guessCase(String input) { boolean firstLetterUpperCase = false; int lowerCaseCount = 0; int upperCaseCount = 0; int letterCount = 0; for (int i = 0; i < input.length(); i++) { char c = input.charAt(i); if (!Character.isAlphabetic(c)) { continue; } if (i == 0) { firstLetterUpperCase = Character.isUpperCase(c); if (firstLetterUpperCase) { upperCaseCount++; } else { lowerCaseCount++; } } else { if (Character.isUpperCase(c)) { upperCaseCount++; } else if (Character.isLowerCase(c)) { lowerCaseCount++; } } letterCount++; } if (letterCount == 0) { return CaseType.DEFAULT_CASE; } if (letterCount == lowerCaseCount) { return CaseType.LOWER_CASE; } if (letterCount == upperCaseCount) { return CaseType.UPPER_CASE; } if (firstLetterUpperCase && letterCount == lowerCaseCount + 1) { return letterCount == 1 ? CaseType.UPPER_CASE : CaseType.TITLE_CASE; } int apostropheIndex = input.indexOf('\''); if (apostropheIndex > 0 && apostropheIndex < input.length() - 1) { if (guessCase(input.substring(0, apostropheIndex)) == CaseType.UPPER_CASE && guessCase(input.substring(apostropheIndex + 1)) == CaseType.LOWER_CASE) { return CaseType.UPPER_CASE_ROOT_LOWER_CASE_ENDING; } } return CaseType.MIXED_CASE; } String format(SingleAnalysis analysis, String apostrophe); String format(SingleAnalysis analysis); String formatToCase(SingleAnalysis analysis, CaseType type, String apostrophe); String formatToCase(SingleAnalysis analysis, CaseType type); boolean canBeFormatted(SingleAnalysis analysis, CaseType type); CaseType guessCase(String input); }### Answer:
@Test public void guessCaseTest() { String[] inputs = {"abc", "Abc", "ABC", "Abc'de", "ABC'DE", "ABC.", "ABC'de", "a", "12", "A", "A1"}; WordAnalysisSurfaceFormatter.CaseType[] expected = { LOWER_CASE, TITLE_CASE, UPPER_CASE, TITLE_CASE, UPPER_CASE, UPPER_CASE, UPPER_CASE_ROOT_LOWER_CASE_ENDING, LOWER_CASE, DEFAULT_CASE, UPPER_CASE, UPPER_CASE, }; WordAnalysisSurfaceFormatter formatter = new WordAnalysisSurfaceFormatter(); int i = 0; for (String input : inputs) { Assert.assertEquals(expected[i], formatter.guessCase(input)); i++; } } |
### Question:
RuleBasedDisambiguator { public ResultSentence disambiguate(String sentence) { List<WordAnalysis> ambiguous = analyzer.analyzeSentence(sentence); ResultSentence s = new ResultSentence(sentence, ambiguous); s.makeDecisions(rules); return s; } RuleBasedDisambiguator(TurkishMorphology analyzer, Rules rules); ResultSentence disambiguate(String sentence); }### Answer:
@Test public void test() throws IOException { String input = "4 Neden önemli?"; TurkishMorphology analyzer = TurkishMorphology.createWithDefaults(); RuleBasedDisambiguator disambiguator = new RuleBasedDisambiguator(analyzer, Rules.fromResources()); ResultSentence resultSentence = disambiguator.disambiguate(input); System.out.println(resultSentence.allIgnoredCount()); for (AmbiguityAnalysis a : resultSentence.results) { a.getForTrainingOutput().forEach(System.out::println); } } |
### Question:
WebDocument { public static WebDocument fromText(String meta, List<String> pageData) { String url = Regexps.firstMatch(urlPattern, meta, 2); String id = url.replaceAll("http: String source = Regexps.firstMatch(sourcePattern, meta, 2); String crawlDate = Regexps.firstMatch(crawlDatePattern, meta, 2); String labels = getAttribute(labelPattern, meta); String category = getAttribute(categoryPattern, meta); String title = getAttribute(titlePattern, meta); int i = source.lastIndexOf("/"); if (i >= 0 && i < source.length()) { source = source.substring(i + 1); } return new WebDocument(source, id, title, pageData, url, crawlDate, labels, category); } WebDocument(String source,
String id,
String title,
List<String> lines,
String url,
String crawlDate,
String labels,
String category); static WebDocument fromText(String meta, List<String> pageData); int contentLength(); void removeDuplicateLines(); String getDocumentHeader(); WebDocument emptyContent(); String getLabelString(); String getCategory(); List<String> getLabels(); String getTitle(); long getHash(); String getContentAsString(); List<String> getLines(); void setContent(List<String> lines); @Override boolean equals(Object o); String getSource(); String getId(); String getUrl(); @Override int hashCode(); }### Answer:
@Test public void testTitleWithDoubleQuotes() { String meta = "<doc id=\"http: String content = "Fernandao yeni yıldan şampiyonluk bekliyor\n" + "30.12.2016 Cuma 17:04 (Güncellendi: 30.12.2016 Cuma 17:09)\n" + "Fernandao yeni yıldan şampiyonluk bekliyor\n" + "</doc>"; WebDocument d = WebDocument.fromText(meta, Splitter.on("\n").splitToList(content)); Assert.assertEquals("Fernandao \"yeni yıldan şampiyonluk\" bekliyor", d.getTitle()); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.