public void AppClassMark(ClassMarkViewModel model)
{
using (UnitOfWork.UnitOfWork uow = new UnitOfWork.UnitOfWork())
{
var mark = new ClassMark
{
Student_No = model.Student_No,
Student_name = model.Student_name,
ClassGroupe_id = model.ClassGroupe_id,
Subject1 = model.Subject1,
Subject2 = model.Subject2,
mark = model.mark,
mark12 = model.mark12,
mark21 = model.mark21,
mark23 = model.mark32,
mark32 = model.mark32,
Subject3 = model.Subject3,
Subject4 = model.Subject4,
Subject5 = model.Subject5,
};
uow.Repository <ClassMark>().Insert(mark);
uow.Save();
}
}
public void AddTrainingSignal(short[] signal, ClassMark[] expectedOutput)
{
if (signal.Length != expectedOutput.Length)
throw new Exception("Signal length and marks count must be equal.");
var features = CalculateFeatures(signal);
for (var i = 0; i < signal.Length; i ++)
{
trainingExamples.Add(new TrainingExample(features[i], expectedOutput[i]));
}
}
public ClassMark[] Decompress(int dataLength)
{
var ret = new ClassMark[dataLength];
for (var index = 0; index < ret.Length; index++)
{
ret[index] = ClassMark.Undefined;
}
foreach (var interval in Intervals)
{
for (var i = interval.LeftBound; i < interval.RightBound; i++)
{
if (ret[i] != ClassMark.Undefined)
{
throw new Exception(string.Format("Sample {0} are defined twice in file {1}.", i, pathName));
}
ret[i] = interval.Mark;
}
}
for (var i = 0; i < dataLength; i++)
{
if (ret[i] == ClassMark.Undefined)
{
throw new Exception(string.Format("Sample {0} are undefined in file {1}.", i, pathName));
}
}
return ret;
}
public void Add(StudentResult type)
{
lock (type)
{
if (Count == Date.Length)
{
var newLength = Date.Length + 1000;
var _Date = new System.DateTime[newLength];
Date.CopyTo(_Date);
Date = _Date;
var _ExamResultId = new string[newLength];
ExamResultId.CopyTo(_ExamResultId);
ExamResultId = _ExamResultId;
var _StudentId = new string[newLength];
StudentId.CopyTo(_StudentId);
StudentId = _StudentId;
var _AcademicYear = new string[newLength];
AcademicYear.CopyTo(_AcademicYear);
AcademicYear = _AcademicYear;
var _Semester = new string[newLength];
Semester.CopyTo(_Semester);
Semester = _Semester;
var _Credit = new int[newLength];
Credit.CopyTo(_Credit);
Credit = _Credit;
var _ProgramId = new string[newLength];
ProgramId.CopyTo(_ProgramId);
ProgramId = _ProgramId;
var _Level = new string[newLength];
Level.CopyTo(_Level);
Level = _Level;
var _RegisteredCourseId = new string[newLength];
RegisteredCourseId.CopyTo(_RegisteredCourseId);
RegisteredCourseId = _RegisteredCourseId;
var _Grade = new string[newLength];
Grade.CopyTo(_Grade);
Grade = _Grade;
var _GradePoint = new decimal[newLength];
GradePoint.CopyTo(_GradePoint);
GradePoint = _GradePoint;
var _ClassMark = new decimal[newLength];
ClassMark.CopyTo(_ClassMark);
ClassMark = _ClassMark;
var _ExamMark = new decimal[newLength];
ExamMark.CopyTo(_ExamMark);
ExamMark = _ExamMark;
var _TotalMark = new decimal[newLength];
TotalMark.CopyTo(_TotalMark);
TotalMark = _TotalMark;
var _Scoring = new bool[newLength];
Scoring.CopyTo(_Scoring);
Scoring = _Scoring;
var _LecturerId = new string[newLength];
LecturerId.CopyTo(_LecturerId);
LecturerId = _LecturerId;
}
Date.Span[Count] = type.Date;
ExamResultId.Span[Count] = type.ExamResultId;
StudentId.Span[Count] = type.StudentId;
AcademicYear.Span[Count] = type.AcademicYear;
Semester.Span[Count] = type.Semester;
Credit.Span[Count] = type.Credit;
ProgramId.Span[Count] = type.ProgramId;
Level.Span[Count] = type.Level;
RegisteredCourseId.Span[Count] = type.RegisteredCourseId;
Grade.Span[Count] = type.Grade;
GradePoint.Span[Count] = type.GradePoint;
ClassMark.Span[Count] = type.ClassMark;
ExamMark.Span[Count] = type.ExamMark;
TotalMark.Span[Count] = type.TotalMark;
Scoring.Span[Count] = type.Scoring;
LecturerId.Span[Count] = type.LecturerId;
}
}
public TrainingExample(FeatureVector features, ClassMark expected)
{
Features = features;
Expected = expected;
}
private static short ConvertClassMark(ClassMark r)
{
return r == ClassMark.Tone ? (short)5000 : (short)-5000;
}
private static int GetErrorsCount(ClassMark[] actual, ClassMark[] expected)
{
return Enumerable.Range(0, actual.Length).Count(i => actual[i] != expected[i]);
}
