src/lemon/lp_skeleton.cc
changeset 1435 8e85e6bbefdf
parent 1431 ad44b1dd8013
equal deleted inserted replaced
9:34350def8c80 -1:000000000000
     1 /* -*- C++ -*-
       
     2  * src/lemon/lp_skeleton.cc
       
     3  * - Part of LEMON, a generic C++ optimization library
       
     4  *
       
     5  * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
       
     6  * (Egervary Research Group on Combinatorial Optimization, EGRES).
       
     7  *
       
     8  * Permission to use, modify and distribute this software is granted
       
     9  * provided that this copyright notice appears in all copies. For
       
    10  * precise terms see the accompanying LICENSE file.
       
    11  *
       
    12  * This software is provided "AS IS" with no warranty of any kind,
       
    13  * express or implied, and with no claim as to its suitability for any
       
    14  * purpose.
       
    15  *
       
    16  */
       
    17 
       
    18 #include <lemon/lp_skeleton.h>
       
    19 
       
    20 ///\file
       
    21 ///\brief A skeleton file to implement LP solver interfaces
       
    22 namespace lemon {
       
    23   
       
    24   LpSolverBase &LpSkeleton::_newLp()
       
    25   {
       
    26     LpSolverBase *tmp=0;
       
    27     return *tmp;
       
    28   }
       
    29   
       
    30   LpSolverBase &LpSkeleton::_copyLp()
       
    31   {
       
    32     LpSolverBase *tmp=0;
       
    33     return *tmp;
       
    34   }
       
    35 
       
    36   int LpSkeleton::_addCol()
       
    37   {
       
    38     return ++col_num;
       
    39   }
       
    40   
       
    41   int LpSkeleton::_addRow() 
       
    42   {
       
    43     return ++row_num;
       
    44   }
       
    45   
       
    46   void LpSkeleton::_eraseCol(int ) {
       
    47   }
       
    48   
       
    49   void LpSkeleton::_eraseRow(int) {
       
    50   }
       
    51 
       
    52   void LpSkeleton::_setRowCoeffs(int, 
       
    53 				 int,
       
    54 				 int  const *, 
       
    55 				 Value  const *)
       
    56   {
       
    57   }
       
    58   
       
    59   void LpSkeleton::_setColCoeffs(int, 
       
    60 				 int,
       
    61 				 int  const *, 
       
    62 				 Value  const *)
       
    63   {
       
    64   }
       
    65 
       
    66   void LpSkeleton::_setCoeff(int, int, Value )
       
    67   {
       
    68   }
       
    69 
       
    70 
       
    71   void LpSkeleton::_setColLowerBound(int, Value)
       
    72   {
       
    73   }
       
    74   
       
    75   void LpSkeleton::_setColUpperBound(int, Value)
       
    76   {
       
    77   }
       
    78   
       
    79 //   void LpSkeleton::_setRowLowerBound(int, Value)
       
    80 //   {
       
    81 //   }
       
    82   
       
    83 //   void LpSkeleton::_setRowUpperBound(int, Value)
       
    84 //   {
       
    85 //   }
       
    86 
       
    87   void LpSkeleton::_setRowBounds(int, Value, Value)
       
    88   {
       
    89   }
       
    90   
       
    91   void LpSkeleton::_setObjCoeff(int, Value)
       
    92   {
       
    93   }
       
    94 
       
    95   void LpSkeleton::_setMax()
       
    96   {
       
    97   }
       
    98 
       
    99   void LpSkeleton::_setMin()
       
   100   {
       
   101   }
       
   102 
       
   103   void LpSkeleton::_clearObj()
       
   104   {
       
   105   }
       
   106   
       
   107   LpSkeleton::SolveExitStatus LpSkeleton::_solve()
       
   108   {
       
   109     return SOLVED;
       
   110   }
       
   111 
       
   112   LpSkeleton::Value LpSkeleton::_getPrimal(int)
       
   113   {
       
   114     return 0;
       
   115   }
       
   116   
       
   117   LpSkeleton::Value LpSkeleton::_getPrimalValue()
       
   118   {
       
   119     return 0;
       
   120   }
       
   121   
       
   122   LpSkeleton::SolutionStatus LpSkeleton::_getPrimalStatus()
       
   123   {
       
   124     return OPTIMAL;
       
   125   }
       
   126   
       
   127 } //namespace lemon
       
   128