__inline__ bool rebelege_Verz(LIT x)
/* Macht x -> 0 wieder rueckgaengig fuer eine Verzweigungsvariable. */
/* rebelege_Verz = true falls verzweigt werden muss. */
{
LITV y, z;
LIT kx;
VAR v;
for (y = erstesVork(x); echtesVork(y, x); y = naechstesVork(y))
{
bindeLK(y);
LaengeP1(KlnVk(y));
}
for (y = erstesVork(kx = Komp(x)); echtesVork(y, kx); y = naechstesVork(y))
for (z = naechstesVorkK(y); z != y; z = naechstesVorkK(z))
bindeLv(z);
bindeV(v = Var(x));
setzenbelegt(v, false);
return enthalten(v);
}
__inline__ void rebelege(LIT x)
/* Macht x -> 0 wieder rueckgaengig */
/* ("belegt" wird wieder rueckgesetzt). */
/* Ist BAUMRES gesetzt, so wird aktrelV aktualisiert. */
{
LITV y, z;
LIT kx;
VAR v;
for (y = erstesVork(x); echtesVork(y, x); y = naechstesVork(y))
{
bindeLK(y);
LaengeP1(KlnVk(y));
}
for (y = erstesVork(kx = Komp(x)); echtesVork(y, kx); y = naechstesVork(y))
for (z = naechstesVorkK(y); z != y; z = naechstesVorkK(z))
bindeLv(z);
bindeV(v = Var(x));
setzenbelegt(v, false);
#ifdef BAUMRES
if (enthalten(v))
relVhinzufuegen();
#endif
}
void InitVarLitKlm(void) {
#ifdef BAUMRES
# ifndef LITTAB
extern VarMenge aktrelV;
LITV x = F;
for (unsigned int i = 0; i < L; ++x, ++i) {
const VAR v = Var(LitVk(x)); const VarMenge M = VarK(KlnVk(x));
assert(M + (VPosition(v) - aktrelV));
*(M + (VPosition(v) - aktrelV)) |= VMaske(v);
}
# endif
#endif
return;
}
//! processing x -> 0
__inline__ void belege(const LIT x) {
/* Mit Aktualisierung von "LaenK" und Eintrag in "Pfad" und "belegt". */
/* Vorbedingungen: Es entsteht nicht die leere Klausel. */
/* entferne alle x-Vorkommen aus ihren Klauseln: */
for (LITV y = erstesVork(x); echtesVork(y, x); y = naechstesVork(y)) {
loeseLK(y);
LaengeM1(KlnVk(y));
}
/* fuer Klauseln C mit (non x) entferne alle anderen y in C aus ihren Vorkommenslisten: */
const LIT kx = Komp(x);
for (LITV y = erstesVork(kx); echtesVork(y, kx); y = naechstesVork(y))
for (LITV z = naechstesVorkK(y); z != y; z = naechstesVorkK(z))
loeseLv(z);
LiteinPfad(x); ++Tiefe;
const VAR v = Var(x);
loeseV(v);
setzenbelegt(v, true);
}
__inline__ void belege_VK(const LIT x, const KLN K) {
/* Hier wird noch die fuer die 1-Klauseln-Erzeugung relevante Klausel */
/* in relVar eingetragen. */
/* "belege_VK" wird nicht fuer die Verzweigungsvariable verwendet. */
/* entferne alle x-Vorkommen aus ihren Klauseln: */
for (LITV y = erstesVork(x); echtesVork(y, x); y = naechstesVork(y)) {
loeseLK(y);
LaengeM1(KlnVk(y));
}
/* fuer Klauseln C mit (non x) in C entferne alle anderen y in C aus */
/* ihren Vorkommenslisten: */
const LIT kx = Komp(x);
for (LITV y = erstesVork(kx); echtesVork(y, kx); y = naechstesVork(y))
for (LITV z = naechstesVorkK(y); z != y; z = naechstesVorkK(z))
loeseLv(z);
LiteinPfad(x);
const VAR v = Var(x);
loeseV(v);
setzenbelegt(v, true);
Kln_eintragen_relV(K);
++Tiefe;
}
__inline__ static StapeleintragFZ La_belegeFil(LIT x, StapeleintragFZ sp)
/* Fuehrt x -> 0 durch (bzgl. letzteRK, letzteRL und LaLaenK), */
/* schreibt neu entstehende 1-Klauseln nach HF (mit Eintrag in letzteRL), */
/* wobei sp erhoeht wird, und aktualisiert DKF und NK. */
/* Vor.: Es entsteht nicht die leere Klausel. */
/* Im Falle von BAUMRES wird auch EK aktualisiert. */
/* Rueckgabewert ist der neue Wert von sp. */
{
LITV y, z;
LIT kx, lz, klz;
KLN kn; KLL p;
/* Durchlaufe alle x-Vorkommen und kuerze die aktiven Klauseln */
for (y = erstesVork(x); echtesVork(y, x); y = naechstesVork(y))
{
if (RundeK( kn = KlnVk(y) ) != Runde) /* Klausel von y noch nicht angefasst? */
{
if (Laenge(kn) == 2) /* 2-Klausel? */
{
if (RundeL(klz = Komp(LitVk(naechstesVorkK(y)))) != Runde)
/* 1-Kl-Elim. nicht schon * vorgemerkt? */
{
setzenRundeL(klz);
#ifndef BAUMRES
*(sp++) = klz;
#else
sp -> l = klz;
(sp++) -> k = kn;
#endif
}
}
else /* >= 3-Klausel */
{
setzenRundeK(kn);
p = Laenge(kn);
ZuwLaLaenge(kn, p-1);
DKF[p-1]--;
DKF[p]++;
NK[p-1]++;
}
}
else /* Klausel schon angefasst */
{
if ((p = LaLaenge(kn)) != 0) /* Klausel noch nicht erfuellt? */
{
if (p == 2) /* 2-Klausel? */
{
for (z = naechstesVorkK(y); ; z = naechstesVorkK(z)) /* Suche zweites Literal */
if (RundeL(lz = LitVk(z)) != Runde) /* z nicht auf 0 gesetzt? */
break;
if (RundeL(klz = Komp(lz)) != Runde) /* 1-Kl-Elim. nicht schon vorgemerkt? */
{
setzenRundeL(klz);
#ifndef BAUMRES
*(sp++) = klz;
#else
sp -> l = klz;
(sp++) -> k = kn;
#endif
}
}
else /* >= 3-Klausel */
{
DKF[ M1LaLaenge(kn) ]--;
DKF[p]++;
NK[p-1]++;
NK[p]--;
}
}
}
}
/* Durchlaufen der Komp(x)-Vorkommen und eliminiere alle noch aktiven Klauseln */
for (y = erstesVork(kx = Komp(x)); echtesVork(y, kx); y = naechstesVork(y))
if (RundeK( kn = KlnVk(y) ) != Runde) /* Klausel nicht schon angefasst? */
{
setzenRundeK(kn);
DKF[Laenge(kn)]++;
ZuwLaLaenge(kn, 0);
}
else /* Klausel schon angefasst */
{
if ( (p = LaLaenge(kn)) != 0) /* Klausel noch nicht erfuellt? */
{
DKF[p]++;
NK[p]--;
ZuwLaLaenge(kn, 0);
}
}
return sp;
}
__inline__ static StapeleintragFZ La_belegeFil(const LIT x, StapeleintragFZ sp) {
/* Fuehrt x -> 0 durch (bzgl. letzteRK, letzteRL und LaLaenK), */
/* schreibt neu entstehende 1-Klauseln nach HF (mit Eintrag in letzteRL), */
/* wobei sp erhoeht wird, und aktualisiert DKF und NK. */
/* Vor.: Es entsteht nicht die leere Klausel. */
/* Im Falle von BAUMRES wird auch EK aktualisiert. */
/* Rueckgabewert ist der neue Wert von sp. */
/* Durchlaufe alle x-Vorkommen und kuerze die aktiven Klauseln: */
for (LITV y = erstesVork(x); echtesVork(y, x); y = naechstesVork(y)) {
const KLN kn = KlnVk(y);
if (RundeK(kn) != Runde) {
/* Klausel von y noch nicht angefasst? */
if (Laenge(kn) == 2) { /* 2-Klausel? */
const LIT klz = Komp(LitVk(naechstesVorkK(y)));
if (RundeL(klz) != Runde) {
/* 1-Kl-Elim. nicht schon vorgemerkt? */
setzenRundeL(klz);
#ifndef BAUMRES
*(sp++) = klz;
#else
sp -> l = klz;
(sp++) -> k = kn;
#endif
}
}
else { /* >= 3-Klausel */
setzenRundeK(kn);
const KLL p = Laenge(kn);
ZuwLaLaenge(kn, p-1);
--DKF[p-1];
++DKF[p];
++NK[p-1];
}
}
else { /* Klausel schon angefasst */
const KLL p = LaLaenge(kn);
if (p != 0) { /* Klausel noch nicht erfuellt? */
if (p == 2) { /* 2-Klausel? */
LIT lz; // the second literal
for (LITV z = naechstesVorkK(y); RundeL(lz=LitVk(z)) == Runde; z = naechstesVorkK(z));
const LIT klz = Komp(lz);
if (RundeL(klz) != Runde) { /* 1-Kl-Elim. nicht schon vorgemerkt? */
setzenRundeL(klz);
#ifndef BAUMRES
*(sp++) = klz;
#else
sp -> l = klz;
(sp++) -> k = kn;
#endif
}
}
else { /* >= 3-Klausel */
--DKF[ M1LaLaenge(kn) ];
++DKF[p];
++NK[p-1];
--NK[p];
}
}
}
}
/* Durchlaufen der Komp(x)-Vorkommen und eliminiere alle noch aktiven Klauseln */
const LIT kx = Komp(x);
for (LITV y = erstesVork(kx); echtesVork(y, kx); y = naechstesVork(y)) {
const KLN kn = KlnVk(y);
if (RundeK(kn) != Runde) { /* Klausel nicht schon angefasst? */
setzenRundeK(kn);
++DKF[Laenge(kn)];
ZuwLaLaenge(kn, 0);
}
else { /* Klausel schon angefasst */
const KLL p = LaLaenge(kn);
if (p != 0) { /* Klausel noch nicht erfuellt? */
++DKF[p];
--NK[p];
ZuwLaLaenge(kn, 0);
}
}
}
return sp;
}
