public ConvexHull(List <double[]> basePoints)
{
int dimension = basePoints[0].Count();
if (dimension == 0)
{
throw new ArgumentException();
}
if (basePoints.Any(x => x.Count() != dimension))
{
throw new ArgumentException();
}
Dimension = dimension;
_basePoints = AlgorithmHelper.RemoveDuplicates(basePoints);
_max = AlgorithmHelper.GetMaxInListByComponents(_basePoints);
_min = AlgorithmHelper.GetMinInListByComponents(_basePoints);
_notEqMask = _max.Zip(_min, (x, y) => x != y).ToArray();
_realDimension = _notEqMask.Count(x => x);
if (_realDimension > 0)
{
_realPoints = AlgorithmHelper.RemoveDuplicates(AlgorithmHelper.MaskListOfArrays(_basePoints, _notEqMask));
_realMax = AlgorithmHelper.GetArrayByMask(_max, _notEqMask);
_realMin = AlgorithmHelper.GetArrayByMask(_min, _notEqMask);
if (_realDimension > 1)
{
_convexHull = MIConvexHull.ConvexHull.Create(_realPoints);
}
}
CalculateInequalities();
}
//public List<double[]> GetGridPoints(int[] stepsCount)
//{
// if (_realDimension == 0)
// return new List<double[]> { _basePoints[0] };
// List<double[]> grid;
// int[] realStepsCount = AlgorithmHelper.GetArrayByMask(stepsCount, _notEqMask);
// if (_realDimension == 1)
// grid = GetSingleDimensionGrid(realStepsCount);
// else
// grid = GetMultiDimensionGrid(realStepsCount);
// if (_realDimension != Dimension)
// {
// grid = grid.Select(realPoint => ConvertFromReal(realPoint)).ToList();
// }
// return grid;
//}
public bool IsPointInConvexHull(double[] point)
{
if (point.Count() != Dimension)
{
throw new Exception();
}
if (_realDimension == 0)
{
return(point.SequenceEqual(_max));
}
if (_realDimension != Dimension)
{
for (int i = 0; i < Dimension; i++)
{
if (!_notEqMask[i] && point[i] != _max[i])
{
return(false);
}
}
}
if (_realDimension == 1)
{
int idx = _notEqMask.IndexOf(true);
return(point[idx] <= _max[idx] && point[idx] >= _min[idx]);
}
return(IsRealPointInConvexHull(AlgorithmHelper.GetArrayByMask(point, _notEqMask)));
}
public double[] FindNearestInteriorPoint(double[] point, bool[] notUpper, double[] weights = null)
{
if (weights == null)
{
weights = _max.Select(x => 1.0).ToArray();
}
if (point.Count() != Dimension)
{
throw new Exception();
}
if (_realDimension == 0)
{
return(_max);
}
var nearestPoint = point.Select(x => x).ToArray();
if (_realDimension != Dimension)
{
for (int i = 0; i < Dimension; i++)
{
if (!_notEqMask[i])
{
nearestPoint[i] = _max[i];
}
}
}
if (_realDimension == 1)
{
int idx = _notEqMask.IndexOf(true);
if (nearestPoint[idx] < _min[idx])
{
if (notUpper[idx])
{
return(null);
}
else
{
nearestPoint[idx] = _min[idx];
}
}
else if (nearestPoint[idx] > _max[idx])
{
nearestPoint[idx] = _max[idx];
}
return(nearestPoint);
}
var nearestRealPoint = NearestRealPoint(AlgorithmHelper.GetArrayByMask(nearestPoint, _notEqMask), AlgorithmHelper.GetArrayByMask(weights, _notEqMask), AlgorithmHelper.GetArrayByMask(notUpper, _notEqMask));
return(ConvertFromReal(nearestRealPoint));
}
