Beispiel #1
0
__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;
}
Beispiel #2
0
__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;
}