Data Structures | Macros | Typedefs | Functions | Variables
lists.h File Reference
#include <omalloc/omalloc.h>
#include <kernel/structs.h>
#include <kernel/ideals.h>
#include <Singular/subexpr.h>
#include <Singular/tok.h>

Go to the source code of this file.

Data Structures

class  slists
 

Macros

#define INLINE_THIS   inline
 

Typedefs

typedef slistslists
 

Functions

int lSize (lists L)
 
lists lCopy (lists L)
 
lists lInsert0 (lists ul, leftv v, int pos)
 
BOOLEAN lInsert (leftv res, leftv u, leftv v)
 
BOOLEAN lInsert3 (leftv res, leftv u, leftv v, leftv w)
 
BOOLEAN lAppend (leftv res, leftv u, leftv v)
 
BOOLEAN lDelete (leftv res, leftv u, leftv v)
 
BOOLEAN lAdd (leftv res, leftv u, leftv v)
 
BOOLEAN lRingDependend (lists L)
 
char * lString (lists l, BOOLEAN typed=FALSE, int dim=1)
 
lists liMakeResolv (resolvente r, int length, int reallen, int typ0, intvec **weights, int add_row_shift)
 
resolvente liFindRes (lists L, int *len, int *typ0, intvec ***weights=NULL)
 

Variables

omBin slists_bin
 

Macro Definition Documentation

#define INLINE_THIS   inline

Definition at line 18 of file lists.h.

Typedef Documentation

typedef slists* lists

Definition at line 48 of file lists.h.

Function Documentation

BOOLEAN lAdd ( leftv  res,
leftv  u,
leftv  v 
)

Definition at line 51 of file lists.cc.

52 {
54  lists ul=(lists)u->CopyD();
55  lists vl=(lists)v->CopyD();
56  l->Init(ul->nr+vl->nr+2);
57  int i;
58 
59  for(i=0;i<=ul->nr;i++)
60  {
61  //Print("u[%d]->r[%d]\n",i,i);
62  l->m[i].rtyp=ul->m[i].rtyp;
63  l->m[i].data=ul->m[i].data;
64  }
65  for(i=0;i<=vl->nr;i++)
66  {
67  //Print("v[%d]->r[%d]\n",i,i+ul->nr+1);
68  l->m[i+ul->nr+1].rtyp=vl->m[i].rtyp;
69  l->m[i+ul->nr+1].data=vl->m[i].data;
70  }
71  if (ul->m != NULL)
72  omFreeSize((ADDRESS)ul->m,(ul->nr+1)*sizeof(sleftv));
74  if (vl->m != NULL)
75  omFreeSize((ADDRESS)vl->m,(vl->nr+1)*sizeof(sleftv));
77  memset(u,0,sizeof(*u));
78  memset(v,0,sizeof(*v));
79  res->data = (char *)l;
80  //res->Print();
81  return FALSE;
82 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
sleftv * m
Definition: lists.h:45
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: lists.h:22
#define FALSE
Definition: auxiliary.h:140
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
void * ADDRESS
Definition: auxiliary.h:161
void * data
Definition: subexpr.h:89
int i
Definition: cfEzgcd.cc:123
INLINE_THIS void Init(int l=0)
Definition: lists.h:66
int nr
Definition: lists.h:43
#define NULL
Definition: omList.c:10
slists * lists
Definition: mpr_numeric.h:146
int rtyp
Definition: subexpr.h:92
omBin slists_bin
Definition: lists.cc:23
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
void * CopyD(int t)
Definition: subexpr.cc:662
int l
Definition: cfEzgcd.cc:94
BOOLEAN lAppend ( leftv  res,
leftv  u,
leftv  v 
)

Definition at line 151 of file lists.cc.

152 {
153  lists ul=(lists)u->CopyD();
154  res->data=(char *)lInsert0(ul,v,ul->nr+1);
155  return (res->data==NULL);
156 }
Definition: lists.h:22
void * data
Definition: subexpr.h:89
lists lInsert0(lists ul, leftv v, int pos)
Definition: lists.cc:87
int nr
Definition: lists.h:43
#define NULL
Definition: omList.c:10
slists * lists
Definition: mpr_numeric.h:146
void * CopyD(int t)
Definition: subexpr.cc:662
lists lCopy ( lists  L)

Definition at line 32 of file lists.cc.

33 {
35  int n=L->nr;
36  if (L->nr>=0)
37  N->Init(n+1);
38  else
39  N->Init();
40  for(;n>=0;n--)
41  {
42  N->m[n].Copy(&L->m[n]);
43  }
44  //Print("copy list with %d -> %d elems\n",L->nr,N->nr);
45  return N;
46 }
sleftv * m
Definition: lists.h:45
Definition: lists.h:22
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:49
void Copy(leftv e)
Definition: subexpr.cc:643
INLINE_THIS void Init(int l=0)
Definition: lists.h:66
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
int nr
Definition: lists.h:43
slists * lists
Definition: mpr_numeric.h:146
omBin slists_bin
Definition: lists.cc:23
BOOLEAN lDelete ( leftv  res,
leftv  u,
leftv  v 
)

Definition at line 161 of file lists.cc.

162 {
163  lists ul=(lists)u->Data();
164  int VIndex=(int)(long)v->Data()-1;
165  int EndIndex=lSize(ul);
166 
167  if((0<=VIndex)&&(VIndex<=ul->nr))
168  {
169  ul=(lists)u->CopyD();
170  int i,j;
172  l->Init(EndIndex+(VIndex>EndIndex));
173 
174  for(i=j=0;i<=EndIndex;i++,j++)
175  {
176  if (i!=VIndex)
177  {
178  l->m[j]=ul->m[i];
179  memset(&ul->m[i],0,sizeof(ul->m[i]));
180  }
181  else
182  {
183  j--;
184  ul->m[i].CleanUp();
185  }
186  }
187  omFreeSize((ADDRESS)ul->m,(ul->nr+1)*sizeof(sleftv));
189  res->data = (char *)l;
190  return FALSE;
191  }
192  Werror("wrong index %d in list(%d)",VIndex+1,ul->nr+1);
193  return TRUE;
194 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
sleftv * m
Definition: lists.h:45
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
Definition: lists.h:22
#define FALSE
Definition: auxiliary.h:140
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define TRUE
Definition: auxiliary.h:144
void * ADDRESS
Definition: auxiliary.h:161
void * data
Definition: subexpr.h:89
int j
Definition: myNF.cc:70
int i
Definition: cfEzgcd.cc:123
int lSize(lists L)
Definition: lists.cc:25
INLINE_THIS void Init(int l=0)
Definition: lists.h:66
int nr
Definition: lists.h:43
slists * lists
Definition: mpr_numeric.h:146
void CleanUp(ring r=currRing)
Definition: subexpr.cc:307
void * Data()
Definition: subexpr.cc:1097
omBin slists_bin
Definition: lists.cc:23
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
void Werror(const char *fmt,...)
Definition: reporter.cc:199
void * CopyD(int t)
Definition: subexpr.cc:662
int l
Definition: cfEzgcd.cc:94
resolvente liFindRes ( lists  L,
int *  len,
int *  typ0,
intvec ***  weights = NULL 
)

Definition at line 313 of file lists.cc.

314 {
315  resolvente r;
316  intvec ** w=NULL,*tw=NULL;
317 
318  *len=L->nr+1;
319  if (*len<=0)
320  {
321  WerrorS("empty list");
322  return NULL;
323  }
324  r=(ideal *)omAlloc0((*len)*sizeof(ideal));
325  w=(intvec**)omAlloc0((*len)*sizeof(intvec*));
326  int i=0;
327  *typ0=MODUL_CMD;
328  while (i<(*len))
329  {
330  if (L->m[i].rtyp != MODUL_CMD)
331  {
332  if (L->m[i].rtyp!=IDEAL_CMD)
333  {
334  Werror("element %d is not of type module",i+1);
335  omFreeSize((ADDRESS)r,(*len)*sizeof(ideal));
336  return NULL;
337  }
338  *typ0=IDEAL_CMD;
339  }
340  if ((i>0) && (idIs0(r[i-1])))
341  {
342  //*len=i-1;
343  break;
344  }
345  r[i]=(ideal)L->m[i].data;
346  tw=(intvec*)atGet((idhdl)&L->m[i],"isHomog",INTVEC_CMD);
347  if (tw!=NULL)
348  {
349  w[i]=ivCopy(tw);
350  }
351  tw = NULL;
352  i++;
353  }
354  BOOLEAN hom_complex=TRUE;
355  int j=0;
356  while ((j<i) && hom_complex)
357  {
358  hom_complex = hom_complex && (w[i]!=NULL);
359  j++;
360  }
361  if ((!hom_complex) || (weights==NULL))
362  {
363  for (j=0;j<i;j++)
364  {
365  if (w[j]!=NULL) delete w[j];
366  }
367  omFreeSize((ADDRESS)w,(*len)*sizeof(intvec*));
368  }
369  else
370  {
371  *weights = w;
372  }
373  //Print("find res of length %d (0..%d) L:%d\n",*len,(*len)-1,L->nr);
374  return r;
375 }
sleftv * m
Definition: lists.h:45
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
intvec * ivCopy(const intvec *o)
Definition: intvec.h:137
#define TRUE
Definition: auxiliary.h:144
void * ADDRESS
Definition: auxiliary.h:161
void WerrorS(const char *s)
Definition: feFopen.cc:23
Definition: idrec.h:34
void * data
Definition: subexpr.h:89
const ring r
Definition: syzextra.cc:208
Definition: intvec.h:16
int j
Definition: myNF.cc:70
int i
Definition: cfEzgcd.cc:123
Definition: tok.h:88
void * atGet(idhdl root, const char *name, int t, void *defaultReturnValue)
Definition: attrib.cc:135
int nr
Definition: lists.h:43
#define NULL
Definition: omList.c:10
const CanonicalForm & w
Definition: facAbsFact.cc:55
int rtyp
Definition: subexpr.h:92
ideal * resolvente
Definition: ideals.h:20
int BOOLEAN
Definition: auxiliary.h:131
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
void Werror(const char *fmt,...)
Definition: reporter.cc:199
#define omAlloc0(size)
Definition: omAllocDecl.h:211
lists liMakeResolv ( resolvente  r,
int  length,
int  reallen,
int  typ0,
intvec **  weights,
int  add_row_shift 
)

Definition at line 216 of file lists.cc.

218 {
220  if (length<=0)
221  {
222  // handle "empty" resolutions
223  L->Init(0);
224  }
225  else
226  {
227  int oldlength=length;
228  while (r[length-1]==NULL) length--;
229  if (reallen<=0) reallen=currRing->N;
230  reallen=si_max(reallen,length);
231  L->Init(reallen);
232  int i=0;
233 
234  while (i<length)
235  {
236  if (r[i]!=NULL)
237  {
238  if (i==0)
239  {
240  L->m[i].rtyp=typ0;
241  int j=IDELEMS(r[0])-1;
242  while ((j>0) && (r[0]->m[j]==NULL)) j--;
243  j++;
244  if (j!=IDELEMS(r[0]))
245  {
246  pEnlargeSet(&(r[0]->m),IDELEMS(r[0]),j-IDELEMS(r[0]));
247  IDELEMS(r[0])=j;
248  }
249  }
250  else
251  {
252  L->m[i].rtyp=MODUL_CMD;
253  int rank=IDELEMS(r[i-1]);
254  if (idIs0(r[i-1]))
255  {
256  idDelete(&(r[i]));
257  r[i]=id_FreeModule(rank, currRing);
258  }
259  else
260  {
261  r[i]->rank=si_max(rank,(int)id_RankFreeModule(r[i], currRing));
262  }
263  idSkipZeroes(r[i]);
264  }
265  L->m[i].data=(void *)r[i];
266  if ((weights!=NULL) && (weights[i]!=NULL))
267  {
268  intvec *w=ivCopy(weights[i]);
269  (*w) += add_row_shift;
270  atSet((idhdl)&L->m[i],omStrDup("isHomog"),w,INTVEC_CMD);
271  weights[i] = NULL;
272  }
273  }
274  #ifdef TEST
275  else
276  {
277  // should not happen:
278  Warn("internal NULL in resolvente");
279  L->m[i].data=(void *)idInit(1,1);
280  }
281  #endif
282  i++;
283  }
284  omFreeSize((ADDRESS)r,oldlength*sizeof(ideal));
285  if (i==0)
286  {
287  L->m[0].rtyp=typ0;
288  L->m[0].data=(char *)idInit(1,1);
289  i=1;
290  }
291  while (i<reallen)
292  {
293  L->m[i].rtyp=MODUL_CMD;
294  ideal I=(ideal)L->m[i-1].data;
295  ideal J;
296  int rank=IDELEMS(I);
297  if (idIs0(I))
298  {
299  J=idFreeModule(rank);
300  }
301  else
302  {
303  J=idInit(1,rank);
304  }
305  L->m[i].data=(void *)J;
306  i++;
307  }
308  //Print("make res of length %d (0..%d) L:%d\n",length,length-1,L->nr);
309  }
310  return L;
311 }
ideal id_FreeModule(int i, const ring r)
the free module of rank i
sleftv * m
Definition: lists.h:45
void atSet(idhdl root, const char *name, void *data, int typ)
Definition: attrib.cc:156
Definition: lists.h:22
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
intvec * ivCopy(const intvec *o)
Definition: intvec.h:137
void * ADDRESS
Definition: auxiliary.h:161
Definition: idrec.h:34
void * data
Definition: subexpr.h:89
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
const ring r
Definition: syzextra.cc:208
Definition: intvec.h:16
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
int j
Definition: myNF.cc:70
ideal idFreeModule(int i)
Definition: ideals.h:126
int m
Definition: cfEzgcd.cc:119
static int si_max(const int a, const int b)
Definition: auxiliary.h:166
int i
Definition: cfEzgcd.cc:123
Definition: tok.h:88
#define IDELEMS(i)
Definition: simpleideals.h:24
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
INLINE_THIS void Init(int l=0)
Definition: lists.h:66
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:38
#define NULL
Definition: omList.c:10
slists * lists
Definition: mpr_numeric.h:146
void pEnlargeSet(poly **p, int l, int increment)
Definition: p_polys.cc:3540
const CanonicalForm & w
Definition: facAbsFact.cc:55
int rtyp
Definition: subexpr.h:92
omBin slists_bin
Definition: lists.cc:23
BOOLEAN idIs0(ideal h)
returns true if h is the zero ideal
void idDelete(ideal *h)
delete an ideal
Definition: ideals.h:31
#define Warn
Definition: emacs.cc:80
#define omStrDup(s)
Definition: omAllocDecl.h:263
BOOLEAN lInsert ( leftv  res,
leftv  u,
leftv  v 
)

Definition at line 120 of file lists.cc.

121 {
122  lists ul=(lists)u->CopyD();
123  res->data=(char *)lInsert0(ul,v,0);
124  if (res->data==NULL)
125  {
126  Werror("cannot insert type `%s`",Tok2Cmdname(v->Typ()));
127  return TRUE;
128  }
129  return FALSE;
130 }
Definition: lists.h:22
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
lists lInsert0(lists ul, leftv v, int pos)
Definition: lists.cc:87
#define NULL
Definition: omList.c:10
slists * lists
Definition: mpr_numeric.h:146
const char * Tok2Cmdname(int tok)
Definition: gentable.cc:128
void Werror(const char *fmt,...)
Definition: reporter.cc:199
void * CopyD(int t)
Definition: subexpr.cc:662
lists lInsert0 ( lists  ul,
leftv  v,
int  pos 
)

Definition at line 87 of file lists.cc.

88 {
89  if ((pos<0)||(v->rtyp==NONE))
90  return NULL;
92  l->Init(si_max(ul->nr+2,pos+1));
93  int i,j;
94 
95  for(i=j=0;i<=ul->nr;i++,j++)
96  {
97  if(j==pos) j++;
98  l->m[j]=ul->m[i];
99  }
100  for(j=ul->nr+1;j<pos;j++)
101  l->m[j].rtyp=DEF_CMD;
102  // memset(&(l->m[pos]),0,sizeof(sleftv)); - done by Init
103  l->m[pos].rtyp=v->Typ();
104  l->m[pos].data=v->CopyD();
105  l->m[pos].flag=v->flag;
106  attr *a=v->Attribute();
107  if ((a!=NULL)&&(*a!=NULL))
108  {
109  l->m[pos].attribute=(*a)->Copy();
110  }
111  if (ul->m != NULL)
112  omFreeSize((ADDRESS)ul->m,(ul->nr+1)*sizeof(sleftv));
114  return l;
115 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
sleftv * m
Definition: lists.h:45
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
const poly a
Definition: syzextra.cc:212
Definition: attrib.h:15
BITSET flag
Definition: subexpr.h:91
Definition: lists.h:22
attr * Attribute()
Definition: subexpr.cc:1352
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
void * ADDRESS
Definition: auxiliary.h:161
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
int j
Definition: myNF.cc:70
Definition: tok.h:58
static int si_max(const int a, const int b)
Definition: auxiliary.h:166
int i
Definition: cfEzgcd.cc:123
INLINE_THIS void Init(int l=0)
Definition: lists.h:66
int nr
Definition: lists.h:43
#define NULL
Definition: omList.c:10
slists * lists
Definition: mpr_numeric.h:146
int rtyp
Definition: subexpr.h:92
attr Copy()
Definition: attrib.cc:41
attr attribute
Definition: subexpr.h:90
omBin slists_bin
Definition: lists.cc:23
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
#define NONE
Definition: tok.h:170
void * CopyD(int t)
Definition: subexpr.cc:662
int l
Definition: cfEzgcd.cc:94
BOOLEAN lInsert3 ( leftv  res,
leftv  u,
leftv  v,
leftv  w 
)

Definition at line 135 of file lists.cc.

136 {
137  lists ul=(lists)u->CopyD();
138  res->data=(char *)lInsert0(ul,v,(int)(long)w->Data());
139  if (res->data==NULL)
140  {
141  Werror("cannot insert type `%s` at pos. %d",
142  Tok2Cmdname(v->Typ()),(int)(long)w->Data());
143  return TRUE;
144  }
145  return FALSE;
146 }
Definition: lists.h:22
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
int Typ()
Definition: subexpr.cc:955
void * data
Definition: subexpr.h:89
lists lInsert0(lists ul, leftv v, int pos)
Definition: lists.cc:87
#define NULL
Definition: omList.c:10
slists * lists
Definition: mpr_numeric.h:146
const char * Tok2Cmdname(int tok)
Definition: gentable.cc:128
void * Data()
Definition: subexpr.cc:1097
void Werror(const char *fmt,...)
Definition: reporter.cc:199
void * CopyD(int t)
Definition: subexpr.cc:662
BOOLEAN lRingDependend ( lists  L)

Definition at line 199 of file lists.cc.

200 {
201  if (L==NULL) return FALSE;
202  int i=0;
203  while (i<=L->nr)
204  {
205  if ((L->m[i].rtyp!=QRING_CMD)
206  && (BEGIN_RING<L->m[i].rtyp)
207  && (L->m[i].rtyp<END_RING))
208  return TRUE;
209  if ((L->m[i].rtyp==LIST_CMD)&&lRingDependend((lists)L->m[i].data))
210  return TRUE;
211  i++;
212  }
213  return FALSE;
214 }
sleftv * m
Definition: lists.h:45
Definition: lists.h:22
#define FALSE
Definition: auxiliary.h:140
#define TRUE
Definition: auxiliary.h:144
void * data
Definition: subexpr.h:89
int m
Definition: cfEzgcd.cc:119
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
Definition: tok.h:96
Definition: tok.h:126
BOOLEAN lRingDependend(lists L)
Definition: lists.cc:199
int lSize ( lists  L)

Definition at line 25 of file lists.cc.

26 {
27  int n=L->nr;
28  while ((n>=0)&&((L->m[n].rtyp==DEF_CMD)||(L->m[n].rtyp==0))) n--;
29  return n;
30 }
sleftv * m
Definition: lists.h:45
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
Definition: tok.h:58
int nr
Definition: lists.h:43
int rtyp
Definition: subexpr.h:92
char* lString ( lists  l,
BOOLEAN  typed = FALSE,
int  dim = 1 
)

Definition at line 377 of file lists.cc.

378 {
379  if (l->nr == -1)
380  {
381  if (typed) return omStrDup("list()");
382  return omStrDup("");
383  }
384 
385  char** slist = (char**) omAlloc((l->nr+1) * sizeof(char*));
386  int i, j, k;
387  char *s;
388  for (i=0, j = 0, k = 0; i<=l->nr; i++)
389  {
390  slist[i] = l->m[i].String(NULL, typed, dim);
391  assume(slist[i] != NULL);
392  omCheckAddr(slist[i]);
393  if (*(slist[i]) != '\0')
394  {
395  j += strlen(slist[i]);
396  k++;
397  }
398  }
399  s = (char*) omAlloc(j+k+2+(typed ? 10 : 0) + (dim == 2 ? k : 0));
400 
401  if (typed)
402  sprintf(s, "list(");
403  else
404  *s = '\0';
405 
406  for (i=0; i<=l->nr; i++)
407  {
408  if (*(slist[i]) != '\0')
409  {
410  strcat(s, slist[i]);
411  strcat(s, ",");
412  if (dim == 2) strcat(s, "\n");
413  }
414  omCheckAddr(s);
415  omFree(slist[i]);
416  }
417  if (k > 0) s[strlen(s) - (dim == 2 ? 2 : 1)] = '\0';
418  if (typed) strcat(s, ")");
419  omCheckAddr(s);
420  omFreeSize(slist, (l->nr+1) * sizeof(char*));
421  return s;
422 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
sleftv * m
Definition: lists.h:45
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
int k
Definition: cfEzgcd.cc:93
#define omAlloc(size)
Definition: omAllocDecl.h:210
char * String(void *d=NULL, BOOLEAN typed=FALSE, int dim=1)
Called for conversion to string (used by string(..), write(..),..)
Definition: subexpr.cc:706
int j
Definition: myNF.cc:70
#define omFree(addr)
Definition: omAllocDecl.h:261
#define assume(x)
Definition: mod2.h:405
int dim(ideal I, ring r)
int i
Definition: cfEzgcd.cc:123
int nr
Definition: lists.h:43
#define NULL
Definition: omList.c:10
#define omCheckAddr(addr)
Definition: omAllocDecl.h:328
#define omStrDup(s)
Definition: omAllocDecl.h:263

Variable Documentation

omBin slists_bin

Definition at line 23 of file lists.cc.