trieintseqcountertest.java

一个自然语言处理的Java开源工具包。LingPipe目前已有很丰富的功能

        assertEquals(0,counter.count(new int[] { 7 }, 0, 1));
        assertEquals(0,counter.count(new int[] { 1, 2, 3, 4 }, 0, 4));
        assertEquals(3,counter.count(new int[] { 1, 2, 3 }, 0, 3));
        assertEquals(4,counter.count(new int[] { 1, 2 }, 0, 2));
        assertEquals(4,counter.count(new int[] { 2, 3 }, 0, 2));
        assertEquals(11,counter.count(new int[] { 2 }, 0, 1));

        counter.prune(4);

        assertEquals(0,counter.count(new int[] { 7 }, 0, 1));
        assertEquals(0,counter.count(new int[] { 1, 2, 3, 4 }, 0, 4));
        assertEquals(0,counter.count(new int[] { 1, 2, 3 }, 0, 3));
        assertEquals(4,counter.count(new int[] { 1, 2 }, 0, 2));
        assertEquals(4,counter.count(new int[] { 2, 3 }, 0, 2));
        assertEquals(11,counter.count(new int[] { 2 }, 0, 1));

        counter.prune(5);

        assertEquals(0,counter.count(new int[] { 7 }, 0, 1));
        assertEquals(0,counter.count(new int[] { 1, 2, 3, 4 }, 0, 4));
        assertEquals(0,counter.count(new int[] { 1, 2, 3 }, 0, 3));
        assertEquals(0,counter.count(new int[] { 1, 2 }, 0, 2));
        assertEquals(0,counter.count(new int[] { 2, 3 }, 0, 2));
        assertEquals(11,counter.count(new int[] { 2 }, 0, 1));

        counter.prune(100);
        assertEquals(0,counter.count(new int[] { 2 }, 0, 1));

    }

    public void testOutcomeHistograms() {
        TrieIntSeqCounter counter = new TrieIntSeqCounter(4);
        counter.incrementSubsequences(new int[] { 1, 2, 3 }, 0, 3);
        counter.incrementSubsequences(new int[] { 1, 2, 4 }, 0, 3);
        counter.incrementSubsequences(new int[] { 1, 2, 4 }, 0, 3);
        counter.incrementSubsequences(new int[] { 1, 2, 5 }, 0, 3);
        counter.incrementSubsequences(new int[] { 1, 3, 6 }, 0, 3);
        counter.incrementSubsequences(new int[] { 7, 1, 2 }, 0, 3);
        counter.incrementSubsequences(new int[] { 7, 1, 3 }, 0, 3);
        counter.incrementSubsequences(new int[] { 1, 3 }, 0, 2);
        counter.incrementSubsequences(new int[] { 7, 1 }, 0, 2);
        ObjectToCounterMap trigramCounter = counter.nGramCounts(3,2);
        List keysOrderedByCount = trigramCounter.keysOrderedByCountList();
        assertEquals(1,keysOrderedByCount.size());
        assertEqualsArray(new int[] { 1, 2, 4 },
                          (int[]) keysOrderedByCount.get(0));


        trigramCounter = counter.nGramCounts(2,2);
        keysOrderedByCount = trigramCounter.keysOrderedByCountList();
        assertEquals(4 ,keysOrderedByCount.size()); // 1,2=5; 7,1=3; 1,3=3; 2,4=2
        assertEqualsArray(new int[] { 1, 2 },
                          (int[]) keysOrderedByCount.get(0));
        assertEquals(5,trigramCounter.getCount((int[]) keysOrderedByCount.get(0)));
        assertEqualsArray(new int[] { 2, 4 },
                          (int[]) keysOrderedByCount.get(3));

        try {
            counter.nGramCounts(0,4);
            fail();
        } catch (IllegalArgumentException e) {
            assertTrue(true);
        }
    }

    public void testExs() {
        try {
            new TrieIntSeqCounter(-1);
            fail();
        } catch (IllegalArgumentException e) {
            assertTrue(true);
        }

        TrieIntSeqCounter counter = new TrieIntSeqCounter(3);
        try {
            counter.incrementSubsequences(new int[4], -1, 2);
            fail();
        } catch (IndexOutOfBoundsException e) {
            assertTrue(true);
        }

        try {
            counter.incrementSubsequences(new int[4], 2, 1);
            fail();
        } catch (IndexOutOfBoundsException e) {
            assertTrue(true);
        }

        try {
            counter.incrementSubsequences(new int[4], 2, 5);
            fail();
        } catch (IndexOutOfBoundsException e) {
            assertTrue(true);
        }

        try {
            counter.incrementSubsequences(new int[4], 5, 7);
            fail();
        } catch (IndexOutOfBoundsException e) {
            assertTrue(true);
        }

        try {
            counter.count(new int[3], 5, 7);
            fail();
        } catch (IndexOutOfBoundsException e) {
            assertTrue(true);
        }

        try {
            counter.extensionCount(new int[3], 5, 7);
            fail();
        } catch (IndexOutOfBoundsException e) {
            assertTrue(true);
        }

        try {
            counter.numExtensions(new int[3], 5, 7);
            fail();
        } catch (IndexOutOfBoundsException e) {
            assertTrue(true);
        }

    }

    public void testMaxLength() {
        TrieIntSeqCounter counter = new TrieIntSeqCounter(3);
        assertEquals(3,counter.maxLength());
    }

    public int A = 'a';
    public int B = 'b';
    public int C = 'c';
    public int D = 'd';
    public int R = 'r';

    public int[] ABRACADABRA = new int[] { A, B, R, A, C, A, D, A, B, R, A };

    public void testCount() {
        TrieIntSeqCounter counter = new TrieIntSeqCounter(3);
        counter.incrementSubsequences(new int[] { }, 0, 0);
        assertEquals(0,counter.count(new int[] { }, 0, 0));
        assertEquals(0,counter.count(new int[] { 1 }, 0, 1));

        counter.incrementSubsequences(new int[] { 1 }, 0, 1);
        assertEquals(1,counter.count(new int[] { 1 }, 0, 1));
        assertEquals(0,counter.count(new int[] { 17 }, 0, 1));

        counter.incrementSubsequences(new int[] { 1 }, 0, 1);
        assertEquals(2,counter.count(new int[] { 1 }, 0, 1));
    }

    public void testAbracadbra() {
        TrieIntSeqCounter counter = new TrieIntSeqCounter(3);
        counter.incrementSubsequences(ABRACADABRA,0,ABRACADABRA.length);

        assertEquals(11,counter.count(new int[] { }, 0, 0));
        assertEquals(5,counter.count(new int[] { A }, 0, 1));
        assertEquals(2,counter.count(new int[] { B }, 0, 1));
        assertEquals(1,counter.count(new int[] { C }, 0, 1));
        assertEquals(5,counter.count(new int[] { B, A }, 1, 2));
        assertEquals(2,counter.count(new int[] { A, B }, 0, 2));
        assertEquals(2,counter.count(new int[] { A, B, R }, 0, 3));
        assertEquals(1,counter.count(new int[] { A, D, A }, 0, 3));
        assertEquals(0,counter.count(new int[] { A, D, A, A }, 0, 4));
        assertEquals(0,counter.count(new int[] { A, B, R, A }, 0, 4));

        assertEquals(11,counter.extensionCount(new int[] { }, 0, 0));
        assertEquals(4,counter.extensionCount(new int[] { A }, 0, 1));
        assertEquals(4,counter.extensionCount(new int[] { B, A }, 1, 2));
        assertEquals(4,counter.extensionCount(new int[] { A, B }, 0, 1));
        assertEquals(0,counter.extensionCount(new int[] { A, B, R }, 0, 3));
        assertEquals(1,counter.extensionCount(new int[] { D, A }, 0, 2));

        assertEquals(5,counter.numExtensions(new int[] { }, 0, 0));
        assertEquals(3,counter.numExtensions(new int[] { A }, 0, 1));
        assertEquals(3,counter.numExtensions(new int[] { B, A }, 1, 2));
        assertEquals(3,counter.numExtensions(new int[] { A, B }, 0, 1));
        assertEquals(0,counter.numExtensions(new int[] { A, B, R }, 0, 3));
        assertEquals(1,counter.numExtensions(new int[] { D, A }, 0, 2));

        counter.incrementSubsequences(new int[] { A, D, B }, 0, 3);
        assertEquals(2,counter.extensionCount(new int[] { A, D, B }, 0, 2));
        assertEquals(2,counter.numExtensions(new int[] { A, D, B }, 0, 2));


        counter.incrementSubsequences(new int[] { A, D, B }, 0, 3);
        assertEquals(3,counter.extensionCount(new int[] { A, D, B }, 0, 2));

        counter.incrementSubsequences(new int[] { A, D, A}, 0, 3);
        assertEquals(4,counter.extensionCount(new int[] { A, D }, 0, 2));
        assertEquals(2,counter.numExtensions(new int[] { A, D }, 0, 2));

        assertEqualsArray(new int[] { A, B, C, D, R },
                          counter.observedIntegers());

        assertEqualsArray(new int[] { R },
                          counter.integersFollowing(new int[] { B }, 0, 1));
        assertEqualsArray(new int[] { A, B, C, D, R },
                          counter.integersFollowing(new int[0], 0, 0));

        assertEqualsArray(new int[] { B, C, D },
                          counter.integersFollowing(new int[] { A }, 0, 1));


    }


    public void testMultipleIncrements() {
        Random random = new Random();
        TrieIntSeqCounter counter1 = new TrieIntSeqCounter(3);
        TrieIntSeqCounter counter2 = new TrieIntSeqCounter(3);
        int[] xs = new int[5];
        for (int i = 0; i < 100; ++i) {
            for (int k = 0; k < xs.length; ++k)
                xs[k] = random.nextInt(16);
            int trainingCount = random.nextInt(10); // train 0 to 10 times
            incrementAssertSynched(counter1,counter2,xs,trainingCount);
        }
    }

    void incrementAssertSynched(TrieIntSeqCounter counter1,
                                TrieIntSeqCounter counter2,
                                int[] seq,
                                int count) {
        for (int i = 0; i < count; ++i)
            counter1.incrementSubsequences(seq,0,seq.length);
        counter2.incrementSubsequences(seq,0,seq.length,count);
        assertSynched(counter1,counter2);
        assertSynched(counter2,counter1);
    }

    void assertSynched(TrieIntSeqCounter counter1, TrieIntSeqCounter counter2) {
        int[] seq = new int[counter1.maxLength()];
        for (int n = 0; n < counter1.maxLength(); ++n) {
            int[] followers = counter1.integersFollowing(seq,0,n);
            for (int k = 0; k < followers.length; ++k) {
                seq[n] = followers[k];
                assertCount(counter1,counter2,seq,n+1);
            }
        }
    }

    void assertCount(TrieIntSeqCounter counter1, TrieIntSeqCounter counter2,
                     int[] seq, int length) {
        assertEquals(counter1.count(seq,0,length),
                     counter2.count(seq,0,length));
        assertEquals(counter1.extensionCount(seq,0,length),
                     counter2.extensionCount(seq,0,length));
    }


}