static int bch_dec(int c[255], int n, int t)
{
int i, j, tmp;
int s[4], a[6], b[6], temp[6], deg_a, deg_b;
int sig[5], deg_sig;
int errloc[4], errcnt;
memset(s, 0, 4*sizeof(int));
for (j=0; j<n; j++)
for (i=0; i<t*2; i++)
s[i] = cm(i+1, s[i]) ^ (c[j]&1);
memset(a, 0, 6*sizeof(int));
memset(b, 0, 6*sizeof(int));
a[0] = 1;
deg_a = t*2;
for (i=0; i<t*2; i++) b[i] = s[t*2-1-i];
deg_b = t*2-1;
a[t*2+1] = 1;
b[t*2+1] = 0;
while (deg_b >= t) {
if (b[0] == 0) {
memmove(b, b+1, 5*sizeof(int));
b[5] = 0;
deg_b--;
}
else {
for (i=t*2+1; i>deg_a; i--)
b[i] = gm(b[i], b[0]) ^ gm(a[i], a[0]);
for (i=deg_a; i>deg_b; i--) {
b[i] = gm(b[i], b[0]);
a[i] = gm(a[i], b[0]);
}
for (; i>0; i--)
a[i] = gm(a[i], b[0]) ^ gm(b[i], a[0]);
memmove(a, a+1, 5*sizeof(int));
a[5] = 0;
deg_a--;
if (deg_a < deg_b) {
memcpy(temp, a, 6*sizeof(int));
memcpy(a, b, 6*sizeof(int));
memcpy(b, temp, 6*sizeof(int));
tmp = deg_a;
deg_a = deg_b;
deg_b = tmp;
}
}
}
deg_sig = t*2 - deg_a;
memcpy(sig, a+deg_a+1, (deg_sig+1)*sizeof(int));
errcnt = 0;
for (j=0; j<255; j++) {
tmp = 0;
for (i=0; i<=deg_sig; i++) {
sig[i] = cm(i, sig[i]);
tmp ^= sig[i];
}
if (tmp == 0) {
errloc[errcnt] = j - (255-n);
if (errloc[errcnt] >= 0)
errcnt++;
}
}
if (errcnt<deg_sig) {
return -1;
}
for (i=0; i<errcnt; i++) {
c[errloc[i]] ^= 1;
__D("fix error at %4d\n", errloc[i]);
}
return errcnt;
}
//! Default facet implementation uses month_type defaults
virtual void do_put_month_short(iter_type& oitr, month_enum moy) const
{
month_type gm(moy);
charT c = '\0';
put_string(oitr, gm.as_short_string(c));
}
MaxCutHyperheuristic::MaxCutHyperheuristic(const MaxCutInstance&mi,
double runtime_limit,
bool validation,
MaxCutCallback *mc, int seed,
std::string* selected) :
MaxCutHeuristic(mi, runtime_limit, validation, mc) {
// Step 1: Calculate graph metrics for this instance.
GraphMetrics gm(mi);
std::vector<double> metrics;
gm.AllMetrics(&metrics, NULL);
// Step 2: Obtain predicted probabilities from each random forest model.
// Best-performing model information (using streaming alg to select best)
double bestProbability = -1.0;
Prob bestProblem = MaxCut;
std::string bestCode = "";
int numBest = 1; // Number tied for best
// Check the Max-Cut heuristics
HeuristicFactory factory;
std::vector<std::string> codes;
factory.MaxCutHeuristicCodes(&codes);
for (int i=0; i < codes.size(); ++i) {
UpdateBestModel(codes[i], MaxCut, metrics, &bestProbability, &bestProblem,
&bestCode, &numBest);
}
// Check the QUBO heuristics
factory.QUBOHeuristicCodes(&codes);
for (int i=0; i < codes.size(); ++i) {
UpdateBestModel(codes[i], QUBO, metrics, &bestProbability, &bestProblem,
&bestCode, &numBest);
}
if (selected) {
*selected = bestCode;
}
// Step 3: Run the selected heuristic "H", using callbacks to capture all the
// reported solutions from "H" and report them for the hyper-heuristic.
// Because several previous steps may have used random draws or set the
// random seed, re-set the seed to the original here.
srand(seed);
if (bestProblem == MaxCut) {
// Using a Max-Cut heuristic
HyperheuristicMaxCutCallback callback(this);
// Run with our callback and no validation (solutions will be validated
// with the hyperheuristic, so no need to double validate)
Heuristic *h = factory.RunMaxCutHeuristic(bestCode, mi, runtime_limit,
false, &callback);
delete h; // We don't need to keep around the pointer
} else if (bestProblem == QUBO) {
// Using a QUBO heuristic
HyperheuristicQUBOCallback callback(this, mi);
QUBOInstance qi(mi); // Need to construct a QUBOInstance for heuristic
// Run with our callback and no validation (solutions will be validated
// with the hyperheuristic, so no need to double validate)
Heuristic *h = factory.RunQUBOHeuristic(bestCode, qi, runtime_limit,
false, &callback);
delete h; // We don't need to keep around the pointer
}
}
void MT(void)
{
char buf[10];
while(1)
{
sen.pro = 2;
system("clear");
printf("-----欢迎进入MT-----\n\n");
printf("--------------------\n");
printf("1--------私聊-------\n");
printf("2--------群聊-------\n");
printf("3---------FTP-------\n");
printf("4---------VIP-------\n");
printf("5------修改状态-----\n");
printf("6------修改密码-----\n");
printf("7--------注销-------\n");
printf("8--------退出-------\n");
printf("--------------------\n\n");
printf("请输入你的选择:");
memset(buf,0,10);
fgets(buf,10,stdin);
if(strlen(buf) > 2)
{
continue;
}
if(buf[0] == '1')
{
sl();
}
else if(buf[0] == '2')
{
ql();
}
else if(buf[0] == '3')
{
ftp();
}
else if(buf[0] == '4')
{
vip();
}
else if(buf[0] == '5')
{
zt();
}
else if(buf[0] == '6')
{
gm();
}
else if(buf[0] == '7')
{
sen.pro = 6;
strcpy(sen.message,"ZX");
send(fd,&sen,len_data,0);
MAIN();
}
else if(buf[0] == '8')
{
sen.pro = 6;
strcpy(sen.message,"MT");
send(fd,&sen,len_data,0);
exit(0);
}
}
}
void dynamics_mul::compute_intensity_force(){
HMesh::HalfEdgeAttributeVector<int> touched(s_dsc->get_no_halfedges(), 0);
for (auto eit = s_dsc->halfedges_begin(); eit != s_dsc->halfedges_end(); eit++) {
if(s_dsc->is_interface(*eit) and !touched[*eit]){
auto hew = s_dsc->walker(*eit);
double c0 = mean_inten_[s_dsc->get_label(hew.face())];
double c1 = mean_inten_[s_dsc->get_label(hew.opp().face())];
// Loop on the edge
auto p0 = s_dsc->get_pos(hew.opp().vertex());
auto p1 = s_dsc->get_pos(hew.vertex());
Vec2 L01 = p1 - p0;
L01.normalize();
Vec2 N01(L01[1], -L01[0]); // Outward pointing normal
int length = (int)(p1 - p0).length();
double f0 = 0.0, f1 = 0.0;
Vec2 fg0(0.0), fg1(0.0);
for (int i = 0; i <= length; i++) {
auto p = p0 + (p1 - p0)*(double(i)/(double)length);
double I = s_img->get_intensity(p[0], p[1]);
// Normalize force
int normalizedF = 1;
double f ;
switch (normalizedF) {
case 1:
f = ( (c0-c1)*(2*I - c0 - c1)) / ((c0-c1)*(c0-c1));
break;
case 2:
f = ( (c0-c1)*(2*I - c0 - c1)) / std::abs((c0 - c1));
break;
case 3:
f = (c0-c1)*(2*I - c0 - c1);
break;
default:
f = 0.0;
break;
}
Vec2 fu = N01*(c0-c1)*(2*I - c0 - c1);
// Image gradient force
int lengthM = 10;
Vec2 gm(0.0); double max_grad = 0;
for (int l = 0; l < lengthM; l++) {
Vec2 curPt = p + fu*(l/(double)(lengthM));
Vec2 gg = s_img->grad((int)curPt[0], (int)curPt[1]);
if (max_grad < gg.length()) {
max_grad = gg.length();
gm = gg*(lengthM - l)/(double)lengthM;
}
}
Vec2 fg = gm*(2*I - c0 - c1);
Vec2 fv = (fu + fg)/((c0-c1)*(c0-c1));
fg0 += fv*(p-p1).length() / (double)length;
fg1 += fv*(p-p0).length() / (double)length;
// Barry Centric coordinate
f0 += f*(p-p1).length() / (double)length;
f1 += f*(p-p0).length() / (double)length;
// Image gradient force
// Vec2 fg = s_img->grad((int)p[0], (int)p[1]) * (2*I - c0 - c1) / ((c0-c1)*(c0-c1));
// fg0 += fg*(p-p1).length() / (double)length;
// fg1 += fg*(p-p0).length() / (double)length;
}
// Set force
Vec2 f_x0 = fg0; // N01*f0;
Vec2 f_x1 = fg1; // N01*f1;
s_dsc->add_node_external_force(hew.opp().vertex(), f_x0*g_param.beta);
s_dsc->add_node_external_force(hew.vertex(), f_x1*g_param.beta);
// Avoid retouch the edge
touched[*eit] = 1;
touched[hew.opp().halfedge()] = 1;
}
}
}
void
modifVec(std::list<ElementRange> const& __r, eltType const& u,vectorType & UnVec,ExprType const& expr,
size_type rowstart, int ComponentShiftFactor,
mpl::int_<MESH_EDGES> /**/ )
{
const size_type context = ExprType::context|vm::POINT;
auto mesh = u.functionSpace()->mesh().get();
auto const* dof = u.functionSpace()->dof().get();
auto const* fe = u.functionSpace()->fe().get();
if ( __r.size() == 0 ) return;
auto edge_it = __r.begin()->template get<1>();
auto edge_en = __r.begin()->template get<2>();
bool findAEdge = false;
for( auto lit = __r.begin(), len = __r.end(); lit != len; ++lit )
{
edge_it = lit->template get<1>();
edge_en = lit->template get<2>();
if ( edge_it != edge_en )
{
findAEdge=true;
break;
}
}
if ( !findAEdge ) return;
auto const& edgeForInit = boost::unwrap_ref( *edge_it );
auto gm = mesh->gm();
//auto const& firstEntity = *entity_it;
size_type eid = edgeForInit.elements().begin()->first;
size_type ptid_in_element = edgeForInit.elements().begin()->second;
auto const& elt = mesh->element( eid );
auto geopc = gm->preCompute( fe->edgePoints(ptid_in_element) );
auto ctx = gm->template context<context>( elt, geopc );
auto expr_evaluator = expr.evaluator( mapgmc(ctx) );
auto IhLoc = fe->edgeLocalInterpolant();
std::vector<bool> dofdone( dof->nLocalDofWithGhost(), false );
for( auto const& lit : __r )
{
edge_it = lit.template get<1>();
edge_en = lit.template get<2>();
for ( ; edge_it != edge_en;++edge_it )
{
auto const& theedge = boost::unwrap_ref( *edge_it );
if ( theedge.isGhostCell() )
{
LOG(WARNING) << "edge id : " << theedge.id() << " is a ghost edge";
continue;
}
size_type eid = theedge.elements().begin()->first;
size_type edgeid_in_element = theedge.elements().begin()->second;
auto const& elt = mesh->element( eid );
geopc = gm->preCompute( fe->edgePoints(edgeid_in_element) );
ctx->update( elt, geopc );
expr_evaluator.update( mapgmc( ctx ) );
fe->edgeInterpolate( expr_evaluator, IhLoc );
for( auto const& ldof : u.functionSpace()->dof()->edgeLocalDof( eid, edgeid_in_element ) )
{
size_type index = ldof.index();
if ( dofdone[index] ) continue;
//size_type thedof = u.start()+ (is_comp_space?Elem1::nComponents:1)*ldof.index();
size_type thedof = u.start() + ComponentShiftFactor*index;
double value = ldof.sign()*IhLoc( ldof.localDofInFace() );
UnVec->set(rowstart+thedof,value);
dofdone[index] = true;
}
} // edge_it
} // lit
}
void
modifVec(std::list<ElementRange> const& __r, eltType const& u,vectorType & UnVec,ExprType const& expr,
size_type rowstart, int ComponentShiftFactor,
mpl::int_<MESH_POINTS> /**/ )
{
const size_type context = ExprType::context|vm::POINT;
auto mesh = u.functionSpace()->mesh().get();
auto const* dof = u.functionSpace()->dof().get();
auto const* fe = u.functionSpace()->fe().get();
if ( __r.size() == 0 ) return;
auto point_it = __r.begin()->template get<1>();
auto point_en = __r.begin()->template get<2>();
bool findAPoint = false;
for( auto lit = __r.begin(), len = __r.end(); lit != len; ++lit )
{
point_it = lit->template get<1>();
point_en = lit->template get<2>();
if ( point_it != point_en )
{
findAPoint=true;
break;
}
}
if ( !findAPoint ) return;
auto const& pointForInit = boost::unwrap_ref( *point_it );
size_type eid = pointForInit.elements().begin()->first;
size_type ptid_in_element = pointForInit.elements().begin()->second;
auto const& elt = mesh->element( eid );
auto gm = mesh->gm();
auto geopc = gm->preCompute( fe->vertexPoints(ptid_in_element) );
auto ctx = gm->template context<context>( elt, geopc );
auto expr_evaluator = expr.evaluator( mapgmc(ctx) );
auto IhLoc = fe->vertexLocalInterpolant();
std::vector<bool> dofdone( dof->nLocalDofWithGhost(), false );
for( auto const& lit : __r )
{
point_it = lit.template get<1>();
point_en = lit.template get<2>();
DVLOG(2) << "point " << point_it->id() << " with marker " << point_it->marker() << " nb: " << std::distance(point_it,point_en);
if ( point_it == point_en )
continue;
for ( ; point_it != point_en;++point_it )
{
auto const& thept = boost::unwrap_ref( *point_it );
size_type eid = thept.elements().begin()->first;
size_type ptid_in_element = thept.elements().begin()->second;
auto const& elt = mesh->element( eid );
geopc = gm->preCompute( fe->vertexPoints(ptid_in_element) );
ctx->update( elt, ptid_in_element, geopc, mpl::int_<0>() );
expr_evaluator.update( mapgmc( ctx ) );
fe->vertexInterpolate( expr_evaluator, IhLoc );
for (int c1=0;c1<eltType::nComponents1;c1++)
//for( int c = 0; c < (is_product?nComponents:1); ++c )
{
size_type index = dof->localToGlobal( eid, ptid_in_element, c1 ).index();
//size_type thedof = u.start()+ (is_comp_space?Elem1::nComponents:1)*index; // global dof
size_type thedof = u.start() + ComponentShiftFactor*index;
if ( dofdone[index] ) continue;
double value = IhLoc( c1 );
UnVec->set(rowstart+thedof,value);
dofdone[index] = true;
}
}
}
}
void TankLogic::MakeMove(Consoden::TankGame::GameStatePtr gameState)
{
GameMap gm(m_ownTankId, gameState);
auto currentPosition=gm.OwnPosition();
auto enemyPosition=gm.EnemyPosition();
BfsHelper bfs(gameState, currentPosition);
Consoden::TankGame::Direction::Enumeration moveDirection;
// Look for powerups and enemy
int enemySteps = 20000;
if (bfs.CanReachSquare(enemyPosition)) {
enemySteps = bfs.StepsToSquare(enemyPosition);
}
int powerUpSteps = 20000;
std::pair<int,int> powerUpPos;
for (int x = 0; x < gm.SizeX(); x++) {
for (int y = 0; y < gm.SizeY(); y++) {
std::pair<int,int> pos = std::make_pair(x, y);
if (!bfs.CanReachSquare(pos)) {
continue;
}
if ((gm.IsLaserAmmo(pos) || gm.IsRedeemerAmmo(pos) || gm.IsSmokeGrenade(pos)) && powerUpSteps > bfs.StepsToSquare(pos)) {
powerUpSteps = bfs.StepsToSquare(pos);
powerUpPos = pos;
}
}
}
if (powerUpSteps < enemySteps) {
// It is possible to get a power up, do it
moveDirection=bfs.FindDirection(currentPosition, bfs.BacktrackFromSquare(powerUpPos));
} else if (enemySteps < 20000) {
// It is possible to move all the way to the enemy, do it
moveDirection=bfs.FindDirection(currentPosition, bfs.BacktrackFromSquare(enemyPosition));
} else {
//Find an empty sqaure we can move to, otherwise stand still
moveDirection=Consoden::TankGame::Direction::Neutral;
if (!gm.IsWall(gm.Move(currentPosition, Consoden::TankGame::Direction::Left)) &&
!gm.IsMine(gm.Move(currentPosition, Consoden::TankGame::Direction::Left)))
{
moveDirection=Consoden::TankGame::Direction::Left;
}
else if (!gm.IsWall(gm.Move(currentPosition, Consoden::TankGame::Direction::Right)) &&
!gm.IsMine(gm.Move(currentPosition, Consoden::TankGame::Direction::Right)))
{
moveDirection=Consoden::TankGame::Direction::Right;
}
else if (!gm.IsWall(gm.Move(currentPosition, Consoden::TankGame::Direction::Up)) &&
!gm.IsMine(gm.Move(currentPosition, Consoden::TankGame::Direction::Up)))
{
moveDirection=Consoden::TankGame::Direction::Up;
}
else if (!gm.IsWall(gm.Move(currentPosition, Consoden::TankGame::Direction::Down)) &&
!gm.IsMine(gm.Move(currentPosition, Consoden::TankGame::Direction::Down)))
{
moveDirection=Consoden::TankGame::Direction::Down;
}
}
// Evaluate firing direction
int opponent_x = gm.EnemyPosition().first;
int opponent_y = gm.EnemyPosition().second;
int player_x = gm.OwnPosition().first;
int player_y = gm.OwnPosition().second;
int x_distance;
int x_wrap_distance;
Consoden::TankGame::Direction::Enumeration x_direction;
int y_distance;
int y_wrap_distance;
Consoden::TankGame::Direction::Enumeration y_direction;
Consoden::TankGame::Direction::Enumeration tower_direction;
if (opponent_x > player_x) {
// opponent to the right
x_distance = opponent_x - player_x;
x_wrap_distance = player_x - opponent_x + gm.SizeX();
if (x_distance < x_wrap_distance || !bfs.CanWrapX()) {
x_direction = Consoden::TankGame::Direction::Right; //Shortest linear path to enemy is right
} else {
x_direction = Consoden::TankGame::Direction::Left; //Shortest linear path to enemy is left
x_distance = x_wrap_distance;
}
} else {
// opponent to the left
x_distance = player_x - opponent_x;
x_wrap_distance = opponent_x - player_x + gm.SizeX();
if (x_distance < x_wrap_distance || !bfs.CanWrapX()) {
x_direction = Consoden::TankGame::Direction::Left; //Shortest linear path to enemy is left
} else {
x_direction = Consoden::TankGame::Direction::Right; //Shortest linear path to enemy is right
x_distance = x_wrap_distance;
}
}
if (opponent_y > player_y) {
// opponent is down
y_distance = opponent_y - player_y;
y_wrap_distance = player_y - opponent_y + gm.SizeY();
if (y_distance < y_wrap_distance || !bfs.CanWrapY()) {
y_direction = Consoden::TankGame::Direction::Down; //Shortest linear path to enemy is down
} else {
y_direction = Consoden::TankGame::Direction::Up; //Shortest linear path to enemy is up
y_distance = y_wrap_distance;
}
} else {
// opponent is up
y_distance = player_y - opponent_y;
y_wrap_distance = opponent_y - player_y + gm.SizeY();
if (y_distance < y_wrap_distance || !bfs.CanWrapY()) {
y_direction = Consoden::TankGame::Direction::Up; //Shortest linear path to enemy is up
} else {
y_direction = Consoden::TankGame::Direction::Down; //Shortest linear path to enemy is down
y_distance = y_wrap_distance;
}
}
if (x_distance > y_distance) {
tower_direction = x_direction;
} else {
tower_direction = y_direction;
}
// Firing logic
bool fire = false;
bool fire_redeemer = false;
int redemer_timer = 3;
bool fire_laser = false;
bool deploy_smoke = false;
bool drop_mine = false;
if (gm.HasSmoke()) {
deploy_smoke = true;
}
if (gm.HasRedeemer()) {
fire_redeemer = true;
fire = true;
redemer_timer = 4;
} else if (gm.LaserAmmoCount() > 0) {
fire_laser = true;
fire = true;
// Stand still to fire laser
moveDirection = Consoden::TankGame::Direction::Neutral;
} else {
// Go for regular missile
fire = true;
}
//Sometimes we also drop a mine
drop_mine=(static_cast<int>(gameState->ElapsedTime().GetVal()) % 3)==0;
//Move our joystick.
SetJoystick(moveDirection, tower_direction, fire, drop_mine, fire_laser,deploy_smoke,fire_redeemer, redemer_timer);
}
void UnifyingConflator::apply(shared_ptr<OsmMap>& map)
{
Timer timer;
_reset();
NamedOp(ConfigOptions().getUnifyPreOps().split(";", QString::SkipEmptyParts)).apply(map);
_stats.append(SingleStat("Apply Pre Ops Time (sec)", timer.getElapsedAndRestart()));
// will reproject if necessary.
MapReprojector::reprojectToPlanar(map);
_stats.append(SingleStat("Project to Planar Time (sec)", timer.getElapsedAndRestart()));
if (Log::getInstance().isDebugEnabled())
{
LOG_DEBUG("Writing debug map.");
OsmMapPtr debug(new OsmMap(map));
MapReprojector::reprojectToWgs84(debug);
OsmMapWriterFactory::write(debug, "tmp/debug.osm");
_stats.append(SingleStat("Write Debug Map Time (sec)", timer.getElapsedAndRestart()));
}
LOG_DEBUG("Creating matches...");
// find all the matches in this map
if (_matchThreshold.get())
{
//ScoreMatches logic seems to be the only one that needs to pass in the match threshold now when
//the optimize param is activated. Otherwise, we get the match threshold information from the
//config.
_matchFactory.createMatches(map, _matches, _bounds, _matchThreshold);
}
else
{
_matchFactory.createMatches(map, _matches, _bounds);
}
LOG_DEBUG("Match count: " << _matches.size());
LOG_DEBUG(SystemInfo::getMemoryUsageString());
double findMatchesTime = timer.getElapsedAndRestart();
_stats.append(SingleStat("Find Matches Time (sec)", findMatchesTime));
_stats.append(SingleStat("Number of Matches Found", _matches.size()));
_stats.append(SingleStat("Number of Matches Found per Second",
(double)_matches.size() / findMatchesTime));
vector<const Match*> allMatches = _matches;
// add review tags to all matches that have some review component
_addReviewTags(map, allMatches);
LOG_INFO("Pre-constraining match count: " << allMatches.size());
_stats.append(SingleStat("Number of Matches Before Whole Groups", _matches.size()));
// If there are groups of matches that should not be optimized, remove them before optimization.
MatchSetVector matchSets;
_removeWholeGroups(_matches, matchSets, map);
_stats.append(SingleStat("Number of Whole Groups", matchSets.size()));
// Globally optimize the set of matches to maximize the conflation score.
{
OptimalConstrainedMatches cm(map);
cm.addMatches(_matches.begin(), _matches.end());
cm.setTimeLimit(ConfigOptions(_settings).getUnifyOptimizerTimeLimit());
double cmStart = Time::getTime();
vector<const Match*> cmMatches = cm.calculateSubset();
LOG_INFO("CM took: " << Time::getTime() - cmStart << "s.");
LOG_INFO("CM Score: " << cm.getScore());
LOG_DEBUG(SystemInfo::getMemoryUsageString());
GreedyConstrainedMatches gm(map);
gm.addMatches(_matches.begin(), _matches.end());
double gmStart = Time::getTime();
vector<const Match*> gmMatches = gm.calculateSubset();
LOG_INFO("GM took: " << Time::getTime() - gmStart << "s.");
LOG_INFO("GM Score: " << gm.getScore());
if (gm.getScore() > cm.getScore())
{
_matches = gmMatches;
}
else
{
_matches = cmMatches;
}
}
double optimizeMatchesTime = timer.getElapsedAndRestart();
_stats.append(SingleStat("Optimize Matches Time (sec)", optimizeMatchesTime));
_stats.append(SingleStat("Number of Optimized Matches", _matches.size()));
_stats.append(SingleStat("Number of Matches Optimized per Second",
(double)allMatches.size() / optimizeMatchesTime));
LOG_DEBUG(SystemInfo::getMemoryUsageString());
// #warning validateConflictSubset is on, this is slow.
// _validateConflictSubset(map, _matches);
LOG_INFO("Post constraining match count: " << _matches.size());
{
// search the matches for groups (subgraphs) of matches. In other words, groups where all the
// matches are interrelated by element id
MatchGraph mg;
mg.addMatches(_matches.begin(), _matches.end());
vector< set<const Match*, MatchPtrComparator> > tmpMatchSets =
mg.findSubgraphs(map);
matchSets.insert(matchSets.end(), tmpMatchSets.begin(), tmpMatchSets.end());
LOG_DEBUG(SystemInfo::getMemoryUsageString());
}
LOG_DEBUG("Match sets count: " << matchSets.size());
LOG_DEBUG(SystemInfo::getMemoryUsageString());
/// @todo would it help to sort the matches so the biggest or best ones get merged first?
// convert all the match sets into mergers.
for (size_t i = 0; i < matchSets.size(); ++i)
{
_mergerFactory->createMergers(map, matchSets[i], _mergers);
}
LOG_DEBUG(SystemInfo::getMemoryUsageString());
// don't need the matches any more
_deleteAll(allMatches);
_matches.clear();
LOG_DEBUG(SystemInfo::getMemoryUsageString());
_mapElementIdsToMergers();
LOG_DEBUG(SystemInfo::getMemoryUsageString());
_stats.append(SingleStat("Create Mergers Time (sec)", timer.getElapsedAndRestart()));
vector< pair<ElementId, ElementId> > replaced;
for (size_t i = 0; i < _mergers.size(); ++i)
{
_mergers[i]->apply(map, replaced);
// update any mergers that reference the replaced values
_replaceElementIds(replaced);
replaced.clear();
if (Log::getInstance().getLevel() == Log::Debug)
{
cout << "Applying mergers: " << i + 1 << " / " << _mergers.size() << " \r" << flush;
}
}
if (Log::getInstance().getLevel() == Log::Debug)
{
cout << endl;
}
LOG_DEBUG(SystemInfo::getMemoryUsageString());
size_t mergerCount = _mergers.size();
// free up any used resources.
_reset();
LOG_DEBUG(SystemInfo::getMemoryUsageString());
double mergersTime = timer.getElapsedAndRestart();
_stats.append(SingleStat("Apply Mergers Time (sec)", mergersTime));
_stats.append(SingleStat("Mergers Applied per Second", (double)mergerCount / mergersTime));
NamedOp(ConfigOptions().getUnifyPostOps().split(";", QString::SkipEmptyParts)).apply(map);
_stats.append(SingleStat("Apply Post Ops Time (sec)", timer.getElapsedAndRestart()));
}
int joseph(int n, int k){ // O(klogn)
if(n<=1)return 0;
if(k==1)return n-1; // this line of code can be handled by caller
int x=(n+k-1)/k;
return (x*k+(joseph(n-x,k)*k+gm(x-n,k-1))/(k-1)+(x*k==n+k-1))%n;
}
/* Backward propagation of a reduction on (p + q), where p is a garbled mix,
and q a precise pointer or an integer. */
void main3 () {
int a = 0, b = 1, c = 2;
int *p = gm (&a);
int *q = rand ? &b : (int*)rand;
int v; char w;
if (rand) {
/* According to the C semantics, computes (p + sizeof(*p) q),
so the b address from q is lost in the operation. */
v = *((p + (uintptr_t)q));
Frama_C_show_each_GM_only_a(p, q);
}
if (rand) {
/* Here, size = 0, so &b+[0..3] is valid, and p is reduced accordingly. */
w = *(((char*)p + (uintptr_t)q));
Frama_C_show_each_GM_reduce_p_offset(p, q);
}
p = gm (&a);
q = &b;
if (rand) {
/* The same but q is only a pointer, so &a is impossible too. */
v = *((p + (uintptr_t)q));
Frama_C_show_each_GM_BOTTOM(p, q);
}
p = gm (rand ? &a : &b);
q = rand ? &b : (int*)rand;
if (rand) {
/* Here, &b appear in the garbled mix of p, and may interfere with the
(4 * &b) from q: no reduction is feasible. */
v = *((p + (uintptr_t)q));
Frama_C_show_each_GM_no_reduction(p, q);
}
p = gm (rand ? &a : &b);
q = rand ? &c : (int*)rand;
if (rand) {
/* &c is the only valid location after the condition, so q = &c and p = 0. */
if ( *(((char*)p + (uintptr_t)q)) == 2)
Frama_C_show_each_GM_only_c(p, q);
}
if (rand) {
/* &b is the only valid location after the condition, so p = &b+[..] and
q is an integer. */
if ( *((p + (uintptr_t)q)) == 1)
Frama_C_show_each_GM_only_b(p, q);
}
p = gm (rand ? &a : &b);
q = rand ? &b : (int*)rand;
if (rand) {
/* No pointer on c, so bottom after the condition. */
if ( *(((char*)p + (uintptr_t)q)) == 2)
Frama_C_show_each_GM_BOTTOM(p, q);
}
if (rand) {
/* &b is the only valid location after the condition, but it may be builds
by any combination of a garbled mix of &b for p. */
if ( *(((char*)p + (uintptr_t)q)) == 1)
Frama_C_show_each_GM_only_b_and_gm(p, q);
}
}
void CMomentumPlayer::Spawn()
{
SetModel(ENTITY_MODEL);
SetBodygroup(1, 11);//BODY_PROLATE_ELLIPSE
// BASECLASS SPAWN MUST BE AFTER SETTING THE MODEL, OTHERWISE A NULL HAPPENS!
BaseClass::Spawn();
AddFlag(FL_GODMODE);
RemoveSolidFlags(FSOLID_NOT_SOLID); // this removes the flag that was added while switching to spectator mode which
// prevented the player from activating triggers
// do this here because we can't get a local player in the timer class
ConVarRef gm("mom_gamemode");
switch (gm.GetInt())
{
case MOMGM_BHOP:
case MOMGM_SURF:
case MOMGM_UNKNOWN:
default:
EnableAutoBhop();
break;
case MOMGM_SCROLL:
DisableAutoBhop();
break;
}
// Reset all bool gameevents
IGameEvent *runSaveEvent = gameeventmanager->CreateEvent("run_save");
IGameEvent *runUploadEvent = gameeventmanager->CreateEvent("run_upload");
IGameEvent *timerStartEvent = gameeventmanager->CreateEvent("timer_state");
m_RunData.m_bIsInZone = false;
m_RunData.m_bMapFinished = false;
m_RunData.m_iCurrentZone = 0;
m_bHasPracticeMode = false;
ResetRunStats();
if (runSaveEvent)
{
runSaveEvent->SetBool("run_saved", false);
gameeventmanager->FireEvent(runSaveEvent);
}
if (runUploadEvent)
{
runUploadEvent->SetBool("run_posted", false);
runUploadEvent->SetString("web_msg", "");
gameeventmanager->FireEvent(runUploadEvent);
}
if (timerStartEvent)
{
timerStartEvent->SetInt("ent", entindex());
timerStartEvent->SetBool("is_running", false);
gameeventmanager->FireEvent(timerStartEvent);
}
// Linear/etc map
g_Timer->DispatchMapInfo();
RegisterThinkContext("THINK_EVERY_TICK");
RegisterThinkContext("CURTIME");
RegisterThinkContext("THINK_AVERAGE_STATS");
RegisterThinkContext("CURTIME_FOR_START");
RegisterThinkContext("TWEEN");
SetContextThink(&CMomentumPlayer::UpdateRunStats, gpGlobals->curtime + gpGlobals->interval_per_tick,
"THINK_EVERY_TICK");
SetContextThink(&CMomentumPlayer::CheckForBhop, gpGlobals->curtime, "CURTIME");
SetContextThink(&CMomentumPlayer::CalculateAverageStats, gpGlobals->curtime + AVERAGE_STATS_INTERVAL,
"THINK_AVERAGE_STATS");
SetContextThink(&CMomentumPlayer::LimitSpeedInStartZone, gpGlobals->curtime, "CURTIME_FOR_START");
SetContextThink(&CMomentumPlayer::TweenSlowdownPlayer, gpGlobals->curtime, "TWEEN");
SetNextThink(gpGlobals->curtime);
DevLog("Finished spawn!\n");
}
double interpolate( util::matrix_t<double> &data,
util::matrix_t<double> &par,
double I, double T, int idx, bool quiet )
{
MatDoub tempirr;
std::vector<double> parvals;
std::vector<sp_point> pts, hull;
double maxz = -1e99;
double tmin = 1e99;
double tmax = -1e99;
double imin = 1e99;
double imax = -1e99;
double dist = 1e99;
int idist = -1;
for( size_t i=0;i<data.nrows();i++ )
{
double z = par(i,idx);
if ( !std::isfinite( z ) )
continue;
double temp = data(i,TC);//x value
double irr = data(i,IRR);//y value
if ( temp < tmin ) tmin = temp;
if ( temp > tmax ) tmax = temp;
if ( irr < imin ) imin = irr;
if ( irr > imax ) imax = irr;
double d = sqrt( (irr-I)*(irr-I) + (temp-T)*(temp-T) );
if ( d < dist )
{
dist = d;
idist = (int)i;
}
std::vector<double> it(2,0.0);
it[0] = temp; it[1] = irr;
tempirr.push_back( it );
parvals.push_back( z );
if ( z > maxz ) maxz = z;
pts.push_back( sp_point( temp, irr, z ) );
}
Toolbox::convex_hull( pts, hull );
if ( Toolbox::pointInPolygon( hull, sp_point(T, I, 0.0) ) )
{
// scale values based on max - helps GM interp routine
for( size_t i=0;i<parvals.size();i++)
parvals[i] /= maxz;
Powvargram vgram( tempirr, parvals, 1.75, 0. );
GaussMarkov gm( tempirr, parvals, vgram );
// test the fit against the data
double err_fit = 0.;
for( size_t i=0;i<parvals.size();i++ )
{
double zref = parvals[i];
double zfit = gm.interp( tempirr[i] );
double dz = zref - zfit;
err_fit += dz*dz;
}
err_fit = sqrt(err_fit);
if ( err_fit > 0.01 )
{
log( util::format("interpolation function for iec61853 parameter '%s' at I=%lg T=%lg is poor: %lg RMS",
parnames[idx], I, T, err_fit ),
SSC_WARNING );
}
std::vector<double> q(2,0.0);
q[0] = T;
q[1] = I;
// now interpolate and return the value
return gm.interp( q ) * maxz;
}
else
{
// if we're pretty close, return the nearest known value
if ( dist < 30. )
{
if ( !quiet )
log( util::format("query point (%lg, %lg) is outside convex hull of data but close... returning nearest value from data table at (%lg, %lg)=%lg",
T, I, data(idist,TC), data(idist,IRR), par(idist,idx) ),
SSC_WARNING );
return par(idist,idx);
}
// fall back to the 5 parameter model's auxiliary equations
// to estimate the parameter values outside the convex hull
int idx_stc = -1;
for( size_t i=0;i<data.nrows();i++)
if ( data(i,IRR) == 1000.0
&& data(i,TC) == 25.0 )
idx_stc = (int)i;
if ( idx_stc < 0 )
throw general_error("STC conditions required to be supplied in the temperature/irradiance data");
double value = par(idist,idx);;
if ( idx == A )
{
double a_nearest = par( idist, A );
double T_nearest = data( idist, TC );
double a_est = a_nearest * T/T_nearest;
value = a_est;
}
else if ( idx == IL )
{
double IL_nearest = par( idist, IL );
double I_nearest = data(idist, IRR );
double IL_est = IL_nearest * I/I_nearest;
value = IL_est;
}/*
else if ( idx == IO )
{
#define Tc_ref 298.15
#define Eg_ref 1.12
#define KB 8.618e-5
double IO_stc = par(idx_stc,IO);
double TK = T+273.15;
double EG = Eg_ref * (1-0.0002677*(TK-Tc_ref));
double IO_oper = IO_stc * pow(TK/Tc_ref, 3) * exp( 1/KB*(Eg_ref/Tc_ref - EG/TK) );
value = IO_oper;
}*/
else if ( idx == RSH )
{
double RSH_nearest = par( idist, RSH );
double I_nearest = data(idist, IRR );
double RSH_est = RSH_nearest * I_nearest/I;
value = RSH_est;
}
if ( !quiet )
log( util::format("query point (%lg, %lg) is too far out of convex hull of data (dist=%lg)... estimating value from 5 parameter modele at (%lg, %lg)=%lg",
T, I, dist, data(idist,TC), data(idist,IRR), value ),
SSC_WARNING );
return value;
}
}
void Create3x1Label3Model(GM& gm_return)
{
size_t numberOfNodes=3, numberOflabels=3;
typename GM::SpaceType space(numberOfNodes,numberOflabels);
GM gm(space);
// single site factors
opengm::ExplicitFunction<double> f1(&numberOflabels,&numberOflabels+1, 0.0);
typename GM::IndexType j;
{ j=0;
f1(0) = 1.0;
f1(1) = 2.0;
f1(2) = 3.0;
typename GM::FunctionIdentifier fId = gm.addFunction(f1);
gm.addFactor(fId,&j, &j+1);}
{ j=1;
f1(0) = 4.0;
f1(1) = 5.0;
f1(2) = 6.0;
typename GM::FunctionIdentifier fId = gm.addFunction(f1);
gm.addFactor(fId,&j, &j+1);}
{ j=2;
f1(0) = 7.0;
f1(1) = 8.0;
f1(2) = 9.0;
typename GM::FunctionIdentifier fId = gm.addFunction(f1);
gm.addFactor(fId,&j, &j+1);}
//pw factors
size_t shape[] = {numberOflabels,numberOflabels};
opengm::ExplicitFunction<double> f2(shape,shape+2, 0.0);
{ size_t vi[] = {0,1};
f2(0,0) = 5.0;
f2(0,1) = 0.0;
f2(0,2) = 1.0;
f2(1,0) = 5.0;
f2(1,1) = 0.0;
f2(1,2) = 1.0;
f2(2,0) = 1.0;
f2(2,1) = 0.0;
f2(2,2) = 10.0;
typename GM::FunctionIdentifier fId = gm.addFunction(f2);
gm.addFactor(fId,vi,vi+2);}
{ size_t vi[] = {1,2};
f2(0,0) = 5.0;
f2(0,1) = 5.0;
f2(0,2) = 1.0;
f2(1,0) = 0.0;
f2(1,1) = 0.0;
f2(1,2) = 0.0;
f2(2,0) = 1.0;
f2(2,1) = 1.0;
f2(2,2) = 10.0;
typename GM::FunctionIdentifier fId = gm.addFunction(f2);
gm.addFactor(fId,vi,vi+2);}
gm_return=gm;
};
bool CMomentumGameMovement::CheckJumpButton()
{
if (player->pl.deadflag)
{
mv->m_nOldButtons |= IN_JUMP; // don't jump again until released
return false;
}
// See if we are waterjumping. If so, decrement count and return.
if (player->m_flWaterJumpTime)
{
player->m_flWaterJumpTime -= gpGlobals->frametime;
if (player->m_flWaterJumpTime < 0)
player->m_flWaterJumpTime = 0;
return false;
}
// If we are in the water most of the way...
if (player->GetWaterLevel() >= 2)
{
// swimming, not jumping
SetGroundEntity(NULL);
if (player->GetWaterType() == CONTENTS_WATER) // We move up a certain amount
mv->m_vecVelocity[2] = 100;
else if (player->GetWaterType() == CONTENTS_SLIME)
mv->m_vecVelocity[2] = 80;
// play swiming sound
if (player->m_flSwimSoundTime <= 0)
{
// Don't play sound again for 1 second
player->m_flSwimSoundTime = 1000;
PlaySwimSound();
}
return false;
}
// No more effect
if (player->GetGroundEntity() == NULL)
{
mv->m_nOldButtons |= IN_JUMP;
return false; // in air, so no effect
}
//AUTOBHOP---
//only run this code if autobhop is disabled
if (!player->HasAutoBhop())
{
if (mv->m_nOldButtons & IN_JUMP)
return false; // don't pogo stick
}
// In the air now.
SetGroundEntity(NULL);
player->PlayStepSound((Vector &) mv->GetAbsOrigin(), player->m_pSurfaceData, 1.0, true);
//MoveHelper()->PlayerSetAnimation( PLAYER_JUMP );
//player->DoAnimationEvent(PLAYERANIMEVENT_JUMP);
float flGroundFactor = 1.0f;
if (player->m_pSurfaceData)
{
flGroundFactor = player->m_pSurfaceData->game.jumpFactor;
}
// if we weren't ducking, bots and hostages do a crouchjump programatically
if ((!player || player->IsBot()) && !(mv->m_nButtons & IN_DUCK))
{
player->m_duckUntilOnGround = true;
FinishDuck();
}
// Acclerate upward
// If we are ducking...
float startz = mv->m_vecVelocity[2];
if ((player->m_Local.m_bDucking) || (player->GetFlags() & FL_DUCKING))
{
mv->m_vecVelocity[2] = flGroundFactor * sqrt(2 * 800 * 57.0); // 2 * gravity * height
}
else
{
mv->m_vecVelocity[2] += flGroundFactor * sqrt(2 * 800 * 57.0); // 2 * gravity * height
}
//stamina stuff (scroll gamemode only)
ConVarRef gm("mom_gamemode");
if (gm.GetInt() == MOMGM_SCROLL)
{
if (player->m_flStamina > 0)
{
float flRatio;
flRatio = (STAMINA_MAX - ((player->m_flStamina / 1000.0) * STAMINA_RECOVER_RATE)) / STAMINA_MAX;
mv->m_vecVelocity[2] *= flRatio;
}
player->m_flStamina = (STAMINA_COST_JUMP / STAMINA_RECOVER_RATE) * 1000.0;
}
FinishGravity();
mv->m_outWishVel.z += mv->m_vecVelocity[2] - startz;
mv->m_outStepHeight += 0.1f;
// Flag that we jumped.
mv->m_nOldButtons |= IN_JUMP; // don't jump again until released
return true;
}
int
main(int argc, char** argv)
{
// parse arguments
warthog::util::param valid_args[] =
{
{"scen", required_argument, 0, 0},
{"alg", required_argument, 0, 1},
{"gen", required_argument, 0, 3},
{"help", no_argument, &print_help, 1},
{"checkopt", no_argument, &checkopt, 1},
{"verbose", no_argument, &verbose, 1},
{"wgm", no_argument, &wgm, 1}
};
warthog::util::cfg cfg;
cfg.parse_args(argc, argv, valid_args);
if(print_help)
{
help();
exit(0);
}
std::string sfile = cfg.get_param_value("scen");
std::string alg = cfg.get_param_value("alg");
std::string gen = cfg.get_param_value("gen");
// generate scenarios
if(gen != "")
{
warthog::scenario_manager sm;
warthog::gridmap gm(gen.c_str());
sm.generate_experiments(&gm, 1000) ;
sm.write_scenario(std::cout);
exit(0);
}
// run experiments
if(alg == "" || sfile == "")
{
std::cerr << "Err. Must specify a scenario file and search algorithm. Try --help for options.\n";
exit(0);
}
warthog::scenario_manager scenmgr;
scenmgr.load_scenario(sfile.c_str());
if(alg == "jps+")
{
run_jpsplus(scenmgr);
}
if(alg == "jps2")
{
run_jps2(scenmgr);
}
if(alg == "jps2+")
{
run_jps2plus(scenmgr);
}
if(alg == "jps")
{
if(wgm)
{
run_jps_wgm(scenmgr);
}
else
{
run_jps(scenmgr);
}
}
if(alg == "astar")
{
if(wgm)
{
run_wgm_astar(scenmgr);
}
else
{
run_astar(scenmgr);
}
}
if(alg == "sssp")
{
if(wgm)
{
run_wgm_sssp(scenmgr);
}
else
{
//run_astar(scenmgr);
}
}
}
