Solver_module.h

Go to the documentation of this file.

/*
 * Lurupa, a library for verified linear programming.
 * Copyright (C) 2006 by Christian Keil
 *
 * This file is part of Lurupa.
 *
 * Lurupa is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
 * USA
 */

#ifndef LURUPA_SOLVER_MODULE_H
#define LURUPA_SOLVER_MODULE_H

#include <lurupa/globals.h>
#include <lurupa/Report.h>
#include <Vector.h>

struct Primal_deflation;
class Lp;

class Lp_solver {
public:
  virtual ~Lp_solver() {};
};

struct Solver_module_interface {
  const char *(*get_version)           ();
  void        (*print_version)         ();
  void        (*print_brief_version)   ();
  bool        (*init)                  (Report *);
  void        (*print_options)         ();
  bool        (*solve_primal_perturbed)(const Primal_deflation &, Lp *, const int);
  bool        (*solve_dual_perturbed)  (const VECTOR &, Lp *, const int);
  bool        (*solve_original)        (Lp *, double &);
  bool        (*get_dual_ray)          (Lp *, int &);
  bool        (*get_primal_ray)        (Lp *, int &);
  void        (*set_primal_phase1)     (Lp *);
  void        (*set_dual_phase1)       (Lp *);
  void        (*restore_primal)        (Lp *);
  void        (*restore_dual)          (Lp *);
  void        (*restore_primal_phase1) (Lp *);
  void        (*restore_dual_phase1)   (Lp *);
  bool        (*read_lp)               (Lp *, FILE *, const double, double &);
#if 0
  bool        (*set_solution)          (Lp *, void *);
#endif

  bool        (*set_lp)                (Lp *, const double, double &);
  bool        (*set_module_options)    (Lp *, int, char *[]);
  double      (*get_accuracy)          ();
  void        (*lp2solver)             (Lp *);
  void        (*set_bounds)            (Lp *, int, double, double);
};

class Solver_module {
public:
  static const char *get_version();

  static void print_version();
  static void print_brief_version();

  static bool init(Report *preport);

  static double get_accuracy();

  static bool set_module_options(int argc, char *argv[]);

  static bool read_lp(Lp *lp, FILE *in, const double relative_interval_radius, double &eta);
  static void print_options();

#if 0
  static bool set_solution(Lp *lp, void *p);
#endif

  static bool set_lp(Lp *lp, const double relative_interval_radius, double &eta);

  static bool solve_original(Lp *lp, double &optimal_value);

  static bool solve_primal_perturbed(const Primal_deflation &deflation,
                                     Lp *lp, const int iteration);

  static bool solve_dual_perturbed(const VECTOR &deflation_c, Lp *lp,
                                   const int iteration);

  static bool get_dual_ray(Lp *lp, int &iyzray);

  static bool get_primal_ray(Lp *lp, int &ixray);

  static void set_primal_phase1(Lp *lp);

  static void set_dual_phase1(Lp *lp);

  static void restore_primal(Lp *lp);

  static void restore_dual(Lp *lp);

  static void restore_primal_phase1(Lp *);

  static void restore_dual_phase1(Lp *);

  static void lp2solver(Lp *lp_lurupa);

  static void set_bounds(Lp *lp, int var, double lower, double upper);

protected:
  static Report *preport;  
private:
  Solver_module();
  ~Solver_module();
}; /* Solver_module */

extern "C" {
  void getFuncPointers(Solver_module_interface &i);
}

#endif /* ifdef LURUPA_SOLVER_MODULE_H */

---