Ejemplo n.º 1
0
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;
	}
    }
Ejemplo n.º 2
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;
}
Ejemplo n.º 3
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;
}