public StudentController(IStudent studentManager, ITrainer trainerManager, IBeltEarning beltEarningManager, ITraining trainingManager)
{
this.studentManager = studentManager;
this.beltEarningManager = beltEarningManager;
this.trainerManager = trainerManager;
this.trainingManager = trainingManager;
}
/// <summary>
/// Removes a training from the list.
/// </summary>
/// <param name="training">Training.</param>
public void Delete(ITraining training)
{
if (repository.Contains(training))
{
repository.Remove(training);
}
}
public TrainingController(IRole _irole, IMenu _imenu, ITraining _itraining, IUser _iuser)
{
irole = _irole;
imenu = _imenu;
itraining = _itraining;
iuser = _iuser;
}
/// <summary>
/// Adds a training to the list.
/// </summary>
/// <param name="training">Training.</param>
public void Add(ITraining training)
{
if (!repository.Contains(training))
{
repository.Add(training);
}
}
public void ShowTrainingSingle(ITraining training)
{
ViewParameter par = new ViewParameter(ViewParameter.Action.TrainingShow, this, application);
par.AddParameter(training);
par.AddParameter(application.GetExcercises());
NavigateTo(Views.TrainingSingle, par);
}
public async Task ExportTrainingAsync(ITraining training, string filename, StorageFolder storageFolder)
{
HtmlBuilderTraining htmlBuilder = new HtmlBuilderTraining(training);
// Create sample file; replace if exists.
StorageFile exportFile = await storageFolder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
await FileIO.WriteTextAsync(exportFile, htmlBuilder.GetDocument());
}
public void CreateTrainingFromValues_AllValues_TrainingsNotNull()
{
double repetitions = 25;
ITraining res = _trainingFactory.CreateTrainingFromValues(repetitions, _user, _activity, _trainingDate);
Assert.IsNotNull(res);
}
public ReportController(IReport ireport, IUser iuser,
ICommon icommon, ITraining itraining, ICalendar icalendar)
{
_IReport = ireport;
_IUser = iuser;
_ICommon = icommon;
_ITraining = itraining;
_ICalendar = icalendar;
}
public void CreateTrainingFromValues_AllValues_TrainingsNotSame()
{
double repetitions = 25;
ITraining res = _trainingFactory.CreateTrainingFromValues(repetitions, _user, _activity, _trainingDate);
var expected = new Training(_user, repetitions + 10, _activity, _trainingDate);
Assert.AreNotEqual(expected, res);
}
private bool Validate(ITraining validation)
{
var output = GetOutput(validation.Inputs);
for (int i = 0; i < output.Length; i++)
{
var diff = validation.DesiredOutput[i] - output[i];
if (diff >= 0.5 || diff <= -0.5f)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Adds the meal record.
/// </summary>
/// <param name="item">The meal history record.</param>
/// <returns></returns>
public async Task <ITraining> AddMealRecord(ITraining item)
{
var wrappedRecord = item as Training;
var newMealRecord = wrappedRecord != null?wrappedRecord.UnwrapDataObject() : item;
if (newMealRecord != null)
{
using (var dietyContext = DietyDbContext)
{
DietyDbContext.Trainings.Add(newMealRecord as TrainingDb);
await DietyDbContext.SaveChangesAsync();
}
}
return(item);
}
public HomeController(IUser iuser, ITraining itraining,
IPdfSharpService pdfService, IMentor mentor,
IInternal iinternal, IAllocation allocation,
IAspiration aspiration, ILog log,
IMigraDocService migraDocService)
{
_IUser = iuser;
_ITraining = itraining;
_pdfService = pdfService;
_IMentor = mentor;
_IInternal = iinternal;
_IAllocation = allocation;
_IAspiration = aspiration;
_ILog = log;
_migraDocService = migraDocService;
}
//crée un training
public ITraining Create(ITraining training)
{
using (var connection = Database.GetConnection())
{
connection.Open();
var cmd = connection.CreateCommand();
cmd.CommandText = TrainingSqlServer.ReqCreate;
cmd.Parameters.AddWithValue($"@{TrainingSqlServer.ColIdTrainingDate}", training.TrainingDate.Id);
cmd.Parameters.AddWithValue($"@{TrainingSqlServer.ColIdActivity}", training.Activity.Id);
cmd.Parameters.AddWithValue($"@{TrainingSqlServer.ColIdUser}", training.User.Id);
cmd.Parameters.AddWithValue($"@{TrainingSqlServer.ColRepetitions}", training.Repetitions);
training.Id = (int)cmd.ExecuteScalar();
}
return(training);
}
/// <summary>
/// Creates the edit training view.
/// </summary>
/// <param name="trainingInfo">The training information.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">trainingInfo</exception>
public ITrainingView CreateEditTrainingView(ITraining trainingInfo)
{
if (trainingInfo == null)
{
throw new ArgumentNullException(nameof(trainingInfo));
}
var returnTraining = new TrainingView
{
TrainingID = trainingInfo.TrainingID,
TrainingName = trainingInfo.TrainingName,
CompanyID = trainingInfo.CompanyID,
IsActive = trainingInfo.IsActive,
DateCreated = trainingInfo.DateCreated,
TrainingDescription = trainingInfo.TrainingDescription,
};
return(returnTraining);
}
public HtmlBuilderTraining(ITraining training)
{
AddTitle(training.Name);
AddParagraph(training.Description);
string categoriesString = "";
foreach (IExcercise excercise in training.Excercises)
{
// Concatenate the categories
if (excercise.Categories.Count > 0)
{
categoriesString = excercise.Categories[0].Name;
for (int i = 1; i < excercise.Categories.Count; i++)
{
categoriesString += ", " + excercise.Categories[i].Name;
}
}
AddSection(excercise.Name, categoriesString, excercise.Description);
}
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
Object[] param = e.Parameter as Object[];
if (param != null)
{
parameter = new ViewParameter(param);
gui = parameter.GetGui();
application = parameter.GetApplication();
// Since we do not need the parameter any more, overwrite them
param = parameter.GetParameter();
switch (parameter.GetAction())
{
case ViewParameter.Action.TrainingCreate:
excercisesAll = param[0] as ObservableCollection <Excercise>;
training = new Training();
Editable = true;
break;
case ViewParameter.Action.TrainingShow:
training = param[0] as ITraining;
excercisesAll = param[1] as ObservableCollection <Excercise>;
Editable = false;
break;
case ViewParameter.Action.TrainingEdit:
training = param[0] as ITraining;
excercisesAll = param[1] as ObservableCollection <Excercise>;
trainingTmp = new Training(training.ID, training.Name, training.Description, training.Excercises);
Editable = true;
break;
default:
throw new NotImplementedException();
}
}
base.OnNavigatedTo(e);
}
private static void subTestOptimization1(ITraining bprop, double[][] x, double[][] y, double[][] tx, double[][] ty)
{
GaussianRule2[] terms = new GaussianRule2[] { new GaussianRule2() };
terms[0].Init(
new double[] { 0.5, 0.3 },
new double[] { 0 },
new double[] { 0.0, 0.0 });
int epoch = 0;
int maxit = 1000;
double trnError = 0.0;
double tstError = 0.0;
do
{
trnError = bprop.Iteration(x, y, terms);
tstError = bprop.Error(tx, ty, terms);
} while (!bprop.isTrainingstoped() && epoch++ < maxit);
Trace.WriteLine(string.Format("Epochs {0} - Error {1}/{2}", epoch, trnError, tstError), "training");
Assert.IsFalse(tstError > 1e-2);
Assert.IsFalse(trnError > 1e-2);
Assert.AreEqual(terms[0].Z[0], 1.0, 1e-2);
}
private void Solve(double[][] x, double[][] y, double[][] tx, double[][] ty, ITraining bprop)
{
KMEANSExtractorI extractor = new KMEANSExtractorI(int.Parse(txtbxRulesCount.Text));
var timer = Stopwatch.StartNew();
var fis = ANFISBuilder <GaussianRule2> .Build(x, y, extractor, bprop, int.Parse(txtbxMaxIterCount.Text));
timer.Stop();
double err = bprop.Error(tx, ty, fis.RuleBase);
string line = "";
double correctClass = 0;
for (int i = 0; i < tx.Length; i++)
{
double[] o = fis.Inference(tx[i]);
if (tx[i].Length == 4 && o.Length == 3)
{
line = $"input: [{tx[i][0]}, {tx[i][1]}, {tx[i][2]}, {tx[i][3]}] output:[{o[0].ToString("F2")}, {o[1].ToString("F2")}, {o[2].ToString("F2")}] expected output: [{ty[i][0]}, {ty[i][1]}, {ty[i][2]}]";
}
for (int j = 0; j < ty[i].Length; j++)
{
if (ty[i][j] == 1.0 && o[j] == o.Max())
{
correctClass++;
line += " OK";
}
}
if (tx[i].Length == 4 && o.Length == 3)
{
InMemoryLogger.PrintMessage(line);
}
}
InMemoryLogger.PrintMessage(string.Format("Correct answers {5}\tClassification Error {4}\tElapsed {2}\tRuleBase {3}", err, bprop.GetType().Name, timer.Elapsed, fis.RuleBase.Length, 1.0 - correctClass / ty.Length, correctClass));
}
private static void subtestIris(double[][] x, double[][] y, double[][] tx, double[][] ty, ITraining bprop)
{
KMEANSExtractorI extractor = new KMEANSExtractorI(15);
var timer = Stopwatch.StartNew();
ANFIS fis = ANFISBuilder <GaussianRule2> .Build(x, y, extractor, bprop, 1000);
timer.Stop();
double err = bprop.Error(tx, ty, fis.RuleBase);
double correctClass = 0;
for (int i = 0; i < tx.Length; i++)
{
double[] o = fis.Inference(tx[i]);
for (int j = 0; j < ty[i].Length; j++)
{
if (ty[i][j] == 1.0 && o[j] == o.Max())
{
correctClass++;
}
}
}
Trace.WriteLine(string.Format("[{1}]\tIris Dataset Error {0} Classification Error {4}\tElapsed {2}\tRuleBase {3}", err, bprop.GetType().Name, timer.Elapsed, fis.RuleBase.Length, 1.0 - correctClass / ty.Length), "training");
Assert.IsFalse(ty.Length - correctClass > 2);
}
public void DeleteTraining(ITraining training)
{
database.Delete(training);
}
/// <summary>
/// Updates a training.
/// </summary>
/// <param name="training">Training.</param>
public void Update(ITraining training)
{
}
public TrainingController(ITraining training)
{
this._training = training;
}
public void DeleteExcerciseOfTraining(ITraining training, int excerciseIndex)
{
database.Delete(training, excerciseIndex);
}
public TrainingController(ITraining trainingManager, ITrainer trainerManager)
{
this.trainingManager = trainingManager;
this.trainerManager = trainerManager;
}
public CalendarController(ICalendar icalendar, IUser iuser, ITraining itraining)
{
_ICalendar = icalendar;
_IUser = iuser;
_ITraining = itraining;
}
/// <summary>
/// Removes a training from the backend service.
/// </summary>
/// <param name="training">Training.</param>
public void Delete(ITraining training)
{
throw new NotImplementedException();
}
public TrainingsController(ITraining trainingManager)
{
this.trainingManager = trainingManager;
}
static Logger _log = new Logger("ABuilder", InternalTraceLevel.Default, TextWriter.Null); // LogManager.GetLogger("ABuilder");
public static ANFIS Build(double[][] input, double[][] output, IRuleExtractor RuleExtractor, ITraining trainer, int MaxIterations)
{
_log.Info("Start...");
_log.Info($"Constructing initial rule set with [{RuleExtractor.GetType().Name}]");
var ruleBase = RuleSetFactory <R> .Build(input, output, RuleExtractor).Select(z => z as IRule).ToList();
_log.Info($"Get {ruleBase.Count} initial rules.");
int epoch = 0;
double trnError = 0.0;
Console.WriteLine();
Console.WriteLine();
do
{
trnError = trainer.Iteration(input, output, ruleBase);
_log.Info($"Epoch {epoch}, training error {trnError}");
if (double.IsNaN(trnError))
{
_log.Info("Failure! Training error is NAN.");
throw new Exception("Failure! Bad system design.");
}
} while (!trainer.isTrainingstoped() && epoch++ < MaxIterations);
ANFIS fis = new ANFIS(ruleBase);
_log.Info("Done");
return(fis);
}
public MentorController(ITraining itraining, IUser iuser, IMentor imentor)
{
_ITraining = itraining;
_IUser = iuser;
_IMentor = imentor;
}
private static void subtestLogisticsMap <T>(double[][] x, double[][] y, double[][] tx, double[][] ty, ITraining bprop) where T : IRule, new()
{
KMEANSExtractorIO extractor = new KMEANSExtractorIO(10);
var timer = Stopwatch.StartNew();
ANFIS fis = ANFISBuilder <T> .Build(x, y, extractor, bprop, 1000);
timer.Stop();
double err = bprop.Error(tx, ty, fis.RuleBase);
Trace.WriteLine(string.Format("[{1} - {4}]\tLogistic map Error {0}\tElapsed {2}\tRuleBase {3}", err, bprop.GetType().Name, timer.Elapsed, fis.RuleBase.Length, typeof(T).Name), "training");
Assert.IsFalse(err > 1e-2);
}
