BlockIP.h

Go to the documentation of this file.

//****************************************************************************
#ifndef BLOCKIP_H
#define BLOCKIP_H

#include "MatrixBlockIP.h"
#include "StdForm.h"

using namespace std;

class BlockIP {
    
    // data representation
    
 public: // some types needed by users of the class
  enum TYPE_PROBLEM {LINEAR, QUADRATIC, NONLINEAR};
  enum TYPE_COMP_DY {CHOL_PWRS_PCG, FULL_CHOL, HYBRID_PCG, CHOL_THETA0_PCG};
  // AUTOMATIC is NEWTON if NONLINEAR problem or PCG solver is used
  enum TYPE_DIRECTION {NEWTON,SECOND_ORDER,AUTOMATIC}; 
  enum TYPE_START_POINT {SIMPLE, QUAD_EQCONS_PROB};
  // QUAD_REG: regularization term f(mu) * 1/2 x'Qx is added
  // PROX_REG: proximal point regularization term f(mu) * 1/2* (x-xk)'Q(x-xk) is added
  enum TYPE_REG {NO_REG, QUAD_REG, PROX_REG};
  enum OUTPUT {NONE, SCREEN, FILE, BOTH};

 private:

    // constants
    static constexpr double INF= 1.0e128;
    static const int M_PW_PREC= 1;
    static constexpr double SIGMA= 0.1;
    static constexpr double RHO= 0.995;
    static constexpr double OPTIM_GAP= 1.0e-6;
    static constexpr double OPTIM_GAP_SAFEGUARD= 1.0e-5;
    static constexpr double OPTIM_PFEAS= 1.0e-6;
    static constexpr double OPTIM_DFEAS= 1.0e-6;
    static const int OUTPUT_FREQ= 1;
    static const int MAXITER= 200;
    static constexpr double PCG_TOL_LIN= 1.0e-2;
    static constexpr double PCG_TOL_QUAD= 1.0e-3;
    static constexpr double MIN_PCGTOL= 1.0e-8;
    static constexpr double RED_PCGTOL= 0.95;
    static const TYPE_COMP_DY TYPE_COMP_DY_DEFAULT= CHOL_PWRS_PCG;
    static const TYPE_DIRECTION TYPE_DIRECTION_DEFAULT= AUTOMATIC;
    static const TYPE_START_POINT TYPE_START_POINT_DEFAULT= SIMPLE;
    static const TYPE_REG TYPE_REG_DEFAULT= NO_REG;
    static constexpr double FACTOR_REG_DEFAULT= 1.0e-6;
    static const bool DEACTIVATELNK= true;

    // definition of problem, variables provided by the user and other not provided 
    // but required and computed
    int input_problem; // -1 unchecked problem, 0 wrong problem, 1 ok problem
    
//only to test
public:
    int k_blocks; 
    int km; 
    int kn; 
    int m_cons; 
    int n_vars; 
    int l_link; 
    int *ini_n; 
    int *ini_m; 
    double *cost; 
    double *qcost; 
    double *lb; 
    double *ub; 
    double *lhs; 
    double *rhs; 
    
    bool sameN; 
    bool sameL; 
    MatrixBlockIP *N; 
    MatrixBlockIP *L; 
    MatrixBlockIP *A; 
    MatrixBlockIP *D; 
    MatrixBlockIP *Theta0; 

    void (*fobj) (int n, double x[], double &fx, double Gx[], double Hx[], void *params);
    void *params; 
    double fx, *Gx, *Hx; 
    double dobj; 
    
    bool inStdForm; 

    string *blockNames; 
    string *varNames; 
    string *consNames; 
    
    TYPE_PROBLEM type_objective; 
    StdForm *stdForm; 
    double constantFObj; 
    int *origNVars; 
    int *origNCons; 
    
private:
//end only to test
    bool initialized; 
    
    bool keepStdFormAfterDelete; 
    
    bool deleteMatrices; 
    
    WHO_PERMUTES whoperm;
    
    double inf; 

    double optim_gap; 
    double optim_pfeas; 
    double optim_dfeas; 
    int maxiter; 

    int output_freq; 
    OUTPUT output; 

    double epsmach; 
    double init_pcgtol; 
    double pcgtol; 
    double min_pcgtol; 
    double maxit_pcg; 
    double red_pcgtol; 
    int m_pw_prec; 
    int totcgit; 
    int cgit; 
    int it; 
    double est_specrad; 
    bool show_specrad; 
    bool comp_specrad; 

    TYPE_COMP_DY type_comp_dy; 
    TYPE_DIRECTION type_direction; 
    TYPE_DIRECTION this_type_direction; 
    TYPE_START_POINT type_start_point; 
    TYPE_REG type_reg; 
    double factor_reg; 

    double *x, *y, *z, *w, *s; 
    double *rb, *rc, *rxz, *rsw; 
    double *dxdz, *dsdw; 
    double normb, normc, normrb, normrc; 
    double alpha_p, alpha_d; 
    double rho; 
    double *dx, *dy, *dz, *dw; 
    double gap; 
    double mu, mu0; 
    double sigma; 
    double psi; 
    double *Theta; 
    double *Ax, *Aty, *r, *rhsdy, *rhspcg, *Cvaux, *Cvaux2; 
    double *r_cg, *z_cg, *p_cg; 
    double qreg; 
    double *valpha, *vbeta; 

    bool deactivateLnk; 
    int numActiveLnk; 
    int numInactiveLnk; 
    int numInactiveLnkWithUb; 
    bool *isActiveLnk; 
    int *listActiveLnk; 
    int *listInactiveLnk; 
    
    int numFreeVars; 
    int numUnfreeVars; 
    bool *isFreeVar; 
    int *listFreeVars; 
    int *listUnfreeVars; 
    
    struct BackupLnk {
      int lnk;
      double rhs;
      double **a;
    };
    int numBackupLnk;
    BackupLnk *backupLnk;
    
    int numWithUb; 
    int numWithoutUb;
    int *listWithoutUb;
    int *listWithUb;

    /*// BlockIPminimize variables
    double *b;
    double *u;
    double *c;
    double *q;*/
    
    // member functions

 public: //interface routines
    
    // Constructor
    BlockIP();
    
    // Create an instance with problem in standard form: 0 <= variables <= ub and constraints = rhs
    BlockIP(TYPE_PROBLEM type_objective, double* &cost, double* &qcost, void (*fobj) (int n, double x[], double &fx, double Gx[], double Hx[], void *params), void *params, double* &ub, double* &rhs, int numBlocks, bool sameN, MatrixBlockIP N[], bool sameL, MatrixBlockIP L[]);
    
    // Create an instance with general problem: lb <= variables <= ub and lhs <= constraints  <= rhs
    BlockIP(TYPE_PROBLEM type_objective, double* &cost, double* &qcost, void (*fobj) (int n, double x[], double &fx, double Gx[], double Hx[], void *params), void *params, double* &lb, double* &ub, double* &lhs, double* &rhs, int numBlocks, bool sameN, MatrixBlockIP N[], bool sameL, MatrixBlockIP L[]);
    
    // Destructor
    ~BlockIP();

    // Initializes class attributes
    void initialize();
    // Frees memory of class atrributes
    void free_memory();

    // Create a problem in standard form: 0 <= variables <= ub and constraints = rhs
    void create_problem(TYPE_PROBLEM type_objective, double* &cost, double* &qcost, void (*fobj) (int n, double x[], double &fx, double Gx[], double Hx[], void *params), void *params, double* &ub, double* &rhs, int numBlocks, bool sameN, MatrixBlockIP N[], bool sameL, MatrixBlockIP L[]);
    
    // Create a general problem: lb <= variables <= ub and lhs <= constraints  <= rhs
    void create_problem(TYPE_PROBLEM type_objective, double* &cost, double* &qcost, void (*fobj) (int n, double x[], double &fx, double Gx[], double Hx[], void *params), void *params, double* &lb, double* &ub, double* &lhs, double* &rhs, int numBlocks, bool sameN, MatrixBlockIP N[], bool sameL, MatrixBlockIP L[]);
    
/*    // Load a problem in standard form: 0 <= variables <= ub and constraints = rhs
    void load_problem(double cost[], double qcost[], void (*fobj) (int n, double x[], double &fx, double Gx[], double Hx[], void *params), void *params, double ub[], double rhs[], int numBlocks, bool sameN, MatrixBlockIP N[], bool sameL, MatrixBlockIP L[], bool copy_vectors=true);
    
    // Load a general problem: lb <= variables <= ub and lhs <= constraints  <= rhs
    void load_problem(double cost[], double qcost[], void (*fobj) (int n, double x[], double &fx, double Gx[], double Hx[], void *params), void *params, double lb[], double ub[], double lhs[], double rhs[], int numBlocks, bool sameN, MatrixBlockIP N[], bool sameL, MatrixBlockIP L[], bool copy_vectors=true, bool convertToStd=true);*/
    
    // Convert a problem into standard form
    void convert_to_standard();

    // Check the input problem and compute dimensions
    void check_input_problem_and_compute_dimensions();
    
    // Check if the problems satisfies the conditions when using sameN
    void check_sameN();
    
    // Problem minimization
    int minimize();
    // set to default values all the parameters of the minimization interior-point algorithm
    void set_defaults_minimize();

    /* Retrieve results after optimization */

    // Return number of IP iterations
    int get_it();

    // Return overall number of PCG iterations
    int get_cgit();

    // Return objective function
    double get_fobj();
    
    // Return dual objective function
    double get_dobj();
    
    /* Change some parameters */    
    // Set infinity value to be considered
    void set_inf(double inf= INF);
    
    // Get infinity value to be considered
    double get_inf();
    
    // Set number of terms used as preconditioner of the power series expansion of (D-C'*B^{-1}*B)^{-1}
    void set_m_pw_prec(int m_pw_prec=M_PW_PREC);

    // Get number of terms used as preconditioner of the power series expansion of (D-C'*B^{-1}*B)^{-1}
    int get_m_pw_prec();

    // Set reduction of the centrality parameter at each IP iteration
    void set_sigma(double sigma=SIGMA);
    
    // Get reduction of the centrality parameter at each IP iteration
    double get_sigma();
    
    // Set reduction of the step-length for the primal and dual variables at each IP iteration
    void set_rho(double rho=RHO);
    
    // Get reduction of the step-length for the primal and dual variables at each IP iteration
    double get_rho();
    
    // Set optimality gap tolerance
    void set_optim_gap(double optim_gap=OPTIM_GAP);
    
    // Get optimality gap tolerance
    double get_optim_gap();
    
    // Set primal feasibility tolerance
    void set_optim_pfeas(double optim_pfeas=OPTIM_PFEAS);
    
    // Get primal feasibility tolerance
    double get_optim_pfeas();
    
    // Set dual feasibility tolerance
    void set_optim_dfeas(double optim_dfeas=OPTIM_DFEAS);
    
    // Get dual feasibility tolerance
    double get_optim_dfeas();
    
    // Set output information lines will be printed each output_freq IP iterations
    void set_output_freq(int output_freq=OUTPUT_FREQ);
    
    // Get output information lines will be printed each output_freq IP iterations
    int get_output_freq();
    
    // Set type of output
    void set_output(OUTPUT output=SCREEN);
    
    // Get type of output
    OUTPUT get_output();
    
    // Set maximum number of IP iterations
    void set_maxiter(int maxiter=MAXITER);
    
    // Get maximum number of IP iterations
    int get_maxiter();
    
    // Set initial tolerance for the conjugate gradient (by default PCG_TOL_LIN if linear problem, PCG_TOL_QUAD if quadratic or -convex- nonlinear)
    void set_init_pcgtol(double init_pcgtol);
    
    // Get initial tolerance for the conjugate gradient (by default PCG_TOL_LIN if linear problem, PCG_TOL_QUAD if quadratic or -convex- nonlinear)
    double get_init_pcgtol();
    
    // Set minimum tolerance for the conjugate gradient
    void set_min_pcgtol(double min_pcgtol=MIN_PCGTOL);
    
    // Get minimum tolerance for the conjugate gradient
    double get_min_pcgtol();
    
    // Set maximum number of pcg iterations (if 0, then the value will be computed by the code)
    void set_maxit_pcg(double maxit_pcg=0);
    
    // Get maximum number of pcg iterations (if 0, then the value will be computed by the code)
    double get_maxit_pcg();
    
    // Set reduction of pcg_tol at each IP iteration
    void set_red_pcgtol(double red_pcgtol=RED_PCGTOL);
    
    // Get reduction of pcg_tol at each IP iteration
    double get_red_pcgtol();
    
    // Set show_specrad at each IP iteration
    void set_show_specrad(bool show_specrad=false);
    
    // Get show_specrad 
    bool get_show_specrad();
    
    // Set how dy direction is computed
    void set_type_comp_dy(TYPE_COMP_DY type_comp_dy=TYPE_COMP_DY_DEFAULT);
    
    // Get how dy direction is computed
    TYPE_COMP_DY get_type_comp_dy();
    
    // Set which direction is computed
    void set_type_direction(TYPE_DIRECTION type_direction=TYPE_DIRECTION_DEFAULT);
    
    // Get which direction is computed
    TYPE_DIRECTION get_type_direction();
    
     // Set how starting point is computed 
    void set_type_start_point(TYPE_START_POINT type_start_point=TYPE_START_POINT_DEFAULT);
    
    // Get how starting point is computed
    TYPE_START_POINT get_type_start_point();
    
     // Set type of regularization
    void set_type_reg(TYPE_REG type_reg=TYPE_REG_DEFAULT);
    
    // Get type of regularization
    TYPE_REG get_type_reg();
 
     // Set factor of regularization
    void set_factor_reg(double factor_reg=FACTOR_REG_DEFAULT);
    
    // Get factor of regularization
    double get_factor_reg();
 
    // Set flag on deactivation of linking
    void set_deactivateLnk(bool deactivateLnk=DEACTIVATELNK);
    
    // Get flag on deactivation of linking
    bool get_deactivateLnk();

    // Get the number of blocks
    int get_k_blocks();
    
    // Get the number of constraints without linking constraints
    int get_km();

    // Get the number of variables without linking constraints
    int get_kn();

    // Get the number of linking constraints
    int get_l_link();

    // Get the number of variables of the problem to be optimized
    int get_n_vars();
    
    // Get the number of variables of the problem to be optimized
    int get_m_cons();

    // Get the number of variables of the original problem
    int get_num_vars();
    
    // Get the number of constraints of the original problem
    int get_num_cons();
    
    // Set who performs the permutation
    void set_whoperm(WHO_PERMUTES whoperm_=CHOLESKY);
    
    // Get who performs the permutation
    WHO_PERMUTES get_whoperm();
    
    // Get primal variables of problem optimized
    const double* get_x();

    // Get dual variables of problem optimized (of equality constraints)
    const double* get_y();

    // Get dual variable of problem optimized (of x>=0) i=1..n_vars
    const double* get_z();

    // Get dual variable of problem optimized (of x<=u) i=1..n_vars
    const double* get_w();

    // Get value of primal variable x(i) of problem optimized i=1..n_vars
    double get_x(int i);

    // Get value of dual variable y(i) of problem optimized (of equality constraints) i=1..m_cons
    double get_y(int i);

    // Get value of dual variable z(i) of problem optimized (of x>=0) i=1..n_vars
    double get_z(int i);

    // Get value of dual variable w(i) of problem optimized (of x<=u) i=1..n_vars
    double get_w(int i);

    // These two needed public for wrapper functions to call PCG
    int min_PCG_Hv(int nn, double *v, double *Hv);
    int min_PCG_Hz_eq_r(int nn, double *zz, double *rr);
    int min_PCG_Theta0z_eq_r(int nn, double *zz, double *rr);

    // Set the constant to add to the objective function
    void set_constant_fobj(double constant);
    
    // Get the constant to add to the objective function
    double get_constant_fobj();
    
    // Set the names of the problem
    void set_names(string *blockNames, string *varNames, string *consNames, bool copy_vectors=true);
    
    // Get the names of the problem
    void get_names(const string* &blockNames, const string* &varNames, const string* &consNames);
    
    // Convert the problem to standard form (if it is not already converted) and write the problem in mps file
    void convert_to_std_and_write_mps(const char *filename);
    
    // Write the problem in mps file
    void write_mps(const char *filename);
    
    // Write the problem in mps file
    void write_mps(const char *filename, TYPE_PROBLEM type_objective, double cost[], double qcost[], double lb[], double ub[], double lhs[], double rhs[], int numBlocks, bool sameN, MatrixBlockIP N[], bool sameL, MatrixBlockIP L[], string *blockNames=NULL, string *varNames=NULL, string *consNames=NULL, double constantFObj=0);

    // Create a problem from a mps file
    void read_mps(const char *filename);
    
    // Write the problem in BlockIP format file
    void write_BlockIP_format(const char *filename);
    
    // Create a problem from a BlockIP format file
    void read_BlockIP_format(const char *filename);
    
    // Write all data related to the problem into a file
    void write_problem(const char *filename);
    
    // Get the StdForm related to the problem
    StdForm* get_std_form(bool keepStdFormAfterDelete=false);
  
    // Create names for blocks, variables and constraints if does not exist
    void create_names();
    
    // Get the name of the variables including the block name
    string* get_full_var_names();
    
    // Get the name of the constraints including the block name
    string* get_full_cons_names();

 private:
    void min_initializations();
    void min_preprocess();
    void min_normb_normc();
    void min_Ax(double *Ax, const double *x);
    void min_Aty(double *Aty, const double *y);
    void min_compute_s();
    void min_compute_mu();
    void min_compute_sigma_psi();
    void min_update_inactivelnk();
    void min_KKT_residuals();
    void min_starting_point();
    void min_objective_functions_nonlin();
    void min_objective_functions_linquad();
    void eval_fobj(double x[], double &fx, double Gx[], double Hx[]);
    void min_write_problem_information();
    void min_write_current_point_info();
    void min_steplengths(double &talpha_p, double &talpha_d, double tdx[], double tdz[], double tdw[]);
    bool min_optimal();
    void min_compute_Theta();
    void min_compute_Theta0();
    void min_compute_direction();
    void min_Newton_direction();
    void min_second_order_predictor_corrector_direction();
    void min_update_newpoint();
    void min_test_newpoint();
    void min_backup_inactive(int lnk);
    void min_restore_inactive(int lnk);
    void min_compute_dy_cholpcg(double *dy, double *rhsdy, bool only_solve=false);
    void min_compute_dy_fullchol(double *dy, double *rhsdy, bool only_solve=false);
    void min_free_memory();
    void min_check_Newton_direction_is_correct();
    void min_check_predictor_direction_is_correct();
    void min_check_predictor_corrector_direction_is_correct();
    void min_solve_NThetaNt(double *v);
    void min_Ctv(double *v, double *Ctv);
    void min_Cv(double *v, double *Cv);
    void min_debug_write_variables();
    void min_debug_variables_of_inactivelnk();
    void min_debug_variables_without_ub();
    void min_update_qreg();
};

inline void BlockIP::set_inf(double inf)
{
    this->inf= inf;
}

inline double BlockIP::get_inf()
{
  return inf;
}

inline void BlockIP::set_m_pw_prec(int m_pw_prec)
{
  this->m_pw_prec= m_pw_prec;
}

inline  int BlockIP::get_m_pw_prec()
{
  return m_pw_prec;
}

inline void BlockIP::set_sigma(double sigma)
{
  this->sigma= sigma;
}

inline double BlockIP::get_sigma()
{
  return sigma;
}

inline void BlockIP::set_rho(double rho)
{
  this->rho= rho;
}

inline double BlockIP::get_rho()
{
  return rho;
}

inline void BlockIP::set_optim_gap(double optim_gap)
{
  this->optim_gap= optim_gap;
}

inline double BlockIP::get_optim_gap()
{
  return optim_gap;
}

inline void BlockIP::set_optim_pfeas(double optim_pfeas)
{
  this->optim_pfeas= optim_pfeas;
}

inline double BlockIP::get_optim_pfeas()
{
  return optim_pfeas;
}

inline void BlockIP::set_optim_dfeas(double optim_dfeas)
{
  this->optim_dfeas= optim_dfeas;
}

inline double BlockIP::get_optim_dfeas()
{
  return optim_dfeas;
}

inline void BlockIP::set_output_freq(int output_freq)
{
  this->output_freq= output_freq;
}

inline int BlockIP::get_output_freq()
{
  return output_freq;
}

inline void BlockIP::set_output(OUTPUT output)
{
  this->output= output;
}

inline BlockIP::OUTPUT BlockIP::get_output()
{
  return output;
}

inline void BlockIP::set_maxiter(int maxiter)
{
  this->maxiter= maxiter;
}

inline int BlockIP::get_maxiter()
{
  return maxiter;
}

inline void BlockIP::set_init_pcgtol(double init_pcgtol)
{
  this->init_pcgtol= init_pcgtol;
}

inline double BlockIP::get_init_pcgtol()
{
  return init_pcgtol;
}

inline void BlockIP::set_min_pcgtol(double min_pcgtol)
{
  this->min_pcgtol= min_pcgtol;
}

inline double BlockIP::get_min_pcgtol()
{
  return min_pcgtol;
}

inline void BlockIP::set_maxit_pcg(double maxit_pcg)
{
  this->maxit_pcg= maxit_pcg;
}

inline double BlockIP::get_maxit_pcg()
{
  return maxit_pcg;
}

inline void BlockIP::set_red_pcgtol(double red_pcgtol)
{
  this->red_pcgtol= red_pcgtol;
}

inline double BlockIP::get_red_pcgtol()
{
  return red_pcgtol;
}

inline void BlockIP::set_show_specrad(bool show_specrad)
{
  this->show_specrad= show_specrad;
}

inline bool BlockIP::get_show_specrad()
{
  return show_specrad;
}

inline void BlockIP::set_type_comp_dy(TYPE_COMP_DY type_comp_dy)
{
  this->type_comp_dy= type_comp_dy;
}

inline BlockIP::TYPE_COMP_DY BlockIP::get_type_comp_dy()
{
  return type_comp_dy;
}

inline void BlockIP::set_type_direction(TYPE_DIRECTION type_direction)
{
  this->type_direction= type_direction;
}
 
inline BlockIP::TYPE_DIRECTION BlockIP::get_type_direction()
{
  return type_direction;
}    

inline void BlockIP::set_type_start_point(TYPE_START_POINT type_start_point)
{
  this->type_start_point= type_start_point;
}

inline BlockIP::TYPE_START_POINT BlockIP::get_type_start_point()
{
  return type_start_point;
}

inline void BlockIP::set_type_reg(TYPE_REG type_reg)
{
  this->type_reg= type_reg;
}

inline BlockIP::TYPE_REG BlockIP::get_type_reg()
{
  return type_reg;
}

inline void BlockIP::set_factor_reg(double factor_reg)
{
  this->factor_reg= factor_reg;
}

inline double BlockIP::get_factor_reg()
{
  return factor_reg;
}

inline void BlockIP::set_deactivateLnk(bool deactivateLnk)
{
  this->deactivateLnk= deactivateLnk;
}
    
inline bool BlockIP::get_deactivateLnk()
{
  return deactivateLnk;
}

inline int BlockIP::get_k_blocks()

{
  return k_blocks;
}

inline int BlockIP::get_km()

{
  return km;
}

inline int BlockIP::get_kn()

{
  return kn;
}

inline int BlockIP::get_l_link()

{
  return l_link;
}

inline int BlockIP::get_n_vars()

{
  return n_vars;
}

inline int BlockIP::get_m_cons()

{
  return m_cons;
}

inline int BlockIP::get_num_vars()

{
  if (stdForm)
    return stdForm->numOrigVars;
  else
    return n_vars;
}

inline int BlockIP::get_num_cons()

{
  if (stdForm)
    return m_cons + stdForm->deletedRows->size();
  else
    return m_cons;
}

inline void BlockIP::set_whoperm(WHO_PERMUTES whoperm_)
{
    whoperm= whoperm_;
}

inline WHO_PERMUTES BlockIP::get_whoperm()
{
  return whoperm;
}

inline const double* BlockIP::get_x()
{
  if (stdForm)
    return stdForm->xOrig;
  else
    return x;
}

inline const double* BlockIP::get_y()
{
  if (stdForm)
    return stdForm->yOrig;
  else
    return y;
}

inline const double* BlockIP::get_z()
{
  if (stdForm)
    return stdForm->zOrig;
  else
    return z;
}

inline const double* BlockIP::get_w()
{
  if (stdForm)
    return stdForm->wOrig;
  else
    return w;
}

inline double BlockIP::get_x(int i)
{
  if (stdForm)
    return stdForm->xOrig[i];
  else
    return x[i];
}

inline double BlockIP::get_y(int i)
{
  if (stdForm)
    return stdForm->yOrig[i];
  else
    return y[i];
}

inline double BlockIP::get_z(int i)
{
  if (stdForm)
    return stdForm->zOrig[i];
  else
    return z[i];
}

inline double BlockIP::get_w(int i)
{
  if (stdForm)
    return stdForm->wOrig[i];
  else
    return w[i];
}



inline int BlockIP::get_it()
{
    return(it);
}

inline int BlockIP::get_cgit()
{
    return(totcgit);
}

inline double BlockIP::get_fobj()
{
  if (stdForm)
    return fx + stdForm->constantFObj;
  else
    return(fx);
}

inline double BlockIP::get_dobj()
{
  if (stdForm)
    return dobj + stdForm->constantFObj;
  else
    return(dobj);
}

inline StdForm* BlockIP::get_std_form(bool keepStdFormAfterDelete)

{
  this->keepStdFormAfterDelete = keepStdFormAfterDelete;
  return stdForm;
}

inline void BlockIP::set_constant_fobj(double constant)
{
  constantFObj = constant;
}

inline double BlockIP::get_constant_fobj()
{
  return constantFObj;
}  

inline void BlockIP::eval_fobj(double x[], double &fx, double Gx[], double Hx[])
{
  if (stdForm)
    stdForm->fobj_stdform(n_vars, x, fx, Gx, Hx, params);
  else
    fobj(n_vars, x, fx, Gx, Hx, params);
}
    

#endif //BLOCKIP_H