private bool FillStates(string input) { Regex regex = new Regex(@"\s*\w+\s*:\s*(\w|ε)\s*->\s*\w+\s*"); // Ввод по образцу [current]: [symbol] -> [next] MatchCollection matches = regex.Matches(input); if (matches.Count == 1) { string[] groups = input.Split(new char[] { ' ', ':', '-', '>' }, StringSplitOptions.RemoveEmptyEntries); for (int i = 0; i < groups.Length; i = i + 3) { if (Alphabet == "" || Alphabet.Contains(groups[i + 1][0])) { StateTable.Add(new TransRule(groups[i], groups[i + 1][0], groups[i + 2])); } else { Console.WriteLine($"Символ {groups[i + 1][0]} не включен во входной алфавит"); return(false); } } return(true); } else { Console.WriteLine("Правило не соответствует установленному шаблону"); return(false); } }
public string VigenerFromString(Mode mode, string Text) { if (!CheckKey()) { throw new Exception("Incorrect key value"); } int charIndex; // index in alphabet int msgIndex = 0; // index in message letters int index = 0; // index in all message chars int keyIndex; // index in key StringBuilder stringBuilder = new StringBuilder(Text); foreach (var character in Text) { if (!(Alphabet.Contains(Char.ToUpper(character)) || Alphabet.Contains(Char.ToLower(character)))) { index++; continue; } //shift of alphabet for encrypting and index of char in non-shifted alphabet for decrypting charIndex = Alphabet.IndexOf(Char.ToLower(character)); // index of column in shifted alphabet keyIndex = Alphabet.IndexOf(Key[msgIndex % Key.Length]); if (mode == Mode.ENCRYPT) { charIndex = (keyIndex + charIndex) % Alphabet.Length; } else { charIndex = (charIndex - keyIndex + Alphabet.Length) % Alphabet.Length; } stringBuilder.Replace(character, Char.IsUpper(character) ? Char.ToUpper(Alphabet[charIndex]) : Char.ToLower(Alphabet[charIndex]), index, 1); msgIndex++; index++; } return(stringBuilder.ToString()); }
private void Validate(A letter) { if (!Alphabet.Contains(letter)) { throw new ArgumentException(string.Format("The letter {0} is not recognized", letter)); } }
public bool AddCommand(int column, int row, Command command) { if (command is null) { TableCommand.Commands[row, column] = null; return(true); } if (!Alphabet.Contains(command.ChangeSim)) { return(false); } if (column <= 0 || row <= 0 || column > TableCommand.Commands.GetLength(1) || row > TableCommand.Commands.GetLength(0)) { return(false); } if (command.ChangeSim is '\0') { return(false); } if (command.State >= CountState || command.State < 0) { return(false); } TableCommand.Commands[row, column] = command; return(true); }
private void rebuildSubstitutionMatrix() { string value = SubstitutionPass.ToUpperInvariant(); StringBuilder sb = new StringBuilder(); HashSet <char> seen = new HashSet <char>(); foreach (char c in value) { // add character to matrix if unique and part of alphabet if (!seen.Contains(c) && Alphabet.Contains(c)) { sb.Append(c); seen.Add(c); } } // fill matrix with remaining characters foreach (char c in Alphabet) { if (!seen.Contains(c)) { sb.Append(c); } } SubstitutionMatrix = sb.ToString(); Debug.Assert(sb.Length == Alphabet.Length, "Matrix length != Alphabet length"); }
public double IndexOfCoincidence(List <char> Cipher) { Dictionary <char, double> counts = new Dictionary <char, double>(); foreach (char s in Cipher) { if (Alphabet.Contains(s)) { if (counts.ContainsKey(s)) { counts[s]++; } else { counts.Add(s, 1); } } } double sum = 0.0; foreach (char s in counts.Keys) { sum += counts[s] * (counts[s] - 1); } return(sum / (double)(Cipher.Count * (Cipher.Count - 1))); }
/// <summary> /// Run the machine using the given input. /// </summary> /// <param name="x">The input string.</param> /// <returns>True if the machine accepts the input string.</returns> public bool Run(char[] x) { var i = 0; var current = InitialState; while (i < x.Length) { if (!Alphabet.Contains(x[i])) { return(false); } if (x[i] == Alphabet.EmptyString) { i++; continue; } var q = Transitions[current, x[i]]; if (q == null) { return(false); } current = q.Q; i++; } return(current.Accepting); }
/// <summary> /// Manually adds a letter to the set of recognizable letters. /// </summary> /// <param name="letter">Letter to recognize.</param> public void AddLetter(A letter) { if (Alphabet.Contains(letter)) { return; } Alphabet.Add(letter); }
protected void CheckWordInAlphabet(string w) { for (int i = 0; i < w.Length; i++) { if (!Alphabet.Contains(w[i])) { throw new AlphabetException(w[i], this); } } }
private bool CheckKey() { foreach (var c in Key) { if (!Alphabet.Contains(c)) { return(false); } } return(true); }
public void SetValueToTapePoint(int keyIndex, char value) { if (keyIndex < Tape.Min || keyIndex > Tape.Max || value is '\0') { return; } if (Alphabet.Contains(value)) { Tape.TapeDic[keyIndex].SetValue(value); } }
public static string ReverseLetter(string str) { const string Alphabet = "QqWwEeRrTtYyUuIiOoPpAaSsDdFfGgHhJjKkLlZzXxCcVvBbNnMm"; var sortedStr = str.Where(c => Alphabet.Contains(c)); string result = ""; foreach (char c in sortedStr.Reverse()) { result += c; } return(result); }
public void RemovePossibilityTest() { /*** ARRANGE ***/ Alphabet alphabet = CreateDefaultAlphabet(); Cell target = new Cell(alphabet); int value = 3; // arbitrary /*** ACT ***/ target.RemovePossibility(value); /*** ASSERT ***/ Assert.IsFalse(target.CanBe(value)); // value is no longer a possible value Assert.IsTrue(alphabet.Contains(value)); // alphabet remains unchanged }
public (State, string) Run(string str) { string tape = $"{EmptyChar}{str}{EmptyChar}"; State currentState = InputState; currentState.IsActive = true; int idx = 1; while (!currentState.IsOutput) { char curChar = tape[idx]; if (!Alphabet.Contains(curChar)) { throw new InvalidOperationException("Alphabet doesn't contain this character"); } var transition = currentState.GetTransition(curChar); if (transition == null) { Console.WriteLine($"There is no transition for char '{curChar}' in state #{currentState.Id}"); break; } // zapis znak tape = $"{tape.Substring(0, idx)}{transition.LetterToWrite}{tape.Substring(idx + 1)}"; currentState.IsActive = false; currentState = transition.EndState; currentState.IsActive = true; idx = transition.DirectionToGo == Direction.Left ? --idx : transition.DirectionToGo == Direction.Right ? ++idx : idx; if (idx < 0) // extend tape { idx = 0; tape = EmptyChar + tape; } else if (idx >= tape.Length) { idx = tape.Length; tape += EmptyChar; } } return(currentState, tape); }
private void RebuildTranspositionCleanPassword() { string value = TranspositionPass.ToUpperInvariant(); //if no transposition password was given, we use a default password of A, meaning, we have no transposition if (string.IsNullOrEmpty(value) || string.IsNullOrWhiteSpace(value)) { value = "A"; } // remove characters not part of alphabet List <char> cleanPassword = new List <char>(); foreach (char c in value) { if (Alphabet.Contains(c)) { cleanPassword.Add(c); } } // copy and sort characters char[] keyChars = cleanPassword.ToArray(); Array.Sort(keyChars); // determine column order int[] newColumnOrder = new int[keyChars.Length]; for (int i = 0; i < keyChars.Length; i++) { int column = Array.IndexOf(keyChars, cleanPassword[i]); newColumnOrder[i] = column; keyChars[column] = (char)0; // make sure the same character won't be found again } KeyColumnOrder = newColumnOrder; // build nice looking string for output (note: column numbers start with 0 in array, but 1 in string) StringBuilder keyWord = new StringBuilder(); if (newColumnOrder.Length >= 1) { keyWord.Append((newColumnOrder[0] + 1)); for (int i = 1; i < newColumnOrder.Length; i++) { keyWord.Append("-" + (newColumnOrder[i] + 1)); } } CleanTranspositionPass = keyWord.ToString(); }
public Result SetWordDefault(string wordDefault = "101") { //проверка на существование всех символов for (int i = 0; i < wordDefault.Length; i++) { if (!Alphabet.Contains(wordDefault[i])) { wordDefault = wordDefault.Remove(i, 1); i--; } } WordDefault = wordDefault; return(Tape.SetWordDefault(wordDefault)); }
/// <summary> /// The check recovery available. /// </summary> /// <param name="chain"> /// Source sequence. /// </param> /// <param name="length"> /// Length of L-gram. /// </param> /// <returns> /// true if chain is recoverable form L-grams. /// </returns> private bool CheckRecoveryAvailable(AbstractChain chain, int length) { var iterator = new IteratorStart(chain, length, 1); var alphabet = new Alphabet(); while (iterator.Next()) { if (alphabet.Contains(iterator.Current())) { return false; } alphabet.Add(iterator.Current()); } return true; }
/// <summary> /// Remove non-letters from this string, swap them for '_' /// </summary> public static string LettersOnly(this string _string) { if (string.IsNullOrEmpty(_string)) { return(string.Empty); } StringBuilder builder = new StringBuilder(_string); for (int i = 0; i < _string.Length; i++) { if (!Alphabet.Contains(_string[i].ToString().ToLower())) { builder.Remove(i, 1); builder.Insert(i, '_'); } } return(builder.ToString()); }
public void DeleteValuesFromAlph(HashSet <char> removeAlph) { //проверка на существование всех символов в алфавите => новый алфавит для удаления создать removeAlph = removeAlph.Where(i => Alphabet.Contains(i)).ToHashSet(); removeAlph.Remove(' '); //удалить символы из текущей строки WordDefault = new string(WordDefault.Where(i => !removeAlph.Contains(i)).ToArray()); //удалить удалить символы из алфавита foreach (var item in removeAlph) { Alphabet.Remove(item); } Tape.SetWordDefault(WordDefault); GetNewTableMinus(CountState, Alphabet); }
protected override void CheckConstraints() { base.CheckConstraints(); foreach (var t in Transforms) { if (t.Key.q >= StatesCount | t.Value.qNext >= StatesCount) //transform states within states throw new StateException(t.Key.q, this); else if (t.Key.ci.HasValue && !Alphabet.Contains(t.Key.ci.Value)) //input alphabet of transform key throw new AlphabetException(t.Key.ci.Value, this); else if (t.Key.cw.HasValue && !WorkAlphabet.Contains(t.Key.cw.Value)) //work alphabet of transform key throw new AlphabetException(t.Key.cw.Value, this); //BUG: contains string else if (t.Value.cw2 != null && !WorkAlphabet.Contains(t.Value.cw2[0])) //work alphabet of transform value throw new AlphabetException(t.Value.cw2[0], this); } //accepted States in States for (int i = 0; i < AcceptedStates.Length; i++) if (AcceptedStates[i] >= StatesCount) throw new StateException(AcceptedStates[i], this); }
protected override void CheckConstraints() { base.CheckConstraints(); foreach (var t in Transforms) { for (int i = 0; i < t.Value.Length; i++) { if (t.Key.q >= StatesCount) throw new StateException(t.Key.q, this); else if (t.Value[i].qNext >= StatesCount) throw new StateException(t.Value[i].qNext, this); else if (t.Key.ci.HasValue && !Alphabet.Contains(t.Key.ci.Value)) throw new AlphabetException(t.Key.ci.Value, this); else if (t.Key.cw.HasValue && !WorkAlphabet.Contains(t.Key.cw.Value)) throw new AlphabetException(t.Key.cw.Value, this); else if (t.Value[i].cw2 != null && t.Value[i].cw2 != "" && !WorkAlphabet.Contains(t.Value[i].cw2[0])) throw new AlphabetException(t.Value[i].cw2[0], this); } } for (int i = 0; i < AcceptedStates.Length; i++) if (AcceptedStates[i] >= StatesCount) throw new StateException(AcceptedStates[i], this); }
protected override void CheckConstraints() { base.CheckConstraints(); foreach (var t in Transforms) { for (int i = 0; i < t.Value.Length; i++) { if (t.Key.q >= StatesCount) // q to high { throw new StateException(t.Key.q, this); } if (t.Value[i] >= StatesCount) // qNext to high { throw new StateException(t.Value[i], this); } if (t.Key.c.HasValue && !Alphabet.Contains(t.Key.c.Value)) // char not in alphabet { throw new AlphabetException(t.Key.c.Value, this); } } } }
/// <summary> /// Adiciona transição entre 2 estados. /// </summary> /// <param name="estadoOrigem">O estado origem do autômato.</param> /// <param name="consumirFita">O símbolo a ser avaliado.</param> /// <param name="estadoDestino">O estado destino.</param> public void AdicionarTransicao(string estadoOrigem, string estadoDestino, Symbol consumirPilha, Symbol consumirFita, params Symbol[] gravarPilha) { if (consumirPilha == null) { consumirPilha = Symbol.EmptySymbol; } SymbolList vars = new SymbolList(); if (gravarPilha == null || gravarPilha.Length == 0) { vars.Add(Symbol.EmptySymbol); } else { vars.AddRange(gravarPilha); } foreach (var symbol in vars) { if (StackAlphabet.IndexOf(symbol) < 0 && symbol != Symbol.EmptySymbol && symbol != Symbol.StackFinal && symbol != Symbol.TapeFinal) { StackAlphabet.Add(symbol); } } // Adiciona transições.. if (States.ContainsKey(estadoOrigem) && States.ContainsKey(estadoDestino)) { if (!Alphabet.Contains(consumirFita)) { Alphabet.Add(consumirFita); } States[estadoOrigem].AdicionarTransicao(States[estadoDestino], consumirFita, consumirPilha, vars); } }
private static Key ReadKey(string path, Alphabet alphabet) { if (!File.Exists(path)) { throw new FileNotFoundException(); } char[] text = null; using (BinaryReader reader = new BinaryReader(File.Open(path, FileMode.Open), Encoding.GetEncoding(1251))) { text = new char[reader.BaseStream.Length]; for (long i = 0, l = reader.BaseStream.Length; i < l; ++i) { text[i] = reader.ReadChar(); if (!alphabet.Contains(text[i])) { throw new ArgumentException("Symbol " + text[i] + " is not in the given alphabet!"); } } } return(new Key(text, alphabet)); }
/// <summary> /// Checks if alphabet is appropriate for dna sequence, /// e.g. contains only nucleotide elements. /// </summary> /// <param name="alphabet"> /// Alphabet to check. /// </param> public static void CheckDnaAlphabet(Alphabet alphabet) { if (alphabet.Cardinality > 4) { throw new Exception("DNA alphabet cardinality must be 4 or less"); } var completeAlphabet = new Alphabet { new ValueString("A"), new ValueString("C"), new ValueString("T"), new ValueString("G") }; for (int i = 0; i < alphabet.Cardinality; i++) { if (!completeAlphabet.Contains(alphabet[i])) { throw new Exception("Alphabet contains at least 1 wrong element: " + alphabet[i]); } } }
protected override void CheckConstraints() { base.CheckConstraints(); foreach (var ti in Transforms) { foreach (char c in ti.Key.c) { if (!BandAlphabet.Contains(c)) { throw new Automat.AlphabetException(c, this); } } foreach (char c in ti.Value.c2) { if (!BandAlphabet.Contains(c)) { throw new Automat.AlphabetException(c, this); } } if (Alphabet.Contains(BlankSymbol)) { throw new Automat.AlphabetException(BlankSymbol, this); } if (ti.Key.q >= StatesCount) { throw new Automat.StateException(ti.Key.q, this); } if (ti.Value.qNext >= StatesCount) { throw new Automat.StateException(ti.Value.qNext, this); } } }
public void Test_NotContains() { Alphabet alphabet = Alphabet.Decimal; Assert.False(alphabet.Contains('A')); }
public void Test_Contains() { Alphabet alphabet = Alphabet.Decimal; Assert.True(alphabet.Contains('9')); }
protected bool BelongsToAlphabet(char value) => Alphabet.Contains(value);
/// <summary> /// (Overridable) Accepts an unassigned Puzzle and returns it created and populated with required values. /// </summary> /// <param name="Puzzle"></param> public virtual void InitializePuzzle(out Puzzle Puzzle) { List<string> puzzleRows = GetPuzzleContent(); int[] cellValues = new int[puzzleRows[0].Length * puzzleRows.Count]; Alphabet puzzleAlphabet = new Alphabet(); ExtractMetadata(puzzleRows); // Assumption: All values in the puzzle's alphabet can be found among the pre-filled cells it contains. for (int rowIndex = 0; rowIndex < puzzleRows.Count; rowIndex++) { for (int columnIndex = 0; columnIndex < puzzleRows[rowIndex].Length; columnIndex++) { string cellValue = puzzleRows[rowIndex].Substring(columnIndex, 1); if (cellValue != _EmptyCellDesignator && !puzzleAlphabet.Contains(int.Parse(cellValue))) { puzzleAlphabet.Add(int.Parse(cellValue)); } cellValues[rowIndex * puzzleRows.Count + columnIndex] = cellValue == _EmptyCellDesignator ? _EmptyCellValue : int.Parse(cellValue); } } Puzzle = new Puzzle(puzzleRows[0].Length, puzzleRows.Count, this.BoxWidth, this.BoxHeight, puzzleAlphabet); for (int cellIndex = 0; cellIndex < Puzzle.Cells.Count; cellIndex++) { Puzzle.Cells[cellIndex].Value = cellValues[cellIndex]; if (Puzzle.Cells[cellIndex].Value != _EmptyCellValue) { Puzzle.Cells[cellIndex].SetAsSolved(); } } if (Puzzle.SolveCount == 0) { Puzzle.ErrorMessage = "Error: The puzzle has no starting values in it."; } else { Puzzle.ErrorMessage = null; } }
public FiniteAutomaton(States q, Alphabet a, TransitionFunction d, State q0, AcceptingStates f) { States = q; Alphabet = a; Transitions = d; InitialState = q0; AcceptingStates = f; if (States.Count == 0) { throw new ArgumentException("The set of states cannot be empty."); } if (!States.Contains(InitialState)) { throw new ArgumentException("The initial state does not exist in the set of states!"); } foreach (var s in AcceptingStates) { if (!States.Contains(s)) { throw new ArgumentException($"The accepting state {s} does not exist in the set of states!"); } } foreach (var t in Transitions) { if (!States.Contains(t.P) || !States.Contains(t.Q) || (t.A != Alphabet.EmptyString && !Alphabet.Contains(t.A))) { throw new ArgumentException($"Invalid transition {t}"); } } }
private void ParsLine(string line) { string[] transition = line.Split(','); long source; long destination; //Recognize initial and final states and set source and destination. if (transition[0][0] == '*') { source = long.Parse(transition[0].Substring(2)); if (source >= StateCount) { throw InputIncorrectException; } if (!FinalStates.Contains(source)) { FinalStates.Add(source); } } else if (transition[0][0] == '-' && transition[0][1] == '>') { source = long.Parse(transition[0].Substring(3)); if (!InitialStateSet) { InitialState = source; } else if (InitialState != source || source >= StateCount) { throw InputIncorrectException; } } else { source = long.Parse(transition[0].Substring(1)); } if (transition[4][0] == '*') { destination = long.Parse(transition[4].Substring(2)); if (destination >= StateCount) { throw InputIncorrectException; } if (!FinalStates.Contains(destination)) { FinalStates.Add(destination); } } else if (transition[4][0] == '-' && transition[4][1] == '>') { destination = long.Parse(transition[4].Substring(3)); if (!InitialStateSet) { InitialState = destination; } else if (InitialState != destination || destination >= StateCount) { throw InputIncorrectException; } } else { destination = long.Parse(transition[4].Substring(1)); } //Check for transition alphabet correctness if (transition[1] != "_" && !Alphabet.Contains(transition[1][0])) { throw InputIncorrectException; } //Add transition Transitions[source].Item1.Add(destination); Transitions[source].Item2.Add(transition[1][0]); //Check for stack alphabet correctness if (transition[2].Length != 1) //pop element { throw InputIncorrectException; } else if (transition[2][0] != '_' && transition[2][0] != StackInitialSymbol && !StackAlphabet.Contains(transition[2][0])) { throw InputIncorrectException; } if (transition[3] != "_" && transition[3].Length != 2) //push element { throw InputIncorrectException; } foreach (char chr in transition[3]) { if (chr != '_' && chr != StackInitialSymbol && !StackAlphabet.Contains(chr)) { throw InputIncorrectException; } } //Add pop and push elements Transitions[source].Item3.Add(transition[2][0]); Transitions[source].Item4.Add(transition[3]); }
/// <summary> /// Has to be called every Update to ensure correct calling /// </summary> public void Update(GameTime gameTime) { // Shift pressed to lastPressed LastPressedKeys = new List <Keys>(PressedKeys); PressedKeys.Clear(); KeyboardState state = Keyboard.GetState(); PressedKeys.AddRange(state.GetPressedKeys()); // Add simulated keys foreach (Keys key in SimulatedKeys) { if (!PressedKeys.Contains(key)) { PressedKeys.Add(key); } } // Get pressed time for gmkeyboard.string // Remove released keys foreach (Keys key in PressTime.Keys.ToList()) { if (!PressedKeys.Contains(key)) { PressTime.Remove(key); } } // Add newly pressed keys to pressTime foreach (Keys key in PressedKeys) { if (!PressTime.ContainsKey(key)) { PressTime.Add(key, -gameTime.ElapsedGameTime.TotalMilliseconds); } } Dictionary <Keys, double> lastPressTime = new Dictionary <Keys, double>(PressTime); TriggeredKeys.Clear(); // Handle KeyboardString foreach (Keys key in PressTime.Keys.ToList()) { // Don't add key to string if it isn't allowed to if (Settings.AddSimulatedKeysToKeyboardString == false) { if (SimulatedKeys.Contains(key)) { break; } } PressTime[key] += gameTime.ElapsedGameTime.TotalMilliseconds; bool shouldFire = false; // Fire if key is just pressed if (PressTime[key] == 0) { shouldFire = true; } // Check if it should refire because key is hold if (PressTime[key] >= Settings.ReFireDelay) { int maxTime = Settings.ReFireDelay + Settings.ReFireInterval * 20; if (PressTime[key] > maxTime) { PressTime[key] -= Settings.ReFireInterval * 20; lastPressTime[key] -= Settings.ReFireInterval * 20; } for (int t = Settings.ReFireDelay; t < maxTime; t += Settings.ReFireInterval) { if (PressTime[key] > t && lastPressTime[key] < t) { shouldFire = true; } } } if (shouldFire) { TriggeredKeys.Add(key); // s = shift pressed? bool s = Check(Keys.LeftShift) | Check(Keys.RightShift); string keyString = key.ToString(); if (Alphabet.Contains(key)) { s = state.CapsLock ? !s : s; // Invert shift if CapsLock is on String += s ? keyString : keyString.ToLower(); } else { bool nl = state.NumLock; switch (key) { case Keys.Space: String += " "; break; case Keys.Back: if (String.Length > 0) { String = String.Substring(0, String.Length - 1); } break; case Keys.D1: String += s ? "!" : "1"; break; case Keys.D2: String += s ? "@" : "2"; break; case Keys.D3: String += s ? "#" : "3"; break; case Keys.D4: String += s ? "$" : "4"; break; case Keys.D5: String += s ? "%" : "5"; break; case Keys.D6: String += s ? "^" : "6"; break; case Keys.D7: String += s ? "&" : "7"; break; case Keys.D8: String += s ? "*" : "8"; break; case Keys.D9: String += s ? "(" : "9"; break; case Keys.D0: String += s ? ")" : "0"; break; case Keys.OemComma: String += s ? "<" : ","; break; case Keys.OemPeriod: String += s ? ">" : "."; break; case Keys.OemQuestion: String += s ? "?" : "/"; break; case Keys.OemSemicolon: String += s ? ":" : ";"; break; case Keys.OemQuotes: String += s ? "\"" : "'"; break; case Keys.OemPipe: String += s ? "|" : "\\"; break; case Keys.OemMinus: String += s ? "_" : "-"; break; case Keys.OemPlus: String += s ? "+" : "="; break; case Keys.OemOpenBrackets: String += s ? "{" : "["; break; case Keys.OemCloseBrackets: String += s ? "}" : "]"; break; case Keys.OemTilde: String += s ? "~" : "`"; break; case Keys.NumPad0: String += nl ? "0" : ""; break; case Keys.NumPad1: String += nl ? "1" : ""; break; case Keys.NumPad2: String += nl ? "2" : ""; break; case Keys.NumPad3: String += nl ? "3" : ""; break; case Keys.NumPad4: String += nl ? "4" : ""; break; case Keys.NumPad5: String += nl ? "5" : ""; break; case Keys.NumPad6: String += nl ? "6" : ""; break; case Keys.NumPad7: String += nl ? "7" : ""; break; case Keys.NumPad8: String += nl ? "8" : ""; break; case Keys.NumPad9: String += nl ? "9" : ""; break; case Keys.Multiply: String += "*"; break; case Keys.Divide: String += "/"; break; case Keys.Add: String += "+"; break; case Keys.Subtract: String += "-"; break; case Keys.Decimal: String += "."; break; case Keys.Enter: String += Settings.ParseEnter ? "\n" : ""; break; case Keys.Tab: String += Settings.ParseTab ? "\t" : ""; break; default: break; } } // Limit Keyboard.String length if (String.Length > Settings.StoreLength) { String = String.Substring(String.Length - Settings.StoreLength); } } } }