implab/ImplabNet Files · Implab/Automaton/IndexedAlphabetBase.cs

Added 'Fail' method to RunnableComponent which allows component to move from...

Added 'Fail' method to RunnableComponent which allows component to move from Running to Failed state. Added PollingComponent a timer based runnable component More tests Added FailPromise a thin class to wrap exceptions Fixed error handling in SuccessPromise classes.

cin - - Load All Authors

File last commit:

r180:c32688129f14 ref20160224


                r203:4d9830a9bbb8

Download file

             IndexedAlphabetBase.cs
        
                    50 lines
            
             | 1.8 KiB
            
                | text/x-csharp
            
             |
                CSharpLexer
            
             / Implab / Automaton / IndexedAlphabetBase.cs
          
                    History
                
                 |
                  Annotation
                 | Raw
                 |Copy content
                 |Copy permalink

      using Implab;

      using System;

      using System.Collections.Generic;

      using System.Diagnostics;

      using System.Linq;

      namespace Implab.Automaton {

          /// <summary>

          /// Indexed alphabet is the finite set of symbols where each symbol has a zero-based unique index.

          /// </summary>

          /// <remarks>

          /// Indexed alphabets are usefull in bulting efficient translations from source alphabet

          /// to the input alphabet of the automaton. It's assumed that the index to the symbol match

          /// is well known and documented.

          /// </remarks>

          public abstract class IndexedAlphabetBase<T> : MapAlphabet<T> {

              protected IndexedAlphabetBase() :base(true, null) {

              }

              public abstract int GetSymbolIndex(T symbol);

              /// <summary>

              /// Gets the translation map from the index of the symbol to it's class this is usefull for the optimized input symbols transtaion.

              /// </summary>

              /// <remarks>

              /// The map is continous and start from the symbol with zero code. The last symbol

              /// in the map is the last classified symbol in the alphabet, i.e. the map can be

              /// shorter then the whole alphabet.

              /// </remarks>

              /// <returns>The translation map.</returns>

              public int[] GetTranslationMap() {

                  var map = new Dictionary<int, int>();

                  int max = 0;

                  foreach (var p in Mappings) {

                      var index = GetSymbolIndex(p.Key);

                      max = Math.Max(max, index);

                      map[index] = p.Value;

                  }

                  var result = new int[max + 1];

                  for (int i = 0; i < result.Length; i++)

                      map.TryGetValue(i, out result[i]);

                  return result;

              }

          }

      }

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages

				using Implab;
				using System;
				using System.Collections.Generic;
				using System.Diagnostics;
				using System.Linq;

				namespace Implab.Automaton {
				/// <summary>
				/// Indexed alphabet is the finite set of symbols where each symbol has a zero-based unique index.
				/// </summary>
				/// <remarks>
				/// Indexed alphabets are usefull in bulting efficient translations from source alphabet
				/// to the input alphabet of the automaton. It's assumed that the index to the symbol match
				/// is well known and documented.
				/// </remarks>
				public abstract class IndexedAlphabetBase<T> : MapAlphabet<T> {

				protected IndexedAlphabetBase() :base(true, null) {
				}

				public abstract int GetSymbolIndex(T symbol);

				/// <summary>
				/// Gets the translation map from the index of the symbol to it's class this is usefull for the optimized input symbols transtaion.
				/// </summary>
				/// <remarks>
				/// The map is continous and start from the symbol with zero code. The last symbol
				/// in the map is the last classified symbol in the alphabet, i.e. the map can be
				/// shorter then the whole alphabet.
				/// </remarks>
				/// <returns>The translation map.</returns>
				public int[] GetTranslationMap() {
				var map = new Dictionary<int, int>();

				int max = 0;
				foreach (var p in Mappings) {
				var index = GetSymbolIndex(p.Key);
				max = Math.Max(max, index);
				map[index] = p.Value;
				}

				var result = new int[max + 1];

				for (int i = 0; i < result.Length; i++)
				map.TryGetValue(i, out result[i]);

				return result;
				}
				}
				}