ascend4/solver/var.c

/*
 *  SLV: Ascend Numeric Solver
 *  by Karl Michael Westerberg
 *  Created: 2/6/90
 *  Version: $Revision: 1.31 $
 *  Version control file: $RCSfile: var.c,v $
 *  Date last modified: $Date: 1998/02/19 13:31:36 $
 *  Last modified by: $Author: mthomas $
 *
 *  This file is part of the SLV solver.
 *
 *  Copyright (C) 1990 Karl Michael Westerberg
 *  Copyright (C) 1993 Joseph Zaher
 *  Copyright (C) 1994 Joseph Zaher, Benjamin Andrew Allan
 *
 *  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 "utilities/ascConfig.h"
#include "utilities/ascMalloc.h"
#include "general/dstring.h"
#include "general/list.h"
#include "compiler/compiler.h"
#include "compiler/symtab.h"
#include "compiler/instance_enum.h"
#include "compiler/fractions.h"
#include "compiler/module.h"
#include "compiler/library.h"
#include "compiler/dimen.h"
#include "compiler/child.h"
#include "compiler/type_desc.h"
#include "compiler/atomvalue.h"
#include "compiler/parentchild.h"
#include "compiler/instquery.h"
#include "compiler/instance_io.h"
#include "solver/mtx.h"
#include "solver/slv_types.h"
#include "solver/rel.h"
#include "solver/var.h"
#include "solver/discrete.h"
#include "solver/conditional.h"
#include "solver/logrel.h"
#include "solver/bnd.h"
#include "solver/slv_server.h"
#include "solver/slv_common.h"
#include "solver/linsol.h"
#include "solver/linsolqr.h"
#include "solver/slv_client.h"

/* useful cast */
#define IPTR(i) ((struct Instance *)(i))

/* useful symbol table things to know */
#define FIXED_V g_strings[0]
#define LOWER_V g_strings[1]
#define UPPER_V g_strings[2]
#define RELAXED_V g_strings[3]
#define NOMINAL_V g_strings[4]
#define INTERFACE_V g_strings[5]

/*
 * array of those symbol table entries we need.
 */
static symchar * g_strings[6];

SlvBackendToken var_instanceF(const struct var_variable *var)
{ if (var==NULL || var->ratom==NULL) {
    FPRINTF(stderr,"var_instance called on bad var\n");
    return NULL;
  }
  return var->ratom;
}

void var_set_instanceF(struct var_variable *var, SlvBackendToken i)
{
  if (var==NULL)  {
    FPRINTF(stderr,"var_set_instance called on NULL var\n");
    return;
  }
  var->ratom = i;
}


char *var_make_name(const slv_system_t sys,const  struct var_variable *var)
{
  return WriteInstanceNameString(IPTR(var->ratom),IPTR(slv_instance(sys)));
}

char *var_make_xname(const struct var_variable *var)
{
   static char name[81];
   char *res;
   sprintf(name,"x%d",var_sindex(var));
   res=(char *)ascmalloc((strlen(name)+1)*sizeof(char));
   sprintf(res,"%s",name);
   return res;
}

void var_write_name(const slv_system_t sys,
  const struct var_variable *var,FILE *fp)
{
  if (var == NULL || fp==NULL) return;
  if (sys!=NULL) {
    WriteInstanceName(fp,var_instance(var),slv_instance(sys));
  } else {
    WriteInstanceName(fp,var_instance(var),NULL);
  }
}

void var_destroy(struct var_variable *var)
{
  if (var==NULL) return;
  var->ratom = NULL;
  ascfree((POINTER)var->incidence);
}


int32 var_mindexF(const struct var_variable *var)
{
  if (var==NULL || var->ratom==NULL) {
    FPRINTF(stderr,"var_set_mindex called on bad var\n");
    return -1;
  }
  return var->mindex;
}

void var_set_mindexF(struct var_variable *var, int32 index)
{
  if (var==NULL || var->ratom==NULL) {
    FPRINTF(stderr,"var_set_mindex called on bad var\n");
    return;
  }
  var->mindex = index;
}

int32 var_sindexF(const struct var_variable *var)
{
  if (var==NULL || var->ratom==NULL) {
    FPRINTF(stderr,"var_set_sindex called on bad var\n");
    return -1;
  }
  return var->sindex;
}

void var_set_sindexF(struct var_variable *var, int32 index)
{
  if (var==NULL || var->ratom==NULL) {
    FPRINTF(stderr,"var_set_sindex called on bad var\n");
    return;
  }
  var->sindex = index;
}

real64 var_value(const struct var_variable *var)
{
  if (var==NULL || var->ratom==NULL) {
    FPRINTF(stderr,"var_value called on bad var\n");
    return 0.0;
  }
  return( RealAtomValue(var->ratom) );
}

void var_set_value(struct var_variable *var, real64 value)
{
  if (var==NULL || var->ratom==NULL) {
    FPRINTF(stderr,"var_set_value called on bad var\n");
    return;
  }
  SetRealAtomValue(var->ratom,value,(unsigned)0);
}

real64 var_nominal(struct var_variable *var)
{
  struct Instance *c;
  if (var==NULL || var->ratom==NULL) {
    FPRINTF(stderr,"var_nominal called on bad var\n");
    return 1.0;
  }
  c = ChildByChar(var->ratom,NOMINAL_V);
  if( c == NULL ) {
    FPRINTF(stderr,"ERROR:  (var) var_nominal\n");
    FPRINTF(stderr,"        No 'nominal' field in variable.\n");
    WriteInstance(stderr,IPTR(var->ratom));
    return 1.0;
  }
  return( RealAtomValue(c) );
}

void var_set_nominal(struct var_variable *var, real64 nominal)
{
  struct Instance *c;
  if (var==NULL || var->ratom==NULL) {
    FPRINTF(stderr,"var_set_nominal called on bad var\n");
    return;
  }
  c = ChildByChar(IPTR(var->ratom),NOMINAL_V);
  if( c == NULL ) {
    FPRINTF(stderr,"ERROR:  (var) var_set_nominal\n");
    FPRINTF(stderr,"        No 'nominal' field in variable.\n");
    WriteInstance(stderr,IPTR(var->ratom));
    return;
  }
  SetRealAtomValue(c,nominal,(unsigned)0);
}


real64 var_lower_bound(struct var_variable *var)
{
  struct Instance *c;
  if (var==NULL || var->ratom==NULL) {
    FPRINTF(stderr,"var_lower_bound called on bad var\n");
    return 0.0;
  }
  c = ChildByChar(IPTR(var->ratom),LOWER_V);
  if( c == NULL ) {
    FPRINTF(stderr,"ERROR:  (var) var_lower_bound\n");
    FPRINTF(stderr,"        No 'lower_bound' field in variable.\n");
    WriteInstance(stderr,IPTR(var->ratom));
    return 0.0;
  }
  return( RealAtomValue(c) );
}

void var_set_lower_bound(struct var_variable *var, real64 lower_bound)
{
  struct Instance *c;
  if (var==NULL || var->ratom==NULL) {
    FPRINTF(stderr,"var_set_lower_bound called on bad var\n");
    return;
  }
  c = ChildByChar(IPTR(var->ratom),LOWER_V);
  if( c == NULL ) {
    FPRINTF(stderr,"ERROR:  (var) var_set_lower_bound\n");
    FPRINTF(stderr,"        No 'lower_bound' field in variable.\n");
    WriteInstance(stderr,IPTR(var->ratom));
    return;
  }
  SetRealAtomValue(c,lower_bound,(unsigned)0);
}


real64 var_upper_bound(struct var_variable *var)
{
  struct Instance *c;
  if (var==NULL || var->ratom==NULL) {
    FPRINTF(stderr,"var_upper_bound called on bad var\n");
    return 0.0;
  }
  c = ChildByChar(IPTR(var->ratom),UPPER_V);
  if( c == NULL ) {
    FPRINTF(stderr,"ERROR:  (var) var_upper_bound\n");
    FPRINTF(stderr,"        No 'upper_bound' field in variable.\n");
    WriteInstance(stderr,IPTR(var->ratom));
    return 0.0;
  }
  return( RealAtomValue(c) );
}

void var_set_upper_bound(var,upper_bound)
struct var_variable *var;
real64 upper_bound;
{
  struct Instance *c;
  if (var==NULL || var->ratom==NULL) {
    FPRINTF(stderr,"var_set_upper_bound called on bad var\n");
    return;
  }
  c = ChildByChar(IPTR(var->ratom),UPPER_V);
  if( c == NULL ) {
    FPRINTF(stderr,"ERROR:  (var) var_set_upper_bound\n");
    FPRINTF(stderr,"        No 'upper_bound' field in variable.\n");
    WriteInstance(stderr,IPTR(var->ratom));
    return;
  }
  SetRealAtomValue(c,upper_bound,(unsigned)0);
}

uint32 var_flagsF(const struct var_variable *var)
{
  return var->flags;
}

void var_set_flagsF(struct var_variable *var, uint32 flags)
{
  var->flags = flags;
}

uint32 var_fixed(struct var_variable *var)
{
  struct Instance *c;
  if (var==NULL || var->ratom==NULL) {
    FPRINTF(stderr,"var_fixed called on bad var\n");
    return FALSE;
  }
  c = ChildByChar(IPTR(var->ratom),FIXED_V);
  if( c == NULL ) {
    FPRINTF(stderr,"ERROR:  (var) var_fixed\n");
    FPRINTF(stderr,"        No 'fixed' field in variable.\n");
    WriteInstance(stderr,IPTR(var->ratom));
    return FALSE;
  }
  var_set_flagbit(var,VAR_FIXED,GetBooleanAtomValue(c));
  return( GetBooleanAtomValue(c) );
}

void var_set_fixed(struct var_variable *var, uint32 fixed)
{
  struct Instance *c;
  if (var==NULL || var->ratom==NULL) {
    FPRINTF(stderr,"var_set_fixed called on bad var\n");
    return;
  }
  c = ChildByChar(IPTR(var->ratom),FIXED_V);
  if( c == NULL ) {
    FPRINTF(stderr,"ERROR:  (var) var_set_fixed\n");
    FPRINTF(stderr,"        No 'fixed' field in variable.\n");
    WriteInstance(stderr,IPTR(var->ratom));
    return;
  }
  SetBooleanAtomValue(c,fixed,(unsigned)0);
  var_set_flagbit(var,VAR_FIXED,fixed);
}

uint32 var_relaxed(struct var_variable *var)
{
  struct Instance *c;
  if (var==NULL || var->ratom==NULL) {
    FPRINTF(stderr,"var_relaxed called on bad var\n");
    return FALSE;
  }
  c = ChildByChar((var->ratom),RELAXED_V);
  if( c == NULL ) {
    FPRINTF(stderr,"ERROR:  (var) var_relaxed\n");
    FPRINTF(stderr,"        No 'relaxed' field in variable.\n");
    WriteInstance(stderr,(var->ratom));
    return FALSE;
  }
  var_set_flagbit(var,VAR_RELAXED,GetBooleanAtomValue(c));
  return( GetBooleanAtomValue(c) );
}

void var_set_relaxed(struct var_variable *var, uint32 fixed)
{
  struct Instance *c;
  if (var==NULL || var->ratom==NULL) {
    FPRINTF(stderr,"var_set_relaxed called on bad var\n");
    return;
  }
  c = ChildByChar(IPTR(var->ratom),RELAXED_V);
  if( c == NULL ) {
    FPRINTF(stderr,"ERROR:  (var) var_set_relaxed\n");
    FPRINTF(stderr,"        No 'relaxed' field in variable.\n");
    WriteInstance(stderr,IPTR(var->ratom));
    return;
  }
  SetBooleanAtomValue(c,fixed,(unsigned)0);
  var_set_flagbit(var,VAR_RELAXED,fixed);
}

uint32 var_interface(struct var_variable *var)
{
  struct Instance *c;
  if (var==NULL || var->ratom==NULL) {
    FPRINTF(stderr,"var_interface called on bad var\n");
    return FALSE;
  }
  c = ChildByChar(IPTR(var->ratom),INTERFACE_V);
  if( c == NULL ) {
    FPRINTF(stderr,"ERROR:  (var) var_interface\n");
    FPRINTF(stderr,"        No 'interface' field in variable.\n");
    WriteInstance(stderr,IPTR(var->ratom));
    return 0;
  }
  var_set_flagbit(var,VAR_INTERFACE,GetBooleanAtomValue(c));
  return( GetIntegerAtomValue(c) );
}

extern uint32 var_flagbit(const struct var_variable *var,const uint32 one)
{
  if (var==NULL || var->ratom == NULL) {
    FPRINTF(stderr,"ERROR: var_flagbit called with bad var.\n");
    return 0;
  }
  return (var->flags & one);
}

void var_set_flagbit(struct var_variable *var, uint32 field,uint32 one)
{
  if (var==NULL || var->ratom == NULL) {
    FPRINTF(stderr,"ERROR: var_set_flagbit called with bad var.\n");
    return;
  }
  if (one) {
    var->flags |= field;
  } else {
    var->flags &= ~field;
  }
}

int32 var_apply_filter(const struct var_variable *var,
  const var_filter_t *filter)
{
  if (var==NULL || filter==NULL || var->ratom == NULL) {
    FPRINTF(stderr,"var_apply_filter miscalled with NULL\n");
    return FALSE;
  }
  /* AND to mask off irrelevant bits in flags and match value, then compare */
  return ( (filter->matchbits & var->flags) ==
           (filter->matchbits & filter->matchvalue)
         );
}


int32 var_n_incidencesF(struct var_variable *var)
{
  if (var!=NULL) return var->n_incidences;
  FPRINTF(stderr,"var_n_incidences miscalled with NULL\n");
  return 0;
}
void var_set_incidencesF(struct var_variable *var,int32 n,
                         struct rel_relation **i)
{
  if(var!=NULL && n >=0) {
    if (n && i==NULL) {
      FPRINTF(stderr,"var_set_incidence miscalled with NULL ilist\n");
    }
    var->n_incidences = n;
    var->incidence = i;
    return;
  }
  FPRINTF(stderr,"var_set_incidence miscalled with NULL or n < 0\n");
}
const struct rel_relation **var_incidence_list( struct var_variable *var)
{
  if (var==NULL) return NULL;
  return( (const struct rel_relation **)var->incidence );
}

struct rel_relation **var_incidence_list_to_modify( struct var_variable *var)
{
  if (var==NULL) return NULL;
  return( (struct rel_relation **)var->incidence );
}


/* 
 * global for use with the push function. Sets the ip to the
 * value in g_var_tag;
 * should be using vp instead of a global counter.
 */
static void *g_var_tag = NULL;
static void * SetVarTags(struct Instance *i,VOIDPTR vp)
{
  (void)vp;
  if (i!=NULL && InstanceKind(i)==REAL_ATOM_INST) {
    return g_var_tag;
  } else {
    return NULL;
  }
}

struct var_variable **var_BackendTokens_to_vars(slv_system_t sys,
  SlvBackendToken *atoms, int32 len)
{
  int32 i,vartot,vlen,count=0;
  uint32 apos,ulen;
  struct var_variable **result;
  struct var_variable **vlist;
  struct gl_list_t *oldips;
  if (sys==NULL || atoms == NULL || len < 1) {
    return NULL;
  }
  ulen = (uint32)len;
  result = (struct var_variable **)malloc(len*sizeof(struct var_variable *));
  if (result == NULL) return result;
  /* init results to null */
  for (i=0; i<len; i++) result[i] = NULL;
  /* fill ips w/len in all the vars in tree. */
  g_var_tag = (void *)len;
  vartot = slv_get_num_master_vars(sys) +
           slv_get_num_master_pars(sys) +
           slv_get_num_master_unattached(sys);
  oldips = PushInterfacePtrs(slv_instance(sys),SetVarTags,vartot,0,NULL);
  /* fill ips of wanted atoms with i */
  for (i=0; i<len; i++) {
    if (GetInterfacePtr(atoms[i])==g_var_tag &&
    InstanceKind(atoms[i]) == REAL_ATOM_INST) {
    /* guard a little */
      SetInterfacePtr((struct Instance *)atoms[i],(void *)i);
    } else {
      /* the odds of g_var_tag being a legal pointer are vanishingly
    small, so if we find an ATOM without g_var_tag we assume it
    is outside the tree and shouldn't have been in the list. */
      FPRINTF(stderr,"var_BackendTokens_to_vars called with bad token.\n");
    }
  }
  /* run through the master lists and put the vars with their atoms */
  vlist = slv_get_master_var_list(sys);
  vlen = slv_get_num_master_vars(sys);
  for (i = 0; i <vlen; i++) {
    apos = (uint32)GetInterfacePtr(var_instance(vlist[i]));
    if ( apos < ulen ) {
      result[apos] = vlist[i];
      count++;
    }
  }
  vlist = slv_get_master_par_list(sys);
  vlen = slv_get_num_master_pars(sys);
  for (i = 0; i <vlen; i++) {
    apos = (uint32)GetInterfacePtr(var_instance(vlist[i]));
    if ( apos < ulen ) {
      result[apos] = vlist[i];
      count++;
    }
  }
  vlist = slv_get_master_unattached_list(sys);
  vlen = slv_get_num_master_unattached(sys);
  for (i = 0; i <vlen; i++) {
    apos = (uint32)GetInterfacePtr(var_instance(vlist[i]));
    if ( apos < ulen ) {
      result[apos] = vlist[i];
      count++;
    }
  }
  if (count < len) {
    FPRINTF(stderr,
           "var_BackendTokens_to_vars found less than expected vars\n");
    FPRINTF(stderr,"len = %d, vars found = %d\n",len,count);
  } else {
    FPRINTF(stderr,
           "var_BackendTokens_to_vars found more than expected vars\n");
    FPRINTF(stderr,"len = %d, vars found = %d\n",len,count);
  }
  PopInterfacePtrs(oldips,NULL,NULL);
  return result;
}

static struct TypeDescription *g_solver_var_type;
static struct TypeDescription *g_solver_int_type;
static struct TypeDescription *g_solver_binary_type;
static struct TypeDescription *g_solver_semi_type;

boolean set_solver_types(void) {
  boolean nerr = 0;
  if( (g_solver_var_type = FindType(AddSymbol(SOLVER_VAR_STR))) == NULL ) {
    FPRINTF(stderr,"ERROR:  (var.c) set_solver_types\n");
    FPRINTF(stderr,"        Type solver_var not defined.\n");
    FPRINTF(stderr,"        Solvers will not work.\n");
    nerr++;
  }
  if( (g_solver_int_type = FindType(AddSymbol(SOLVER_INT_STR))) == NULL ) {
    FPRINTF(stderr,"ERROR:  (var.c) set_solver_types\n");
    FPRINTF(stderr,"        Type solver_int not defined.\n");
    FPRINTF(stderr,"        MPS will not work.\n");
    nerr++;
  }
  g_solver_binary_type = FindType(AddSymbol(SOLVER_BINARY_STR));
  if( g_solver_binary_type == NULL) {
    FPRINTF(stderr,"ERROR:  (var.c) set_solver_types\n");
    FPRINTF(stderr,"        Type solver_binary not defined.\n");
    FPRINTF(stderr,"        MPS will not work.\n");
    nerr++;
  }
  if( (g_solver_semi_type = FindType(AddSymbol(SOLVER_SEMI_STR))) == NULL ) {
    FPRINTF(stderr,"ERROR:  (var.c) set_solver_types\n");
    FPRINTF(stderr,"        Type solver_semi not defined.\n");
    FPRINTF(stderr,"        MPS will not work.\n");
    nerr++;
  }

  LOWER_V = AddSymbolL("lower_bound",11);
  UPPER_V = AddSymbolL("upper_bound",11);
  RELAXED_V = AddSymbolL("relaxed",7);
  NOMINAL_V = AddSymbolL("nominal",7);
  FIXED_V = AddSymbolL("fixed",5);
  INTERFACE_V = AddSymbolL("interface",9);
 
  return nerr;
}

boolean solver_var( SlvBackendToken inst)
{
  struct TypeDescription *type;

  if (!g_solver_var_type) return FALSE;
  type = InstanceTypeDesc(IPTR(inst));
  return( type == MoreRefined(type,g_solver_var_type) );
}

boolean solver_int( SlvBackendToken inst)
{
  struct TypeDescription *type;

  if (!g_solver_int_type) return FALSE;
  type = InstanceTypeDesc(IPTR(inst));
  return( type == MoreRefined(type,g_solver_int_type) );
}

boolean solver_binary( SlvBackendToken inst)
{
  struct TypeDescription *type;

  if (!g_solver_binary_type) return FALSE;
  type = InstanceTypeDesc(IPTR(inst));
  return( type == MoreRefined(type,g_solver_binary_type) );
}

boolean solver_semi( SlvBackendToken inst)
{
  struct TypeDescription *type;

  if (!g_solver_semi_type) return FALSE;
  type = InstanceTypeDesc(IPTR(inst));
  return( type == MoreRefined(type,g_solver_semi_type) );
}

1	aw0a	1	/*
2			* SLV: Ascend Numeric Solver
3			* by Karl Michael Westerberg
4			* Created: 2/6/90
5			* Version: $Revision: 1.31 $
6			* Version control file: $RCSfile: var.c,v $
7			* Date last modified: $Date: 1998/02/19 13:31:36 $
8			* Last modified by: $Author: mthomas $
9			*
10			* This file is part of the SLV solver.
11			*
12			* Copyright (C) 1990 Karl Michael Westerberg
13			* Copyright (C) 1993 Joseph Zaher
14			* Copyright (C) 1994 Joseph Zaher, Benjamin Andrew Allan
15			*
16			* The SLV solver is free software; you can redistribute
17			* it and/or modify it under the terms of the GNU General Public License as
18			* published by the Free Software Foundation; either version 2 of the
19			* License, or (at your option) any later version.
20			*
21			* The SLV solver is distributed in hope that it will be
22			* useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
23			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24			* General Public License for more details.
25			*
26			* You should have received a copy of the GNU General Public License
27			* along with the program; if not, write to the Free Software Foundation,
28			* Inc., 675 Mass Ave, Cambridge, MA 02139 USA. Check the file named
29			* COPYING. COPYING is found in ../compiler.
30			*
31			*/
32
33			#include "utilities/ascConfig.h"
34			#include "utilities/ascMalloc.h"
35			#include "general/dstring.h"
36			#include "general/list.h"
37			#include "compiler/compiler.h"
38			#include "compiler/symtab.h"
39			#include "compiler/instance_enum.h"
40			#include "compiler/fractions.h"
41			#include "compiler/module.h"
42			#include "compiler/library.h"
43			#include "compiler/dimen.h"
44			#include "compiler/child.h"
45			#include "compiler/type_desc.h"
46			#include "compiler/atomvalue.h"
47			#include "compiler/parentchild.h"
48			#include "compiler/instquery.h"
49			#include "compiler/instance_io.h"
50			#include "solver/mtx.h"
51			#include "solver/slv_types.h"
52			#include "solver/rel.h"
53			#include "solver/var.h"
54			#include "solver/discrete.h"
55			#include "solver/conditional.h"
56			#include "solver/logrel.h"
57			#include "solver/bnd.h"
58			#include "solver/slv_server.h"
59			#include "solver/slv_common.h"
60			#include "solver/linsol.h"
61			#include "solver/linsolqr.h"
62			#include "solver/slv_client.h"
63
64			/* useful cast */
65			#define IPTR(i) ((struct Instance *)(i))
66
67			/* useful symbol table things to know */
68			#define FIXED_V g_strings[0]
69			#define LOWER_V g_strings[1]
70			#define UPPER_V g_strings[2]
71			#define RELAXED_V g_strings[3]
72			#define NOMINAL_V g_strings[4]
73			#define INTERFACE_V g_strings[5]
74
75			/*
76			* array of those symbol table entries we need.
77			*/
78			static symchar * g_strings[6];
79
80			SlvBackendToken var_instanceF(const struct var_variable *var)
81			{ if (var==NULL \|\| var->ratom==NULL) {
82			FPRINTF(stderr,"var_instance called on bad var\n");
83			return NULL;
84			}
85			return var->ratom;
86			}
87
88			void var_set_instanceF(struct var_variable *var, SlvBackendToken i)
89			{
90			if (var==NULL) {
91			FPRINTF(stderr,"var_set_instance called on NULL var\n");
92			return;
93			}
94			var->ratom = i;
95			}
96
97
98			char var_make_name(const slv_system_t sys,const struct var_variable var)
99			{
100			return WriteInstanceNameString(IPTR(var->ratom),IPTR(slv_instance(sys)));
101			}
102
103			char var_make_xname(const struct var_variable var)
104			{
105			static char name[81];
106			char *res;
107			sprintf(name,"x%d",var_sindex(var));
108			res=(char )ascmalloc((strlen(name)+1)sizeof(char));
109			sprintf(res,"%s",name);
110			return res;
111			}
112
113			void var_write_name(const slv_system_t sys,
114			const struct var_variable var,FILE fp)
115			{
116			if (var == NULL \|\| fp==NULL) return;
117			if (sys!=NULL) {
118			WriteInstanceName(fp,var_instance(var),slv_instance(sys));
119			} else {
120			WriteInstanceName(fp,var_instance(var),NULL);
121			}
122			}
123
124			void var_destroy(struct var_variable *var)
125			{
126			if (var==NULL) return;
127			var->ratom = NULL;
128			ascfree((POINTER)var->incidence);
129			}
130
131
132			int32 var_mindexF(const struct var_variable *var)
133			{
134			if (var==NULL \|\| var->ratom==NULL) {
135			FPRINTF(stderr,"var_set_mindex called on bad var\n");
136			return -1;
137			}
138			return var->mindex;
139			}
140
141			void var_set_mindexF(struct var_variable *var, int32 index)
142			{
143			if (var==NULL \|\| var->ratom==NULL) {
144			FPRINTF(stderr,"var_set_mindex called on bad var\n");
145			return;
146			}
147			var->mindex = index;
148			}
149
150			int32 var_sindexF(const struct var_variable *var)
151			{
152			if (var==NULL \|\| var->ratom==NULL) {
153			FPRINTF(stderr,"var_set_sindex called on bad var\n");
154			return -1;
155			}
156			return var->sindex;
157			}
158
159			void var_set_sindexF(struct var_variable *var, int32 index)
160			{
161			if (var==NULL \|\| var->ratom==NULL) {
162			FPRINTF(stderr,"var_set_sindex called on bad var\n");
163			return;
164			}
165			var->sindex = index;
166			}
167
168			real64 var_value(const struct var_variable *var)
169			{
170			if (var==NULL \|\| var->ratom==NULL) {
171			FPRINTF(stderr,"var_value called on bad var\n");
172			return 0.0;
173			}
174			return( RealAtomValue(var->ratom) );
175			}
176
177			void var_set_value(struct var_variable *var, real64 value)
178			{
179			if (var==NULL \|\| var->ratom==NULL) {
180			FPRINTF(stderr,"var_set_value called on bad var\n");
181			return;
182			}
183			SetRealAtomValue(var->ratom,value,(unsigned)0);
184			}
185
186			real64 var_nominal(struct var_variable *var)
187			{
188			struct Instance *c;
189			if (var==NULL \|\| var->ratom==NULL) {
190			FPRINTF(stderr,"var_nominal called on bad var\n");
191			return 1.0;
192			}
193			c = ChildByChar(var->ratom,NOMINAL_V);
194			if( c == NULL ) {
195			FPRINTF(stderr,"ERROR: (var) var_nominal\n");
196			FPRINTF(stderr," No 'nominal' field in variable.\n");
197			WriteInstance(stderr,IPTR(var->ratom));
198			return 1.0;
199			}
200			return( RealAtomValue(c) );
201			}
202
203			void var_set_nominal(struct var_variable *var, real64 nominal)
204			{
205			struct Instance *c;
206			if (var==NULL \|\| var->ratom==NULL) {
207			FPRINTF(stderr,"var_set_nominal called on bad var\n");
208			return;
209			}
210			c = ChildByChar(IPTR(var->ratom),NOMINAL_V);
211			if( c == NULL ) {
212			FPRINTF(stderr,"ERROR: (var) var_set_nominal\n");
213			FPRINTF(stderr," No 'nominal' field in variable.\n");
214			WriteInstance(stderr,IPTR(var->ratom));
215			return;
216			}
217			SetRealAtomValue(c,nominal,(unsigned)0);
218			}
219
220
221			real64 var_lower_bound(struct var_variable *var)
222			{
223			struct Instance *c;
224			if (var==NULL \|\| var->ratom==NULL) {
225			FPRINTF(stderr,"var_lower_bound called on bad var\n");
226			return 0.0;
227			}
228			c = ChildByChar(IPTR(var->ratom),LOWER_V);
229			if( c == NULL ) {
230			FPRINTF(stderr,"ERROR: (var) var_lower_bound\n");
231			FPRINTF(stderr," No 'lower_bound' field in variable.\n");
232			WriteInstance(stderr,IPTR(var->ratom));
233			return 0.0;
234			}
235			return( RealAtomValue(c) );
236			}
237
238			void var_set_lower_bound(struct var_variable *var, real64 lower_bound)
239			{
240			struct Instance *c;
241			if (var==NULL \|\| var->ratom==NULL) {
242			FPRINTF(stderr,"var_set_lower_bound called on bad var\n");
243			return;
244			}
245			c = ChildByChar(IPTR(var->ratom),LOWER_V);
246			if( c == NULL ) {
247			FPRINTF(stderr,"ERROR: (var) var_set_lower_bound\n");
248			FPRINTF(stderr," No 'lower_bound' field in variable.\n");
249			WriteInstance(stderr,IPTR(var->ratom));
250			return;
251			}
252			SetRealAtomValue(c,lower_bound,(unsigned)0);
253			}
254
255
256			real64 var_upper_bound(struct var_variable *var)
257			{
258			struct Instance *c;
259			if (var==NULL \|\| var->ratom==NULL) {
260			FPRINTF(stderr,"var_upper_bound called on bad var\n");
261			return 0.0;
262			}
263			c = ChildByChar(IPTR(var->ratom),UPPER_V);
264			if( c == NULL ) {
265			FPRINTF(stderr,"ERROR: (var) var_upper_bound\n");
266			FPRINTF(stderr," No 'upper_bound' field in variable.\n");
267			WriteInstance(stderr,IPTR(var->ratom));
268			return 0.0;
269			}
270			return( RealAtomValue(c) );
271			}
272
273			void var_set_upper_bound(var,upper_bound)
274			struct var_variable *var;
275			real64 upper_bound;
276			{
277			struct Instance *c;
278			if (var==NULL \|\| var->ratom==NULL) {
279			FPRINTF(stderr,"var_set_upper_bound called on bad var\n");
280			return;
281			}
282			c = ChildByChar(IPTR(var->ratom),UPPER_V);
283			if( c == NULL ) {
284			FPRINTF(stderr,"ERROR: (var) var_set_upper_bound\n");
285			FPRINTF(stderr," No 'upper_bound' field in variable.\n");
286			WriteInstance(stderr,IPTR(var->ratom));
287			return;
288			}
289			SetRealAtomValue(c,upper_bound,(unsigned)0);
290			}
291
292			uint32 var_flagsF(const struct var_variable *var)
293			{
294			return var->flags;
295			}
296
297			void var_set_flagsF(struct var_variable *var, uint32 flags)
298			{
299			var->flags = flags;
300			}
301
302			uint32 var_fixed(struct var_variable *var)
303			{
304			struct Instance *c;
305			if (var==NULL \|\| var->ratom==NULL) {
306			FPRINTF(stderr,"var_fixed called on bad var\n");
307			return FALSE;
308			}
309			c = ChildByChar(IPTR(var->ratom),FIXED_V);
310			if( c == NULL ) {
311			FPRINTF(stderr,"ERROR: (var) var_fixed\n");
312			FPRINTF(stderr," No 'fixed' field in variable.\n");
313			WriteInstance(stderr,IPTR(var->ratom));
314			return FALSE;
315			}
316			var_set_flagbit(var,VAR_FIXED,GetBooleanAtomValue(c));
317			return( GetBooleanAtomValue(c) );
318			}
319
320			void var_set_fixed(struct var_variable *var, uint32 fixed)
321			{
322			struct Instance *c;
323			if (var==NULL \|\| var->ratom==NULL) {
324			FPRINTF(stderr,"var_set_fixed called on bad var\n");
325			return;
326			}
327			c = ChildByChar(IPTR(var->ratom),FIXED_V);
328			if( c == NULL ) {
329			FPRINTF(stderr,"ERROR: (var) var_set_fixed\n");
330			FPRINTF(stderr," No 'fixed' field in variable.\n");
331			WriteInstance(stderr,IPTR(var->ratom));
332			return;
333			}
334			SetBooleanAtomValue(c,fixed,(unsigned)0);
335			var_set_flagbit(var,VAR_FIXED,fixed);
336			}
337
338			uint32 var_relaxed(struct var_variable *var)
339			{
340			struct Instance *c;
341			if (var==NULL \|\| var->ratom==NULL) {
342			FPRINTF(stderr,"var_relaxed called on bad var\n");
343			return FALSE;
344			}
345			c = ChildByChar((var->ratom),RELAXED_V);
346			if( c == NULL ) {
347			FPRINTF(stderr,"ERROR: (var) var_relaxed\n");
348			FPRINTF(stderr," No 'relaxed' field in variable.\n");
349			WriteInstance(stderr,(var->ratom));
350			return FALSE;
351			}
352			var_set_flagbit(var,VAR_RELAXED,GetBooleanAtomValue(c));
353			return( GetBooleanAtomValue(c) );
354			}
355
356			void var_set_relaxed(struct var_variable *var, uint32 fixed)
357			{
358			struct Instance *c;
359			if (var==NULL \|\| var->ratom==NULL) {
360			FPRINTF(stderr,"var_set_relaxed called on bad var\n");
361			return;
362			}
363			c = ChildByChar(IPTR(var->ratom),RELAXED_V);
364			if( c == NULL ) {
365			FPRINTF(stderr,"ERROR: (var) var_set_relaxed\n");
366			FPRINTF(stderr," No 'relaxed' field in variable.\n");
367			WriteInstance(stderr,IPTR(var->ratom));
368			return;
369			}
370			SetBooleanAtomValue(c,fixed,(unsigned)0);
371			var_set_flagbit(var,VAR_RELAXED,fixed);
372			}
373
374			uint32 var_interface(struct var_variable *var)
375			{
376			struct Instance *c;
377			if (var==NULL \|\| var->ratom==NULL) {
378			FPRINTF(stderr,"var_interface called on bad var\n");
379			return FALSE;
380			}
381			c = ChildByChar(IPTR(var->ratom),INTERFACE_V);
382			if( c == NULL ) {
383			FPRINTF(stderr,"ERROR: (var) var_interface\n");
384			FPRINTF(stderr," No 'interface' field in variable.\n");
385			WriteInstance(stderr,IPTR(var->ratom));
386			return 0;
387			}
388			var_set_flagbit(var,VAR_INTERFACE,GetBooleanAtomValue(c));
389			return( GetIntegerAtomValue(c) );
390			}
391
392			extern uint32 var_flagbit(const struct var_variable *var,const uint32 one)
393			{
394			if (var==NULL \|\| var->ratom == NULL) {
395			FPRINTF(stderr,"ERROR: var_flagbit called with bad var.\n");
396			return 0;
397			}
398			return (var->flags & one);
399			}
400
401			void var_set_flagbit(struct var_variable *var, uint32 field,uint32 one)
402			{
403			if (var==NULL \|\| var->ratom == NULL) {
404			FPRINTF(stderr,"ERROR: var_set_flagbit called with bad var.\n");
405			return;
406			}
407			if (one) {
408			var->flags \|= field;
409			} else {
410			var->flags &= ~field;
411			}
412			}
413
414			int32 var_apply_filter(const struct var_variable *var,
415			const var_filter_t *filter)
416			{
417			if (var==NULL \|\| filter==NULL \|\| var->ratom == NULL) {
418			FPRINTF(stderr,"var_apply_filter miscalled with NULL\n");
419			return FALSE;
420			}
421			/* AND to mask off irrelevant bits in flags and match value, then compare */
422			return ( (filter->matchbits & var->flags) ==
423			(filter->matchbits & filter->matchvalue)
424			);
425			}
426
427
428			int32 var_n_incidencesF(struct var_variable *var)
429			{
430			if (var!=NULL) return var->n_incidences;
431			FPRINTF(stderr,"var_n_incidences miscalled with NULL\n");
432			return 0;
433			}
434			void var_set_incidencesF(struct var_variable *var,int32 n,
435			struct rel_relation **i)
436			{
437			if(var!=NULL && n >=0) {
438			if (n && i==NULL) {
439			FPRINTF(stderr,"var_set_incidence miscalled with NULL ilist\n");
440			}
441			var->n_incidences = n;
442			var->incidence = i;
443			return;
444			}
445			FPRINTF(stderr,"var_set_incidence miscalled with NULL or n < 0\n");
446			}
447			const struct rel_relation *var_incidence_list( struct var_variable var)
448			{
449			if (var==NULL) return NULL;
450			return( (const struct rel_relation **)var->incidence );
451			}
452
453			struct rel_relation *var_incidence_list_to_modify( struct var_variable var)
454			{
455			if (var==NULL) return NULL;
456			return( (struct rel_relation **)var->incidence );
457			}
458
459
460
461			/*
462			* global for use with the push function. Sets the ip to the
463			* value in g_var_tag;
464			* should be using vp instead of a global counter.
465			*/
466			static void *g_var_tag = NULL;
467			static void * SetVarTags(struct Instance *i,VOIDPTR vp)
468			{
469			(void)vp;
470			if (i!=NULL && InstanceKind(i)==REAL_ATOM_INST) {
471			return g_var_tag;
472			} else {
473			return NULL;
474			}
475			}
476
477			struct var_variable **var_BackendTokens_to_vars(slv_system_t sys,
478			SlvBackendToken *atoms, int32 len)
479			{
480			int32 i,vartot,vlen,count=0;
481			uint32 apos,ulen;
482			struct var_variable **result;
483			struct var_variable **vlist;
484			struct gl_list_t *oldips;
485			if (sys==NULL \|\| atoms == NULL \|\| len < 1) {
486			return NULL;
487			}
488			ulen = (uint32)len;
489			result = (struct var_variable *)malloc(lensizeof(struct var_variable *));
490			if (result == NULL) return result;
491			/* init results to null */
492			for (i=0; i<len; i++) result[i] = NULL;
493			/* fill ips w/len in all the vars in tree. */
494			g_var_tag = (void *)len;
495			vartot = slv_get_num_master_vars(sys) +
496			slv_get_num_master_pars(sys) +
497			slv_get_num_master_unattached(sys);
498			oldips = PushInterfacePtrs(slv_instance(sys),SetVarTags,vartot,0,NULL);
499			/* fill ips of wanted atoms with i */
500			for (i=0; i<len; i++) {
501			if (GetInterfacePtr(atoms[i])==g_var_tag &&
502			InstanceKind(atoms[i]) == REAL_ATOM_INST) {
503			/* guard a little */
504			SetInterfacePtr((struct Instance )atoms[i],(void )i);
505			} else {
506			/* the odds of g_var_tag being a legal pointer are vanishingly
507			small, so if we find an ATOM without g_var_tag we assume it
508			is outside the tree and shouldn't have been in the list. */
509			FPRINTF(stderr,"var_BackendTokens_to_vars called with bad token.\n");
510			}
511			}
512			/* run through the master lists and put the vars with their atoms */
513			vlist = slv_get_master_var_list(sys);
514			vlen = slv_get_num_master_vars(sys);
515			for (i = 0; i <vlen; i++) {
516			apos = (uint32)GetInterfacePtr(var_instance(vlist[i]));
517			if ( apos < ulen ) {
518			result[apos] = vlist[i];
519			count++;
520			}
521			}
522			vlist = slv_get_master_par_list(sys);
523			vlen = slv_get_num_master_pars(sys);
524			for (i = 0; i <vlen; i++) {
525			apos = (uint32)GetInterfacePtr(var_instance(vlist[i]));
526			if ( apos < ulen ) {
527			result[apos] = vlist[i];
528			count++;
529			}
530			}
531			vlist = slv_get_master_unattached_list(sys);
532			vlen = slv_get_num_master_unattached(sys);
533			for (i = 0; i <vlen; i++) {
534			apos = (uint32)GetInterfacePtr(var_instance(vlist[i]));
535			if ( apos < ulen ) {
536			result[apos] = vlist[i];
537			count++;
538			}
539			}
540			if (count < len) {
541			FPRINTF(stderr,
542			"var_BackendTokens_to_vars found less than expected vars\n");
543			FPRINTF(stderr,"len = %d, vars found = %d\n",len,count);
544			} else {
545			FPRINTF(stderr,
546			"var_BackendTokens_to_vars found more than expected vars\n");
547			FPRINTF(stderr,"len = %d, vars found = %d\n",len,count);
548			}
549			PopInterfacePtrs(oldips,NULL,NULL);
550			return result;
551			}
552
553			static struct TypeDescription *g_solver_var_type;
554			static struct TypeDescription *g_solver_int_type;
555			static struct TypeDescription *g_solver_binary_type;
556			static struct TypeDescription *g_solver_semi_type;
557
558			boolean set_solver_types(void) {
559			boolean nerr = 0;
560			if( (g_solver_var_type = FindType(AddSymbol(SOLVER_VAR_STR))) == NULL ) {
561			FPRINTF(stderr,"ERROR: (var.c) set_solver_types\n");
562			FPRINTF(stderr," Type solver_var not defined.\n");
563			FPRINTF(stderr," Solvers will not work.\n");
564			nerr++;
565			}
566			if( (g_solver_int_type = FindType(AddSymbol(SOLVER_INT_STR))) == NULL ) {
567			FPRINTF(stderr,"ERROR: (var.c) set_solver_types\n");
568			FPRINTF(stderr," Type solver_int not defined.\n");
569			FPRINTF(stderr," MPS will not work.\n");
570			nerr++;
571			}
572			g_solver_binary_type = FindType(AddSymbol(SOLVER_BINARY_STR));
573			if( g_solver_binary_type == NULL) {
574			FPRINTF(stderr,"ERROR: (var.c) set_solver_types\n");
575			FPRINTF(stderr," Type solver_binary not defined.\n");
576			FPRINTF(stderr," MPS will not work.\n");
577			nerr++;
578			}
579			if( (g_solver_semi_type = FindType(AddSymbol(SOLVER_SEMI_STR))) == NULL ) {
580			FPRINTF(stderr,"ERROR: (var.c) set_solver_types\n");
581			FPRINTF(stderr," Type solver_semi not defined.\n");
582			FPRINTF(stderr," MPS will not work.\n");
583			nerr++;
584			}
585
586			LOWER_V = AddSymbolL("lower_bound",11);
587			UPPER_V = AddSymbolL("upper_bound",11);
588			RELAXED_V = AddSymbolL("relaxed",7);
589			NOMINAL_V = AddSymbolL("nominal",7);
590			FIXED_V = AddSymbolL("fixed",5);
591			INTERFACE_V = AddSymbolL("interface",9);
592
593			return nerr;
594			}
595
596			boolean solver_var( SlvBackendToken inst)
597			{
598			struct TypeDescription *type;
599
600			if (!g_solver_var_type) return FALSE;
601			type = InstanceTypeDesc(IPTR(inst));
602			return( type == MoreRefined(type,g_solver_var_type) );
603			}
604
605			boolean solver_int( SlvBackendToken inst)
606			{
607			struct TypeDescription *type;
608
609			if (!g_solver_int_type) return FALSE;
610			type = InstanceTypeDesc(IPTR(inst));
611			return( type == MoreRefined(type,g_solver_int_type) );
612			}
613
614			boolean solver_binary( SlvBackendToken inst)
615			{
616			struct TypeDescription *type;
617
618			if (!g_solver_binary_type) return FALSE;
619			type = InstanceTypeDesc(IPTR(inst));
620			return( type == MoreRefined(type,g_solver_binary_type) );
621			}
622
623			boolean solver_semi( SlvBackendToken inst)
624			{
625			struct TypeDescription *type;
626
627			if (!g_solver_semi_type) return FALSE;
628			type = InstanceTypeDesc(IPTR(inst));
629			return( type == MoreRefined(type,g_solver_semi_type) );
630			}
631