My Project
Loading...
Searching...
No Matches
bbpolytope.cc File Reference
#include "kernel/mod2.h"
#include "Singular/ipid.h"
#include "Singular/ipshell.h"
#include "Singular/blackbox.h"
#include "misc/intvec.h"
#include "coeffs/bigintmat.h"
#include "callgfanlib_conversion.h"
#include "gfanlib/gfanlib.h"
#include "gfanlib/gfanlib_q.h"

Go to the source code of this file.

Functions

std::string bbpolytopeToString (gfan::ZCone const &c)
 
void * bbpolytope_Init (blackbox *)
 
BOOLEAN bbpolytope_Assign (leftv l, leftv r)
 
char * bbpolytope_String (blackbox *, void *d)
 
void bbpolytope_destroy (blackbox *, void *d)
 
void * bbpolytope_Copy (blackbox *, void *d)
 
static BOOLEAN ppCONERAYS1 (leftv res, leftv v)
 
static BOOLEAN ppCONERAYS3 (leftv res, leftv u, leftv v)
 
BOOLEAN polytopeViaVertices (leftv res, leftv args)
 
static BOOLEAN ppCONENORMALS1 (leftv res, leftv v)
 
static BOOLEAN ppCONENORMALS2 (leftv res, leftv u, leftv v)
 
static BOOLEAN ppCONENORMALS3 (leftv res, leftv u, leftv v, leftv w)
 
BOOLEAN polytopeViaNormals (leftv res, leftv args)
 
BOOLEAN vertices (leftv res, leftv args)
 
int getAmbientDimension (gfan::ZCone *zc)
 
int getCodimension (gfan::ZCone *zc)
 
int getDimension (gfan::ZCone *zc)
 
gfan::ZVector intStar2ZVectorWithLeadingOne (const int d, const int *i)
 
gfan::ZCone newtonPolytope (poly p, ring r)
 
BOOLEAN newtonPolytope (leftv res, leftv args)
 
BOOLEAN scalePolytope (leftv res, leftv args)
 
BOOLEAN dualPolytope (leftv res, leftv args)
 
BOOLEAN mixedVolume (leftv res, leftv args)
 
void bbpolytope_setup (SModulFunctions *p)
 

Variables

VAR int polytopeID
 

Function Documentation

◆ bbpolytope_Assign()

BOOLEAN bbpolytope_Assign ( leftv l,
leftv r )

Definition at line 37 of file bbpolytope.cc.

38{
39 gfan::ZCone* newZc;
40 if (r==NULL)
41 {
42 if (l->Data()!=NULL)
43 {
44 gfan::ZCone* zd = (gfan::ZCone*)l->Data();
45 delete zd;
46 }
47 newZc = new gfan::ZCone();
48 }
49 else if (r->Typ()==l->Typ())
50 {
51 if (l->Data()!=NULL)
52 {
53 gfan::ZCone* zd = (gfan::ZCone*)l->Data();
54 delete zd;
55 }
56 gfan::ZCone* zc = (gfan::ZCone*)r->Data();
57 newZc = new gfan::ZCone(*zc);
58 }
59 // else if (r->Typ()==INT_CMD) TODO:r->Typ()==BIGINTMAT_CMD
60 // {
61 // int ambientDim = (int)(long)r->Data();
62 // if (ambientDim < 0)
63 // {
64 // Werror("expected an int >= 0, but got %d", ambientDim);
65 // return TRUE;
66 // }
67 // if (l->Data()!=NULL)
68 // {
69 // gfan::ZCone* zd = (gfan::ZCone*)l->Data();
70 // delete zd;
71 // }
72 // newZc = new gfan::ZCone(ambientDim);
73 // }
74 else
75 {
76 Werror("assign Type(%d) = Type(%d) not implemented",l->Typ(),r->Typ());
77 return TRUE;
78 }
79
80 if (l->rtyp==IDHDL)
81 {
82 IDDATA((idhdl)l->data) = (char*) newZc;
83 }
84 else
85 {
86 l->data=(void *)newZc;
87 }
88 return FALSE;
89}
#define TRUE
Definition auxiliary.h:101
#define FALSE
Definition auxiliary.h:97
int l
Definition cfEzgcd.cc:100
int Typ()
Definition subexpr.cc:1048
void * Data()
Definition subexpr.cc:1192
#define IDDATA(a)
Definition ipid.h:126
#define NULL
Definition omList.c:12
void Werror(const char *fmt,...)
Definition reporter.cc:189
idrec * idhdl
Definition ring.h:22
#define IDHDL
Definition tok.h:31

◆ bbpolytope_Copy()

void * bbpolytope_Copy ( blackbox * ,
void * d )

Definition at line 110 of file bbpolytope.cc.

111{
112 gfan::ZCone* zc = (gfan::ZCone*)d;
113 gfan::ZCone* newZc = new gfan::ZCone(*zc);
114 return newZc;
115}

◆ bbpolytope_destroy()

void bbpolytope_destroy ( blackbox * ,
void * d )

Definition at line 101 of file bbpolytope.cc.

102{
103 if (d!=NULL)
104 {
105 gfan::ZCone* zc = (gfan::ZCone*) d;
106 delete zc;
107 }
108}

◆ bbpolytope_Init()

void * bbpolytope_Init ( blackbox * )

Definition at line 32 of file bbpolytope.cc.

33{
34 return (void*)(new gfan::ZCone());
35}

◆ bbpolytope_setup()

void bbpolytope_setup ( SModulFunctions * p)

Definition at line 549 of file bbpolytope.cc.

550{
551 blackbox *b=(blackbox*)omAlloc0(sizeof(blackbox));
552 // all undefined entries will be set to default in setBlackboxStuff
553 // the default Print is quite usefule,
554 // all other are simply error messages
555 b->blackbox_destroy=bbpolytope_destroy;
556 b->blackbox_String=bbpolytope_String;
557 //b->blackbox_Print=blackbox_default_Print;
558 b->blackbox_Init=bbpolytope_Init;
559 b->blackbox_Copy=bbpolytope_Copy;
560 b->blackbox_Assign=bbpolytope_Assign;
561 p->iiAddCproc("gfan.lib","polytopeViaPointsInternal",FALSE,polytopeViaVertices);
562 p->iiAddCproc("gfan.lib","polytopeViaInequalitiesInternal",FALSE,polytopeViaNormals);
563 p->iiAddCproc("gfan.lib","verticesInternal",FALSE,vertices);
564 p->iiAddCproc("gfan.lib","newtonPolytopeInternal",FALSE,newtonPolytope);
565 p->iiAddCproc("gfan.lib","scalePolytopeInternal",FALSE,scalePolytope);
566 p->iiAddCproc("gfan.lib","dualPolytopeInternal",FALSE,dualPolytope);
567 p->iiAddCproc("gfan.lib","mixedVolumeInternal",FALSE,mixedVolume);
568 /********************************************************/
569 /* the following functions are implemented in bbcone.cc */
570 // iiAddCproc("gfan.lib","getAmbientDimensionInternal",FALSE,getAmbientDimension);
571 // iiAddCproc("gfan.lib","getCodimensionInternal",FALSE,getAmbientDimension);
572 // iiAddCproc("gfan.lib","getDimensionInternal",FALSE,getDimension);
573 /********************************************************/
574 /* the following functions are identical to those in bbcone.cc */
575 // iiAddCproc("gfan.lib","facetsInternal",FALSE,facets);
576 // iiAddCproc("gfan.lib","setLinearFormsInternal",FALSE,setLinearForms);
577 // iiAddCproc("gfan.lib","getLinearFormsInternal",FALSE,getLinearForms);
578 // iiAddCproc("gfan.lib","setMultiplicityInternal",FALSE,setMultiplicity);
579 // iiAddCproc("gfan.lib","getMultiplicityInternal",FALSE,getMultiplicity);
580 // iiAddCproc("gfan.lib","hasFaceInternal",FALSE,hasFace);
581 /***************************************************************/
582 // iiAddCproc("gfan.lib","getEquationsInternal",FALSE,getEquations);
583 // iiAddCproc("gfan.lib","getInequalitiesInternal",FALSE,getInequalities);
584 polytopeID=setBlackboxStuff(b,"polytope");
585 //Print("created type %d (polytope)\n",polytopeID);
586}
BOOLEAN polytopeViaVertices(leftv res, leftv args)
void bbpolytope_destroy(blackbox *, void *d)
char * bbpolytope_String(blackbox *, void *d)
Definition bbpolytope.cc:91
BOOLEAN polytopeViaNormals(leftv res, leftv args)
BOOLEAN dualPolytope(leftv res, leftv args)
BOOLEAN scalePolytope(leftv res, leftv args)
VAR int polytopeID
Definition bbpolytope.cc:16
void * bbpolytope_Init(blackbox *)
Definition bbpolytope.cc:32
BOOLEAN bbpolytope_Assign(leftv l, leftv r)
Definition bbpolytope.cc:37
BOOLEAN mixedVolume(leftv res, leftv args)
gfan::ZCone newtonPolytope(poly p, ring r)
BOOLEAN vertices(leftv res, leftv args)
void * bbpolytope_Copy(blackbox *, void *d)
int setBlackboxStuff(blackbox *bb, const char *n)
define a new type
Definition blackbox.cc:143
int p
Definition cfModGcd.cc:4086
CanonicalForm b
Definition cfModGcd.cc:4111
#define omAlloc0(size)

◆ bbpolytope_String()

char * bbpolytope_String ( blackbox * ,
void * d )

Definition at line 91 of file bbpolytope.cc.

92{ if (d==NULL) return omStrDup("invalid object");
93 else
94 {
95 gfan::ZCone* zc = (gfan::ZCone*)d;
96 std::string s=bbpolytopeToString(*zc);
97 return omStrDup(s.c_str());
98 }
99}
std::string bbpolytopeToString(gfan::ZCone const &c)
Definition bbpolytope.cc:18
const CanonicalForm int s
Definition facAbsFact.cc:51
#define omStrDup(s)

◆ bbpolytopeToString()

std::string bbpolytopeToString ( gfan::ZCone const & c)

Definition at line 18 of file bbpolytope.cc.

19{
20 std::stringstream s;
21 gfan::ZMatrix i=c.getInequalities();
22 gfan::ZMatrix e=c.getEquations();
23 s<<"AMBIENT_DIM"<<std::endl;
24 s<<c.ambientDimension()-1<<std::endl;
25 s<<"INEQUALITIES"<<std::endl;
26 s<<toString(i)<<std::endl;
27 s<<"EQUATIONS"<<std::endl;
28 s<<toString(e)<<std::endl;
29 return s.str();
30}
std::string toString(const gfan::ZCone *const c)
Definition bbcone.cc:27
int i
Definition cfEzgcd.cc:132

◆ dualPolytope()

BOOLEAN dualPolytope ( leftv res,
leftv args )

Definition at line 472 of file bbpolytope.cc.

473{
474 leftv u = args;
475 if ((u != NULL) && (u->Typ() == polytopeID))
476 {
477 gfan::initializeCddlibIfRequired();
478 gfan::ZCone* zp = (gfan::ZCone*) u->Data();
479 gfan::ZCone* zq = new gfan::ZCone(zp->dualCone());
480 res->rtyp = polytopeID;
481 res->data = (void*) zq;
482 gfan::deinitializeCddlibIfRequired();
483 return FALSE;
484 }
485 WerrorS("dualPolytope: unexpected parameters");
486 return TRUE;
487}
CanonicalForm res
Definition facAbsFact.cc:60
void WerrorS(const char *s)
Definition feFopen.cc:24
sleftv * leftv
Definition structs.h:53

◆ getAmbientDimension()

int getAmbientDimension ( gfan::ZCone * zc)

Definition at line 386 of file bbpolytope.cc.

387{ // hence ambientDimension-1
388 return zc->ambientDimension()-1;
389}

◆ getCodimension()

int getCodimension ( gfan::ZCone * zc)

Definition at line 391 of file bbpolytope.cc.

392{
393 return zc->codimension();
394}

◆ getDimension()

int getDimension ( gfan::ZCone * zc)

Definition at line 396 of file bbpolytope.cc.

397{
398 return zc->dimension()-1;
399}

◆ intStar2ZVectorWithLeadingOne()

gfan::ZVector intStar2ZVectorWithLeadingOne ( const int d,
const int * i )

Definition at line 401 of file bbpolytope.cc.

402{
403 gfan::ZVector zv(d+1);
404 zv[0]=1;
405 for(int j=1; j<=d; j++)
406 {
407 zv[j]=i[j];
408 }
409 return zv;
410}
int j
Definition facHensel.cc:110

◆ mixedVolume()

BOOLEAN mixedVolume ( leftv res,
leftv args )

Definition at line 489 of file bbpolytope.cc.

490{
491 leftv u = args;
492 if ((u != NULL) && (u->Typ() == LIST_CMD))
493 {
494 gfan::initializeCddlibIfRequired();
495 lists l = (lists) u->Data();
496 int k = lSize(l)+1;
497 std::vector<gfan::IntMatrix> P(k);
498 for (int i=0; i<k; i++)
499 {
500 if (l->m[i].Typ() == polytopeID)
501 {
502 gfan::ZCone* p = (gfan::ZCone*) l->m[i].Data();
503 gfan::ZMatrix pv = p->extremeRays();
504 int r = pv.getHeight();
505 int c = pv.getWidth();
506 gfan::IntMatrix pw(r,c-1);
507 for (int n=0; n<r; n++)
508 for (int m=1; m<c; m++)
509 pw[n][m-1] = pv[n][m].toInt();
510 P[i]=pw.transposed();
511 } else if (l->m[i].Typ() == POLY_CMD)
512 {
513 poly p = (poly) l->m[i].Data();
514 int N = rVar(currRing);
515 gfan::IntMatrix pw(0,N);
516 int *leadexpv = (int*)omAlloc((N+1)*sizeof(int));
517 while (p!=NULL)
518 {
519 p_GetExpV(p,leadexpv,currRing);
520 gfan::IntVector zv(N);
521 for (int i=0; i<N; i++)
522 zv[i] = leadexpv[i+1];
523 pw.appendRow(zv);
524 pIter(p);
525 }
526 P[i]=pw.transposed();
527 omFreeSize(leadexpv,(N+1)*sizeof(int));
528 }
529 else
530 {
531 WerrorS("mixedVolume: entries of unsupported type in list");
532 gfan::deinitializeCddlibIfRequired();
533 return TRUE;
534 }
535 }
536 gfan::Integer mv = gfan::mixedVolume(P);
537
538 res->rtyp = BIGINT_CMD;
539 res->data = (void*) integerToNumber(mv);
540 gfan::deinitializeCddlibIfRequired();
541 return FALSE;
542 }
543 WerrorS("mixedVolume: unexpected parameters");
544 return TRUE;
545}
number integerToNumber(const gfan::Integer &I)
const CanonicalForm CFMap CFMap & N
Definition cfEzgcd.cc:56
int m
Definition cfEzgcd.cc:128
int k
Definition cfEzgcd.cc:99
@ POLY_CMD
Definition grammar.cc:290
int lSize(lists L)
Definition lists.cc:25
#define pIter(p)
Definition monomials.h:37
slists * lists
#define omFreeSize(addr, size)
#define omAlloc(size)
static void p_GetExpV(poly p, int *ev, const ring r)
Definition p_polys.h:1536
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition ring.h:598
@ BIGINT_CMD
Definition tok.h:38
@ LIST_CMD
Definition tok.h:118

◆ newtonPolytope() [1/2]

BOOLEAN newtonPolytope ( leftv res,
leftv args )

Definition at line 429 of file bbpolytope.cc.

430{
431 leftv u = args;
432 if ((u != NULL) && (u->Typ() == POLY_CMD))
433 {
434 gfan::initializeCddlibIfRequired();
435 poly p = (poly)u->Data();
436 res->rtyp = polytopeID;
437 res->data = (void*) new gfan::ZCone(newtonPolytope(p,currRing));
438 gfan::deinitializeCddlibIfRequired();
439 return FALSE;
440 }
441 WerrorS("newtonPolytope: unexpected parameters");
442 return TRUE;
443}

◆ newtonPolytope() [2/2]

gfan::ZCone newtonPolytope ( poly p,
ring r )

Definition at line 412 of file bbpolytope.cc.

413{
414 int N = rVar(r);
415 gfan::ZMatrix zm(0,N+1);
416 int *leadexpv = (int*)omAlloc((N+1)*sizeof(int));
417 while (p!=NULL)
418 {
419 p_GetExpV(p,leadexpv,r);
420 gfan::ZVector zv = intStar2ZVectorWithLeadingOne(N, leadexpv);
421 zm.appendRow(zv);
422 pIter(p);
423 }
424 omFreeSize(leadexpv,(N+1)*sizeof(int));
425 gfan::ZCone Delta = gfan::ZCone::givenByRays(zm,gfan::ZMatrix(0, zm.getWidth()));
426 return Delta;
427}
gfan::ZVector intStar2ZVectorWithLeadingOne(const int d, const int *i)

◆ polytopeViaNormals()

BOOLEAN polytopeViaNormals ( leftv res,
leftv args )

Definition at line 330 of file bbpolytope.cc.

331{
332 leftv u = args;
333 if ((u != NULL) && ((u->Typ() == BIGINTMAT_CMD) || (u->Typ() == INTMAT_CMD)))
334 {
335 if (u->next == NULL)
336 {
337 gfan::initializeCddlibIfRequired();
338 BOOLEAN bo = ppCONENORMALS1(res, u);
339 gfan::deinitializeCddlibIfRequired();
340 return bo;
341 }
342 }
343 leftv v = u->next;
344 if ((v != NULL) && ((v->Typ() == BIGINTMAT_CMD) || (v->Typ() == INTMAT_CMD)))
345 {
346 if (v->next == NULL)
347 {
348 gfan::initializeCddlibIfRequired();
349 BOOLEAN bo = ppCONENORMALS2(res, u, v);
350 gfan::deinitializeCddlibIfRequired();
351 return bo;
352 }
353 }
354 leftv w = v->next;
355 if ((w != NULL) && (w->Typ() == INT_CMD))
356 {
357 if (w->next == NULL)
358 {
359 gfan::initializeCddlibIfRequired();
360 BOOLEAN bo = ppCONENORMALS3(res, u, v, w);
361 gfan::deinitializeCddlibIfRequired();
362 return bo;
363 }
364 }
365 WerrorS("polytopeViaInequalities: unexpected parameters");
366 return TRUE;
367}
int BOOLEAN
Definition auxiliary.h:88
static BOOLEAN ppCONENORMALS2(leftv res, leftv u, leftv v)
static BOOLEAN ppCONENORMALS1(leftv res, leftv v)
static BOOLEAN ppCONENORMALS3(leftv res, leftv u, leftv v, leftv w)
leftv next
Definition subexpr.h:86
const CanonicalForm & w
Definition facAbsFact.cc:51
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
@ BIGINTMAT_CMD
Definition grammar.cc:278
@ INTMAT_CMD
Definition grammar.cc:280
@ INT_CMD
Definition tok.h:96

◆ polytopeViaVertices()

BOOLEAN polytopeViaVertices ( leftv res,
leftv args )

Definition at line 184 of file bbpolytope.cc.

185{
186 leftv u = args;
187 if ((u != NULL) && ((u->Typ() == BIGINTMAT_CMD) || (u->Typ() == INTMAT_CMD)))
188 {
189 if (u->next == NULL)
190 {
191 gfan::initializeCddlibIfRequired();
192 BOOLEAN bo = ppCONERAYS1(res, u);
193 gfan::deinitializeCddlibIfRequired();
194 return bo;
195 }
196 leftv v = u->next;
197 if ((v != NULL) && (v->Typ() == INT_CMD))
198 {
199 if (v->next == NULL)
200 {
201 gfan::initializeCddlibIfRequired();
202 BOOLEAN bo = ppCONERAYS3(res, u, v);
203 gfan::deinitializeCddlibIfRequired();
204 return bo;
205 }
206 }
207 }
208 WerrorS("polytopeViaPoints: unexpected parameters");
209 return TRUE;
210}
static BOOLEAN ppCONERAYS1(leftv res, leftv v)
static BOOLEAN ppCONERAYS3(leftv res, leftv u, leftv v)

◆ ppCONENORMALS1()

static BOOLEAN ppCONENORMALS1 ( leftv res,
leftv v )
static

Definition at line 212 of file bbpolytope.cc.

213{
214 /* method for generating a cone object from inequalities;
215 valid parametrizations: (bigintmat) */
216 bigintmat* ineq = NULL;
217 if (v->Typ() == INTMAT_CMD)
218 {
219 intvec* ineq0 = (intvec*) v->Data();
220 ineq = iv2bim(ineq0,coeffs_BIGINT);
221 }
222 else
223 ineq = (bigintmat*) v->Data();
224 gfan::ZMatrix* zm = bigintmatToZMatrix(ineq);
225 gfan::ZCone* zc = new gfan::ZCone(*zm, gfan::ZMatrix(0, zm->getWidth()));
226 delete zm;
227 if (v->Typ() == INTMAT_CMD)
228 delete ineq;
229 res->rtyp = polytopeID;
230 res->data = (void*) zc;
231 return FALSE;
232}
bigintmat * iv2bim(intvec *b, const coeffs C)
Definition bigintmat.cc:347
gfan::ZMatrix * bigintmatToZMatrix(const bigintmat &bim)
Matrices of numbers.
Definition bigintmat.h:51
VAR coeffs coeffs_BIGINT
Definition polys.cc:14

◆ ppCONENORMALS2()

static BOOLEAN ppCONENORMALS2 ( leftv res,
leftv u,
leftv v )
static

Definition at line 234 of file bbpolytope.cc.

235{
236 /* method for generating a cone object from iequalities,
237 and equations (...)
238 valid parametrizations: (bigintmat, bigintmat)
239 Errors will be invoked in the following cases:
240 - u and v have different numbers of columns */
241 bigintmat* ineq = NULL; bigintmat* eq = NULL;
242 if (u->Typ() == INTMAT_CMD)
243 {
244 intvec* ineq0 = (intvec*) u->Data();
245 ineq = iv2bim(ineq0,coeffs_BIGINT);
246 }
247 else
248 ineq = (bigintmat*) u->Data();
249 if (v->Typ() == INTMAT_CMD)
250 {
251 intvec* eq0 = (intvec*) v->Data();
252 eq = iv2bim(eq0,coeffs_BIGINT);
253 }
254 else
255 eq = (bigintmat*) v->Data();
256
257 if (ineq->cols() != eq->cols())
258 {
259 Werror("expected same number of columns but got %d vs. %d",
260 ineq->cols(), eq->cols());
261 return TRUE;
262 }
263 gfan::ZMatrix* zm1 = bigintmatToZMatrix(ineq);
264 gfan::ZMatrix* zm2 = bigintmatToZMatrix(eq);
265 gfan::ZCone* zc = new gfan::ZCone(*zm1, *zm2);
266 delete zm1;
267 delete zm2;
268 if (u->Typ() == INTMAT_CMD)
269 delete ineq;
270 if (v->Typ() == INTMAT_CMD)
271 delete eq;
272
273 res->rtyp = polytopeID;
274 res->data = (void*) zc;
275 return FALSE;
276}
int cols() const
Definition bigintmat.h:144

◆ ppCONENORMALS3()

static BOOLEAN ppCONENORMALS3 ( leftv res,
leftv u,
leftv v,
leftv w )
static

Definition at line 278 of file bbpolytope.cc.

279{
280 /* method for generating a cone object from inequalities, equations,
281 and an integer k;
282 valid parametrizations: (bigintmat, bigintmat, int);
283 Errors will be invoked in the following cases:
284 - u and v have different numbers of columns,
285 - k not in [0..3];
286 if the 2^0-bit of k is set, then ... */
287 bigintmat* ineq = NULL; bigintmat* eq = NULL;
288 if (u->Typ() == INTMAT_CMD)
289 {
290 intvec* ineq0 = (intvec*) u->Data();
291 ineq = iv2bim(ineq0,coeffs_BIGINT);
292 }
293 else
294 ineq = (bigintmat*) u->Data();
295 if (v->Typ() == INTMAT_CMD)
296 {
297 intvec* eq0 = (intvec*) v->Data();
298 eq = iv2bim(eq0,coeffs_BIGINT);
299 }
300 else
301 eq = (bigintmat*) v->Data();
302
303 if (ineq->cols() != eq->cols())
304 {
305 Werror("expected same number of columns but got %d vs. %d",
306 ineq->cols(), eq->cols());
307 return TRUE;
308 }
309 int k = (int)(long)w->Data();
310 if ((k < 0) || (k > 3))
311 {
312 WerrorS("expected int argument in [0..3]");
313 return TRUE;
314 }
315 gfan::ZMatrix* zm1 = bigintmatToZMatrix(ineq);
316 gfan::ZMatrix* zm2 = bigintmatToZMatrix(eq);
317 gfan::ZCone* zc = new gfan::ZCone(*zm1, *zm2, k);
318 delete zm1;
319 delete zm2;
320 if (u->Typ() == INTMAT_CMD)
321 delete ineq;
322 if (v->Typ() == INTMAT_CMD)
323 delete eq;
324
325 res->rtyp = polytopeID;
326 res->data = (void*) zc;
327 return FALSE;
328}

◆ ppCONERAYS1()

static BOOLEAN ppCONERAYS1 ( leftv res,
leftv v )
static

Definition at line 117 of file bbpolytope.cc.

118{
119 /* method for generating a cone object from half-lines
120 (cone = convex hull of the half-lines; note: there may be
121 entire lines in the cone);
122 valid parametrizations: (bigintmat) */
124 if (v->Typ() == INTMAT_CMD)
125 {
126 intvec* rays0 = (intvec*) v->Data();
127 rays = iv2bim(rays0,coeffs_BIGINT);
128 }
129 else
130 rays = (bigintmat*) v->Data();
131
132 gfan::ZMatrix* zm = bigintmatToZMatrix(rays);
133 gfan::ZCone* zc = new gfan::ZCone();
134 *zc = gfan::ZCone::givenByRays(*zm, gfan::ZMatrix(0, zm->getWidth()));
135 res->rtyp = polytopeID;
136 res->data = (void*) zc;
137
138 delete zm;
139 if (v->Typ() == INTMAT_CMD)
140 delete rays;
141 return FALSE;
142}
BOOLEAN rays(leftv res, leftv args)
Definition bbcone.cc:662

◆ ppCONERAYS3()

static BOOLEAN ppCONERAYS3 ( leftv res,
leftv u,
leftv v )
static

Definition at line 144 of file bbpolytope.cc.

145{
146 /* method for generating a cone object from half-lines
147 (any point in the cone being the sum of a point
148 in the convex hull of the half-lines and a point in the span
149 of the lines), and an integer k;
150 valid parametrizations: (bigintmat, int);
151 Errors will be invoked in the following cases:
152 - k not 0 or 1;
153 if the k=1, then the extreme rays are known:
154 each half-line spans a (different) extreme ray */
156 if (u->Typ() == INTMAT_CMD)
157 {
158 intvec* rays0 = (intvec*) u->Data();
159 rays = iv2bim(rays0,coeffs_BIGINT);
160 }
161 else
162 rays = (bigintmat*) u->Data();
163 int k = (int)(long)v->Data();
164
165 if ((k < 0) || (k > 1))
166 {
167 WerrorS("expected int argument in [0..1]");
168 return TRUE;
169 }
170 k=k*2;
171 gfan::ZMatrix* zm = bigintmatToZMatrix(rays);
172 gfan::ZCone* zc = new gfan::ZCone();
173 *zc = gfan::ZCone::givenByRays(*zm,gfan::ZMatrix(0, zm->getWidth()));
174 //k should be passed on to zc; not available yet
175 res->rtyp = polytopeID;
176 res->data = (void*) zc;
177
178 delete zm;
179 if (v->Typ() == INTMAT_CMD)
180 delete rays;
181 return FALSE;
182}

◆ scalePolytope()

BOOLEAN scalePolytope ( leftv res,
leftv args )

Definition at line 445 of file bbpolytope.cc.

446{
447 leftv u = args;
448 if ((u != NULL) && (u->Typ() == INT_CMD))
449 {
450 leftv v = u->next;
451 if ((v != NULL) && (v->Typ() == polytopeID))
452 {
453 gfan::initializeCddlibIfRequired();
454 int s = (int)(long) u->Data();
455 gfan::ZCone* zp = (gfan::ZCone*) v->Data();
456 gfan::ZMatrix zm = zp->extremeRays();
457 for (int i=0; i<zm.getHeight(); i++)
458 for (int j=1; j<zm.getWidth(); j++)
459 zm[i][j]*=s;
460 gfan::ZCone* zq = new gfan::ZCone();
461 *zq = gfan::ZCone::givenByRays(zm,gfan::ZMatrix(0, zm.getWidth()));
462 res->rtyp = polytopeID;
463 res->data = (void*) zq;
464 gfan::deinitializeCddlibIfRequired();
465 return FALSE;
466 }
467 }
468 WerrorS("scalePolytope: unexpected parameters");
469 return TRUE;
470}

◆ vertices()

BOOLEAN vertices ( leftv res,
leftv args )

Definition at line 369 of file bbpolytope.cc.

370{
371 leftv u = args;
372 if ((u != NULL) && (u->Typ() == polytopeID))
373 {
374 gfan::initializeCddlibIfRequired();
375 gfan::ZCone* zc = (gfan::ZCone*)u->Data();
376 gfan::ZMatrix zmat = zc->extremeRays();
377 res->rtyp = BIGINTMAT_CMD;
378 res->data = (void*)zMatrixToBigintmat(zmat);
379 gfan::deinitializeCddlibIfRequired();
380 return FALSE;
381 }
382 WerrorS("vertices: unexpected parameters");
383 return TRUE;
384}
bigintmat * zMatrixToBigintmat(const gfan::ZMatrix &zm)

Variable Documentation

◆ polytopeID

VAR int polytopeID

Definition at line 16 of file bbpolytope.cc.