public Relative(int relativeNumber, RelationshipDegree relationshipDegree,
List <Relative> parentsList, List <Relative> childsList)
{
RelativeNumber = relativeNumber;
RelationshipDegree = relationshipDegree;
ParentsList = parentsList;
ChildsList = childsList;
}
public static List <RelationshipDegree> GetPossibleRelationshipsList(int yOfMrca,
int numberOfGenerationsBetweenMrcaAndZeroRelative, int numberOfGenerationsBetweenMrcaAndFirstRelative,
RelationshipDegree _zeroRelationshipDegree, RelationshipDegree _firstRelationshipDegree,
List <RelationshipDegree> _relationshipDegreesList)
{
/*
* Определение основной степени родства.
*/
List <RelationshipDegree> possibleRelationshipDegreesList = new List <RelationshipDegree>
{
GetRelationship(
numberOfGenerationsBetweenMrcaAndZeroRelative,
numberOfGenerationsBetweenMrcaAndFirstRelative,
_relationshipDegreesList)
};
/*
* Определение дополнительных степеней родства, которые могут возникать от того, что 1-я и 2-я личности
* находятся в одной вертикали.
*/
if (_zeroRelationshipDegree.X == _firstRelationshipDegree.X &&
!((_zeroRelationshipDegree.X == 0 && _zeroRelationshipDegree.Y >= 0) || (_firstRelationshipDegree.X == 0 && _firstRelationshipDegree.Y >= 0)))
{
int y0New = _zeroRelationshipDegree.Y;
int y1New = _firstRelationshipDegree.Y;
while (y0New < _zeroRelationshipDegree.X && y1New < _firstRelationshipDegree.X)
{
try
{
yOfMrca = GetYOfMRCA(_zeroRelationshipDegree.X, ++y0New, _firstRelationshipDegree.X, ++y1New);
possibleRelationshipDegreesList.Add(GetRelationship(
yOfMrca - _zeroRelationshipDegree.Y,
yOfMrca - _firstRelationshipDegree.Y,
_relationshipDegreesList));
}
catch (InvalidOperationException IOE)
{
Console.WriteLine(IOE);
}
}
}
/*
* Определение возможности отсутствия родства между 1-й и 2-й личностями.
*/
if (((_zeroRelationshipDegree.X > 1) && (_firstRelationshipDegree.X > 1)) ||
((_zeroRelationshipDegree.Y > 0) && (_firstRelationshipDegree.Y > 0)) ||
((_zeroRelationshipDegree.Y > 0) && (_firstRelationshipDegree.X > 1) || (_firstRelationshipDegree.Y > 0) && (_zeroRelationshipDegree.X > 1)))
{
possibleRelationshipDegreesList.Add(_relationshipDegreesList.Where(rel => rel.X == -1 && rel.Y == -1).Single());
}
return(possibleRelationshipDegreesList);
}
private static RelationshipDegree GetTrueRelationshipDegree(Relative zeroRelative, Relative firstRelative, List <RelationshipDegree> possibleRelationshipDegreesList)
{
RelationshipDegree trueRelationshipDegree = null;
foreach (RelationshipDegree possibleRelationshipDegree in possibleRelationshipDegreesList)
{
if (possibleRelationshipDegree.RelationshipDegreeNumber == 0)
{
trueRelationshipDegree = possibleRelationshipDegree;
}
else
{
if (AncestorList.Contains(possibleRelationshipDegree.RelationshipDegreeNumber))
{
int yDistanceToMRCA = possibleRelationshipDegree.Y;
List <Relative> parentsList = GetParentsListInSelectedGeneration(zeroRelative, yDistanceToMRCA);
if (parentsList.Contains(firstRelative))
{
trueRelationshipDegree = possibleRelationshipDegree;
break;
}
}
else if (DescendantsList.Contains(possibleRelationshipDegree.RelationshipDegreeNumber))
{
int yDistanceToMRCA = possibleRelationshipDegree.Y;
List <Relative> childsList = GetChildsListInSelectedGeneration(zeroRelative, yDistanceToMRCA);
if (childsList.Contains(firstRelative))
{
trueRelationshipDegree = possibleRelationshipDegree;
break;
}
}
else
{
int yDistanceToMRCAFromZeroPerson = possibleRelationshipDegree.X;
List <Relative> parentsListOfZeroPerson = GetParentsListInSelectedGeneration(zeroRelative, yDistanceToMRCAFromZeroPerson);
int yDistanceToMRCAFromFirstPerson = possibleRelationshipDegree.X - possibleRelationshipDegree.Y;
List <Relative> parentsListOfFirstPerson = GetParentsListInSelectedGeneration(firstRelative, yDistanceToMRCAFromFirstPerson);
if (parentsListOfZeroPerson.Intersect(parentsListOfFirstPerson).ToList().Count > 0)
{
trueRelationshipDegree = possibleRelationshipDegree;
break;
}
}
}
}
return(trueRelationshipDegree);
}
public static float[][] GetMatrix(int generatedMatrixSize, List <Relative> relativesList)
{
List <int> relativesNumbersRange = Enumerable.Range(0, relativesList.Count).ToList();
List <int> randomNumbers = new List <int> {
0
};
for (int i = 1; i < generatedMatrixSize; i++)
{
int randomValue = GetNextRandomValue(1, relativesNumbersRange.Count);
randomNumbers.Add(relativesNumbersRange[randomValue]);
relativesNumbersRange.RemoveAt(randomValue);
}
float[][] relativesMatrix = new float[generatedMatrixSize][];
for (int i = 0; i < generatedMatrixSize; i++)
{
relativesMatrix[i] = new float[generatedMatrixSize];
Relative zeroRelative = relativesList[randomNumbers[i]];
for (int j = i + 1; j < generatedMatrixSize; j++)
{
Relative firstRelative = relativesList[randomNumbers[j]];
if (i == 0)
{
relativesMatrix[i][j] = relativesList[randomNumbers[j]].RelationshipDegree.RelationshipDegreeNumber;
}
else
{
int yMrca = GetYOfMRCA(zeroRelative.RelationshipDegree.X, zeroRelative.RelationshipDegree.Y,
firstRelative.RelationshipDegree.X, firstRelative.RelationshipDegree.Y);
int y0Result = yMrca - zeroRelative.RelationshipDegree.Y;
int y1Result = yMrca - firstRelative.RelationshipDegree.Y;
List <RelationshipDegree> possibleRelationshipDegreesList = GetPossibleRelationshipsList(yMrca,
y0Result, y1Result,
zeroRelative.RelationshipDegree, firstRelative.RelationshipDegree,
RelationshipDegreesDictionary.Values.ToList());
possibleRelationshipDegreesList = possibleRelationshipDegreesList.Where(x => x.RelationshipDegreeNumber != 1).ToList();
RelationshipDegree trueRelationshipDegree = GetTrueRelationshipDegree(zeroRelative, firstRelative, possibleRelationshipDegreesList);
relativesMatrix[i][j] = trueRelationshipDegree.RelationshipDegreeNumber;
}
}
}
return(relativesMatrix);
}
private static List <Relative> GetTree(int generatedMatrixSize, List <int> existingRelationshipDegrees, double probabilityOfNotCreatingNewRelative)
{
List <Relative> relativesList = new List <Relative>
{
{ new Relative(0, RelationshipDegreesDictionary[1], new List <Relative>(), new List <Relative>()) }
};
int relativeNumber = 1;
List <int> allPossibleRelationships = GetListOfAllPossibleRelationshipsOfProband(existingRelationshipDegrees);
for (int i = 1; i < generatedMatrixSize; i++)
{
RelationshipDegree selectedRandomRelationship = RelationshipDegreesDictionary[allPossibleRelationships[GetNextRandomValue(0, allPossibleRelationships.Count)]];
int distanceX = selectedRandomRelationship.X - relativesList[0].RelationshipDegree.X;
int distanceY = selectedRandomRelationship.Y - relativesList[0].RelationshipDegree.Y;
if (distanceX == 0)
{
if (distanceY > 0)
{
for (int stepY = 0; stepY < distanceY; stepY++)
{
relativesList = AddParentalRelationship(relativesList, relativeNumber,
0, stepY + 1,
stepY == 0, stepY == distanceY - 1,
probabilityOfNotCreatingNewRelative);
relativeNumber++;
}
}
else
{
for (int stepY = 0; stepY > distanceY; stepY--)
{
relativesList = AddDescendantRelationship(relativesList, relativeNumber,
0, stepY - 1,
stepY == 0, stepY == distanceY + 1,
true, probabilityOfNotCreatingNewRelative);
relativeNumber++;
}
}
}
else
{
for (int stepY = 0; stepY < distanceX; stepY++)
{
relativesList = AddParentalRelationship(relativesList, relativeNumber,
0, stepY + 1,
stepY == 0, 0 != 0,
probabilityOfNotCreatingNewRelative);
relativeNumber++;
}
for (int stepY = distanceX; stepY > distanceY; stepY--)
{
relativesList = AddDescendantRelationship(relativesList, relativeNumber,
distanceX, stepY - 1,
1 == 0, stepY == distanceY + 1,
false, probabilityOfNotCreatingNewRelative);
relativeNumber++;
}
}
}
return(relativesList.Distinct().ToList());
}
