libpcp/pcp_poly.cc

   1 // Copyright (C) 2009 Free Software Foundation, Inc.
   2 // Contributed by Jan Sjodin <jan.sjodin@amd.com>.
   3
   4 // This file is part of the Polyhedral Compilation Package Library (libpcp).
   5
   6 // Libpcp is free software; you can redistribute it and/or modify it
   7 // under the terms of the GNU Lesser General Public License as published by
   8 // the Free Software Foundation; either version 2.1 of the License, or
   9 // (at your option) any later version.
  10
  11 // Libpcp is distributed in the hope that it will be useful, but WITHOUT ANY
  12 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13 // FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
  14 // more details.
  15
  16 // You should have received a copy of the GNU Lesser General Public License
  17 // along with libpcp; see the file COPYING.LIB.  If not, write to the
  18 // Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  19 // MA 02110-1301, USA.
  20
  21 // As a special exception, if you link this library with other files, some
  22 // of which are compiled with GCC, to produce an executable, this library
  23 // does not by itself cause the resulting executable to be covered by the
  24 // GNU General Public License.  This exception does not however invalidate
  25 // any other reasons why the executable file might be covered by the GNU
  26 // General Public License.
  27
  28 #include "pcp_poly.h"
  29
  30
  31 // PcpPoly
  32 PcpPoly* PcpPoly::theDefault = NULL;
  33
  34 PcpPoly* PcpPoly::getDefault()
  35 {
  36   if(PcpPoly::theDefault == NULL)
  37     {
  38       theDefault = new PcpPoly(PcpPolySpi::create());
  39     }
  40   return theDefault;
  41 }
  42
  43 PcpPoly::PcpPoly(PcpPolySpi* spi)
  44 {
  45   setSpi(spi);
  46 }
  47
  48 void
  49 PcpPoly::setSpi(PcpPolySpi* spi)
  50 {
  51   this->spi = spi;}
  52
  53 PcpPolySpi*
  54 PcpPoly::getSpi()
  55 {
  56   return this->spi;
  57 }
  58
  59 int
  60 PcpPoly::coefficientGetValue(PcpPolySpi::Coefficient* coefficient)
  61 {
  62   return getSpi()->coefficientGetValue(coefficient);
  63 }
  64
  65 const char*
  66 PcpPoly::coefficientToString(PcpPolySpi::Coefficient* coefficient)
  67 {
  68   return getSpi()->coefficientToString(coefficient);
  69 }
  70
  71
  72 PcpPolySpi::Coefficient*
  73 PcpPoly::coefficientCreate(int value)
  74 {
  75   return getSpi()->coefficientCreate(value);
  76 }
  77
  78 void
  79 PcpPoly::coefficientDestroy(PcpPolySpi::Coefficient* coefficient)
  80 {
  81   getSpi()->coefficientDestroy(coefficient);
  82 }
  83
  84 PcpPolySpi::LinearExpr*
  85 PcpPoly::linearExprCopy(PcpPolySpi::LinearExpr* linearExpr)
  86 {
  87   return getSpi()->linearExprCopy(linearExpr);
  88 }
  89
  90 void
  91 PcpPoly::linearExprAddToCoefficient(PcpPolySpi::LinearExpr* linearExpr,
  92                                     int dimension,
  93                                     PcpPolySpi::Coefficient* coefficient)
  94 {
  95   getSpi()->linearExprAddToCoefficient(linearExpr, dimension, coefficient);
  96 }
  97
  98 void
  99 PcpPoly::linearExprAddToCoefficient(PcpPolySpi::LinearExpr* linearExpr, int dimension, int value)
 100 {
 101   getSpi()->linearExprAddToCoefficient(linearExpr, dimension, getSpi()->coefficientCreate(value));
 102 }
 103
 104 void
 105 PcpPoly::linearExprAddToInhomogenous(PcpPolySpi::LinearExpr* linearExpr, PcpPolySpi::Coefficient* value)
 106 {
 107   getSpi()->linearExprAddToInhomogenous(linearExpr, value);
 108 }
 109
 110 void
 111 PcpPoly::linearExprAddToInhomogenous(PcpPolySpi::LinearExpr* linearExpr, int value)
 112 {
 113   getSpi()->linearExprAddToInhomogenous(linearExpr, getSpi()->coefficientCreate(value));
 114 }
 115
 116 void
 117 PcpPoly::linearExprSetCoefficient(PcpPolySpi::LinearExpr* linearExpr, int dimension,
 118                                   PcpPolySpi::Coefficient* coefficient)
 119 {
 120   return getSpi()->linearExprSetCoefficient(linearExpr, dimension, coefficient);
 121 }
 122
 123 void
 124 PcpPoly::linearExprSetCoefficient(PcpPolySpi::LinearExpr* linearExpr, int dimension, int value)
 125 {
 126   return getSpi()->linearExprSetCoefficient(linearExpr, dimension, getSpi()->coefficientCreate(value));
 127 }
 128
 129 void
 130 PcpPoly::linearExprSubtract(PcpPolySpi::LinearExpr* linearExpr, PcpPolySpi::LinearExpr* subtract)
 131 {
 132   getSpi()->linearExprSubtract(linearExpr, subtract);
 133 }
 134
 135 const char*
 136 PcpPoly::linearExprToString(PcpPolySpi::LinearExpr* linearExpr)
 137 {
 138   return getSpi()->linearExprToString(linearExpr);
 139 }
 140
 141
 142 PcpPolySpi::LinearExpr*
 143 PcpPoly::linearExprCreate()
 144 {
 145   return getSpi()->linearExprCreate();
 146 }
 147
 148 PcpPolySpi::LinearExpr*
 149 PcpPoly::linearExprCreate(int numDimensions)
 150 {
 151   return getSpi()->linearExprCreate(numDimensions);
 152 }
 153
 154 void
 155 PcpPoly::linearExprDestroy(PcpPolySpi::LinearExpr* linearExpr)
 156 {
 157   getSpi()->linearExprDestroy(linearExpr);
 158 }
 159
 160
 161 PcpPolySpi::Constraint*
 162 PcpPoly::constraintCreateEqualZero(PcpPolySpi::LinearExpr* linearExpr)
 163 {
 164   return getSpi()->constraintCreateEqualZero(linearExpr);
 165 }
 166
 167 PcpPolySpi::Constraint*
 168 PcpPoly::constraintCreateGreaterEqualZero(PcpPolySpi::LinearExpr* linearExpr)
 169 {
 170   return getSpi()->constraintCreateGreaterEqualZero(linearExpr);
 171 }
 172
 173 void
 174 PcpPoly::constraintDestroy(PcpPolySpi::Constraint* constraint)
 175 {
 176   getSpi()->constraintDestroy(constraint);
 177 }
 178
 179 const char*
 180 PcpPoly::constraintToString(PcpPolySpi::Constraint* constraint)
 181 {
 182   getSpi()->constraintToString(constraint);
 183 }
 184
 185 PcpPolySpi::ConstraintSystem*
 186 PcpPoly::polyhedronGetConstraintSystem(PcpPolySpi::Polyhedron* polyhedron)
 187 {
 188   return getSpi()->polyhedronGetConstraintSystem(polyhedron);
 189 }
 190
 191 void
 192 PcpPoly::polyhedronAddConstraint(PcpPolySpi::Polyhedron* polyhedron,
 193                                  PcpPolySpi::Constraint* constraint)
 194 {
 195   getSpi()->polyhedronAddConstraint(polyhedron, constraint);
 196 }
 197
 198 void
 199 PcpPoly::polyhedronAddConstraints(PcpPolySpi::Polyhedron* polyhedron,
 200                                   PcpPolySpi::ConstraintSystem* constraintSystem)
 201 {
 202   getSpi()->polyhedronAddConstraints(polyhedron, constraintSystem);
 203 }
 204
 205 void
 206 PcpPoly::polyhedronRemap(PcpPolySpi::Polyhedron* polyhedron, PcpArray<int>* map)
 207 {
 208   getSpi()->polyhedronRemap(polyhedron, map);
 209 }
 210
 211 PcpPolySpi::Polyhedron*
 212 PcpPoly::polyhedronCopy(PcpPolySpi::Polyhedron* polyhedron)
 213 {
 214   getSpi()->polyhedronCopy(polyhedron);
 215 }
 216
 217 PcpPolySpi::Polyhedron*
 218 PcpPoly::polyhedronCreate(int numDimensions)
 219 {
 220   return getSpi()->polyhedronCreate(numDimensions);
 221 }
 222
 223 void
 224 PcpPoly::polyhedronDestroy(PcpPolySpi::Polyhedron* polyhedron)
 225 {
 226   getSpi()->polyhedronDestroy(polyhedron);
 227 }
 228
 229 PcpPolySpi::PointsetPowerset*
 230 PcpPoly::pointsetPowersetCreate(PcpPolySpi::Polyhedron* polyhedron)
 231 {
 232   return getSpi()->pointsetPowersetCreate(polyhedron);
 233 }
 234
 235 void
 236 PcpPoly::pointsetPowersetDestroy(PcpPolySpi::PointsetPowerset* poinsetPowerset)
 237 {
 238   return pointsetPowersetDestroy(poinsetPowerset);
 239 }
 240
 241 ///////////////////////////////////////////////////////////////////////////////
 242 // PcpPolyCoefficient
 243
 244 void
 245 PcpPolyCoefficient::setCoefficient(PcpPolySpi::Coefficient* coefficient)
 246 {
 247   this->coefficient = coefficient;
 248 }
 249
 250 PcpPolySpi::Coefficient*
 251 PcpPolyCoefficient::getCoefficient()
 252 {
 253   return this->coefficient;
 254 }
 255
 256 void
 257 PcpPolyCoefficient::setValue(int value)
 258 {
 259   setCoefficient(PcpPoly::getDefault()->coefficientCreate(value));
 260 }
 261
 262 int
 263 PcpPolyCoefficient::getValue()
 264 {
 265   return PcpPoly::getDefault()->coefficientGetValue(this->getCoefficient());
 266 }
 267
 268 PcpPolyCoefficient::PcpPolyCoefficient(int value)
 269 {
 270   setValue(value);
 271 }
 272
 273 PcpPolyCoefficient::~PcpPolyCoefficient()
 274 {
 275   PcpPoly::getDefault()->coefficientDestroy(this->getCoefficient());
 276 }
 277
 278 // PcpPolyLinearExpr
 279 void
 280 PcpPolyLinearExpr::setLinearExpr(PcpPolySpi::LinearExpr* linearExpr)
 281 {
 282   this->linearExpr = linearExpr;
 283 }
 284
 285 PcpPolySpi::LinearExpr*
 286 PcpPolyLinearExpr::getLinearExpr()
 287 {
 288   return this->linearExpr;
 289 }
 290
 291
 292 PcpPolyLinearExpr*
 293 PcpPolyLinearExpr::copy()
 294 {
 295   PcpPoly::getDefault()->linearExprCopy(this->getLinearExpr());
 296 }
 297
 298 void
 299 PcpPolyLinearExpr::addToCoefficient(int dimension, int value)
 300 {
 301   PcpPoly::getDefault()->linearExprAddToCoefficient(this->getLinearExpr(), dimension, value);
 302 }
 303
 304 void
 305 PcpPolyLinearExpr::addToInhomogenous(int value)
 306 {
 307   PcpPoly::getDefault()->linearExprAddToInhomogenous(this->getLinearExpr(), value);
 308 }
 309
 310 void
 311 PcpPolyLinearExpr::setCoefficient(int dimension, int value)
 312 {
 313   PcpPoly::getDefault()->linearExprSetCoefficient(this->getLinearExpr(), dimension, value);
 314 }
 315
 316 void
 317 PcpPolyLinearExpr::subtract(PcpPolyLinearExpr* expr)
 318 {
 319   PcpPoly::getDefault()->linearExprSubtract(this->getLinearExpr(), expr->getLinearExpr());
 320 }
 321
 322 const char* PcpPolyLinearExpr::toString()
 323 {
 324   return PcpPoly::getDefault()->linearExprToString(this->getLinearExpr());
 325 }
 326
 327
 328 PcpPolyLinearExpr::PcpPolyLinearExpr()
 329 {
 330   this->setLinearExpr(PcpPoly::getDefault()->linearExprCreate());
 331 }
 332
 333 PcpPolyLinearExpr::PcpPolyLinearExpr(int numDimensions)
 334 {
 335   this->setLinearExpr(PcpPoly::getDefault()->linearExprCreate(numDimensions));
 336 }
 337
 338 PcpPolyLinearExpr::~PcpPolyLinearExpr()
 339 {
 340   PcpPoly::getDefault()->linearExprDestroy(this->getLinearExpr());
 341 }
 342
 343 ///////////////////////////////////////////////////////////////////////////////
 344 // PcpPolyConstraint
 345
 346 void
 347 PcpPolyConstraint::setOperator(PcpPolyConstraintOperator oper)
 348 {
 349   this->oper = oper;
 350 }
 351
 352 PcpPolyConstraintOperator
 353 PcpPolyConstraint::getOperator()
 354 {
 355   return this->oper;
 356 }
 357
 358 void
 359 PcpPolyConstraint::setConstraint(PcpPolySpi::Constraint* constraint)
 360 {
 361   this->constraint = constraint;
 362 }
 363
 364 PcpPolySpi::Constraint*
 365 PcpPolyConstraint::getConstraint()
 366 {
 367   return this->constraint;
 368 }
 369
 370 const char*
 371 PcpPolyConstraint::toString()
 372 {
 373   return PcpPoly::getDefault()->constraintToString(this->getConstraint());
 374 }
 375
 376
 377 PcpPolyConstraint::PcpPolyConstraint(PcpPolyConstraintOperator oper,
 378                                      PcpPolyLinearExpr* expr)
 379 {
 380   this->setOperator(oper);
 381   PcpPolySpi::LinearExpr* spiExpr = expr->getLinearExpr();
 382   this->setConstraint(oper.isEqualZero()
 383                       ? PcpPoly::getDefault()->constraintCreateEqualZero(spiExpr)
 384                       : PcpPoly::getDefault()->constraintCreateGreaterEqualZero(spiExpr));
 385 }
 386
 387 PcpPolyConstraint::~PcpPolyConstraint()
 388 {
 389   PcpPoly::getDefault()->constraintDestroy(this->getConstraint());
 390 }
 391
 392 ///////////////////////////////////////////////////////////////////////////////
 393 // PcpPolyConstraintSystem
 394
 395 void
 396 PcpPolyConstraintSystem::setConstraintSystem(PcpPolySpi::ConstraintSystem* constraintSystem)
 397 {
 398   this->constraintSystem = constraintSystem;
 399 }
 400
 401 PcpPolySpi::ConstraintSystem*
 402 PcpPolyConstraintSystem::getConstraintSystem()
 403 {
 404   return this->constraintSystem;
 405 }
 406
 407 PcpPolyConstraintSystem::PcpPolyConstraintSystem(PcpPolySpi::ConstraintSystem* constraintSystem)
 408 {
 409   this->setConstraintSystem(constraintSystem);
 410 }
 411
 412 ///////////////////////////////////////////////////////////////////////////////
 413 // PcpPolyPolyhedron
 414
 415 void
 416 PcpPolyPolyhedron::setPolyhedron(PcpPolySpi::Polyhedron* polyhedron)
 417 {
 418   this->polyhedron = polyhedron;
 419 }
 420
 421 PcpPolySpi::Polyhedron*
 422 PcpPolyPolyhedron::getPolyhedron()
 423 {
 424   return this->polyhedron;
 425 }
 426
 427 PcpPolyConstraintSystem*
 428 PcpPolyPolyhedron::getConstraintSystem()
 429 {
 430   PcpPolySpi::Polyhedron* polyhedron = this->getPolyhedron();
 431   return new PcpPolyConstraintSystem(PcpPoly::getDefault()->polyhedronGetConstraintSystem(polyhedron));
 432 }
 433
 434 void
 435 PcpPolyPolyhedron::addConstraint(PcpPolyConstraint* constraint)
 436 {
 437   PcpPoly::getDefault()->polyhedronAddConstraint(this->getPolyhedron(), constraint->getConstraint());
 438 }
 439
 440 void
 441 PcpPolyPolyhedron::addConstraints(PcpPolyConstraintSystem* constraintSystem)
 442 {
 443   PcpPoly::getDefault()->polyhedronAddConstraints(this->getPolyhedron(),
 444                                                   constraintSystem->getConstraintSystem());
 445 }
 446
 447 void
 448 PcpPolyPolyhedron::remap(PcpArray<int>* map)
 449 {
 450   PcpPoly::getDefault()->polyhedronRemap(this->getPolyhedron(), map);
 451 }
 452
 453 PcpPolyPolyhedron::PcpPolyPolyhedron(PcpPolyPolyhedron* polyhedron)
 454 {
 455   this->setPolyhedron(PcpPoly::getDefault()->polyhedronCopy(polyhedron->getPolyhedron()));
 456 }
 457
 458 PcpPolyPolyhedron::PcpPolyPolyhedron(int numDimensions)
 459 {
 460   this->setPolyhedron(PcpPoly::getDefault()->polyhedronCreate(numDimensions));
 461 }
 462
 463 PcpPolyPolyhedron::~PcpPolyPolyhedron()
 464 {
 465   PcpPoly::getDefault()->polyhedronDestroy(this->getPolyhedron());
 466 }
 467
 468 ///////////////////////////////////////////////////////////////////////////////
 469 void PcpPolyPointsetPowerset::setPointsetPowerset(PcpPolySpi::PointsetPowerset* pointsetPowerset)
 470 {
 471   this->pointsetPowerset = pointsetPowerset;
 472 }
 473
 474 PcpPolySpi::PointsetPowerset*
 475 PcpPolyPointsetPowerset::getPointsetPowerset()
 476 {
 477   return this->pointsetPowerset;
 478 }
 479
 480 PcpPolyPointsetPowerset::PcpPolyPointsetPowerset(PcpPolyPolyhedron* polyhedron)
 481 {
 482   this->setPointsetPowerset(PcpPoly::getDefault()->pointsetPowersetCreate(polyhedron->getPolyhedron()));
 483 }
 484
 485 PcpPolyPointsetPowerset::~PcpPolyPointsetPowerset()
 486 {
 487   PcpPoly::getDefault()->pointsetPowersetDestroy(this->getPointsetPowerset());
 488 }
 489