/// <summary>
/// Find the set of symbols that is represented by input symbol
/// </summary>
/// <param name="symbol">Symbol to look up</param>
/// <returns>Set of symbols</returns>
public HashSet <ISequenceItem> GetBasicSymbols(ISequenceItem symbol)
{
if (symbol == null)
{
throw new ArgumentNullException("symbol");
}
// Validate input symbol
Nucleotide n = symbol as Nucleotide;
if (n == null || !values.Contains(n))
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentCulture, Properties.Resource.INVALID_SYMBOL, symbol.Symbol, Name));
}
if (ambiguousToBasicSymbolMap.ContainsKey(symbol))
{
return(ambiguousToBasicSymbolMap[symbol]);
}
else
{
// It is base / unambiguous character
return(new HashSet <ISequenceItem>()
{
symbol
});
}
}
/// <summary>
/// Indication of whether or not an ISequenceItem is in the alphabet. This is
/// a simple lookup and will only match exactly with items of this alphabet. It
/// will not compare items from other alphabets that match the same nucleotide.
/// </summary>
/// <param name="item">Item whose presence is to be checked</param>
/// <returns>True if this contains input item</returns>
public bool Contains(ISequenceItem item)
{
Nucleotide nucleo = item as Nucleotide;
if (nucleo == null)
{
return(false);
}
return(values.Contains(nucleo));
}
/// <summary>
/// Returns a new copy of the Nucleotide object.
/// </summary>
/// <returns>Clone of this nucleotide</returns>
public virtual Nucleotide Clone()
{
Nucleotide nucleotide = new Nucleotide();
nucleotide.val = val;
nucleotide.symbol = symbol;
nucleotide.Name = name;
nucleotide.IsGap = IsGap;
nucleotide.IsAmbiguous = IsAmbiguous;
return(nucleotide);
}
/// <summary>
/// Overrides Object Equals.
/// Two nucleotides are judged equal, if they have the same symbol
/// </summary>
/// <param name="obj">Object to be compared with</param>
/// <returns>True if equal</returns>
public override bool Equals(object obj)
{
Nucleotide other = obj as Nucleotide;
if (other != null)
{
return(this.Symbol == other.Symbol);
}
else
{
return(false);
}
}
/// <summary>
/// Find the consensus nucleotide for a set of nucleotides
/// </summary>
/// <param name="symbols">Set of sequence items</param>
/// <returns>Consensus nucleotide</returns>
public ISequenceItem GetConsensusSymbol(HashSet <ISequenceItem> symbols)
{
// Validate that all are valid DNA symbols
foreach (ISequenceItem s in symbols)
{
Nucleotide n = s as Nucleotide;
if (n == null || !values.Contains(n))
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentCulture, Properties.Resource.INVALID_SYMBOL, s.Symbol, Name));
}
}
// Remove all gap symbols
symbols.ExceptWith(gapItems);
if (symbols.Count == 0)
{
// All are gap characters, return default 'Gap'
return(DefaultGap);
}
else if (symbols.Count == 1)
{
return(symbols.First());
}
else
{
HashSet <ISequenceItem> baseSet = new HashSet <ISequenceItem>();
foreach (Nucleotide n in symbols)
{
if (ambiguousToBasicSymbolMap.ContainsKey(n))
{
baseSet.UnionWith(ambiguousToBasicSymbolMap[n]);
}
else
{
// If not found in ambiguous map, it has to be base / unambiguous character
baseSet.Add(n);
}
}
return(basicToAmbiguousSymbolMap[baseSet]);
}
}
/// <summary>
/// Transcribes a DNA sequence into the corresponding sequence on
/// the other strand, then reverses it so that the new sequence has
/// the same orientation as the original (in the 3'-to-5' sense). The length
/// of the resulting sequence will equal the length of the source
/// sequence. Gap and ambiguous characters will also be transcribed.
///
/// For example:
///
/// Sequence dna = new Sequence(Alphabets.DNA, "TACCGC");
/// Sequence otherStrand = Complementarity.ReverseComplement(dna);
///
/// otherStrand.ToString() would produce "GCGGTA"
/// </summary>
/// <param name="dnaSource">The input sequence.</param>
/// <returns>A new complementary sequence.</returns>
public static ISequence ReverseComplement(ISequence dnaSource)
{
if (dnaSource.Alphabet != Alphabets.DNA)
{
string message = "ReverseComplement is only supported for DNA sequence.";
Trace.Report(message);
throw new NotSupportedException(message);
}
Sequence result = new Sequence(Alphabets.DNA);
result.IsReadOnly = false;
result.ID = "Reverse Complement: " + dnaSource.ID;
result.DisplayID = "Reverse Complement: " + dnaSource.DisplayID;
for (int iSymbol = dnaSource.Count - 1; iSymbol >= 0; --iSymbol)
{
Nucleotide n = (Nucleotide)dnaSource[iSymbol];
result.Add(GetDnaComplement(n));
}
result.IsReadOnly = true;
return(result);
}
/// <summary>
/// Returns the complement of an RNA nucleotide. This also
/// respects ambiguous characters in the RNA alphabet.
/// </summary>
public static Nucleotide GetRnaComplement(Nucleotide rnaSource)
{
return(rnaToComplement[rnaSource]);
}
/// <summary>
/// Returns the complement of a DNA nucleotide. This also
/// respects ambiguous characters in the DNA alphabet.
/// </summary>
public static Nucleotide GetDnaComplement(Nucleotide dnaSource)
{
return(dnaToComplement[dnaSource]);
}