Programmieren mit XBOOLE

Transkript

1 Wissenschaftliche Schriftenreihe Technische Universität Chemnitz Frank Dresig / Nico Kümmling / Bernd Steinbach / Jens Wazel Programmieren mit XBOOLE Chemnitz 1992

2 Autoren Dipl.-Ing. Frank Dresig Dipl.-Ing. Nico Kümmling Doz. Dr.-Ing. habil. Bernd Steinbach Dipl.-Ing. Jens Wazel Technische Universität Chemnitz Fachbereich Elektrotechnik Lehrstuhl Informationstechnik/Automatentheorie Leiter: Prof. Dr.-Ing. habil. D. Bochmann Reichenhainer Straße Chemnitz Telefon (Chemnitz) Telefax (Chemnitz)

3 Vorwort Sie haben das Buch "Logikentwurf mit XBOOLE" studiert, einige allgemeine Probleme mit XBM gelöst, sich dabei schon ein wenig in die Philosophie von XBOOLE eingearbeitet und wollen nun Ihr ganz spezielles Problem mit XBOOLE/XB PORT bearbeiten, die Fähigkeiten von XBOOLE in Ihren eigenen C-Programmen nutzen. Also los. Turbo-C starten, einen 40k-Quelltext laden, einige XB_PORT-Befehle eintippen, Compilerlauf. Ein Kinderspiel. Sie holen sich einen Becher Kaffee, freuen sich wieder einmal über den neuen Rechner, der Ihnen freudig entgegenblinkt. Doch was müssen Sie entdecken: Error, undefined, undefined Dass Ihnen das passieren muss! Also - <CTRL+PgUp>, '#include "xb_port.h" eintragen, speichern, Projektfile laden, 'xb_portl.lib' hinzufügen, speichern, per Pick zurück, F9 schon im Tastaturpuffer. Routine. Sie pusten in den Kaffee, schielen über den Becherrand. Success. Na also. Run. Die Fehlermeldung bemerken Sie erst nach einem Moment, da Sie sich gerade die Zunge verbrannt haben. Sie lehnen sich zurück. So einfach ist es wohl doch nicht. Seufzend drehen Sie am Kontrastregler, greifen nach Buch und Dokumentation, vorsichtig und in kleinen Schlucken den Kaffee genießend. Stunden später Sie haben sich festgebissen, Sie blättern, lesen, notieren Satzfetzen, malen Bitkombinationen, schütteln den Kopf. Der Abschiedsgruß Ihrer Kollegen ist längst in leeren Fluren verhallt. Trockenschwimmen macht raue Haut. Für heute geben Sie auf. Ist es Ihnen so oder ähnlich ergangen? Gibt es Effekte in der Arbeit mit XB_PORT, die Ihnen so abwegig erscheinen, dass nur ein Systemfehler die Ursache sein kann? Wollen Sie einige Tricks kennenlernen, die Ihre Programme sicherer und überschaubarer werden lassen? Möchten Sie die Möglichkeiten von XB_PORT voll ausreizen? Dann verschieben Sie zunächst einmal das große Problem, das einer XBOOLE-unterstützten Lösung harrt. Folgen Sie uns auf einen kleinen Exkurs durch die Geheimnisse von XB_PORT. Das vorliegende Heft soll Ihnen dabei helfen. Im ersten Abschnitt diskutieren wir zunächst das Einsatzfeld eines XBOOLE-Monitors und seine Grenzen. Damit wird Ihnen die Entscheidung erleichtert, ob sich eine Aufgabe besser als XBOOLE- C-Programm oder durch die direkte Anwendung des XBOOLE-Monitors lösen lässt. 3

4 Der zweite Abschnitt soll Ihnen den Einstieg in die Anwendung von XBOOLE in C-Programmen erleichtern. Anhand leicht verständlicher Problemstellungen werden XBOOLE-Lösungen als vollständige C-Programme angegeben und erläutert. Wir haben dabei bewusst solche XBOOLE- Operationen ausgewählt, die einerseits sehr häufig verwendet werden und andererseits XBOOLE- Anwender in der Lernphase vor Probleme stellen. Besonders wertvoll waren dabei Hinweise aus /Wa91/ und auch die Fragen vieler Studenten zur XBOOLE-Programmierung. Der dritte Abschnitt beschreibt XBOOLE unter globalen Aspekten. Es werden wesentliche Eigenschaften und Anwendungsgebiete vorgestellt, verwendete Abkürzungen und nutzbare vordefinierte Konstanten aufgelistet. Weiter werden die für XBOOLE verwendeten Operationsprinzipien beschrieben und ein Überblick über den Systemaufbau gegeben. Die genaue Darstellung der Datenstrukturen der XBOOLE-Objekte bildet den Schwerpunkt im vierten Abschnitt. Dieses Wissen ist Voraussetzung, um bestimmte Befehle von XB PORT, die unmittelbar mit Teilen von XBOOLE-Objekten arbeiten, effektiv nutzen zu können. Alle 108 XBOOLE-Operationen werden detailliert im Abschnitt 5 vorgestellt. Ausführlich werden der Funktionsaufruf, die Parameter und die Operationsergebnisse erläutert. Der sechste Abschnitt beschreibt das Konzept der Fehlerbehandlung und fasst die XBOOLE-Fehlermeldungen zusammen. Der siebente Abschnitt enthält eine Befehlsübersicht sowie den in ein Anwenderprogramm einzubindenden XB_PORT-Header. Hier können Sie sich schnell über die Syntax von Befehlen informieren. Wir empfehlen Ihnen aber, dieses Heft zunächst erst einmal vollständig von vorn bis hinten zu lesen. Auf diese Weise ersparen Sie sich die Zeit zur Fehlersuche und werden mit allen Möglichkeiten, die XBOOLE bietet, vertraut. Falls Sie Hinweise zu XBOOLE benötigen oder uns Ihre Anwendungserfahrungen mitteilen möchten, stehen wir Ihnen gern als Diskussionspartner zur Verfügung. Chemnitz, den 21. Mai 1992 Frank Dresig Nico Kümmling Bernd Steinbach Jens Wazel 4

5 Inhaltsverzeichnis 1. Vom XBOOLE-Monitor zum XBOOLE-Programm Programmieren mit XBOOLE in C Zeiger und XBOOLE-Daten Datenübergabe Sequentieller Variablenzugriff Explizite Ternärvektoranalyse Eingabekonvertierung Felder in XB_PORT XBOOLE/XB_PORT - Charakteristik Wesen Symbole, Konstanten und Begriffe Organisationsprinzipien TM-Systeme Struktur systemrelevanter Objekte im Fachsystem Variablenliste Raumliste Raumdefinition Temärmatrizen (TM) Allgemeiner Aufbau Ternärvektorliste (TVL) Variablentupel - geordnete Variablenmenge (VT) Prädikate von Temärmatrizen Speicherliste Zusatzobjekte Datenstruktur auf externen Speichermedien XB_PORT - Operationen Mengenoperationen Ableitungsoperationen (Operationen des Booleschen Differentialkalküls) Konvertierungsoperationen Ternärmatrixoperationen

6 5.5. Testoperationen Variablenmengenoperationen Prädikatbestimmung Objektverwaltung Externe Speicherung Speicherverwaltung Fehlerbehandlung XB_PORT - Fehler XB_PORT - Übersicht Operationen Anwenderheader xb_port.h Literaturverzeichnis Index

7 1. Vom XBOOLE-Monitor zum XBOOLE-Programm Erste Kenntnisse der Arbeit mit XBOOLE haben Sie wahrscheinlich beim Umgang mit einem XBOOLE-Monitor erworben. Es ist unwichtig, ob Sie unter MS-DOS den pull-down-menügesteuerten XBOOLE-Monitor, den portablen, unter MS-DOS und UNIX lauffähigen durch Kommandozeilen gesteuerten XBOOLE-Monitor oder den an der Universität Stuttgart im Institut für Systemdynamik und Regelungstechnik erarbeiteten ebenfalls durch Kommandozeilen gesteuerten XBOOLE-Monitor mit erweiterter Steuersprache verwendet haben. Hinsichtlich der XBOOLE-Grundoperationen unterscheiden sich diese drei Programme nicht. Erstaunt werden Sie die schnellen Reaktionen auf Ihre Kommandos zum Ausführen Boolescher Operationen festgestellt haben und sich jetzt vielleicht fragen, lohnt es sich, über die Anwendung des XBOOLE-Monitors hinaus auch den Umgang mit XBOOLE in der Programmiersprache C zu erlernen. Dieser Abschnitt soll Ihnen als Entscheidungshilfe die Vorzüge des XBOOLE-Monitors, aber auch seine Grenzen zeigen und darüber hinaus den großen Gewinn andeuten, den Sie für viele Aufgaben durch die Anwendung von XBOOLE in C erzielen. Betrachten wir typische Schritte der Problemlösung an einer allgemein bekannten Aufgabenstellung. Primkonjunktionen einer Booleschen Funktion lassen sich nicht weiter vereinfachen und werden folglich für die Schaltungssynthese bevorzugt. Für Funktionen von vier bis fünf unabhängigen Variablen finden Sie die Primkonjunktionen noch bequem mit dem Karnaugh-Plan. Wie ermitteln Sie aber Primkonjunktionen, falls die Funktion etwa von 10 unabhängigen Variablen abhängt? Greifen wir dieses Problem auf und versuchen es zunächst mit dem XBOOLE-Monitor zu lösen. Gegeben sei die Boolesche Funktion f(x 1,...,x 10) als Boolescher Ausdruck in beliebiger Form und drei Konjunktionen von denen Sie wissen möchten, ob es Konjunktionen von f sind und welche Primkonjunktion jeweils die Konjunktion impliziert. Die Primärdaten erfassen Sie vorteilhaft in einem Problemprogramm für Ihren XBOOLE-Monitor, um das wiederholte Eintippen wegen irgendwelcher Schreibfehler zu sparen. Übernehmen Sie am besten das folgende pk_dat.prp und arbeiten es mit go pk_dat in Ihrem Monitor ab. Problemprogramm: space 16 1! Definiere Raum 1 mit max. 16 Variablen avar 1! Eingabe der Variablen x l x2 x3 x4 x5 x6 x7 x8 x9 x10. sbe 1 1! Lösen Boolescher Gleichungen (Ergebnis: Raum 1, Objekt 1) x2*/x4*x7+(xl#(x5+x4+/x10*x3*x8)#x2*/x4) &(x8+/x4*x6*/x9+x2*x4)+(x7=(x3+/x4))+ (/x2*/x8*x4#x6*/x2*x7#x2*/x10*x8)& (x3#x5*x9*/x4). tin 1 2 /d! Eingabe einer TVL (Raum 1, Objekt 2, disjunktive Form) xl x2 x3 x4 x5 x6 x7 x8 x9 xl ! K ! K ! K3 sts pk_dat! Speichern TM-System end 7

8 Mit dem Kommando cat können Sie überprüfen, ob die Funktions-TVL (gelöste Gleichung - Objektnummer 1) und die Liste der Konjunktionen (Objektnummer 2) angelegt wurden. Dabei erhalten Sie Informationen über die Zeilenanzahl und die Anzahl der belegten Fächer im Fachsystem. Wenn die Daten vorhanden sind, kann die Analyse beginnen. Zunächst ist die Frage zu beantworten, ob die Konjunktionen K1, K2 und K3 aus der Liste 2 überhaupt Konjunktionen von f sind. Als Kriterium hierfür kennen Sie die Boolesche Gleichung K j (x) f(x) = K j (x). Da Sie mit orthogonalen disjunktiv/antivalenten Formen arbeiten, verwenden Sie für die Konjunktion ISC (intersection - Durchschnitt) und für die Äquivalenz CSD (complement of symmetric difference - Komplement der symmetrischen Differenz). Mit STV wählen Sie die erste Konjunktion und tippen die folgenden Kommandos ein: Eingabe: STV 2 1 5! (K1) = 1 ISC 5 1 6! (K1 * f) = 1 CSD 6 5 7! (KI * f = K1) = 1 OBB 7 7! Ergebnis OUT 7 Ausgabe: x1 x2 x3 x4 x5 x6 x7 x8 x9 x Was sagt dieses Ergebnis? Die Boolesche Gleichung müsste für alle x-vektoren erfüllt sein. Eine "Strichzeile" für die x-variablen würde diesen Sachverhalt kennzeichnen. Ob sich die 8 Vektoren aber zu einer Strichzeile zusammenfassen lassen erkennt man nicht sofort. Leichter können Sie die Entscheidung treffen, wenn Sie das Komplement (CPL 7 8) bilden. Sehen Sie bei OUT 8 eine leere Liste, dann ist die gewählte Konjunktion für die Funktion verwendbar. Im XBOOLE-Monitor verwenden Sie dazu folgende Kommandos: Eingabe: STV 2 1 5! (KI) = 1 ISC 5 1 6! (K1 * f) = 1 CSD 6 5 7! (K1 * f = K1) = 1 CPL 7 8! (K1 * f = K1) = 0 OBB 8 8! Ergebnis OUT Ausgabe: x1 x2 x3 x4 x5 x6 x7 x8 x9 x Damit ist offensichtlich, dass K 1 keine Konjunktion der gegebenen Funktion f(x) ist und wir haben einen ersten Lösungsalgorithmus gefunden: ISC - CSD - CPL. 8

9 Mit dem XBOOLE-Monitor können Sie sehr gut experimentell verschiedene Algorithmen ausprobieren. Die beiden "C" (complement) in diesem Algorithmus weisen bereits auf eine Vereinfachungsmöglichkeit hin. Zwei Komplementbildungen nacheinander auszuführen, bringt für die Lösung keinen Gewinn. Den modifizierten Algorithmus ISC - SYD würde man auch aus der umgestellten Booleschen Gleichung (K j (x) f(x)) K j (x) = 0 finden. Entsteht mit diesem Algorithmus auch wirklich das gleiche Ergebnis? Probieren Sie es doch gleich einmal aus. Eingabe: STV ISC SYD OBB 7 7 OUT 7 Ausgabe: xl x2 x3 x4 x5 x6 x7 x8 x9 xl Ja, das gleiche Resultat entsteht. Eine Mengenoperation konnte eingespart werden. Wenn wir einmal über günstige Algorithmen für dieses Problem mit Unterstützung des XBOOLE-Monitors nachdenken, wollen wir auch möglichst einen wirklich optimalen Algorithmus finden. Eine weitere Umformung der Booleschen Gleichung führt zu K j (x) ( f(x) 1 ) = 0 K j (x) f(x) = 0. Sie können also sogar die beiden Operationen ISC und SYD durch die eine Operation DIF ersetzen. Enthält der neue Algorithmus DIF auch keinen Denkfehler? Er sieht beinahe zu einfach aus. Das Experiment mit dem XBOOLE- Monitor hilft uns Sicherheit zu gewinnen. Eingabe: STV DIF OBB 6 6 OUT 6 Ausgabe: xl x2 x3 x4 x5 x6 x7 x8 x9 xl Ja, das gleiche Resultat entsteht. Nun ist das Überprüfen der Konjunktionen K 2 und K 3 mit dem XBOOLE-Monitor ein Kinderspiel. 9

10 Eingabe: STV DIF OBB 6 6 OUT 6 Ausgabe: xl x2 x3 x4 x5 x6 x7 x8 x9 xl0. Eingabe: STV DIF OBB 6 6 OUT 6 Ausgabe: xl x2 x3 x4 x5 x6 x7 x8 x9 xl0. Für beide Konjunktionen K 2 und K 3 entstehen leere TVL, im Gegensatz zu K 1 können beiden Konjunktionen also zur Darstellung von f(x) verwendet werden. Handelt es sich aber bei K 2 und K 3 um Primkonjunktionen? Eine Primkonjunktion von f(x) muss einerseits eine Konjunktion von f(x) sein und das Kriterium ~ ヨ (x j i) max K j (x) f(x) = max K j (x) x j i x j i erfüllen. Die MAXK-Operation steht im XBOOLE-Monitor zur Verfügung. Aus den gerade durchgeführten algorithmischen Überlegungen wissen Sie, dass es günstiger ist, folgendes Kriterium zu verwenden ~ ヨ (x j i ) max K j (x) f(x) = 0. x j i Diese Formel lässt sich sehr einfach interpretieren. Durch max K j (x) = K j (x j i = 0) =K j (x j i = 1) = K j (x \ x j i). x j i wird eine Konjunktion K j (x \ x j i) berechnet, die aus K j (x) beim Entfernen von x j i entsteht. K j (x \ x j i) nimmt für doppelt so viel Binärvektoren den Wert Eins an als K j (x). Gibt es ein x j i, für das max K j (x) f(x) = 0 x j i gilt, so liegt K j (x \ x j i) vollständig in f(x) und überdeckt K j (x); hieraus folgt, dass K j (x) keine Primkonjunktion ist. Für die Arbeit im Monitor ist es etwas unangenehmer, dass nach diesem Kriterium jede Variable x j i der Konjunktion K j (x) separat überprüft werden muss. Eine Hilfe kann ein Problemprogramm pkon.prp sein, das davon ausgeht, dass f(x) auf 1, K j (x) auf 5 und x j i auf 6 bereitsteht. 10

11 pkon.prp: MAXK DIF OBB 8 8 OUT 8 Zur Analyse der Konjunktion benötigen Sie die einzelnen Variablen, die als Variablentupel mit VTIN 1 3 xi x2 x3 x4 x5 x6 x7 x8 x9 x10. eingegeben werden. Die Konjunktion K 2 enthält die Variablen (x 1,x 3,x 7,x 8,x 10), die mit dem Problemprogramm pkon.prp zu überprüfen sind. Eingabe: STV 2 2 5! K2 STV 3 1 6! X1 GO PKON Ausgabe: xl x2 x3 x4 x5 x6 x7 x8 x9 xl Da keine leere TVL entsteht, muss x 1 in der Konjunktion K 2 verbleiben. Eingabe: STV 3 3 6! X3 GO PKON Ausgabe: xl x2 x3 x4 x5 x6 x7 x8 x9 xl0. Das Ergebnis ist eine leere TVL. Nach dem Kriterium darf es aber keine solche Variable geben. Um eine Primkonjunktion aus K 2 zu konstruieren, setzen Sie die weitere Analyse ausgehend von der reduzierten Konjunktion K 2 fort. Eingabe: MAXK 5 6 5! K2 ohne X3 STV 3 7 6! X7 GO PKON Ausgabe: xl x2 x3 x4 x5 x6 x7 x8 x9 xl x 7 muss in der Konjunktion verbleiben. Weiter mit x 8! Eingabe: STV 3 8 6! x8 GO PKON Ausgabe: xl x2 x3 x4 x5 x6 x7 x8 x9 xl0. 000l Auch x 8 ist notwendig. Verbleibt noch x 10. Eingabe: STV ! x10 GO PKON Ausgabe: xl x2 x3 x4 x5 x6 x7 x8 x9 xl0. 11

12 _ Offensichtlich muss auch x 10 aus K 2 entfernt werden, um die Primkonjunktion PK 2 = x 1 x 7 x 8 zu erhalten. Eingabe: OUT 7 Ausgabe: xl x7 x Nach STV können Sie auf dem gleichen Weg auch die Konjunktion K 3 analysieren und werden feststellen, dass es sich bei dieser Konjunktion bereits um eine Primkonjunktion handelt. Damit wäre zunächst die Aufgabe gelöst. Welche Schlussfolgerungen können wir bezüglich der Eignung des XBOOLE-Monitors zum Problemlösen ziehen? Der unmittelbare Zugriff auf die XBOOLE-Operationen stellt einen großen Vorteil für die Analyse verschiedener Algorithmen dar. Aufgaben, die in der Variablenanzahl oberhalb der durch Handrechnung beherrschbaren liegen, bereiten keine Probleme. In zyklischen Abläufen müssen allerdings alle Schritte explizit einzeln ausgeführt werden. Das erfordert von Ihnen in größerem Umfang Routineaktionen, bei denen sich auch eine Fehlbedienung einschleichen kann oder das Akzeptieren einer erhöhten Rechenzeit durch die interpretative Arbeitsweise. Nehmen wir an, es wären anstelle von 3 Konjunktionen 100 Konjunktionen zu analysieren. In diesem Fall ist die Grenze der sinnvollen Anwendung des XBOOLE-Monitors überschritten. Ein kurzes C-Programm, in dem Sie unter Verwendung von XBOOLE-Operationen die gleichen Algorithmen implementieren, nimmt Ihnen die mühsame Steuerung des Ablaufs ab. Im Gegensatz zum XBOOLE-Monitor können Sie alle im XBOOLE-Kern verfügbaren Operationen, insbesondere auch die Testoperationen, zur Problemlösung verwenden. Ein weiterer Aspekt, der gegen den XBOOLE-Monitor spricht, besteht im verfügbaren Speicherplatz. Die Benutzeroberfläche und die Interpreter der Kommandos belegen beim XBOOLE- Monitor zusätzlich zum XBOOLE-Kern Speicherplatz, der im Grenzfall die Problemlösung verhindert. Der wesentliche Vorteil der Anwendung von XBOOLE-Funktionen in C-Programmen besteht aber darin, dass ein sehr breites Anwendungsfeld über den XBOOLE-Monitor hinaus erschlossen wird. Umfangreiche Werkzeuge für die Analyse /BoPo81, Bö77, KPS84, StFe89, StLe88/ und Synthese /BDS91, DLRB92, DRB91, St84, StLe88/ digitaler Schaltungen, zu ihrer Testdatenberechnung /Le89, Le91, StHi89, StLe90 1, Simulation /BoSt9l, St90, St89/ und Verifikation /BoSt91, St89/ oder auch zur Verarbeitung von Bildern, Graphen und Relationen /BoSt91, FPS82, Un92/ lassen sich effizient nur durch die Einbettung von XBOOLE in eine höhere Programmiersprache verwirklichen. 12

13 /* Create: pk tu chemnitz steinbach Update: xb_port mee steinbach XB_PORT_MODUL : pk Gegeben : t1 : Funktions-TVL t2 : Liste der Konjunktionen Gesucht : Funktion pk(t1, t2, pkl), die aus t2 "Nichtkonjunktionen" von t1 entfernt und die verbleibenden Konjunktionen zu Primkonjunktionen umformt. */ #include <stdio.h> #include "xbport.h" void pk (t1, t2, pkl) uns **t1, /* Funktions-TVL */ **t2, /* Liste der Konjunktionen */ **pkl; /* Primkonjunktionenliste */ { uns *konj, /* Konjunktion */ *konj_var, /* Konjunktion aller Variablen */ *konj_neu, /* neu gebildete Konjunktion */ *xi /* ausgewaehlte Variable */ i /* Index */ li; /* letzter Index */ konj = konj_var = konj_neu = xi = NULL; /* Initialisierung */ i = 1; while ( i <= NTV (t2) ) /* fuer alle Konjunktionen aus t2 */ { STV (t2, i, &konj); /* selektiere Konjunktion i */ if ( TE_DIF (&konj,t1) /* akzeptiere Konjunktion */ else DTV (t2,i,t2); /* loesche Nichtkonjunktion */ } EMPTY (t1,pkl); /* leere Primponjunktionenliste */ li = NTV (t2); /* Anzahl der Konjunktionen */ for (i=1; i <= ii; i++) /* fuer alle Konjunktionen aus t2 */ { STV (t2, i, &konj); /* selektiere Konjunktion i */ COPYOBJ (&konj, &konj_var); /* Variablen von Ki unveraendert */ while ( SV_NEXT(&konj_var,&xi,&xi) ) /* Variablenauswahl */ { MAXK (&konj,&xi,&konj_neu); /* erweitere Konjunktion */ if ( TE_DIF (&konj_neu,t1) ) /* neue Konjunktion zulaessig? */ COPYOBJ (&konj_neu,&konj); /* akzeptiere Konjunktion */ } CON (pkl,&konj,pkl); /* sammle Primkonjunktionen */ } DELOBJ (&konj); /* loesche angelegtes Objekt: konj */ DELOBJ (&konj_var); /* loesche angelegtes Objekt: konj_var */ DELOBJ (&konj_neu); /* loesche angelegtes Objekt: konj_neu */ return; } 13

14 main () { uns *tvl1, /* Funktions-TVL */ *tvl2, /* Konjunktionen */ *pkl; /* Primkonjunktionenliste */ tvl1 = tvl2 = pkl = NULL; /* Initialisierung */ LDS ("PK_DAT"); /* lade TVL-System PK_DAT.SDT */ GET_ML (1,&tvll); /* ordne erstes Objekt der tvl1 zu GET_ML (2,&tvl2); /* ordne zweites Objekt der tvl2 zu */ OUT_TVL (&tvl2); /* zeige Konjunktionenliste an */ pk (&tvl1,&tvl2,&pkl); /* Unterprogrammaufruf OUT_TVL (&tvl2); /* zeige zulaessige Konjunktionen an */ OUT_TVL (&pkl); /* zeige Primkonjunktionenliste an */ PUT_ML (3,&pkl); /* Primkonjunktionenliste -> Objekt 3 */ STS ("PK_ERG"); /* speichere TVL-System PK_ERG.SDT */ DELOBJ (&tvl1); /* loesche angelegtes Objekt: tvl1 */ DELOBJ (&tvl2); /* ]oesche angelegtes Objekt: tv12 */ DELOBJ (&pkl); /* loesche angelegtes Objekt: pkl */ return(0); } Der XB_PORT-MODUL pk übernimmt die ganze Arbeit. Die erforderlichen Primärdaten, d.h. die Funktions-TVL und die Liste der zu analysierenden Konjunktionen werden im Hauptprogramm main() mit der LDS-Operation (lad System) eingelesen und durch GET_ML den Variablen tvl1 und tvl2 zugeordnet. Die eingelesene Datei pk_dat.sdt wurde durch den STS-Befehl (store system) bei der Abarbeitung des Problemprogrammes mit dem XBOOLE-Monitor erzeugt. Zur Kontrolle wird vor dem Aufruf des Unterprogrammes pk die Liste der Konjunktionen mit OUT_TVL ausgegeben. Im Unterprogramm pk verbirgt sich unser erster Analysealgorithmus hinsichtlich der Konjunktionen in der TE_DIF-Operation, die als wichtiges Nebenprodukt den Entscheidungswert liefert. Nicht für f(x) verwertbare Konjunktionen werden mit DTV aus der Liste der Konjunktionen gestrichen. Die verbleibenden- Konjunktionen werden in der for-schleife in Primkonjunktionen umgewandelt und in der TVL pkl gesammelt. Nach dem im XBOOLE-Monitor erprobten Algorithmus wird dazu die MAXK-Operation in Verbindung mit einer weiteren TE_DIF-Operation verwendet. Wesentlich bequemer als im XBOOLE-Monitor wird die Auswahl der für die Maximum-Operation notwendigen Variablen unter Verwendung der SV_NEXT-Operation (vgl. Abschnitt 2.3) gesteuert. Das Unterprogramm pk stellt dem Hauptprogramm die um "Nichtkonjunktionen von f(x)" reduzierte tvl2 und die Liste der Primkonjunktionen pkl zur Verfügung. Im Hauptprogramm werden diese beiden TVL angezeigt und gemeinsam mit der Funktions-TVL als TVL-System pk_erg.sdt zur weiteren Bearbeitung, zum Beispiel mit dem - XBOOLE-Monitor ausgegeben. Wenn Sie dieses Programm mit einem verfügbaren C-Compiler übersetzen und zusammen mit der Bibliothek xb_portl.lib linken erhalten Sie das ausführbare Programm pk.exe. Nach dem Aufruf pk erscheinen sofort die folgenden drei TVL (gegebene Konjunktionen, Konjunktionen für f(x), Primkonjunktionen): 14

15 x xxxx xxxx xl ============ x xxxx xxxx xl ============ x xxxx xxxx xl ============ Die Stärken des XBOOLE-Monitors liegen auf der Seite algorithmischer Experimente und der Aufbereitung von Primärdaten. Für umfangreichere Nutzrechnungen eignet sich XBOOLE/XB_PORT in C-Programmen wesentlich besser. Diese beiden Varianten von XBOOLE ergänzen sich vorteilhaft. 15

16 2. Programmieren mit XBOOLE in C 2.1 Zeiger und XBOOLE-Daten Die Programmiersprache C ist bekannt als "Zeigersprache"*. XB_PORT nutzt dies mit äußerster Konsequenz zur Lösung der vielfältigen Verwaltungsaufgaben. XB_PORT speichert zusammengehörige Daten unterschiedlicher Größe als Objekte in einem Fachsystem. Die Objekte werden über Zeiger angesprochen. Das klare Verständnis der Arbeit mit diesen ist demzufolge eine entscheidende Voraussetzung für ein erfolgreiches Arbeiten mit XB_PORT. Da ein Grundwissen über den Typ Zeiger vorausgesetzt werden darf, sollen die folgenden Ausführungen nur kurz die in XB_PORT-Funktionen häufig verwendeten Konstruktionen umreißen. Im Header xb_port.h wird die Typdefinition typedef unsigned uns vorgenommen. Variablen, die sich auf den neuen Typ uns beziehen, haben somit einen maschinenabhängigen Wertebereich von 0,..., (16 Bit). Der Typ uns begegnet uns in fast allen Funktionsdeklarationen von XB_PORT, meist in der Form uns **variable. Wenn uns *variable bedeutet, dass variable einen Zeiger auf Werte vom Typ uns darstellt, so ist uns **variable als Zeiger auf einen Zeiger auf uns zu verstehen. Das klingt etwas verwirrend. Die folgenden Beispiele sollen ihnen helfen, mit XBOOLE-Objekten sicher umzugehen. Ternärvektorlisten (TVL) und Variablentupel (VT) sind die wichtigsten XBOOLE-Objekte. In Abhängigkeit von der Variablenanzahl können diese Objekte Speicherplatz benötigen, der in weiten Grenzen schwanken kann. Sie brauchen sich über die Reservierung des erforderlichen Speicherplatzes bei der Anwendung von- XBOOLE keine Gedanken zu machen. Die dynamische Speicherplatzverwaltung innerhalb eines Fachsystems von XBOOLE stellt jedem Objekt den erforderlichen Speicherplatz zur Verfügung, solange nicht die Grenze des nutzbaren Hauptspeichers überschritten wird. Die Konsequenz hiervon ist, dass in den C-Programmen auf die TVL und VT mit Zeigern verwiesen werden muss. * Für PC-Nutzer: Die XBOOLE-Bibliothek xb_portl.lib verlangt die Einstellung des Speichermodells LARGE. Dieses verwendet sogenannte Far-Zeiger, die eine vollständige Adresse (32 Bit) im Format Segment:Offset enthalten. Far-Zeiger erlauben die Arbeit mit mehreren Codesegmenten und liefern somit die Voraussetzung für Programme mit mehr als 64 kbyte Code sowie für die Verwaltung von mehr als 64 kbyte Daten. Vergewissern Sie sich bitte, ob Sie die richtige Einstellung ihres C-Compilers vorgenommen haben. 16

17 Nehmen wir an, die Boolesch Funktion f(x) =max k ( g (x) h(x) ) = 0 x 1 sei für die gegebenen Funktionen g(x) und h(x) sowie den Variablenvektor x 1 zu berechnen. f(x) nimmt für alle Vektoren x 0 den Wert Eins an, für die wenigstens ein Vektor x 1 existiert, mit dem auch ( g (x) h(x) ) den Wert Eins annimmt. Diese einfache Aufgabe könnten Sie natürlich auch mit einem XBOOLE- Monitor lösen. Hier soll sie uns zum Kennenlernen des Umgangs mit XBOOLE-Objekten in C dienen. Für die Konvertierung der gegebenen Funktionen bzw. Variablentupel in XBOOLE- Objekte bedienen wir uns der Einfachheit halber weiter eines XBOOLE-Monitors. Sie können mit einem Ihnen geläufigen Editor die Primärdaten im Rahmen der Syntax des XBOOLE-Monitors als Problemprogramm erfassen. Am Ende des Problemprogrammes veranlassen Sie durch ein STS- Kommando, dass die konvertierten Daten in ihr Arbeitsverzeichnis unter einem von Ihnen gewählten Namen gespeichert werden. Die dadurch angelegte Datei name.sdt beinhaltet dann alle Daten bereits in einer externen Kopie des XBOOLE-Fachsystems. Beispiel: mkgnh.prp space 16 tin 1 1! Funktion g(x) a1 start stop m00 m01 m10 m l sbe 1 2! Funktion h(x) ((m00+m10&m10)#(a1&start))&/m01&m11+ /a1&/stop. obb 2 2 vtin 1 5! Variablentupel xl m00 m01 m10 m11. sts mkgnh end Nach der Abarbeitung von mkgnh.prp mit einem XBOOLE-Monitor enthält die Datei mkgnh.sdt die TVL der Funktion g(x) als Objekt 1, die TVL der Funktion h(x) als Objekt 2 und das Variablentupel des Vektors x 1 als Objekt 5. Im C-Programm mkgnh.c können Sie nun sehr bequem auf diese Daten zugreifen. Sowohl im hauptspeicherinternen Fachsystem als auch in einer Datei name.sdt (hier mkgnh.sdt) sind alle Informationen eines Ternärmatrix (TM)- Sytems ausgehend von den drei Wurzelobjekten Variablenliste (VL), Raumliste (space list SL) und Speicherliste (memory list ML) erreichbar. Die Variablenliste enthält die Zeichenketten der Booleschen Variablen. In der Raumliste werden Zeiger auf die vom Anwender definierten Booleschen Räume, die selbst wieder XBOOLE-Objekte sind, verwaltet. Diese Raumdefinitionen (space definition SD) enthalten Angaben über die Anzahl der Maschinenworte je Ternärvektor, die vom Anwender festgelegte maximale Variablenanzahl und die Variablenzuordnung zu den TM- Spalten. In der Speicherliste sind schließlich die Zeiger auf alle anderen Objekte des TM-Systems (z.b. TVL oder VT) enthalten. Der Speicherlistenindex entspricht der vom XBOOLE-Monitor bekannten Objektnummer. 17

18 /* Create: mkgnh tu chemnitz steinbach Update: xb_port mee steinbach XB_PORT_MODUL : mkgnh */ #include <stdio.h> #include "xb.port.h" main () { uns *g, /* Funktions-TVL von g(x) */ *h, /* Funktions-TVL von h(x) */ *x1, /* Varablentupel x1 */ *f; /* Funktions-TVL von f(x) */ g = h = xl = f = NULL; /* Initialisierung */ LDS ("mkgnh"); /* lade TM-System mit g(x), h(x), x1 */ GET_ML (1,&g); /* ordne Zeigerwert von g(x) *g zu */ GET_ML (2,&h); /* ordne Zeigerwert von h(x) *h zu */ GET_NL (5,&x1); /* ordne Zeigerwert von xl *x1 zu */ OUT_TVL (&g); /* Kontrollausgabe von g(x) */ OUT_TVL (&h); /* Kontrollausgabe von h(x) */ OUT_VT (&x1); /* Kontrollausgabe von x1 */ DIF (&g,&h,&f); /* Berechnung von g(x) * /h(x) */ MAXK (&f,&x1,&f); /* Berechnung des k-fachen Maximums */ OUT_TVL(&f); /* Kontrollausgabe von f(x) */ PUT_ML (3,&f); /* trage Zeigerwert von f(x) in ML (Index 3) ein */ STS ("mkgnh_e"); /* speichere TM-System */ DELOBJ (&g); /* loesche Funktions-TVL von g(x) */ DELOBJ (&h); /* loesche Funktions-TVL von h(x) */ DELOBJ (&x1); /* loesche Variablentupel von x1 */ DELOBJ (&f); /* loesche Funktions-rVL von f(x) */ return; } Um in einem C-Programm mit XBOOLE-Operationen arbeiten zu können, muss mit einer #include - Präprozessoranweisung die Headerdatei xb_port.h eingefügt werden. Sie enthält die notwendigen Funktionsdeklarationen und Definitionen von Konstanten. Zum Lösen unserer Aufgabe benötigen wir die Funktions-TVL für g(x) und h(x) sowie das Variablentupel x 1. Um mit diesen Objekten operieren zu können, definieren wir die Zeiger *g, *h und *x1. Auch für die zu berechnende Funktions-TVL für f(x) wird in gleicher Weise ein Zeiger *f angelegt. Die Werte dieser Zeigervariablen sind zunächst unbestimmt. Den tatsächlichen Zeigerwert müssen Sie als "XBOOLE-C-Programmierer" nicht wissen. Mit einer Ausnahme vergibt das XBOOLE-System von sich aus die jeweils richtigen Zeigerwerte. Diese Ausnahme besteht in der expliziten Zuweisung des Zeigerwertes NULL, mit dem Sie zum Ausdruck bringen, dass der Zeigervariable noch kein XBOOLE-Objekt zugeordnet ist. Enthält eine Zeigervariable, die im Aufruf von XBOOLE verwendet wird, nicht den Wert NULL, so nehmen die XBOOLE-Operationen an, dass an dem angegebenen Speicherplatz das zugehörige XBOOLE- Objekt (TVL, VT,... ) existiert und versuchen dieses zu verarbeiten. Durch einen für alle XBOOLE- Objekte festgelegten konstanten Kode kontrolliert XBOOLE die Gültigkeit von Objektadressen. 18

19 Fehler, die sich aus unzulässigen Manipulationen mit XBOOLE-Zeigern ergeben, werden Ihnen durch Const.-Code Error als xb_error in Verbindung mit der gerade aufgerufenen Funktion angezeigt. Sie vermeiden diese Fehler, wenn Sie alle in einem Programm definierten "XBOOLE-Zeiger" vor ihrer Anwendung mit NULL initialisieren und danach alle Veränderungen der Zeigerwerte den XBOOLE- Operationen überlassen. Die benötigten Daten für g(x), h(x) und x 1 werden mit der LDS-Operation unter Angabe des im Problemprogramm bei STS angegebenen Namens eingelesen. Die Zeiger auf diese drei Objekte stehen nach dieser Operation in der Speicherliste (memory list - ML) unter den gleichen Indizes, die bei ihrer Definition im XBOOLE-Monitor als Objektnummer (1, 2, 5) verwendet wurden, zur Verfügung. Um frei mit den TVL für g(x) und h(x) und das Variablentupel x 1 arbeiten zu können, übertragen wir mit der GET_ML-Operation die realen Zeigerwerte auf unsere definierten Variablen. Achtung! Die Zeigerwerte sind jetzt an zwei Stellen gespeichert; auf *g, *h, *x1 und in der Speicherliste. Falls Sie die Objekte *g, *h, *x1 verändern kann dafür ein anderer Speicherplatz festgelegt werden. XBOOLE korrigiert aber nur den Zeigerwert, mit dem eine Funktion aufgerufen wurde. Beabsichtigen Sie solche XBOOLE-Operationen auszuführen, sollten Sie gleich nach dem Lesen des Zeigerwertes unter dem entsprechenden Index der Speicherliste ML mit PUT_ML NULL eintragen. Zur Lösung unserer Aufgabe bleiben g, h und x1 unverändert, sodass wir hierauf verzichten können. Beim Aufruf der GET_ML-Operationen wird Ihnen sicher auffallen, das nicht g sondern &g als Parameter angegeben ist. Die Übergabe eines Zeigers (&) auf einen Zeiger (g) ist durch die zwingende Wertübergabe der Programmiersprache C bedingt. Auf diese Weise kann die XBOOLE-Operation GET_ML den Wert auf dem Speicherplatz des g-zeigers ändern. Um Ihnen den Umgang mit XBOOLE zu erleichtern, hält sich XBOOLE streng daran, dass für XBOOLE- Objekte in allen Funktionsaufrufen Zeiger auf Zeiger angegeben werden. Vergleichen Sie, in allen Aufrufen von XBOOLE-Operationen steht vor g, h, x1 und f der Adress-Operator "&". In unserem ersten Test wollen wir uns nun davon überzeugen, dass die Funktions-TVL für g(x) und h(x) sowie das Variablentupel x 1 auch tatsächlich als Operanden zur Verfügung stehen. Mit OUT_TVL bzw. OUT_VT werden die angegebenen Objekte auf dem Standardausgabegerät angezeigt. Sie erhalten folgende Ausgabe: s ts atm mmm aro tp0 101 ========

20 s ts atm mmm aro tp0 101 ======== : m00 2 : m01 3 : m10 4 : m11 Für die eigentliche Berechnung werden nur zwei XBOOLE-Operationen benötigt. Die DIF- Operation berechnet: f(x) := g (x) h(x) und die MAXK-Operation bildet schließlich f(x) =max k f (x) x 1 Während die DIF-Operation mit drei verschiedenen Argumenten(&g,&h,&f)aufgerufen wird, tritt in der MAXK-Operation &f sowohl als Zeiger auf die zu verarbeitende als auch auf die Resultats-TVL auf. Solche Operationen, die Sie aus anderen Zuweisungen kennen (z.b. a :=a+b in C: a+=b; ) dürfen also auch mit XBOOLE-Objekten ausgeführt werden. Die XBOOLE-Operation trägt in solchen Fällen den neuen Zeiger für das Resultatsobjekt auf den angegebenen Argumentspeicherplatz ein und löscht implizit das nun nicht mehr erreichbare XBOOLE-Objekt. Für die Ergebnisausgabe bestehen mehrere Möglichkeiten. Die berechnete Funktions-TVL für f(x) kann direkt mit OUT_TVL ausgegeben werden. s ts at aro 1tp === Wird f(x) für weitere Berechnungen benötigt, so trägt man ihren Zeiger mit PUT_ML in die Speicherliste ein. Hier wurde als Index "3" gewählt. Die mit STS in das aktuelle Verzeichnis gespeicherte Datei mkgnh_e.sdt können Sie zum Beispiel in den XBOOLE-Monitor mit LDS laden. Dort steht Ihnen neben den Primärdaten jetzt unter der Objektnummer 3 die berechnete Funktion f(x) zur Verfügung. 20

21 Im Fachsystem bleiben die TVL und das VT unter den aktuellen Zeigerwerten gespeichert. In umfangreicheren XBOOLE-Programmen können Sie Speicherkonflikte reduzieren, wenn Sie am Ende jedes Teilprogrammes die nicht mehr benötigten XBOOLE-Objekte löschen. Wir empfehlen deshalb, konsequent an jedem Programmende die in dem Programm definierten und initialisierten XBOOLE-Objekte auch mit DELOBJ zu löschen, wobei DELOBJ den Argumentzeiger auf NULL zurücksetzt. Häufige Fehler: - Objektadresse für TVL und VT nicht NULL gesetzt - falscher Dateiname in LDS - kein Zeiger-auf-Zeiger-Argument in XBOOLE-Operation - wegen doppelter Speicherung eines Zeigerwertes und einer Veränderung nur an einer Stelle zeigt an der anderen Stelle der Zeiger nicht auf ein XBOOLE-Objekt - Löschen von nicht vorhandenen Objekten (Zeigerwert = NULL) mit DELOBJ - In Zweifelsfällen selektiv löschen: if (tvli) DELOBJ(&tvli); 21

22 2.2. Datenübergabe Gut strukturierte C-Programme bestehen aus mehreren Unterprogrammen (functions), die vom Hauptprogramm (main) aufgerufen werden. Für das Lösen umfangreicher Probleme mit XBOOLE ergibt sich hieraus der Vorteil, dass die von einem der Unterprogramme zu lösende Aufgabe separat unter Verwendung eines einfachen, als Testrahmen dienenden Hauptprogrammes implementiert werden kann. Da in C nur die Wertübergabe an Funktionen möglich ist, gibt es hinsichtlich der Übergabe von Zeigern auf XBOOLE-Objekte einige Besonderheiten zu berücksichtigen, die in diesem Abschnitt erläutert werden. Nehmen wir an, es wird ein Unterprogramm zur Transformation zwischen Funktions-TVL in ODA- FORM und OKE-FORM benötigt, das als Eingabe auch nichtorthogonal disjunktive bzw. konjunktive TVL zulassen soll. Der Lösungsalgorithmus für diese einfache Aufgabe ist bekannt: 1. Negation nach De Morgan, 2. Komplementbildung. Im Ergebnis der Komplementbildung mit CPL entstehen die gesuchten orthogonalen TVL auch mit nichtorthogonalen TVL in D_FORM oder K_FORM als Eingangsparameter. Die gesuchte Funktion nennen wir cf_dk und testen sie mit Hilfe von zwei Booleschen Funktionen, die wir als cf_dk.prp erfassen und mit einem XBOOLE-Monitor in cf_dk.sdt durch Abarbeitung dieses Problemprogrammes überführen. space 16 1 tin 1 1 /d a b c d tin 1 2 /k a b c d sts cf_dk end Im Hauptprogramm main werden in bekannter Weise (vgl. Abschnitt 2.1) die Zeiger *tvl1 und *tvl2 für diese beiden Funktionen definiert und initialisiert. Nacheinander sollen die Ergebnisse der dualen Funktionen über den Zeiger *res (Resultat) erreichbar sein. Da res erst innerhalb der Funktion cf_dk angelegt wird, darf die Initialisierung von res anstatt in main auch in der Funktion cf_dk vorgenommen werden. Wir empfehlen Ihnen aber, den Grundsätzen von XBOOLE zu folgen, und grundsätzlich nur initialisierte (Zuweisung von NULL) bzw. bereits mit konkreten Objektadressen belegte Zeiger an Unterprogramme zu übergeben. Für das Hauptprogramm bleibt damit das Programmierschema unverändert: 1. Definition von Zeigern (uns *name) für XBOOLE-Objekte, 2. Initialisieren der Zeiger (name = NULL) für XBOOLE-Objekte, 3. Aufruf von Funktionen mit Zeiger auf Zeiger (z.b. OUT_TVL(&name)), 4. Löschen angelegter XBOOLE-Objekte (DELOBJ(&name)). 22

23 /* Create: cf_dk tu chemnitz steinbach Update: xb_port mee steinbach XB_PORT_MODUL : cf_dk Gegeben : t1 : Funktions-TVL in disjunktiver oder konjunktiver Form Gesucht : Funktion cf_dk (t1, erg), die t1 in die jeweils duale orthogonale Form erg umwandelt. */ #include <stdio.h> #include "xb_port.h" void cf_dk (t1, erg) uns **t1, /* Funktions-TVL */ **erg; /* duale Funktions-TVL - Ergebnis */ { uns *h; /* Konjunktion */ h = NULL; /* Initialisierung */ NDM(tl,&h); /* Negation nach De Morgan */ CPL(&h,erg); /* Komplement */ OBB(erg,erg); /* orthogonale Blockbildung */ DELOBJ (&h); /* loesche angelegtes Objekt: konj */ return; } main() { uns *tvl1, /* Funktions-TVL1 */ *tv12, /* Resultat */ *res; /* Funktions-TVL2 */ tvl1 = tvl2 = res = NULL; /* Initialisierung */ LDS ("cfdk"); /* lade PVL-System PK_DAT.SDT */ GET_ML (1,&tvl1); /* ordne erstes Objekt der tvl1 zu */ GET_ML (2,&tv12); /* ordne zweites Objekt der tvl2 zu */ OUT_TVL (&tvll); /* zeige TVL 1 an */ cf_dk (&tvl1,&res); /* Unterprogrammaufruf */ OUT_TVL (&res); /* zeige duale Funktion an */ OUT_TVL (&tvl2); /* zeige TVL 2 an */ cf_dk (&tvl2,&res); /* Unterprogrammaufruf */ OUT_TVL (&res); /* zeige duale Funktion an */ DELOBJ (&tvl1); /* loesche angelegtes Objekt: tvl1 */ DELOBJ (&tvl2); /* loesche angelegtes Objekt: tvl2 */ DELOBJ (&res); /* loesche angelegtes Objekt: res */ } Welche Besonderheiten gibt es aber in Unterprogrammen mit XBOOLE-Operationen zu beachten? Beim ersten Betrachten der void-funktion cf_dk wird Ihnen sicher auffallen, dass die Übergabeparameter t1 und erg als Zeiger auf Zeiger vom Typ uns definiert sind (uns **t1 uns **erg) und dass vor diesen Variablen im Aufruf von XBOOLE-Operationen der gewohnte Adressoperator (&) fehlt. Das ist kein Versehen, sondern durch die verwendete Parameterübergabe bedingt. Doch schauen wir uns den Sachverhalt in Ruhe etwas genauer an. 23

24 Durch den Aufruf von cf_dk(&tvl1 &res); im Hauptprogramm werden an das Unterprogramm Zeiger auf Zeigervariable übergeben, die im Hauptprogramm definiert sind. Die Konsequenz daraus ist, dass die Unterprogrammvariablen ti und erg als Zeiger auf Zeiger vom Typ uns (uns **t1 **erg;) zu definieren sind. Hieraus ergibt sich ein wesentlicher Vorteil für die XBOOLE-Anwendung. Der Zeiger auf eine TVL steht nur an einer Stelle, und sowohl im Hauptprogramm als auch im Unterprogramm wird nur über diesen Zeiger auf die TVL zugegriffen. Im Allgemeinen muss man davon ausgehen, dass nach einer XBOOLE-Operation die Ergebnis-TVL an einer anderen Stelle im Speicher steht, als die TVL, auf die zuvor mit der Zeigervariable verwiesen wurde. Von der XBOOLE-Operation wird aber garantiert, dass der neue Zeigerwert der angegebenen Variable zugeordnet und die bisher über diese Variable erreichbare TVL implizit gelöscht wird. Würde man direkt einen Zeigerwert an ein Unterprogramm übergeben, so könnte der Fall eintreten, dass im Unterprogramm eine TVL implizit gelöscht wird, der Zeiger im Unterprogramm korrigiert wird, aber im Hauptprogramm unverändert bleibt und deshalb bei einem erneuten Zugriff auf die gewünschte TVL im Hauptprogramm ein Fehler auftritt. Die Ursache für den Fehler liegt darin, dass XBOOLE beim Aufruf einer Operation nur den Speicherplatz eines Zeigers auf ein Objekt kennt und diesen aktualisiert; Zeigerkopien können deshalb auf Stellen zeigen, an denen kein XBOOLE-Objekt mehr existiert. Alle XBOOLE-Objekte, die nur im Unterprogramm benötigt werden, sind im Unterprogramm in bekannter Weise zu definieren (uns *h;) und zu initialisieren (h=null;) und am Ende des Unterprogrammes zu löschen (DELOBJ(&h);). Innerhalb eines Unterprogrammes müssen nun die beiden Variablenarten konsequent unterschieden werden. Die Variablen ti und erg sind bereits mit einem konkreten TVL-Bezug versehen bzw. initialisiert und dürfen deshalb nicht noch einmal NULL gesetzt werden. Da es sich bei diesen Variablen (z.b. ti) um Zeiger auf Zeiger handelt, entfällt im Aufruf von XBOOLE-Operationen der Adressoperator (&) während die lokalen XBOOLE-Zeigervariablen (z.b. h) beim Aufruf von XBOOLE-Operationen durch den Adressoperator zu Zeiger auf Zeiger umzuwandeln sind (z.b. NDM(t1 &h);). Da der Zeiger der Ergebnis-TVL (res) im Hauptprogramm definiert ist und über erg genau dieser Speicherplatz adressiert wird, sind keine zusätzlichen Aktionen zur Rückübergabe von XBOOLE-Objektadressen an das Hauptprogramm notwendig. Für Unterprogramme ergibt sich somit folgendes Programmierschema: 1. Definieren der Parameter zur Übergabe von XBOOLE-Objekten als Zeiger auf Zeiger (uns **puname;), 2. Definieren von Zeigern auf lokale XBOOLE-Objekte (uns *lname;), 3. Initialisieren nur der lokalen Zeiger auf lokale XBOOLE-Objekte (name=null;), 4. Aufruf von Funktionen mit Zeiger auf Zeiger (z.b. ORTH (puname, &lname) ;)' wobei der Adressoperator "&" nur vor die lokalen Zeiger zu schreiben ist, 5. Löschen nur der lokal angelegten XBOOLE-Objekte (DELOBJ(&lname);). 24

25 Für unsere im Problemprogramm cf_dk.prp enthaltenen Funktionen erhält man bei Abarbeitung des C-Programmes cf_dk.c die Ausgabe: abcd ==== tvl1 in D FORM abcd ==== abcd ==== abcd ==== res gebildet aus tvll in 0KE_FORM tvl2 in K_FORM res gebildet aus tvl2 in ODA_FORM Häufige Fehler: - Mehrfachdefinition von XBOOLE-Zeigervariablen und Zugriffsversuch über nichtaktualisierte Zeiger - Initialisierung von externen Variablen im Unterprogramm, wodurch Primärdaten verlorengehen - Adressoperator (&) vor externen Zeigervariablen bei XBOOLE-Operationen im Unterprogramm (-> Compilerwarnung) - kein Adressoperator (&) vor lokalen Zeigervariablen bei XBOOLE-Operationen im Unterprogramm (-> Compilerwarnung) 25

26 2.3. Sequentieller Variablenzugriff Es gibt viele Aufgabenstellungen, die einen sequentiellen Zugriff auf alle Variablen einer TVL erfordern, wie zum Beispiel die Primkonjunktionenbildung im ersten Abschnitt. Die XBOOLE- Operation SV_NEXT kann hierzu sehr gute Dienste leisten, erfordert aber auch die genaue Kenntnis ihrer Eigenschaften. Zur Erläuterung soll hier folgende Aufgabe dienen: Aus einer Funktions-TVL sind alle Variablen zu entfernen, von denen die Funktions-TVL nicht tatsächlich abhängt. Die zu analysierende Funktions-TVL erzeugen wir durch Lösen einer Booleschen Gleichung mit einem XBOOLE-Monitor. space 16 avar a b c d e. sbell (b&/c&/d&/e#/a&/d#a&b&/c&/d&/e) +/a&b&/c&/d+a&c&d. sts unabh end Der Gleichungsausdruck des verwendeten Problemprogrammes unabh.prp enthält die Variablen a,b,c,d und e. Das Hauptprogramm main dient als Testrahmen für das Unterprogramm unabh und zeigt die gegebene Funktions-TVL sowie die daraus gebildete wertverlaufsgleiche vereinfachte Funktions-TVL an. In der Funktion unabh benötigen wir ein XBOOLE-Objekt, das jeweils die ausgewählte Variable repräsentiert. Dieses Objekt xi wird definiert, initialisiert, aber nicht explizit gelöscht. Warum das so ist, werden wir später feststellen. Da die Funktion unabh die gegebene TVL t1 unverändert lassen und die TVL erg erzeugen soll, kopieren wir zunächst t1 auf erg mit COPYOBJ. Damit haben wir eine günstige Ausgangssituation zur Lösung unserer Aufgabe, für die folgende theoretische Grundlage besteht: f(x) wenn: = 0, dann: f (x\x i ) := max f(x) x i x i Nacheinander müssen aus f(x) die einzelnen Variablen x i ausgewählt werden, und falls sich als Ableitungswert Null ergibt, darf die Variable x i mit einer MAXK- Operation aus f(x) entfernt werden. Die SV_NEXT-Operation arbeitet nach folgenden Regeln: 1. wird als zweiter Operand ein NULL-Zeiger übergeben, so entsteht als dritter Operand eine TVL, die die erste Variable (entsprechend der Raumordnung) des ersten Operanden enthält und der Funktionswert ist TRUE; 2. beschreibt der zweite Operand genau eine, aber nicht die letzte Variable aus dem ersten Operand, so wird dem letzten Operand die nach der Raumordnung folgende Variable aus dem ersten Operand zugeordnet und der Funktionswert ist TRUE; 26

27 3. beschreibt der zweite Operand die letzte Variable des ersten Operanden, wird der dritte Operand implizit gelöscht und der Funktionswert FALSE zurückgegeben. 4. wird als zweiter Operand nicht der NULL-Zeiger übergeben und beschreibt das zugehörige Objekt nicht genau eine Variable aus dem ersten Operand, so ist die Folgevariable nicht definiert, der Funktionswert ist FALSE und es entsteht ein XBOOLE- Error (SV_ERROR); Wird als zweiter und dritter Operand xi verwendet, so erzeugt SV_NEXT beim ersten Aufruf die erste Variable von t1 (Regel 1) und bei jedem weiteren Aufruf die jeweils folgende Variable von t1 (Regel 2) als TVL xi, verbunden mit dem Funktionswert TRUE. Wird die letzte Variable von t1 als zweiter Operand an SV_NEXT übergeben, so tritt die Regel 3 in Kraft; die TVL xi (3. Operand) wird implizit gelöscht und wegen des Funktionswertes FALSE wird die while-schleife abgebrochen. Damit erklärt sich, dass xi nicht explizit gelöscht werden darf. Unser Beispiel enthält noch eine weitere Fehlergefahr. Innerhalb der while-schleife wird nach erfolgreichem Test (TE DERK) mit der MAXK-Operation die Variable xi aus der TVL erg entfernt. Würde man erg anstelle von ti in SV_NEXT verwenden, so würde nach dem Entfernen einer Variable bei Aufruf von SV_NEXT die Regel 4 in Kraft treten und unerwünscht ein Fehler entstehen. Falls nicht wie in unserem Fall eine unveränderte TVL (t1) als "Variablenmuster" zur Verfügung steht, legt man eine solche TVL oder ein VT an. Das Programm pk.c aus dem Abschnitt 1 enthält hierzu eine Beispiellösung. Die Abarbeitung des Programms unabh.c liefert folgende Bildschirmausgabe: abcd e ====== acd === Es ist zu erkennen, dass die Variablen b und e nicht zur Darstellung der Funktion erforderlich sind. Häufige Fehler: - Variable des zweiten Operanden von SV_NEXT ist nicht im ersten Operanden enthalten - Zweiter Operand von SV_NEXT enthält mehr als eine Variable - Nichtbeachtung, dass SV_NEXT den dritten Operanden implizit löscht, wenn es keine weitere Variable gibt. 27

28 /* Create: unabh tu chemnitz steinbach Update: xb_port mee steinbach XB_PORT_MODUL : unabh Gegeben : t1 : Funktions-TVL Gesucht : Funktion unabh (t1, arg), die aus t1 alle Variablen entfernt, von denen t1 nicht abhaengt und die so reduzierte Funktions-TVL arg zurueck gibt. */ #include <stdio> #include "xb_port.h" void unabh (t1, arg) uns *t1, /* Funktions-TVL */ **arg; /* Ergebnis Funktions-TVL - nur abhaengige Variablen */ { uns *xi; /* ausgewaehlte Variable */ xi = NULL; /* Initialisierung */ COPYOBJ(t1,erg); /* kopiere t1 auf erg */ while ( SV_NEXT (t1,&xi,&xi) ) /* Variablenauswahl */ if (TE_DERK (erg,&xi) /* falls erg von xi unabhaengig */ MAXK (erg,&xi,erg); /* entferne xi aus arg */ OBB (erg,erg); } main () { uns *tvl1, /* Funktions-TVL */ *tvl2; /* Funktions-TVL unabhaengiger Variablen */ tvl1 = tvl2 = NULL; /* Initialisierung */ LDS ("unabh"); /* lade TVL-System UNABH.SDT */ GET_ML (1,&tvl1); /* ordne erstes Objekt der tvl1 zu */ OUT_TVL (&tvl1); /* zeige Funktions-TVL tvl1 an */ unabh (&tvll,&tvl2); /* Unterprogrammaufruf */ OUT_TVL (&tvl2); /* zeige Ergebnis an */ PUT_ML (2,&tvl2); /* Ergebnis-TVL -> Objekt 2 */ STS ("unabhe"); /* speichere TVL-System */ DELOBJ (&tvl1); /* loesche angelegtes Objekt: tvl1 */ DELOBJ (&tv12); /* loesche angelegtem Objekt: tv12 */ return(0); } 28

29 2.4. Explizite Ternärvektoranalyse Sehr viele Aufgaben können unmittelbar mit den von XBOOLE zur Verfügung gestellten Operationen gelöst werden. Darüber hinaus sind natürlich auch andere Manipulationen mit Ternärvektorlisten denkbar. Um diese zu ermöglichen, ihre Vielfalt nicht einzuschränken und die Anzahl der Operationen des XBOOLE-Kerns zu beschränken, wurden Operationen zum direkten Zugriff auf Ternärvektoren bereitgestellt. Die Operationen FIRST_ROW und NEXT_ROW erlauben einen schnellen Zugriff auf einzelne Ternärvektoren. Mit jedem Aufruf einer dieser Operationen wird genau ein Ternärvektor in einen anwenderverwalteten Puffer übertragen. Dieser Puffer muss groß genug sein, um einen vollständigen Ternärvektor aufnehmen zu können. Ein Ternärvektor belegt stets mehrere Maschinenworte. Der in der zugehörigen Raumdefinition festgelegte typ definiert die Anzahl von Maschinenworten, die zur Speicherung eines Ternärvektors benötigt werden. Es empfiehlt sich, im Hinblick auf eine effiziente Speicherauslastung den Puffer dynamisch zu vereinbaren. Betrachten wir die Anwendung der XBOOLE-Operationen FIRST_ROW und NEXT_ROW sowie die direkte Verarbeitung von Ternärvektoren an einem Beispiel. Es ist die Anzahl der Binärvektoren zu berechnen, die zu einer orthogonalen TVL gehören. Um den typischen Umgang mit XBOOLE zu demonstrieren, lässt das Programm beliebig lange Ternärvektoren zu. Die Anzahl der Binärvektoren kann zwischen Null und 2 n liegen, wenn n die Spaltenanzahl der TVL ist. Wir wollen hier zur Vereinfachung annehmen, dass der Datentyp unsigned genügt, um die Anzahl der Binärvektoren (number of binary vectors - nbv) darzustellen. Der Funktion nbv wird die zu analysierende TVL in bekannter Weise als uns **t1 übergeben; der Funktionswert sum von nbv soll die Anzahl der Binärvektoren der orthogonalen TVL t1 sein. Besitzt die TVL 1 Ternärvektoren, die jeweils s i Strichelemente enthalten, so ergibt sich l sum = 2 s i i=1 und für l = 0 gilt: sum = 0. Wir setzen deshalb diesen Anfangswert und führen den Hauptteil von nbv nur im Fall l > 0 aus. Ein Ternärvektor wird stets durch TYP Maschinenworte MW i gespeichert (vgl. Bild 2.1). A 1 B 1 A 2 B 2 A TYP/2 B TYP/2 MW 0 MW 1 MW 2 MW 3 MW TYP-2 MW TYP-1 Bild 2.1. Speicherstruktur eines Ternärvektors 29