void
OLCSprint::UpdateTrace(bool force)
{
/* since this is online, all solutions must have start to end of
trace satisfy the finish altitude requirements. otherwise there
is no point even retrieving the full trace or starting a
search. */
/* assuming a bounded ceiling and very long flight, this would be
expected to reduce the number of trace acquisitions and solution
starts by 50%. In practice the number will be lower than this
but the fewer wasted cpu cycles the better. */
if (trace_master.size() < 2) {
ClearTrace();
return;
}
const TracePoint &first = trace_master.front();
const TracePoint &last = trace_master.back();
if (!IsFinishAltitudeValid(first, last)) {
ClearTrace();
return;
}
ContestDijkstra::UpdateTrace(force);
}
SolverResult
OLCTriangle::Solve(bool exhaustive)
{
if (trace_master.size() < 3) {
ClearTrace();
is_complete = false;
return SolverResult::FAILED;
}
if (!running) {
// branch and bound is currently in finished state, update trace
UpdateTrace(exhaustive);
}
if (!is_complete || running) {
if (n_points < 3) {
ResetBranchAndBound();
return SolverResult::FAILED;
}
if (is_closed)
SolveTriangle(exhaustive);
if (!SaveSolution())
return SolverResult::FAILED;
return SolverResult::VALID;
} else {
return SolverResult::FAILED;
}
}
void CTrace::PrepareTrace() {
mnindex = 0;
ClearTrace();
int nparas = (int)TracedParameters.size();
if (nparas > 0 && mnsize > 0) {
trace = new double*[nparas];
for (int i = 0; i < nparas; i++) { //refactor this later
int size =0;
if (TracedParameters[i] == "alpha" || TracedParameters[i] == "k_star" || TracedParameters[i] == "Nmis" || TracedParameters[i] == "index") {
size = 1;
}
if (TracedParameters[i] == "nu") {
size = m->par->K;
}
if (TracedParameters[i] == "z") {
size = m->par->n;
}
if (TracedParameters[i] == "ImputedX") {
size = m->par->n*m->par->J;
}
if (TracedParameters[i] == "psi") {
size = m->par->K * m->par->cumLevelsJ[m->par->J];
}
if (size > 0) {//always
trace[i] = new double[mnsize * size];
}
}
}
}
SolverResult
ContestDijkstra::Solve(bool exhaustive)
{
assert(num_stages <= MAX_STAGES);
if (trace_master.size() < num_stages) {
/* not enough data in master trace */
ClearTrace();
finished = false;
return SolverResult::FAILED;
}
if (finished || dijkstra.IsEmpty()) {
UpdateTrace(exhaustive);
if (n_points < num_stages)
return SolverResult::FAILED;
// don't re-start search unless we have had new data appear
if (!trace_dirty && !finished)
return SolverResult::FAILED;
} else if (exhaustive || n_points < num_stages ||
CheckMasterSerial()) {
UpdateTrace(exhaustive);
if (n_points < num_stages)
return SolverResult::FAILED;
}
assert(n_points >= num_stages);
if (trace_dirty) {
trace_dirty = false;
finished = false;
dijkstra.Clear();
dijkstra.Reserve(CONTEST_QUEUE_SIZE);
StartSearch();
AddStartEdges();
if (dijkstra.IsEmpty())
return SolverResult::FAILED;
}
SolverResult result = DistanceGeneral(exhaustive ? 0 - 1 : 25);
if (result != SolverResult::INCOMPLETE) {
if (incremental && continuous)
/* enable the incremental solver, which considers the existing
Dijkstra edge map */
finished = true;
else
/* start the next iteration from scratch */
dijkstra.Clear();
if (result == SolverResult::VALID && !SaveSolution())
result = SolverResult::FAILED;
}
return result;
}
void
ContestDijkstra::Reset()
{
dijkstra.Clear();
solution_valid = false;
ClearTrace();
AbstractContest::Reset();
}
void
ContestDijkstra::Reset()
{
dijkstra.Clear();
ClearTrace();
finished = false;
AbstractContest::Reset();
}
void
OLCTriangle::Reset()
{
is_complete = false;
is_closed = false;
best_d = 0;
// set tick_iterations to a default value,
// this should be adjusted when the trace size is known
tick_iterations = 1000;
closing_pairs.Clear();
ClearTrace();
ResetBranchAndBound();
AbstractContest::Reset();
}
CTrace::~CTrace(void)
{
ClearTrace();
}
