internal void CompareDataAnalyserReports(DataAnalyserReport expected, DataAnalyserReport actual)
{
Assert.Equal(expected.TotalAmountOfTests, actual.TotalAmountOfTests);
Assert.Equal(expected.PersonStatistics.Count, actual.PersonStatistics.Count);
foreach (var key in expected.PersonStatistics.Keys)
{
Assert.True(actual.PersonStatistics.ContainsKey(key));
ComparePersonStatistics(expected.PersonStatistics[key],
actual.PersonStatistics[key]);
}
Assert.Equal(expected.ResultDistribution, actual.ResultDistribution);
Assert.Equal(expected.QuestionStatistics.Count, actual.QuestionStatistics.Count);
foreach (var key in expected.QuestionStatistics.Keys)
{
Assert.True(actual.QuestionStatistics.ContainsKey(key));
CompareQuestionStatistics(expected.QuestionStatistics[key],
actual.QuestionStatistics[key]);
}
Assert.Equal(expected.AmountOfUniqueEmails, actual.AmountOfUniqueEmails);
Assert.Equal(expected.AttemptDistribution, actual.AttemptDistribution);
}
/// <summary>
/// Analyzes new information and adds data to an existing report
/// </summary>
/// <param name="report">An existing report</param>
/// <param name="newData">Collection of new tests</param>
public static void AddNewData(this DataAnalyserReport report, IEnumerable <PersonTestResult> newData)
{
foreach (var el in newData)
{
AddNewData(report, el);
}
}
public static void ToStream(Stream stream, DataAnalyserReport report, int bufferSize = 4 * 1024)
{
using (var writer = new StreamWriter(stream, Encoding.UTF8, bufferSize, true))
{
writer.WriteLine("Всего тестов: {0}", report.TotalAmountOfTests);
writer.WriteLine("Количество уникальных e-mail'ов: {0}\n", report.AmountOfUniqueEmails);
writer.WriteLine("Распределение попыток:");
for (var i = 0; i < report.AttemptDistribution.Length; i++)
{
if (report.AttemptDistribution[i] != 0)
{
writer.WriteLine("{0}: {1}", i + 1, report.AttemptDistribution[i]);
}
}
writer.WriteLine();
writer.WriteLine("Распределение результатов:");
foreach (var el in report.ResultDistribution)
{
writer.WriteLine("{0}: {1}", el.Key, el.Value);
}
writer.WriteLine();
writer.WriteLine("Статистика вопросов:");
foreach (var el in report.QuestionStatistics)
{
writer.WriteLine("Вопрос: {0}\nПравильных ответов: {1}, неправильных: {2}, всего: {3}\n" +
"Правильный ответ: {4}, а люди отвечали 0:{5} 1:{6} 2:{7} 3:{8}\n",
el.Key, el.Value.RightAnswersAmount, el.Value.WrongAnswersAmount,
el.Value.RightAnswersAmount + el.Value.WrongAnswersAmount,
el.Value.RightAnswerIndex, el.Value.AnswersDistribution[0], el.Value.AnswersDistribution[1],
el.Value.AnswersDistribution[2], el.Value.AnswersDistribution[3]);
}
(var kDistribution, var bDistribution) = report.GetAdditionalInfo();
if (kDistribution != null && bDistribution != null)
{
writer.WriteLine("Распределение коэффициента K:");
foreach (var el in kDistribution.Intervals)
{
writer.WriteLine("В интервале от {0:F2} и до {1:F2}: {2}",
el.LeftBorder, el.RightBorder, el.NumericsAmount);
}
writer.WriteLine();
writer.WriteLine("Распределение коэффициента B:");
foreach (var el in bDistribution.Intervals)
{
writer.WriteLine("В интервале от {0:F2} и до {1:F2}: {2}",
el.LeftBorder, el.RightBorder, el.NumericsAmount);
}
writer.WriteLine();
}
}
}
public void ToStream(Stream stream, DataAnalyserReport report)
{
_main.Write("Всего тестов:");
_main.WriteLine(report.TotalAmountOfTests);
_main.Write("Количество уникальных e-mail'ов:");
_main.WriteLine(report.AmountOfUniqueEmails);
BuildAttemptDistributionChart(report.AttemptDistribution);
BuildResultDistributionChart(report.ResultDistribution);
(var kDistr, var bDistr) = report.GetAdditionalInfo();
if (kDistr != null && bDistr != null)
{
BuildNumericDistributionChart(kDistr, "KDistribution", "Распределение коэффициента K");
BuildNumericDistributionChart(bDistr, "BDistribution", "Распределение коэффициента B");
var distr = new DoubleNumericDistribution(kDistr.LeftBorder, kDistr.RightBorder,
bDistr.LeftBorder, bDistr.RightBorder, 10);
foreach (var el in report.PersonStatistics)
{
if (el.Value.AdditionalInfo != null)
{
distr.AddNumerics(el.Value.AdditionalInfo.Value.K,
el.Value.AdditionalInfo.Value.B,
el.Value.AdditionalInfo.Value.R);
}
}
BuildKAndBDistributionsChart(distr);
BuildSigmaMinDistributionChart(distr);
BuildSigmaMaxDistributionChart(distr);
}
foreach (var el in report.QuestionStatistics)
{
BuildQuestionStatistics(el);
}
_package.SaveAs(stream);
}
/// <summary>
/// Analyzes new information and adds data to an existing report
/// </summary>
/// <param name="report">An existing report</param>
/// <param name="newData">Information about new test</param>
public static void AddNewData(this DataAnalyserReport report, PersonTestResult newData)
{
if (!report.PersonStatistics.ContainsKey(newData.Person.Email))
{
report.PersonStatistics.Add(newData.Person.Email, new PersonStatistics());
}
report.PersonStatistics[newData.Person.Email].Results.Add(newData.Result);
CalculateAdditionalInfo(report.PersonStatistics[newData.Person.Email]);
if (!report.ResultDistribution.ContainsKey(newData.Result))
{
report.ResultDistribution.Add(newData.Result, 0U);
}
report.ResultDistribution[newData.Result]++;
report.TotalAmountOfTests++;
foreach (var answer in newData.Answers)
{
if (!report.QuestionStatistics.ContainsKey(answer.Question.QuestionText))
{
report.QuestionStatistics.Add(answer.Question.QuestionText, new QuestionStatistics());
}
var el = report.QuestionStatistics[answer.Question.QuestionText];
if (answer.AnswerIndex == answer.Question.CorrectAnswerIndex)
{
el.RightAnswersAmount++;
}
else
{
el.WrongAnswersAmount++;
}
el.RightAnswerIndex = answer.Question.CorrectAnswerIndex;
el.AnswersDistribution[answer.AnswerIndex]++;
}
}
/// <summary>
/// Performs data analysis
/// </summary>
/// <param name="data">Data for analysis</param>
/// <param name="minNumberForAdvStat">Minimum number of tests for one person to build advanced statistics</param>
/// <returns>Report</returns>
public static DataAnalyserReport Analyze(IEnumerable <PersonTestResult> data, uint minNumberForAdvStat = 4)
{
_minNumberForAdvStat = minNumberForAdvStat;
var report = new DataAnalyserReport();
// Collection of pair <Email, Amount of attempts>
var personStatistics = new Dictionary <string, PersonStatistics>();
// Collection of pair <Result, Amount>
var resultDistribution = new Dictionary <uint, uint>();
// Statistics on questions
var qStatistics = new Dictionary <string, QuestionStatistics>();
var totalAmount = 0U;
var maxNumberOfAttempts = 0U;
var personWithMaxNumberOfAttempts = "";
foreach (var testResult in data)
{
if (!personStatistics.ContainsKey(testResult.Person.Email))
{
personStatistics.Add(testResult.Person.Email, new PersonStatistics());
}
personStatistics[testResult.Person.Email].Results.Add(testResult.Result);
if (personStatistics[testResult.Person.Email].AmountOfAttempts > maxNumberOfAttempts)
{
maxNumberOfAttempts = personStatistics[testResult.Person.Email].AmountOfAttempts;
personWithMaxNumberOfAttempts = testResult.Person.Email;
}
if (!resultDistribution.ContainsKey(testResult.Result))
{
resultDistribution.Add(testResult.Result, 0);
}
resultDistribution[testResult.Result]++;
totalAmount++;
// Collect statistics on questions
foreach (var answer in testResult.Answers)
{
if (!qStatistics.ContainsKey(answer.Question.QuestionText))
{
qStatistics.Add(answer.Question.QuestionText, new QuestionStatistics());
}
if (answer.AnswerIndex == answer.Question.CorrectAnswerIndex)
{
qStatistics[answer.Question.QuestionText].RightAnswersAmount++;
}
else
{
qStatistics[answer.Question.QuestionText].WrongAnswersAmount++;
}
qStatistics[answer.Question.QuestionText].AnswersDistribution[answer.AnswerIndex]++;
qStatistics[answer.Question.QuestionText].RightAnswerIndex = answer.Question.CorrectAnswerIndex;
}
}
foreach (var pStatistics in personStatistics)
{
CalculateAdditionalInfo(pStatistics.Value);
}
report.TotalAmountOfTests = totalAmount;
report.PersonStatistics = personStatistics;
report.ResultDistribution = resultDistribution;
report.QuestionStatistics = qStatistics;
return(report);
}
