spiceparser/eqnlist.c

   1 /********************
   2     This file is part of the software library CADLIB written by Conrad Ziesler
   3     Copyright 2003, Conrad Ziesler, all rights reserved.
   4
   5 *************************
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19
  20 ******************/
  21 /* eqnlist.c, routines for equation dependency lists, part of package eqn
  22    Conrad Ziesler
  23 */
  24
  25 #include <stdio.h>
  26 #include "debug.h"
  27
  28 #include "names.h"
  29 #include "list.h"
  30 #include "eqn.h"
  31 #include "bitlist.h"
  32
  33
  34
  35 int __debug_eqnlist__=1;
  36
  37 #ifndef STRIP_DEBUGGING
  38 #define D(level,a) do { if(__debug_eqnlist__>(level)) a; } while(0)
  39 #else
  40 #define D(level,a)
  41 #endif
  42
  43 void eqnl_init(eqnlist_t *nl)
  44 {
  45   nl->params=names_new();
  46   list_init(&(nl->eqnlist),sizeof(eqn_t),LIST_DEFMODE);
  47   list_init(&(nl->cache),sizeof(float),LIST_DEFMODE);
  48 }
  49 void eqnl_free(eqnlist_t *nl)
  50 {
  51   list_empty(&(nl->eqnlist));
  52   list_empty(&(nl->cache));
  53   names_free(nl->params);
  54 }
  55
  56 int eqnl_find(eqnlist_t *nl, char *str)
  57 {
  58   int ind;
  59   ind=names_check(nl->params,str);
  60   return ind;
  61 }
  62
  63 eqn_t eqnl_eqn(eqnlist_t *nl, int index)
  64 {
  65   eqn_t *ep;
  66   ep=list_data(&(nl->eqnlist),index);
  67   if(ep!=NULL)
  68     return *ep;
  69   return eqn_empty();
  70 }
  71
  72
  73 int eqnl_add(eqnlist_t *nl, eqn_t e, char *str)
  74 {
  75 #ifdef NO_EQUATIONS
  76   return -1;
  77 #else
  78   int i;
  79   eqn_t ed;
  80   float fv=0.0;
  81
  82   ed=eqn_copy(e);
  83   i=list_add(&(nl->eqnlist),&ed);
  84   if(names_check(nl->params,str)>=0)
  85     { fprintf(stderr,"eqnlist equations: you are doing something wierd w/ hier. (%s) \n",str);   assert(0); }
  86   names_add(nl->params,i,str);
  87   list_add(&(nl->cache),&fv);
  88   D(10,fprintf(stderr,"eqnl_add: adding %s as index %i\n",str,i));
  89   return i;
  90 #endif
  91 }
  92
  93 /* here we evaluate terminals for the user, that is equations
  94    for which no other equation depends,
  95
  96    we first lookup in the parameter cache any dependencies
  97    and then call eqntok_eval to do the dirty work
  98 */
  99
 100 float eqnl_eval(eqnlist_t *nl, eqn_t e)
 101 {
 102 #ifdef NO_EQUATIONS
 103   return e.val;
 104 #else
 105   float *fp;
 106   float res;
 107   int r;
 108   eqntoken_t *et;
 109   int index;
 110
 111   if(e.eqn==NULL)return 0.0;
 112   for(et=e.eqn;!OP_ISEND(et->op);et=eqntoken_next(et))
 113     {
 114       if((et->op==OPlit) || (et->op==OPlitm))
 115         assert(0);
 116
 117       if((et->op==OPlitv) || (et->op==OPlitvm))
 118         {
 119           if((index=et->z.lit.ref)==eqn_litref_INIT)
 120             assert(0);
 121
 122           fp=list_data(&(nl->cache),index);
 123           if(fp!=NULL)
 124             et->z.lit.cache=*fp;
 125           else assert(0);
 126         }
 127     }
 128   res=0.0;
 129   r=eqntok_eval(&res,e.eqn);
 130   assert(r==0);
 131   return res;
 132 #endif
 133 }
 134
 135
 136 /*
 137   any parameter is stored in our cache.
 138   here we resolve parameter dependecies
 139   and evaluate all parameters.
 140
 141 */
 142
 143 void eqnl_evaldep(eqnlist_t *nl)
 144 {
 145 #ifdef NO_EQUATIONS
 146   return;
 147 #else
 148   eqntoken_t *et;
 149   int i,sweep,qleft=0,qdep,index;
 150   eqn_t *e;
 151   bitlist_t *bl;
 152
 153   qleft=list_qty(&(nl->eqnlist));
 154   bl=bitlist_new(qleft);
 155
 156   for(sweep=0;sweep<32;sweep++) /* limit heirarchy depth to stop cycles */
 157     {
 158       /* now check dependencies of all equations until done */
 159       list_iterate(&(nl->eqnlist),i,e)
 160         {
 161           if(!bitlist_test(bl,i)) /* quick check for done */
 162             {
 163               qdep=0;
 164               /* go through eqntokens and find dependencies */
 165               for(et=e->eqn;!OP_ISEND(et->op);et=eqntoken_next(et))
 166                 {
 167                   if((et->op==OPlit) || (et->op==OPlitm))
 168                     assert(0);
 169
 170                   if((et->op==OPlitv) || (et->op==OPlitvm))
 171                     {
 172                       if((index=et->z.lit.ref)==eqn_litref_INIT)
 173                         assert(0);
 174
 175                       if(bitlist_test(bl,index))
 176                         { /* dependency is already computed, get its value */
 177                           float *fp;
 178
 179                           fp=list_data(&(nl->cache),index);
 180                           if(fp!=NULL)
 181                             et->z.lit.cache=*fp;
 182                           else assert(0);
 183                         }
 184                       else qdep++; /* indicate dependency not done */
 185                     }
 186                 }
 187
 188               if(qdep==0) /* all dependencies resolved, mark as done */
 189                 {
 190                   int r=100;
 191                   float *fp;
 192
 193                   fp=list_data(&(nl->cache),i);
 194
 195                   if(fp!=NULL) /* compute new value */
 196                     {
 197                       r=eqntok_eval(fp,e->eqn);
 198                       D(5,fprintf(stderr,"Evaldep: recomputed equation %i -> %s == %g\n",i,eqnl_lookup(nl,i),*fp));
 199                     }
 200                   assert(r==0);
 201                   bitlist_set(bl,i);
 202                   qleft--;
 203                 }
 204
 205             }
 206         }
 207       if(qleft==0)break;
 208     }
 209   if(sweep==32)
 210     {
 211       assert(0);
 212     }
 213
 214   bitlist_free(bl);
 215 #endif
 216 }
 217
 218 /* do eqntoken_depend looking up unresolved symbols in eqnlist
 219    that is, a single predefined list of parameters
 220  */
 221
 222 static eqn_litref_t eqnl_depend_lookup(struct plookup_st *user, char *str)
 223 {
 224   eqn_litref_t r;
 225   r=eqnl_find(user->user, str);
 226   if(r<0)
 227     {
 228       fprintf(stderr,"eqnl_depend: unresolved symbol %s\n",str);
 229       assert(0);
 230     }
 231   return r;
 232 }
 233
 234
 235 void eqnl_depend(eqnlist_t *nl, eqn_t e)
 236 {
 237   plookup_t plu;
 238   if(e.eqn==NULL)return;
 239   plu.lookup=eqnl_depend_lookup;
 240   plu.user=nl;
 241   eqntok_depend(e.eqn,&plu);
 242 }
 243
 244
 245 /* do eqnl_depend on all predefined parameters in eqnlist */
 246 void eqnl_autodepend(eqnlist_t *nl)
 247 {
 248   int i;
 249   eqn_t *e;
 250
 251   list_iterate(&(nl->eqnlist),i,e)
 252     {
 253       eqnl_depend(nl,*e);
 254     }
 255 }
 256
 257 /* check if an entry in our eqn table is undefined,
 258    that is it should be defined by the client
 259    before it tries to call evaleqns
 260 */
 261 int eqnl_is_undefined(eqnlist_t *nl, int index)
 262 {
 263   eqn_t *ep;
 264   ep= list_data(&(nl->eqnlist),index);
 265   if(ep==NULL)return -1;
 266   return eqn_is_undefined(*ep);
 267 }
 268
 269
 270 int eqnl_define(eqnlist_t *nl, int index, float *valp)
 271 {
 272   eqn_t *ep;
 273   ep= list_data(&(nl->eqnlist),index);
 274   if(ep==NULL)return -1;
 275   eqn_setvalp(ep,valp);
 276   return 0;
 277 }
 278
 279 int eqnl_qty(eqnlist_t *nl)
 280 {
 281   int a,b;
 282   a=list_qty(&(nl->eqnlist));
 283   b=list_qty(&(nl->cache));
 284   assert(a==b);
 285   return a;
 286 }
 287
 288 char *eqnl_lookup(eqnlist_t *nl, int index)
 289 {
 290   return names_lookup(nl->params,index);
 291 }