Stores NetworkManager::getStoreCandidates()
{
Stores result;
while( !depthSearcher->isExhausted() )
{
Elements elements = depthSearcher->getElementCandidates();
cerr << "[NM]\tDepth search returned " << elements.size() << endl;
for ( Elements::iterator i = elements.begin(); i != elements.end(); i++ )
{
Element * element = *i;
if ( ! element->isStore() )
continue;
Store * store = (Store *) element;
if ( rejectedStores.find(store) != rejectedStores.end() )
continue;
result.insert(store);
}
depthSearcher->increaseSearchSpace();
if ( !result.empty() )
break;
}
rejectedStores.insert(result.begin(), result.end());
cerr << "[NM]\tPrepared " << result.size() << " candidates" << endl;
return result;
}
int Environment::loadSkin(char *fSkinDirectory)
{
Elements *fOldElements = mElements;
Resources *fOldResources = mResources;
struct stat sbuf;
char buf[255];
sprintf(buf, "%sskin.xml", fSkinDirectory);
printf("Loading %s\n", buf);
if (stat(buf, &sbuf)) {
return 0;
}
xmlDoc *theDoc = 0;
xmlNode *theRoot = 0;
theDoc = xmlReadFile(buf, NULL, 0);
if (theDoc == NULL) {
return 0;
}
theRoot = xmlDocGetRootElement(theDoc);
xmlNode *fNode = theRoot->children;
while (fNode) {
if (!strcmp((char *) fNode->name, "Resources") && fNode->children) {
Resources *t = new Resources();
t->xmlConfigure(fNode->children);
setResources(t);
} else if (!strcmp((char *) fNode->name, "Elements") && fNode->children) {
Elements *t = new Elements();
t->xmlConfigure(fNode->children);
setElements(t);
}
fNode = fNode->next;
}
if (fOldElements != mElements && fOldElements) {
delete fOldElements;
}
if (fOldResources != mResources && fOldResources) {
delete fOldResources;
}
setSkinPath(fSkinDirectory);
debugPrint(" Loading resources\n");
mResources->loadResources();
debugPrint(" Associating resources & elements\n");
mElements->associateResources(mResources);
xmlFreeDoc(theDoc);
return 1;
}
bool check_count(Elements const& elements)
{
// root may contain count < min but should never contain count > max
return elements.size() <= m_parameters.get_max_elements()
&& ( elements.size() >= m_parameters.get_min_elements()
|| m_current_level == 0 );
}
void AnimationContainer::Run()
{
// 在更新所有元素后通知观察者. 如果所有元素在更新时都被删除, 那么我们的引用计数
// 将会变为0, 在通知观察者后也会被删除. 这里添加一次引用保证遍历所有元素后对象
// 还是合法的.
scoped_refptr<AnimationContainer> this_ref(this);
TimeTicks current_time = TimeTicks::Now();
last_tick_time_ = current_time;
// 拷贝一份用于遍历, 这样在调用Step时移除任何元素都不会有问题.
Elements elements = elements_;
for(Elements::const_iterator i=elements.begin(); i!=elements.end(); ++i)
{
// 确保元素是合法的.
if(elements_.find(*i) != elements_.end())
{
(*i)->Step(current_time);
}
}
if(observer_)
{
observer_->AnimationContainerProgressed(this);
}
}
std::vector<std::pair<std::string, double> > Layer::getPeakFamilies(const double & energy, \
const Elements & elements) const
{
if (this->hasMaterial)
{
const std::map<std::string, double> & composition = this->material.getComposition();
std::map<std::string, double> actualComposition;
std::vector<std::string> elementsList;
std::map<std::string, double>::const_iterator c_it;
std::map<std::string, double>::const_iterator c_it2;
for(c_it = composition.begin(); c_it != composition.end(); ++c_it)
{
actualComposition = elements.getComposition(c_it->first);
for(c_it2 = actualComposition.begin(); c_it2 != actualComposition.end(); ++c_it2)
{
if (std::find(elementsList.begin(), elementsList.end(), c_it2->first) == elementsList.end())
{
elementsList.push_back(c_it2->first);
}
}
}
return elements.getPeakFamilies(elementsList, energy);
}
else
{
return elements.getPeakFamilies(this->materialName, energy);
}
}
bool ExhaustiveSearcher::updatePathes(Elements & assignments) {
std::map<Link *, Path> oldPathes;
for(Elements::iterator i = assignments.begin(); i != assignments.end(); i++ ) {
Element * assignment = *i;
Elements edges = assignment->adjacentEdges();
for(Elements::iterator e = edges.begin(); e != edges.end(); e++ ) {
Element * edge = *e;
Link * tunnel = edge->toLink();
Path oldPath = tunnel->getRoute();
oldPathes[tunnel] = oldPath;
Element * start = tunnel->getFirst()->getParentNode()->getAssignee();
Element * end = tunnel->getSecond()->getParentNode()->getAssignee();
BSearcher searcher(start, end, tunnel);
if ( !searcher.isValid() )
continue;
if ( !searcher.search() ) {
for(std::map<Link *, Path>::iterator p = oldPathes.begin();
p != oldPathes.end(); p++)
p->first->setRoute(p->second);
return false;
}
Path route = searcher.getPath();
tunnel->setRoute(route);
}
}
return true;
}
void Environment::xmlConfigure(xmlNode *fNode)
{
int fEmbeddedSkin = 0;
while (fNode) {
if (!strcmp((char *) fNode->name, "Menu")) {
SubMenuNode *t = new SubMenuNode();
t->xmlConfigure(fNode->children);
setTopMenu(t);
setCurrentMenu(t);
} else if (!strcmp((char *) fNode->name, "Resources")) {
Resources *t = new Resources();
t->xmlConfigure(fNode->children);
setResources(t);
fEmbeddedSkin = 1;
} else if (!strcmp((char *) fNode->name, "Elements")) {
Elements *t = new Elements();
t->xmlConfigure(fNode->children);
setElements(t);
fEmbeddedSkin = 1;
} else if (!strcmp((char *) fNode->name, "Dialog")) {
Generic *t = new Generic();
t->xmlConfigure(fNode->children);
setDialog(t);
} else if (!strcmp((char *) fNode->name, "LogFile")) {
setLogFileName((char *) fNode->children->content);
}
fNode = fNode->next;
}
if (fEmbeddedSkin) {
mResources->loadResources();
mElements->associateResources(mResources);
}
}
Elements ExhaustiveSearcher::getAssignmentPack(ExhaustiveSearcher::Assignments & assignments) {
Elements result;
for (Assignments::iterator i = assignments.begin(); i != assignments.end(); i++) {
result.insert(i->first);
}
return result;
}
Elements ExhaustiveSearcher::getNextCortege() {
Elements result;
for ( int i = 0; i < depth; i++ )
result.insert(candidates[indices[i]]);
advanceCursors();
return result;
}
/// Gets a sorted list of face nodes
void sorted_face_nodes(const Elements& celements, const common::Table<Uint>::ArrayT& connectivity_table, const Uint element_idx, const Uint face_idx, CFaceConnectivity::IndicesT& face_nodes)
{
face_nodes.reserve(celements.element_type().faces().stride[face_idx]);
BOOST_FOREACH(const Uint local_node, celements.element_type().faces().nodes_range(face_idx))
{
face_nodes.push_back(connectivity_table[element_idx][local_node]);
}
std::sort(face_nodes.begin(), face_nodes.end());
}
void NetworkManager::setSearchSpace(const Nodes & nodes)
{
rejectedNodes.clear();
rejectedStores.clear();
Elements elements;
for (Nodes::iterator i = nodes.begin(); i != nodes.end(); i++)
{
elements.insert(*i);
}
depthSearcher = new DepthSearcher(network, elements);
}
bool Retrieve_Template::retrieve(Elements &elements) //returns just a category but can contain redundancy
{
if (!err && this->query->next())
{
elements.clear();
for (int i=0;i<columns.count();i++)
elements.append(this->query->value(i));
return true;
}
else
return false;
}
std::map<std::string, double> Layer::getMassAttenuationCoefficients(const double & energy, \
const Elements & elements) const
{
if (this->hasMaterial)
{
return elements.getMassAttenuationCoefficients(this->material.getComposition(), energy);
}
else
{
return elements.getMassAttenuationCoefficients(this->materialName, energy);
}
}
ExhaustiveSearcher::Assignments ExhaustiveSearcher::getAssignmentsCache(Elements & resources) {
Assignments result;
for (Elements::iterator i = resources.begin(); i != resources.end(); i++) {
Element * resource = *i;
Elements assignments = resource->getAssignments();
for(Elements::iterator a = assignments.begin(); a != assignments.end(); a++ ) {
Element * assignment = *a;
result[assignment] = resource;
}
}
return result;
}
bool EventDispatcher::DispatchEvent(Element* target_element, const String& name, const Dictionary& parameters, bool interruptible)
{
//Event event(target_element, name, parameters, interruptible);
Event* event = Factory::InstanceEvent(target_element, name, parameters, interruptible);
if (event == NULL)
return false;
// Build the element traversal from the tree
typedef std::vector<Element*> Elements;
Elements elements;
Element* walk_element = target_element->GetParentNode();
while (walk_element)
{
elements.push_back(walk_element);
walk_element = walk_element->GetParentNode();
}
event->SetPhase(Event::PHASE_CAPTURE);
// Capture phase - root, to target (only events that have registered as capture events)
// Note: We walk elements in REVERSE as they're placed in the list from the elements parent to the root
for (int i = elements.size() - 1; i >= 0 && event->IsPropagating(); i--)
{
EventDispatcher* dispatcher = elements[i]->GetEventDispatcher();
event->SetCurrentElement(elements[i]);
dispatcher->TriggerEvents(event);
}
// Target phase - direct at the target
if (event->IsPropagating())
{
event->SetPhase(Event::PHASE_TARGET);
event->SetCurrentElement(target_element);
TriggerEvents(event);
}
if (event->IsPropagating())
{
event->SetPhase(Event::PHASE_BUBBLE);
// Bubble phase - target to root (normal event bindings)
for (size_t i = 0; i < elements.size() && event->IsPropagating(); i++)
{
EventDispatcher* dispatcher = elements[i]->GetEventDispatcher();
event->SetCurrentElement(elements[i]);
dispatcher->TriggerEvents(event);
}
}
bool propagating = event->IsPropagating();
event->RemoveReference();
return propagating;
}
void KeywordManager::Peek(const string_t& filename,
const TokenRange& range,
Elements& elements,
std::vector<TokenRange>& preidentified_tokens) const {
typedef std::pair<ElementCategory, std::vector<string_t>> entry_t;
static const std::vector<entry_t> entries{
{kElementAudioTerm, {L"Dual Audio"}},
{kElementVideoTerm, {L"H264", L"H.264", L"h264", L"h.264"}},
{kElementVideoResolution, {L"480p", L"720p", L"1080p"}},
{kElementSource, {L"Blu-Ray"}}
};
auto it_begin = filename.begin() + range.offset;
auto it_end = it_begin + range.size;
for (const auto& entry : entries) {
for (const auto& keyword : entry.second) {
auto it = std::search(it_begin, it_end, keyword.begin(), keyword.end());
if (it != it_end) {
auto offset = it - filename.begin();
elements.insert(entry.first, keyword);
preidentified_tokens.push_back(TokenRange(offset, keyword.size()));
}
}
}
}
void KeywordManager::Peek(const string_t& filename,
const TokenRange& range,
Elements& elements,
std::vector<TokenRange>& preidentified_tokens) const {
typedef std::pair<ElementCategory, std::vector<string_t>> entry_t;
static /*const*/ std::vector<entry_t> entries;
{ ElementCategory c = kElementAudioTerm; const char_t* k[] = {L"Dual Audio"}; entry_t e; e.first = c; e.second.assign(k, k + _countof(k)); entries.push_back(e); }
{ ElementCategory c = kElementVideoTerm; const char_t* k[] = {L"H264", L"H.264", L"h264", L"h.264"}; entry_t e; e.first = c; e.second.assign(k, k + _countof(k)); entries.push_back(e); }
{ ElementCategory c = kElementVideoResolution; const char_t* k[] = {L"480p", L"720p", L"1080p"}; entry_t e; e.first = c; e.second.assign(k, k + _countof(k)); entries.push_back(e); }
{ ElementCategory c = kElementSource; const char_t* k[] = {L"Blu-Ray"}; entry_t e; e.first = c; e.second.assign(k, k + _countof(k)); entries.push_back(e); }
string_t::const_iterator it_begin = filename.begin() + range.offset;
string_t::const_iterator it_end = it_begin + range.size;
for(std::vector<entry_t>::const_iterator entry = entries.begin(); entry != entries.end(); ++entry) {
for(std::vector<string_t>::const_iterator keyword = entry->second.begin(); keyword != entry->second.end(); ++keyword) {
string_t::const_iterator it = std::search(it_begin, it_end, keyword->begin(), keyword->end());
if (it != it_end) {
size_t offset = it - filename.begin();
elements.insert(entry->first, *keyword);
preidentified_tokens.push_back(TokenRange(offset, keyword->size()));
}
}
}
}
void QuadTree::collideElements(Elements &elems, Elements &elems2, QuadTree::callInfo call) const
{
for (Elements::const_iterator it = elems.begin(); it != elems.end(); ++it)
{
for (Elements::const_iterator it2 = elems2.begin(); it2 != elems2.end(); ++it2)
{
if (this->collideRect((*it)->getXElement(), (*it)->getYElement(), (*it)->getWidthElement(), (*it)->getHeightElement(),
(*it2)->getXElement(), (*it2)->getYElement(), (*it2)->getWidthElement(), (*it2)->getHeightElement()))
{
if (call & QuadTree::LEFT)
(*it)->collide(**it2);
if (call & QuadTree::RIGHT)
(*it2)->collide(**it);
}
}
}
}
int main() {
Elements map;
map.reserve(256); // pre-allocate 256 "nodes"!
map.insert({
{ "one", "Eins" },
{ "two", "Zwei" },
{ "three", "Drei" },
{ "four", "Vier" },
{ "five", "Fuenf" },
});
for (auto& e : map) {
std::cout << "Entry: " << e.first << " -> " << e.second << "\n";
}
std::cout << "map[\"three\"] -> " << map.find("three")->second << "\n";
}
bool ManageRoundomName::loadNameCfg(Element * root_ele)
{
if (NULL == root_ele)
{
return false;
}
string attr_name_name = "xing";
string attr_female_name = "female";
string attr_male_name = "male";
Elements eles = root_ele->get_elements();
for (Elements::iterator it = eles.begin(); it != eles.end(); ++it)
{
Attributes attrs = (*it)->get_attributes();
for (Attributes::iterator attr_it = attrs.begin(); attr_it != attrs.end(); ++attr_it)
{
Attribute * attr = *attr_it;
if (attr->get_name() == attr_name_name)
{
if (attr->get_value().length() > 0)
{
m_random_name_info.surname.push_back(attr->get_value());
}
}
else if (attr->get_name() == attr_female_name)
{
if (attr->get_value().length() > 0)
{
m_random_name_info.female_name.push_back(attr->get_value());
}
}
else if (attr->get_name() == attr_male_name)
{
if (attr->get_value().length() > 0)
{
m_random_name_info.male_name.push_back(attr->get_value());
}
}
}
}
return true;
}
ExhaustiveSearcher::ExhaustiveSearcher(Network * n, Element * t, int d, int ma)
:
network(n),
target(t),
maxAttempts(ma),
attempt(0),
depth(d)
{
Elements cand = Operation::filter(network->getElements(), target, Criteria::isExhaustiveCandidate);
if ( cand.size() < depth )
depth = cand.size();
candidates = vector<Element *>(cand.begin(), cand.end());
indices = new int[depth + 1];
for ( int i = 0; i < depth; i++ )
indices[i] = i;
indices[depth] = candidates.size();
printf("Created exhaustive search environment to assign element %p, %d possible candidates\n", t, candidates.size());
}
std::vector<double> Layer::getTransmission(const std::vector<double> & energy, const Elements & elements, \
const double & angle) const
{
const double PI = std::acos(-1.0);
std::vector<double>::size_type i;
std::vector<double> tmpDoubleVector;
double tmpDouble;
if (angle == 90.0)
{
tmpDouble = this->density * this->thickness;
}
else
{
if (angle < 0)
tmpDouble = std::sin(-angle * PI / 180.);
else
tmpDouble = std::sin(angle * PI / 180.);
tmpDouble = this->density * this->thickness / tmpDouble;
}
if(tmpDouble <= 0.0)
{
std::string msg;
msg = "Layer " + this->name + " thickness is " + elements.toString(tmpDouble) + " g/cm2";
throw std::runtime_error( msg );
}
if (this->hasMaterial)
{
tmpDoubleVector = elements.getMassAttenuationCoefficients(this->material.getComposition(), energy)["total"];
}
else
{
tmpDoubleVector = elements.getMassAttenuationCoefficients(this->materialName, energy)["total"];
}
for (i = 0; i < tmpDoubleVector.size(); i++)
{
tmpDoubleVector[i] = (1.0 - this->funnyFactor) + \
(this->funnyFactor * exp(-(tmpDouble * tmpDoubleVector[i])));
}
return tmpDoubleVector;
}
bool ExhaustiveSearcher::makeAttempt() {
if ( isExhausted() )
return false;
Elements cortege = getNextCortege();
Assignments cache = getAssignmentsCache(cortege);
Elements assignmentPack = getAssignmentPack(cache);
Operation::forEach(assignmentPack, Operation::unassign);
assignmentPack.insert(target);
if ( performGreedyAssignment(assignmentPack, cortege) ) {
if ( updatePathes(assignmentPack) )
return true;
}
for(Assignments::iterator i = cache.begin(); i != cache.end(); i++ )
i->second->assign(i->first);
return false;
}
std::map<std::string, double> Layer::getComposition(const Elements & elements) const
{
if (this->hasMaterial)
{
return this->material.getComposition();
}
else
{
return elements.getComposition(this->materialName);
}
}
static inline void apply(Elements const& elements,
size_t & choosen_index,
margin_type & sum_of_margins,
content_type & smallest_overlap,
content_type & smallest_content,
Parameters const& parameters,
Translator const& translator)
{
typedef typename Elements::value_type element_type;
typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
typedef typename tag<indexable_type>::type indexable_tag;
BOOST_GEOMETRY_INDEX_ASSERT(elements.size() == parameters.get_max_elements() + 1, "wrong number of elements");
// copy elements
Elements elements_copy(elements); // MAY THROW, STRONG (alloc, copy)
// sort elements
element_axis_corner_less<element_type, Translator, indexable_tag, Corner, AxisIndex> elements_less(translator);
std::sort(elements_copy.begin(), elements_copy.end(), elements_less); // MAY THROW, BASIC (copy)
// init outputs
choosen_index = parameters.get_min_elements();
sum_of_margins = 0;
smallest_overlap = (std::numeric_limits<content_type>::max)();
smallest_content = (std::numeric_limits<content_type>::max)();
// calculate sum of margins for all distributions
size_t index_last = parameters.get_max_elements() - parameters.get_min_elements() + 2;
for ( size_t i = parameters.get_min_elements() ; i < index_last ; ++i )
{
// TODO - awulkiew: may be optimized - box of group 1 may be initialized with
// box of min_elems number of elements and expanded for each iteration by another element
Box box1 = rtree::elements_box<Box>(elements_copy.begin(), elements_copy.begin() + i, translator);
Box box2 = rtree::elements_box<Box>(elements_copy.begin() + i, elements_copy.end(), translator);
sum_of_margins += index::detail::comparable_margin(box1) + index::detail::comparable_margin(box2);
content_type ovl = index::detail::intersection_content(box1, box2);
content_type con = index::detail::content(box1) + index::detail::content(box2);
// TODO - shouldn't here be < instead of <= ?
if ( ovl < smallest_overlap || (ovl == smallest_overlap && con <= smallest_content) )
{
choosen_index = i;
smallest_overlap = ovl;
smallest_content = con;
}
}
::boost::ignore_unused_variable_warning(parameters);
}
int main() {
{
Elements hashtable;
hashtable.insert({
{ "one", "Eins" },
{ "two", "Zwei" },
{ "three", "Drei" },
{ "four", "Vier" },
{ "five", "Fuenf" },
});
for (auto& e : hashtable) {
std::cout << "Hash entry: " << e.first << " -> " << e.second << "\n";
}
std::cout << "hashtable[\"three\"] -> " << hashtable.find("three")->second << "\n";
}
boost::singleton_pool<boost::fast_pool_allocator_tag, sizeof(Elements::value_type)>::release_memory(); // free up allocated nodes
}
double Layer::getTransmission(const double & energy, const Elements & elements, const double & angle) const
{
// The material might not have been defined in the current Elements instance.
// However, its composition might be fine.
const double PI = std::acos(-1.0);
double muTotal;
double tmpDouble;
if (this->hasMaterial)
{
muTotal = elements.getMassAttenuationCoefficients(this->material.getComposition(), energy)["total"];
}
else
{
muTotal = elements.getMassAttenuationCoefficients(this->materialName, energy)["total"];
}
if (angle == 90.0)
{
tmpDouble = this->density * this->thickness;
}
else
{
if (angle < 0)
{
tmpDouble = std::sin(-angle * PI / 180.);
}
else
{
tmpDouble = std::sin(angle * PI / 180.);
}
tmpDouble = (this->density * this->thickness) / tmpDouble;
}
if(tmpDouble <= 0.0)
{
std::string msg;
msg = "Layer " + this->name + " thickness is " + elements.toString(tmpDouble) + " g/cm2";
throw std::runtime_error( msg );
}
return (1.0 - this->funnyFactor) + (this->funnyFactor * std::exp(-(tmpDouble * muTotal)));
}
std::map<std::string, std::map<std::string, double> > Detector::getEscape(const double & energy,
const Elements & elementsLibrary,
const std::string & label,
const int & update)
{
// To implement a cache at the detector level does not work because the same
// detector can use different elementsLibrary instances and to use different
// labels to identify them does not seem a good idea.
// It is preferable to fill the cache at the elements library level
if (label.size())
{
if (update != 0)
this->escapePeakCache.clear();
if (this->escapePeakCache.find(label) != this->escapePeakCache.end())
{
if (this->escapePeakCache[label].find(energy) != this->escapePeakCache[label].end())
{
return this->escapePeakCache[label][energy];
}
}
this->escapePeakCache[label][energy] = elementsLibrary.getEscape(this->getComposition(elementsLibrary), \
energy, \
this->escapePeakEnergyThreshold, \
this->escapePeakIntensityThreshold, \
this->escapePeakNThreshold, \
this->escapePeakAlphaIn,
0);
return this->escapePeakCache[label][energy];
}
else
{
return elementsLibrary.getEscape(this->getComposition(elementsLibrary), \
energy, \
this->escapePeakEnergyThreshold, \
this->escapePeakIntensityThreshold, \
this->escapePeakNThreshold, \
this->escapePeakAlphaIn,
0);
}
}
bool ExhaustiveSearcher::performGreedyAssignment(Elements & t, Elements & p) {
std::vector<Element *> targets(t.begin(), t.end());
std::vector<Element *> physical(p.begin(), p.end());
std::sort(targets.begin(), targets.end(), Criteria::elementWeightDescending);
std::sort(physical.begin(), physical.end(), Criteria::elementWeightDescending);
for(vector<Element *>::iterator i = targets.begin(); i != targets.end(); i++) {
Element * element = *i;
bool result;
for (vector<Element *>::iterator j = physical.begin(); j != physical.end(); j++) {
Element * assignee = *j;
result = assignee->assign(element);
if ( result )
break;
}
if ( !result ) {
Operation::forEach(t, Operation::unassign);
return false;
}
std::sort(physical.begin(), physical.end(), Criteria::elementWeightDescending);
}
return true;;
}
static inline void apply(Elements const& elements,
Parameters const& parameters,
Translator const& translator,
separation_type & separation,
size_t & seed1,
size_t & seed2)
{
const size_t elements_count = parameters.get_max_elements() + 1;
BOOST_GEOMETRY_INDEX_ASSERT(elements.size() == elements_count, "unexpected number of elements");
BOOST_GEOMETRY_INDEX_ASSERT(2 <= elements_count, "unexpected number of elements");
// find the lowest low, highest high
coordinate_type lowest = geometry::get<DimensionIndex>(rtree::element_indexable(elements[0], translator));
coordinate_type highest = geometry::get<DimensionIndex>(rtree::element_indexable(elements[0], translator));
size_t lowest_index = 0;
size_t highest_index = 0;
for ( size_t i = 1 ; i < elements_count ; ++i )
{
coordinate_type coord = geometry::get<DimensionIndex>(rtree::element_indexable(elements[i], translator));
if ( coord < lowest )
{
lowest = coord;
lowest_index = i;
}
if ( highest < coord )
{
highest = coord;
highest_index = i;
}
}
separation = highest - lowest;
seed1 = lowest_index;
seed2 = highest_index;
if ( lowest_index == highest_index )
seed2 = (lowest_index + 1) % elements_count; // % is just in case since if this is true lowest_index is 0
::boost::ignore_unused_variable_warning(parameters);
}
