trieintseqcountertest.java

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

package com.aliasi.test.unit.lm;

import com.aliasi.lm.TrieIntSeqCounter;

import com.aliasi.util.ObjectToCounterMap;

import com.aliasi.test.unit.BaseTestCase;

import java.util.List;
import java.util.Random;

public class TrieIntSeqCounterTest extends BaseTestCase {

    public void testZero() {
        TrieIntSeqCounter counter = new TrieIntSeqCounter(3);

        int[] is_12 = new int[] { 1, 2 };
        int[] is_13 = new int[] { 1, 3 };

        counter.incrementSequence(is_12,0,2,12);
        assertEquals(12,counter.count(is_12,0,2));
        assertEquals(12,counter.extensionCount(is_12,0,1));

        counter.incrementSequence(is_13,0,2,10);
        assertEquals(10,counter.count(is_13,0,2));
        assertEquals(22,counter.extensionCount(is_13,0,1));

        counter.incrementSequence(is_13,0,2,44);
        assertEquals(54,counter.count(is_13,0,2));
        assertEquals(66,counter.extensionCount(is_13,0,1));

        counter.incrementSequence(is_13,0,0,111);
        assertEquals(111,counter.count(is_13,0,0));

        counter.incrementSequence(is_13,0,1,444);
        assertEquals(444,counter.count(is_13,0,1));
        assertEquals(444,counter.extensionCount(is_13,0,0));

        counter.incrementSequence(is_13,0,0,111);
        assertEquals(222,counter.count(is_13,0,0));

        counter.incrementSequence(is_13,0,1,444);
        assertEquals(888,counter.count(is_13,0,1));
        assertEquals(888,counter.extensionCount(is_13,0,0));

        int[] is_2 = new int[] { 2 };
        int[] is_3 = new int[] { 3 };
        int[] is_4 = new int[] { 4 };
        counter.incrementSequence(is_2,0,1,10);
        counter.incrementSequence(is_3,0,1,100);
        counter.incrementSequence(is_4,0,1,1000);

        assertEquals(10,counter.count(is_2,0,1));
        assertEquals(100,counter.count(is_3,0,1));
        assertEquals(1000,counter.count(is_4,0,1));
        assertEquals(1998,counter.extensionCount(is_4,0,0));
    }


    public void testSequence() {
        int[] is_1 = new int[] { 1 };
        TrieIntSeqCounter counter = new TrieIntSeqCounter(3);
        counter.incrementSequence(is_1, 0, 1, 3);
        assertEquals(3,counter.extensionCount(is_1, 0, 0));
        assertEquals(3,counter.count(is_1, 0, 1));
        assertEquals(0,counter.extensionCount(is_1,0,1));

        int[] is_123 = new int[] { 1, 2, 3 };
        counter.incrementSequence(is_123, 0, 3, 5);
        assertEquals(3,counter.extensionCount(is_1, 0, 0));
        assertEquals(3,counter.count(is_1, 0, 1));
        assertEquals(0,counter.extensionCount(is_1,0,1));
        assertEquals(5,counter.count(is_123,0,3));
        assertEquals(5,counter.extensionCount(is_123,0,2));

        int[] is_12345 = new int[] { 1, 2, 3, 4, 5 };
        int[] is_345 = new int[] { 3, 4, 5 };
        int[] is_34 = new int[] { 3, 4 };
        counter.incrementSequence(is_12345,0,5,109);
        assertEquals(0,counter.count(is_12345,0,5));
        assertEquals(109,counter.extensionCount(is_34,0,2));
        assertEquals(109,counter.count(is_345,0,3));
        assertEquals(109,counter.count(is_12345,2,5));

        int[] is_134 = new int[] { 1, 3, 4 };
        int[] is_135 = new int[] { 1, 3, 5 };
        int[] is_136 = new int[] { 1, 3, 6 };
        int[] is_137 = new int[] { 1, 3, 7 };
        counter.incrementSequence(is_134,0,3,12);
        assertEquals(12,counter.count(is_134,0,3));
        counter.incrementSequence(is_134,0,3,10);
        assertEquals(22,counter.count(is_134,0,3));

        counter.incrementSequence(is_135,0,3,44);
        assertEquals(22,counter.count(is_134,0,3));
        assertEquals(44,counter.count(is_135,0,3));

        counter.incrementSequence(is_136,0,3,55);
        assertEquals(22,counter.count(is_134,0,3));
        assertEquals(44,counter.count(is_135,0,3));
        assertEquals(55,counter.count(is_136,0,3));

        counter.incrementSequence(is_137,0,3,81);
        assertEquals(22,counter.count(is_134,0,3));
        assertEquals(44,counter.count(is_135,0,3));
        assertEquals(55,counter.count(is_136,0,3));
        assertEquals(81,counter.count(is_137,0,3));

        counter.incrementSequence(is_136,0,3,1000);
        assertEquals(22,counter.count(is_134,0,3));
        assertEquals(44,counter.count(is_135,0,3));
        assertEquals(1055,counter.count(is_136,0,3));
        assertEquals(81,counter.count(is_137,0,3));
    }

    public void testSize() {
        TrieIntSeqCounter counter = new TrieIntSeqCounter(4);
        assertEquals(1,counter.trieSize());

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

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

        counter.incrementSubsequences(new int[] { 3 }, 0, 1);
        assertEquals(4,counter.trieSize());

        counter.incrementSubsequences(new int[] { 4 }, 0, 1);
        assertEquals(5,counter.trieSize());

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

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

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

        counter.incrementSubsequences(new int[] { 2, 3}, 0, 2);
        assertEquals(9,counter.trieSize());

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

        counter.incrementSubsequences(new int[] { 1, 2, 3, 4}, 0, 4);
        assertEquals(13,counter.trieSize()); // +3,4; +2,3,4; +1,2,3,4
    }

    public void testScaling1() {
        TrieIntSeqCounter counter = new TrieIntSeqCounter(4);
        counter.incrementSubsequences(new int[] { 1, 2 }, 0, 2);
        counter.incrementSubsequences(new int[] { 1, 3 }, 0, 2);
        counter.incrementSubsequences(new int[] { 1, 3 }, 0, 2);
        counter.rescale(0.5F);
        assertEquals(3,counter.count(new int[] { }, 0, 0));
        assertEquals(1,counter.count(new int[] { 1 }, 0, 1));
        assertEquals(0,counter.count(new int[] { 1, 2 }, 0, 2));
        assertEquals(1,counter.count(new int[] { 1, 3 }, 0, 2));
    }

    public void testScaling2() {
        TrieIntSeqCounter counter = new TrieIntSeqCounter(4);
        counter.incrementSubsequences(new int[] { 1, 2 }, 0, 2);
        counter.incrementSubsequences(new int[] { 1, 3 }, 0, 2);
        counter.incrementSubsequences(new int[] { 1, 3 }, 0, 2);
        counter.incrementSubsequences(new int[] { 1, 4 }, 0, 2);
        counter.rescale(0.5);
        assertEquals(4,counter.count(new int[] { }, 0, 0));
        assertEquals(2,counter.count(new int[] { 1 }, 0, 1));
        assertEquals(0,counter.count(new int[] { 1, 2 }, 0, 2));
        assertEquals(1,counter.count(new int[] { 1, 3 }, 0, 2));
        assertEquals(0,counter.count(new int[] { 1, 4 }, 0, 2));
    }

    public void testScaling3() {
        TrieIntSeqCounter counter = new TrieIntSeqCounter(4);
        counter.incrementSubsequences(new int[] { 1, 2, 3, 4 }, 0, 4);
        counter.incrementSubsequences(new int[] { 1, 2, 3, 4 }, 0, 4);
        counter.incrementSubsequences(new int[] { 1, 2, 3, 4 }, 0, 4);
        counter.incrementSubsequences(new int[] { 1, 2, 3, 5 }, 0, 4);
        counter.incrementSubsequences(new int[] { 1, 2, 3, 6 }, 0, 4);
        counter.incrementSubsequences(new int[] { 1, 7, 8, 9 }, 0, 4);
        counter.rescale(0.5);
        assertEquals(12,counter.count(new int[] { }, 0, 0));
        assertEquals(3,counter.count(new int[] { 1 }, 0, 1));
        assertEquals(2,counter.count(new int[] { 1, 2 }, 0, 2));
        assertEquals(2,counter.count(new int[] { 1, 2, }, 0, 2));
        assertEquals(0,counter.count(new int[] { 1, 7, }, 0, 2));
        assertEquals(2,counter.count(new int[] { 1, 2, 3}, 0, 3));
        assertEquals(1,counter.count(new int[] { 1, 2, 3, 4}, 0, 4));
    }

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

    public void testPruning2() {
        TrieIntSeqCounter counter = new TrieIntSeqCounter(4);
        counter.incrementSubsequences(new int[] { 1, 2, 3, 4 }, 0, 4);
        counter.incrementSubsequences(new int[] { 1, 2, 3, 4 }, 0, 4);
        counter.incrementSubsequences(new int[] { 1, 2, 3 }, 0, 3);
        counter.incrementSubsequences(new int[] { 1, 2 }, 0, 2);
        counter.incrementSubsequences(new int[] { 1 }, 0, 1);

        counter.incrementSubsequences(new int[] { 2, 3 }, 0, 2);
        counter.incrementSubsequences(new int[] { 2, 4 }, 0, 2);
        counter.incrementSubsequences(new int[] { 2, 4 }, 0, 2);
        counter.incrementSubsequences(new int[] { 2, 5 }, 0, 2);
        counter.incrementSubsequences(new int[] { 2, 5 }, 0, 2);
        counter.incrementSubsequences(new int[] { 2, 5 }, 0, 2);

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

        counter.incrementSubsequences(new int[] { 3, 5 }, 0, 2);
        counter.incrementSubsequences(new int[] { 3, 6 }, 0, 2);
        counter.incrementSubsequences(new int[] { 3, 6 }, 0, 2);

        counter.incrementSubsequences(new int[] { 4, 5 }, 0, 2);
        counter.incrementSubsequences(new int[] { 4, 5 }, 0, 2);
        counter.incrementSubsequences(new int[] { 4, 5 }, 0, 2);

        counter.incrementSubsequences(new int[] { 7 }, 0, 1);

        assertEquals(1,counter.count(new int[] { 7 }, 0, 1));
        assertEquals(2,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(1);

        assertEquals(1,counter.count(new int[] { 7 }, 0, 1));
        assertEquals(2,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(2);

        assertEquals(0,counter.count(new int[] { 7 }, 0, 1));
        assertEquals(2,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(3);