/// <summary>
/// Reorganizes source chain.
/// </summary>
/// <param name="source">
/// Source chain.
/// </param>
/// <returns>
/// <see cref="AbstractChain"/>.
/// </returns>
/// <exception cref="InvalidOperationException">
/// Thrown if level is less than 0.
/// </exception>
public override AbstractChain Reorganize(AbstractChain source)
{
if (level < 0)
{
throw new InvalidOperationException("Markov chain level can't be less than 0");
}
if (level == 0)
{
return source;
}
var result = new BaseChain();
result.ClearAndSetNewLength(source.GetLength() + level);
for (int i = 0; i < source.GetLength(); i++)
{
result[i] = source[i];
}
var iterator = new IteratorStart(source, level, 1);
iterator.Reset();
iterator.Next();
AbstractChain addition = iterator.Current();
for (int i = 0; i < addition.GetLength(); i++)
{
result[source.GetLength() + i] = addition[i];
}
return result;
}
/// <summary>
/// Initializes a new instance of the <see cref="TestObject"/> class.
/// </summary>
public TestObject()
{
chain = new BaseChain(10);
chain2 = new BaseChain(5);
alpha.Add((ValueString)'a');
alpha.Add((ValueString)'b');
alpha.Add((ValueString)'c');
pm1 = new ValuePhantom { alpha[2], alpha[1] };
pm2 = new ValuePhantom { alpha[0] };
chain.Set(PhantomMessageBc, 0);
chain.Set(PhantomMessageA, 1);
chain.Set(PhantomMessageA, 2);
chain.Set(PhantomMessageBc, 3);
chain.Set(PhantomMessageA, 4);
chain.Set(PhantomMessageBc, 5);
chain.Set(PhantomMessageA, 6);
chain.Set(PhantomMessageBc, 7);
chain.Set(PhantomMessageA, 8);
chain.Set(PhantomMessageA, 9);
chain2.Set(alpha[1], 0);
chain2.Set(PhantomMessageA, 1);
chain2.Set(PhantomMessageBc, 2);
chain2.Set(alpha[0], 3);
chain2.Set(PhantomMessageBc, 4);
}
public void FourthTest()
{
var resultChain = new BaseChain(10);
var iterator = new IteratorWritableStart(resultChain);
iterator.Reset();
while (iterator.Next())
{
iterator.WriteValue(mother.PhantomMessageBc);
}
var gen = new PhantomChainGenerator(resultChain, new SimpleGenerator());
List<BaseChain> res = gen.Generate(1000);
int counter = 0;
for (int i = 0; i < 999; i++)
{
for (int j = i + 1; j < 1000; j++)
{
if (res[i].Equals(res[j]))
{
counter++;
}
}
}
Assert.AreEqual(0, counter);
}
/// <summary>
/// Create data sequence and matter.
/// </summary>
/// <param name="sequence">
/// The common sequence.
/// </param>
/// <param name="sequenceStream">
/// The sequence stream.
/// </param>
/// <param name="precision">
/// Precision of data sequence.
/// </param>
public void Create(CommonSequence sequence, Stream sequenceStream, int precision)
{
var stringSequence = FileHelper.ReadSequenceFromStream(sequenceStream);
string[] text = stringSequence.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
var cleanedSequence = text.Where(t => !t.Equals("\"volume\"") && !string.IsNullOrEmpty(t) && !string.IsNullOrWhiteSpace(t)).ToList();
var elements = new List<IBaseObject>();
for (int i = 0; i < cleanedSequence.Count; i++)
{
var element = cleanedSequence[i];
if (element.Substring(element.Length - 2, 2).Equals(".0"))
{
cleanedSequence[i] = cleanedSequence[i].Substring(0, cleanedSequence[i].Length - 2);
}
int intElement = int.Parse(cleanedSequence[i]);
int multiplier = (int)Math.Pow(10, precision);
intElement /= multiplier;
intElement *= multiplier;
elements.Add(new ValueInt(intElement));
}
var chain = new BaseChain(elements);
MatterRepository.CreateMatterFromSequence(sequence);
var alphabet = ElementRepository.ToDbElements(chain.Alphabet, sequence.NotationId, true);
Create(sequence, alphabet, chain.Building);
}
/// <summary>
/// Initializes a new instance of the <see cref="PhantomTable"/> class.
/// </summary>
/// <param name="source">
/// Phantom chain.
/// </param>
public PhantomTable(BaseChain source)
{
BaseChain internalChain = source;
ulong v = 1;
StartPositions.Add(0);
for (int j = 0; j < internalChain.GetLength(); j++)
{
if ((((ValuePhantom)internalChain[j])[0] is ValueString)
|| (((ValuePhantom)internalChain[j])[0] is BaseChain))
{
StartPositions.Add(StartPositions[j] + ((ValuePhantom)internalChain[j])[0].ToString().Length);
}
else
{
StartPositions.Add(StartPositions[j] + 1);
}
table.Add(null);
}
table.Add(null);
for (int i = internalChain.GetLength(); i > 0; i--)
{
var temp = (ValuePhantom)internalChain[i - 1];
table[i] = new Record(temp, v);
v *= (uint)temp.Cardinality;
}
// tree root is associated with phantom message
var t = new ValuePhantom { NullValue.Instance() };
table[0] = new Record(t, v);
}
/// <summary>
/// Reorganizes <see cref="AbstractChain"/> into <see cref="AbstractChain"/>.
/// </summary>
/// <param name="source">
/// Source chain.
/// </param>
/// <returns>
/// The <see cref="AbstractChain"/>.
/// </returns>
public override AbstractChain Reorganize(AbstractChain source)
{
var result = source.Clone() as AbstractChain;
if (result != null)
{
return result;
}
result = new BaseChain();
result.ClearAndSetNewLength(source.GetLength());
var iteratorRead = new IteratorSimpleStart(source, 1);
var iteratorWrite = new IteratorWritableStart(result);
iteratorRead.Reset();
iteratorWrite.Reset();
iteratorRead.Next();
iteratorWrite.Next();
for (int i = 0; i < source.GetLength(); i++)
{
iteratorWrite.WriteValue(iteratorRead.Current());
iteratorRead.Next();
iteratorWrite.Next();
}
return result;
}
public void ToStringTest()
{
var stringExpected = "abcabccc";
var chain = new Chain(stringExpected);
Assert.AreEqual(stringExpected, chain.ToString());
var baseChain = new BaseChain(stringExpected);
Assert.AreEqual(stringExpected, baseChain.ToString());
}
public void CloneTest()
{
chain = new BaseChain("123456789A");
var itsClone = (BaseChain)chain.Clone();
Assert.AreEqual(chain, itsClone);
Assert.AreNotSame(chain, itsClone);
}
/// <summary>
/// Addes chain to alphabet.
/// </summary>
/// <param name="item">
/// The item.
/// </param>
/// <returns>
/// <see cref="int"/>.
/// </returns>
public override int Add(IBaseObject item)
{
var temp = item as BaseChain;
if (temp == null)
{
temp = new BaseChain(1);
temp.Set(item, 0);
}
return base.Add(temp);
}
/// <summary>
/// Reorganizes <see cref="AbstractChain"/> into <see cref="AbstractChain"/>.
/// </summary>
/// <param name="source">
/// Source chain.
/// </param>
/// <returns>
/// The <see cref="AbstractChain"/>.
/// </returns>
public override AbstractChain Reorganize(AbstractChain source)
{
var resent = new BaseChain();
resent.ClearAndSetNewLength(source.GetLength());
for (int i = 0; i < source.GetLength(); i++)
{
var phantom = source[i] as ValuePhantom;
resent.Set(phantom != null ? phantom[0] : source[i], i);
}
return resent;
}
/// <summary>
/// The teach.
/// </summary>
/// <param name="chain">
/// The chain.
/// </param>
/// <param name="method">
/// The method.
/// </param>
public override void Teach(BaseChain chain, TeachingMethod method)
{
var builder = new MatrixBuilder();
var absoluteMatrix = (IAbsoluteMatrix)builder.Create(chain.Alphabet.Cardinality, Rank);
for (int i = 0; i < chain.Alphabet.Cardinality; i++)
{
int[] temp = new int[1];
temp[0] = chain.Alphabet.IndexOf(chain.Alphabet[i]);
absoluteMatrix.Add(temp);
}
ProbabilityMatrixes[0] = absoluteMatrix.ProbabilityMatrix();
}
/// <summary>
/// Generates sequence.
/// </summary>
/// <param name="length">
/// Length of generated sequence.
/// </param>
/// <param name="chainRank">
/// Rank of used markov chain.
/// </param>
/// <returns>
/// Generated sequence as <see cref="BaseChain"/>.
/// </returns>
public override BaseChain Generate(int length, int chainRank)
{
var temp = new BaseChain();
temp.ClearAndSetNewLength(length);
var read = Rank > 1 ? new IteratorStart(temp, Rank - 1, 1) : null;
var write = new IteratorWritableStart(temp);
if (read != null)
{
read.Reset();
read.Next();
}
write.Reset();
Generator.Reset();
int m = 0;
for (int j = 0; j < length; j++)
{
if (m == HeterogeneityRank + 1)
{
m = 0;
}
m += 1;
write.Next();
if (j >= Rank)
{
if (read != null)
{
read.Next();
}
}
if (read != null)
{
BaseChain chain = (BaseChain)read.Current();
var indexedChain = new int[chain.GetLength()];
for (int k = 0; k < chain.GetLength(); k++)
{
indexedChain[k] = Alphabet.IndexOf(chain[k]);
}
write.WriteValue(GetObject(ProbabilityMatrixes[m - 1].GetProbabilityVector(Alphabet, indexedChain)));
}
}
return temp;
}
public void Initialize()
{
chainBase = new BaseChain(10);
chainBase[0] = new ValueString('1');
chainBase[1] = new ValueString('2');
chainBase[2] = new ValueString('3');
chainBase[3] = new ValueString('4');
chainBase[4] = new ValueString('5');
chainBase[5] = new ValueString('6');
chainBase[6] = new ValueString('7');
chainBase[7] = new ValueString('8');
chainBase[8] = new ValueString('9');
chainBase[9] = new ValueString('A');
}
public void ToStringDelimiterTest()
{
var source = "abcabccc";
var chain = new Chain(source);
var baseChain = new BaseChain(source);
var expected = "a b c a b c c c";
Assert.AreEqual(expected, chain.ToString(" "));
Assert.AreEqual(expected, baseChain.ToString(" "));
expected = "acbcccacbcccccc";
Assert.AreEqual(expected, chain.ToString("c"));
Assert.AreEqual(expected, baseChain.ToString("c"));
}
public void ToStringLongDelimiterTest()
{
var source = "abcabccc";
var chain = new Chain(source);
var baseChain = new BaseChain(source);
var expected = "a - b - c - a - b - c - c - c";
Assert.AreEqual(expected, chain.ToString(" - "));
Assert.AreEqual(expected, baseChain.ToString(" - "));
expected = "a, b, c, a, b, c, c, c";
Assert.AreEqual(expected, chain.ToString(", "));
Assert.AreEqual(expected, baseChain.ToString(", "));
}
/// <summary>
/// Initializes a new instance of the <see cref="PhantomChainGenerator"/> class.
/// </summary>
/// <param name="chain">
/// The chain.
/// </param>
/// <param name="generator">
/// The gen.
/// </param>
public PhantomChainGenerator(BaseChain chain, IGenerator generator)
{
this.generator = generator;
var reorganizer = new SpacePhantomReorganizer();
var internalChain = (BaseChain)reorganizer.Reorganize(chain);
for (int w = 0; w < internalChain.GetLength(); w++)
{
totalLength += ((ValuePhantom)internalChain[w])[0].ToString().Length;
}
ulong tempVariants = 1;
int counter = 0;
for (int k = 0; k < (int)Math.Ceiling((double)internalChain.GetLength() / BasicChainLength); k++)
{
tempChains.Add(new BaseChain());
tempChains[k].ClearAndSetNewLength(BasicChainLength);
tree.Add(null);
}
// variants count calculation cycle
for (int i = 0; i < tempChains.Count; i++)
{
for (int j = 0; j < tempChains[i].GetLength(); j++)
{
ValuePhantom tempMessage;
if (counter < internalChain.GetLength())
{
tempMessage = (ValuePhantom)internalChain[counter];
tempChains[i][j] = tempMessage;
}
else
{
tempMessage = new ValuePhantom { new ValueString('a') };
tempChains[i][j] = tempMessage;
}
tempVariants *= (uint)tempMessage.Cardinality;
counter++;
}
if ((i != tempChains.Count - 1) || (tempChains.Count == 1))
{
Variants = Math.Min(Variants, tempVariants);
}
tempVariants = 1;
tree[i] = new TreeTop(tempChains[i], generator);
}
}
public void ContentTest()
{
var m1 = new ValuePhantom { new ValueString('1'), new ValueString('2'), new ValueString('3') };
var m2 = new ValuePhantom { new ValueString('4'), new ValueString('3') };
var test = new BaseChain(3);
test.Set(m1, 0);
test.Set(m2, 1);
test.Set(m2, 2);
var table = new PhantomTable(test);
Assert.AreEqual(m1, table[1].Content);
Assert.AreEqual(m2, table[2].Content);
Assert.AreEqual(m2, table[3].Content);
}
/// <summary>
/// Method that creates chain of "first occurrences of different elements".
/// </summary>
/// <param name="source">
/// Source chain.
/// </param>
/// <returns>/
/// Dissimilar chain.
/// </returns>
public static Chain Create(BaseChain source)
{
var result = new Chain(source.GetLength());
Alphabet sourceAlphabet = source.Alphabet;
var entries = new int[sourceAlphabet.Cardinality];
for (int i = 0; i < source.GetLength(); i++)
{
int elementIndex = sourceAlphabet.IndexOf(source[i]);
int entry = ++entries[elementIndex];
result.Set(new ValueInt(entry), i);
}
return result;
}
/// <summary>
/// The divide.
/// </summary>
/// <param name="chain">
/// The chain.
/// </param>
/// <returns>
/// The <see cref="BaseChain"/>.
/// </returns>
public BaseChain Divide(BaseChain chain)
{
var firstChain = new ActualChain(chain);
var stack = new Stack();
stack.Push(firstChain);
ArrayList list = alphabet.GetLengthList();
do
{
var actChain = (ActualChain)stack.Pop();
BaseChain chain4Check = actChain.Source;
for (int i = list.Count - 1; i >= 0; i--)
{
BaseChain word;
if (chain4Check.GetLength() >= (int)list[i])
{
var it = new IteratorStart(chain4Check, (int)list[i], 1);
it.Next();
word = (BaseChain)it.Current();
}
else
{
continue;
}
if (alphabet.Contains(word))
{
// solution is found
if (chain4Check.GetLength() == (int)list[i])
{
actChain.RemoveCharacter((int)list[i]);
return actChain.GetResult();
}
var newChain = (ActualChain)actChain.Clone();
newChain.RemoveCharacter((int)list[i]);
stack.Push(newChain);
}
}
}
while (stack.Count > 0);
return null;
}
public void FirstTest()
{
var resultChain = new BaseChain(10);
resultChain.Set(mother.PhantomMessageBc[1], 0);
resultChain.Set(mother.PhantomMessageA[0], 1);
resultChain.Set(mother.PhantomMessageA[0], 2);
resultChain.Set(mother.PhantomMessageBc[1], 3);
resultChain.Set(mother.PhantomMessageA[0], 4);
resultChain.Set(mother.PhantomMessageBc[1], 5);
resultChain.Set(mother.PhantomMessageA[0], 6);
resultChain.Set(mother.PhantomMessageBc[1], 7);
resultChain.Set(mother.PhantomMessageA[0], 8);
resultChain.Set(mother.PhantomMessageA[0], 9);
var gen = new PhantomChainGenerator(mother.SourceChain, new MockGenerator());
List<BaseChain> res = gen.Generate(1);
Assert.AreEqual(res.Count, 1);
Assert.AreEqual(resultChain, res[0]);
}
public void VolumeTest()
{
var m3 = new ValuePhantom { new ValueString('a') };
var m1 = new ValuePhantom { new ValueString('1'), new ValueString('2'), new ValueString('3') };
var m2 = new ValuePhantom { new ValueString('4'), new ValueString('3') };
var test = new BaseChain(4);
test.Set(m1, 0);
test.Set(m2, 1);
test.Set(m2, 2);
test.Set(m3, 3);
var table = new PhantomTable(test);
Assert.AreEqual(12, table[0].Volume);
Assert.AreEqual(4, table[1].Volume);
Assert.AreEqual(2, table[2].Volume);
Assert.AreEqual(1, table[3].Volume);
Assert.AreEqual(1, table[4].Volume);
}
public void AddLengthMoreThanChainRankTest()
{
alphabet.Add(a);
alphabet.Add(b);
alphabet.Add(c);
alphabet.Add(d);
baseChain = new BaseChain(3);
baseChain.Set(a, 0);
baseChain.Set(b, 1);
baseChain.Set(b, 2);
matrix = new Matrix(alphabet.Cardinality, 2);
var arrayCh = new int[baseChain.GetLength()];
arrayCh[0] = alphabet.IndexOf(baseChain[0]);
arrayCh[1] = alphabet.IndexOf(baseChain[1]);
arrayCh[2] = alphabet.IndexOf(baseChain[2]);
Assert.Throws<ArgumentException>(() => matrix.Add(arrayCh));
}
/// <summary>
/// Initializes a new instance of the <see cref="TreeTop"/> class,
/// representing root element of the tree.
/// </summary>
/// <param name="source">
/// The input chain.
/// </param>
/// <param name="generator">
/// The gen.
/// </param>
public TreeTop(BaseChain source, IGenerator generator)
{
table = new PhantomTable(source);
this.generator = generator;
StartPosition = 0;
Volume = table[0].Volume;
Level = -1;
if ((table[1].Content[0] is ValueString) || (table[1].Content[0] is BaseChain))
{
isString = true;
}
if ((source != null) && (source.GetLength() != 0))
{
var temp = (ValuePhantom)source[0];
for (int i = 0; i < temp.Cardinality; i++)
{
Children.Add(new TreeNode(this, temp[i], table));
}
}
}
public void TreeVolumeTest()
{
var m1 = new ValuePhantom { new ValueString('1'), new ValueString('2'), new ValueString('3') };
var m2 = new ValuePhantom { new ValueString('4'), new ValueString('3') };
var m3 = new ValuePhantom { new ValueString('a') };
var test = new BaseChain(4);
test.Set(m1, 0);
test.Set(m2, 1);
test.Set(m2, 2);
test.Set(m3, 3);
IGenerator gen = new SimpleGenerator();
var tree = new TreeTop(test, gen);
Assert.AreEqual(12, tree.Volume);
var ch1 = tree.GetChild(0);
Assert.AreEqual(4, ch1.Volume);
var ch2 = tree.GetChild(1);
Assert.AreEqual(4, ch2.Volume);
var ch3 = tree.GetChild(2);
Assert.AreEqual(4, ch3.Volume);
}
/// <summary>
/// Creates literature sequence in database.
/// </summary>
/// <param name="commonSequence">
/// The common sequence.
/// </param>
/// <param name="sequenceStream">
/// The sequence stream.
/// </param>
/// <param name="languageId">
/// The language id.
/// </param>
/// <param name="original">
/// The original.
/// </param>
/// <param name="translatorId">
/// The translator id.
/// </param>
public void Create(CommonSequence commonSequence, Stream sequenceStream, int languageId, bool original, int? translatorId)
{
var stringSequence = FileHelper.ReadSequenceFromStream(sequenceStream);
string[] text = stringSequence.Split('\n');
for (int l = 0; l < text.Length - 1; l++)
{
// removing "\r"
text[l] = text[l].Substring(0, text[l].Length - 1);
}
var chain = new BaseChain(text.Length - 1);
// file always contains empty string at the end
// TODO: rewrite this, add empty string check at the end or write a normal trim
for (int i = 0; i < text.Length - 1; i++)
{
chain.Set(new ValueString(text[i]), i);
}
MatterRepository.CreateMatterFromSequence(commonSequence);
var alphabet = ElementRepository.ToDbElements(chain.Alphabet, commonSequence.NotationId, true);
Create(commonSequence, original, languageId, translatorId, alphabet, chain.Building);
}
public void SortListTest()
{
var temp = new ChainsAlphabet();
var a = new BaseChain(2);
for (int i = 0; i < a.GetLength(); i++)
{
a.Set((ValueInt)i, i);
}
temp.Add(a);
var b = new BaseChain(1);
for (int i = 0; i < b.GetLength(); i++)
{
b.Set((ValueInt)i, i);
}
temp.Add(b);
var c = new BaseChain(5);
for (int i = 0; i < c.GetLength(); i++)
{
c.Set((ValueInt)i, i);
}
temp.Add(c);
var d = new BaseChain(2);
for (int i = 0; i < d.GetLength(); i++)
{
d.Set((ValueInt)(i + 1), i);
}
temp.Add(d);
ArrayList list = temp.GetLengthList();
Assert.AreEqual(5, list[2]);
Assert.AreEqual(2, list[1]);
Assert.AreEqual(1, list[0]);
}
/// <summary>
/// The create DNA sequence.
/// </summary>
/// <param name="sequence">
/// The common sequence.
/// </param>
/// <param name="fastaSequence">
/// Sequence as <see cref="ISequence"/>>.
/// </param>
/// <param name="partial">
/// The partial.
/// </param>
/// <exception cref="Exception">
/// Thrown if at least one element of new sequence is missing in db
/// or if sequence is empty or invalid.
/// </exception>
public void Create(CommonSequence sequence, ISequence fastaSequence, bool partial)
{
// TODO: fix it for batch import or remove fasta headers completely
string fastaHeader = ">" + fastaSequence.ID;
if (fastaHeader.Contains("Resource temporarily unavailable"))
{
throw new Exception("Sequence is empty or invalid (probably ncbi is not responding).");
}
string stringSequence = fastaSequence.ConvertToString().ToUpper();
var chain = new BaseChain(stringSequence);
if (!ElementRepository.ElementsInDb(chain.Alphabet, sequence.NotationId))
{
throw new Exception("At least one element of new sequence is invalid (not A, C, T, G or U).");
}
MatterRepository.CreateMatterFromSequence(sequence);
var alphabet = ElementRepository.ToDbElements(chain.Alphabet, sequence.NotationId, false);
Create(sequence, partial, alphabet, chain.Building);
}
public void ConstructorTest()
{
chain = new Chain(100);
Assert.AreEqual(100, chain.GetLength());
}
public void Initialization()
{
chain = new BaseChain(10);
}
public void Initialization()
{
chain = new Chain("adbaacbbaaca");
baseChain = new BaseChain("adbaacbbaaca");
}
