private Alphabet AlphabetCapture() { Speak("Alphabet Capture ready, every letter you enter from now will be added to your custom alphabet. " + "Press Enter/Escape to end Capture. Remember that word character order is important. Repeats will be ignored"); var alpha = new Alphabet(); while (true) { var character = Console.ReadKey(true); if (character.Key == ConsoleKey.Enter || character.Key == ConsoleKey.Escape) { break; } var added = alpha.Add(character.KeyChar); if (added) { Console.Write(character.KeyChar); } } Console.WriteLine(); Speak($"Alphabet Capture ended with {alpha.Count} characters."); return(alpha); }
/// <summary> /// Loads sequence by id from db and converts it to <see cref="Chain"/>. /// </summary> /// <param name="sequenceId"> /// The sequence id. /// </param> /// <returns> /// The sequence as <see cref="Chain"/>. /// </returns> public Chain GetLibiadaChain(long sequenceId) { if (Db.CommonSequence.Any(s => s.Id == sequenceId)) { var matter = Db.CommonSequence.Include(s => s.Matter).Single(s => s.Id == sequenceId).Matter; return(new Chain(Db.GetSequenceBuilding(sequenceId), GetAlphabet(sequenceId), sequenceId)); } // if it is not "real" sequence , then it must be image "sequence" var imageSequence = Db.ImageSequences.Include(s => s.Matter).Single(s => s.Id == sequenceId); if (imageSequence.Matter.Nature != Nature.Image) { throw new Exception("Cannot find sequence to return"); } var image = Image.Load(imageSequence.Matter.Source); var orderExtractor = imageSequence.OrderExtractor.GetAttribute <ImageOrderExtractor, ImageOrderExtractorAttribute>().Value; var sequence = ImageProcessor.ProcessImage(image, new IImageTransformer[0], new IMatrixTransformer[0], (IImageOrderExtractor)Activator.CreateInstance(orderExtractor)); var alphabet = new Alphabet { NullValue.Instance() }; var incompleteAlphabet = sequence.Alphabet; for (int j = 0; j < incompleteAlphabet.Cardinality; j++) { alphabet.Add(incompleteAlphabet[j]); } return(new Chain(sequence.Building, alphabet)); }
/// <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); }
public void Add_ExistsSymbols_NotExtendAlphabet() { //arrange var alphabet = new Alphabet("a"); //act alphabet.Add("aaaaa"); //assert Assert.AreEqual(0, alphabet.LowerCase.Except("a").Count()); }
public void Add_NewSymbols_ExtendAlphabet() { //arrange var alphabet = new Alphabet("a"); //act alphabet.Add("bc"); //assert Assert.AreEqual(0, "abc".Except(alphabet.LowerCase).Count()); }
private static Alphabet GetAlphabet(IEnumerable <HtmlNode> nodes) { var alphabet = new Alphabet(); foreach (var node in nodes) { var child = node.ChildNodes.First(); alphabet.Add(new Letter( child.InnerText, "http://apteka.103.by" + child.Attributes["href"].Value )); } return(alphabet); }
/// <summary> /// The to libiada alphabet. /// </summary> /// <param name="elementIds"> /// The element ids. /// </param> /// <returns> /// The <see cref="Alphabet"/>. /// </returns> public Alphabet ToLibiadaAlphabet(long[] elementIds) { var alphabet = new Alphabet { NullValue.Instance() }; List <Element> elements = GetElements(elementIds); foreach (long elementId in elementIds) { Element el = elements.Single(e => e.Id == elementId); alphabet.Add(new ValueString(el.Value)); } return(alphabet); }
/// <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> /// 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); } }
public ActionResult Index(short[] characteristicLinkIds, string[] customSequences, bool localFile, string fileType, bool toLower, bool removePunctuation) { return(CreateTask(() => { int sequencesCount = localFile ? Request.Files.Count : customSequences.Length; var sequencesNames = new string[sequencesCount]; var sequences = new Chain[sequencesCount]; if (localFile) { for (int i = 0; i < sequencesCount; i++) { Stream sequenceStream = FileHelper.GetFileStream(Request.Files[i]); sequencesNames[i] = Request.Files[i].FileName; switch (fileType) { case "text": using (var sr = new StreamReader(sequenceStream)) { string stringTextSequence = sr.ReadToEnd(); if (toLower) { stringTextSequence = stringTextSequence.ToLower(); } if (removePunctuation) { stringTextSequence = Regex.Replace(stringTextSequence, @"[^\w\s]", ""); } sequences[i] = new Chain(stringTextSequence); } break; case "image": var image = Image.Load(sequenceStream); var sequence = ImageProcessor.ProcessImage(image, new IImageTransformer[0], new IMatrixTransformer[0], new LineOrderExtractor()); var alphabet = new Alphabet { NullValue.Instance() }; var incompleteAlphabet = sequence.Alphabet; for (int j = 0; j < incompleteAlphabet.Cardinality; j++) { alphabet.Add(incompleteAlphabet[j]); } sequences[i] = new Chain(sequence.Building, alphabet); break; case "genetic": ISequence fastaSequence = NcbiHelper.GetFastaSequence(sequenceStream); var stringSequence = fastaSequence.ConvertToString(); sequences[i] = new Chain(stringSequence); sequencesNames[i] = fastaSequence.ID; break; case "wavFile": var reader = new BinaryReader(Request.Files[i].InputStream); int chunkID = reader.ReadInt32(); int fileSize = reader.ReadInt32(); int riffType = reader.ReadInt32(); int fmtID = reader.ReadInt32(); int fmtSize = reader.ReadInt32(); int fmtCode = reader.ReadInt16(); int channels = reader.ReadInt16(); int sampleRate = reader.ReadInt32(); int fmtAvgBPS = reader.ReadInt32(); int fmtBlockAlign = reader.ReadInt16(); int bitDepth = reader.ReadInt16(); if (fmtSize == 18) { // Read any extra values int fmtExtraSize = reader.ReadInt16(); reader.ReadBytes(fmtExtraSize); } int dataID = reader.ReadInt32(); int dataSize = reader.ReadInt32(); byte[] byteArray = reader.ReadBytes(dataSize); var shortArray = new short[byteArray.Length / 2]; Buffer.BlockCopy(byteArray, 0, shortArray, 0, byteArray.Length); //shortArray = Amplitude(shortArray, 20); shortArray = Sampling(shortArray, 50); //shortArray = shortArray.Select(s => (short)(s / 10)).ToArray(); sequences[i] = new Chain(shortArray); break; default: throw new ArgumentException("Unknown file type", nameof(fileType)); } } } else { for (int i = 0; i < sequencesCount; i++) { sequences[i] = new Chain(customSequences[i]); sequencesNames[i] = $"Custom sequence {i + 1}. Length: {customSequences[i].Length}"; } } var sequencesCharacteristics = new SequenceCharacteristics[sequences.Length]; for (int j = 0; j < sequences.Length; j++) { var characteristics = new double[characteristicLinkIds.Length]; for (int k = 0; k < characteristicLinkIds.Length; k++) { Link link = characteristicTypeLinkRepository.GetLinkForCharacteristic(characteristicLinkIds[k]); FullCharacteristic characteristic = characteristicTypeLinkRepository.GetCharacteristic(characteristicLinkIds[k]); IFullCalculator calculator = FullCalculatorsFactory.CreateCalculator(characteristic); characteristics[k] = calculator.Calculate(sequences[j], link); } sequencesCharacteristics[j] = new SequenceCharacteristics { MatterName = sequencesNames[j], Characteristics = characteristics }; } var characteristicNames = new string[characteristicLinkIds.Length]; var characteristicsList = new SelectListItem[characteristicLinkIds.Length]; for (int k = 0; k < characteristicLinkIds.Length; k++) { characteristicNames[k] = characteristicTypeLinkRepository.GetCharacteristicName(characteristicLinkIds[k]); characteristicsList[k] = new SelectListItem { Value = k.ToString(), Text = characteristicNames[k], Selected = false }; } var result = new Dictionary <string, object> { { "characteristics", sequencesCharacteristics }, { "characteristicNames", characteristicNames }, { "characteristicsList", characteristicsList } }; return new Dictionary <string, object> { { "data", JsonConvert.SerializeObject(result) } }; })); }
/// <summary> /// The to libiada alphabet. /// </summary> /// <param name="elementIds"> /// The element ids. /// </param> /// <returns> /// The <see cref="Alphabet"/>. /// </returns> public Alphabet ToLibiadaAlphabet(List<long> elementIds) { var alphabet = new Alphabet { NullValue.Instance() }; foreach (long elementId in elementIds) { Element el = db.Element.Single(e => e.Id == elementId); alphabet.Add(new ValueString(el.Value)); } return alphabet; }
/// <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; } }