public bool isSatisfied(Quartet q, PartitionSet p) { string t1 = string.Empty; string t2 = string.Empty; string t3 = string.Empty; string t4 = string.Empty; t1 = q._First_Taxa_Value; t2 = q._Second_Taxa_Value; t3 = q._Third_Taxa_Value; t4 = q._Fourth_Taxa_Value; Partition PartitionA = p.PartitionList[0]; Partition PartitionB = p.PartitionList[1]; if (isInSamePart(PartitionA, t1, t2) && isInSamePart(PartitionB, t3, t4)) { return(true); } else if (isInSamePart(PartitionB, t1, t2) && isInSamePart(PartitionA, t3, t4)) { return(true); } //if (isInSamePart(PartitionA, t2, t1) && isInSamePart(PartitionB, t4, t3)) //{ // return true; //} //else if (isInSamePart(PartitionB, t2, t1) && isInSamePart(PartitionA, t4, t3)) //{ // return true; //} return(false); }
public bool isViolated(Quartet q, PartitionSet p) { string t1 = string.Empty; string t2 = string.Empty; string t3 = string.Empty; string t4 = string.Empty; t1 = q._First_Taxa_Value; t2 = q._Second_Taxa_Value; t3 = q._Third_Taxa_Value; t4 = q._Fourth_Taxa_Value; Partition PartitionA = p.PartitionList[0]; Partition PartitionB = p.PartitionList[1]; if ((isInPart(PartitionA, t1) && isInPart(PartitionB, t2)) || (isInPart(PartitionA, t2) && isInPart(PartitionB, t1))) { if ((isInPart(PartitionA, t2) && isInPart(PartitionB, t3)) || (isInPart(PartitionA, t3) && isInPart(PartitionB, t2))) { return(true); } } return(false); }
public List <Quartet> Get_Set_Of_Sorted_Distinct_Quartets_Original() { List <Quartet> Set_Of_Sorted_Distinct_Quartets_Original = new List <Quartet>(); foreach (Quartet q in Set_Of_Sorted_Distinct_Quartets) { Quartet qq = new Quartet(); qq._DuplicateQuatrets = q._DuplicateQuatrets; qq._First_Taxa_Value = q._First_Taxa_Value; qq._Second_Taxa_Value = q._Second_Taxa_Value; qq._Third_Taxa_Value = q._Third_Taxa_Value; qq._Fourth_Taxa_Value = q._Fourth_Taxa_Value; qq._Quartet_Name = q._Quartet_Name; qq._Quartet_Input = q._Quartet_Input; qq._Quartet_LeftPart = q._Quartet_LeftPart; qq._Quartet_LeftPartReverse = q._Quartet_LeftPartReverse; qq._Quartet_RightPart = q._Quartet_RightPart; qq._Quartet_RightPartReverse = q._Quartet_RightPartReverse; qq._isDistinct = q._isDistinct; qq._Frequency = q._Frequency; qq._DuplicateQuatrets = q._DuplicateQuatrets; qq._PartitionStatus = PartitionStatus.None; Set_Of_Sorted_Distinct_Quartets_Original.Add(qq); } return(Set_Of_Sorted_Distinct_Quartets_Original); }
public void Test_CompareTo_Greater() { var quadOne = new Quartet("9.6.3.1"); var quadTwo = new Quartet("12.3.4.5"); Assert.IsTrue(quadOne.CompareTo(quadTwo) < 0); Assert.IsTrue(quadTwo.CompareTo(quadOne) > 0); }
/// <summary> /// Checks whether the detected software is older than the newest known software. /// </summary> /// <param name="detected">the corresponding detected software</param> /// <returns>Returns true, if the detected software version is older /// than the newest software version, thus needing an update. /// Returns false, if no update is necessary.</returns> public virtual bool needsUpdate(DetectedSoftware detected) { // Simple version string comparison may not be enough, so use the // parsed version numbers instead. Quartet verDetected = new Quartet(detected.displayVersion); Quartet verNewest = new Quartet(info().newestVersion); return(verDetected < verNewest); }
public JsonResult Add(Quartet.Entities.Commands.AddTask command) { var commandServiceClient = _clientFactory.GetCommandServiceClient(); command.TaskId = Guid.NewGuid(); command.TaskType = TaskType.Consultant; if (command.CustomerId.HasValue) { command.TaskType = TaskType.Customer; } if (command.DueDateUtc != null) { command.DueDateUtc = command.DueDateUtc.Value.ToUniversalTime(); } if (String.IsNullOrEmpty(command.Title)) { var result = new { Result = "Error", Message = Resources.GetString("REMINDERLIST_ACTION_TITLEISREQUIRED") }; var jsonResult = JsonConvert.SerializeObject(result); return Json(jsonResult, JsonRequestBehavior.AllowGet); } try { commandServiceClient.Execute(command); } catch (Exception exception) { var result = new { Result = "Error", Message = exception.Message }; var jsonResult = JsonConvert.SerializeObject(result); return Json(jsonResult, JsonRequestBehavior.AllowGet); } var successResult = new { Result = "Success", Message = Resources.GetString("REMINDERLIST_ADDSUCCESS"), TaskId = command.TaskId, TaskType = command.TaskType.ToString() }; var resultJson = JsonConvert.SerializeObject(successResult); return Json(resultJson, JsonRequestBehavior.AllowGet); }
public void Test_constructor_nonNumeric() { // constructor with parameter should set only numeric parts var four = new Quartet("12.3b.foo7.8c"); Assert.AreEqual <uint>(12, four.major); Assert.AreEqual <uint>(0, four.minor); Assert.AreEqual <uint>(0, four.patch); Assert.AreEqual <uint>(0, four.build); }
public Quartet Reverse(Quartet q) { Quartet Right = new Quartet(); Right._First_Taxa_Value = q._Third_Taxa_Value; Right._Second_Taxa_Value = q._Fourth_Taxa_Value; Right._Third_Taxa_Value = q._First_Taxa_Value; Right._Fourth_Taxa_Value = q._Second_Taxa_Value; return(Right); }
public void Test_operatorLess() { var quadOne = new Quartet("9.6.3.1"); var quadTwo = new Quartet("12.3.4.5"); var quadThree = new Quartet("12.3.4.5"); Assert.IsTrue(quadOne < quadTwo); Assert.IsFalse(quadTwo < quadOne); Assert.IsFalse(quadTwo < quadThree); Assert.IsFalse(quadThree < quadTwo); }
public void Test_CompareTo_Equal() { var quadOne = new Quartet("12.3.4.56"); var quadTwo = new Quartet("12.3.4.56"); Assert.AreEqual(0, quadOne.CompareTo(quadTwo)); Assert.AreEqual(0, quadTwo.CompareTo(quadOne)); // self comparison Assert.AreEqual(0, quadOne.CompareTo(quadOne)); Assert.AreEqual(0, quadTwo.CompareTo(quadTwo)); }
public void Test_operatorGreater() { var quadOne = new Quartet("9.6.3.1"); var quadTwo = new Quartet("12.3.4.5"); var quadThree = new Quartet("12.3.4.5"); Assert.IsFalse(quadOne > quadTwo); Assert.IsTrue(quadTwo > quadOne); Assert.IsFalse(quadTwo > quadThree); Assert.IsFalse(quadThree > quadTwo); }
public void Test_Equals() { var quadOne = new Quartet("12.3.4.56"); var quadTwo = new Quartet("12.3.4.56"); // two instances should be equal Assert.IsTrue(quadOne.Equals(quadTwo)); Assert.IsTrue(quadTwo.Equals(quadOne)); // self equality Assert.IsTrue(quadOne.Equals(quadOne)); Assert.IsTrue(quadTwo.Equals(quadTwo)); }
public List <SplitModel> getSplitArrays(Quartet q, SplitModel model) { List <SplitModel> list = new List <SplitModel>(); Quartet Left = q; Quartet Right = Reverse(q); list.Add(getSplitModelAfterCalculation(Left, model)); list.Add(getSplitModelAfterCalculation(Right, model)); return(list); }
public List <Quartet> GetConsistancyStatusOfQuatret(List <ConsistencyDataModel> _DepthOneChain, List <Quartet> input) { Quartet dummyQuatret; foreach (Quartet q in input) { q._ConsistancyStatus = ConsistencyStatus.None; q._ConsistancyStatus = CheckForInConsistency(_DepthOneChain, q); if (q._ConsistancyStatus == ConsistencyStatus.InConsistent) { dummyQuatret = new Quartet() { _First_Taxa_Value = q._Third_Taxa_Value, _Second_Taxa_Value = q._Fourth_Taxa_Value, _Third_Taxa_Value = q._First_Taxa_Value, _Fourth_Taxa_Value = q._Second_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 }; q._ConsistancyStatus = CheckForInConsistency(_DepthOneChain, dummyQuatret); } } return(new List <Quartet>(input.Select(m => new Quartet() { _First_Taxa_Value = m._First_Taxa_Value, _Second_Taxa_Value = m._Second_Taxa_Value, _Third_Taxa_Value = m._Third_Taxa_Value, _Fourth_Taxa_Value = m._Fourth_Taxa_Value, _Quartet_Name = m._Quartet_Name, _Quartet_Input = m._Quartet_Input, _Quartet_LeftPart = m._Quartet_LeftPart, _Quartet_LeftPartReverse = m._Quartet_LeftPartReverse, _Quartet_RightPart = m._Quartet_RightPart, _Quartet_RightPartReverse = m._Quartet_RightPartReverse, _isDistinct = m._isDistinct, _Frequency = m._Frequency, _ConsistancyStatus = m._ConsistancyStatus, _PartitionStatus = m._PartitionStatus }))); }
public void Test_constructor() { // default constructor should set 0.0.0.0 var three = new Quartet(); Assert.AreEqual <uint>(0, three.major); Assert.AreEqual <uint>(0, three.minor); Assert.AreEqual <uint>(0, three.patch); Assert.AreEqual <uint>(0, three.build); // constructor with parameter should set version numbers three = new Quartet("12.345.67.8"); Assert.AreEqual <uint>(12, three.major); Assert.AreEqual <uint>(345, three.minor); Assert.AreEqual <uint>(67, three.patch); Assert.AreEqual <uint>(8, three.build); }
public List <Quartet> readInconsistentQuatret(string path) { List <Quartet> Set_Of_Quartets = new List <Quartet>(); Quartet quartet; int counter = 0; string line; int QuartetName = 0; System.IO.StreamReader file = new System.IO.StreamReader(path); while ((line = file.ReadLine()) != null) { if (!string.IsNullOrEmpty(line.Trim()) && line.Trim().Count() != 0) { foreach (string l in line.Split(';')) { if (l.Contains(",")) { if (l.Split(',').Count() == 4) { quartet = new Quartet(); quartet._First_Taxa_Value = Helper.getFirstTaxaValue(l.Split(',')[0]); quartet._Second_Taxa_Value = Helper.getSecondTaxaValue(l.Split(',')[1]); quartet._Third_Taxa_Value = Helper.getFirstTaxaValue(l.Split(',')[2]); quartet._Fourth_Taxa_Value = Helper.getSecondTaxaValue(l.Split(',')[3]); quartet._Quartet_Name = "q" + QuartetName.ToString(); quartet._Quartet_LeftPart = quartet._First_Taxa_Value.ToString() + quartet._Second_Taxa_Value.ToString(); quartet._Quartet_LeftPartReverse = quartet._Second_Taxa_Value.ToString() + quartet._First_Taxa_Value.ToString(); quartet._Quartet_RightPart = quartet._Third_Taxa_Value.ToString() + quartet._Fourth_Taxa_Value.ToString(); quartet._Quartet_RightPartReverse = quartet._Fourth_Taxa_Value.ToString() + quartet._Third_Taxa_Value.ToString(); quartet._Quartet_Input = l + ";"; quartet._PartitionStatus = PartitionStatus.None; counter++; QuartetName++; Set_Of_Quartets.Add(quartet); } } } } } file.Close(); return(Set_Of_Quartets); }
public SplitModel getSplitModelAfterCalculation(Quartet q, SplitModel model) { SplitModel objSplit = new SplitModel(); objSplit._InputQuatret = q; objSplit._LeftPartOfSplit.Add(q._First_Taxa_Value); objSplit._LeftPartOfSplit.Add(q._Second_Taxa_Value); objSplit._LeftPartOfSplit = getUnionOfTaxaList(objSplit._LeftPartOfSplit, model._LeftPartOfSplit); objSplit._RightPartOfSplit.Add(q._Third_Taxa_Value); objSplit._RightPartOfSplit.Add(q._Fourth_Taxa_Value); objSplit._RightPartOfSplit = getUnionOfTaxaList(objSplit._RightPartOfSplit, model._RightPartOfSplit); //Disable Sorting for avoiding memory leakage //objSplit._LeftPartOfSplit.Sort(); //objSplit._RightPartOfSplit.Sort(); objSplit._CountTaxa = objSplit._LeftPartOfSplit.Count() + objSplit._RightPartOfSplit.Count(); return(objSplit); }
/// <summary> /// Gets the latest available version from download site directory listing. /// </summary> /// <returns>Returns latest available version number, if successful. /// Returns null, if an error occurred.</returns> private string getLatestAvailableVersion() { // See https://get.videolan.org/vlc/ for available versions. string htmlCode = null; using (var client = new WebClient()) { try { htmlCode = client.DownloadString("https://get.videolan.org/vlc/"); } catch (Exception ex) { logger.Warn("Exception occurred while checking for available versions of VLC: " + ex.Message); return(null); } client.Dispose(); } // using Regex reVersion = new Regex("\"[0-9]+\\.[0-9]+\\.[0-9]+(\\.[0-9]+)?/\""); var matches = reVersion.Matches(htmlCode); var latestVersion = new Quartet("0.0.0.0"); string latestVersionString = null; foreach (Match m in matches) { if (!m.Success) { continue; } var possibleVersionString = m.Value.Replace("\"", "").Replace("/", ""); var possibleVersion = new Quartet(possibleVersionString); if (string.IsNullOrWhiteSpace(latestVersionString) || possibleVersion > latestVersion) { latestVersion = possibleVersion; latestVersionString = possibleVersionString; } } // foreach return(latestVersionString); }
public void Test_constructor_short() { // constructor with parameter should set missing parts to zero var four = new Quartet("12.3.4"); Assert.AreEqual <uint>(12, four.major); Assert.AreEqual <uint>(3, four.minor); Assert.AreEqual <uint>(4, four.patch); Assert.AreEqual <uint>(0, four.build); four = new Quartet("12.3"); Assert.AreEqual <uint>(12, four.major); Assert.AreEqual <uint>(3, four.minor); Assert.AreEqual <uint>(0, four.patch); Assert.AreEqual <uint>(0, four.build); four = new Quartet("12"); Assert.AreEqual <uint>(12, four.major); Assert.AreEqual <uint>(0, four.minor); Assert.AreEqual <uint>(0, four.patch); Assert.AreEqual <uint>(0, four.build); }
public bool isNotExistInDistinctDuplicate(Quartet findQuatret) { int count = 0; for (int k = 0; k < Set_Of_DistinctDuplicate_Quartets.Count; k++) { var CurrQuatret = Set_Of_DistinctDuplicate_Quartets[k]; if (findQuatret._Quartet_Name != CurrQuatret._Quartet_Name) { if (CheckValue(findQuatret._Quartet_LeftPart, findQuatret._Quartet_RightPart, CurrQuatret._Quartet_LeftPart, CurrQuatret._Quartet_LeftPartReverse, CurrQuatret._Quartet_RightPart, CurrQuatret._Quartet_RightPartReverse)) { count++; } } } if (count == 0) { return(true); } return(false); }
public PartitionStatus getPartitionStatus(Quartet q, PartitionSet p) { if (isSatisfied(q, p)) { return(PartitionStatus.Satisfied); } else if (isDiffered(q, p)) { return(PartitionStatus.Differed); } else if (isIsolated(q, p)) { return(PartitionStatus.Isolated); } else if (isViolated(q, p)) { return(PartitionStatus.Viotated); } else { return(PartitionStatus.Viotated); } }
public void _upToDate_info(ISoftware sw) { Assert.IsNotNull(sw); if (!sw.implementsSearchForNewer()) { Assert.Inconclusive("The check for up to date information was not performed, " + "because this class indicates that it does not implement the searchForNewer() method."); } var info = sw.info(); var newerInfo = sw.searchForNewer(); Assert.IsNotNull(newerInfo, "searchForNewer() returned null!"); int comp = string.Compare(info.newestVersion, newerInfo.newestVersion); var older = new Quartet(info.newestVersion); var newer = new Quartet(newerInfo.newestVersion); if (comp < 0 || older < newer) { Assert.Inconclusive( "Known newest version of " + info.Name + " is " + info.newestVersion + ", but the current newest version is " + newerInfo.newestVersion + "!"); } }
public void Test_Equals_negative() { // two different numbers should not be equal var quadOne = new Quartet("12.3.4.5"); var quadTwo = new Quartet("12.1.2.7"); Assert.IsFalse(quadOne.Equals(quadTwo)); Assert.IsFalse(quadTwo.Equals(quadOne)); quadOne = new Quartet("1.2.3.4"); quadTwo = new Quartet("2.4.6.8"); Assert.IsFalse(quadOne.Equals(quadTwo)); Assert.IsFalse(quadTwo.Equals(quadOne)); quadOne = new Quartet("1.2.3.4"); quadTwo = new Quartet("1.4.6.8"); Assert.IsFalse(quadOne.Equals(quadTwo)); Assert.IsFalse(quadTwo.Equals(quadOne)); quadOne = new Quartet("1.2.3.4"); quadTwo = new Quartet("1.2.3.6"); Assert.IsFalse(quadOne.Equals(quadTwo)); Assert.IsFalse(quadTwo.Equals(quadOne)); }
public ConsistencyStatus CheckForInConsistency(List <ConsistencyDataModel> _DepthOneChain, Quartet input) { ConsistencyStatus status = ConsistencyStatus.InConsistent; int pos1 = 0; int pos2 = 0; int pos3 = 0; int pos4 = 0; input._ConsistancyStatus = ConsistencyStatus.None; pos1 = getPosition(_DepthOneChain, input._First_Taxa_Value); pos2 = getPosition(_DepthOneChain, input._Second_Taxa_Value); pos3 = getPosition(_DepthOneChain, input._Third_Taxa_Value); pos4 = getPosition(_DepthOneChain, input._Fourth_Taxa_Value); if (pos1 != -1 && pos2 != -1 && pos3 != -1 && pos4 != -1) { if (pos1 == pos2 && pos2 < pos3 && pos3 == pos4) { status = ConsistencyStatus.Consistent; } else if (pos1 < pos2 && pos2 < pos3 && pos3 < pos4) { status = ConsistencyStatus.Consistent; } else if (pos1 < pos2 && pos2 < pos4 && pos4 < pos3) { status = ConsistencyStatus.Consistent; } else if (pos1 > pos2 && pos1 < pos3 && pos3 < pos4) { status = ConsistencyStatus.Consistent; } else if (pos1 > pos2 && pos1 < pos4 && pos4 < pos3) { status = ConsistencyStatus.Consistent; } else if (pos1 == pos2 && pos2 < pos4 && pos4 < pos3) { status = ConsistencyStatus.Consistent; } else if (pos1 == pos2 && pos2 < pos3 && pos4 > pos3) { status = ConsistencyStatus.Consistent; } else if (pos1 < pos2 && pos2 < pos3 && pos4 == pos3) { status = ConsistencyStatus.Consistent; } else if (pos1 > pos2 && pos1 < pos3 && pos4 == pos3) { status = ConsistencyStatus.Consistent; } else { status = ConsistencyStatus.InConsistent; } } else { status = ConsistencyStatus.InConsistent; } return(status); }
//private List<ConsistencyDataModel> _DepthOneChainMain = new List<ConsistencyDataModel>(); //private int _DepthOneChainMainCount = 0; public void GetFinalSplitCalculation(List <Quartet> _listOfViolatedQuatret, SplitModel Model, int countTotalInConsistentQuatret) { List <Quartet> listOfViolatedQuatret = new List <Quartet>(_listOfViolatedQuatret); List <SplitModel> Split = new List <SplitModel>(); SplitModel objSplitCurrent; Quartet CurrentInput = new Quartet(); if (listOfViolatedQuatret.Count == 0) { SplitModel objModel = new SplitModel(); objModel._LeftPartOfSplit = Model._LeftPartOfSplit; objModel._RightPartOfSplit = Model._RightPartOfSplit; objModel._LeftPartOfSplit.Sort(); objModel._RightPartOfSplit.Sort(); objModel._CountTaxa = objModel._LeftPartOfSplit.Count() + objModel._RightPartOfSplit.Count(); FinalSplit.Add(objModel); return; } objSplitCurrent = new SplitModel(); CurrentInput = listOfViolatedQuatret[0]; objSplitCurrent._LeftPartOfSplit.Add(CurrentInput._First_Taxa_Value); objSplitCurrent._LeftPartOfSplit.Add(CurrentInput._Second_Taxa_Value); objSplitCurrent._RightPartOfSplit.Add(CurrentInput._Third_Taxa_Value); objSplitCurrent._RightPartOfSplit.Add(CurrentInput._Fourth_Taxa_Value); objSplitCurrent._LeftPartOfSplit.Sort(); objSplitCurrent._RightPartOfSplit.Sort(); objSplitCurrent._CountTaxa = objSplitCurrent._LeftPartOfSplit.Count() + objSplitCurrent._RightPartOfSplit.Count(); List <SplitModel> _splits; if (listOfViolatedQuatret.Count == countTotalInConsistentQuatret) { if (listOfViolatedQuatret.Count >= 1) { listOfViolatedQuatret.RemoveAt(0); } GetFinalSplitCalculation(listOfViolatedQuatret, objSplitCurrent, countTotalInConsistentQuatret); } else { _splits = getSplitArrays(CurrentInput, Model); if (listOfViolatedQuatret.Count >= 1) { listOfViolatedQuatret.RemoveAt(0); } if (_splits[0]._CountTaxa < _splits[1]._CountTaxa) { GetFinalSplitCalculation(listOfViolatedQuatret, _splits[0], countTotalInConsistentQuatret); } else if (_splits[0]._CountTaxa > _splits[1]._CountTaxa) { GetFinalSplitCalculation(listOfViolatedQuatret, _splits[1], countTotalInConsistentQuatret); } else { GetFinalSplitCalculation(listOfViolatedQuatret, _splits[0], countTotalInConsistentQuatret); } //GetFinalSplitCalculation(listOfViolatedQuatret, _splits[0], countTotalInConsistentQuatret); //GetFinalSplitCalculation(listOfViolatedQuatret, _splits[1], countTotalInConsistentQuatret); } }
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 }
//Main Method to Calculate Wrong Taxa public void CalculateWrongTaxa() { WrongPositionStatusClass obj; WrongTaxa wrongTaxa; Quartet qQuartet; Pair pairWithWrongTaxa; foreach (Quartet q in ListOfInconsistent) { try { #region Calculate Wrong Taxa Taxa t1 = getTaxa(q._First_Taxa_Value); Taxa t2 = getTaxa(q._Second_Taxa_Value); Taxa t3 = getTaxa(q._Third_Taxa_Value); Taxa t4 = getTaxa(q._Fourth_Taxa_Value); int p1 = getPosition(t1); int p2 = getPosition(t2); int p3 = getPosition(t3); int p4 = getPosition(t4); obj = new WrongPositionStatusClass(); obj = CalculateWrongPosition(p1, t1._Taxa_Value, p2, t2._Taxa_Value, p3, t3._Taxa_Value, p4, t4._Taxa_Value, q); if (obj.WrongPositionStatus != WrongPositionStatus.None) { wrongTaxa = new WrongTaxa(); pairWithWrongTaxa = new Pair(); pairWithWrongTaxa.Quatret = q._Quartet_Input.Trim(); if (obj.WrongPositionStatus == WrongPositionStatus.aStartLeft) { wrongTaxa.wrongPositionStatus = WrongPositionStatus.aStartLeft; wrongTaxa.Taxa = getTaxa(obj.taStart); wrongTaxa._PositionIntheDepthOne = obj.aStart; } else if (obj.WrongPositionStatus == WrongPositionStatus.aStartRight) { wrongTaxa.wrongPositionStatus = WrongPositionStatus.aStartRight; wrongTaxa.Taxa = getTaxa(obj.taStart); wrongTaxa._PositionIntheDepthOne = obj.aStart; } else if (obj.WrongPositionStatus == WrongPositionStatus.aEndLeft) { wrongTaxa.wrongPositionStatus = WrongPositionStatus.aEndLeft; wrongTaxa.Taxa = getTaxa(obj.taEnd); wrongTaxa._PositionIntheDepthOne = obj.aEnd; } else if (obj.WrongPositionStatus == WrongPositionStatus.aEndRight) { wrongTaxa.wrongPositionStatus = WrongPositionStatus.aEndRight; wrongTaxa.Taxa = getTaxa(obj.taEnd); wrongTaxa._PositionIntheDepthOne = obj.aEnd; } else if (obj.WrongPositionStatus == WrongPositionStatus.bStartLeft) { wrongTaxa.wrongPositionStatus = WrongPositionStatus.bStartLeft; wrongTaxa.Taxa = getTaxa(obj.tbStart); wrongTaxa._PositionIntheDepthOne = obj.bStart; } else if (obj.WrongPositionStatus == WrongPositionStatus.bStartRight) { wrongTaxa.wrongPositionStatus = WrongPositionStatus.bStartRight; wrongTaxa.Taxa = getTaxa(obj.tbStart); wrongTaxa._PositionIntheDepthOne = obj.bStart; } else if (obj.WrongPositionStatus == WrongPositionStatus.bEndLeft) { wrongTaxa.wrongPositionStatus = WrongPositionStatus.bEndLeft; wrongTaxa.Taxa = getTaxa(obj.tbEnd); wrongTaxa._PositionIntheDepthOne = obj.bEnd; } else if (obj.WrongPositionStatus == WrongPositionStatus.bEndRight) { wrongTaxa.wrongPositionStatus = WrongPositionStatus.bEndRight; wrongTaxa.Taxa = getTaxa(obj.tbEnd); wrongTaxa._PositionIntheDepthOne = obj.bEnd; } qQuartet = new Quartet(); qQuartet._First_Taxa_Value = obj.taStart; qQuartet._Second_Taxa_Value = obj.taEnd; qQuartet._Third_Taxa_Value = obj.tbStart; qQuartet._Fourth_Taxa_Value = obj.tbEnd; wrongTaxa.Quartet = qQuartet; //if (!isInWrongTaxaWithoutStatus(wrongTaxa.Taxa._Taxa_Value)) //{ wrongPositionedTaxaList.Add(wrongTaxa); if (qQuartet == null) { } if (wrongTaxa == null) { } if (qQuartet._First_Taxa_Value == wrongTaxa.Taxa._Taxa_Value || qQuartet._Second_Taxa_Value == wrongTaxa.Taxa._Taxa_Value) { pairWithWrongTaxa.tx1 = qQuartet._First_Taxa_Value; pairWithWrongTaxa.tx2 = qQuartet._Second_Taxa_Value; pairWithWrongTaxa.wrongTaxa = wrongTaxa.Taxa._Taxa_Value; } else { pairWithWrongTaxa.tx1 = qQuartet._Third_Taxa_Value; pairWithWrongTaxa.tx2 = qQuartet._Fourth_Taxa_Value; pairWithWrongTaxa.wrongTaxa = wrongTaxa.Taxa._Taxa_Value; } Taxa w1 = getTaxa(pairWithWrongTaxa.tx1); int d1 = getPosition(w1); Taxa w2 = getTaxa(pairWithWrongTaxa.tx2); int d2 = getPosition(w2); int distance = -1; if (d1 > d2) { distance = d1 - d2; } else { distance = d2 - d1; } pairWithWrongTaxa.diff = distance; var maxDifferencedPair = ListOfPairWithWrongTaxa.Where(x => x.wrongTaxa == pairWithWrongTaxa.wrongTaxa).FirstOrDefault(); if (maxDifferencedPair != null) { if (maxDifferencedPair.diff < pairWithWrongTaxa.diff) { ListOfPairWithWrongTaxa.RemoveAll(x => x.wrongTaxa == pairWithWrongTaxa.wrongTaxa); ListOfPairWithWrongTaxa.Add(pairWithWrongTaxa); } } else { ListOfPairWithWrongTaxa.Add(pairWithWrongTaxa); } } #endregion } catch (Exception ex) { } } }
public ActionResult Save(Quartet.Entities.Commands.UpdateTask updateTask) { var commandServiceClient = _clientFactory.GetCommandServiceClient(); var taskClient = _clientFactory.GetTaskQueryServiceClient(); var task = taskClient.GetTaskById(updateTask.TaskId); if (task == null) throw ApiHelpers.ServerError("Task for which an update was requested does not exist"); if (updateTask.DueDateUtc != null) { updateTask.DueDateUtc = updateTask.DueDateUtc.Value.ToUniversalTime(); } if (updateTask.Title == null) { var result = new { Result = "Error", Message = Resources.GetString("REMINDERLIST_ACTION_TITLEISREQUIRED") }; var jsonResult = JsonConvert.SerializeObject(result); return Json(jsonResult, JsonRequestBehavior.AllowGet); } if (updateTask.TaskType != TaskType.Consultant && updateTask.TaskType != TaskType.Customer && !String.IsNullOrEmpty(task.Title)) { updateTask.Title = task.Title; } try { commandServiceClient.Execute(updateTask); } catch (FaultException<ValidationResult> faultException) { var result = new { Result = "Error", Message = faultException.Detail.Errors.FirstOrDefault() }; var jsonResult = JsonConvert.SerializeObject(result); return Json(jsonResult, JsonRequestBehavior.AllowGet); } catch (Exception exception) { var result = new { Result = "Error", Message = exception.Message }; var jsonResult = JsonConvert.SerializeObject(result); return Json(jsonResult, JsonRequestBehavior.AllowGet); } var successResult = new { Result = "Success", Message = Resources.GetString("REMINDERLIST_UPDATESUCCESS"), }; var successJsonResult = JsonConvert.SerializeObject(successResult); return Json(successJsonResult, JsonRequestBehavior.AllowGet); }
//Main Method for calculating Wrong Position public WrongPositionStatusClass CalculateWrongPosition(int p1, string t1, int p2, string t2, int p3, string t3, int p4, string t4, Quartet q) { WrongPositionStatusClass statusClass = new WrongPositionStatusClass(); WrongPositionStatus status = WrongPositionStatus.None; if (status == WrongPositionStatus.None) { status = whoisInWrongPosition(p1, t1, p2, t2, p3, t3, p4, t4, q); } if (status != WrongPositionStatus.None) { statusClass = getWrongPositionStatusClass(status, p1, t1, p2, t2, p3, t3, p4, t4); //return status; return(statusClass); } if (status == WrongPositionStatus.None) { status = whoisInWrongPosition(p2, t2, p1, t1, p3, t3, p4, t4, q); } if (status != WrongPositionStatus.None) { statusClass = getWrongPositionStatusClass(status, p2, t2, p1, t1, p3, t3, p4, t4); //return status; return(statusClass); } //----- if (status == WrongPositionStatus.None) { status = whoisInWrongPosition(p1, t1, p2, t2, p4, t4, p3, t3, q); } if (status != WrongPositionStatus.None) { statusClass = getWrongPositionStatusClass(status, p1, t1, p2, t2, p4, t4, p3, t3); //return status; return(statusClass); } if (status == WrongPositionStatus.None) { status = whoisInWrongPosition(p2, t2, p1, t1, p4, t4, p3, t3, q); } if (status != WrongPositionStatus.None) { statusClass = getWrongPositionStatusClass(status, p2, t2, p1, t1, p4, t4, p3, t3); //return status; return(statusClass); } //----- if (status == WrongPositionStatus.None) { status = whoisInWrongPosition(p3, t3, p4, t4, p1, t1, p2, t2, q); } if (status != WrongPositionStatus.None) { statusClass = getWrongPositionStatusClass(status, p3, t3, p4, t4, p1, t1, p2, t2); //return status; return(statusClass); } if (status == WrongPositionStatus.None) { status = whoisInWrongPosition(p3, t3, p4, t4, p2, t2, p1, t1, q); } if (status != WrongPositionStatus.None) { statusClass = getWrongPositionStatusClass(status, p3, t3, p4, t4, p2, t2, p1, t1); // return status; return(statusClass); } //-- if (status == WrongPositionStatus.None) { status = whoisInWrongPosition(p4, t4, p3, t3, p1, t1, p2, t2, q); } if (status != WrongPositionStatus.None) { statusClass = getWrongPositionStatusClass(status, p4, t4, p3, t3, p1, t1, p2, t2); // return status; return(statusClass); } if (status == WrongPositionStatus.None) { status = whoisInWrongPosition(p4, t4, p3, t3, p2, t2, p1, t1, q); } if (status != WrongPositionStatus.None) { statusClass = getWrongPositionStatusClass(status, p4, t4, p3, t3, p2, t2, p1, t1); // return status; return(statusClass); } // return status; return(statusClass); }
public WrongPositionStatus whoisInWrongPosition(int aStart, string taStart, int aEnd, string taEnd, int bStart, string tbStart, int bEnd, string tbEnd, Quartet q) { WrongPositionStatus status = WrongPositionStatus.None; //Case 1 if (inBetween(aStart, bStart, aEnd) && inBetween(aStart, bEnd, aEnd) && bStart < bEnd) { if (isInWrongTaxa(taStart, WrongPositionStatus.aStartRight)) { status = WrongPositionStatus.aStartRight; } else if (isInWrongTaxa(taEnd, WrongPositionStatus.aEndLeft)) { status = WrongPositionStatus.aEndLeft; } else { // aStart or aEnd in wrong position status = WrongPositionStatus.aEndLeft; } } //Case 2 else if (inBetween(aStart, bStart, aEnd) && inBetween(bStart, aEnd, bEnd) && bStart < bEnd && aStart < bEnd) { if (isInWrongTaxa(tbStart, WrongPositionStatus.bStartRight)) { // bStart in wrong position status = WrongPositionStatus.bStartRight; } else { status = WrongPositionStatus.aEndLeft; } } //Case 3 else if (inBetween(bStart, aStart, bEnd) && inBetween(aStart, bEnd, aEnd) && bStart < bEnd && bStart < aEnd) { if (isInWrongTaxa(taStart, WrongPositionStatus.aStartRight)) { status = WrongPositionStatus.aStartRight; } else { // bEnd in wrong position status = WrongPositionStatus.bEndLeft; } } //Case 4 else if (aStart == bStart && aEnd == bEnd && aStart < aEnd) { if (isInWrongTaxa(taStart, WrongPositionStatus.aStartLeft)) { status = WrongPositionStatus.aStartLeft; } else if (isInWrongTaxa(taStart, WrongPositionStatus.aStartRight)) { status = WrongPositionStatus.aStartRight; } else if (isInWrongTaxa(taEnd, WrongPositionStatus.aEndLeft)) { status = WrongPositionStatus.aEndLeft; } else if (isInWrongTaxa(taEnd, WrongPositionStatus.aEndRight)) { status = WrongPositionStatus.aEndRight; } else if (isInWrongTaxa(tbStart, WrongPositionStatus.bStartLeft)) { status = WrongPositionStatus.bStartLeft; } else if (isInWrongTaxa(tbStart, WrongPositionStatus.bStartRight)) { status = WrongPositionStatus.bStartRight; } else if (isInWrongTaxa(tbEnd, WrongPositionStatus.bEndLeft)) { status = WrongPositionStatus.bEndLeft; } else if (isInWrongTaxa(tbEnd, WrongPositionStatus.bEndRight)) { status = WrongPositionStatus.bEndRight; } else { //bStart and bEnd both status = WrongPositionStatus.bStartRight; } } //Case 5 else if (inBetween(aStart, bStart, aEnd) && aEnd == bEnd && aStart < aEnd) { if (isInWrongTaxa(taEnd, WrongPositionStatus.aEndLeft)) { status = WrongPositionStatus.aEndLeft; } else { // aEnd in wrong position status = WrongPositionStatus.aEndLeft; } } //Case 6 else if (inBetween(aStart, bEnd, aEnd) && aStart == bStart && aStart < aEnd) { if (isInWrongTaxa(taStart, WrongPositionStatus.aStartRight)) { status = WrongPositionStatus.aStartRight; } else { // aStart in wrong position status = WrongPositionStatus.aStartRight; } } //Case 7 else if (aStart < aEnd && aEnd == bStart && bStart < bEnd && aStart < bEnd) { if (isInWrongTaxa(taEnd, WrongPositionStatus.aEndLeft)) { status = WrongPositionStatus.aEndLeft; } else { // aStart in wrong position status = WrongPositionStatus.bStartRight; } } return(status); }