public void SetFinalGainTableAfterGainCalculation(GainTable m) { this._FinalGainTableAfterGainCalculation = new GainTable() { _TaxaGainSummary = new List <Taxa>(m._TaxaGainSummary.Select(x => new Taxa() { _Taxa_Value = x._Taxa_Value, _Quartet_Name = x._Quartet_Name, _Taxa_ValuePosition_In_Quartet = x._Taxa_ValuePosition_In_Quartet, _Gain = x._Gain, _CumulativeGain = x._CumulativeGain, IsFreeze = x.IsFreeze, _IsolatedCount = x._IsolatedCount, _ViotatedCount = x._ViotatedCount, _DifferedCount = x._DifferedCount, _SatisfiedCount = x._SatisfiedCount, _TaxaPartitionSet = new PartitionSet(x._TaxaPartitionSet._PartitionSetName, x._TaxaPartitionSet._Final_Score, x._TaxaPartitionSet._IsolatedCount, x._TaxaPartitionSet._ViotatedCount, x._TaxaPartitionSet._SatisfiedCount, x._TaxaPartitionSet._DifferedCount, x._TaxaPartitionSet._taxValueForGainCalculation, x._TaxaPartitionSet._Gain, x._TaxaPartitionSet.PartitionList, x._TaxaPartitionSet._ListQuatrets), StepK = x.StepK })), _MaxCumulativeGain = m._MaxCumulativeGain, TaxValue = m.TaxValue, MaximumGainOfTaxValue = m.MaximumGainOfTaxValue, PartitionSet = new PartitionSet(m.PartitionSet._PartitionSetName, m.PartitionSet._Final_Score, m.PartitionSet._IsolatedCount, m.PartitionSet._ViotatedCount, m.PartitionSet._SatisfiedCount, m.PartitionSet._DifferedCount, m.PartitionSet._taxValueForGainCalculation, m.PartitionSet._Gain, m.PartitionSet.PartitionList, m.PartitionSet._ListQuatrets) }; }
public void CalculateGainSummary(PartitionSet p, List <Taxa> _TaxaGainTable) { GainTable Gt = new GainTable(); LoadSet_Of_TaxaWithScore(); LaterPartition(p, this._Set_Of_TaxaWithScore, this.Set_Of_Taxa.Count()); int Step = 0; int _CGain = 0; foreach (Taxa tx in _TaxaGainTable) { _CGain = _CGain + tx._Gain; tx._CumulativeGain = _CGain; tx.StepK = Step; Step++; } if (_TaxaGainTable.Count != 0) { var maximumCGain = _TaxaGainTable.Max(x => x._CumulativeGain); if (maximumCGain != null) { var TotalCount = _TaxaGainTable.Where(x => x._CumulativeGain == maximumCGain).Count(); if (TotalCount != null) { if (TotalCount > 0) { foreach (Taxa tt in _TaxaGainTable) { if (tt._CumulativeGain == maximumCGain) { Gt = new GainTable(); Gt.PartitionSet = tt._TaxaPartitionSet; Gt.TaxValue = tt._Taxa_Value; Gt._MaxCumulativeGain = tt._CumulativeGain; Gt.MaximumGainOfTaxValue = tt._Gain; Gt._TaxaGainSummary = new List <Taxa>(_TaxaGainTable); _GainTableList.Add(Gt); break; } } } } } } }
public void Divide(PartitionSet pPartitionSet, string DummyTaxaCharacter, int Level, List <string> _VALID_TAXA_LIST) { string DummyTaxa = DummyTaxaCharacter + Level.ToString(); Taxa TaxaDummy = new Taxa(); TaxaDummy._Taxa_Value = DummyTaxa; //Adding Dummy Taxa to the Set PA and PB FinalPartionPair PartionPair; List <FinalPartionPair> ListPartionPair = new List <FinalPartionPair>(); foreach (Partition p in pPartitionSet.PartitionList) { PartionPair = new FinalPartionPair(); p.TaxaList.Add(TaxaDummy); PartionPair = SubDivideQuatret(pPartitionSet._ListQuatrets, p, DummyTaxa); PartionPair._Root = p.TaxaList; ListPartionPair.Add(PartionPair); } foreach (FinalPartionPair pair in ListPartionPair) { if (CountValidTaxa(pair._P.TaxaList, _VALID_TAXA_LIST) >= 1 && (pair._Q == null)) { _ListFinalPartionPair.Add(pair); } else if (CountValidTaxa(pair._P.TaxaList, _VALID_TAXA_LIST) >= 3 && (pair._Q != null)) { InputProcessing input = new InputProcessing(pair._Q, pair._P.TaxaList); Bipartition bpA = new Bipartition(input); GainTable GTable = bpA.getFinalGainTable(); Divide(GTable.PartitionSet, DummyTaxaCharacter, Level + 1, _VALID_TAXA_LIST); } else if (CountValidTaxa(pair._P.TaxaList, _VALID_TAXA_LIST) < 3 && (pair._Q != null)) { _ListFinalPartionPair.Add(pair); } } }
public static void PrintGainSummary(GainTable _TaxaGainTable) { StringBuilder sb = new StringBuilder(); sb.AppendLine("======================================================Gain Summary======================================================"); int count = 0; int tableIndex = 1; count = 0; foreach (Taxa tt in _TaxaGainTable._TaxaGainSummary) { if (count == 0) { sb.AppendLine("Table :" + tableIndex.ToString()); sb.AppendLine("------------------------------------------------------------------------------------------------------------------------------------------------------------"); sb.AppendLine(" " + "K" + " " + " " + "Taxon" + " " + " " + "Gain" + " " + " " + "CGain" + " "); sb.AppendLine("-----------------------------------------------------------------------------------------------------------------------------------------------------------"); sb.AppendLine(" " + (tt.StepK + 1).ToString() + " " + " " + tt._Taxa_Value + " " + " " + tt._Gain + " " + " " + tt._CumulativeGain + " "); } else { sb.AppendLine(" " + (tt.StepK + 1).ToString() + " " + " " + tt._Taxa_Value + " " + " " + tt._Gain + " " + " " + tt._CumulativeGain + " "); } count++; } tableIndex++; // System.Console.WriteLine(sb.ToString()); //System.Console.ReadLine(); File.AppendAllText(Constant.OutputFilePath, sb.ToString()); }
public void CalculateConsistancy() { if (File.Exists(Constant.OutputFilePath)) { File.Delete(Constant.OutputFilePath); } DivideAndConquer divideAndConquer = new DivideAndConquer(); InputProcessing input = new InputProcessing(); Bipartition bp = new Bipartition(input); GainTable GainTable = new GainTable(); GainTable = bp.getFinalGainTable(); int loop = 0; ConsistencyDataModel data = new ConsistencyDataModel(); DepthOneTreeNode node; List <DepthOneTreeNode> ListDepthOneTreeNode = new List <DepthOneTreeNode>(); ConsistencyDataModel dataRandom = new ConsistencyDataModel(); DepthOneTreeNode nodeRandom; List <DepthOneTreeNode> ListDepthOneTreeNodeRandom = new List <DepthOneTreeNode>(); if (GainTable != null) { SetFinalGainTableAfterGainCalculation(GainTable); PartitionSet setOfMaxGain = GainTable.PartitionSet; SetALLQuatretInput(setOfMaxGain._ListQuatrets); var vDiffered = setOfMaxGain._ListQuatrets.FindAll(x => x._PartitionStatus == PartitionStatus.Differed); if (vDiffered != null) { SetDifferedQuatretInput(vDiffered.ToList()); } var vIsolated = setOfMaxGain._ListQuatrets.FindAll(x => x._PartitionStatus == PartitionStatus.Isolated); if (vIsolated != null) { SetIsolatedQuatretInput(vIsolated.ToList()); } var vViolated = setOfMaxGain._ListQuatrets.FindAll(x => x._PartitionStatus == PartitionStatus.Viotated); if (vViolated != null) { SetViolatedQuatretInput(vViolated.ToList()); } OutputProcessing.PrintGainSummary(GainTable); OutputProcessing.WriteCountInformationFromMaxGainTable(GainTable); _VALID_TAXA_LIST = input.Get_SetOfTaxa(); divideAndConquer.Divide(GainTable.PartitionSet, DummyTaxaCharacter, 1, _VALID_TAXA_LIST); List <FinalPartionPair> ll = divideAndConquer.getFinalPartionPair(); OutputProcessing.PrintFinalTableOfDivideAndConquerApproach(ll); loop = 0; foreach (FinalPartionPair pair in ll) { ListDepthOneTreeNode = new List <DepthOneTreeNode>(); data = new ConsistencyDataModel(); data._Differed_Quatret = this._DifferedQuatretListAfterGain; data._Isolated_Quatret = this._IsolatedQuatretListAfterGain; data._Violated_Quatret = this._ViolatedQuatretListAfterGain; foreach (Taxa tx in pair._P.TaxaList) { node = new DepthOneTreeNode(); node._Position = loop; node._Taxa_Value = tx._Taxa_Value; ListDepthOneTreeNode.Add(node); } data._DepthOneChain = ListDepthOneTreeNode; _ListConsistencyDataModel.Add(data); loop++; } #region finding Consistancy Status ConsistencyDataModel dmodel = _ListConsistencyDataModel[0]; string OutputHeader = "======================================================Consistancy Calculation======================================================"; #region ISOLATED dmodel._Isolated_Quatret = GetConsistancyStatusOfQuatret(_ListConsistencyDataModel, dmodel._Isolated_Quatret); var vIsoConsistent = dmodel._Isolated_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.Consistent); SetIsolatedQuatretConsistentAfterDevideAndConquer(vIsoConsistent); var vIsoInConsistent = dmodel._Isolated_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.InConsistent); SetIsolatedQuatretInConsistentAfterDevideAndConquer(vIsoInConsistent); OutputProcessing.WriteQuatretConsistancy(dmodel._Isolated_Quatret, PartitionStatus.Isolated, OutputHeader); #endregion #region Violated Quatret dmodel._Violated_Quatret = GetConsistancyStatusOfQuatret(_ListConsistencyDataModel, dmodel._Violated_Quatret); var vViolatedConsistent = dmodel._Violated_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.Consistent); SetViolatedQuatretConsistentAfterDevideAndConquer(vViolatedConsistent); var vViolatedInConsistent = dmodel._Violated_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.InConsistent); SetViolatedQuatretInConsistentAfterDevideAndConquer(vViolatedInConsistent); OutputProcessing.WriteQuatretConsistancy(dmodel._Violated_Quatret, PartitionStatus.Viotated, string.Empty); #endregion #region Differed Quatret dmodel._Differed_Quatret = GetConsistancyStatusOfQuatret(_ListConsistencyDataModel, dmodel._Differed_Quatret); var vDiffConsistent = dmodel._Differed_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.Consistent); SetDifferedQuatretConsistentAfterDevideAndConquer(vDiffConsistent); var vDiffInConsistent = dmodel._Differed_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.InConsistent); SetDifferedQuatretInConsistentAfterDevideAndConquer(vDiffInConsistent); OutputProcessing.WriteQuatretConsistancy(dmodel._Differed_Quatret, PartitionStatus.Differed, string.Empty); #endregion #endregion #region Random Technique var listOfTaxaRandom = input.getSetOfTaxa(); divideAndConquer.generateDepthOneTreeRandomly(listOfTaxaRandom, DummyTaxaCharacter, 1, _VALID_TAXA_LIST, this._ALLQuatretListAfterGain); List <FinalPartionPair> llRandom = divideAndConquer.getFinalPartionPairRandom(); //OutputProcessing.PrintDepthOneTreeRandom(llRandom, "Random Depth One Tree"); loop = 0; foreach (FinalPartionPair pair in llRandom) { ListDepthOneTreeNodeRandom = new List <DepthOneTreeNode>(); dataRandom = new ConsistencyDataModel(); dataRandom._Differed_Quatret = this._DifferedQuatretListAfterGain; dataRandom._Isolated_Quatret = this._IsolatedQuatretListAfterGain; dataRandom._Violated_Quatret = this._ViolatedQuatretListAfterGain; dataRandom._ALL_Quatret = this._ALLQuatretListAfterGain; foreach (Taxa tx in pair._Root) { nodeRandom = new DepthOneTreeNode(); nodeRandom._Position = loop; nodeRandom._Taxa_Value = tx._Taxa_Value; ListDepthOneTreeNodeRandom.Add(nodeRandom); } dataRandom._DepthOneChain = ListDepthOneTreeNodeRandom; _ListConsistencyDataModelRandom.Add(dataRandom); loop++; } ConsistencyDataModel dmodelRandom = _ListConsistencyDataModelRandom[0]; //string OutputHeaderRandom = "======================================================Consistancy Calculation(Random Technique)======================================================"; dmodelRandom._ALL_Quatret = GetConsistancyStatusOfQuatret(_ListConsistencyDataModelRandom, dmodelRandom._ALL_Quatret); var vConsistentRandom = dmodelRandom._ALL_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.Consistent); SetRandomQuatretConsistentAfterDevideAndConquer(vConsistentRandom); var vInConsistentRandom = dmodelRandom._ALL_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.InConsistent); SetRandomQuatretInConsistentAfterDevideAndConquer(vInConsistentRandom); //OutputProcessing.WriteQuatretConsistancy(dmodelRandom._ALL_Quatret, PartitionStatus.None, OutputHeaderRandom); #endregion } }
public void StepByStep() { #region Step:1 Find Depth One Chain and Consistancy Calculation ConsistancyCalculation obj = new ConsistancyCalculation(); obj.CalculateConsistancy(); // Getting the GainTable After Initial Bipartition GainTable GB = obj.getFinalGainTableAfterGainCalculation(); // Getting Partition with maximum Gained Taxa PartitionSet SetP = GB.PartitionSet; // Getting Differred, Isolated And Violated Quatret Before Devide and Conquer List <Quartet> _DifferedQuatretListAfterGain = obj.getDifferedQuatretListAfterGain(); List <Quartet> _IsolatedQuatretListAfterGain = obj.getIsolatedQuatretListAfterGain(); List <Quartet> _ViolatedQuatretListAfterGain = obj.getViolatedQuatretListAfterGain(); // Getting All QUatret List <Quartet> _ALLQuatretListAfterGain = obj.getALLQuatretListAfterGain(); // Getting Depth One Chain After Devide And Conquer List <ConsistencyDataModel> _ListConsistencyDataModel = obj.getListConsistencyDataModel(); List <ConsistencyDataModel> _ListConsistencyDataModelRandom = obj.getListConsistencyDataModelRandom(); List <ConsistencyDataModel> _ListConsistencyDataModelRandomAfterDuplication = new List <ConsistencyDataModel>(); #region OriginalDepthOneTree for Duplication with Random Technique List <ConsistencyDataModel> _ListConsistencyDataModelOriginal = new List <ConsistencyDataModel>(); List <ConsistencyDataModel> _ListConsistencyDataModelOriginalAfterRandomDuplication = new List <ConsistencyDataModel>(); ConsistencyDataModel Cmodel; Quartet CQuatet; List <Quartet> CListQuatret; List <DepthOneTreeNode> CListDepthOneTreeNode = new List <DepthOneTreeNode>(); DepthOneTreeNode CDepthOneTreeNode; foreach (ConsistencyDataModel model in _ListConsistencyDataModel) { Cmodel = new ConsistencyDataModel(); if (_ListConsistencyDataModelRandom[0]._ALL_Quatret != null) { if (_ListConsistencyDataModelRandom[0]._ALL_Quatret.Count != 0) { CListQuatret = new List <Quartet>(); foreach (Quartet q in _ListConsistencyDataModelRandom[0]._ALL_Quatret) { CQuatet = new Quartet() { _First_Taxa_Value = q._Fourth_Taxa_Value, _Second_Taxa_Value = q._Third_Taxa_Value, _Third_Taxa_Value = q._Second_Taxa_Value, _Fourth_Taxa_Value = q._First_Taxa_Value, _Quartet_Name = q._Quartet_Name, _Quartet_Input = q._Quartet_Input, _Quartet_LeftPart = q._Quartet_LeftPart, _Quartet_LeftPartReverse = q._Quartet_LeftPartReverse, _Quartet_RightPart = q._Quartet_RightPart, _Quartet_RightPartReverse = q._Quartet_RightPartReverse, _isDistinct = q._isDistinct, _Frequency = q._Frequency, _ConsistancyStatus = ConsistencyStatus.None, _PartitionStatus = q._PartitionStatus }; CListQuatret.Add(CQuatet); } Cmodel._ALL_Quatret = new List <Quartet>(CListQuatret); } } CListQuatret = new List <Quartet>(); foreach (Quartet q in model._Isolated_Quatret) { CQuatet = new Quartet() { _First_Taxa_Value = q._Fourth_Taxa_Value, _Second_Taxa_Value = q._Third_Taxa_Value, _Third_Taxa_Value = q._Second_Taxa_Value, _Fourth_Taxa_Value = q._First_Taxa_Value, _Quartet_Name = q._Quartet_Name, _Quartet_Input = q._Quartet_Input, _Quartet_LeftPart = q._Quartet_LeftPart, _Quartet_LeftPartReverse = q._Quartet_LeftPartReverse, _Quartet_RightPart = q._Quartet_RightPart, _Quartet_RightPartReverse = q._Quartet_RightPartReverse, _isDistinct = q._isDistinct, _Frequency = q._Frequency, _ConsistancyStatus = q._ConsistancyStatus, _PartitionStatus = q._PartitionStatus }; CListQuatret.Add(CQuatet); } Cmodel._Isolated_Quatret = new List <Quartet>(CListQuatret); CListQuatret = new List <Quartet>(); foreach (Quartet q in model._Violated_Quatret) { CQuatet = new Quartet() { _First_Taxa_Value = q._Fourth_Taxa_Value, _Second_Taxa_Value = q._Third_Taxa_Value, _Third_Taxa_Value = q._Second_Taxa_Value, _Fourth_Taxa_Value = q._First_Taxa_Value, _Quartet_Name = q._Quartet_Name, _Quartet_Input = q._Quartet_Input, _Quartet_LeftPart = q._Quartet_LeftPart, _Quartet_LeftPartReverse = q._Quartet_LeftPartReverse, _Quartet_RightPart = q._Quartet_RightPart, _Quartet_RightPartReverse = q._Quartet_RightPartReverse, _isDistinct = q._isDistinct, _Frequency = q._Frequency, _ConsistancyStatus = q._ConsistancyStatus, _PartitionStatus = q._PartitionStatus }; CListQuatret.Add(CQuatet); } Cmodel._Violated_Quatret = new List <Quartet>(CListQuatret); CListQuatret = new List <Quartet>(); foreach (Quartet q in model._Differed_Quatret) { CQuatet = new Quartet() { _First_Taxa_Value = q._Fourth_Taxa_Value, _Second_Taxa_Value = q._Third_Taxa_Value, _Third_Taxa_Value = q._Second_Taxa_Value, _Fourth_Taxa_Value = q._First_Taxa_Value, _Quartet_Name = q._Quartet_Name, _Quartet_Input = q._Quartet_Input, _Quartet_LeftPart = q._Quartet_LeftPart, _Quartet_LeftPartReverse = q._Quartet_LeftPartReverse, _Quartet_RightPart = q._Quartet_RightPart, _Quartet_RightPartReverse = q._Quartet_RightPartReverse, _isDistinct = q._isDistinct, _Frequency = q._Frequency, _ConsistancyStatus = q._ConsistancyStatus, _PartitionStatus = q._PartitionStatus }; CListQuatret.Add(CQuatet); } Cmodel._Differed_Quatret = new List <Quartet>(CListQuatret); CListDepthOneTreeNode = new List <DepthOneTreeNode>(); foreach (DepthOneTreeNode node in model._DepthOneChain) { CDepthOneTreeNode = new DepthOneTreeNode(); CDepthOneTreeNode._Position = node._Position; CDepthOneTreeNode._Taxa_Value = node._Taxa_Value; CListDepthOneTreeNode.Add(CDepthOneTreeNode); } Cmodel._DepthOneChain = CListDepthOneTreeNode; _ListConsistencyDataModelOriginal.Add(Cmodel); } #endregion // Getting Consistent and Inconsistent Quatret List <Quartet> _DifferredConsistentAfterDevideAndConquer = obj.getDifferedQuatretConsistentAfterDevideAndConquer(); List <Quartet> _IsolatedConsistentAfterDevideAndConquer = obj.getIsolatedQuatretConsistentAfterDevideAndConquer(); List <Quartet> _ViolatedConsistentAfterDevideAndConquer = obj.getViolatedQuatretConsistentAfterDevideAndConquer(); List <Quartet> _IsolatedInConsistentAfterDevideAndConquer = obj.getIsolatedQuatretInConsistentAfterDevideAndConquer(); List <Quartet> _DifferredInConsistentAfterDevideAndConquer = obj.getDifferedQuatretInConsistentAfterDevideAndConquer(); List <Quartet> _ViolatedInConsistentAfterDevideAndConquer = obj.getViolatedQuatretInConsistentAfterDevideAndConquer(); List <Quartet> _RandomConsistentAfterDevideAndConquer = obj.getRandomQuatretConsistentAfterDevideAndConquer(); List <Quartet> _RandomInConsistentAfterDevideAndConquer = obj.getRandomQuatretInConsistentAfterDevideAndConquer(); #endregion #region Step:2 Get The Input (Isolated ,Violated, Differred ) var vAllInConsistentQuatret = _IsolatedInConsistentAfterDevideAndConquer.Concat(_DifferredInConsistentAfterDevideAndConquer).Concat(_ViolatedInConsistentAfterDevideAndConquer); OutputProcessing.WriteListOfQuatretInConsistancy(vAllInConsistentQuatret.ToList()); #endregion #region Step:3 Calculate Super Split List using All Inconsistent Quatret SplitCalculation objSplitCalculation = new SplitCalculation(); SplitModel SuperSplit = new SplitModel(); if (vAllInConsistentQuatret.ToList().Count != 0) { SuperSplit = objSplitCalculation.CalculateSuperSplit(vAllInConsistentQuatret.ToList()); OutputProcessing.WriteSplitValues(SuperSplit, "Super Split"); } #endregion #region Step:4 Calculate HyBrid DepthOne List List <List <string> > HyBridDepthOneList = new List <List <string> >(); if (SuperSplit._LeftPartOfSplit.Count < SuperSplit._RightPartOfSplit.Count) { SuperSplit._RightPartOfSplit = new List <string>(); } else if (SuperSplit._RightPartOfSplit.Count < SuperSplit._LeftPartOfSplit.Count) { SuperSplit._LeftPartOfSplit = new List <string>(); } else if (SuperSplit._RightPartOfSplit.Count == SuperSplit._LeftPartOfSplit.Count) { SuperSplit._LeftPartOfSplit = new List <string>(); } HyBridDepthOneList = objSplitCalculation.getHyBridDepthOneTaxaListWithoutRemovingCommonTaxa(SetP, SuperSplit); List <string> LeftMost = HyBridDepthOneList[0]; List <string> RightMost = HyBridDepthOneList[1]; List <DepthOneTreeNode> DepthOneTreeNodeLeft = new List <DepthOneTreeNode>(); List <DepthOneTreeNode> DepthOneTreeNodeRight = new List <DepthOneTreeNode>(); DepthOneTreeNode __node; int pos = 0; foreach (string tx in LeftMost) { __node = new DepthOneTreeNode(); __node._Position = pos; __node._Taxa_Value = tx; pos++; DepthOneTreeNodeLeft.Add(__node); } pos = 0; foreach (string tx in RightMost) { __node = new DepthOneTreeNode(); __node._Position = pos; __node._Taxa_Value = tx; pos++; DepthOneTreeNodeRight.Add(__node); } _ListConsistencyDataModel.Insert(0, new ConsistencyDataModel() { _Isolated_Quatret = _ListConsistencyDataModel[0]._Isolated_Quatret, _Differed_Quatret = _ListConsistencyDataModel[0]._Differed_Quatret, _Violated_Quatret = _ListConsistencyDataModel[0]._Violated_Quatret, _DepthOneChain = new List <DepthOneTreeNode>(DepthOneTreeNodeLeft) }); _ListConsistencyDataModel.Add(new ConsistencyDataModel() { _Isolated_Quatret = _ListConsistencyDataModel[0]._Isolated_Quatret, _Differed_Quatret = _ListConsistencyDataModel[0]._Differed_Quatret, _Violated_Quatret = _ListConsistencyDataModel[0]._Violated_Quatret, _DepthOneChain = new List <DepthOneTreeNode>(DepthOneTreeNodeRight) }); OutputProcessing.PrintHyBridDepthOneTree(_ListConsistencyDataModel); OutputProcessing.GenerateInputForHyBridDepthOneTree(_ListConsistencyDataModel); OutputProcessing.GenerateCountOfDuplicateTaxa(DepthOneTreeNodeLeft, DepthOneTreeNodeRight); #endregion #region Step:5 Calculate Random DepthOne Chain string OutputHeaderRandom = "===============================================Consistancy Calculation(Randomized Technique)======================================================"; OutputProcessing.PrintHyBridDepthOneTree(_ListConsistencyDataModelRandom, "Randomized Divide and Conquer Approach with Split Analysis Technique", "====================================Depth One Element with Randomized Technique======================"); OutputProcessing.WriteQuatretConsistancy(_ListConsistencyDataModelRandom[0]._ALL_Quatret, PartitionStatus.None, OutputHeaderRandom); List <Quartet> all_InconsistentQuatret_for_Random = new List <Quartet>(); var vInConsistent_for_Random = _ListConsistencyDataModelRandom[0]._ALL_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.InConsistent); foreach (Quartet q in vInConsistent_for_Random) { CQuatet = new Quartet() { _First_Taxa_Value = q._Fourth_Taxa_Value, _Second_Taxa_Value = q._Third_Taxa_Value, _Third_Taxa_Value = q._Second_Taxa_Value, _Fourth_Taxa_Value = q._First_Taxa_Value, _Quartet_Name = q._Quartet_Name, _Quartet_Input = q._Quartet_Input, _Quartet_LeftPart = q._Quartet_LeftPart, _Quartet_LeftPartReverse = q._Quartet_LeftPartReverse, _Quartet_RightPart = q._Quartet_RightPart, _Quartet_RightPartReverse = q._Quartet_RightPartReverse, _isDistinct = q._isDistinct, _Frequency = q._Frequency, _ConsistancyStatus = q._ConsistancyStatus, _PartitionStatus = q._PartitionStatus }; all_InconsistentQuatret_for_Random.Add(CQuatet); } #endregion #region Step:6 Calculate Duplication For Random DepthOne Chain objSplitCalculation.CalculateRandomDepthOneChainWithRandomizedUnionOperationDuplicationNew(_ListConsistencyDataModelRandom[0]._ALL_Quatret, _ListConsistencyDataModelRandom); _ListConsistencyDataModelRandomAfterDuplication = objSplitCalculation.getListConsistencyDataModelRandomAfterDuplication(); bool isAddedtotheleft = objSplitCalculation.getIsAddedToLeft(); int totalCount = _ListConsistencyDataModelRandomAfterDuplication.Count() - 1; //OutputHeaderRandom = "======================================================Consistancy Calculation(Random Technique Duplication)======================================================"; OutputProcessing.PrintHyBridDepthOneTree(_ListConsistencyDataModelRandomAfterDuplication, "Randomized Depth One Element With Duplicated Taxa"); if (isAddedtotheleft) { OutputProcessing.GenerateCountOfDuplicateTaxaOfRandomDepthTree(_ListConsistencyDataModelRandomAfterDuplication[0]._DepthOneChain, isAddedtotheleft); } else { OutputProcessing.GenerateCountOfDuplicateTaxaOfRandomDepthTree(_ListConsistencyDataModelRandomAfterDuplication[totalCount]._DepthOneChain, isAddedtotheleft); } #endregion #region Step:7 Calculate Super Split for Random DepthOne Chain OutputHeaderRandom = "======================================================Inconsistant Quatrets(Randomized Divide and Conquer Approach)======================================================"; OutputProcessing.WriteQuatretConsistancy(all_InconsistentQuatret_for_Random, PartitionStatus.None, OutputHeaderRandom); objSplitCalculation = new SplitCalculation(); SuperSplit = new SplitModel(); if (vAllInConsistentQuatret.ToList().Count != 0) { SuperSplit = objSplitCalculation.CalculateSuperSplit(all_InconsistentQuatret_for_Random.ToList()); OutputProcessing.WriteSplitValues(SuperSplit, "Super Split For Randomized Depth One Chain"); } // Calculate Random DepthOne Chain With SuperSplit List <List <string> > HyBridDepthOneListRandom = new List <List <string> >(); if (SuperSplit._LeftPartOfSplit.Count < SuperSplit._RightPartOfSplit.Count) { SuperSplit._RightPartOfSplit = new List <string>(); } else if (SuperSplit._RightPartOfSplit.Count < SuperSplit._LeftPartOfSplit.Count) { SuperSplit._LeftPartOfSplit = new List <string>(); } else if (SuperSplit._RightPartOfSplit.Count == SuperSplit._LeftPartOfSplit.Count) { SuperSplit._LeftPartOfSplit = new List <string>(); } HyBridDepthOneListRandom = objSplitCalculation.getHyBridDepthOneTaxaListWithoutRemovingCommonTaxa(null, SuperSplit); List <string> LeftMostRandom = HyBridDepthOneListRandom[0]; List <string> RightMostRandom = HyBridDepthOneListRandom[1]; List <DepthOneTreeNode> DepthOneTreeNodeLeftRandom = new List <DepthOneTreeNode>(); List <DepthOneTreeNode> DepthOneTreeNodeRightRandom = new List <DepthOneTreeNode>(); DepthOneTreeNode __nodeRandom; pos = 0; foreach (string tx in LeftMostRandom) { __nodeRandom = new DepthOneTreeNode(); __nodeRandom._Position = pos; __nodeRandom._Taxa_Value = tx; pos++; DepthOneTreeNodeLeftRandom.Add(__nodeRandom); } pos = 0; foreach (string tx in RightMostRandom) { __nodeRandom = new DepthOneTreeNode(); __nodeRandom._Position = pos; __nodeRandom._Taxa_Value = tx; pos++; DepthOneTreeNodeRightRandom.Add(__nodeRandom); } if (isAddedtotheleft) { _ListConsistencyDataModelRandom.RemoveAt(0); } else { _ListConsistencyDataModelRandom.RemoveAt(_ListConsistencyDataModelRandom.Count - 1); } _ListConsistencyDataModelRandom.Insert(0, new ConsistencyDataModel() { _Isolated_Quatret = _ListConsistencyDataModelRandom[0]._Isolated_Quatret, _Differed_Quatret = _ListConsistencyDataModelRandom[0]._Differed_Quatret, _Violated_Quatret = _ListConsistencyDataModelRandom[0]._Violated_Quatret, _DepthOneChain = new List <DepthOneTreeNode>(DepthOneTreeNodeLeftRandom) }); _ListConsistencyDataModelRandom.Add(new ConsistencyDataModel() { _Isolated_Quatret = _ListConsistencyDataModelRandom[0]._Isolated_Quatret, _Differed_Quatret = _ListConsistencyDataModelRandom[0]._Differed_Quatret, _Violated_Quatret = _ListConsistencyDataModelRandom[0]._Violated_Quatret, _DepthOneChain = new List <DepthOneTreeNode>(DepthOneTreeNodeRightRandom) }); OutputProcessing.PrintHyBridDepthOneTree(_ListConsistencyDataModelRandom, "Randomized Depth One Element with Minimum Super-Element"); //OutputProcessing.GenerateInputForHyBridDepthOneTree(_ListConsistencyDataModelRandom); OutputProcessing.GenerateCountOfDuplicateTaxa(DepthOneTreeNodeLeftRandom, DepthOneTreeNodeRightRandom); //------- #endregion #region Step 8: Calculate Duplication for Original Depth One Chain with Random Technique List <Quartet> all_Quatret = new List <Quartet>(); all_Quatret = obj.GetConsistancyStatusOfQuatret(_ListConsistencyDataModelOriginal, _ListConsistencyDataModelOriginal[0]._ALL_Quatret); foreach (ConsistencyDataModel dmodel in _ListConsistencyDataModelOriginal) { dmodel._ALL_Quatret = new List <Quartet>(all_Quatret); } OutputProcessing.PrintHyBridDepthOneTree(_ListConsistencyDataModelOriginal, "Depth One Element from Bipartition Based Divide and Conquer Approach"); ConsistencyDataModel dmodelOriginal = _ListConsistencyDataModelOriginal[0]; OutputHeaderRandom = string.Empty; var vConsistentOriginal = dmodelOriginal._ALL_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.Consistent); var vInConsistentOriginal = dmodelOriginal._ALL_Quatret.FindAll(x => x._ConsistancyStatus == ConsistencyStatus.InConsistent); objSplitCalculation.CalculateRandomDepthOneChainWithRandomizedUnionOperationDuplicationNew(vInConsistentOriginal, _ListConsistencyDataModelOriginal); _ListConsistencyDataModelOriginalAfterRandomDuplication = objSplitCalculation.getListConsistencyDataModelRandomAfterDuplication(); isAddedtotheleft = objSplitCalculation.getIsAddedToLeft(); totalCount = _ListConsistencyDataModelOriginalAfterRandomDuplication.Count() - 1; OutputProcessing.WriteQuatretConsistancy(dmodelOriginal._ALL_Quatret, PartitionStatus.None, OutputHeaderRandom); OutputProcessing.PrintHyBridDepthOneTree(_ListConsistencyDataModelOriginalAfterRandomDuplication, "Depth One Element with Randomized Duplication"); if (isAddedtotheleft) { OutputProcessing.GenerateCountOfDuplicateTaxaOfRandomDepthTree(_ListConsistencyDataModelOriginalAfterRandomDuplication[0]._DepthOneChain, isAddedtotheleft); } else { OutputProcessing.GenerateCountOfDuplicateTaxaOfRandomDepthTree(_ListConsistencyDataModelOriginalAfterRandomDuplication[totalCount]._DepthOneChain, isAddedtotheleft); } #endregion }
public static void WriteCountInformationFromMaxGainTable(GainTable _TaxaGainTable) { PartitionSet PartitionSets = _TaxaGainTable.PartitionSet; StringBuilder sb = new StringBuilder(); sb.AppendLine("----------------Set Of Quatret(" + PartitionSets._ListQuatrets.Count.ToString() + ")-----------------"); string SetOfQuatrets = "Q={"; foreach (Quartet tx in PartitionSets._ListQuatrets) { SetOfQuatrets = SetOfQuatrets + "((" + tx._First_Taxa_Value.ToString() + "," + tx._Second_Taxa_Value.ToString() + "),(" + tx._Third_Taxa_Value.ToString() + "," + tx._Fourth_Taxa_Value.ToString() + "));"; } SetOfQuatrets = SetOfQuatrets.Substring(0, SetOfQuatrets.Length - 1); sb.AppendLine(SetOfQuatrets + "}"); sb.AppendLine("----------------After Bipartition-----------------"); string InitialBiPart = string.Empty; int ii = 0; PartitionSet set = PartitionSets; foreach (Partition part in set.PartitionList) { InitialBiPart = InitialBiPart + "P" + part._PartitionName + "={"; foreach (Taxa t in part.TaxaList) { InitialBiPart = InitialBiPart + t._Taxa_Value.ToString() + ","; } InitialBiPart = InitialBiPart.Substring(0, InitialBiPart.Length - 1); InitialBiPart = InitialBiPart + "}"; sb.AppendLine(InitialBiPart); InitialBiPart = string.Empty; } sb.AppendLine("----------------Set Of Satisfied-----------------"); SetOfQuatrets = "Satisfied: (" + set._SatisfiedCount.ToString() + ")={"; foreach (Quartet tx in set._ListQuatrets) { if (tx._PartitionStatus == PartitionStatus.Satisfied) { SetOfQuatrets = SetOfQuatrets + "((" + tx._First_Taxa_Value.ToString() + "," + tx._Second_Taxa_Value.ToString() + "),(" + tx._Third_Taxa_Value.ToString() + "," + tx._Fourth_Taxa_Value.ToString() + "));"; } } SetOfQuatrets = SetOfQuatrets.Substring(0, SetOfQuatrets.Length - 1); if (set._SatisfiedCount != 0) { sb.AppendLine(SetOfQuatrets + "}"); } else { sb.AppendLine(SetOfQuatrets); } sb.AppendLine("----------------Set Of Violated-----------------"); SetOfQuatrets = "Viotated : (" + set._ViotatedCount.ToString() + ")={"; foreach (Quartet tx in set._ListQuatrets) { if (tx._PartitionStatus == PartitionStatus.Viotated) { SetOfQuatrets = SetOfQuatrets + "((" + tx._First_Taxa_Value.ToString() + "," + tx._Second_Taxa_Value.ToString() + "),(" + tx._Third_Taxa_Value.ToString() + "," + tx._Fourth_Taxa_Value.ToString() + "));"; } } SetOfQuatrets = SetOfQuatrets.Substring(0, SetOfQuatrets.Length - 1); if (set._ViotatedCount != 0) { sb.AppendLine(SetOfQuatrets + "}"); } else { sb.AppendLine(SetOfQuatrets); } sb.AppendLine("----------------Set Of Differed-----------------"); SetOfQuatrets = "Differed : (" + set._DifferedCount.ToString() + ")={"; foreach (Quartet tx in set._ListQuatrets) { if (tx._PartitionStatus == PartitionStatus.Differed) { SetOfQuatrets = SetOfQuatrets + "((" + tx._First_Taxa_Value.ToString() + "," + tx._Second_Taxa_Value.ToString() + "),(" + tx._Third_Taxa_Value.ToString() + "," + tx._Fourth_Taxa_Value.ToString() + "));"; } } SetOfQuatrets = SetOfQuatrets.Substring(0, SetOfQuatrets.Length - 1); if (set._DifferedCount != 0) { sb.AppendLine(SetOfQuatrets + "}"); } else { sb.AppendLine(SetOfQuatrets); } sb.AppendLine("----------------Set Of Isolated-----------------"); SetOfQuatrets = "Isolated : (" + set._IsolatedCount.ToString() + ")={"; foreach (Quartet tx in set._ListQuatrets) { if (tx._PartitionStatus == PartitionStatus.Isolated) { SetOfQuatrets = SetOfQuatrets + "((" + tx._First_Taxa_Value.ToString() + "," + tx._Second_Taxa_Value.ToString() + "),(" + tx._Third_Taxa_Value.ToString() + "," + tx._Fourth_Taxa_Value.ToString() + "));"; } } SetOfQuatrets = SetOfQuatrets.Substring(0, SetOfQuatrets.Length - 1); if (set._IsolatedCount != 0) { sb.AppendLine(SetOfQuatrets + "}"); } else { sb.AppendLine(SetOfQuatrets); } ii++; File.AppendAllText(Constant.OutputFilePath, sb.ToString()); }