示例#1
0
        /**
         * Backtraces through the penalty table.  This starts at the "lower right" corner (i.e., the last word of the longer
         * of the reference vs. hypothesis strings) and works its way backwards.
         *
         * @param backtraceTable created from call to createBacktraceTable
         * @return a linked list of Integers representing the backtrace
         */
        LinkedList <Integer> Backtrace(int[,] backtraceTable)
        {
            var list = new LinkedList <Integer>();
            var i    = _referenceItems.Count;
            var j    = _hypothesisItems.Count;

            while ((i >= 0) && (j >= 0))
            {
                Java.Add(list, backtraceTable[i, j]);
                switch (backtraceTable[i, j])
                {
                case Ok:
                    i--;
                    j--;
                    break;

                case Substitution:
                    i--;
                    j--;
                    _substitutions++;
                    break;

                case Insertion:
                    j--;
                    _insertions++;
                    break;

                case Deletion:
                    i--;
                    _deletions++;
                    break;
                }
            }
            return(list);
        }
 /// <summary>
 ///  Puts the probability into the map.
 /// </summary>
 /// <param name="wordSequence">The tag for the prob.</param>
 /// <param name="logProb">The probability in log math base.</param>
 /// <param name="logBackoff">The backoff probability in log math base.</param>
 private void Put(WordSequence wordSequence, float logProb, float logBackoff)
 {
     // System.out.println("Putting " + wordSequence + " p " + logProb
     // + " b " + logBackoff);
     Java.Put(_map, wordSequence, new Probability(logProb, logBackoff));
     Java.Add(_tokens, wordSequence);
 }
 public void add(Node n)
 {
     if (n.getBeginTime() < startTime)
     {
         startTime = n.getBeginTime();
     }
     if (n.getEndTime() > endTime)
     {
         endTime = n.getEndTime();
     }
     Java.Add(elements, n);
 }
        /**
         * Form a subcluster by extracting all nodes corresponding to a given word.
         *
         * @param cluster the parent cluster
         * @param word    the word to cluster by
         * @return the subcluster.
         */
        protected LinkedList <Node> makeWordSubCluster(LinkedList <Node> cluster, String word)
        {
            var sub = new LinkedList <Node>();

            foreach (Node n in cluster)
            {
                if (n.getWord().getSpelling().Equals(word))
                {
                    Java.Add(sub, n);
                }
            }
            return(sub);
        }
示例#5
0
        /**
         * Based on the backtrace information, words are aligned as appropriate with insertions and deletions causing
         * asterisks to be placed in the word lists.  This generates the alignedReferenceWords and alignedHypothesisWords
         * lists.
         *
         * @param backtrace the backtrace list created in backtrace
         */
        void AlignWords(LinkedList <Integer> backtrace, IStringRenderer renderer)
        {
            var    referenceWordsIterator  = _referenceItems.GetEnumerator();
            var    hypothesisWordsIterator = _hypothesisItems.GetEnumerator();
            string referenceWord;
            string hypothesisWord;
            Object a = null;
            Object b = null;

            _alignedReferenceWords  = new LinkedList <string>();
            _alignedHypothesisWords = new LinkedList <string>();


            for (var m = backtrace.Count - 2; m >= 0; m--)
            {
                int backtraceEntry = backtrace.ElementAt(m);

                if (backtraceEntry != Insertion)
                {
                    referenceWordsIterator.MoveNext();
                    a             = referenceWordsIterator.Current;
                    referenceWord = renderer.GetRef(a, b);
                }
                else
                {
                    referenceWord = null;
                }
                if (backtraceEntry != Deletion)
                {
                    hypothesisWordsIterator.MoveNext();
                    b = hypothesisWordsIterator.Current;
                    hypothesisWord = renderer.GetHyp(a, b);
                }
                else
                {
                    hypothesisWord = null;
                }
                switch (backtraceEntry)
                {
                case Substitution:
                {
                    referenceWord  = referenceWord.ToUpper();
                    hypothesisWord = hypothesisWord.ToUpper();
                    break;
                }

                case Insertion:
                {
                    hypothesisWord = hypothesisWord.ToUpper();
                    break;
                }

                case Deletion:
                {
                    referenceWord = referenceWord.ToUpper();
                    break;
                }

                case Ok:
                    break;
                }

                // Expand the missing words out to be all *'s.
                //
                if (referenceWord == null)
                {
                    referenceWord = Stars.Substring(0, hypothesisWord.Length);
                }
                if (hypothesisWord == null)
                {
                    hypothesisWord = Stars.Substring(0, referenceWord.Length);
                }

                // Fill the words up with spaces so they are the same
                // Length.
                //
                if (referenceWord.Length > hypothesisWord.Length)
                {
                    hypothesisWord = hypothesisWord + (Spaces.Substring(0, referenceWord.Length - hypothesisWord.Length));
                }
                else if (referenceWord.Length < hypothesisWord.Length)
                {
                    referenceWord = referenceWord + (Spaces.Substring(0, hypothesisWord.Length - referenceWord.Length));
                }

                Java.Add(_alignedReferenceWords, referenceWord);
                Java.Add(_alignedHypothesisWords, hypothesisWord);
            }
        }
 public Cluster(Node n)
 {
     startTime = n.getBeginTime();
     endTime   = n.getEndTime();
     Java.Add(elements, n);
 }
示例#7
0
 private static void AddInterfaces(Type[] interfaces, Java.Util.ISet<Type> ret, Java.Util.IQueue<Type> toVisit)
 {
     foreach (var i in interfaces)
     {
         if (i == typeof(IGenericTypeDefinition))
             continue; // hide this marker interface.
         
         if (!ret.Contains(i))
         {
             ret.Add(i);
             toVisit.Add(i);
         }
     }
 }