public void UpdateBasicStatsUI(BasicStatistics basicStatistics)
{
UpdateStatisticTextValue(strenghtTxt, basicStatistics.Strenght);
UpdateStatisticTextValue(vitalityTxt, basicStatistics.Vitality);
UpdateStatisticTextValue(intelligenceTxt, basicStatistics.Intelligence);
UpdateStatisticTextValue(dexterityTxt, basicStatistics.Dexterity);
}
void OnGUI()
{
BasicStatistics stats = GetComponent <BasicStatistics>();
GUI.Label(new Rect(position.x, position.y, boxSize.x, boxSize.y), sliderText);
stats.ATT = (int)GUI.HorizontalSlider(new Rect(position.x + boxSize.x, position.y + margin.y, sliderSize, sliderArea), stats.ATT, minimumValue, maximumValue);
GUI.Box(new Rect(position.x + boxSize.x + margin.x + sliderSize, position.y, boxSize.x, boxSize.y), stats.ATT.ToString());
}
public IBasicStatistics Analise(IRouletteRolls rouletteRolls)
{
_rouletteRolls = rouletteRolls;
_basicStatisticUnits = new BasicStatistics(_rouletteRolls.RollTemplatesPool, _rouletteRolls.Count);
CountRouletteRolls();
return(_basicStatisticUnits);
}
public void AllResultsHaveName()
{
var benchmarkResults = CreateEngine <AleatoryBenchmark>(new BenchmarkOptions()
{
Repetitions = 1
}).Execute();
var statisticCalculator = new BasicStatistics();
var statisticResults = statisticCalculator.Calculate(benchmarkResults.Single().Methods.Single());
Assert.AreEqual(statisticResults.Count, statisticCalculator.GetHeaders().Count());
}
private int CalculateDamage(BasicStatistics enemy, BasicStatistics owner)
{
int TotalDamage = 0;
//CalculateDamage accoding to one of the rules
foreach (var damage in this.Damage)
{
TotalDamage += (int) ((1- enemy.DamageResistance[damage.Type]) * (owner.ATT+balanceConstant) / (enemy.DEF+balanceConstant) * damage.Value);
//TotalDamage += (int)((1 - (enemy.DEF + enemy.PhysicalResistance - owner.ATT)/100) * PhysicalDmg);
}
return TotalDamage;
}
void OnGUI()
{
BasicStatistics stats = GetComponent <BasicStatistics>();
GUI.Label(new Rect(Screen.width - 2 * position.x - sliderSize - 2 * boxSize.x, position.y, boxSize.x, boxSize.y), sliderText);
stats.DEF = (int)GUI.HorizontalSlider(new Rect(Screen.width - 2 * position.x - sliderSize - boxSize.x, position.y + margin.y, sliderSize, sliderArea), stats.DEF, minimumValue, maximumValue);
GUI.Box(new Rect(Screen.width - position.x - boxSize.x, position.y, boxSize.x, boxSize.y), stats.DEF.ToString());
GUI.Box(new Rect(Screen.width - HPboxSize.x - HPmargin.x, Screen.height - HPmargin.y, HPboxSize.x, HPboxSize.y), ("HP =" + stats.HP.ToString()));
//Buttons
//hasMagicRes = GUI.Toggle(new Rect(Screen.width - magicResistancePosition.x - imageSize.x,magicResistancePosition.y,imageSize.x,imageSize.y),stats.MagicResistance,(stats.MagicResistance>0) ? magicResActiveIcon : magicResDisabledIcon);
}
private int CalculateDamage(BasicStatistics enemy, BasicStatistics owner)
{
int TotalDamage = 0;
//CalculateDamage accoding to one of the rules
foreach (var damage in this.Damage)
{
TotalDamage += (int)((1 - enemy.DamageResistance[damage.Type]) * (owner.ATT + balanceConstant) / (enemy.DEF + balanceConstant) * damage.Value);
//TotalDamage += (int)((1 - (enemy.DEF + enemy.PhysicalResistance - owner.ATT)/100) * PhysicalDmg);
}
return(TotalDamage);
}
private void RecordAllocationResult()
{
BasicStatistics stats = new BasicStatistics(this.allDistances);
var CI = new ConfidenceIntervalStandardNormal(stats);
this.allocationResult = new AllocationResult()
{
Mean = stats.Mean,
LCI = CI.LowerBound,
UCI = CI.UpperBound,
Stats = stats,
};
}
/// <summary>
/// Create a LocalityResult object to store result for locality
/// </summary>
/// <param name="locality">Name of locality</param>
/// <param name="tours">Length of n sampled tours</param>
private void RecordLocalityResults(string locality, List <double> days)
{
BasicStatistics stats = new BasicStatistics(days);
var CI = new ConfidenceIntervalStandardNormal(stats);
var localityResult = new LocalityResult()
{
Locality = locality,
Mean = Math.Round(stats.Mean, DECIMAL_PLACES),
LCI = Math.Round(CI.LowerBound, DECIMAL_PLACES),
UCI = Math.Round(CI.UpperBound, DECIMAL_PLACES),
FifthPercentile = Math.Round(stats.Percentile(FIFTH_PERCENTILE), DECIMAL_PLACES),
NinetyFifthPercentile = Math.Round(stats.Percentile(NINETYFIFTH_PERCENTILE), DECIMAL_PLACES)
};
resultsByLocality.Add(localityResult);
}
public void Statistics_MinMax_Test()
{
var data = new double[10][];
for (int i = 0; i < data.Length; i++)
{
data[i] = new double[3];
data[i][0] = i + 5;
data[i][1] = Math.Sin(i * 2.14);
data[i][2] = Math.Sin(2 * i + i * i - 5);
}
var minMax = BasicStatistics.calculateMinMax(data);
Assert.Equal(5, minMax.min[0]);
Assert.Equal(-0.98742414298941528, minMax.min[1]);
Assert.Equal(-0.98803162409286183, minMax.min[2]);
Assert.Equal(14, minMax.max[0]);
Assert.Equal(0.84233043163664567, minMax.max[1]);
Assert.Equal(0.99287264808453712, minMax.max[2]);
}
public void Statistics_MeanStDev_Test()
{
var data = new double[10][];
for (int i = 0; i < data.Length; i++)
{
data[i] = new double[3];
data[i][0] = i + 5;
data[i][1] = Math.Sin(i * 2.14);
data[i][2] = Math.Sin(2 * i + i * i - 5);
}
var minMax = BasicStatistics.calculateMeanStDev(data);
Assert.Equal(9.5, minMax.means[0]);
Assert.Equal(0.02222381660881375, minMax.means[1]);
Assert.Equal(-0.16633643848431015, minMax.means[2]);
Assert.Equal(3.0276503540974917, minMax.stdevs[0]);
Assert.Equal(0.72201262859409132, minMax.stdevs[1]);
Assert.Equal(0.72052383815693033, minMax.stdevs[2]);
}
public void ValuesHaveRequiredOrder()
{
// We need EXACTLY this order because of how HtmlOutputRenderer and its HTML template files
// are implemented. If things will change there (with more robust code) then this test may
// be simplified.
// Note that with a small number of repetitions this check may fail because of "random" function call overhead, if
// this test fails on some environment you may need to increase this number (I keep it low just to make test faster).
var benchmarkResults = CreateEngine <AleatoryBenchmark>(new BenchmarkOptions()
{
Repetitions = 10
}).Execute();
var statisticCalculator = new BasicStatistics();
var statisticResults = statisticCalculator.Calculate(benchmarkResults.Single().Methods.Single());
var distribution = statisticCalculator.GetHeaders().Select(x => (TimeSpan)statisticResults[x]).ToArray();
for (int i = 1; i < distribution.Length; ++i)
{
Assert.IsTrue(distribution[i] > distribution[i - 1],
String.Format("Item #{0} has value {1} but it should be greater than item #{2} (with value {3}.", i, distribution[i], i - 1, distribution[i - 1]));
}
}
public float Evaluate(IChromosome ch, IParameters param, int it)
{
var iData = GetData();
var chr = (Chromosome)ch;
var expTree = chr.expressionTree;
double fitness = 0;
double rowFitness = 0.0;
double[] y;
var evalData = new List <(int, double[])>();
var dic = new Dictionary <int, List <double[]> >();
var preCalcData = new Dictionary <int, (double[], double[][])>();
var result = new List <(int, int)>();
//for each trainign sample
for (int i = 0; i < iData.RowCount; i++)
{
var rowInputData = iData.GetDataInputRow(i);
// evaluate the function against each rowData
y = expTree.Evaluate2(rowInputData, param);
if (y == null)
{
return(float.NaN);
}
//get output Value
var yo = (int)iData.GetRowOutput(i);
//add result in to list
evalData.Add((yo, y));
//map result with class
if (dic.ContainsKey(yo))
{
dic[yo].Add(y);
}
else
{
dic.Add(yo, new List <double[]>()
{
y
});
}
}
//calculate centroids and Covariance matrix for each cluster
for (int i = 0; i < dic.Keys.Count; i++)
{
//class value
var c = dic.Keys.ElementAt(i);
var vals = dic.Values.ElementAt(i).ToArray();
//predicted values for the class
var cData = AdvancedStatistics.ToColumnVector <double>(vals);
//calculated centroid for the cData
var cen = cData.Select(x => x.MeanOf()).ToArray();
//calculate CovarianceMatrix
var cov = BasicStatistics.Covariance(cData);
if (!isValid(cov))
{
return(float.NaN);
}
preCalcData.Add(c, (cen, cov));
}
//for each training sample
//go through all samples
foreach (var item in evalData)
{
//calculate Mahanalobis distance for each training sample
double minMD = double.MaxValue;
int predictedCluster = 0;
foreach (var c in dic.Keys)
{
var md = AdvancedStatistics.MD(item.Item2, preCalcData[c].Item1, preCalcData[c].Item2);
//map result with class
if (minMD > md)
{
predictedCluster = c;
minMD = md;
}
}
//map actual and predicted class value
result.Add((item.Item1, predictedCluster));
}
float corectedPredicted = result.Where(x => x.Item1 == x.Item2).Count();
var rawFitness = corectedPredicted / (float)result.Count;
if (double.IsNaN(rawFitness) || double.IsInfinity(rawFitness))
{
fitness = float.NaN;
}
else//calculate adjusted fitness
{
fitness = (rawFitness * 1000.0);
}
//store extra data into chromosome
chr.ExtraData = preCalcData;
return((float)System.Math.Round(fitness, 2));
}
public static BasicStatistics CreateBasicStatistics(global::System.Guid ID, int clouds, int serviceDeployments, int serviceDeploymentsNotRunning, int serviceDeploymentsRequiringAttention, int serviceVMs, int standaloneVMs, int vMsNotRunning, int vMsRequiringAttention)
{
BasicStatistics basicStatistics = new BasicStatistics();
basicStatistics.ID = ID;
basicStatistics.Clouds = clouds;
basicStatistics.ServiceDeployments = serviceDeployments;
basicStatistics.ServiceDeploymentsNotRunning = serviceDeploymentsNotRunning;
basicStatistics.ServiceDeploymentsRequiringAttention = serviceDeploymentsRequiringAttention;
basicStatistics.ServiceVMs = serviceVMs;
basicStatistics.StandaloneVMs = standaloneVMs;
basicStatistics.VMsNotRunning = vMsNotRunning;
basicStatistics.VMsRequiringAttention = vMsRequiringAttention;
return basicStatistics;
}
public void InitializeBattleStatisics(BasicStatsUIView basicStatsUIView, DuelStatsUIView duelStatsUIView)
{
basicStatistics = new BasicStatistics(statisticsLevelUpdater, basicStatsUIView);
duelStatistics = new DuelStatistics(statisticsLevelUpdater, characterInformation._Level, duelStatsUIView);
}
