public ExtremumSearcher(
eye_tracking_mouse.Options.CalibrationMode starting_mode,
DataSet data_set,
Action <TestResultsInfo> test_results_info_callback,
CancellationToken cancellation_token)
{
this.data_set = data_set;
this.cancellation_token = cancellation_token;
this.test_results_info_callback = test_results_info_callback;
iterator = new CalibrationModeIterator(starting_mode);
handled_extremums.Add(iterator.GetUniqueKey(starting_mode));
extremums_queue.Add(new UtilityAndModePair(0, starting_mode));
}
public static void UniqueKeysAreUnique(eye_tracking_mouse.Options.CalibrationMode mode)
{
var unique_keys = new HashSet <long>();
var iterator = new CalibrationModeIterator(mode);
foreach (var field in iterator.Fields)
{
field.SetFieldValue(mode, field.Min);
}
for (int i = 0; i < 10; i++)
{
foreach (var field in iterator.Fields)
{
if (field.Increment(mode, 1))
{
long key = iterator.GetUniqueKey(mode);
Assert(!unique_keys.Contains(key));
unique_keys.Add(key);
}
}
}
unique_keys.Clear();
foreach (var field in iterator.Fields)
{
field.SetFieldValue(mode, field.Min);
}
long tests_to_run = 1000000;
try
{
ForEachFieldValue(0, iterator.Fields, mode, (x) => {
if (--tests_to_run < 0)
{
throw new NotImplementedException("Удалые пляски на костылях.");
}
else
{
long key = iterator.GetUniqueKey(x);
Assert(!unique_keys.Contains(key));
unique_keys.Add(key);
}
});
} catch (NotImplementedException)
{
Assert(tests_to_run < 0);
}
foreach (var field in iterator.Fields)
{
field.SetFieldValue(mode, field.Min);
}
tests_to_run = 1000001;
try
{
ForEachFieldValue(0, iterator.Fields, mode, (x) => {
if (--tests_to_run < 0)
{
throw new NotImplementedException("Удалые пляски на костылях.");
}
else if (tests_to_run == 0)
{
long key = iterator.GetUniqueKey(x);
Assert(!unique_keys.Contains(key));
}
else
{
long key = iterator.GetUniqueKey(x);
Assert(unique_keys.Contains(key));
}
});
}
catch (NotImplementedException)
{
Assert(tests_to_run < 0);
}
}
public async Task <List <UtilityAndModePair> > SearchNext()
{
if (extremums_queue.Count == 0)
{
return(null);
}
var retval = new List <UtilityAndModePair>();
const int max_tasks_count = 12;
var tasks = new Task <List <UtilityAndModePair> > [Math.Min(max_tasks_count, extremums_queue.Count)];
var new_test_results_array = new Dictionary <long, float> [tasks.Length];
for (int i = 0; i < tasks.Length; i++)
{
new_test_results_array[i] = new Dictionary <long, float>();
var new_test_results = new_test_results_array[i];
var mode = extremums_queue[i].mode;
tasks[i] = Task.Factory.StartNew <List <UtilityAndModePair> >(() =>
{
return(FindNeighbourExtremums(mode, new_test_results));
}, cancellation_token);
}
extremums_queue.RemoveRange(0, tasks.Length);
List <UtilityAndModePair> new_extremums = new List <UtilityAndModePair>();
for (int i = 0; i < tasks.Length; i++)
{
new_extremums.InsertRange(new_extremums.Count, await tasks[i]);
}
// merge cached results
foreach (var new_test_results in new_test_results_array)
{
new_test_results.ToList().ForEach(x =>
{
if (!previous_test_results.ContainsKey(x.Key))
{
previous_test_results.Add(x.Key, x.Value);
}
});
}
foreach (var extremum in new_extremums)
{
long key = iterator.GetUniqueKey(extremum.mode);
if (handled_extremums.Contains(key))
{
continue;
}
handled_extremums.Add(key);
extremums_queue.Add(extremum);
retval.Add(extremum);
}
extremums_queue.Sort((x, y) => {
if (x.utility < y.utility)
{
return(1);
}
if (x.utility == y.utility)
{
return(0);
}
return(-1);
});
QueueInfo = "Queue. Size: " + extremums_queue.Count + " \nContent: ";
for (int i = 0; i < extremums_queue.Count && i < 10; i++)
{
QueueInfo += extremums_queue[i].utility + " ";
}
QueueInfo += "\n Extremums handled: " + handled_extremums.Count() + "\n";
return(retval);
}