static void La_HuelleFil(LIT x) /* Berechnet Huelle, DeltaN, DeltaK und NeuK. */ /* (Im Falle von BAUMRES auch EinerKl.) */ { StapeleintragFZ sp; /* Stapelzeiger auf das naechste freie Element in HF */ StapeleintragFZ p; if (++Runde == 0) { NullsetzenRK(); NullsetzenRL(); Runde = 1; } DN = & (DeltaN[Eps][Schalter]); HF = Huelle[Eps][Schalter]; DKF = DeltaK[Eps][Schalter]; NK = NeuK[Eps][Schalter]; #ifndef BAUMRES HF[0] = x; #else HF -> l = x; #endif sp = HF + 1; setzenRundeL(x); p = HF; { unsigned int i; for (i = 2; i <= aktP; i++) DKF[i] = NK[i] = 0; } do { sp = La_belegeFil(x, sp); p++; if (sp > p) /* noch 1-Kl. zu eliminieren? */ #ifndef BAUMRES x = *p; #else x = p -> l; #endif else { *DN = p - HF; return; } }
__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; }