bool PbSolver::convertPbs(bool first_call)
{
vec<Formula> converted_constrs;
if (first_call){
findIntervals();
if (!rewriteAlmostClauses()){
ok = false;
return false; }
}
for (int i = 0; i < constrs.size(); i++){
if (constrs[i] == NULL) continue;
Linear& c = *constrs[i]; assert(c.lo != Int_MIN || c.hi != Int_MAX);
if (options->opt_verbosity >= 1)
/**/reportf("---[%4d]---> ", constrs.size() - 1 - i);
if (options->opt_convert == ct_Sorters) {
if (options->opt_dump) { // no formulae built
buildConstraint(c,primesLoader, options);
} else {
converted_constrs.push(buildConstraint(c,primesLoader, options));
}
}
else if (options->opt_convert == ct_Adders)
linearAddition(c, converted_constrs, options->opt_verbosity);
else if (options->opt_convert == ct_BDDs)
converted_constrs.push(convertToBdd(c, options->opt_verbosity));
else if (options->opt_convert == ct_Mixed){
int adder_cost = estimatedAdderCost(c);
//**/printf("estimatedAdderCost: %d\n", estimatedAdderCost(c));
Formula result = convertToBdd(c, options->opt_verbosity, (int)(adder_cost * options->opt_bdd_thres));
if (result == _undef_)
result = buildConstraint(c,primesLoader, options, (int)(adder_cost * options->opt_sort_thres));
if (result == _undef_)
linearAddition(c, converted_constrs, options->opt_verbosity);
else
converted_constrs.push(result);
}else
assert(false);
if (!ok) return false;
}
if (!options->opt_validateResoult) cleanPBC();
formulaSize = converted_constrs.size();
clausify(*sat_solver, options, converted_constrs);
if (options->opt_dump) {
exit(0);
}
return ok;
}
// Will return '_undef_' if 'cost_limit' is exceeded.
//
Formula buildConstraint(const Linear& c, int max_cost)
{
vec<Formula> ps;
vec<Int> Cs;
for (int j = 0; j < c.size; j++)
ps.push(lit2fml(c[j])),
Cs.push(c(j));
vec<Int> dummy;
int cost;
vec<int> base;
optimizeBase(Cs, dummy, cost, base);
FEnv::push();
Formula ret;
try {
ret = buildConstraint(ps, Cs, base, c.lo, c.hi, max_cost);
}catch (Exception_TooBig){
FEnv::pop();
return _undef_;
}
if (opt_verbosity >= 1){
reportf("Sorter-cost:%5d ", FEnv::topSize());
reportf("Base:"); for (int i = 0; i < base.size(); i++) reportf(" %d", base[i]); reportf("\n");
}
FEnv::keep();
return ret;
}
static
Formula buildConstraint(vec<Formula>& ps, vec<Int>& Cs, vec<int>& base, Int lo, Int hi, int max_cost)
{
vec<Formula> carry;
vec<vec<Formula> > digits;
buildConstraint(ps, Cs, carry, base, 0, digits, max_cost);
if (FEnv::topSize() > max_cost) throw Exception_TooBig();
vec<int> lo_digs;
vec<int> hi_digs;
if (lo != Int_MIN)
convert(lo, base, lo_digs);
if (hi != Int_MAX)
convert(hi+1, base, hi_digs); // (+1 because we will change '<= x' to '!(... >= x+1)'
/*DEBUG
pf("Networks:");
for (int i = 0; i < digits.size(); i++)
pf(" %d", digits[i].size());
pf("\n");
if (lo != Int_MIN){
pf("lo=%d :", lo); for (int i = 0; i < lo_digs.size(); i++) pf(" %d", lo_digs[i]); pf("\n"); }
if (hi != Int_MAX){
pf("hi+1=%d :", hi+1); for (int i = 0; i < hi_digs.size(); i++) pf(" %d", hi_digs[i]); pf("\n"); }
END*/
/*
Base: (1) 8 24 480
aaa bbbbbb ccc ddddddd
Num: 2 0 5 6
*/
Formula ret = ((lo == Int_MIN) ? _1_ : lexComp(lo_digs, digits))
& ((hi == Int_MAX) ? _1_ : ~lexComp(hi_digs, digits));
if (FEnv::topSize() > max_cost) throw Exception_TooBig();
return ret;
}
Racer::Racer(IDirect3DDevice9* device, RacerType racerType)
{
engineVoice = NULL;
gunMountDraw = new Drawable(GUNMOUNTMESH, "textures/gun.dds", device);
Renderer::renderer->addDrawable(gunMountDraw);
gunDraw = new Drawable(GUNMESH, "textures/gun.dds", device);
Renderer::renderer->addDrawable(gunDraw);
engineVoice = Sound::sound->reserveSFXVoice();
health = 100;
kills = 0;
suicides = 0;
deaths = 0;
givenDamage = 0;
takenDamage = 0;
laserReady = true;
laserTime = 0.0f;
respawnTimer = 0.0f;
respawned = true;
index = -1;
currentSteering = 0.0f;
currentAcceleration = 0.0f;
lookDir.set(0, 0, 1);
lookHeight = 0;
switch (racerType)
{
case RACER1:
drawable = new Drawable(RACER, "textures/racerred.dds", device);
break;
case RACER2:
drawable = new Drawable(RACER, "textures/racerblue.dds", device);
break;
case RACER3:
drawable = new Drawable(RACER, "textures/racerorange.dds", device);
break;
case RACER4:
drawable = new Drawable(RACER, "textures/racergreen.dds", device);
break;
case RACER5:
drawable = new Drawable(RACER, "textures/racerteal.dds", device);
break;
case RACER6:
drawable = new Drawable(RACER, "textures/raceryellow.dds", device);
break;
case RACER7:
drawable = new Drawable(RACER, "textures/racerpurple.dds", device);
break;
case RACER8:
drawable = new Drawable(RACER, "textures/racerpink.dds", device);
break;
default:
drawable = new Drawable(RACER, "textures/racerred.dds", device);
}
// Set up filter group (so the car doesn't collide with the wheels)
int collisionGroupFilter = Physics::physics->getFilter();
hkpRigidBodyCinfo info;
hkVector4 halfExtent(0.9f, 0.6f, 2.3f); //Half extent for racer rigid body box
info.m_shape = new hkpBoxShape(halfExtent);
info.m_qualityType = HK_COLLIDABLE_QUALITY_CRITICAL;
info.m_centerOfMass.set(0.0f, 0.0f, 0.0f);
info.m_restitution = 0.0f;
info.m_maxAngularVelocity = 10.0f;
info.m_maxLinearVelocity = 170.0f;
info.m_angularDamping = 0.4f;
hkpMassProperties massProperties;
hkpInertiaTensorComputer::computeBoxVolumeMassProperties(halfExtent, chassisMass, massProperties);
info.setMassProperties(massProperties);
info.m_collisionFilterInfo = hkpGroupFilter::calcFilterInfo(hkpGroupFilterSetup::LAYER_AI, collisionGroupFilter);
body = new hkpRigidBody(info); //Create rigid body
body->setLinearVelocity(hkVector4(0, 0, 0));
info.m_shape->removeReference();
hkpPropertyValue val;
val.setPtr(this);
body->setProperty(0, val);
index = Renderer::renderer->addDrawable(drawable);
Physics::physics->addRigidBody(body);
// Create tires
wheelFL = new FrontWheel(device, collisionGroupFilter);
Renderer::renderer->addDrawable(wheelFL->drawable);
Physics::physics->addRigidBody(wheelFL->body);
wheelFR = new FrontWheel(device, collisionGroupFilter);
Renderer::renderer->addDrawable(wheelFR->drawable);
Physics::physics->addRigidBody(wheelFR->body);
wheelRL = new RearWheel(device, collisionGroupFilter);
Renderer::renderer->addDrawable(wheelRL->drawable);
Physics::physics->addRigidBody(wheelRL->body);
wheelRR = new RearWheel(device, collisionGroupFilter);
Renderer::renderer->addDrawable(wheelRR->drawable);
Physics::physics->addRigidBody(wheelRR->body);
// Now constrain the tires
hkpGenericConstraintData* constraint;
hkpConstraintInstance* constraintInst;
constraint = new hkpGenericConstraintData();
buildConstraint(&attachFL, constraint, FRONT);
constraintInst = new hkpConstraintInstance(wheelFL->body, body, constraint);
Physics::world->addConstraint(constraintInst);
constraint->removeReference();
constraint = new hkpGenericConstraintData();
buildConstraint(&attachFR, constraint, FRONT);
constraintInst = new hkpConstraintInstance(wheelFR->body, body, constraint);
Physics::world->addConstraint(constraintInst);
constraint->removeReference();
constraint = new hkpGenericConstraintData();
buildConstraint(&attachRL, constraint, REAR);
constraintInst = new hkpConstraintInstance(wheelRL->body, body, constraint);
Physics::world->addConstraint(constraintInst);
constraint->removeReference();
constraint = new hkpGenericConstraintData();
buildConstraint(&attachRR, constraint, REAR);
constraintInst = new hkpConstraintInstance(wheelRR->body, body, constraint);
Physics::world->addConstraint(constraintInst);
constraint->removeReference();
hkpConstraintStabilizationUtil::stabilizeRigidBodyInertia(body);
reset(&(hkVector4(0, 0, 0, 0)), 0);
emitter = Sound::sound->getEmitter();
braking = false;
}
Racer::Racer(IDirect3DDevice9* device, Renderer* r, Physics* p, RacerType racerType)
{
index = -1;
currentSteering = 0.0f;
switch (racerType)
{
case PLAYER:
drawable = new Drawable(RACER, "racer1.dds", device);
break;
case AI1:
drawable = new Drawable(RACER, "racer2.dds", device);
break;
default:
drawable = new Drawable(RACER, "racer2.dds", device);
}
// Set up filter group (so the car doesn't collide with the wheels)
int collisionGroupFilter = p->getFilter();
hkpRigidBodyCinfo info;
hkVector4 halfExtent(0.9f, 0.7f, 2.3f); //Half extent for racer rigid body box
info.m_shape = new hkpBoxShape(halfExtent);
info.m_qualityType = HK_COLLIDABLE_QUALITY_CRITICAL;
info.m_centerOfMass = hkVector4(0.0f, -0.4f, -1.2f); // move CM a bit
info.m_restitution = 0.1f;
hkpMassProperties massProperties;
hkpInertiaTensorComputer::computeBoxVolumeMassProperties(halfExtent, chassisMass, massProperties);
info.setMassProperties(massProperties);
info.m_collisionFilterInfo = hkpGroupFilter::calcFilterInfo(hkpGroupFilterSetup::LAYER_AI, collisionGroupFilter);
body = new hkpRigidBody(info); //Create rigid body
body->setLinearVelocity(hkVector4(0, 0, 0));
info.m_shape->removeReference();
index = r->addDrawable(drawable);
p->addRigidBody(body);
// Create tires
wheelFL = new FrontWheel(device, collisionGroupFilter);
r->addDrawable(wheelFL->drawable);
p->addRigidBody(wheelFL->body);
WheelListener* listenFL = new WheelListener(&(wheelFL->touchingGround));
wheelFL->body->addContactListener(listenFL);
wheelFR = new FrontWheel(device, collisionGroupFilter);
r->addDrawable(wheelFR->drawable);
p->addRigidBody(wheelFR->body);
WheelListener* listenFR = new WheelListener(&(wheelFR->touchingGround));
wheelFL->body->addContactListener(listenFR);
wheelRL = new RearWheel(device, collisionGroupFilter);
r->addDrawable(wheelRL->drawable);
p->addRigidBody(wheelRL->body);
WheelListener* listenRL = new WheelListener(&(wheelRL->touchingGround));
wheelFL->body->addContactListener(listenRL);
wheelRR = new RearWheel(device, collisionGroupFilter);
r->addDrawable(wheelRR->drawable);
p->addRigidBody(wheelRR->body);
WheelListener* listenRR = new WheelListener(&(wheelRR->touchingGround));
wheelFL->body->addContactListener(listenRR);
// Now constrain the tires
hkpGenericConstraintData* constraint;
hkpConstraintInstance* constraintInst;
constraint = new hkpGenericConstraintData();
buildConstraint(&attachFL, constraint, FRONT);
constraintInst = new hkpConstraintInstance(wheelFL->body, body, constraint);
p->world->addConstraint(constraintInst);
constraint->removeReference();
constraint = new hkpGenericConstraintData();
buildConstraint(&attachFR, constraint, FRONT);
constraintInst = new hkpConstraintInstance(wheelFR->body, body, constraint);
p->world->addConstraint(constraintInst);
constraint->removeReference();
constraint = new hkpGenericConstraintData();
buildConstraint(&attachRL, constraint, REAR);
constraintInst = new hkpConstraintInstance(wheelRL->body, body, constraint);
p->world->addConstraint(constraintInst);
constraint->removeReference();
constraint = new hkpGenericConstraintData();
buildConstraint(&attachRR, constraint, REAR);
constraintInst = new hkpConstraintInstance(wheelRR->body, body, constraint);
p->world->addConstraint(constraintInst);
constraint->removeReference();
hkpConstraintStabilizationUtil::stabilizeRigidBodyInertia(body);
reset();
}
static
void buildConstraint(vec<Formula>& ps, vec<Int>& Cs, vec<Formula>& carry, vec<int>& base, int digit_no, vec<vec<Formula> >& out_digits, int max_cost)
{
assert(ps.size() == Cs.size());
if (FEnv::topSize() > max_cost) throw Exception_TooBig();
/**
pf("buildConstraint(");
for (int i = 0; i < ps.size(); i++)
pf("%d*%s ", Cs[i], (*debug_names)[index(ps[i])]);
pf("+ %d carry)\n", carry.size());
**/
if (digit_no == base.size()){
// Final digit, build sorter for rest:
// -- add carry bits:
for (int i = 0; i < carry.size(); i++)
ps.push(carry[i]),
Cs.push(1);
out_digits.push();
buildSorter(ps, Cs, out_digits.last());
}else{
vec<Formula> ps_rem;
vec<int> Cs_rem;
vec<Formula> ps_div;
vec<Int> Cs_div;
// Split sum according to base:
int B = base[digit_no];
for (int i = 0; i < Cs.size(); i++){
Int div = Cs[i] / Int(B);
int rem = toint(Cs[i] % Int(B));
if (div > 0){
ps_div.push(ps[i]);
Cs_div.push(div);
}
if (rem > 0){
ps_rem.push(ps[i]);
Cs_rem.push(rem);
}
}
// Add carry bits:
for (int i = 0; i < carry.size(); i++)
ps_rem.push(carry[i]),
Cs_rem.push(1);
// Build sorting network:
vec<Formula> result;
buildSorter(ps_rem, Cs_rem, result);
// Get carry bits:
carry.clear();
for (int i = B-1; i < result.size(); i += B)
carry.push(result[i]);
out_digits.push();
for (int i = 0; i < B-1; i++){
Formula out = _0_;
for (int j = 0; j < result.size(); j += B){
int n = j+B-1;
if (j + i < result.size())
out |= result[j + i] & ((n >= result.size()) ? _1_ : ~result[n]);
}
out_digits.last().push(out);
}
buildConstraint(ps_div, Cs_div, carry, base, digit_no+1, out_digits, max_cost); // <<== change to normal loop
}
}
// Will return '_undef_' if 'cost_limit' is exceeded.
//
Formula buildConstraint(const Linear& c,PrimesLoader& pl, PBOptions* options, int max_cost)
{
vec<Formula> ps;
vec<Int> Cs;
for (int j = 0; j < c.size; j++)
ps.push(lit2fml(c[j])),
Cs.push(c(j));
vec<int> base;
SearchMetaData* data = searchForBase(Cs, base, pl, options);
FEnv::push();
if (options->opt_dump) { // don't spend time on building unneeded formulae
return _undef_;
}
Int lo = c.lo;
Int hi = c.hi;
if (options->opt_tare & (lo == hi | lo == Int_MIN | hi == Int_MAX)) {
Int toNormlize;
Int toAdd;
if (lo == Int_MIN) toNormlize = hi;
else toNormlize = lo;
Int temp = 1;
int i;
for(i=0;temp<toNormlize && i<base.size();i++) temp *= base[i];
if (temp < toNormlize) {
i=2;
while (temp*i < toNormlize) i++;
temp*=i;
}
else {
i--;
Int bmi;
if (i==-1) bmi=1;
else bmi = temp / base[i];
while(temp-bmi>=toNormlize) temp-=bmi;
assert(temp > toNormlize);
}
toAdd = temp-toNormlize;
if (toAdd>0) {
ps.push(_1_);
Cs.push(toAdd);
if (lo != Int_MIN) lo=lo+toAdd;
if (hi != Int_MAX) hi=hi+toAdd;
}
}
Formula ret;
try {
if (options->opt_verbosity >= 1) {
if (c.lo != Int_MIN) {
printf("orignal lo:%5d \n", (int)toint(c.lo));
printf("normlized lo:%5d \n", (int)toint(lo));
}
if (c.hi != Int_MAX) {
printf("orignal hi:%5d \n", (int)toint(c.hi));
printf("normlized hi:%5d \n", (int)toint(hi));
}
}
ret = buildConstraint(ps, Cs, base, lo, hi, max_cost, options);
}catch (Exception_TooBig){
FEnv::pop();
return _undef_;
}
if (data!=0) data->fEnvSize = FEnv::topSize();
if (options->opt_verbosity >= 1){
printf("FEnv.topSize:%5d ", FEnv::topSize());
printf("Base:"); for (int i = 0; i < base.size(); i++) printf(" %d", base[i]); printf("\n");
}
FEnv::keep();
return ret;
}
