Mercuriallemon-0.x / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
lemon/lp_skeleton.cc
author kpeter
Mon, 18 Feb 2008 03:32:06 +0000
changeset 2575 e866e288cba6
parent 2391 14a343be7a5a
child 2605 852361980706
permissions -rw-r--r--
Major improvements in NetworkSimplex.

Main changes:
- Use -potenital[] instead of potential[] to conform to the usual
terminology.
- Use function parameter instead of #define commands to select pivot rule.
- Use much faster implementation for the candidate list pivot rule.
It is about 5-20 times faster now.
- Add a new pivot rule called "Limited Search" that is a modified
version of "Block Search". It is about 25 percent faster on rather
sparse graphs.
- By default "Limited Search" is used for sparse graphs and
"Block Search" is used otherwise. This combined method is the most
efficient on every input class.
- Change the name of private members to start with "_".
- Change the name of function parameters not to start with "_".
- Remove unnecessary documentation for private members.
- Many doc improvements. 
     1 /* -*- C++ -*-

     2  *

     3  * This file is a part of LEMON, a generic C++ optimization library

     4  *

     5  * Copyright (C) 2003-2008

     6  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

     7  * (Egervary Research Group on Combinatorial Optimization, EGRES).

     8  *

     9  * Permission to use, modify and distribute this software is granted

    10  * provided that this copyright notice appears in all copies. For

    11  * precise terms see the accompanying LICENSE file.

    12  *

    13  * This software is provided "AS IS" with no warranty of any kind,

    14  * express or implied, and with no claim as to its suitability for any

    15  * purpose.

    16  *

    17  */

    18 

    19 #include <lemon/lp_skeleton.h>

    20 

    21 ///\file

    22 ///\brief A skeleton file to implement LP solver interfaces

    23 namespace lemon {

    24   

    25   LpSolverBase &LpSkeleton::_newLp()

    26   {

    27     LpSolverBase *tmp=0;

    28     return *tmp;

    29   }

    30   

    31   LpSolverBase &LpSkeleton::_copyLp()

    32   {

    33     LpSolverBase *tmp=0;

    34     return *tmp;

    35   }

    36 

    37   int LpSkeleton::_addCol()

    38   {

    39     return ++col_num;

    40   }

    41   

    42   int LpSkeleton::_addRow() 

    43   {

    44     return ++row_num;

    45   }

    46   

    47   void LpSkeleton::_eraseCol(int ) {

    48   }

    49   

    50   void LpSkeleton::_eraseRow(int) {

    51   }

    52 

    53   void LpSkeleton::_getColName(int, std::string &) const {

    54   }

    55   

    56   

    57   void LpSkeleton::_setColName(int, const std::string &) {

    58   }

    59 

    60   int LpSkeleton::_colByName(const std::string&) const { return -1; }

    61   

    62   

    63   void LpSkeleton::_setRowCoeffs(int, ConstRowIterator, ConstRowIterator) {

    64   }

    65 

    66   void LpSkeleton::_getRowCoeffs(int, RowIterator) const {

    67   }

    68   

    69   void LpSkeleton::_setColCoeffs(int, ConstColIterator, ConstColIterator) {

    70   }

    71 

    72   void LpSkeleton::_getColCoeffs(int, ColIterator) const {

    73   }

    74 

    75   void LpSkeleton::_setCoeff(int, int, Value )

    76   {

    77   }

    78 

    79   LpSkeleton::Value LpSkeleton::_getCoeff(int, int) const

    80   {

    81     return 0;

    82   }

    83 

    84 

    85   void LpSkeleton::_setColLowerBound(int, Value)

    86   {

    87   }

    88   

    89   LpSkeleton::Value LpSkeleton::_getColLowerBound(int) const

    90   {

    91     return 0;

    92   }

    93   

    94   void LpSkeleton::_setColUpperBound(int, Value)

    95   {

    96   }

    97 

    98   LpSkeleton::Value LpSkeleton::_getColUpperBound(int) const

    99   {

   100     return 0;

   101   }

   102   

   103 //   void LpSkeleton::_setRowLowerBound(int, Value)

   104 //   {

   105 //   }

   106   

   107 //   void LpSkeleton::_setRowUpperBound(int, Value)

   108 //   {

   109 //   }

   110 

   111   void LpSkeleton::_setRowBounds(int, Value, Value)

   112   {

   113   }

   114 

   115   void LpSkeleton::_getRowBounds(int, Value&, Value&) const

   116   {

   117   }

   118   

   119   void LpSkeleton::_setObjCoeff(int, Value)

   120   {

   121   }

   122 

   123   LpSkeleton::Value LpSkeleton::_getObjCoeff(int) const

   124   {

   125     return 0;

   126   }

   127 

   128   void LpSkeleton::_setMax()

   129   {

   130   }

   131 

   132   void LpSkeleton::_setMin()

   133   {

   134   }

   135 

   136   bool LpSkeleton::_isMax() const

   137   {

   138     return true;

   139   }

   140 

   141 

   142   void LpSkeleton::_clearObj()

   143   {

   144   }

   145   

   146   LpSkeleton::SolveExitStatus LpSkeleton::_solve()

   147   {

   148     return SOLVED;

   149   }

   150 

   151   LpSkeleton::Value LpSkeleton::_getPrimal(int) const

   152   {

   153     return 0;

   154   }

   155   

   156   LpSkeleton::Value LpSkeleton::_getDual(int) const

   157   {

   158     return 0;

   159   }

   160   

   161   LpSkeleton::Value LpSkeleton::_getPrimalValue() const

   162   {

   163     return 0;

   164   }

   165   

   166   LpSkeleton::SolutionStatus LpSkeleton::_getPrimalStatus() const

   167   {

   168     return UNDEFINED;

   169   }

   170 

   171   LpSkeleton::SolutionStatus LpSkeleton::_getDualStatus() const

   172   {

   173     return UNDEFINED;

   174   }

   175 

   176   LpSkeleton::ProblemTypes LpSkeleton::_getProblemType() const

   177   {

   178     return UNKNOWN;

   179   }

   180 

   181   bool LpSkeleton::_isBasicCol(int) const

   182   {

   183     return true;

   184   }

   185 

   186 } //namespace lemon

   187
lemon-0.x