public void CanComputePercentileUsingNearestMethod()
{
var percentile = new Percentile(_data);
percentile.Method = PercentileMethod.Nearest;
Assert.AreEqual(95.1959, percentile.Compute(.9));
}
public void InvalidPercentileValuesThrowArgumentException()
{
var percentile = new Percentile(Data);
Assert.Throws <ArgumentException>(() => percentile.Compute(-0.1));
Assert.Throws <ArgumentException>(() => percentile.Compute(100.1));
}
public PlayerPosition Generate()
{
// we generate a random percentile
Percentile percentileCategory = _percentileGenerator.Generate();
// then, using the 1-NN calculator, we get the nearest neighbour to the percentile
var categoryCalculator = new PercentileNearestNeighbourCalculator <PositionCategory>(
percentileCategory, _percentileCategories.ToArray());
// and we get the category from the nearest neighbour
PositionCategory category = categoryCalculator.GetNearestNeighbourUnderlyingType();
// retrieve positions from the category
List <PercentileData <PlayerPosition> > positionsData = _percentilePositions
.Where(pp => pp.Object.PositionCategory == category)
.ToList();
var min = positionsData.Min(p => p.Percentile);
var max = positionsData.Max(p => p.Percentile);
var positionPercentile = _percentileGenerator.Generate(min, max);
var positionCalculator = new PercentileNearestNeighbourCalculator <PlayerPosition>(
positionPercentile, positionsData.ToArray());
return(positionCalculator.GetNearestNeighbourUnderlyingType());
}
public IActionResult GetMetricsByPercentileFromAllCluster(
[FromRoute] HddMetricGetByIntervalForClusterRequest request,
[FromRoute] Percentile percentile)
{
_logger.LogDebug("Вызов метода. Параметры:" +
$" {nameof(request.FromTime)} = {request.FromTime}" +
$" {nameof(request.ToTime)} = {request.ToTime}" +
$" {nameof(percentile)} = {percentile}");
var agents = _agentRepository.GetAllAgentsInfo();
var response = new AllMetricsResponse <HddMetricDto>();
foreach (var agent in agents.Agents)
{
var currentAgentMetrics = _repository.GetByTimeIntervalPercentile(agent.AgentId, request.FromTime, request.ToTime, percentile);
foreach (var metric in currentAgentMetrics.Metrics)
{
response.Metrics.Add(_mapper.Map <HddMetricDto>(metric));
}
}
return(Ok(response));
}
public void TestInitialize()
{
KthPercentile = 50;
KthPercentileLess = 45;
KthPercentileGreater = 68;
percentileDoubleEven = new Percentile(arrayDoubleEven, KthPercentile);
percentileDecimalEven = new Percentile(arrayDecimalEven, KthPercentile);
percentileFloatEven = new Percentile(arrayFloatEven, KthPercentile);
percentileIntEven = new Percentile(arrayIntEven, KthPercentile);
percentileDoubleOdd = new Percentile(arrayDoubleOdd, KthPercentile);
percentileDecimalOdd = new Percentile(arrayDecimalOdd, KthPercentile);
percentileFloatOdd = new Percentile(arrayFloatOdd, KthPercentile);
percentileIntOdd = new Percentile(arrayIntOdd, KthPercentile);
percentileDoubleOddLess = new Percentile(arrayDoubleOdd, KthPercentileLess);
percentileDecimalOddLess = new Percentile(arrayDecimalOdd, KthPercentileLess);
percentileFloatOddLess = new Percentile(arrayFloatOdd, KthPercentileLess);
percentileIntOddLess = new Percentile(arrayIntOdd, KthPercentileLess);
percentileDoubleOddGreater = new Percentile(arrayDoubleOdd, KthPercentileGreater);
percentileDecimalOddGreater = new Percentile(arrayDecimalOdd, KthPercentileGreater);
percentileFloatOddGreater = new Percentile(arrayFloatOdd, KthPercentileGreater);
percentileIntOddGreater = new Percentile(arrayIntOdd, KthPercentileGreater);
}
public IActionResult GetMetricsByPercentileFromAgent([FromRoute] DateTimeOffset fromTime, [FromRoute] DateTimeOffset toTime,
[FromRoute] Percentile percentile)
{
_logger.LogInformation($"Входные данные {fromTime} {toTime} {percentile}");
var metrics = _repository.GetFromTo(fromTime, toTime);
if (metrics == null)
{
return(Ok());
}
var response = new AllCpuMetricsResponse()
{
Metrics = new List <CpuMetricDto>()
};
metrics = SortAndDeleteForPercentile(metrics, percentile);
foreach (var metric in metrics)
{
response.Metrics.Add(_mapper.Map <CpuMetricDto>(metric));
}
return(Ok($"По перцентилю {percentile} нагрузка не превышает {metrics.Max(metric => metric.Value)}%"));
}
public PercentileNearestNeighbourCalculator
(
Percentile x,
PercentileData <T>[] data
) : base(x, data, 1)
{
}
public PercentileGrowth(int percentile, Gender gender, List <WeightForAge> weightsForAges, List <StatureForAge> staturesForAges)
{
Percentile = new Percentile(percentile);
Gender = gender;
_weightForAges.AddRange(weightsForAges);
_staturesForAges.AddRange(staturesForAges);
}
public IActionResult GetMetricsByPercentileFromAgent([FromRoute] int agentId, [FromRoute] DateTimeOffset fromTime, [FromRoute] DateTimeOffset toTime,
[FromRoute] Percentile percentile)
{
_logger.LogInformation($"Метод GetMetricsByPercentileFromAgent fromTime {fromTime} toTime {toTime}");
var metrics = _metricsAgentClient.GetAllRamMetrics(new GetAllRamMetricsApiRequest
{
ClientBaseAddress = _uriAdress.GetUri(agentId),
FromTime = fromTime,
ToTime = toTime
});
if (metrics != null)
{
double[] masValue = new double[metrics.Metrics.Count];
for (int i = 0; i < masValue.Length; i++)
{
masValue[i] = metrics.Metrics[i].Value;
}
var percentileCalculationMethod = new PercentileCalculationMethod();
var percentileValue = percentileCalculationMethod.PercentileCalculation(masValue, (double)percentile / 100);
return(Ok(percentileValue));
}
return(Ok());
}
public void CanComputePercentileUsingExcelMethod()
{
var percentile = new Percentile(_data);
percentile.Method = PercentileMethod.Excel;
Assert.AreEqual(95.19568, percentile.Compute(.9));
}
public void EmptyDataSetReturnsNaN()
{
var data = new double[] {};
var percentile = new Percentile(data);
Assert.IsTrue(double.IsNaN(percentile.Compute(0)));
Assert.IsTrue(double.IsNaN(data.Quantile(0)));
}
public void CanComputePercentileUsingNearestMethod()
{
var percentile = new Percentile(Data)
{
Method = PercentileMethod.Nearest
};
Assert.AreEqual(95.1959, percentile.Compute(.9));
}
public void CanComputePercentileUsingExcelMethod()
{
var percentile = new Percentile(Data)
{
Method = PercentileMethod.Excel
};
Assert.AreEqual(95.19568, percentile.Compute(.9));
}
public IActionResult GetMetricsByPercentileFromAllCluster(
[FromRoute] TimeSpan fromTime,
[FromRoute] TimeSpan toTime,
[FromRoute] Percentile percentile)
{
_logger.LogInformation($"Общие данные From:{fromTime}, To:{toTime}, Percentile:{percentile}");
return(Ok());
}
public Foot Generate()
{
Percentile rndPct = _percentileGenerator.Generate();
var calculator = new PercentileKNearestNeighborCalculator <Foot>(rndPct, _data);
return(calculator.GetNearestNeighbours().Value[0].Value.Object);
}
public void CanComputePercentileUsingNistMethod()
{
var percentile = new Percentile(Data)
{
Method = PercentileMethod.Nist
};
Assert.AreEqual(95.19807, percentile.Compute(.9));
}
public void ShouldRecreateCalcualtionObjectWhenKNumberChanges_Int()
{
Percentile percentile = new Percentile(arrayIntEven, KthPercentile);
percentile.KthPercentile = KthPercentileGreater;
double result = (double)percentile.GetResult();
Assert.AreEqual(6.0, result);
}
public void CanComputePercentileUsingNearestMethod()
{
var percentile = new Percentile(Data)
{
Method = PercentileMethod.Nearest
};
Assert.AreEqual(95.1959, percentile.Compute(.9));
Assert.AreEqual(95.1959, Data.QuantileCustom(.9, QuantileDefinition.Nearest));
}
public void CanComputePercentileUsingExcelMethod()
{
var percentile = new Percentile(Data)
{
Method = PercentileMethod.Excel
};
Assert.AreEqual(95.19568, percentile.Compute(.9));
Assert.AreEqual(95.19568, Data.QuantileCustom(.9, QuantileDefinition.Excel));
}
public IActionResult GetMetricsByPercentileFromAgent(
[FromRoute] int agentId,
[FromRoute] TimeSpan fromTime,
[FromRoute] TimeSpan toTime,
[FromRoute] Percentile percentile)
{
_logger.LogInformation($"Агент: {agentId}, From:{fromTime}, To:{toTime}, Percentile:{percentile}");
return(Ok());
}
public void ShouldRecreateCalcualtionObjectWhenKNumberChanges_Decimal()
{
Percentile percentile = new Percentile(arrayDecimalEven, KthPercentile);
percentile.KthPercentile = KthPercentileGreater;
decimal result = (decimal)percentile.GetResult();
Assert.AreEqual(6.4M, result);
}
public void ShouldRecreateCalcualtionObjectWhenKNumberChanges_Float()
{
Percentile percentile = new Percentile(arrayFloatEven, KthPercentile);
percentile.KthPercentile = KthPercentileGreater;
float result = (float)percentile.GetResult();
Assert.AreEqual(6.4F, result);
}
public void InvalidPercentileValuesReturnNaN()
{
var percentile = new Percentile(Data);
Assert.IsTrue(double.IsNaN(percentile.Compute(-0.1)));
Assert.IsTrue(double.IsNaN(percentile.Compute(1.1)));
Assert.IsTrue(double.IsNaN(Data.Quantile(-0.1)));
Assert.IsTrue(double.IsNaN(Data.Quantile(1.1)));
}
public void CanComputePercentileUsingNearestMethod()
{
var percentile = new Percentile(Data)
{
Method = PercentileMethod.Nearest
};
Assert.AreEqual(95.1959, percentile.Compute(.9));
Assert.AreEqual(95.1959, Data.QuantileCustom(.9, QuantileDefinition.Nearest));
}
public void CanComputePercentileUsingExcelMethod()
{
var percentile = new Percentile(Data)
{
Method = PercentileMethod.Excel
};
Assert.AreEqual(95.19568, percentile.Compute(.9));
Assert.AreEqual(95.19568, Data.QuantileCustom(.9, QuantileDefinition.Excel));
}
public void Merge(Percentile Group)
{
// Put your code here
List<double> secondDoubleList = Group.DoubleList;
foreach (double d in secondDoubleList)
{
doubleList.Add(d);
}
this.percentile = Group.PercentileValue;
}
public void Merge(Percentile Group)
{
// Put your code here
List <double> secondDoubleList = Group.DoubleList;
foreach (double d in secondDoubleList)
{
doubleList.Add(d);
}
this.percentile = Group.PercentileValue;
}
public void GetMetricsByPercentileFromAllCluster_ReturnsOk(
int start,
int end,
Percentile percentile)
{
var fromTime = TimeSpan.FromSeconds(start);
var toTime = TimeSpan.FromSeconds(end);
var result = _controller.GetMetricsByPercentileFromAllCluster(fromTime, toTime, percentile);
_ = Assert.IsAssignableFrom <IActionResult>(result);
}
public void CanComputePercentileUsingInterpolationMethod()
{
var data = new double[] { 1, 2, 3, 4, 5 };
var percentile = new Percentile(data);
percentile.Method = PercentileMethod.Interpolation;
var values = new[] { .25, .5, .75 };
var percentiles = percentile.Compute(values);
Assert.AreEqual(1.75, percentiles[0]);
Assert.AreEqual(3.0, percentiles[1]);
Assert.AreEqual(4.25, percentiles[2]);
}
public void CanComputePercentileUsingInterpolationMethod()
{
var data = new double[] { 1, 2, 3, 4, 5 };
var percentile = new Percentile(data)
{
Method = PercentileMethod.Interpolation
};
var values = new[] { .25, .5, .75 };
var percentiles = percentile.Compute(values);
Assert.AreEqual(1.75, percentiles[0]);
Assert.AreEqual(3.0, percentiles[1]);
Assert.AreEqual(4.25, percentiles[2]);
}
public void GetMetricsByPercentileFromAgent_ReturnsOk()
{
//var agentId = 1;
var fromTime = TimeSpan.FromSeconds(0);
var toTime = TimeSpan.FromSeconds(100);
Percentile percentile = 0;
//Act
var result = controller.GetMetricsByPercentileFromAgent(fromTime, toTime, percentile);
// Assert
_ = Assert.IsAssignableFrom <IActionResult>(result);
}
public void GetFromTimeToTimePercentile()
{
_mock.Setup(repository => repository.GetFromTo(It.IsAny <DateTimeOffset>(), It.IsAny <DateTimeOffset>())).Verifiable();
DateTime d1 = new DateTime(2011, 10, 10);
DateTime d2 = new DateTime(2011, 11, 11);
DateTimeOffset fromTime = new DateTimeOffset(d1);
DateTimeOffset toTime = new DateTimeOffset(d2);
Percentile percentile = Percentile.P99;
var result = _controller.GetMetricsByPercentileFromAgent(fromTime, toTime, percentile);
_mock.Verify(repository => repository.GetFromTo(It.IsAny <DateTimeOffset>(), It.IsAny <DateTimeOffset>()), Times.AtMostOnce());
}
public PercentileGrowth GetForPercentile(Percentile percentile)
{
var calculator = new PercentileKNearestNeighborCalculator
(
percentile,
_growths.Select(pg => pg.Percentile).ToArray()
);
Maybe <List <KnnResult <Percentile> > > resultList = calculator.Search();
resultList.ValueOrThrow(new ApplicationException("No value returned"));
KnnResult <Percentile> knnResult = resultList.Value[0];
return(_growths[knnResult.Position.IndexValue]);
}
public void GetMetricsByPercentileFromClusterCheckRequestSelect()
{
//Arrange
DateTimeOffset fromTime = DateTimeOffset.FromUnixTimeSeconds(3);
DateTimeOffset toTime = DateTimeOffset.FromUnixTimeSeconds(15);
Percentile percentile = Percentile.P99;
string sort = "value";
_mock.Setup(a => a.GetByPeriodWithSorting(fromTime, toTime, sort)).Returns(new List <DotNetMetricModel>()).Verifiable();
//Act
var result = _controller.GetMetricsByPercentileFromAllCluster(fromTime, toTime, percentile);
//Assert
_mock.Verify(repository => repository.GetByPeriodWithSorting(fromTime, toTime, sort), Times.AtMostOnce());
_logger.Verify();
}
public IActionResult GetMetricsByPercentileFromAgent(
[FromRoute] DateTimeOffset fromTime,
[FromRoute] DateTimeOffset toTime,
[FromRoute] Percentile percentile)
{
var metrics = _repository.GetByPeriodWithSorting(fromTime, toTime, "value");
var percentileMetric = metrics.Cast <DotNetMetric>().SingleOrDefault(i => i.Value == PercentileCalculator.Calculate(GetListValuesFromMetrics(metrics), (double)percentile / 100.0));
var response = new AllDotNetMetricsResponse()
{
Metrics = new List <DotNetMetricDto>()
};
response.Metrics.Add(_mapper.Map <DotNetMetricDto>(percentileMetric));
_logger.LogInformation($"Запрос метрик DotNet персентиля за период с {fromTime} по {toTime}");
return(Ok(response));
}
private int _k; // le nombre de voisins à chercher/renvoyer
public PercentileKNearestNeighborCalculator(Percentile x, Percentile[] data, int k = 1)
{
if (k < 1)
{
throw new ArgumentException(nameof(k));
}
if (data is null)
{
throw new ArgumentNullException(nameof(data));
}
if (data.Length == 0)
{
throw new ArgumentException(nameof(data));
}
_x = x;
_data = data;
_k = k;
}
public void InvalidPercentileValuesThrowArgumentException()
{
var percentile = new Percentile(Data);
Assert.Throws<ArgumentException>(() => percentile.Compute(-0.1));
Assert.Throws<ArgumentException>(() => percentile.Compute(100.1));
}
public void EmptyDataSetReturnsNaN()
{
var data = new double[] {};
var percentile = new Percentile(data);
Assert.IsTrue(double.IsNaN(percentile.Compute(0)));
Assert.IsTrue(double.IsNaN(data.Quantile(0)));
}
public void InvalidPercentileValuesReturnNaN()
{
var percentile = new Percentile(Data);
Assert.IsTrue(double.IsNaN(percentile.Compute(-0.1)));
Assert.IsTrue(double.IsNaN(percentile.Compute(1.1)));
Assert.IsTrue(double.IsNaN(Data.Quantile(-0.1)));
Assert.IsTrue(double.IsNaN(Data.Quantile(1.1)));
}
public void CanComputePercentileUsingInterpolationMethod()
{
var data = new double[] {1, 2, 3, 4, 5};
var percentile = new Percentile(data)
{
Method = PercentileMethod.Interpolation
};
var values = new[] {.25, .5, .75};
var percentiles = percentile.Compute(values);
Assert.AreEqual(1.75, percentiles[0]);
Assert.AreEqual(3.0, percentiles[1]);
Assert.AreEqual(4.25, percentiles[2]);
var q = data.QuantileCustomFunc(QuantileDefinition.R5);
Assert.AreEqual(1.75, q(0.25));
Assert.AreEqual(3.0, q(0.5));
Assert.AreEqual(4.25, q(0.75));
}
