//internal Pattern(string name) { PatternName = name; }
/// <summary>
/// Construct a pattern with a given name usually passed from child class
/// </summary>
/// <param name="name"> name of element</param>
public Pattern(string name)
{
match = new QUT.Bio.BioPatML.Patterns.Match(this);
Threshold = 0.0;
PatternName = name;
Impact = 1.0; //start it with a default value
}
public void TestCopy () {
Match m = new Match( voidPattern, null, 3, 2, +1, 1 );
Match sub1 = new Match( voidPattern, null, 4, 2, +1, 0.5 );
sub1.Impact = 0.5;
Match sub2 = new Match( voidPattern, null, 5, 2, +1, 0.1 );
sub2.Impact = 0.7;
m.SubMatches.Add( sub1 );
m.SubMatches.Add( sub2 );
Match mc = m.Clone();
Assert.AreEqual( 2, m.SubMatches.Count );
Assert.AreEqual( 2, mc.SubMatches.Count );
Assert.IsTrue( mc != m );
Assert.IsTrue( sub1 != mc.SubMatches[0] );
Assert.IsTrue( sub2 != mc.SubMatches[1] );
Assert.AreEqual( 3, mc.Start );
Assert.AreEqual( 4, mc.SubMatches[0].Start );
Assert.AreEqual( 5, mc.SubMatches[1].Start );
Assert.AreEqual( 0.5, mc.SubMatches[0].Impact, 1e-10 );
Assert.AreEqual( 0.7, mc.SubMatches[1].Impact, 1e-10 );
}
public void TestConstructor () {
Sequence seq = new Sequence( AlphabetType.DNA, "atcg" );
Match m = new Match( voidPattern, seq, 3, 2, +1, 1 );
Assert.AreEqual( 3, m.Start );
Assert.AreEqual( 2, m.Length );
Assert.AreEqual( 1, m.Strand );
Assert.AreEqual( seq, m.BaseSequence );
Assert.AreEqual( "cg", m.Letters() );
Assert.AreEqual( 1.0, m.Similarity, 1e-3 );
}
public void TestSubMatch () {
Sequence seq1 = new Sequence( AlphabetType.DNA, "tttggccaaagcc" );
Match m = new Match( null );
Match sub1 = new Match( null );
Match sub2 = new Match( null );
Assert.AreEqual( 0, m.SubMatches.Count );
m.SubMatches.Add( sub1 );
m.SubMatches.Add( sub2 );
Assert.AreEqual( 2, m.SubMatches.Count );
Assert.AreEqual( sub1, m.SubMatches[0] );
Assert.AreEqual( sub2, m.SubMatches[1] );
}
public void TestSetGet () {
Sequence seq = new Sequence( AlphabetType.DNA, "atcg" );
Match m = new Match( null );
m.Set( seq, 3, 4, +1, 0.75 );
Assert.AreEqual( seq, m.BaseSequence );
Assert.AreEqual( 3, m.Start );
Assert.AreEqual( 4, m.Length );
Assert.AreEqual( 1, m.Strand );
Assert.AreEqual( 0.75, m.Similarity, 1e-3 );
Assert.AreEqual( 1, m.CalcMismatches() );
Assert.AreEqual( 3, m.Matches );
}
public void TestToString () {
Sequence seq = new Sequence( AlphabetType.DNA, "actgactg" );
Match m = new Match( voidPattern, null, 3, 2, +1, 1 );
m.SetSequence( seq );
Assert.AreEqual( "{3, 2, 1, 1, tg}", m.ToString() ); //change the expected result from usual 1.0 to 1
m.SubMatches.Add( new Match( voidPattern, null, 4, 2, -1, 0.5 ) );
m.SubMatches[ 0 ].SetSequence( seq );
m.SubMatches.Add( new Match( voidPattern, null, 5, 3, +1, 0.1 ) );
m.SubMatches[ 1 ].SetSequence( seq );
Assert.AreEqual( "{3, 2, 1, 1, tg, {4, 2, -1, 0.5, tc}, {5, 3, 1, 0.1, act}}",
m.ToString() ); //see original code for actual result, i trim away the 1 decimal placing to pass the
//test as there wont be much impact
}
public void TestCalcSimilarity () {
Match m = new Match( null );
Match sub1 = new Match( voidPattern, null, 0, 0, +1, 1.0 );
Match sub2 = new Match( voidPattern, null, 0, 0, +1, 0.5 );
m.SubMatches.Add( sub1 );
m.SubMatches.Add( sub2 );
m.CalcSimilarity();
Assert.AreEqual( 0.75, m.Similarity, 1e-3 );
}
/// <summary>
/// Constructs an empty profile.
/// </summary>
/// <param name="name">Name for element profile best</param>
/// <param name="threshold">Similarity threshold.</param>
public ProfileBest(string name, double threshold)
: base (name)
{
maxMatch = new Match(this);
Threshold = threshold;
}
public void TestCalcStartEnd () {
Match m = new Match( null );
Match sub1 = new Match( voidPattern, null, 2, 2, +1, 0.0 );
Match sub2 = new Match( voidPattern, null, 3, 2, +1, 0.0 );
m.SubMatches.Add( sub1 );
m.SubMatches.Add( sub2 );
m.CalcStartEnd();
Assert.AreEqual( 2, m.SubMatches.Count );
Assert.AreEqual( 2, m.Start );
Assert.AreEqual( 3, m.Length );
Assert.AreEqual( 4, m.End );
}
/// <summary>
/// Creates a deep copy of the given match object.
/// </summary>
/// <param name="match">Match object to copy.</param>
/// <returns>Returns a deep copy.</returns>
public Match Clone(Match match)
{
Match newMatch = new Match(null);
newMatch.Set(match);
newMatch.SubMatchedList = null;
for (int i = 0; i < match.SubMatchNumber; i++)
newMatch.Add(Clone(match.GetSubMatch(i)));
return (newMatch);
}
/// <summary>
/// Replaces a sub match which replaces the sub match for the given index.
/// </summary>
/// <param name="index">Index of the sub match to replace.</param>
/// <param name="match">Match to set.</param>
public void ReplaceSubMatch(int index, Match match)
{
MatchedList.Insert(index, match);
}
/// <summary>
/// Adds a sub match to the list of sub matches at the given index position.
/// </summary>
/// <param name="index">Index position for insertion.</param>
/// <param name="match">Match to add.</param>
public void Add(int index, Match match)
{
if (MatchedList == null)
MatchedList = (new FeatureList("SubMatches"));
MatchedList.Add(index, match);
}
/// <summary>
/// Setter for a match object on base of another match object.
/// </summary>
/// <param name="match">Match object with initial values.</param>
public void Set(Match match)
{
Set(match.BaseSequence, match.Start, match.Length,
match.Strand, match.Similarity);
this.MatchPattern = match.MatchPattern;
//this.Name = match.MatchPattern.PatternName;
this.impact = match.impact;
FeatureList subMatchList = match.SubMatchedList;
if (subMatchList != null)
{
if (MatchedList == null)
{
FeatureList matchList = new FeatureList("SubMatches");
for (int i = 0; i < subMatchList.Count; i++)
matchList.Add(Clone((Match)subMatchList.Feature(i)));
MatchedList = matchList;
}
else
{
for (int i = 0; i < subMatchList.Count; i++)
((Match)MatchedList.Feature(i)).Set((Match)subMatchList.Feature(i));
}
}
else
MatchedList = null;
}
/// <summary>
/// Implementation of the pattern interface. A match is successful if
/// every pattern of the profile matches successfully and the mean
/// similarity is higher or equal than the profile similarity threshold
/// <see cref="QUT.Bio.BioPatML.Patterns.IMatcher">IMatcher Match Method</see>
/// </summary>
/// <param name="sequence"></param>
/// <param name="position"></param>
/// <returns></returns>
public override Match Match(BioPatML.Sequences.Sequence sequence, int position)
{
Match match = Matched;
Match maxMatch = null;
int patternNumber = patternList.Count;
for (int index = 0; index < patternNumber; index++)
{
ProfileElement element = this[index];
position = index > 0 ? element.GapStart : position;
maxMatch = MaxMatch(element, sequence, position);
if (maxMatch == null)
return (null);
element.Pattern.Matched.Set(maxMatch);
}
match.CalcSimilarity();
if (match.Similarity < Threshold)
return (null);
match.CalcStartEnd();
match.Strand = sequence.Strand;
match.SetSequence(sequence);
return (match);
}
public void TestSetMatch () {
Sequence seq = new Sequence( AlphabetType.DNA, "atcg" );
Match m1 = new Match( null );
Match m2 = new Match( null );
m1.Set( seq, 3, 2, +1, 0.5 );
m2.Set( m1 );
Assert.AreEqual( seq, m2.BaseSequence );
Assert.AreEqual( 3, m2.Start );
Assert.AreEqual( 2, m2.Length );
Assert.AreEqual( 1, m2.Strand );
Assert.AreEqual( 0.5, m2.Similarity, 1e-3 );
Assert.AreEqual( "cg", m2.Letters() );
}
public void TestCalcLength () {
Match m = new Match( null );
Match sub1 = new Match( voidPattern, null, 2, 2, +1, 0.0 );
Match sub2 = new Match( voidPattern, null, 3, 4, +1, 0.0 );
m.SubMatches.Add( sub1 );
m.SubMatches.Add( sub2 );
Assert.AreEqual( 2, sub1.CalcLength() );
Assert.AreEqual( 4, sub2.CalcLength() );
Assert.AreEqual( 6, m.CalcLength() );
}
/// <summary>
/// Default constructor, constructing an empty profile best
/// </summary>
public ProfileBest() : base("ProfileBest" + Id.ToString()) { maxMatch = new Match(this); }
