示例#1
0
        } // SuSdSdSu

        public static Dictionary <DeltaKey, int> CreateScanCornerDeltaTable()
        {
            Dictionary <DeltaKey, int> deltaTable = CreateInitialTable(-5);

            // Want to match lefts and rights, ups and down
            DeltaKey key = new DeltaKey("Su", "Su");

            deltaTable[key] = 1;

            key             = new DeltaKey("Sd", "Sd");
            deltaTable[key] = 1;

            key             = new DeltaKey("Sl", "Sl");
            deltaTable[key] = 1;

            key             = new DeltaKey("Sr", "Sr");
            deltaTable[key] = 1;

            foreach (Token y in tokens)
            {
                // Penalise any kind of insertions
                key             = new DeltaKey("", Wordbook.TokenToString(y));
                deltaTable[key] = -10;

                // and deletions
                key             = new DeltaKey(Wordbook.TokenToString(y), "");
                deltaTable[key] = -10;
            }

            return(deltaTable);
        } // SrSlSuSd, and all variants
示例#2
0
        public static Dictionary <DeltaKey, int> CreateCompareVerticalDeltaTable() // SuSdSuSd
        {
            Dictionary <DeltaKey, int> deltaTable = CreateInitialTable(-2);

            // Want to match lefts and rights mostly, perfect match == 8
            DeltaKey key = new DeltaKey("Su", "Su");

            deltaTable[key] = 2;

            key             = new DeltaKey("Sd", "Sd");
            deltaTable[key] = 2;

            foreach (Token y in tokens)
            {
                // Penalise any kind of insertions
                key             = new DeltaKey("", Wordbook.TokenToString(y));
                deltaTable[key] = -2;

                // Penalise any kind of deletion
                key             = new DeltaKey(Wordbook.TokenToString(y), "");
                deltaTable[key] = -2;
            }

            // Insertions of short lefts and rights are okay
            key             = new DeltaKey("", "Sl");
            deltaTable[key] = -1;

            key             = new DeltaKey("", "Sr");
            deltaTable[key] = -1;

            // Therefore, for one insertion of an up or down, the threshold will be 7 or higher.
            // Perfect match is 8, minus 1 for 1 insertion of an Su or Sd.

            return(deltaTable);
        }
示例#3
0
        } // SrSlSlSr

        public static Dictionary <DeltaKey, int> CreateScanVerticalDeltaTable()
        {
            Dictionary <DeltaKey, int> deltaTable = CreateInitialTable(-1);

            // Want to match lefts and rights mostly
            DeltaKey key = new DeltaKey("Su", "Su");

            deltaTable[key] = 1;

            key             = new DeltaKey("Sd", "Sd");
            deltaTable[key] = 1;

            foreach (Token y in tokens)
            {
                // Penalise any kind of insertions
                key             = new DeltaKey("", Wordbook.TokenToString(y));
                deltaTable[key] = -10;

                // and deletions
                key             = new DeltaKey(Wordbook.TokenToString(y), "");
                deltaTable[key] = -10;
            }

            return(deltaTable);
        } // SuSdSdSu
示例#4
0
        } // SrSrSrSrLl

        public static Dictionary <DeltaKey, int> CreateLongLineDeltaTable()
        {
            Dictionary <DeltaKey, int> deltaTable = CreateInitialTable(-1);

            DeltaKey key = new DeltaKey("Sr", "Sr");

            deltaTable[key] = 5;

            key             = new DeltaKey("Sr", "Mr");
            deltaTable[key] = 2;

            key             = new DeltaKey("Sr", "Sl");
            deltaTable[key] = 0;

            key             = new DeltaKey("Ll", "Ll");
            deltaTable[key] = 10;

            key             = new DeltaKey("Ll", "");
            deltaTable[key] = -10;

            foreach (Token y in tokens)
            {
                key             = new DeltaKey("", Wordbook.TokenToString(y));
                deltaTable[key] = -10;
            }

            return(deltaTable);
        } // SrSrSrSrLl
示例#5
0
        // Returns a delta table all initialised to -1.
        public static Dictionary <DeltaKey, int> CreateInitialTable(int initialValue)
        {
            Dictionary <DeltaKey, int> deltaTable = new Dictionary <DeltaKey, int>();

            // Add all possibilities
            foreach (Token x in tokens)
            {
                foreach (Token y in tokens)
                {
                    DeltaKey key = new DeltaKey(Wordbook.TokenToString(x), Wordbook.TokenToString(y));
                    deltaTable[key] = initialValue;
                }
            }

            // Add epsilons for deletion and insertions
            foreach (Token y in tokens)
            {
                DeltaKey key = new DeltaKey("", Wordbook.TokenToString(y));
                deltaTable[key] = -1;
            }

            foreach (Token x in tokens)
            {
                DeltaKey key = new DeltaKey(Wordbook.TokenToString(x), "");
                deltaTable[key] = -1;
            }

            return(deltaTable);
        }
示例#6
0
        // Local Alignment for ATOMS via Smith–Waterman algorithm

        // Returns a list tuples that show the position (startIndex, length) of every match of x in the longer string y, (that is above the threshold).
        static public List <Tuple <int, int> > GetLocationsOfLocalMatches(List <Token> x, List <Token> y, Dictionary <DeltaKey, int> delta, int threshold)
        {
            // Create table
            //#############
            int numColumns = x.Count + 1;
            int numRows    = y.Count + 1;

            int[,] table = new int[numColumns, numRows];

            // Zero out first row and column.
            for (int column = 0; column < numColumns; column++)
            {
                table[column, 0] = 0;
            }

            for (int row = 0; row < numRows; row++)
            {
                table[0, row] = 0;
            }

            // Starting at (1, 1) going left to right, to bottom fill in the spaces in the table.
            for (int row = 1; row < numRows; row++)
            {
                for (int column = 1; column < numColumns; column++)
                {
                    int left    = table[column - 1, row] + delta[new DeltaKey(Wordbook.TokenToString(x[column - 1]), "")];                                     // deletion
                    int top     = table[column, row - 1] + delta[new DeltaKey("", Wordbook.TokenToString(y[row - 1]))];;                                       // insertion
                    int topLeft = table[column - 1, row - 1] + delta[new DeltaKey(Wordbook.TokenToString(x[column - 1]), Wordbook.TokenToString(y[row - 1]))]; // match or replace

                    table[column, row] = Max(left, top, topLeft, 0);
                }
            }

            //PrintTable(table, numColumns, numRows);
            Tuple <int, int> maxLocation = FindMaxInTable(table, numColumns, numRows);

            // Display all substring matches that are above the threshold
            var startingLocations = FindMatchLocationsAboveThreshold(table, numColumns, numRows, threshold);
            List <Tuple <int, int> > subStringLocations = new List <Tuple <int, int> >();

            foreach (var location in startingLocations)
            {
                Tuple <int, int> subStringPosition = FindMatchingSubstring(table, location, x, y, delta);
                int subStringLength = subStringPosition.Item2 - subStringPosition.Item1;

                Tuple <int, int> subStringLocation = new Tuple <int, int>(subStringPosition.Item1, subStringLength);
                subStringLocations.Add(subStringLocation);
            }

            return(subStringLocations);
        }
示例#7
0
        } // SuSuSuSu

        public static Dictionary <DeltaKey, int> CreateStringRightDeltaTable()
        {
            Dictionary <DeltaKey, int> deltaTable = CreateInitialTable(-1);

            // Want to match only rights. Perfect match would score 8.
            DeltaKey key = new DeltaKey("Sr", "Sr");

            deltaTable[key] = 2;

            // Replacing Sr with any number of Mr is okay too.
            key             = new DeltaKey("Sr", "Mr");
            deltaTable[key] = 2;

            // Replacing a short right in the string with a short left is okay.
            key             = new DeltaKey("Sr", "Sl");
            deltaTable[key] = 1;

            // Short ups and downs are okay
            key             = new DeltaKey("Sr", "Su");
            deltaTable[key] = 1;

            key             = new DeltaKey("Sr", "Sd");
            deltaTable[key] = 1;

            // If there is one replacement of an Sr either with Sl Su Sd, and the rest match with Sr, then the matching score would be 7. 6 for two replacements, etc.
            // We want to allow only one replacement somewhere in the string. So we will want a threshold of 7 when finding matches.

            // todo: need a way to specify the first and last tokens in the atom cannot change
            //          perhaps something like Sr - - Sr, where Sr matching with Sr score is high and whatever the dummy - char is has an equally high score for being replace with Sr, whilst slightly lower score for being replaced with Su, Sl, Sd.

            foreach (Token y in tokens)
            {
                // Penalise any kind of insertions
                key             = new DeltaKey("", Wordbook.TokenToString(y));
                deltaTable[key] = -10;

                // Penalise any kind of deletion
                key             = new DeltaKey(Wordbook.TokenToString(y), "");
                deltaTable[key] = -10;
            }

            return(deltaTable);
        } // SrSrSrSr, see notes for matching information
示例#8
0
        static private Tuple <int, int> FindMatchingSubstring(int[,] table, Tuple <int, int> maxLocation, List <Token> x, List <Token> y, Dictionary <DeltaKey, int> delta)
        {
            int column = maxLocation.Item1;
            int row    = maxLocation.Item2;

            bool searching = true;

            while (searching)
            {
                // Keep searching until we git a 0 in the table.
                if (table[column, row] == 0)
                {
                    searching = false;
                    break;
                }

                // Otherwise, keep moving up the table following the path we took to get here.
                int topLeft = table[column - 1, row - 1] + delta[new DeltaKey(Wordbook.TokenToString(x[column - 1]), Wordbook.TokenToString(y[row - 1]))]; // match or replace
                if (table[column, row] == topLeft)
                {
                    column--;
                    row--;
                    continue;
                }

                int left = table[column - 1, row] + delta[new DeltaKey(Wordbook.TokenToString(x[column - 1]), "")]; // deletion
                int top  = table[column, row - 1] + delta[new DeltaKey("", Wordbook.TokenToString(y[row - 1]))];    // insertion
                if (table[column, row] == left)
                {
                    column--;
                    continue;
                }

                if (table[column, row] == top)
                {
                    row--;
                    continue;
                }
            }

            return(Tuple.Create(row, maxLocation.Item2));
        }
示例#9
0
        public AtomBook(Wordbook wordbook)
        {
            this.wordbook            = wordbook;
            this.numberOfStrings     = FindAtoms(StringTypes);
            this.numberOfLines       = FindAtoms(LineTypes);
            this.numberOfComparisons = FindAtoms(ComparisonTypes);
            this.numberOfScans       = FindAtoms(ScanningTypes);

            // Strings
            numberOfStringUp    = FindAtoms(new AtomType[] { AtomType.StringUp });
            numberOfStringRight = FindAtoms(new AtomType[] { AtomType.StringRight });;
            numberOfStringDown  = FindAtoms(new AtomType[] { AtomType.StringDown });;
            numberOfStringLeft  = FindAtoms(new AtomType[] { AtomType.StringLeft });;

            numberOfMediumLines = FindAtoms(new AtomType[] { AtomType.MediumLine });;
            numberOfLongLines   = FindAtoms(new AtomType[] { AtomType.LongLine });;

            numberOfCompareHorizontal    = FindAtoms(new AtomType[] { AtomType.CompareHorizontal });;
            numberOfCompareVertical      = FindAtoms(new AtomType[] { AtomType.CompareVertical });;
            numberOfCompareHorizontalAlt = FindAtoms(new AtomType[] { AtomType.CompareHorizontalAlt });;
            numberOfCompareVerticalAlt   = FindAtoms(new AtomType[] { AtomType.CompareVerticalAlt });;

            numberOfScanRightUp      = FindAtoms(new AtomType[] { AtomType.ScanRightUp });;
            numberOfScanUpLeft       = FindAtoms(new AtomType[] { AtomType.ScanUpLeft });;
            numberOfScanLeftDown     = FindAtoms(new AtomType[] { AtomType.ScanLeftDown });;
            numberOfScanDownRight    = FindAtoms(new AtomType[] { AtomType.ScanDownRight });;
            numberOfScanRightUpAlt   = FindAtoms(new AtomType[] { AtomType.ScanRightUpAlt });;
            numberOfScanUpLeftAlt    = FindAtoms(new AtomType[] { AtomType.ScanUpLeftAlt });;
            numberOfScanLeftDownAlt  = FindAtoms(new AtomType[] { AtomType.ScanLeftDownAlt });;
            numberOfScanDownRightAlt = FindAtoms(new AtomType[] { AtomType.ScanDownRightAlt });;

            numberOfScanHorizontal    = FindAtoms(new AtomType[] { AtomType.ScanHorizontal });;
            numberOfScanVertical      = FindAtoms(new AtomType[] { AtomType.ScanVertical });;
            numberOfScanHorizontalAlt = FindAtoms(new AtomType[] { AtomType.ScanHorizontalAlt });;
            numberOfScanVerticalAlt   = FindAtoms(new AtomType[] { AtomType.ScanVerticalAlt });;
        }
示例#10
0
        } // SdSdSdSd

        public static Dictionary <DeltaKey, int> CreateStringLeftDeltaTable()
        {
            Dictionary <DeltaKey, int> deltaTable = CreateInitialTable(-1);

            // Want to match only lefts. Perfect match would score 8.
            DeltaKey key = new DeltaKey("Sl", "Sl");

            deltaTable[key] = 2;

            // Replacing Sl with any number of Ml is okay too.
            key             = new DeltaKey("Sl", "Ml");
            deltaTable[key] = 2;

            // Short left rights and ups are okay.
            key             = new DeltaKey("Sl", "Sd");
            deltaTable[key] = 1;

            key             = new DeltaKey("Sl", "Sr");
            deltaTable[key] = 1;

            key             = new DeltaKey("Sl", "Su");
            deltaTable[key] = 1;

            foreach (Token y in tokens)
            {
                // Penalise any kind of insertions
                key             = new DeltaKey("", Wordbook.TokenToString(y));
                deltaTable[key] = -10;

                // Penalise any kind of deletion
                key             = new DeltaKey(Wordbook.TokenToString(y), "");
                deltaTable[key] = -10;
            }

            return(deltaTable);
        } // SlSlSlSl