//------------------- search ----------------------
void CIncrementalImprovement::search(){
int trial;
//Генерируем случайное решение
while (_Add());
//Сохраняем найденное решение
BestCost = CurCost;
BestProfit = CurProfit;
for (int i = 0; i < NumItem; i++) best[i] = cur[i];
//Несколько раз удаляем произвольную инвестицию и добавляем новую(ые) и сохраняем лучшее
for (trial = 0; trial < NumItem; trial++){
//Удаляем произвольную инвестицию
_Del();
//Случайный выбор до тех пор, пока не исчерпан лимит средств
while (_Add());
//Лучше полученное решение предыдущего?
//Если Да, то сохраняем изменения, если Нет, то отказываемся от полученного решения
if (CurProfit > BestProfit){
BestProfit = CurProfit;
BestCost = CurCost;
for (int i = 0; i < NumItem; i++) best[i] = cur[i];
}
else{
CurProfit = BestProfit;
CurCost = BestCost;
for (int i = 0; i < NumItem; i++) cur[i] = best[i];
}
}
}
//------------------- search ----------------------
void CStopMoment::search(){
int bad_trials, non_changes;
bad_trials = 0;
//Испытания повторяются до тех пор,
//пока не досигнем NumItem испытаний в строке без изменений
do{
//Генерируем случайное решение
while (_Add());
//Начинаем работать с этим решением как с испытываемым
int trial_cost = CurCost;
int trial_profit = CurProfit;
bool *trial_bool = new bool[NumItem];
for (int i = 0; i < NumItem; i++) trial_bool[i] = cur[i];
//Повторяем до тех пор, пока не попробуем
//NumItem изменений в строке без улучшения
non_changes = 0;
while (non_changes < NumItem){
//Удаление случайного элемента
_Del();
//Случайный выбор до тех пор, пока не исчерпан лимит средств
while (_Add());
//Если это улучшает решение, сохраняем его,
//в противном случае востанавливаем исходные значения
if (CurProfit > trial_profit){
trial_profit = CurProfit;
trial_cost = CurCost;
for (int i = 0; i < NumItem; i++) trial_bool[i] = cur[i];
non_changes = 0; //Это хооршее изменение
}
else{
CurProfit = trial_profit;
CurCost = trial_cost;
for (int i = 0; i < NumItem; i++) cur[i] = trial_bool[i];
++non_changes; //Это плохое изменение
}
} //Конец While - попытки изменения
//Если испытание является наилучшим решением на данный момент,
//сохраняем его
if (trial_profit > BestProfit){
BestProfit = trial_profit;
BestCost = trial_cost;
for (int i = 0; i < NumItem; i++) best[i] = trial_bool[i];
bad_trials=0; // Это хорошее испытание
}
else ++bad_trials; //Это плохое испытание
//Сброс исследуемого решения для следующего испытания
CurProfit = 0;
CurCost = 0;
for (int i = 0; i < NumItem; i++) cur[i] = false;
}
while (bad_trials >= NumItem);
}
fssh_status_t
FileMap::_Cache(fssh_off_t offset, fssh_off_t size)
{
file_extent* lastExtent = NULL;
if (fCount > 0)
lastExtent = ExtentAt(fCount - 1);
fssh_off_t mapEnd = 0;
if (lastExtent != NULL)
mapEnd = lastExtent->offset + lastExtent->disk.length;
fssh_off_t end = offset + size;
if (fCacheAll && mapEnd < end)
return FSSH_B_ERROR;
fssh_status_t status = FSSH_B_OK;
fssh_file_io_vec vecs[8];
const fssh_size_t kMaxVecs = 8;
while (status == FSSH_B_OK && mapEnd < end) {
// We don't have the requested extents yet, retrieve them
fssh_size_t vecCount = kMaxVecs;
status = vfs_get_file_map(Vnode(), mapEnd, FSSH_SIZE_MAX, vecs,
&vecCount);
if (status == FSSH_B_OK || status == FSSH_B_BUFFER_OVERFLOW)
status = _Add(vecs, vecCount, mapEnd);
}
return status;
}
void QuadTree::_Add(Node* node, SpatialNode* newElement)
{
if( node->pChild_NW == NULL )//if 1 is NULL then all are NULL
{
if( node->ElementsPts.size()+1 > m_MaxNodeLeaf )
{
node->pChild_NW = new Node(node->Volume.m_MinX, node->Volume.m_MinY, (node->Volume.m_MinX+node->Volume.m_MaxX)/2.0f, (node->Volume.m_MinY+node->Volume.m_MaxY)/2.0f);
node->pChild_NE = new Node((node->Volume.m_MinX+node->Volume.m_MaxX)/2.0f, node->Volume.m_MinY, node->Volume.m_MaxX, (node->Volume.m_MinY+node->Volume.m_MaxY)/2.0f);
node->pChild_SW = new Node(node->Volume.m_MinX, (node->Volume.m_MinY+node->Volume.m_MaxY)/2.0f, (node->Volume.m_MinX+node->Volume.m_MaxX)/2.0f, node->Volume.m_MaxY);
node->pChild_SE = new Node((node->Volume.m_MinX+node->Volume.m_MaxX)/2.0f, (node->Volume.m_MinY+node->Volume.m_MaxY)/2.0f, node->Volume.m_MaxX, node->Volume.m_MaxY);
for(int i=0; i < node->ElementsPts.size() ; ++i)
_Add(node, node->ElementsPts[i]);
node->ElementsPts.clear();
}else
{
node->ElementsPts.push_back(newElement);
return;
}
}
sf::Vector2<float> pos = newElement->GetPosition();
if( node->pChild_NW->IsInside(pos) )
{
_Add(node->pChild_NW, newElement);
}else if( node->pChild_NE->IsInside(pos) )
{
_Add(node->pChild_NE, newElement);
}else if( node->pChild_SW->IsInside(pos) )
{
_Add(node->pChild_SW, newElement);
}else if( node->pChild_SE->IsInside(pos) )
{
_Add(node->pChild_SE, newElement);
}
}
//------------------- search ----------------------
void CRandomSearchMod::search(){
int trial;
//делаем несколько испытаний и сохраняем лучшее
for (trial = 0; trial < NumItem; trial++){
//Случайный выбор до тех пор, пока не исчерпан лимит средств
while (_Add());
//Лучше полученное решение предыдущего?
if (CurProfit > BestProfit){
BestProfit = CurProfit;
BestCost = CurCost;
for (int i = 0; i < NumItem; i++) best[i] = cur[i];
}
//Сброс исследуемого решения для следующего испутания
CurProfit = 0;
CurCost = 0;
for (int i = 0; i < NumItem; i++) cur[i] = false;
}
}
void QuadTree::Construct(std::vector<SpatialNode*> Elements)
{
Clear();
for(int i=0; i < Elements.size() ; ++i)
_Add(&m_Root, Elements[i]);
}
void QuadTree::AddElement(SpatialNode* newElement)
{
_Add(&m_Root, newElement);
}
// ------------------ search ----------------------
void CLocalOptimum::search()
{
int bad_tests, // кол-во неэффективных испытаний
bad_changes; // кол-во неэффективных изменений
trial = new bool[NumItem];
// Испытания поторяются до тех пор, пока
// не произойдет max_bad_test испытаний без улучшений.
bad_tests = 0;
while (bad_tests <= max_bad_tests)
{
// формирование начального случайного решения
while (_Add());
TrialProfit = CurProfit;
TrialCost = CurCost;
for (int i=0; i<NumItem; i++)
trial[i] = cur[i];
// Повторять до max_bad_changes отсутствия улучшений в решениях.
bad_changes = 0;
while (bad_changes <= max_bad_changes)
{
// Удаление num случайных элементов
for (int i=0; i<num; i++)
_Del();
// Добавление num случайных элементов
while (_Add());
// Если данное изменение улучшает решение, то сохраняю его.
// Иначе восстанавливаю предыдущее.
if (CurProfit > TrialProfit)
{
// Сохранение решения
TrialProfit = CurProfit;
TrialCost = CurCost;
copybool(cur, trial);
bad_changes = 0; // Сброс счетчика плохих изменений
} else
{
// Восстановление решения
CurProfit = TrialProfit;
CurCost = TrialCost;
copybool(trial, cur);
++bad_changes; // Очередное плохое изменение
}
} // while (bad_changes <= max_bad_changes)
// Если это испытание лучше лучшего, то его нужно сохранить.
if (TrialProfit > BestProfit)
{
BestProfit = TrialProfit;
BestCost = TrialCost;
copybool(trial, best);
bad_tests = 0; // Сброс счетчика прохих решений
} else
++bad_tests; // Очередное плохое решение
// Очистка текущего решения
CurProfit = 0;
CurCost = 0;
for (int i=0; i<NumItem; i++)
cur[i] = false;
}
delete[] trial;
}
// ------------------ search ----------------------
void CSimulatedAnnealing::search()
{
if (NumItem < 2) return;
// поиск максимальной и минимальной прибыли
int max_profit = invest[0].profit,
min_profit = max_profit;
for (int i=1; i<NumItem; i++)
{
if (max_profit < invest[i].profit)
max_profit = invest[i].profit;
if (min_profit > invest[i].profit)
min_profit = invest[i].profit;
}
// начальное значение T
float T = 0.75 * (max_profit - min_profit);
// формирование начального случайного решения
while (_Add());
// принятия случайного решения как лучшего
BestProfit = CurProfit;
BestCost = CurCost;
for (int i=0; i<NumItem; i++)
best[i] = cur[i];
int num_save = 0,
num_unch = 0;
bool save_changed,
save;
while (num_unch < MaxUnchanged)
{
// удаление K_ch случайных элементов
for (int i=0; i<K_ch; i++)
_Del();
// добавление K_ch случайных элементов
while (_Add());
// если есть улучшение
if (CurProfit > BestProfit)
{
save_changed = true;
save = false;
} else
if (CurProfit == BestProfit)
{ // формула вероятности даст 1
save = save_changed = false;
} else
{ // нужно ли сохранять решение
save = save_changed = (rand() < expl(abs(CurProfit - BestProfit)/T));
}
// если нужно сохранить новое решение
if (save_changed)
{
// сохраняю новое решение
BestProfit = CurProfit;
BestCost = CurCost;
copybool(cur, best);
num_unch = 0; // было сохранено изменение
} else
{ // восстановление пердыдущего решения
CurProfit = BestProfit;
CurCost = BestCost;
copybool(best, cur);
++num_unch;
}
// если сохранено решение, которое НЕ ЛУЧШЕ предыдущего
if (save)
{
if (++num_save > MaxSaved)
{
num_save = 0;
T *= 0.8;
num_unch = 0;
}
} // if (save)
} // while (num_unch < MaxUnchanged)
}
