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);
}
