ascend4/solver/logrel.c

/*
 *  Logical Relation Module
 *  by Vicente Rico-Ramirez
 *  Created: 09/96
 *  Version: $Revision: 1.8 $
 *  Version control file: $RCSfile: logrel.c,v $
 *  Date last modified: $Date: 1998/01/29 00:42:26 $
 *  Last modified by: $Author: ballan $
 *
 *  This file is part of the SLV solver.
 *
 *  The SLV solver is free software; you can redistribute
 *  it and/or modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of the
 *  License, or (at your option) any later version.
 *
 *  The SLV solver is distributed in hope that it will be
 *  useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with the program; if not, write to the Free Software Foundation,
 *  Inc., 675 Mass Ave, Cambridge, MA 02139 USA.  Check the file named
 *  COPYING.  COPYING is found in ../compiler.
 *
 */

#include <math.h>
#include "utilities/ascConfig.h"
#include "utilities/ascMalloc.h"
#include "utilities/mem.h"
#include "general/list.h"
#include "general/dstring.h"
#include "compiler/fractions.h"
#include "compiler/instance_enum.h"
#include "compiler/compiler.h"
#include "compiler/symtab.h"
#include "compiler/extfunc.h"
#include "compiler/extcall.h"
#include "compiler/functype.h"
#include "compiler/safe.h"
#include "compiler/dimen.h"
#include "compiler/types.h"
#include "compiler/find.h"
#include "compiler/atomvalue.h"
#include "compiler/instquery.h"
#include "compiler/mathinst.h"
#include "compiler/parentchild.h"
#include "compiler/instance_io.h"
#include "compiler/logical_relation.h"
#include "compiler/logrelation.h"
#include "compiler/logrel_util.h"
#include "compiler/packages.h"
#define _SLV_SERVER_C_SEEN_ /* for the extrel stuff in header */
#include "solver/mtx.h"
#include "solver/slv_types.h"
#include "solver/var.h"
#include "solver/rel.h"
#include "solver/discrete.h"
#include "solver/conditional.h"
#include "solver/logrel.h"
#include "solver/bnd.h"
#include "solver/slv_server.h"

#ifndef IPTR
#define IPTR(i) ((struct Instance *)(i))
#endif
#define LOGREL_DEBUG FALSE

/* define symchar names needed */
static symchar *g_strings[1];
#define INCLUDED_R g_strings[0]


static const struct logrel_relation g_logrel_defaults = {
   NULL,        /* instance */
   NULL,        /* incidence */
   0,           /* n_incidences */
   -1,          /* mindex */
   -1,          /* sindex */
   -1,          /* model index */
   (LOGREL_INCLUDED)    /* flags */
};

/*
 *  Don't forget to update the
 *  initialization when the structure
 *  is modified.
 */


static struct logrel_relation
*logrel_copy(const struct logrel_relation *logrel)
{
   struct logrel_relation *newlogrel;
   newlogrel = (struct logrel_relation *)
                               ascmalloc( sizeof(struct logrel_relation) );
   *newlogrel = *logrel;
   return(newlogrel);
}


struct logrel_relation *logrel_create(SlvBackendToken instance,
                      struct logrel_relation *newlogrel)
{
  if (newlogrel==NULL) {
    newlogrel = logrel_copy(&g_logrel_defaults); /* malloc the logrelation */
  } else {
    *newlogrel = g_logrel_defaults; /* init the space we've been sent */
  }
  assert(newlogrel!=NULL);
  newlogrel->instance = instance;
  return(newlogrel);
}


SlvBackendToken logrel_instance(struct logrel_relation *logrel)
{
  if (logrel==NULL) return NULL;
  return (SlvBackendToken) logrel->instance;
}

void logrel_write_name(slv_system_t sys,struct logrel_relation *logrel,
               FILE *fp)
{
  if (logrel == NULL || fp==NULL) return;
  if (sys!=NULL) {
    WriteInstanceName(fp,logrel_instance(logrel),slv_instance(sys));
  } else {
    WriteInstanceName(fp,logrel_instance(logrel),NULL);
  }
}


void logrel_destroy(struct logrel_relation *logrel)
{
   struct Instance *inst;

   ascfree((POINTER)logrel->incidence);
   inst = IPTR(logrel->instance);
   if (inst) {
     if (GetInterfacePtr(inst)==logrel) {
       SetInterfacePtr(inst,NULL);
     }
   }
   ascfree((POINTER)logrel);
}


uint32 logrel_flags( struct logrel_relation *logrel)
{
  return logrel->flags;
}

void logrel_set_flags(struct logrel_relation *logrel, unsigned int flags)
{
  logrel->flags = flags;
}


uint32 logrel_flagbit(struct logrel_relation *logrel, uint32 one)
{
  if (logrel==NULL || logrel->instance == NULL) {
    FPRINTF(stderr,"ERROR: logrel_flagbit called with bad logrel.\n");
    return 0;
  }
  return (logrel->flags & one);
}


void logrel_set_flagbit(struct logrel_relation *logrel, uint32 field,
            uint32 one)
{
  if (one) {
    logrel->flags |= field;
  } else {
    logrel->flags &= ~field;
  }
}


boolean logrel_not_equal(struct logrel_relation *logrel)
{
  switch( LogRelRelop(GetInstanceLogRelOnly(IPTR(logrel->instance))) ) {
  case e_boolean_neq:
    return(TRUE);
  default:
    return(FALSE);
  }
}


boolean logrel_equal( struct logrel_relation *logrel)
{
  switch( LogRelRelop(GetInstanceLogRelOnly(IPTR(logrel->instance))) ) {
  case e_boolean_eq:
    return(TRUE);
  default:
    return(FALSE);
  }
}


static enum logrel_enum compenum2logrelenum(enum Expr_enum t)
{
  switch (t) {
  case e_boolean_eq:
    return e_logrel_equal;
  case e_boolean_neq:
    return e_logrel_not_equal;
  default:
    FPRINTF(ASCERR,"ERROR (logrel.c): compenum2logrelenum miscalled.\n");
    return e_logrel_equal;
  }
}


enum logrel_enum logrel_relop( struct logrel_relation *logrel)
{
  return
    compenum2logrelenum(LogRelRelop(
        GetInstanceLogRelOnly(IPTR(logrel->instance))));
}


char *logrel_make_name(slv_system_t sys,struct logrel_relation *logrel)
{
  return WriteInstanceNameString(IPTR(logrel->instance),
                 IPTR(slv_instance(sys)));
}


int32 logrel_mindex( struct logrel_relation *logrel)
{
   return( logrel->mindex );
}


void logrel_set_mindex( struct logrel_relation *logrel, int32 index)
{
   logrel->mindex = index;
}


int32 logrel_sindex( struct logrel_relation *logrel)
{
   return( logrel->sindex );
}

void logrel_set_sindex( struct logrel_relation *logrel, int32 index)
{
   logrel->sindex = index;
}


int32 logrel_model(const struct logrel_relation *logrel)
{
   return((const int32) logrel->model );
}


void logrel_set_model( struct logrel_relation *logrel, int32 index)
{
   logrel->model = index;
}


int32 logrel_residual(struct logrel_relation *logrel)
{
   return( LogRelResidual(GetInstanceLogRelOnly(IPTR(logrel->instance))));
}


void logrel_set_residual( struct logrel_relation *logrel, int32 residual)
{
  struct logrelation *logreln;
  logreln = (struct logrelation *)
            GetInstanceLogRelOnly(IPTR(logrel->instance));
  SetLogRelResidual(logreln,residual);
}


int32 logrel_nominal( struct logrel_relation *logrel)
{
  return( LogRelNominal(GetInstanceLogRelOnly(IPTR(logrel->instance))));
}


int32 logrel_n_incidencesF(struct logrel_relation *logrel)
{
  if (logrel!=NULL) return logrel->n_incidences;
  FPRINTF(stderr,"logrel_n_incidences miscalled with NULL\n");
  return 0;
}


void logrel_set_incidencesF(struct logrel_relation *logrel,int n,
                            struct dis_discrete **bv)
{
  if(logrel!=NULL && n >=0) {
    if (n && bv==NULL) {
      FPRINTF(stderr,"logrel_set_incidence miscalled with NULL list\n");
    }
    logrel->n_incidences = n;
    logrel->incidence = bv;
    return;
  }
  FPRINTF(stderr,"logrel_set_incidence miscalled with NULL or n < 0\n");
}


const struct dis_discrete
**logrel_incidence_list( struct logrel_relation *logrel)
{
  if (logrel==NULL) return NULL;
  return( (const struct dis_discrete **)logrel->incidence );
}


struct dis_discrete
**logrel_incidence_list_to_modify( struct logrel_relation *logrel)
{
  if (logrel==NULL) return NULL;
  return( (struct dis_discrete **)logrel->incidence );
}


int logrel_apply_filter( struct logrel_relation *logrel,
             logrel_filter_t *filter)
{
  if (logrel==NULL || filter==NULL) {
    FPRINTF(stderr,"logrel_apply_filter miscalled with NULL\n");
    return FALSE;
  }
  /* AND to mask off irrelevant bits in flags and match value,
     then compare */
  return ( (filter->matchbits & logrel->flags) ==
           (filter->matchbits & filter->matchvalue) );
}

/* to bad there's no entry point that rel must call before being used
 * generally, like the FindType checking stuff in var.c
 */
static void check_included_flag(void){
  if (INCLUDED_R == NULL || AscFindSymbol(INCLUDED_R) == NULL) {
    INCLUDED_R = AddSymbolL("included",8);
  }
}

uint32 logrel_included( struct logrel_relation *logrel)
{
   struct Instance *c;
   check_included_flag();
   c = ChildByChar(IPTR(logrel->instance),INCLUDED_R);
   if( c == NULL ) {
      FPRINTF(stderr,"ERROR:  (logrel) logrel_included\n");
      FPRINTF(stderr,"        No 'included' field in logrelation.\n");
      WriteInstance(stderr,IPTR(logrel->instance));
      return FALSE;
   }
   logrel_set_flagbit(logrel,LOGREL_INCLUDED,GetBooleanAtomValue(c));
   return( GetBooleanAtomValue(c) );
}


void logrel_set_included( struct logrel_relation *logrel, uint32 included)
{
   struct Instance *c;
   check_included_flag();
   c = ChildByChar(IPTR(logrel->instance),INCLUDED_R);
   if( c == NULL ) {
      FPRINTF(stderr,"ERROR:  (logrel) logrel_set_included\n");
      FPRINTF(stderr,"        No 'included' field in logrelation.\n");
      WriteInstance(stderr,IPTR(logrel->instance));
      return;
   }
   SetBooleanAtomValue(c,included,(unsigned)0);
   logrel_set_flagbit(logrel,LOGREL_INCLUDED,included);
}
1	/*
2	* Logical Relation Module
3	* by Vicente Rico-Ramirez
4	* Created: 09/96
5	* Version: $Revision: 1.8 $
6	* Version control file: $RCSfile: logrel.c,v $
7	* Date last modified: $Date: 1998/01/29 00:42:26 $
8	* Last modified by: $Author: ballan $
9	*
10	* This file is part of the SLV solver.
11	*
12	* The SLV solver is free software; you can redistribute
13	* it and/or modify it under the terms of the GNU General Public License as
14	* published by the Free Software Foundation; either version 2 of the
15	* License, or (at your option) any later version.
16	*
17	* The SLV solver is distributed in hope that it will be
18	* useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with the program; if not, write to the Free Software Foundation,
24	* Inc., 675 Mass Ave, Cambridge, MA 02139 USA. Check the file named
25	* COPYING. COPYING is found in ../compiler.
26	*
27	*/
28
29	#include <math.h>
30	#include "utilities/ascConfig.h"
31	#include "utilities/ascMalloc.h"
32	#include "utilities/mem.h"
33	#include "general/list.h"
34	#include "general/dstring.h"
35	#include "compiler/fractions.h"
36	#include "compiler/instance_enum.h"
37	#include "compiler/compiler.h"
38	#include "compiler/symtab.h"
39	#include "compiler/extfunc.h"
40	#include "compiler/extcall.h"
41	#include "compiler/functype.h"
42	#include "compiler/safe.h"
43	#include "compiler/dimen.h"
44	#include "compiler/types.h"
45	#include "compiler/find.h"
46	#include "compiler/atomvalue.h"
47	#include "compiler/instquery.h"
48	#include "compiler/mathinst.h"
49	#include "compiler/parentchild.h"
50	#include "compiler/instance_io.h"
51	#include "compiler/logical_relation.h"
52	#include "compiler/logrelation.h"
53	#include "compiler/logrel_util.h"
54	#include "compiler/packages.h"
55	#define _SLV_SERVER_C_SEEN_ /* for the extrel stuff in header */
56	#include "solver/mtx.h"
57	#include "solver/slv_types.h"
58	#include "solver/var.h"
59	#include "solver/rel.h"
60	#include "solver/discrete.h"
61	#include "solver/conditional.h"
62	#include "solver/logrel.h"
63	#include "solver/bnd.h"
64	#include "solver/slv_server.h"
65
66	#ifndef IPTR
67	#define IPTR(i) ((struct Instance *)(i))
68	#endif
69	#define LOGREL_DEBUG FALSE
70
71	/* define symchar names needed */
72	static symchar *g_strings[1];
73	#define INCLUDED_R g_strings[0]
74
75
76	static const struct logrel_relation g_logrel_defaults = {
77	NULL, /* instance */
78	NULL, /* incidence */
79	0, /* n_incidences */
80	-1, /* mindex */
81	-1, /* sindex */
82	-1, /* model index */
83	(LOGREL_INCLUDED) /* flags */
84	};
85
86	/*
87	* Don't forget to update the
88	* initialization when the structure
89	* is modified.
90	*/
91
92
93	static struct logrel_relation
94	logrel_copy(const struct logrel_relation logrel)
95	{
96	struct logrel_relation *newlogrel;
97	newlogrel = (struct logrel_relation *)
98	ascmalloc( sizeof(struct logrel_relation) );
99	newlogrel = logrel;
100	return(newlogrel);
101	}
102
103
104	struct logrel_relation *logrel_create(SlvBackendToken instance,
105	struct logrel_relation *newlogrel)
106	{
107	if (newlogrel==NULL) {
108	newlogrel = logrel_copy(&g_logrel_defaults); /* malloc the logrelation */
109	} else {
110	newlogrel = g_logrel_defaults; / init the space we've been sent */
111	}
112	assert(newlogrel!=NULL);
113	newlogrel->instance = instance;
114	return(newlogrel);
115	}
116
117
118
119	SlvBackendToken logrel_instance(struct logrel_relation *logrel)
120	{
121	if (logrel==NULL) return NULL;
122	return (SlvBackendToken) logrel->instance;
123	}
124
125	void logrel_write_name(slv_system_t sys,struct logrel_relation *logrel,
126	FILE *fp)
127	{
128	if (logrel == NULL \|\| fp==NULL) return;
129	if (sys!=NULL) {
130	WriteInstanceName(fp,logrel_instance(logrel),slv_instance(sys));
131	} else {
132	WriteInstanceName(fp,logrel_instance(logrel),NULL);
133	}
134	}
135
136
137	void logrel_destroy(struct logrel_relation *logrel)
138	{
139	struct Instance *inst;
140
141	ascfree((POINTER)logrel->incidence);
142	inst = IPTR(logrel->instance);
143	if (inst) {
144	if (GetInterfacePtr(inst)==logrel) {
145	SetInterfacePtr(inst,NULL);
146	}
147	}
148	ascfree((POINTER)logrel);
149	}
150
151
152	uint32 logrel_flags( struct logrel_relation *logrel)
153	{
154	return logrel->flags;
155	}
156
157	void logrel_set_flags(struct logrel_relation *logrel, unsigned int flags)
158	{
159	logrel->flags = flags;
160	}
161
162
163	uint32 logrel_flagbit(struct logrel_relation *logrel, uint32 one)
164	{
165	if (logrel==NULL \|\| logrel->instance == NULL) {
166	FPRINTF(stderr,"ERROR: logrel_flagbit called with bad logrel.\n");
167	return 0;
168	}
169	return (logrel->flags & one);
170	}
171
172
173	void logrel_set_flagbit(struct logrel_relation *logrel, uint32 field,
174	uint32 one)
175	{
176	if (one) {
177	logrel->flags \|= field;
178	} else {
179	logrel->flags &= ~field;
180	}
181	}
182
183
184	boolean logrel_not_equal(struct logrel_relation *logrel)
185	{
186	switch( LogRelRelop(GetInstanceLogRelOnly(IPTR(logrel->instance))) ) {
187	case e_boolean_neq:
188	return(TRUE);
189	default:
190	return(FALSE);
191	}
192	}
193
194
195	boolean logrel_equal( struct logrel_relation *logrel)
196	{
197	switch( LogRelRelop(GetInstanceLogRelOnly(IPTR(logrel->instance))) ) {
198	case e_boolean_eq:
199	return(TRUE);
200	default:
201	return(FALSE);
202	}
203	}
204
205
206	static enum logrel_enum compenum2logrelenum(enum Expr_enum t)
207	{
208	switch (t) {
209	case e_boolean_eq:
210	return e_logrel_equal;
211	case e_boolean_neq:
212	return e_logrel_not_equal;
213	default:
214	FPRINTF(ASCERR,"ERROR (logrel.c): compenum2logrelenum miscalled.\n");
215	return e_logrel_equal;
216	}
217	}
218
219
220	enum logrel_enum logrel_relop( struct logrel_relation *logrel)
221	{
222	return
223	compenum2logrelenum(LogRelRelop(
224	GetInstanceLogRelOnly(IPTR(logrel->instance))));
225	}
226
227
228	char logrel_make_name(slv_system_t sys,struct logrel_relation logrel)
229	{
230	return WriteInstanceNameString(IPTR(logrel->instance),
231	IPTR(slv_instance(sys)));
232	}
233
234
235	int32 logrel_mindex( struct logrel_relation *logrel)
236	{
237	return( logrel->mindex );
238	}
239
240
241	void logrel_set_mindex( struct logrel_relation *logrel, int32 index)
242	{
243	logrel->mindex = index;
244	}
245
246
247	int32 logrel_sindex( struct logrel_relation *logrel)
248	{
249	return( logrel->sindex );
250	}
251
252	void logrel_set_sindex( struct logrel_relation *logrel, int32 index)
253	{
254	logrel->sindex = index;
255	}
256
257
258	int32 logrel_model(const struct logrel_relation *logrel)
259	{
260	return((const int32) logrel->model );
261	}
262
263
264	void logrel_set_model( struct logrel_relation *logrel, int32 index)
265	{
266	logrel->model = index;
267	}
268
269
270	int32 logrel_residual(struct logrel_relation *logrel)
271	{
272	return( LogRelResidual(GetInstanceLogRelOnly(IPTR(logrel->instance))));
273	}
274
275
276	void logrel_set_residual( struct logrel_relation *logrel, int32 residual)
277	{
278	struct logrelation *logreln;
279	logreln = (struct logrelation *)
280	GetInstanceLogRelOnly(IPTR(logrel->instance));
281	SetLogRelResidual(logreln,residual);
282	}
283
284
285
286	int32 logrel_nominal( struct logrel_relation *logrel)
287	{
288	return( LogRelNominal(GetInstanceLogRelOnly(IPTR(logrel->instance))));
289	}
290
291
292	int32 logrel_n_incidencesF(struct logrel_relation *logrel)
293	{
294	if (logrel!=NULL) return logrel->n_incidences;
295	FPRINTF(stderr,"logrel_n_incidences miscalled with NULL\n");
296	return 0;
297	}
298
299
300	void logrel_set_incidencesF(struct logrel_relation *logrel,int n,
301	struct dis_discrete **bv)
302	{
303	if(logrel!=NULL && n >=0) {
304	if (n && bv==NULL) {
305	FPRINTF(stderr,"logrel_set_incidence miscalled with NULL list\n");
306	}
307	logrel->n_incidences = n;
308	logrel->incidence = bv;
309	return;
310	}
311	FPRINTF(stderr,"logrel_set_incidence miscalled with NULL or n < 0\n");
312	}
313
314
315	const struct dis_discrete
316	*logrel_incidence_list( struct logrel_relation logrel)
317	{
318	if (logrel==NULL) return NULL;
319	return( (const struct dis_discrete **)logrel->incidence );
320	}
321
322
323	struct dis_discrete
324	*logrel_incidence_list_to_modify( struct logrel_relation logrel)
325	{
326	if (logrel==NULL) return NULL;
327	return( (struct dis_discrete **)logrel->incidence );
328	}
329
330
331	int logrel_apply_filter( struct logrel_relation *logrel,
332	logrel_filter_t *filter)
333	{
334	if (logrel==NULL \|\| filter==NULL) {
335	FPRINTF(stderr,"logrel_apply_filter miscalled with NULL\n");
336	return FALSE;
337	}
338	/* AND to mask off irrelevant bits in flags and match value,
339	then compare */
340	return ( (filter->matchbits & logrel->flags) ==
341	(filter->matchbits & filter->matchvalue) );
342	}
343
344	/* to bad there's no entry point that rel must call before being used
345	* generally, like the FindType checking stuff in var.c
346	*/
347	static void check_included_flag(void){
348	if (INCLUDED_R == NULL \|\| AscFindSymbol(INCLUDED_R) == NULL) {
349	INCLUDED_R = AddSymbolL("included",8);
350	}
351	}
352
353	uint32 logrel_included( struct logrel_relation *logrel)
354	{
355	struct Instance *c;
356	check_included_flag();
357	c = ChildByChar(IPTR(logrel->instance),INCLUDED_R);
358	if( c == NULL ) {
359	FPRINTF(stderr,"ERROR: (logrel) logrel_included\n");
360	FPRINTF(stderr," No 'included' field in logrelation.\n");
361	WriteInstance(stderr,IPTR(logrel->instance));
362	return FALSE;
363	}
364	logrel_set_flagbit(logrel,LOGREL_INCLUDED,GetBooleanAtomValue(c));
365	return( GetBooleanAtomValue(c) );
366	}
367
368
369	void logrel_set_included( struct logrel_relation *logrel, uint32 included)
370	{
371	struct Instance *c;
372	check_included_flag();
373	c = ChildByChar(IPTR(logrel->instance),INCLUDED_R);
374	if( c == NULL ) {
375	FPRINTF(stderr,"ERROR: (logrel) logrel_set_included\n");
376	FPRINTF(stderr," No 'included' field in logrelation.\n");
377	WriteInstance(stderr,IPTR(logrel->instance));
378	return;
379	}
380	SetBooleanAtomValue(c,included,(unsigned)0);
381	logrel_set_flagbit(logrel,LOGREL_INCLUDED,included);
382	}