Changeset 522


Ignore:
Timestamp:
Sep 19, 2005 10:13:59 AM (15 years ago)
Author:
andreasw
Message:
  • implemented fixing variables by adding equality constraints (new option fixed_variable_treament)
  • avoid reordering of primal variables if there are not fixed variables (in TNLPAdapter)
  • in iteration output line move obj function a bit to the left
  • take -qtune=auto out of options for ASL (gives segfault in some cases)
Location:
branches/dev
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • branches/dev/Algorithm/IpOrigIterationOutput.cpp

    r517 r522  
    111111    if (!IpData().info_skip_output()) {
    112112      Jnlst().Printf(J_SUMMARY, J_MAIN,
    113                      "%4d%c %13.7e %7.2e %7.2e %5.1f %7.2e %5s %7.2e %7.2e%c%3d",
     113                     "%4d%c%14.7e %7.2e %7.2e %5.1f %7.2e %5s %7.2e %7.2e%c%3d",
    114114                     iter, info_iter, unscaled_f, inf_pr, inf_du, log10(mu), dnrm, regu_x_ptr,
    115115                     alpha_dual, alpha_primal, alpha_primal_char,
  • branches/dev/Algorithm/IpPDFullSpaceSolver.cpp

    r510 r522  
    483483            perturbHandler_->PerturbForSingularity(delta_x, delta_s,
    484484                                                   delta_c, delta_d);
    485             IpData().Append_info_string("M");
     485            IpData().Append_info_string("a");
    486486          }
    487487        }
  • branches/dev/Algorithm/IpRestoIterationOutput.cpp

    r501 r522  
    138138
    139139    Jnlst().Printf(J_SUMMARY, J_MAIN,
    140                    "%4d%c %13.7e %7.2e %7.2e %5.1f %7.2e %5s %7.2e %7.2e%c%3d",
     140                   "%4d%c%14.7e %7.2e %7.2e %5.1f %7.2e %5s %7.2e %7.2e%c%3d",
    141141                   iter, info_iter, f, inf_pr, inf_du, log10(mu), dnrm, regu_x_ptr,
    142142                   alpha_dual, alpha_primal, alpha_primal_char,
  • branches/dev/Interfaces/IpNLP.hpp

    r501 r522  
    7272
    7373    /** Method for obtaining the bounds information */
    74     virtual bool GetBoundsInformation(Matrix& Px_L,
     74    virtual bool GetBoundsInformation(const Matrix& Px_L,
    7575                                      Vector& x_L,
    76                                       Matrix& Px_U,
     76                                      const Matrix& Px_U,
    7777                                      Vector& x_U,
    78                                       Matrix& Pd_L,
     78                                      const Matrix& Pd_L,
    7979                                      Vector& d_L,
    80                                       Matrix& Pd_U,
     80                                      const Matrix& Pd_U,
    8181                                      Vector& d_U)=0;
    8282
  • branches/dev/Interfaces/IpTNLPAdapter.cpp

    r517 r522  
    3434      n_full_g_(-1),
    3535      nz_jac_c_(-1),
     36      nz_jac_c_no_fixed_(-1),
    3637      nz_jac_d_(-1),
    3738      nz_full_jac_g_(-1),
     
    7980      "any bound greater or this value will be considered +inf (i.e. not upper bounded).",
    8081      1e19);
     82    roptions->AddStringOption2(
     83      "fixed_variable_treatment",
     84      "Determines how fixed variables should be handled.",
     85      "make_parameter",
     86      "make_parameter", "Remove fixed variable from optimization variables",
     87      "make_constraint", "Add equality constraints fixing variables",
     88      "The main difference between those two options is that the starting "
     89      "point in the \"make_constraint\" case still has the fixed variables at "
     90      "their given values, whereas in the other case the functions are always "
     91      "evaluated with the fixed values for those variables.  Also, for "
     92      "\"make_constraints\", bound multipliers are computed for the fixed "
     93      "variables.");
    8194    roptions->AddStringOption3(
    8295      "derivative_test",
     
    124137
    125138    Index enum_int;
     139    options.GetEnumValue("fixed_variable_treatment", enum_int, prefix);
     140    fixed_variable_treatment_ = FixedVariableTreatmentEnum(enum_int);
    126141    options.GetEnumValue("derivative_test", enum_int, prefix);
    127142    derivative_test_ = DerivativeTestEnum(enum_int);
     
    231246      tnlp_->get_bounds_info(n_full_x_, x_l, x_u, n_full_g_, g_l, g_u);
    232247
    233       Index n_x_not_fixed = 0;
     248      Index n_x_var = 0;
    234249      Index n_x_l = 0;
    235250      Index n_x_u = 0;
     
    244259        Number upper_bound = x_u[i];
    245260        if (lower_bound == upper_bound) {
    246           // Variable is fixed, remove it from the problem
    247           full_x_[i] = lower_bound;
    248           x_fixed_map_tmp[n_x_fixed_] = i;
    249           n_x_fixed_++;
     261          switch (fixed_variable_treatment_) {
     262            case MAKE_PARAMETER:
     263            // Variable is fixed, remove it from the problem
     264            full_x_[i] = lower_bound;
     265            x_fixed_map_tmp[n_x_fixed_] = i;
     266            n_x_fixed_++;
     267            break;
     268            case MAKE_CONSTRAINT:
     269            x_fixed_map_tmp[n_x_fixed_] = i; // don't really need this
     270            // array then
     271            n_x_fixed_++;
     272            x_not_fixed_map[n_x_var] = i;
     273            n_x_var++;
     274            break;
     275            default:
     276            DBG_ASSERT(false && "invalid fixed_variable_treatment_");
     277          }
    250278        }
    251279        else if (lower_bound > upper_bound) {
     
    255283        }
    256284        else {
    257           x_not_fixed_map[n_x_not_fixed] = i;
     285          x_not_fixed_map[n_x_var] = i;
    258286          if (lower_bound > nlp_lower_bound_inf_) {
    259             x_l_map[n_x_l] = n_x_not_fixed;
     287            x_l_map[n_x_l] = n_x_var;
    260288            n_x_l++;
    261289          }
    262290
    263291          if (upper_bound < nlp_upper_bound_inf_) {
    264             x_u_map[n_x_u] = n_x_not_fixed;
     292            x_u_map[n_x_u] = n_x_var;
    265293            n_x_u++;
    266294          }
    267           n_x_not_fixed++;
     295          n_x_var++;
    268296        }
    269297      }
    270298
    271299      // If there are fixed variables, we keep their position around
    272       // for a possible warm start later
     300      // for a possible warm start later or if fixed variables are
     301      // treated by added equality constraints
    273302      if (n_x_fixed_>0) {
    274303        x_fixed_map_ = new Index[n_x_fixed_];
     
    282311      delete [] x_fixed_map_tmp;
    283312
    284       x_space_ = new DenseVectorSpace(n_x_not_fixed);
     313      x_space_ = new DenseVectorSpace(n_x_var);
    285314      x_l_space_ = new DenseVectorSpace(n_x_l);
    286315      x_u_space_ = new DenseVectorSpace(n_x_u);
    287316
    288       P_x_full_x_space_ = new ExpansionMatrixSpace(n_full_x_, n_x_not_fixed, x_not_fixed_map);
    289       P_x_full_x_ = P_x_full_x_space_->MakeNewExpansionMatrix();
    290 
    291       P_x_x_L_space_ = new ExpansionMatrixSpace(n_x_not_fixed, n_x_l, x_l_map);
     317      if (n_x_fixed_>0 && fixed_variable_treatment_==MAKE_PARAMETER) {
     318        P_x_full_x_space_ = new ExpansionMatrixSpace(n_full_x_, n_x_var, x_not_fixed_map);
     319        P_x_full_x_ = P_x_full_x_space_->MakeNewExpansionMatrix();
     320      }
     321      else {
     322        P_x_full_x_space_ = NULL;
     323        P_x_full_x_ = NULL;
     324      }
     325
     326      P_x_x_L_space_ = new ExpansionMatrixSpace(n_x_var, n_x_l, x_l_map);
    292327      px_l_space_ = GetRawPtr(P_x_x_L_space_);
    293328      P_x_x_L_ = P_x_x_L_space_->MakeNewExpansionMatrix();
    294       P_x_x_U_space_ = new ExpansionMatrixSpace(n_x_not_fixed, n_x_u, x_u_map);
     329      P_x_x_U_space_ = new ExpansionMatrixSpace(n_x_var, n_x_u, x_u_map);
    295330      px_u_space_ = GetRawPtr(P_x_x_U_space_);
    296331      P_x_x_U_ = P_x_x_U_space_->MakeNewExpansionMatrix();
     
    353388
    354389      // create the required c_space
    355       SmartPtr<DenseVectorSpace> dc_space = new DenseVectorSpace(n_c);
    356       c_rhs_ = new Number[n_c];
    357       c_space_ = GetRawPtr(dc_space);
     390
     391      if (n_x_fixed_==0 || fixed_variable_treatment_==MAKE_PARAMETER) {
     392        SmartPtr<DenseVectorSpace> dc_space = new DenseVectorSpace(n_c);
     393        c_space_ = GetRawPtr(dc_space);
     394        c_rhs_ = new Number[n_c];
     395      }
     396      else {
     397        SmartPtr<DenseVectorSpace> dc_space =
     398          new DenseVectorSpace(n_c+n_x_fixed_);
     399        c_space_ = GetRawPtr(dc_space);
     400        c_rhs_ = new Number[n_c+n_x_fixed_];
     401      }
    358402      // create the internal expansion matrix for c to g
    359403      P_c_g_space_ = new ExpansionMatrixSpace(n_full_g_, n_c, c_map);
     
    403447        }
    404448      }
    405       const Index* c_col_pos = P_x_full_x_->CompressedPosIndices();
    406       const Index* c_row_pos = P_c_g_->CompressedPosIndices();
    407449
    408450      // ... build the non-zero structure for jac_c
    409451      // ... (the permutation from rows in jac_g to jac_c is
    410452      // ...  the same as P_c_g_)
    411       jac_idx_map_ = new Index[nz_full_jac_g_];
    412       Index* jac_c_iRow = new Index[nz_full_jac_g_];
    413       Index* jac_c_jCol = new Index[nz_full_jac_g_];
     453      Index nz_jac_all;
     454      if (fixed_variable_treatment_==MAKE_PARAMETER) {
     455        nz_jac_all = nz_full_jac_g_;
     456      }
     457      else {
     458        nz_jac_all = nz_full_jac_g_ + n_x_fixed_;
     459      }
     460      jac_idx_map_ = new Index[nz_jac_all];
     461      Index* jac_c_iRow = new Index[nz_jac_all];
     462      Index* jac_c_jCol = new Index[nz_jac_all];
    414463      Index current_nz = 0;
    415       for (Index i=0; i<nz_full_jac_g_; i++) {
    416         const Index c_row = c_row_pos[g_iRow[i]-1];
    417         const Index c_col = c_col_pos[g_jCol[i]-1];
    418         if (c_col != -1 && c_row != -1) {
    419           jac_idx_map_[current_nz] = i;
    420           jac_c_iRow[current_nz] = c_row + 1;
    421           jac_c_jCol[current_nz] = c_col + 1;
     464      const Index* c_row_pos = P_c_g_->CompressedPosIndices();
     465      if (IsValid(P_x_full_x_)) {
     466        // there are missing variables x
     467        const Index* c_col_pos = P_x_full_x_->CompressedPosIndices();
     468        for (Index i=0; i<nz_full_jac_g_; i++) {
     469          const Index c_row = c_row_pos[g_iRow[i]-1];
     470          const Index c_col = c_col_pos[g_jCol[i]-1];
     471          if (c_col != -1 && c_row != -1) {
     472            jac_idx_map_[current_nz] = i;
     473            jac_c_iRow[current_nz] = c_row + 1;
     474            jac_c_jCol[current_nz] = c_col + 1;
     475            current_nz++;
     476          }
     477        }
     478      }
     479      else {
     480        for (Index i=0; i<nz_full_jac_g_; i++) {
     481          const Index c_row = c_row_pos[g_iRow[i]-1];
     482          const Index c_col = g_jCol[i]-1;
     483          if (c_row != -1) {
     484            jac_idx_map_[current_nz] = i;
     485            jac_c_iRow[current_nz] = c_row + 1;
     486            jac_c_jCol[current_nz] = c_col + 1;
     487            current_nz++;
     488          }
     489        }
     490      }
     491      nz_jac_c_no_fixed_ = current_nz;
     492      Index n_added_constr;
     493      if (fixed_variable_treatment_==MAKE_PARAMETER) {
     494        nz_jac_c_ = nz_jac_c_no_fixed_;
     495        n_added_constr = 0;
     496      }
     497      else {
     498        nz_jac_c_ = nz_jac_c_no_fixed_ + n_x_fixed_;
     499        for (Index i=0; i<n_x_fixed_; i++) {
     500          jac_c_iRow[current_nz] = n_c + i + 1;
     501          jac_c_jCol[current_nz] = x_fixed_map_[i]+1;
    422502          current_nz++;
    423503        }
    424       }
    425       nz_jac_c_ = current_nz;
    426       Jac_c_space_ = new GenTMatrixSpace(n_c, n_x_not_fixed, nz_jac_c_, jac_c_iRow, jac_c_jCol);
     504        n_added_constr = n_x_fixed_;
     505      }
     506
     507      Jac_c_space_ = new GenTMatrixSpace(n_c+n_added_constr, n_x_var,
     508                                         nz_jac_c_, jac_c_iRow, jac_c_jCol);
    427509      delete [] jac_c_iRow;
    428510      jac_c_iRow = NULL;
     
    430512      jac_c_jCol = NULL;
    431513
    432       const Index* d_col_pos = P_x_full_x_->CompressedPosIndices();
    433       const Index* d_row_pos = P_d_g_->CompressedPosIndices();
    434514      // ... build the nonzero structure for jac_d
    435515      // ... (the permuation from rows in jac_g to jac_c is the
     
    438518      Index* jac_d_jCol = new Index[nz_full_jac_g_];
    439519      current_nz = 0;
    440       for (Index i=0; i<nz_full_jac_g_; i++) {
    441         const Index d_row = d_row_pos[g_iRow[i]-1];
    442         const Index d_col = d_col_pos[g_jCol[i]-1];
    443         if (d_col != -1 && d_row != -1) {
    444           jac_idx_map_[current_nz + nz_jac_c_] = i;
    445           jac_d_iRow[current_nz] = d_row + 1;
    446           jac_d_jCol[current_nz] = d_col + 1;
    447           current_nz++;
     520      const Index* d_row_pos = P_d_g_->CompressedPosIndices();
     521      if (IsValid(P_x_full_x_)) {
     522        const Index* d_col_pos = P_x_full_x_->CompressedPosIndices();
     523        for (Index i=0; i<nz_full_jac_g_; i++) {
     524          const Index d_row = d_row_pos[g_iRow[i]-1];
     525          const Index d_col = d_col_pos[g_jCol[i]-1];
     526          if (d_col != -1 && d_row != -1) {
     527            jac_idx_map_[current_nz + nz_jac_c_no_fixed_] = i;
     528            jac_d_iRow[current_nz] = d_row + 1;
     529            jac_d_jCol[current_nz] = d_col + 1;
     530            current_nz++;
     531          }
     532        }
     533      }
     534      else {
     535        for (Index i=0; i<nz_full_jac_g_; i++) {
     536          const Index d_row = d_row_pos[g_iRow[i]-1];
     537          const Index d_col = g_jCol[i]-1;
     538          if (d_row != -1) {
     539            jac_idx_map_[current_nz + nz_jac_c_no_fixed_] = i;
     540            jac_d_iRow[current_nz] = d_row + 1;
     541            jac_d_jCol[current_nz] = d_col + 1;
     542            current_nz++;
     543          }
    448544        }
    449545      }
    450546      nz_jac_d_ = current_nz;
    451       Jac_d_space_ = new GenTMatrixSpace(n_d, n_x_not_fixed, nz_jac_d_, jac_d_iRow, jac_d_jCol);
     547      Jac_d_space_ = new GenTMatrixSpace(n_d, n_x_var, nz_jac_d_, jac_d_iRow, jac_d_jCol);
    452548      delete [] jac_d_iRow;
    453549      jac_d_iRow = NULL;
     
    475571      }
    476572
    477       h_idx_map_ = new Index[nz_full_h_];
    478       const Index* h_pos = P_x_full_x_->CompressedPosIndices();
    479573      current_nz = 0;
    480       for (Index i=0; i<nz_full_h_; i++) {
    481         const Index h_row = h_pos[full_h_iRow[i]-1];
    482         const Index h_col = h_pos[full_h_jCol[i]-1];
    483         if (h_row != -1 && h_col != -1) {
    484           h_idx_map_[current_nz] = i;
    485           h_iRow[current_nz] = h_row + 1;
    486           h_jCol[current_nz] = h_col + 1;
     574      if (IsValid(P_x_full_x_)) {
     575        h_idx_map_ = new Index[nz_full_h_];
     576        const Index* h_pos = P_x_full_x_->CompressedPosIndices();
     577        for (Index i=0; i<nz_full_h_; i++) {
     578          const Index h_row = h_pos[full_h_iRow[i]-1];
     579          const Index h_col = h_pos[full_h_jCol[i]-1];
     580          if (h_row != -1 && h_col != -1) {
     581            h_idx_map_[current_nz] = i;
     582            h_iRow[current_nz] = h_row + 1;
     583            h_jCol[current_nz] = h_col + 1;
     584            current_nz++;
     585          }
     586        }
     587      }
     588      else {
     589        h_idx_map_ = NULL;
     590        for (Index i=0; i<nz_full_h_; i++) {
     591          const Index h_row = full_h_iRow[i]-1;
     592          const Index h_col = full_h_jCol[i]-1;
     593          h_iRow[i] = h_row + 1;
     594          h_jCol[i] = h_col + 1;
    487595          current_nz++;
    488596        }
     597        current_nz = nz_full_h_;
    489598      }
    490599      nz_h_ = current_nz;
    491       Hess_lagrangian_space_ = new SymTMatrixSpace(n_x_not_fixed, nz_h_, h_iRow, h_jCol);
     600      Hess_lagrangian_space_ = new SymTMatrixSpace(n_x_var, nz_h_, h_iRow, h_jCol);
    492601      delete [] full_h_iRow;
    493602      full_h_iRow = NULL;
     
    519628  }
    520629
    521   bool TNLPAdapter::GetBoundsInformation(Matrix& Px_L,
     630  bool TNLPAdapter::GetBoundsInformation(const Matrix& Px_L,
    522631                                         Vector& x_L,
    523                                          Matrix& Px_U,
     632                                         const Matrix& Px_U,
    524633                                         Vector& x_U,
    525                                          Matrix& Pd_L,
     634                                         const Matrix& Pd_L,
    526635                                         Vector& d_L,
    527                                          Matrix& Pd_U,
     636                                         const Matrix& Pd_U,
    528637                                         Vector& d_U)
    529638  {
     
    538647    tnlp_->get_bounds_info(n_full_x_, x_l, x_u, n_full_g_, g_l, g_u);
    539648
    540     // Set the values of fixed variables
    541     for (Index i=0; i<n_x_fixed_; i++) {
    542       DBG_ASSERT(x_l[x_fixed_map_[i]] == x_u[x_fixed_map_[i]]);
    543       full_x_[x_fixed_map_[i]] = x_l[x_fixed_map_[i]];
     649    if (fixed_variable_treatment_==MAKE_PARAMETER) {
     650      // Set the values of fixed variables
     651      for (Index i=0; i<n_x_fixed_; i++) {
     652        DBG_ASSERT(x_l[x_fixed_map_[i]] == x_u[x_fixed_map_[i]]);
     653        full_x_[x_fixed_map_[i]] = x_l[x_fixed_map_[i]];
     654      }
    544655    }
    545656
     
    548659    DBG_ASSERT(dx_L);
    549660    Number* values = dx_L->Values();
    550     ExpansionMatrix* em_Px_L = dynamic_cast<ExpansionMatrix*>(&Px_L);
     661    const ExpansionMatrix* em_Px_L =
     662      dynamic_cast<const ExpansionMatrix*>(&Px_L);
    551663    DBG_ASSERT(em_Px_L);
    552     for (Index i=0; i<Px_L.NCols(); i++) {
    553       Index ipopt_idx = em_Px_L->ExpandedPosIndices()[i];
    554       Index full_idx = P_x_full_x_->ExpandedPosIndices()[ipopt_idx];
    555       Number lower_bound = x_l[full_idx];
    556       values[i] = lower_bound;
     664    if (IsValid(P_x_full_x_)) {
     665      for (Index i=0; i<Px_L.NCols(); i++) {
     666        const Index ipopt_idx = em_Px_L->ExpandedPosIndices()[i];
     667        const Index full_idx = P_x_full_x_->ExpandedPosIndices()[ipopt_idx];
     668        const Number lower_bound = x_l[full_idx];
     669        values[i] = lower_bound;
     670      }
     671    }
     672    else {
     673      for (Index i=0; i<Px_L.NCols(); i++) {
     674        const Index ipopt_idx = em_Px_L->ExpandedPosIndices()[i];
     675        const Number lower_bound = x_l[ipopt_idx];
     676        values[i] = lower_bound;
     677      }
    557678    }
    558679
     
    560681    DBG_ASSERT(dx_U);
    561682    values = dx_U->Values();
    562     ExpansionMatrix* em_Px_U = dynamic_cast<ExpansionMatrix*>(&Px_U);
     683    const ExpansionMatrix* em_Px_U =
     684      dynamic_cast<const ExpansionMatrix*>(&Px_U);
    563685    DBG_ASSERT(em_Px_U);
    564     for (Index i=0; i<Px_U.NCols(); i++) {
    565       Index ipopt_idx = em_Px_U->ExpandedPosIndices()[i];
    566       Index full_idx = P_x_full_x_->ExpandedPosIndices()[ipopt_idx];
    567       Number upper_bound = x_u[full_idx];
    568       values[i] = upper_bound;
     686    if (IsValid(P_x_full_x_)) {
     687      for (Index i=0; i<Px_U.NCols(); i++) {
     688        const Index ipopt_idx = em_Px_U->ExpandedPosIndices()[i];
     689        const Index full_idx = P_x_full_x_->ExpandedPosIndices()[ipopt_idx];
     690        const Number upper_bound = x_u[full_idx];
     691        values[i] = upper_bound;
     692      }
     693    }
     694    else {
     695      for (Index i=0; i<Px_U.NCols(); i++) {
     696        const Index ipopt_idx = em_Px_U->ExpandedPosIndices()[i];
     697        const Number upper_bound = x_u[ipopt_idx];
     698        values[i] = upper_bound;
     699      }
    569700    }
    570701
     
    577708      c_rhs_[i] = rhs;
    578709    }
     710    // similarly, if we have fixed variables, consider them here
     711    if (fixed_variable_treatment_==MAKE_CONSTRAINT) {
     712      Index n_c_no_fixed = P_c_g_->NCols();
     713      for (Index i=0; i<n_x_fixed_; i++) {
     714        DBG_ASSERT(x_l[x_fixed_map_[i]]==x_u[x_fixed_map_[i]]);
     715        c_rhs_[n_c_no_fixed+i] = x_l[x_fixed_map_[i]];
     716      }
     717    }
    579718
    580719    // get the bounds values for d
     
    582721    DBG_ASSERT(dd_L);
    583722    values = dd_L->Values();
    584     ExpansionMatrix* em_Pd_L = dynamic_cast<ExpansionMatrix*>(&Pd_L);
     723    const ExpansionMatrix* em_Pd_L =
     724      dynamic_cast<const ExpansionMatrix*>(&Pd_L);
    585725    DBG_ASSERT(em_Pd_L);
    586726    for (Index i=0; i<Pd_L.NCols(); i++) {
     
    594734    DBG_ASSERT(dd_U);
    595735    values = dd_U->Values();
    596     ExpansionMatrix* em_Pd_U = dynamic_cast<ExpansionMatrix*>(&Pd_U);
     736    const ExpansionMatrix* em_Pd_U =
     737      dynamic_cast<const ExpansionMatrix*>(&Pd_U);
    597738    DBG_ASSERT(em_Pd_U);
    598739    for (Index i=0; i<Pd_U.NCols(); i++) {
     
    646787      DBG_ASSERT(dx);
    647788      Number* values = dx->Values();
    648       const Index* x_pos = P_x_full_x_->ExpandedPosIndices();
    649       for (Index i=0; i<x->Dim(); i++) {
    650         values[i] = full_x[x_pos[i]];
     789      if (IsValid(P_x_full_x_)) {
     790        const Index* x_pos = P_x_full_x_->ExpandedPosIndices();
     791        for (Index i=0; i<x->Dim(); i++) {
     792          values[i] = full_x[x_pos[i]];
     793        }
     794      }
     795      else {
     796        IpBlasDcopy(x->Dim(), full_x, 1, values, 1);
    651797      }
    652798    }
     
    657803      Number* values = dy_c->Values();
    658804      const Index* y_c_pos = P_c_g_->ExpandedPosIndices();
    659       for (Index i=0; i<y_c->Dim(); i++) {
     805      for (Index i=0; i<P_c_g_->NCols(); i++) {
    660806        values[i] = full_lambda[y_c_pos[i]];
     807      }
     808      if (fixed_variable_treatment_==MAKE_CONSTRAINT) {
     809        // ToDo maybe use info from z_L and Z_U here?
     810        const Number zero = 0.;
     811        IpBlasDcopy(n_x_fixed_, &zero, 0, &values[P_c_g_->NCols()], 1);
    661812      }
    662813    }
     
    676827      DBG_ASSERT(dz_l);
    677828      Number* values = dz_l->Values();
    678       const Index* x_pos = P_x_full_x_->ExpandedPosIndices();
    679829      const Index* z_l_pos = P_x_x_L_->ExpandedPosIndices();
    680       for (Index i=0; i<z_L->Dim(); i++) {
    681         Index idx = z_l_pos[i]; // convert from x_L to x (ipopt)
    682         idx = x_pos[idx]; // convert from x (ipopt) to x_full
    683         values[i] = full_z_l[idx];
     830      if (IsValid(P_x_full_x_)) {
     831        const Index* x_pos = P_x_full_x_->ExpandedPosIndices();
     832        for (Index i=0; i<z_L->Dim(); i++) {
     833          Index idx = z_l_pos[i]; // convert from x_L to x (ipopt)
     834          idx = x_pos[idx]; // convert from x (ipopt) to x_full
     835          values[i] = full_z_l[idx];
     836        }
     837      }
     838      else {
     839        for (Index i=0; i<z_L->Dim(); i++) {
     840          Index idx = z_l_pos[i]; // convert from x_L to x (ipopt)
     841          values[i] = full_z_l[idx];
     842        }
    684843      }
    685844    }
     
    689848      DBG_ASSERT(dz_u);
    690849      Number* values = dz_u->Values();
    691       const Index* x_pos = P_x_full_x_->ExpandedPosIndices();
    692850      const Index* z_u_pos = P_x_x_U_->ExpandedPosIndices();
    693       for (Index i=0; i<z_U->Dim(); i++) {
    694         Index idx = z_u_pos[i]; // convert from x_u to x (ipopt)
    695         idx = x_pos[idx]; // convert from x (ipopt) to x_full
    696         values[i] = full_z_u[idx];
     851      if (IsValid(P_x_full_x_)) {
     852        const Index* x_pos = P_x_full_x_->ExpandedPosIndices();
     853        for (Index i=0; i<z_U->Dim(); i++) {
     854          Index idx = z_u_pos[i]; // convert from x_u to x (ipopt)
     855          idx = x_pos[idx]; // convert from x (ipopt) to x_full
     856          values[i] = full_z_u[idx];
     857        }
     858      }
     859      else {
     860        for (Index i=0; i<z_U->Dim(); i++) {
     861          Index idx = z_u_pos[i]; // convert from x_u to x (ipopt)
     862          values[i] = full_z_u[idx];
     863        }
    697864      }
    698865    }
     
    727894    }
    728895
    729     Number* full_grad_f = new Number[n_full_x_];
    730     if (tnlp_->eval_grad_f(n_full_x_, full_x_, new_x, full_grad_f)) {
    731       const Index* x_pos = P_x_full_x_->ExpandedPosIndices();
     896    if (IsValid(P_x_full_x_)) {
     897      Number* full_grad_f = new Number[n_full_x_];
     898      if (tnlp_->eval_grad_f(n_full_x_, full_x_, new_x, full_grad_f)) {
     899        const Index* x_pos = P_x_full_x_->ExpandedPosIndices();
     900        DenseVector* dg_f = dynamic_cast<DenseVector*>(&g_f);
     901        DBG_ASSERT(dg_f);
     902        Number* values = dg_f->Values();
     903
     904        for (Index i=0; i<g_f.Dim(); i++) {
     905          values[i] = full_grad_f[x_pos[i]];
     906        }
     907        retvalue = true;
     908      }
     909      delete [] full_grad_f;
     910    }
     911    else {
    732912      DenseVector* dg_f = dynamic_cast<DenseVector*>(&g_f);
    733913      DBG_ASSERT(dg_f);
    734914      Number* values = dg_f->Values();
    735 
    736       for (Index i=0; i<g_f.Dim(); i++) {
    737         values[i] = full_grad_f[x_pos[i]];
    738       }
    739       retvalue = true;
    740     }
    741 
    742     delete [] full_grad_f;
     915      retvalue = tnlp_->eval_grad_f(n_full_x_, full_x_, new_x, values);
     916    }
     917
    743918    return retvalue;
    744919  }
     
    756931    if (internal_eval_g(new_x)) {
    757932      const Index* c_pos = P_c_g_->ExpandedPosIndices();
    758       for (Index i=0; i<c.Dim(); i++) {
     933      Index n_c_no_fixed = P_c_g_->NCols();
     934      for (Index i=0; i<n_c_no_fixed; i++) {
    759935        values[i] = full_g_[c_pos[i]];
    760936        values[i] -= c_rhs_[i];
     937      }
     938      if (fixed_variable_treatment_==MAKE_CONSTRAINT) {
     939        for (Index i=0; i<n_x_fixed_; i++) {
     940          values[n_c_no_fixed+i] =
     941            full_x_[x_fixed_map_[i]] - c_rhs_[n_c_no_fixed+i];
     942        }
    761943      }
    762944      return true;
     
    778960      Number* values = gt_jac_c->Values();
    779961
    780       for (Index i=0; i<nz_jac_c_; i++) {
     962      for (Index i=0; i<nz_jac_c_no_fixed_; i++) {
    781963        // Assume the same structure as initially given
    782964        values[i] = jac_g_[jac_idx_map_[i]];
     965      }
     966      if (fixed_variable_treatment_==MAKE_CONSTRAINT) {
     967        const Number one = 1.;
     968        IpBlasDcopy(n_x_fixed_, &one, 0, &values[nz_jac_c_no_fixed_], 1);
    783969      }
    784970      return true;
     
    8221008      for (Index i=0; i<nz_jac_d_; i++) {
    8231009        // Assume the same structure as initially given
    824         values[i] = jac_g_[jac_idx_map_[nz_jac_c_ + i]];
     1010        values[i] = jac_g_[jac_idx_map_[nz_jac_c_no_fixed_ + i]];
    8251011      }
    8261012      return true;
     
    8591045    }
    8601046
    861     Number* full_h = new Number[nz_full_h_];
    862 
    863     if (tnlp_->eval_h(n_full_x_, full_x_, new_x, obj_factor, n_full_g_,
    864                       full_lambda_, new_y, nz_full_h_, NULL, NULL, full_h)) {
    865       SymTMatrix* st_h = dynamic_cast<SymTMatrix*>(&h);
    866       DBG_ASSERT(st_h);
    867       Number* values = st_h->Values();
    868       for (Index i=0; i<nz_h_; i++) {
    869         values[i] = full_h[h_idx_map_[i]];
    870       }
    871       retval = true;
    872     }
    873 
    874     delete [] full_h;
     1047    SymTMatrix* st_h = dynamic_cast<SymTMatrix*>(&h);
     1048    DBG_ASSERT(st_h);
     1049    Number* values = st_h->Values();
     1050
     1051    if (h_idx_map_) {
     1052      Number* full_h = new Number[nz_full_h_];
     1053
     1054      if (tnlp_->eval_h(n_full_x_, full_x_, new_x, obj_factor, n_full_g_,
     1055                        full_lambda_, new_y, nz_full_h_, NULL, NULL, full_h)) {
     1056        for (Index i=0; i<nz_h_; i++) {
     1057          values[i] = full_h[h_idx_map_[i]];
     1058        }
     1059        retval = true;
     1060      }
     1061      delete [] full_h;
     1062    }
     1063    else {
     1064      retval = tnlp_->eval_h(n_full_x_, full_x_, new_x, obj_factor, n_full_g_,
     1065                             full_lambda_, new_y, nz_full_h_, NULL, NULL,
     1066                             values);
     1067    }
     1068
    8751069    return retval;
    8761070  }
     
    8851079    SmartPtr<Vector>& d_scaling) const
    8861080  {
    887     x_scaling = x_space->MakeNew();
    888     c_scaling = c_space->MakeNew();
    889     d_scaling = d_space->MakeNew();
    890     DBG_ASSERT((c_scaling->Dim()+d_scaling->Dim()) == n_full_g_);
    891     Number* full_x_scaling = new Number[n_full_x_];
    892     Number* full_g_scaling = new Number[n_full_g_];
    893     tnlp_->get_scaling_parameters(obj_scaling,
    894                                   n_full_x_, full_x_scaling,
    895                                   n_full_g_, full_g_scaling);
    896 
    8971081    DenseVector* dx = dynamic_cast<DenseVector*>(GetRawPtr(x_scaling));
    8981082    DenseVector* dc = dynamic_cast<DenseVector*>(GetRawPtr(c_scaling));
     
    9031087    Number* dd_values = dd->Values();
    9041088
    905     const Index* x_pos = P_x_full_x_->ExpandedPosIndices();
    906     for (Index i=0; i<dx->Dim(); i++) {
    907       dx_values[i] = full_x_scaling[x_pos[i]];
    908     }
     1089    x_scaling = x_space->MakeNew();
     1090    c_scaling = c_space->MakeNew();
     1091    d_scaling = d_space->MakeNew();
     1092    DBG_ASSERT((c_scaling->Dim()+d_scaling->Dim()) == n_full_g_);
     1093    Number* full_g_scaling = new Number[n_full_g_];
     1094
     1095    if (IsValid(P_x_full_x_)) {
     1096      Number* full_x_scaling = new Number[n_full_x_];
     1097      tnlp_->get_scaling_parameters(obj_scaling,
     1098                                    n_full_x_, full_x_scaling,
     1099                                    n_full_g_, full_g_scaling);
     1100
     1101      const Index* x_pos = P_x_full_x_->ExpandedPosIndices();
     1102      for (Index i=0; i<dx->Dim(); i++) {
     1103        dx_values[i] = full_x_scaling[x_pos[i]];
     1104      }
     1105      delete [] full_x_scaling;
     1106    }
     1107    else {
     1108      tnlp_->get_scaling_parameters(obj_scaling,
     1109                                    n_full_x_, dx_values,
     1110                                    n_full_g_, full_g_scaling);
     1111    }
     1112
    9091113    const Index* c_pos = P_c_g_->ExpandedPosIndices();
    910     for (Index i=0; i<dc->Dim(); i++) {
     1114    for (Index i=0; i<P_c_g_->NCols(); i++) {
    9111115      dc_values[i] = full_g_scaling[c_pos[i]];
     1116    }
     1117    if (fixed_variable_treatment_==MAKE_CONSTRAINT) {
     1118      const Number one = 1.;
     1119      IpBlasDcopy(n_x_fixed_, &one, 0, &dc_values[P_c_g_->NCols()], 1);
    9121120    }
    9131121
     
    9171125    }
    9181126
    919     delete [] full_x_scaling;
    9201127    delete [] full_g_scaling;
    9211128  }
     
    9461153    }
    9471154    ResortBnds(z_L, full_z_L, z_U, full_z_U);
     1155
     1156    // Hopefully the following is correct to recover the bound
     1157    // multipliers for fixed variables (sign ok?)
     1158    if (fixed_variable_treatment_==MAKE_CONSTRAINT && n_x_fixed_>0) {
     1159      const DenseVector* dy_c = dynamic_cast<const DenseVector*>(&y_c);
     1160      DBG_ASSERT(dy_c);
     1161      DBG_ASSERT(!dy_c->IsHomogeneous());
     1162      const Number* values = dy_c->Values();
     1163      Index n_c_no_fixed = y_c.Dim() - n_x_fixed_;
     1164      for (Index i=0; i<n_x_fixed_; i++) {
     1165        full_z_L[x_fixed_map_[i]] = Max(0., -values[n_c_no_fixed+i]);
     1166        full_z_U[x_fixed_map_[i]] = Max(0., values[n_c_no_fixed+i]);
     1167      }
     1168    }
    9481169
    9491170    tnlp_->finalize_solution(status,
     
    9651186    DBG_ASSERT(dx);
    9661187
    967     const Index* x_pos = P_x_full_x_->CompressedPosIndices();
    968 
    969     if (dx->IsHomogeneous()) {
    970       Number scalar = dx->Scalar();
    971       for (Index i=0; i<n_full_x_; i++) {
    972         Index idx = x_pos[i];
    973         if (idx != -1) {
    974           x_orig[i] = scalar;
    975         }
    976         else {
    977           x_orig[i] = full_x_[i];
     1188    if (IsValid(P_x_full_x_)) {
     1189      const Index* x_pos = P_x_full_x_->CompressedPosIndices();
     1190
     1191      if (dx->IsHomogeneous()) {
     1192        Number scalar = dx->Scalar();
     1193        for (Index i=0; i<n_full_x_; i++) {
     1194          Index idx = x_pos[i];
     1195          if (idx != -1) {
     1196            x_orig[i] = scalar;
     1197          }
     1198          else {
     1199            x_orig[i] = full_x_[i];
     1200          }
     1201        }
     1202      }
     1203      else {
     1204        const Number* x_values = dx->Values();
     1205        for (Index i=0; i<n_full_x_; i++) {
     1206          Index idx = x_pos[i];
     1207          if (idx != -1) {
     1208            x_orig[i] = x_values[idx];
     1209          }
     1210          else {
     1211            x_orig[i] = full_x_[i];
     1212          }
    9781213        }
    9791214      }
    9801215    }
    9811216    else {
    982       const Number* x_values = dx->Values();
    983       for (Index i=0; i<n_full_x_; i++) {
    984         Index idx = x_pos[i];
    985         if (idx != -1) {
    986           x_orig[i] = x_values[idx];
    987         }
    988         else {
    989           x_orig[i] = full_x_[i];
    990         }
     1217      if (dx->IsHomogeneous()) {
     1218        Number scalar = dx->Scalar();
     1219        IpBlasDcopy(n_full_x_, &scalar, 0, x_orig, 1);
     1220      }
     1221      else {
     1222        IpBlasDcopy(n_full_x_, dx->Values(), 1, x_orig, 1);
    9911223      }
    9921224    }
     
    10011233    if (dc->IsHomogeneous()) {
    10021234      Number scalar = dc->Scalar();
    1003       for (Index i=0; i<c.Dim(); i++) {
     1235      for (Index i=0; i<P_c_g_->NCols(); i++) {
    10041236        g_orig[c_pos[i]] = scalar;
    10051237      }
     
    10071239    else {
    10081240      const Number* c_values = dc->Values();
    1009       for (Index i=0; i<c.Dim(); i++) {
     1241      for (Index i=0; i<P_c_g_->NCols(); i++) {
    10101242        g_orig[c_pos[i]] = c_values[i];
    10111243      }
     
    10381270
    10391271      const Index* bnds_pos_not_fixed = P_x_x_L_->ExpandedPosIndices();
    1040       const Index* bnds_pos_full = P_x_full_x_->ExpandedPosIndices();
    1041 
    1042       if (dx_L->IsHomogeneous()) {
    1043         Number scalar = dx_L->Scalar();
    1044         for (Index i=0; i<x_L.Dim(); i++) {
    1045           int idx = bnds_pos_not_fixed[i];
    1046           idx = bnds_pos_full[idx];
    1047           x_L_orig[idx] = scalar;
     1272
     1273      if (IsValid(P_x_full_x_)) {
     1274        const Index* bnds_pos_full = P_x_full_x_->ExpandedPosIndices();
     1275        if (dx_L->IsHomogeneous()) {
     1276          Number scalar = dx_L->Scalar();
     1277          for (Index i=0; i<x_L.Dim(); i++) {
     1278            int idx = bnds_pos_not_fixed[i];
     1279            idx = bnds_pos_full[idx];
     1280            x_L_orig[idx] = scalar;
     1281          }
     1282        }
     1283        else {
     1284          const Number* x_L_values = dx_L->Values();
     1285          for (Index i=0; i<x_L.Dim(); i++) {
     1286            int idx = bnds_pos_not_fixed[i];
     1287            idx = bnds_pos_full[idx];
     1288            x_L_orig[idx] = x_L_values[i];
     1289          }
    10481290        }
    10491291      }
    10501292      else {
    1051         const Number* x_L_values = dx_L->Values();
    1052         for (Index i=0; i<x_L.Dim(); i++) {
    1053           int idx = bnds_pos_not_fixed[i];
    1054           idx = bnds_pos_full[idx];
    1055           x_L_orig[idx] = x_L_values[i];
     1293        if (dx_L->IsHomogeneous()) {
     1294          Number scalar = dx_L->Scalar();
     1295          for (Index i=0; i<x_L.Dim(); i++) {
     1296            int idx = bnds_pos_not_fixed[i];
     1297            x_L_orig[idx] = scalar;
     1298          }
     1299        }
     1300        else {
     1301          const Number* x_L_values = dx_L->Values();
     1302          for (Index i=0; i<x_L.Dim(); i++) {
     1303            int idx = bnds_pos_not_fixed[i];
     1304            x_L_orig[idx] = x_L_values[i];
     1305          }
    10561306        }
    10571307      }
     
    10631313
    10641314      const Index* bnds_pos_not_fixed = P_x_x_U_->ExpandedPosIndices();
    1065       const Index* bnds_pos_full = P_x_full_x_->ExpandedPosIndices();
    1066 
    1067       if (dx_U->IsHomogeneous()) {
    1068         Number scalar = dx_U->Scalar();
    1069         for (Index i=0; i<x_U.Dim(); i++) {
    1070           int idx = bnds_pos_not_fixed[i];
    1071           idx = bnds_pos_full[idx];
    1072           x_U_orig[idx] = scalar;
     1315
     1316      if (IsValid(P_x_full_x_)) {
     1317        const Index* bnds_pos_full = P_x_full_x_->ExpandedPosIndices();
     1318        if (dx_U->IsHomogeneous()) {
     1319          Number scalar = dx_U->Scalar();
     1320          for (Index i=0; i<x_U.Dim(); i++) {
     1321            int idx = bnds_pos_not_fixed[i];
     1322            idx = bnds_pos_full[idx];
     1323            x_U_orig[idx] = scalar;
     1324          }
     1325        }
     1326        else {
     1327          const Number* x_U_values = dx_U->Values();
     1328          for (Index i=0; i<x_U.Dim(); i++) {
     1329            int idx = bnds_pos_not_fixed[i];
     1330            idx = bnds_pos_full[idx];
     1331            x_U_orig[idx] = x_U_values[i];
     1332          }
    10731333        }
    10741334      }
    10751335      else {
    1076         const Number* x_U_values = dx_U->Values();
    1077         for (Index i=0; i<x_U.Dim(); i++) {
    1078           int idx = bnds_pos_not_fixed[i];
    1079           idx = bnds_pos_full[idx];
    1080           x_U_orig[idx] = x_U_values[i];
     1336        if (dx_U->IsHomogeneous()) {
     1337          Number scalar = dx_U->Scalar();
     1338          for (Index i=0; i<x_U.Dim(); i++) {
     1339            int idx = bnds_pos_not_fixed[i];
     1340            x_U_orig[idx] = scalar;
     1341          }
     1342        }
     1343        else {
     1344          const Number* x_U_values = dx_U->Values();
     1345          for (Index i=0; i<x_U.Dim(); i++) {
     1346            int idx = bnds_pos_not_fixed[i];
     1347            x_U_orig[idx] = x_U_values[i];
     1348          }
    10811349        }
    10821350      }
  • branches/dev/Interfaces/IpTNLPAdapter.hpp

    r517 r522  
    6666
    6767    /** Method for obtaining the bounds information */
    68     virtual bool GetBoundsInformation(Matrix& Px_L,
     68    virtual bool GetBoundsInformation(const Matrix& Px_L,
    6969                                      Vector& x_L,
    70                                       Matrix& Px_U,
     70                                      const Matrix& Px_U,
    7171                                      Vector& x_U,
    72                                       Matrix& Pd_L,
     72                                      const Matrix& Pd_L,
    7373                                      Vector& d_L,
    74                                       Matrix& Pd_U,
     74                                      const Matrix& Pd_U,
    7575                                      Vector& d_U);
    7676
     
    130130    //@}
    131131
    132     /** @name Methods for translating data for IpoptNLP into the TNLP
    133      *  data.  These methods can be used to obtain the current (or
    134      *  final) data for the TNLP formulation from the IpoptNLP
    135      *  structure. */
    136     //@{
    137     /** Sort the primal variables, and add the fixed values in x */
    138     void ResortX(const Vector& x, Number* x_orig);
    139     void ResortG(const Vector& c, const Vector& d, Number *g_orig);
    140     void ResortBnds(const Vector& x_L, Number* x_L_orig,
    141                     const Vector& x_U, Number* x_U_orig);
    142     //@}
     132    /** Enum for treatment of fixed variables option */
     133    enum FixedVariableTreatmentEnum {
     134      MAKE_PARAMETER=0,
     135      MAKE_CONSTRAINT
     136    };
    143137
    144138    /** Enum for specifying which derivative test is to be performed. */
     
    148142      SECOND_ORDER_TEST
    149143    };
     144
    150145    /** Method for performing the derivative test */
    151146    bool CheckDerivatives(DerivativeTestEnum deriv_test);
     
    178173    //@}
    179174
     175    /** @name Methods for translating data for IpoptNLP into the TNLP
     176     *  data.  These methods are used to obtain the current (or
     177     *  final) data for the TNLP formulation from the IpoptNLP
     178     *  structure. */
     179    //@{
     180    /** Sort the primal variables, and add the fixed values in x */
     181    void ResortX(const Vector& x, Number* x_orig);
     182    void ResortG(const Vector& c, const Vector& d, Number *g_orig);
     183    void ResortBnds(const Vector& x_L, Number* x_L_orig,
     184                    const Vector& x_U, Number* x_U_orig);
     185    //@}
     186
    180187    /** Pointer to the TNLP class (class specific to Number* vectors and
    181188     *  harwell triplet matrices) */
     
    191198    /** Value for a upper bound that denotes infinity */
    192199    Number nlp_upper_bound_inf_;
     200    /** Flag indicating how fixed variables should be handled */
     201    FixedVariableTreatmentEnum fixed_variable_treatment_;
    193202    /* Maximal slack for one-sidedly bounded variables.  If a
    194203     *  variable has only one bound, say a lower bound xL, then an
     
    220229    /** non-zeros of the jacobian of c */
    221230    Index nz_jac_c_;
     231    /** non-zeros of the jacobian of c without added constraints for
     232     *  fixed variables. */
     233    Index nz_jac_c_no_fixed_;
    222234    /** non-zeros of the jacobian of d */
    223235    Index nz_jac_d_;
  • branches/dev/configure

    r520 r522  
    98829882    done
    98839883    ASLMAKEFLAGS="CFLAGS=\"$bla $asladdcflags\""
     9884
     9885#   Somehow, -qtune=auto makes ASL segfault on AIX compiler, so take them out
     9886    case $CC in
     9887      xlc* | */xlc* | mpxlc* | */mpxlc*)
     9888        ASLMAKEFLAGS=`echo $ASLMAKEFLAGS | sed 's/-qtune=auto//g' | sed 's/-qarch=auto//g' | sed 's/-qcache=auto//g'`
     9889      ;;
     9890    esac
    98849891
    98859892    echo "$as_me:$LINENO: checking whether $am_make is the GNU make" >&5
  • branches/dev/configure.ac

    r520 r522  
    11531153    ASLMAKEFLAGS="CFLAGS=\"$bla $asladdcflags\""
    11541154
     1155#   Somehow, -qtune=auto makes ASL segfault on AIX compiler, so take them out
     1156    case $CC in
     1157      xlc* | */xlc* | mpxlc* | */mpxlc*)
     1158        ASLMAKEFLAGS=`echo $ASLMAKEFLAGS | sed 's/-qtune=auto//g' | sed 's/-qarch=auto//g' | sed 's/-qcache=auto//g'`
     1159      ;;
     1160    esac
     1161
    11551162    AC_MSG_CHECKING([whether $am_make is the GNU make])
    11561163    rm -f conftest.mak
Note: See TracChangeset for help on using the changeset viewer.