public void ClearAtTest() { var secondComplexChain = new ComplexChain("AGTC"); var firstComplexChain = new ComplexChain("ATC"); secondComplexChain.ClearAt(1); Assert.True(firstComplexChain.Equals(secondComplexChain)); }
/// <summary> /// The calculate std. /// </summary> /// <param name="convoluted"> /// The convoluted. /// </param> /// <param name="pbalance"> /// The pbalance. /// </param> /// <param name="windowLen"> /// The window len. /// </param> /// <param name="length"> /// The length. /// </param> /// <param name="criteriaCalculator"> /// The criteria calculator. /// </param> public void CalculateStd( ComplexChain convoluted, double pbalance, int windowLen, int length, CriterionMethod criteriaCalculator) { foreach (KeyValuePair<List<string>, List<int>> accord in fullEntry.Entry()) { PositionFilter.Filtrate(accord.Value, windowLen); double frequency = criteriaCalculator.Frequency(accord.Value, length, windowLen); double design = criteriaCalculator.DesignExpected( accord.Key, length, windowLen, minusOneEntry, minusTwoEntry); double interval = criteriaCalculator.IntervalEstimate( accord.Value, length, windowLen, convoluted.Anchor); double std = Math.Abs((pbalance * interval) + ((1 - pbalance) * frequency) - design) / Math.Sqrt(design); if (!wordPriority.ContainsKey(std)) { wordPriority.Add(std, accord); } } }
/// <summary> /// The distortion. /// </summary> /// <param name="chain"> /// The chain. /// </param> /// <param name="alphabet"> /// The alphabet. /// </param> /// <returns> /// The <see cref="double"/>. /// </returns> public override double Distortion(ComplexChain chain, FrequencyDictionary alphabet) { double maxFrequency = MaxFrequency(alphabet); double power = alphabet.Count; double greaterToSmaller = power / maxFrequency; double sumToGreater = (power + maxFrequency) / power; return Math.Abs(greaterToSmaller - sumToGreater); }
public void ConcatTwoTest() { int start = 0; int end = chain.GetLength(); var firstComplexChain = new ComplexChain(chain.Substring(start, end - 1)); var secondComplexChain = new ComplexChain(chain.Substring(end - 1, end)); ComplexChain concatChain = firstComplexChain.Concat(secondComplexChain.ToString()); Assert.True(concatChain.Equals(chain)); }
/// <summary> /// The state. /// </summary> /// <param name="chain"> /// The chain. /// </param> /// <param name="alphabet"> /// The alphabet. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> public override bool State(ComplexChain chain, FrequencyDictionary alphabet) { double currentDistortion = depth.Calculate(chain, chain.Anchor); // - calculate(gamutDeep, chain); if (Math.Abs(currentDistortion) > Value) { this.chain = chain.Clone(); this.alphabet = alphabet.Clone(); ThresholdToStop.SaveBest(); Value = currentDistortion; } return ThresholdToStop.Distance > ThresholdVariator.Precision; }
/// <summary> /// The state. /// </summary> /// <param name="chain"> /// The chain. /// </param> /// <param name="alphabet"> /// The alphabet. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> public override bool State(ComplexChain chain, FrequencyDictionary alphabet) { double distortion = Distortion(chain, alphabet); if (Math.Abs(Value) > Math.Abs(distortion)) { this.chain = chain.Clone(); this.alphabet = alphabet.Clone(); Value = distortion; ThresholdToStop.SaveBest(); } return ThresholdToStop.Distance > ThresholdVariator.Precision; }
/// <summary> /// The state. /// </summary> /// <param name="chain"> /// The chain. /// </param> /// <param name="alphabet"> /// The alphabet. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> public override bool State(ComplexChain chain, FrequencyDictionary alphabet) { double current = Distortion(chain, alphabet); if (Value > current) { Value = current; this.chain = chain.Clone(); this.alphabet = alphabet.Clone(); ThresholdToStop.SaveBest(); } return ThresholdToStop.Distance > ThresholdVariator.Precision; }
public void ReplaceTest() { var chain = new ComplexChain(list); var filter = new Filter(chain); int hits = filter.Replace(str2, "-"); var sb = new StringBuilder(); foreach (string s in list) { sb.Append(s); } string result = filter.GetChain().ToString(); string buf = chain.ToString(); Assert.True(buf.Length - result.Length == hits); }
/// <summary> /// Calculate std method. /// </summary> /// <param name="convoluted"> /// The convoluted. /// </param> /// <param name="windowLen"> /// The window len. /// </param> public void CalculateStd(ComplexChain convoluted, int windowLen) { var geometricMean = new GeometricMean(); var arithmeticMean = new ArithmeticMean(); foreach (KeyValuePair<List<string>, List<int>> accord in fullEntry.Entry()) { PositionFilter.Filtrate(accord.Value, windowLen); var temp = new ComplexChain(accord.Value); double geometric = geometricMean.Calculate(temp, convoluted.Anchor); double arithmetic = arithmeticMean.Calculate(temp, convoluted.Anchor); double std = 1 - (1 / Math.Abs(arithmetic - geometric)); if (!wordPriority.ContainsKey(std)) { wordPriority.Add(std, accord); } } }
public void FilteroutTest() { var chain = new ComplexChain(list); var filter = new Filter(chain); int hits = filter.FilterOut(str1); var sb = new StringBuilder(); foreach (string s in list) { sb.Append(s); } string result = filter.GetChain().ToString(); string buf = chain.ToString(); Assert.True(buf.Length - result.Length == hits); filter = new Filter(chain); hits = filter.FilterOut(str2); filter.GetChain().ToString(); chain.ToString(); Assert.True(hits == 3); }
/// <summary> /// The initialize method. /// </summary> /// <param name="chain"> /// The chain. /// </param> /// <param name="windowLength"> /// The window length. /// </param> /// <param name="step"> /// The step. /// </param> private void Initialize(ComplexChain chain, int windowLength, int step) { try { int chainLength = chain.GetLength(); if ((chainLength < windowLength) || (windowLength == 0) || ((step < 1) || (step > chainLength))) { throw new Exception(); } } catch (Exception) { } this.chain = chain.Clone(); this.windowLength = windowLength; this.step = step; CursorPosition = -step; CalculateMaxShifts(); }
/// <summary> /// The update. /// </summary> /// <param name="chain"> /// The chain. /// </param> /// <param name="alphabet"> /// The alphabet. /// </param> private void Update(ComplexChain chain, FrequencyDictionary alphabet) { double dist = TheoryVolume(chain, alphabet) - alphabet.Count; if (Math.Abs(Value) > Math.Abs(dist)) { this.alphabet = alphabet.Clone(); this.chain = chain.Clone(); Value = dist; ThresholdToStop.SaveBest(); } }
/// <summary> /// The distortion. /// </summary> /// <param name="chain"> /// The chain. /// </param> /// <param name="alphabet"> /// The alphabet. /// </param> /// <returns> /// The <see cref="double"/>. /// </returns> public override sealed double Distortion(ComplexChain chain, FrequencyDictionary alphabet) { return TheoryVolume(chain, alphabet) - alphabet.Count; }
/// <summary> /// The state. /// </summary> /// <param name="chain"> /// The chain. /// </param> /// <param name="alphabet"> /// The alphabet. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> public override bool State(ComplexChain chain, FrequencyDictionary alphabet) { Update(chain, alphabet); return (ThresholdToStop.Distance > ThresholdVariator.Precision) && (Math.Abs(Distortion(chain, alphabet)) > precisionOfDifference); }
/// <summary> /// Calculates the theoretical volume the alphabet for a chain. /// </summary> /// <param name="chain"> /// An estimated chain. /// </param> /// <param name="alphabet"> /// Current alphabet. /// </param> /// <returns> /// The theoretical volume the alphabet. /// </returns> public double TheoryVolume(ComplexChain chain, FrequencyDictionary alphabet) { double f = 0; List<string> wordsList = alphabet.GetWords(); foreach (string word in wordsList) { double freq = Frequency(chain, word); if (freq > f) { f = freq; } } double z = chain.GetLength(); double k = 1 / Math.Log(f * z); double b = (k / f) - 1; double v = (k * z) - b; return v; }
public void SetUp() { complexChain = new ComplexChain("AACAGGTGCCCCTTATTT"); }
/// <summary> /// Initializes a new instance of the <see cref="StartIterator" /> class. /// </summary> /// <param name="chain"> /// An iterable sequence /// </param> /// <param name="windowLength"> /// Length of a word (window of cutting) /// </param> /// <param name="step"> /// The number of elements through which the pointer will jump at the next iteration /// </param> public StartIterator(ComplexChain chain, int windowLength, int step) : base(chain, windowLength, step) { }
/// <summary> /// Initializes a new instance of the <see cref="EndIterator"/> class. /// </summary> /// <param name="chain"> /// The chain. /// </param> /// <param name="length"> /// Length of a word (window of cutting) /// </param> /// <param name="step"> /// The number of elements through which the pointer will jump at the next iteration /// </param> public EndIterator(ComplexChain chain, int length, int step) : base(chain, length, step) { CursorPosition = chain.GetLength() - windowLength + 1; }
/// <summary> /// The distortion. /// </summary> /// <param name="chain"> /// The chain. /// </param> /// <param name="alphabet"> /// The alphabet. /// </param> /// <returns> /// The <see cref="double"/>. /// </returns> public override double Distortion(ComplexChain chain, FrequencyDictionary alphabet) { return depth.Calculate(chain.Original(), chain.Anchor); // - gamutDeep.Calculate(chain); }
/// <summary> /// Initializes a new instance of the <see cref="FrequencyDictionary"/> class. /// </summary> /// <param name="sequence"> /// The sequence. /// </param> public FrequencyDictionary(ComplexChain sequence) { Fill(sequence); }
/// <summary> /// Extracts new words and their places of occurrence from a current word sequence /// </summary> /// <param name="sequence">the current word sequence</param> public void Fill(ComplexChain sequence) { Clear(); for (int index = 0; index < sequence.GetLength(); index++) { Put(sequence[index].ToString(), index); } }
/// <summary> /// The distortion. /// </summary> /// <param name="chain"> /// The chain. /// </param> /// <param name="alphabet"> /// The alphabet. /// </param> /// <returns> /// The <see cref="double"/>. /// </returns> public override double Distortion(ComplexChain chain, FrequencyDictionary alphabet) { return (remoteness.Calculate(chain, chain.Anchor) / remoteness.Calculate(chain.Original(), chain.Anchor)) - wordAverageLength.Calculate(chain, chain.Anchor); }
/// <summary> /// The state. /// </summary> /// <param name="chain"> /// The chain. /// </param> /// <param name="alphabet"> /// The alphabet. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> public override bool State(ComplexChain chain, FrequencyDictionary alphabet) { return false; }
/// <summary> /// The distortion. /// </summary> /// <param name="chain"> /// The chain. /// </param> /// <param name="alphabet"> /// The alphabet. /// </param> /// <returns> /// The <see cref="double"/>. /// </returns> public override double Distortion(ComplexChain chain, FrequencyDictionary alphabet) { return 0; }
/// <summary> /// Initializes a new instance of the <see cref="BaseIterator"/> class. /// </summary> /// <param name="chain"> /// An iterated sequence. /// </param> /// <param name="length"> /// Length of a word (window of cutting). /// </param> /// <param name="step"> /// The number of elements through which the pointer will jump at the next iteration. /// </param> public BaseIterator(ComplexChain chain, int length, int step) { CursorPosition = -1; Initialize(chain, length, step); }
/// <summary> /// Initializes a new instance of the <see cref="SequenceCleaner"/> class. /// </summary> /// <param name="chain"> /// The chain. /// </param> public SequenceCleaner(ComplexChain chain) : base(chain) { }
public void ResetTest() { int lengthCut = 2; int step = 1; int index = 0; int position = 6; var list1 = new List<string> { "ABABAB", "ABATAT", "TABABAB", "ABTABAB", "ABABAB", "ABABAB", "ABABAB" }; var chain = new ComplexChain(list1); var iterator = new EndIterator(chain, lengthCut, step); while (iterator.HasNext()) { iterator.Next(); index = index + 1; } iterator.Reset(); Assert.True(iterator.Position() == position); }
/// <summary> /// The frequency. /// </summary> /// <param name="chain"> /// The chain. /// </param> /// <param name="word"> /// The word. /// </param> /// <returns> /// The <see cref="double"/>. /// </returns> public double Frequency(ComplexChain chain, string word) { var temp = new List<object>(chain.Substring(0, chain.GetLength())); return Frequency(temp, word) / (double)chain.GetLength(); }
public void MoveTest() { int len = 2; int step = 1; int from = 1, to = 3; var list1 = new List<string> { "ABABAB", "ABATAT", "TABABAB", "ABTABAB", "ABABAB", "ABABAB", "ABABAB" }; List<string> list = list1.GetRange(@from, to - @from); var chain = new ComplexChain(list1); var iterator = new EndIterator(chain, len, step); iterator.Move(2); List<string> result = iterator.Next(); for (int i = 0; i < list.Count; i++) { Assert.True(list[i].Equals(result[i])); } }
/// <summary> /// The distortion. /// </summary> /// <param name="chain"> /// The chain. /// </param> /// <param name="alphabet"> /// The alphabet. /// </param> /// <returns> /// The <see cref="double"/>. /// </returns> public override double Distortion(ComplexChain chain, FrequencyDictionary alphabet) { return regularity.Calculate(chain, chain.Anchor); }