Exemplo n.º 1
0
__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);

}
Exemplo n.º 2
0
__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

}
Exemplo n.º 3
0
//! 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);
}
Exemplo n.º 4
0
__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;
}
Exemplo n.º 5
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;
}
Exemplo n.º 6
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;
}