Changeset 433


Ignore:
Timestamp:
Aug 11, 2005 12:28:35 PM (14 years ago)
Author:
andreasw
Message:
  • implemented new C and Fortran interface
  • added method for open output file to IpoptApplication?
  • only one exception now for invalid option
Location:
branches/dev
Files:
2 added
20 edited

Legend:

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

    r430 r433  
    137137#else
    138138
    139       THROW_EXCEPTION(OptionsList::OPTION_OUT_OF_RANGE,
     139      THROW_EXCEPTION(OPTION_INVALID,
    140140                      "Selected solver Pardiso not available.");
    141141#endif
     
    147147#else
    148148
    149       ASSERT_EXCEPTION(false,
    150                        OptionsList::OPTION_OUT_OF_RANGE,
    151                        "Selected solver TAUCS not available.");
     149      THROW_EXCEPTION(OPTION_INVALID,
     150                      "Selected solver TAUCS not available.");
    152151#endif
    153152
  • branches/dev/Algorithm/IpFilterLineSearch.cpp

    r430 r433  
    263263    options.GetNumericValue("theta_max_fact", theta_max_fact_, prefix);
    264264    options.GetNumericValue("theta_min_fact", theta_min_fact_, prefix);
    265     ASSERT_EXCEPTION(theta_min_fact_ < theta_max_fact_, OptionsList::OPTION_OUT_OF_RANGE,
     265    ASSERT_EXCEPTION(theta_min_fact_ < theta_max_fact_, OPTION_INVALID,
    266266                     "Option \"theta_min_fact\": This value must be larger than 0 and less than theta_max_fact.");
    267267    options.GetNumericValue("eta_phi", eta_phi_, prefix);
     
    275275    options.GetIntegerValue("max_soc", max_soc_, prefix);
    276276    if (max_soc_>0) {
    277       ASSERT_EXCEPTION(IsValid(pd_solver_), OptionsList::OPTION_OUT_OF_RANGE,
     277      ASSERT_EXCEPTION(IsValid(pd_solver_), OPTION_INVALID,
    278278                       "Option \"max_soc\": This option is non-negative, but no linear solver for computing the SOC given to FilterLineSearch object.");
    279279    }
  • branches/dev/Algorithm/IpPDFullSpaceSolver.cpp

    r430 r433  
    8181    options.GetIntegerValue("min_refinement_steps", min_refinement_steps_, prefix);
    8282    options.GetIntegerValue("max_refinement_steps", max_refinement_steps_, prefix);
    83     ASSERT_EXCEPTION(max_refinement_steps_ >= min_refinement_steps_, OptionsList::OPTION_OUT_OF_RANGE,
     83    ASSERT_EXCEPTION(max_refinement_steps_ >= min_refinement_steps_, OPTION_INVALID,
    8484                     "Option \"max_refinement_steps\": This value must be larger than or equal to min_refinement_steps (default 1)");
    8585
    8686    options.GetNumericValue("residual_ratio_max", residual_ratio_max_, prefix);
    8787    options.GetNumericValue("residual_ratio_singular", residual_ratio_singular_, prefix);
    88     ASSERT_EXCEPTION(residual_ratio_singular_ > residual_ratio_max_, OptionsList::OPTION_OUT_OF_RANGE,
     88    ASSERT_EXCEPTION(residual_ratio_singular_ > residual_ratio_max_, OPTION_INVALID,
    8989                     "Option \"residual_ratio_singular\": This value must be larger than residual_ratio_max.");
    9090    options.GetNumericValue("residual_improvement_factor", residual_improvement_factor_, prefix);
  • branches/dev/Algorithm/LinearSolvers/IpMa27TSolverInterface.cpp

    r430 r433  
    8989    options.GetNumericValue("pivtol", pivtol_, prefix);
    9090    if(options.GetNumericValue("pivtolmax", pivtolmax_, prefix)) {
    91       ASSERT_EXCEPTION(pivtolmax_>=pivtol_, OptionsList::OPTION_OUT_OF_RANGE,
     91      ASSERT_EXCEPTION(pivtolmax_>=pivtol_, OPTION_INVALID,
    9292                       "Option \"pivtolmax\": This value must be between pivtol and 1.");
    9393    }
  • branches/dev/Apps/CUTErInterface/CUTErInterface.f

    r40 r433  
    1 C Copyright (C) 2002, Carnegie Mellon University, Dominique Orban and others.
     1C Copyright (C) 2002, 2004, 2005 Carnegie Mellon University,
     2C                                Dominique Orban and others.
    23C All Rights Reserved.
    34C This code is published under the Common Public License.
     
    4344      DOUBLE PRECISION LAM( CUTE_MMAX )
    4445
    45       INTEGER IERR
    46 C
    47 C     Algorithmic Parameters
    48 C
    49       integer OPTIONS, IPNEWOPTS
     46      INTEGER IERR, IPSOLVE
     47
     48      INTEGER IPROBLEM, IPCREATE
     49C64BIT     INTEGER*8 IPROBLEM, IPCREATE
     50C
    5051      integer NELE_JAC, NELE_HESS
    5152
     
    102103      CALL CNAMES(N, M, PNAME, VNAMES, GNAMES)
    103104C
    104 C     Set algorithmic parameters
    105 C
    106       OPTIONS = 0
    107 C
    108105C     Call IPOPT
    109106C
    110       call IPOPT(N, X, X_L, X_U, M, G, G_L, G_U, NELE_JAC, NELE_HESS,
    111      1     F, LAM, Z_L, Z_U, EV_F, EV_G, EV_GRAD_F, EV_JAC_G,
    112      1     EV_HESS, OPTIONS, IDAT, DAT, IERR)
    113       call IPDELOPTS(OPTIONS)
     107      IPROBLEM = IPCREATE(N, X_L, X_U, M, G_L, G_U, NELE_JAC, NELE_HESS,
     108     1     EV_F, EV_G, EV_GRAD_F, EV_JAC_G, EV_HESS)
     109      if (IPROBLEM.eq.0) then
     110         write(*,*) 'Error creating Ipopt Problem.'
     111         stop
     112      endif
     113C
     114      IERR = IPSOLVE(IPROBLEM, X, G, F, LAM, Z_L, Z_U, IDAT, DAT)
     115C
     116      call IPFREE(IPROBLEM)
    114117C
    115118C     Display CUTEr statistics
  • branches/dev/Common/IpJournalist.hpp

    r430 r433  
    128128                        const char* format, ...) const;
    129129
    130     //     /** Method for printing a vector.  This calls the Vector print
    131     //      *  methods for each appropriate Journal.
    132     //      */
    133     //     void PrintVector(EJournalLevel level,
    134     //                      EJournalCategory category,
    135     //                      const std::string& name,
    136     //                      const Vector& vector,
    137     //                      Index indent=0,
    138     //                      std::string prefix="") const;
    139 
    140     //     /** Method for printing a matrix.  This calls the Matrix print
    141     //      *  methods for each appropriate Journal.
    142     //      */
    143     //     void PrintMatrix(EJournalLevel level,
    144     //                      EJournalCategory category,
    145     //                      const std::string& name,
    146     //                      const Matrix& matrix,
    147     //                      Index indent=0,
    148     //                      std::string prefix="") const;
    149 
    150130    /** Method to print a formatted string
    151131     * using the va_list argument. */
     
    295275    }
    296276
    297     //     /** Print vector to the designated output location */
    298     //     void PrintVector(std::string name, const Vector& vector,
    299     //                      Index indent, std::string prefix)
    300     //     {
    301     //       PrintVectorImpl(name, vector, indent, prefix);
    302     //     }
    303 
    304     //     /** Print matrix to the designated output location */
    305     //     void PrintMatrix(const std::string name, const Matrix& matrix,
    306     //                      Index indent, std::string prefix)
    307     //     {
    308     //       PrintMatrixImpl(name, matrix, indent, prefix);
    309     //     }
    310 
    311277    /** Flush output buffer.*/
    312278    void FlushBuffer()
     
    326292    /** Printf to the designated output location */
    327293    virtual void PrintfImpl(const char* pformat, va_list ap)=0;
    328 
    329     //     /** Print vector to the designated output location */
    330     //     virtual void PrintVectorImpl(std::string name, const Vector& vector, Index indent, std::string prefix)=0;
    331 
    332     //     /** Print matrix to the designated output location */
    333     //     virtual void PrintMatrixImpl(const std::string name, const Matrix& matrix, Index indent, std::string prefix)=0;
    334294
    335295    /** Flush output buffer.*/
     
    397357    virtual void PrintfImpl(const char* pformat, va_list ap);
    398358
    399     //     /** Print vector to the designated output location */
    400     //     virtual void PrintVectorImpl(std::string name, const Vector& vector, Index indent, std::string prefix);
    401 
    402     //     /** Print matrix to the designated output location */
    403     //     virtual void PrintMatrixImpl(const std::string name, const Matrix& matrix, Index indent, std::string prefix);
    404 
    405359    /** Flush output buffer.*/
    406360    virtual void FlushBufferImpl();
  • branches/dev/Common/IpOptionsList.cpp

    r430 r433  
    1717{
    1818
    19   void OptionsList::SetValue(const std::string& tag, const std::string& value)
     19  bool OptionsList::SetValue(const std::string& tag, const std::string& value)
    2020  {
    2121    if (IsValid(reg_options_)) {
     
    2323
    2424      if (IsNull(option)) {
    25         std::string msg = "Tried to set Option: " + tag;
    26         msg += ". It is not a valid option. Please check the list of available options.";
    27         THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
     25        if (IsValid(jnlst_)) {
     26          std::string msg = "Tried to set Option: " + tag;
     27          msg += ". It is not a valid option. Please check the list of available options.\n";
     28          jnlst_->Printf(J_ERROR, J_MAIN, msg.c_str());
     29        }
     30        //THROW_EXCEPTION(OPTION_INVALID, msg);
     31        return false;
    2832      }
    2933
    3034      if (option->Type() != OT_String) {
    31         std::string msg = "Tried to set Option: " + tag;
    32         msg += ". It is a valid option, but it is of type ";
    33         if (option->Type() == OT_Number) {
    34           msg += " Number";
    35         }
    36         else if (option->Type() == OT_Integer) {
    37           msg += " Integer";
    38         }
    39         else {
    40           msg += " Unknown";
    41         }
    42         msg += ", not of type String. Please check the documentation for options.";
    43         if (IsValid(jnlst_)) {
    44           option->OutputDescription(*jnlst_);
    45         }
    46         THROW_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE, msg);
     35        if (IsValid(jnlst_)) {
     36          std::string msg = "Tried to set Option: " + tag;
     37          msg += ". It is a valid option, but it is of type ";
     38          if (option->Type() == OT_Number) {
     39            msg += " Number";
     40          }
     41          else if (option->Type() == OT_Integer) {
     42            msg += " Integer";
     43          }
     44          else {
     45            msg += " Unknown";
     46          }
     47          msg += ", not of type String. Please check the documentation for options.\n";
     48          jnlst_->Printf(J_ERROR, J_MAIN, msg.c_str());
     49          option->OutputDescription(*jnlst_);
     50        }
     51        //THROW_EXCEPTION(OPTION_INVALID, msg);
     52        return false;
    4753      }
    4854
    4955      if (!option->IsValidStringSetting(value)) {
    50         std::string msg = "Setting: " + value;
    51         msg += " is not a valid setting for Option: ";
    52         msg += tag;
    53         msg += ". Check the option documentation.";
    54         if (IsValid(jnlst_)) {
    55           option->OutputDescription(*jnlst_);
    56         }
    57         THROW_EXCEPTION(OPTION_OUT_OF_RANGE, msg);
     56        if (IsValid(jnlst_)) {
     57          std::string msg = "Setting: " + value;
     58          msg += " is not a valid setting for Option: ";
     59          msg += tag;
     60          msg += ". Check the option documentation.\n";
     61          jnlst_->Printf(J_ERROR, J_MAIN, msg.c_str());
     62          option->OutputDescription(*jnlst_);
     63        }
     64        //THROW_EXCEPTION(OPTION_INVALID, msg);
     65        return false;
    5866      }
    5967    }
     
    6169    OptionsList::OptionValue optval(lowercase(value));
    6270    options_[lowercase(tag)] = optval;
    63   }
    64 
    65   void OptionsList::SetNumericValue(const std::string& tag, Number value)
     71
     72    return true;
     73  }
     74
     75  bool OptionsList::SetNumericValue(const std::string& tag, Number value)
    6676  {
    6777    char buffer[256];
     
    7282
    7383      if (IsNull(option)) {
    74         std::string msg = "Tried to set Option: " + tag;
    75         msg += ". It is not a valid option. Please check the list of available options.";
    76         THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
     84        if (IsValid(jnlst_)) {
     85          std::string msg = "Tried to set Option: " + tag;
     86          msg += ". It is not a valid option. Please check the list of available options.\n";
     87          jnlst_->Printf(J_ERROR, J_MAIN, msg.c_str());
     88        }
     89        //THROW_EXCEPTION(OPTION_INVALID, msg);
     90        return false;
    7791      }
    7892
    7993      if (option->Type() != OT_Number) {
    80         std::string msg = "Tried to set Option: " + tag;
    81         msg += ". It is a valid option, but it is of type ";
    82         if (option->Type() == OT_String) {
    83           msg += " String";
    84         }
    85         else if (option->Type() == OT_Integer) {
    86           msg += " Integer";
    87         }
    88         else {
    89           msg += " Unknown";
    90         }
    91         msg += ", not of type Number. Please check the documentation for options.";
    92         if (IsValid(jnlst_)) {
    93           option->OutputDescription(*jnlst_);
    94         }
    95         THROW_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE, msg);
     94        if (IsValid(jnlst_)) {
     95          std::string msg = "Tried to set Option: " + tag;
     96          msg += ". It is a valid option, but it is of type ";
     97          if (option->Type() == OT_String) {
     98            msg += " String";
     99          }
     100          else if (option->Type() == OT_Integer) {
     101            msg += " Integer";
     102          }
     103          else {
     104            msg += " Unknown";
     105          }
     106          msg += ", not of type Number. Please check the documentation for options.\n";
     107          jnlst_->Printf(J_ERROR, J_MAIN, msg.c_str());
     108          option->OutputDescription(*jnlst_);
     109        }
     110        //THROW_EXCEPTION(OPTION_INVALID, msg);
     111        return false;
    96112      }
    97113
    98114      if (!option->IsValidNumberSetting(value)) {
    99         std::string msg = "Setting: ";
    100         msg += buffer;
    101         msg += " is not a valid setting for Option: ";
    102         msg += tag;
    103         msg += ". Check the option documentation.";
    104         if (IsValid(jnlst_)) {
    105           option->OutputDescription(*jnlst_);
    106         }
    107         THROW_EXCEPTION(OPTION_OUT_OF_RANGE, msg);
     115        if (IsValid(jnlst_)) {
     116          std::string msg = "Setting: ";
     117          msg += buffer;
     118          msg += " is not a valid setting for Option: ";
     119          msg += tag;
     120          msg += ". Check the option documentation.\n";
     121          jnlst_->Printf(J_ERROR, J_MAIN, msg.c_str());
     122          option->OutputDescription(*jnlst_);
     123        }
     124        //THROW_EXCEPTION(OPTION_INVALID, msg);
     125        return false;
    108126      }
    109127    }
     
    111129    OptionsList::OptionValue optval(buffer);
    112130    options_[lowercase(tag)] = optval;
    113   }
    114 
    115   void OptionsList::SetIntegerValue(const std::string& tag, Index value)
     131
     132    return true;
     133  }
     134
     135  bool OptionsList::SetIntegerValue(const std::string& tag, Index value)
    116136  {
    117137    char buffer[256];
     
    123143      if (IsNull(option)) {
    124144        std::string msg = "Tried to set Option: " + tag;
    125         msg += ". It is not a valid option. Please check the list of available options.";
    126         THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
     145        msg += ". It is not a valid option. Please check the list of available options.\n";
     146        if (IsValid(jnlst_)) {
     147          jnlst_->Printf(J_ERROR, J_MAIN, msg.c_str());
     148        }
     149        //THROW_EXCEPTION(OPTION_INVALID, msg);
     150        return false;
    127151      }
    128152
    129153      if (option->Type() != OT_Integer) {
    130         std::string msg = "Tried to set Option: " + tag;
    131         msg += ". It is a valid option, but it is of type ";
    132         if (option->Type() == OT_String) {
    133           msg += " String";
    134         }
    135         else if (option->Type() == OT_Number) {
    136           msg += " Number";
    137         }
    138         else {
    139           msg += " Unknown";
    140         }
    141         msg += ", not of type Integer. Please check the documentation for options.";
    142         if (IsValid(jnlst_)) {
    143           option->OutputDescription(*jnlst_);
    144         }
    145         THROW_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE, msg);
     154        if (IsValid(jnlst_)) {
     155          std::string msg = "Tried to set Option: " + tag;
     156          msg += ". It is a valid option, but it is of type ";
     157          if (option->Type() == OT_String) {
     158            msg += " String";
     159          }
     160          else if (option->Type() == OT_Number) {
     161            msg += " Number";
     162          }
     163          else {
     164            msg += " Unknown";
     165          }
     166          msg += ", not of type Integer. Please check the documentation for options.\n";
     167          jnlst_->Printf(J_ERROR, J_MAIN, msg.c_str());
     168          option->OutputDescription(*jnlst_);
     169        }
     170        //THROW_EXCEPTION(OPTION_INVALID, msg);
     171        return false;
    146172      }
    147173
    148174      if (!option->IsValidIntegerSetting(value)) {
    149         std::string msg = "Setting: ";
    150         msg += buffer;
    151         msg += " is not a valid setting for Option: ";
    152         msg += tag;
    153         msg += ". Check the option documentation.";
    154         if (IsValid(jnlst_)) {
    155           option->OutputDescription(*jnlst_);
    156         }
    157         THROW_EXCEPTION(OPTION_OUT_OF_RANGE, msg);
     175        if (IsValid(jnlst_)) {
     176          std::string msg = "Setting: ";
     177          msg += buffer;
     178          msg += " is not a valid setting for Option: ";
     179          msg += tag;
     180          msg += ". Check the option documentation.\n";
     181          jnlst_->Printf(J_ERROR, J_MAIN, msg.c_str());
     182          option->OutputDescription(*jnlst_);
     183        }
     184        //THROW_EXCEPTION(OPTION_INVALID, msg);
     185        return false;
    158186      }
    159187    }
     
    161189    OptionsList::OptionValue optval(buffer);
    162190    options_[lowercase(tag)] = optval;
     191
     192    return true;
    163193  }
    164194
     
    175205        std::string msg = "IPOPT tried to get the value of Option: " + tag;
    176206        msg += ". It is not a valid registered option.";
    177         THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
     207        THROW_EXCEPTION(OPTION_INVALID, msg);
    178208      }
    179209
     
    194224          option->OutputDescription(*jnlst_);
    195225        }
    196         THROW_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE, msg);
     226        THROW_EXCEPTION(OPTION_INVALID, msg);
    197227      }
    198228
     
    221251        std::string msg = "IPOPT tried to get the value of Option: " + tag;
    222252        msg += ". It is not a valid registered option.";
    223         THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
     253        THROW_EXCEPTION(OPTION_INVALID, msg);
    224254      }
    225255
     
    240270          option->OutputDescription(*jnlst_);
    241271        }
    242         THROW_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE, msg);
     272        THROW_EXCEPTION(OPTION_INVALID, msg);
    243273      }
    244274
     
    266296    }
    267297    else {
    268       THROW_EXCEPTION(OPTION_OUT_OF_RANGE, "Tried to get a boolean from an option and failed.");
     298      THROW_EXCEPTION(OPTION_INVALID, "Tried to get a boolean from an option and failed.");
    269299      ret = false;
    270300    }
     
    283313        std::string msg = "IPOPT tried to get the value of Option: " + tag;
    284314        msg += ". It is not a valid registered option.";
    285         THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
     315        THROW_EXCEPTION(OPTION_INVALID, msg);
    286316      }
    287317
     
    302332          option->OutputDescription(*jnlst_);
    303333        }
    304         THROW_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE, msg);
     334        THROW_EXCEPTION(OPTION_INVALID, msg);
    305335      }
    306336    }
     
    314344                          "\": Double value expected, but non-numeric value \"" +
    315345                          strvalue+"\" found.\n";
    316         THROW_EXCEPTION(OPTION_VALUE_IS_NONNUMERIC, msg);
     346        THROW_EXCEPTION(OPTION_INVALID, msg);
    317347      }
    318348      value = retval;
     
    336366        std::string msg = "IPOPT tried to get the value of Option: " + tag;
    337367        msg += ". It is not a valid registered option.";
    338         THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
     368        THROW_EXCEPTION(OPTION_INVALID, msg);
    339369      }
    340370
     
    355385          option->OutputDescription(*jnlst_);
    356386        }
    357         THROW_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE, msg);
     387        THROW_EXCEPTION(OPTION_INVALID, msg);
    358388      }
    359389    }
     
    367397                          "\": Integer value expected, but non-integer value \"" +
    368398                          strvalue+"\" found.\n";
    369         THROW_EXCEPTION(OPTION_VALUE_IS_NONINTEGER, msg);
     399        THROW_EXCEPTION(OPTION_INVALID, msg);
    370400      }
    371401      value = retval;
     
    441471          msg += tag;
    442472          msg += ". It is not a valid option. Check the list of available options.";
    443           THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
     473          THROW_EXCEPTION(OPTION_INVALID, msg);
    444474        }
    445475
    446476        if (option->Type() == OT_String) {
    447           SetValue(tag, value);
     477          ASSERT_EXCEPTION(SetValue(tag, value), OPTION_INVALID,
     478                           "Error setting string value read from option file.");
    448479        }
    449480        else if (option->Type() == OT_Number) {
     
    452483          if (*p_end!='\0' && !isspace(*p_end)) {
    453484            std::string msg = "Option \"" + tag +
    454                               "\": Double value expected, but non-numeric value \"" +
     485                              "\": Double value expected, but non-numeric option value \"" +
    455486                              value + "\" found.\n";
    456             THROW_EXCEPTION(OPTION_VALUE_IS_NONNUMERIC, msg);
    457           }
    458           SetNumericValue(tag, retval);
     487            THROW_EXCEPTION(OPTION_INVALID, msg);
     488          }
     489          ASSERT_EXCEPTION(SetNumericValue(tag, retval), OPTION_INVALID,
     490                           "Error setting numeric value read from file.");
    459491        }
    460492        else if (option->Type() == OT_Integer) {
     
    463495          if (*p_end!='\0' && !isspace(*p_end)) {
    464496            std::string msg = "Option \"" + tag +
    465                               "\": Integer value expected, but non-integer value \"" +
     497                              "\": Integer value expected, but non-integer option value \"" +
    466498                              value + "\" found.\n";
    467499            if (IsValid(jnlst_)) {
    468500              option->OutputDescription(*jnlst_);
    469501            }
    470             THROW_EXCEPTION(OPTION_VALUE_IS_NONINTEGER, msg);
    471           }
    472           SetIntegerValue(tag, retval);
     502            THROW_EXCEPTION(OPTION_INVALID, msg);
     503          }
     504          ASSERT_EXCEPTION(SetIntegerValue(tag, retval), OPTION_INVALID,
     505                           "Error setting integer value read from option file.");
    473506        }
    474507        else {
     
    477510      }
    478511      else {
    479         SetValue(tag, value);
     512        ASSERT_EXCEPTION(SetValue(tag, value), OPTION_INVALID,
     513                         "Error setting value read from option file.");
    480514      }
    481515    }
  • branches/dev/Common/IpOptionsList.hpp

    r342 r433  
    2424namespace Ipopt
    2525{
     26  /** Exception that can be used to indicate errors with options */
     27  DECLARE_STD_EXCEPTION(OPTION_INVALID);
     28
    2629  /** This class stores a list of user set options.  Each options is
    2730   *  identified by a case-insensitive keyword (tag).  Its value is
     
    140143    //@}
    141144
    142     /** @name Exceptions that can be used to indicate errors with
    143     options */
    144     //@{
    145     DECLARE_STD_EXCEPTION(OPTION_NOT_REGISTERED);
    146     DECLARE_STD_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE);
    147     DECLARE_STD_EXCEPTION(OPTION_OUT_OF_RANGE);
    148     DECLARE_STD_EXCEPTION(OPTION_VALUE_IS_NONINTEGER);
    149     DECLARE_STD_EXCEPTION(OPTION_VALUE_IS_NONNUMERIC);
    150     //@}
    151 
    152145    /** @name Get / Set Methods */
    153146    //@{
     
    163156    /** @name Methods for setting options */
    164157    //@{
    165     void SetValue(const std::string& tag, const std::string& value);
    166     void SetNumericValue(const std::string& tag, Number value);
    167     void SetIntegerValue(const std::string& tag, Index value);
     158    bool SetValue(const std::string& tag, const std::string& value);
     159    bool SetNumericValue(const std::string& tag, Number value);
     160    bool SetIntegerValue(const std::string& tag, Index value);
    168161    //@}
    169162
  • branches/dev/Examples/Cpp_example/Makefile.in

    r430 r433  
    1313CXXFLAGS = @CXXFLAGS@
    1414
     15# Directory with header files
     16IPOPTINCDIR = @includedir@/ipopt
     17
    1518# Directory with libipopt.a
    16 IPOPTINCDIR = @includedir@/ipopt
    1719IPOPTLIBDIR = @libdir@
    1820exec_prefix = @exec_prefix@
     
    2426
    2527# Necessary Include dirs
    26 IPOPTSRCROOTDIR = $(SRCDIR)/../..
    27 IPOPTINSTALLROOTDIR = @prefix@
    2828INCL =  -I$(IPOPTINCDIR)
    2929
  • branches/dev/Examples/Fortran_example/Makefile.in

    r150 r433  
    1313FFLAGS = @FFLAGS@
    1414
     15# Directory with include file
     16IPOPTINCDIR = @includedir@/ipopt
     17
    1518# Directory with libipopt.a
    1619IPOPTLIBDIR = @libdir@
     
    2124#LIBS = -L$(IPOPTLIBDIR) -lipopt @IPADDLIBS@
    2225LIBS = @ipoptlib@ @IPADDLIBS@ @CXXLIBS@
     26
     27# Necessary Include dirs
     28INCL =  -I$(IPOPTINCDIR)
    2329
    2430# CHANGEME: This should be the name of your executable
     
    4248
    4349clean:
    44         rm -rf $(EXE) $(OBJS)
     50        rm -f $(EXE) $(OBJS) IPOPT.OUT
    4551
    4652.f.o:
    47         $(F77) $(FFLAGS) -c -o $@ `test -f '$<' || echo '$(SRCDIR)/'`$<
     53        $(F77) $(FFLAGS) $(INCL) -c -o $@ `test -f '$<' || echo '$(SRCDIR)/'`$<
    4854
    4955
    5056.f.obj:
    51         $(F77) $(FFLAGS) -c -o $@ `if test -f '$<'; then $(CYGPATH_W) '$<'; else $(CYGPATH_W) '$(SRCDIR)/$<'; fi`
     57        $(F77) $(FFLAGS) $(INCL) -c -o $@ `if test -f '$<'; then $(CYGPATH_W) '$<'; else $(CYGPATH_W) '$(SRCDIR)/$<'; fi`
  • branches/dev/Examples/Fortran_example/example.f

    r28 r433  
    1 C Copyright (C) 2002, Carnegie Mellon University and others.
     1C Copyright (C) 2002, 2004, 2005 Carnegie Mellon University and others.
    22C All Rights Reserved.
    33C This code is published under the Common Public License.
     
    3434      implicit none
    3535C
     36C     include the Ipopt return codes
     37C
     38      include 'IpReturnCodes.inc'
     39C
    3640C     Size of the problem (number of variables and equality constraints)
    3741C
     
    6064      integer IDAT(1)
    6165C
    62 C     Algorithmic Parameters
    63 C
    64       integer OPTIONS, IPNEWOPTS
    65 C
    66       integer i, IERR
     66C     Place for storing the Ipopt Problem Handle
     67C
     68      integer IPROBLEM
     69      integer IPCREATE
     70C     for 64 platforms:
     71C64   integer*8 IPROBLEM
     72C64   integer*8 IPCREATE
     73C
     74      integer IERR
     75      integer IPSOLVE, IPADDSTROPTION
     76      integer IPADDNUMOPTION, IPADDINTOPTION
     77      integer IPOPENOUTPUTFILE
     78C
    6779      double precision f
     80      integer i
    6881C
    6982C     Set initial point and bounds:
     
    8497      external EV_F, EV_G, EV_GRAD_F, EV_JAC_G, EV_HESS
    8598C
     99C     First create a handle for the Ipopt problem (and read the options
     100C     file)
     101C
     102      IPROBLEM = IPCREATE(N, X_L, X_U, M, G_L, G_U, NELE_JAC, NELE_HESS,
     103     1     EV_F, EV_G, EV_GRAD_F, EV_JAC_G, EV_HESS)
     104      if (IPROBLEM.eq.0) then
     105         write(*,*) 'Error creating an Ipopt Problem handle.'
     106         stop
     107      endif
     108C
     109C     Open an output file
     110C
     111      IERR = IPOPENOUTPUTFILE(IPROBLEM, 'IPOPT.OUT', 5)
     112      if (IERR.ne.0 ) then
     113         write(*,*) 'Error opening the Ipopt output file.'
     114         goto 9000
     115      endif
     116C
     117C     Set a string option
     118C
     119      IERR = IPADDSTROPTION(IPROBLEM, 'mu_strategy', 'adaptive')
     120      if (IERR.ne.0 ) goto 9990
     121C
     122C     Set an integer option
     123C
     124      IERR = IPADDINTOPTION(IPROBLEM, 'max_iter', 3000)
     125      if (IERR.ne.0 ) goto 9990
     126C
     127C     Set a double precision option
     128C
     129      IERR = IPADDNUMOPTION(IPROBLEM, 'tol', 1.d-9)
     130      if (IERR.ne.0 ) goto 9990
     131C
    86132C     As a simple example, we pass the constants in the constraints to
    87133C     the EVAL_C routine via the "private" DAT array.
     
    90136      DAT(2) = 0.d0
    91137C
    92 C     Call optimization routine:
    93 C
    94       OPTIONS = 0
    95       OPTIONS = IPNEWOPTS()
    96 c      call IPADDINTOPT(OPTIONS, 1, "max_iter")
    97 c      call IPADDOPT(OPTIONS, "1", "max_iter")
    98       call IPOPT(N, X, X_L, X_U, M, G, G_L, G_U, NELE_JAC, NELE_HESS,
    99      1     F, LAM, Z_L, Z_U, EV_F, EV_G, EV_GRAD_F, EV_JAC_G,
    100      1     EV_HESS, OPTIONS, IDAT, DAT, IERR)
    101       call IPDELOPTS(OPTIONS)
     138C     Call optimization routine
     139C
     140      IERR = IPSOLVE(IPROBLEM, X, G, F, LAM, Z_L, Z_U, IDAT, DAT)
    102141C
    103142C     Output:
    104143C
    105       if( IERR.eq.0 ) then
     144      if( IERR.eq.IP_SOLVE_SUCCEEDED ) then
    106145         write(*,*)
    107146         write(*,*) 'The solution was found.'
     
    140179      endif
    141180C
     181 9000 continue
     182C
     183C     Clean up
     184C
     185      call IPFREE(IPROBLEM)
     186      stop
     187C
     188 9990 continue
     189      write(*,*) 'Error setting an option'
     190      goto 9000
    142191      end
    143192C
  • branches/dev/Interfaces/IpIpoptApplication.cpp

    r430 r433  
    1 // Copyright (C) 2004, International Business Machines and others.
     1// Copyright (C) 2004, 2005, International Business Machines and others.
    22// All Rights Reserved.
    33// This code is published under the Common Public License.
     
    102102        file_print_level = print_level;
    103103      }
    104       SmartPtr<Journal> file_jrnl = jnlst_->AddFileJournal("OutputFile", output_filename.c_str(), file_print_level);
    105       file_jrnl->SetPrintLevel(J_DBG, J_NONE);
    106     }
    107 
     104      OpenOutputFile(output_filename, file_print_level);
     105    }
    108106
    109107    // output a description of all the options
     
    148146      "",
    149147      "*", "Any acceptable standard file name",
     148      "NOTE: This option only works when read from PARAMS.DAT options file! "
    150149      "An output file with this name will be written (leave unset for no "
    151150      "file output).  The verbosity level is either \"print_level\", or "
     
    155154      "Verbosity level output file.",
    156155      0, J_LAST_LEVEL-1, J_SUMMARY,
     156      "NOTE: This option only works when read from PARAMS.DAT options file! "
    157157      "Determines the verbosity level for the file specified by "
    158158      "\"output_file\".  By defauly it is the same as \"print_level\".");
     
    329329        retValue = Internal_Error;
    330330        jnlst_->Printf(J_SUMMARY, J_MAIN, "\nEXIT: INTERNAL ERROR: Unknown SolverReturn value - Notify IPOPT Authors.\n");
     331        return retValue;
    331332      }
    332333      ip_nlp->FinalizeSolution(status,
     
    339340      retValue = Not_Enough_Degrees_Of_Freedom;
    340341    }
     342    catch(OPTION_INVALID& exc) {
     343      exc.ReportException(*jnlst_);
     344      retValue = Invalid_Option;
     345    }
    341346    catch(IpoptException& exc) {
    342347      exc.ReportException(*jnlst_);
     
    358363
    359364  }
     365
     366  bool IpoptApplication::OpenOutputFile(std::string file_name,
     367                                        EJournalLevel print_level)
     368  {
     369    SmartPtr<Journal> file_jrnl = jnlst_->AddFileJournal("OutputFile:"+file_name,
     370                                                         file_name.c_str(),
     371                                                         print_level);
     372    file_jrnl->SetPrintLevel(J_DBG, J_NONE);
     373
     374    return true;
     375  }
     376
    360377} // namespace Ipopt
  • branches/dev/Interfaces/IpIpoptApplication.hpp

    r430 r433  
    1717namespace Ipopt
    1818{
    19   /** Return codes for the Optimize call for an application */
    20   enum ApplicationReturnStatus
    21   {
    22     Solve_Succeeded,
    23     Maximum_Iterations_Exceeded,
    24     Solved_To_Best_Possible_Precision,
    25     Solved_To_Acceptable_Level,
    26     Infeasible_Problem_Detected,
    27     Restoration_Failed,
    28     Not_Enough_Degrees_Of_Freedom,
    29     Unrecoverable_Exception,
    30     NonIpopt_Exception_Thrown,
    31     Insufficient_Memory,
    32     Internal_Error
    33   };
     19  /* Return codes for the Optimize call for an application */
     20#include "IpReturnCodes.h"
    3421
    3522  DeclareOptionsRegistrar(IpoptApplication);
     
    7158                                        SmartPtr<IpoptCalculatedQuantities>& ip_cq);
    7259    //@}
     60
     61    /** Method for opening an output file with given print_level.
     62     *  Returns false if there was a problem. */
     63    bool OpenOutputFile(std::string file_name, EJournalLevel print_level);
    7364
    7465    /**@name Accessor methods */
  • branches/dev/Interfaces/IpStdCInterface.cpp

    r430 r433  
    1 // Copyright (C) 2004, International Business Machines and others.
     1// Copyright (C) 2004, 2005, International Business Machines and others.
    22// All Rights Reserved.
    33// This code is published under the Common Public License.
     
    77// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
    88
    9 #include "IpUtils.hpp"
    109#include "IpStdCInterface.h"
    1110#include "IpStdInterfaceTNLP.hpp"
    1211#include "IpOptionsList.hpp"
    1312#include "IpIpoptApplication.hpp"
     13#include "IpBlas.hpp"
    1414
    1515#ifdef OLD_C_HEADERS
     
    1919#endif
    2020
    21 OptionsPtr Ipopt_NewOptions()
     21struct IpoptProblemInfo {
     22  Index n;
     23  Number* x_L;
     24  Number* x_U;
     25  Index m;
     26  Number* g_L;
     27  Number* g_U;
     28  Index nele_jac;
     29  Index nele_hess;
     30  Eval_F_CB eval_f;
     31  Eval_G_CB eval_g;
     32  Eval_Grad_F_CB eval_grad_f;
     33  Eval_Jac_G_CB eval_jac_g;
     34  Eval_H_CB eval_h;
     35  Ipopt::SmartPtr<Ipopt::IpoptApplication> app;
     36};
     37
     38IpoptProblem CreateIpoptProblem(
     39    Index n,
     40    Number* x_L,
     41    Number* x_U,
     42    Index m,
     43    Number* g_L,
     44    Number* g_U,
     45    Index nele_jac,
     46    Index nele_hess,
     47    Eval_F_CB eval_f,
     48    Eval_G_CB eval_g,
     49    Eval_Grad_F_CB eval_grad_f,
     50    Eval_Jac_G_CB eval_jac_g,
     51    Eval_H_CB eval_h)
    2252{
    23   Ipopt::OptionsList* options = new Ipopt::OptionsList();
    24   return (OptionsPtr) options;
     53  // make sure input is Ok
     54  if (n<1 || m<0 || !x_L || !x_U || (m>0 && (!g_L || !g_U)) ||
     55      (m==0 && nele_jac != 0) || (m>0 && nele_jac < 1) || nele_hess < 0 ||
     56      !eval_f || !eval_grad_f || (m>0 && (!eval_g || !eval_jac_g))) {
     57    return NULL;
     58  }
     59
     60  IpoptProblem retval = new IpoptProblemInfo;
     61
     62  retval->n = n;
     63  retval->x_L = new Number[n];
     64  for (Index i=0; i<n; i++) {
     65    retval->x_L[i] = x_L[i];
     66  }
     67  retval->x_U = new Number[n];
     68  for (Index i=0; i<n; i++) {
     69    retval->x_U[i] = x_U[i];
     70  }
     71
     72  retval->m = m;
     73  if (m>0) {
     74    retval->g_L = new Number[m];
     75    for (Index i=0; i<m; i++) {
     76      retval->g_L[i] = g_L[i];
     77    }
     78    retval->g_U = new Number[m];
     79    for (Index i=0; i<m; i++) {
     80      retval->g_U[i] = g_U[i];
     81    }
     82  }
     83  else {
     84    retval->g_L = NULL;
     85    retval->g_U = NULL;
     86  }
     87
     88  retval->nele_jac = nele_jac;
     89  retval->nele_hess = nele_hess;
     90  retval->eval_f = eval_f;
     91  retval->eval_g = eval_g;
     92  retval->eval_grad_f = eval_grad_f;
     93  retval->eval_jac_g = eval_jac_g;
     94  retval->eval_h = eval_h;
     95
     96  retval->app = new Ipopt::IpoptApplication();
     97
     98  return retval;
    2599}
    26100
    27 void Ipopt_DeleteOptions(OptionsPtr options)
     101void FreeIpoptProblem(IpoptProblem ipopt_problem)
    28102{
    29   Ipopt::OptionsList* optlist = (Ipopt::OptionsList*)options;
    30   delete optlist;
     103  delete [] ipopt_problem->x_L;
     104  delete [] ipopt_problem->x_U;
     105  if (ipopt_problem->m>0) {
     106    delete [] ipopt_problem->g_L;
     107    delete [] ipopt_problem->g_U;
     108  }
     109
     110  ipopt_problem->app = NULL;
     111
     112  delete ipopt_problem;
    31113}
    32114
    33 Bool Ipopt_AddOption(OptionsPtr options, char* keyword, char* val)
     115
     116Bool AddIpoptStrOption(IpoptProblem ipopt_problem, char* keyword, char* val)
    34117{
    35   Ipopt::OptionsList* optlist = (Ipopt::OptionsList*)options;
    36118  std::string tag(keyword);
    37119  std::string value(val);
    38 
    39   optlist->SetValue(tag, value);
    40 
    41   return (Bool)true;
     120  return (Bool) ipopt_problem->app->Options()->SetValue(tag, value);
    42121}
    43122
    44 Bool Ipopt_AddNumOption(OptionsPtr options, char* keyword, Number val)
     123Bool AddIpoptNumOption(IpoptProblem ipopt_problem, char* keyword, Number val)
    45124{
    46   Ipopt::OptionsList* optlist = (Ipopt::OptionsList*)options;
    47125  std::string tag(keyword);
    48126  Ipopt::Number value=val;
    49 
    50   optlist->SetNumericValue(tag, value);
    51 
    52   return (Bool)true;
     127  return (Bool) ipopt_problem->app->Options()->SetNumericValue(tag, value);
    53128}
    54129
    55 Bool Ipopt_AddIntOption(OptionsPtr options, char* keyword, Int val)
     130Bool AddIpoptIntOption(IpoptProblem ipopt_problem, char* keyword, Int val)
    56131{
    57   Ipopt::OptionsList* optlist = (Ipopt::OptionsList*)options;
    58132  std::string tag(keyword);
    59133  Ipopt::Index value=val;
    60 
    61   optlist->SetIntegerValue(tag, value);
    62 
    63   return (Bool)true;
     134  return (Bool) ipopt_problem->app->Options()->SetIntegerValue(tag, value);
    64135}
    65136
    66 Int IpoptSolve(Index n,
    67                Number* x_,
    68                Number* x_L_,
    69                Number* x_U_,
    70                Index m,
    71                Number* g,
    72                Number* g_L_,
    73                Number* g_U_,
    74                Index nele_jac,
    75                Index nele_hess,
    76                Number* obj_val,
    77                Number* mult_g_,
    78                Number* mult_x_L_,
    79                Number* mult_x_U_,
    80                Eval_F_CB eval_f,
    81                Eval_G_CB eval_g,
    82                Eval_Grad_F_CB eval_grad_f,
    83                Eval_Jac_G_CB eval_jac_g,
    84                Eval_H_CB eval_h,
    85                OptionsPtr options_,
    86                UserDataPtr user_data)
     137Bool OpenIpoptOutputFile(IpoptProblem ipopt_problem, char* file_name,
     138                         Int print_level)
     139{
     140  std::string name(file_name);
     141  Ipopt::EJournalLevel level = Ipopt::EJournalLevel(print_level);
     142  return (Bool) ipopt_problem->app->OpenOutputFile(name, level);
     143}
     144
     145enum ApplicationReturnStatus IpoptSolve(
     146    IpoptProblem ipopt_problem,
     147    Number* x,
     148    Number* g,
     149    Number* obj_val,
     150    Number* mult_g,
     151    Number* mult_x_L,
     152    Number* mult_x_U,
     153    UserDataPtr user_data)
    87154{
    88155  using namespace Ipopt;
    89156
    90   // Since those arrays are assumed not to change during the optimization
    91   // make sure we are not accidentially changing them.
    92   const ::Number* x = x_;
    93   const ::Number* x_L = x_L_;
    94   const ::Number* x_U = x_U_;
    95   const ::Number* g_L = g_L_;
    96   const ::Number* g_U = g_U_;
    97   const ::Number* mult_g = mult_g_;
    98   const ::Number* mult_x_L = mult_x_L_;
    99   const ::Number* mult_x_U = mult_x_U_;
    100 
    101   // Create an IpoptApplication
    102   SmartPtr<IpoptApplication> app =
    103     new IpoptApplication();
    104 
    105   // Get the options
    106   OptionsList* options = (OptionsList*) options_;
    107   if (options) {
    108     // Copy the options given by the C interface user to those in the
    109     // Ipopt Application
    110     *app->Options() = *options;
     157  // For now only copy the values of the x's.  When we allow warm
     158  // starts we also need to copy the values of the multipliers
     159  ::Number* start_x = new ::Number[ipopt_problem->n];
     160  for (::Index i=0; i<ipopt_problem->n; i++) {
     161    start_x[i] = x[i];
    111162  }
    112163
    113164  // Create the original nlp
    114   SmartPtr<TNLP> tnlp =
    115     new StdInterfaceTNLP(n, x_L, x_U, m, g_L, g_U, nele_jac,
    116                          nele_hess, x, mult_g, mult_x_L, mult_x_U,
    117                          eval_f, eval_g, eval_grad_f, eval_jac_g, eval_h,
    118                          x_, mult_x_L_, mult_x_U_, g, mult_g_, obj_val, user_data);
     165  SmartPtr<TNLP> tnlp;
    119166
    120   ApplicationReturnStatus status = app->OptimizeTNLP(tnlp);
     167  bool skip_optimize = false;
     168  try {
     169    tnlp = new StdInterfaceTNLP(ipopt_problem->n, ipopt_problem->x_L,
     170                                ipopt_problem->x_U, ipopt_problem->m,
     171                                ipopt_problem->g_L, ipopt_problem->g_U,
     172                                ipopt_problem->nele_jac,
     173                                ipopt_problem->nele_hess,
     174                                start_x, NULL, NULL, NULL,
     175                                ipopt_problem->eval_f, ipopt_problem->eval_g,
     176                                ipopt_problem->eval_grad_f,
     177                                ipopt_problem->eval_jac_g,
     178                                ipopt_problem->eval_h,
     179                                x, mult_x_L, mult_x_U, g, mult_g,
     180                                obj_val, user_data);
     181  }
     182  catch(INVALID_STDINTERFACE_NLP& exc) {
     183    skip_optimize = true;
     184  }
    121185
    122   return (::Int) status;
     186  ApplicationReturnStatus status;
     187  if (!skip_optimize) {
     188    status = ipopt_problem->app->OptimizeTNLP(tnlp);
     189  }
     190  else {
     191    status = Invalid_Problem_Definition;
     192  }
     193
     194  delete [] start_x;
     195
     196  return status;
    123197}
    124198
  • branches/dev/Interfaces/IpStdCInterface.h

    r30 r433  
    11/*************************************************************************
    2    Copyright (C) 2004, International Business Machines and others.
     2   Copyright (C) 2004, 2005 International Business Machines and others.
    33   All Rights Reserved.
    44   This code is published under the Common Public License.
    5 
     5 
    66   $Id$
    7 
     7 
    88   Authors:  Carl Laird, Andreas Waechter     IBM    2004-09-02
    99 *************************************************************************/
     
    1313
    1414#ifdef __cplusplus
    15 extern "C" {
    16 #endif
    17 
    18   /** This has to be same as in IpTypes.hpp */
     15extern "C"
     16{
     17#endif
     18
     19  /** Type for all number.  We need to make sure that this is
     20      identical with what is defined in Common/IpTypes.hpp */
     21  typedef double Number;
     22
     23  /** Type for all incides.  We need to make sure that this is
     24      identical with what is defined in Common/IpTypes.hpp */
    1925  typedef int Index;
    20   /** This has to be same as in IpTypes.hpp */
     26
     27  /** Type for all integers.  We need to make sure that this is
     28      identical with what is defined in Common/IpTypes.hpp */
    2129  typedef int Int;
    22   /** This has to be same as in IpTypes.hpp */
    23   typedef double Number;
     30
     31  /* This includes the SolverReturn enum type */
     32#include "IpReturnCodes.h"
     33
     34  /** Structure collecting all information about the problem
     35   *  definition and solve statistics etc.  This is defined in the
     36   *  source file. */
     37  struct IpoptProblemInfo;
     38
     39  /** Pointer to a Ipopt Problem. */
     40  typedef struct IpoptProblemInfo* IpoptProblem;
     41
     42  /** define a boolean type for C */
    2443  typedef int Bool;
     44#ifndef TRUE
     45# define TRUE (1)
     46#endif
     47#ifndef FALSE
     48# define FALSE (0)
     49#endif
     50
     51  /** A pointer for anything that is to be passed between the called
     52   *  and individual callback function */
    2553  typedef void * UserDataPtr;
    26   typedef void * OptionsPtr;
    2754
    2855  /** Type defining the callback function for evaluating the value of
    29    *  the objective function. */
     56   *  the objective function.  Return value should be set to false if
     57   *  there was a problem doing the evaluation. */
    3058  typedef Bool (*Eval_F_CB)(Index n, Number* x, Bool new_x,
    31                             Number* obj_value, UserDataPtr user_data);
     59                            Number* obj_value, UserDataPtr user_data);
    3260
    3361  /** Type defining the callback function for evaluating the gradient of
    34    *  the objective function. */
     62   *  the objective function.  Return value should be set to false if
     63   *  there was a problem doing the evaluation. */
    3564  typedef Bool (*Eval_Grad_F_CB)(Index n, Number* x, Bool new_x,
    36                                 Number* grad_f, UserDataPtr user_data);
     65                                Number* grad_f, UserDataPtr user_data);
    3766
    3867  /** Type defining the callback function for evaluating the value of
    39    *  the constraint functions. */
     68   *  the constraint functions.  Return value should be set to false if
     69   *  there was a problem doing the evaluation. */
    4070  typedef Bool (*Eval_G_CB)(Index n, Number* x, Bool new_x,
    41                             Index m, Number* g, UserDataPtr user_data);
     71                            Index m, Number* g, UserDataPtr user_data);
    4272
    4373  /** Type defining the callback function for evaluating the Jacobian of
    44    *  the constrant functions */
     74   *  the constrant functions.  Return value should be set to false if
     75   *  there was a problem doing the evaluation. */
    4576  typedef Bool (*Eval_Jac_G_CB)(Index n, Number *x, Bool new_x,
    46                                 Index m, Index nele_jac,
    47                                 Index *iRow, Index *jCol, Number *values,
    48                                 UserDataPtr user_data);
     77                                Index m, Index nele_jac,
     78                                Index *iRow, Index *jCol, Number *values,
     79                                UserDataPtr user_data);
    4980
    5081  /** Type defining the callback function for evaluating the Hessian of
    51    *  the Lagrangian function */
     82   *  the Lagrangian function.  Return value should be set to false if
     83   *  there was a problem doing the evaluation. */
    5284  typedef Bool (*Eval_H_CB)(Index n, Number *x, Bool new_x, Number obj_factor,
    53                             Index m, Number *lambda, Bool new_lambda,
    54                             Index nele_hess, Index *iRow, Index *jCol,
    55                             Number *values, UserDataPtr user_data);
    56 
    57   /** Function for creating a new Options Object */
    58   OptionsPtr Ipopt_NewOptions(void);
    59 
    60   /** Function for deleting an Options Object */
    61   void Ipopt_DeleteOptions(OptionsPtr options);
    62 
    63   /** Function for adding a string option */
    64   Bool Ipopt_AddOption(OptionsPtr options, char* keyword, char* val);
    65 
    66   /** Function for adding a Number option */
    67   Bool Ipopt_AddNumOption(OptionsPtr options, char* keyword, Number val);
    68 
    69   /** Function for adding an Int option */
    70   Bool Ipopt_AddIntOption(OptionsPtr options, char* keyword, Int val);
    71 
    72   /** Main IPOPT function.  This is the main entrance point for the
    73    *  standard C interface.  Returns error code (0 = success)
     85                            Index m, Number *lambda, Bool new_lambda,
     86                            Index nele_hess, Index *iRow, Index *jCol,
     87                            Number *values, UserDataPtr user_data);
     88
     89  /** Function for creating a new Ipopt Problem object.  This function
     90   *  returns an object that can be passed to the IpoptSolve call.  It
     91   *  contains the basic definition of the optimization problem, such
     92   *  as number of variables and constraints, bounds on variables and
     93   *  constraints, information about the derivatives, and the callback
     94   *  function for the computation of the optimization problem
     95   *  functions and derivatives.  During this call, the options file
     96   *  PARAMS.DAT is read as well.
     97   *
     98   *  If NULL is returned, there was a problem with one of the inputs
     99   *  or reading the options file. */
     100  IpoptProblem CreateIpoptProblem(
     101      Index n             /** Number of optimization variables */
     102    , Number* x_L         /** Lower bounds on variables. This array of
     103                              size n is copied internally, so that the
     104                              caller can change the incoming data after
     105                              return without that IpoptProblem is
     106                              modified.  Any value less or equal than
     107                              the number specified by option
     108                              'nlp_lower_bound_inf' is interpreted to
     109                              be minus infinity. */
     110    , Number* x_U         /** Upper bounds on variables. This rray of
     111                              size n is copied internally, so that the
     112                              caller can change the incoming data after
     113                              return without that IpoptProblem is
     114                              modified.  Any value greater or equal
     115                              than the number specified by option
     116                              'nlp_upper_bound_inf' is interpreted to
     117                              be plus infinity. */
     118    , Index m             /** Number of constraints. */
     119    , Number* g_L         /** Lower bounds on constraints. This rray of
     120                              size m is copied internally, so that the
     121                              caller can change the incoming data after
     122                              return without that IpoptProblem is
     123                              modified.  Any value less or equal than
     124                              the number specified by option
     125                              'nlp_lower_bound_inf' is interpreted to
     126                              be minus infinity. */
     127    , Number* g_U         /** Upper bounds on constraints. This rray of
     128                              size m is copied internally, so that the
     129                              caller can change the incoming data after
     130                              return without that IpoptProblem is
     131                              modified.  Any value greater or equal
     132                              than the number specified by option
     133                              'nlp_upper_bound_inf' is interpreted to
     134                              be plus infinity. */
     135    , Index nele_jac      /** Number of non-zero elements in constraint
     136                              Jacobian. */
     137    , Index nele_hess     /** Number of non-zero elements in Hessian of
     138                              Lagrangian. */
     139    , Eval_F_CB eval_f    /** Callback function for evaluating
     140                              objective function */
     141    , Eval_G_CB eval_g    /** Callback function for evaluating
     142                              constraint functions */
     143    , Eval_Grad_F_CB eval_grad_f
     144                          /** Callback function for evaluating gradient
     145                              of objective function */
     146    , Eval_Jac_G_CB eval_jac_g
     147                          /** Callback function for evaluating Jacobian
     148                              of constraint functions */
     149    , Eval_H_CB eval_h    /** Callback function for evaluating Hessian
     150                              of Lagrangian function */
     151  );
     152
     153  /** Method for freeing a previously created IpoptProblem.  After
     154      freeing an IpoptProblem, it cannot be used anymore. */
     155  void FreeIpoptProblem(IpoptProblem ipopt_problem);
     156
     157
     158  /** Function for adding a string option.  Returns FALSE the option
     159   *  could not be set (e.g., if keyword is unknown) */
     160  Bool AddIpoptStrOption(IpoptProblem ipopt_problem, char* keyword, char* val);
     161
     162  /** Function for adding a Number option.  Returns FALSE the option
     163   *  could not be set (e.g., if keyword is unknown) */
     164  Bool AddIpoptNumOption(IpoptProblem ipopt_problem, char* keyword, Number val);
     165
     166  /** Function for adding an Int option.  Returns FALSE the option
     167   *  could not be set (e.g., if keyword is unknown) */
     168  Bool AddIpoptIntOption(IpoptProblem ipopt_problem, char* keyword, Int val);
     169
     170  /** Function for opening an output file for a given name with given
     171   *  printlevel.  Returns false, if there was a problem opening the
     172   *  file. */
     173  Bool OpenIpoptOutputFile(IpoptProblem ipopt_problem, char* file_name,
     174                           Int print_level);
     175
     176  /** Function calling the Ipopt optimization algorithm for a problem
     177      previously defined with CreateIpoptProblem.  The return
     178      specified outcome of the optimization procedure (e.g., success,
     179      failure etc).
    74180   */
    75   Int IpoptSolve(Index n             /** Number of optimization variables */
    76                , Number* x           /** Input:  Starting point
    77                                          Output: Optimal solution */
    78                , Number* x_L         /** Lower bounds on variables */
    79                , Number* x_U         /** Upper bounds on variables */
    80                , Index m             /** Number of constraints */
    81                , Number* g           /** Values of constraint at final point
    82                                          (output only - ignored if set to NULL) */
    83                , Number* g_L         /** Lower bounds on constraints */
    84                , Number* g_U         /** Upper bounds on constraints */
    85                , Index nele_jac      /** Number of non-zero elements in
    86                                          constraint Jacobian */
    87                , Index nele_hess     /** Number of non-zero elements in
    88                                          Hessian of Lagrangian */
    89                , Number* obj_val     /** Final value of objective function
    90                                          (output only - ignored if set to NULL) */
    91                , Number* mult_g      /** Final multipliers for constraints
    92                                          (output only - ignored if set to NULL) */
    93                , Number* mult_x_L    /** Final multipliers for lower variable bounds
    94                                          (output only - ignored if set to NULL) */
    95                , Number* mult_x_U    /** Final multipliers for upper variable bounds
    96                                          (output only - ignored if set to NULL) */
    97                , Eval_F_CB eval_f    /** Callback function for evaluating
    98                                          objective function */
    99                , Eval_G_CB eval_g    /** Callback function for evaluating
    100                                          constraint functions */
    101                , Eval_Grad_F_CB eval_grad_f
    102                                      /** Callback function for evaluating
    103                                          gradient of objective function */
    104                , Eval_Jac_G_CB eval_jac_g
    105                                      /** Callback function for evaluating
    106                                          Jacobian of constraint functions */
    107                , Eval_H_CB eval_h    /** Callback function for evaluating
    108                                          Hessian of Lagrangian function */
    109                , OptionsPtr options  /** Options for algorithm (NULL: default) */
    110                , UserDataPtr user_data /** Pointer to user data */
    111                  );
     181  enum ApplicationReturnStatus IpoptSolve(
     182      IpoptProblem ipopt_problem
     183                         /** Problem that is to be optimized.  Ipopt
     184                             will use the options previously specified with
     185                             AddIpoptOption (etc) for this problem. */
     186    , Number* x          /** Input:  Starting point
     187                             Output: Optimal solution */
     188    , Number* g          /** Values of constraint at final point
     189                             (output only - ignored if set to NULL) */
     190    , Number* obj_val    /** Final value of objective function
     191                             (output only - ignored if set to NULL) */
     192    , Number* mult_g     /** Final multipliers for constraints
     193                             (output only - ignored if set to NULL) */
     194    , Number* mult_x_L   /** Final multipliers for lower variable bounds
     195                             (output only - ignored if set to NULL) */
     196    , Number* mult_x_U   /** Final multipliers for upper variable bounds
     197                             (output only - ignored if set to NULL) */
     198    , UserDataPtr user_data
     199    /** Pointer to user data.  This will be
     200    passed unmodified to the callback
     201    functions. */
     202  );
     203
     204  /**
     205  void IpoptStatisticsCounts;
     206
     207  void IpoptStatisticsInfeasibilities; */
    112208
    113209#ifdef __cplusplus
  • branches/dev/Interfaces/IpStdFInterface.c

    r430 r433  
    33   All Rights Reserved.
    44   This code is published under the Common Public License.
    5 
     5 
    66   $Id$
    7 
     7 
    88   Authors:  Carl Laird, Andreas Waechter     IBM    2004-09-03
    99 ********************************************************************/
     
    2020typedef long fptr;
    2121
     22/** Return value for indicating that evaluation could be done without
     23    problem. */
     24static const fint OKRetVal = 0;
     25static const fint NotOKRetVal = 1;
     26
    2227/* Function pointer types for the Fortran callback functions */
    2328typedef void (*FEval_F_CB)(fint* N, fdouble* X, fint* NEW_X,
    24                            fdouble* OBJVAL, fint* IDAT, fdouble* DDAT,
    25                            fint* IERR);
     29                           fdouble* OBJVAL, fint* IDAT, fdouble* DDAT,
     30                           fint* IERR);
    2631typedef void (*FEval_G_CB)(fint* N, fdouble* X, fint* NEW_X,
    27                            fint* M, fdouble* G, fint* IDAT, fdouble* DDAT,
    28                            fint* IERR);
     32                           fint* M, fdouble* G, fint* IDAT, fdouble* DDAT,
     33                           fint* IERR);
    2934typedef void (*FEval_Grad_F_CB)(fint *N, fdouble* X, fint* NEW_X,
    30                                 fdouble* GRAD, fint* IDAT, fdouble* DDAT,
    31                                 fint* IERR);
     35                                fdouble* GRAD, fint* IDAT, fdouble* DDAT,
     36                                fint* IERR);
    3237typedef void (*FEval_Jac_G_CB)(fint* TASK, fint* N, fdouble* X, fint* NEW_X,
    33                                fint* M, fint* NNZJAC, fint* IROW, fint* JCOL,
    34                                fdouble* VALUES, fint* IDAT, fdouble* DDAT,
    35                                fint* IERR);
     38                               fint* M, fint* NNZJAC, fint* IROW, fint* JCOL,
     39                               fdouble* VALUES, fint* IDAT, fdouble* DDAT,
     40                               fint* IERR);
    3641typedef void (*FEval_Hess_CB)(fint* TASK, fint* N, fdouble* X, fint* NEW_X,
    37                               fdouble *OBJFACT, fint* M, fdouble* LAMBDA,
    38                               fint* NEW_LAM, fint* NNZHESS, fint* IROW,
    39                               fint* JCOL, fdouble* VALUES, fint* IDAT,
    40                               fdouble* DDAT, fint* IERR);
    41 
    42 static const fint OKRetVal = 0;
    43 
    44 struct _FUserData {
     42                              fdouble *OBJFACT, fint* M, fdouble* LAMBDA,
     43                              fint* NEW_LAM, fint* NNZHESS, fint* IROW,
     44                              fint* JCOL, fdouble* VALUES, fint* IDAT,
     45                              fdouble* DDAT, fint* IERR);
     46
     47struct _FUserData
     48{
    4549  fint* IDAT;
    4650  fdouble* DDAT;
     
    5054  FEval_Jac_G_CB EVAL_JAC_G;
    5155  FEval_Hess_CB EVAL_HESS;
     56  IpoptProblem Problem;
    5257};
    5358
     
    5560
    5661static Bool eval_f(Index n, Number* x, Bool new_x,
    57                    Number* obj_value, UserDataPtr user_data)
     62                   Number* obj_value, UserDataPtr user_data)
    5863{
    5964  fint N = n;
     
    7075
    7176static Bool eval_grad_f(Index n, Number* x, Bool new_x,
    72                         Number* grad_f, UserDataPtr user_data)
     77                        Number* grad_f, UserDataPtr user_data)
    7378{
    7479  fint N = n;
     
    8590
    8691static Bool eval_g(Index n, Number* x, Bool new_x,
    87                    Index m, Number* g, UserDataPtr user_data)
     92                   Index m, Number* g, UserDataPtr user_data)
    8893{
    8994  fint N = n;
     
    101106
    102107static Bool eval_jac_g(Index n, Number *x, Bool new_x, Index m, Index nele_jac,
    103                        Index *iRow, Index *jCol, Number *values,
    104                        UserDataPtr user_data)
     108                       Index *iRow, Index *jCol, Number *values,
     109                       UserDataPtr user_data)
    105110{
    106111  fint N = n;
     
    121126    /* Only request the values */
    122127    TASK = 1;
    123   } else {
     128  }
     129  else {
    124130    printf("Error in IpStdFInterface eval_jac_g!\n");
    125131    return (Bool) 0;
     
    127133
    128134  fuser_data->EVAL_JAC_G(&TASK, &N, x, &NEW_X, &M, &NNZJAC, iRow, jCol,
    129                         values, IDAT, DDAT, &IERR);
     135                        values, IDAT, DDAT, &IERR);
    130136
    131137  return (Bool) (IERR==OKRetVal);
     
    133139
    134140static Bool eval_h(Index n, Number *x, Bool new_x, Number obj_factor,
    135                    Index m, Number *lambda, Bool new_lambda,
    136                    Index nele_hess, Index *iRow, Index *jCol,
    137                    Number *values, UserDataPtr user_data)
     141                   Index m, Number *lambda, Bool new_lambda,
     142                   Index nele_hess, Index *iRow, Index *jCol,
     143                   Number *values, UserDataPtr user_data)
    138144{
    139145  fint N = n;
     
    155161    /* Only request the values */
    156162    TASK = 1;
    157   } else {
     163  }
     164  else {
    158165    printf("Error in IpStdFInterface eval_hess!\n");
    159166    return (Bool) 0;
     
    161168
    162169  fuser_data->EVAL_HESS(&TASK, &N, x, &NEW_X, &obj_factor,
    163                         &M, lambda, &NEW_LAM, &NNZHESS, iRow, jCol,
    164                         values, IDAT, DDAT, &IERR);
    165 
    166   return (Bool) (IERR==OKRetVal);
    167 }
    168 
    169 void F77_FUNC(ipopt,IPOPT)(fint* N,
    170                            fdouble* X,
    171                            fdouble* X_L,
    172                            fdouble* X_U,
    173                            fint* M,
    174                            fdouble* G,
    175                            fdouble* G_L,
    176                            fdouble* G_U,
    177                            fint* NELE_JAC,
    178                            fint* NELE_HESS,
    179                            fdouble* OBJ_VAL,
    180                            fdouble* MULT_G,
    181                            fdouble* MULT_X_L,
    182                            fdouble* MULT_X_U,
    183                            FEval_F_CB EVAL_F,
    184                            FEval_G_CB EVAL_G,
    185                            FEval_Grad_F_CB EVAL_GRAD_F,
    186                            FEval_Jac_G_CB EVAL_JAC_G,
    187                            FEval_Hess_CB EVAL_HESS,
    188                            fptr* OPTIONS,
    189                            fint* IDAT,
    190                            fdouble* DDAT,
    191                            fint* IERR)
     170                        &M, lambda, &NEW_LAM, &NNZHESS, iRow, jCol,
     171                        values, IDAT, DDAT, &IERR);
     172
     173  return (Bool) (IERR==OKRetVal);
     174}
     175
     176fptr F77_FUNC(ipcreate,IPCREATE)
     177(fint* N,
     178 fdouble* X_L,
     179 fdouble* X_U,
     180 fint* M,
     181 fdouble* G_L,
     182 fdouble* G_U,
     183 fint* NELE_JAC,
     184 fint* NELE_HESS,
     185 FEval_F_CB EVAL_F,
     186 FEval_G_CB EVAL_G,
     187 FEval_Grad_F_CB EVAL_GRAD_F,
     188 FEval_Jac_G_CB EVAL_JAC_G,
     189 FEval_Hess_CB EVAL_HESS)
    192190{
    193191  Index n = *N;
     
    195193  Index nele_jac = *NELE_JAC;
    196194  Index nele_hess = *NELE_HESS;
    197   OptionsPtr options = (OptionsPtr)*OPTIONS;
    198195
    199196  FUserData* fuser_data;
    200   UserDataPtr user_data;
    201197
    202198  fuser_data = (FUserData*) malloc(sizeof(FUserData));
    203   fuser_data->IDAT = IDAT;
    204   fuser_data->DDAT = DDAT;
     199
     200  /* First create a new IpoptProblem object; if that fails return 0 */
     201  fuser_data->Problem =
     202    CreateIpoptProblem(n, X_L, X_U, m, G_L, G_U, nele_jac, nele_hess,
     203                       eval_f, eval_g, eval_grad_f, eval_jac_g, eval_h);
     204  if (fuser_data->Problem == NULL) {
     205    free(fuser_data);
     206    return (fptr)NULL;
     207  }
     208
     209  /* Store the information for the callback function */
    205210  fuser_data->EVAL_F = EVAL_F;
    206211  fuser_data->EVAL_G = EVAL_G;
     
    208213  fuser_data->EVAL_JAC_G = EVAL_JAC_G;
    209214  fuser_data->EVAL_HESS = EVAL_HESS;
     215
     216  return (fptr)fuser_data;
     217}
     218
     219void F77_FUNC(ipfree,IPFREE)
     220(fptr* FProblem)
     221{
     222  FUserData* fuser_data = (FUserData*) *FProblem;
     223
     224  FreeIpoptProblem(fuser_data->Problem);
     225  free(fuser_data);
     226
     227  *FProblem = (fptr)NULL;
     228}
     229
     230fint F77_FUNC(ipsolve,IPSOLVE)
     231(fptr* FProblem,
     232 fdouble* X,
     233 fdouble* G,
     234 fdouble* OBJ_VAL,
     235 fdouble* MULT_G,
     236 fdouble* MULT_X_L,
     237 fdouble* MULT_X_U,
     238 fint* IDAT,
     239 fdouble* DDAT)
     240{
     241  FUserData* fuser_data = (FUserData*) *FProblem;
     242  UserDataPtr user_data;
     243
     244  fuser_data->IDAT = IDAT;
     245  fuser_data->DDAT = DDAT;
    210246  user_data = (UserDataPtr) fuser_data;
    211247
    212   *IERR = (fint)IpoptSolve(n, X, X_L, X_U, m, G, G_L, G_U, nele_jac,
    213                            nele_hess, OBJ_VAL, MULT_G, MULT_X_L, MULT_X_U,
    214                            eval_f, eval_g, eval_grad_f, eval_jac_g, eval_h,
    215                            options, user_data);
    216 
    217   free(fuser_data);
    218 
    219   return;
    220 }
    221 
    222 fptr F77_FUNC(ipnewopts,IPNEWOPTS)()
    223 {
    224   return (fptr) Ipopt_NewOptions();
    225 }
    226 
    227 void F77_FUNC(ipdelopts,IPDELOPTS)(fptr* OPTIONS)
    228 {
    229   if ((OptionsPtr)*OPTIONS!=NULL) {
    230     Ipopt_DeleteOptions((OptionsPtr)*OPTIONS);
    231   }
    232 }
    233 
    234 static char* f2cstr(char* FSTR, int slen) {
     248  return (fint)IpoptSolve(fuser_data->Problem, X, G, OBJ_VAL,
     249                          MULT_G, MULT_X_L, MULT_X_U, user_data);
     250}
     251
     252static char* f2cstr(char* FSTR, int slen)
     253{
    235254  int len;
    236255  char* cstr;
     
    242261  cstr = (char*)malloc(sizeof(char)*(len+1));
    243262  strncpy(cstr, FSTR, len);
    244   cstr[len+1]='\0';
     263  cstr[len]='\0';
    245264
    246265  return cstr;
    247266}
    248267
    249 void F77_FUNC(ipaddopt,IPADDOPT)(fptr* OPTIONS, char* VALUE,
    250                                  char* KEYWORD, int vlen, int klen)
     268/* ToDo make sure position of vlen and klen are at the right place */
     269fint F77_FUNC(ipaddstroption,IPADDSTROPTION)
     270(fptr* FProblem,
     271 char* KEYWORD,
     272 char* VALUE,
     273 int klen,
     274 int vlen)
    251275{
    252276  char* keyword;
    253277  char* val;
     278  FUserData* fuser_data = (FUserData*) *FProblem;
     279  fint retval;
    254280
    255281  keyword = f2cstr(KEYWORD, klen);
    256282  val = f2cstr(VALUE, vlen);
    257283
    258   Ipopt_AddOption((OptionsPtr)*OPTIONS, keyword, val);
     284  retval = AddIpoptStrOption(fuser_data->Problem, keyword, val);
    259285
    260286  free(val);
    261287  free(keyword);
    262 }
    263 
    264 void F77_FUNC(ipaddnumopt,IPADDNUMOPT)(fptr* OPTIONS, fdouble* VAL,
    265                                        char* KEYWORD, int klen)
     288
     289  if (retval) {
     290    return OKRetVal;
     291  }
     292  else {
     293    return NotOKRetVal;
     294  }
     295}
     296
     297fint F77_FUNC(ipaddnumoption,IPADDNUMOPTION)
     298(fptr* FProblem,
     299 char* KEYWORD,
     300 fdouble* VALUE,
     301 int klen)
    266302{
    267303  char* keyword;
     304  FUserData* fuser_data = (FUserData*) *FProblem;
     305  fint retval;
    268306
    269307  keyword = f2cstr(KEYWORD, klen);
    270308
    271   Ipopt_AddNumOption((OptionsPtr)*OPTIONS, keyword, *VAL);
     309  retval = AddIpoptNumOption(fuser_data->Problem, keyword, *VALUE);
    272310
    273311  free(keyword);
    274 }
    275 
    276 void F77_FUNC(ipaddintopt,IPADDINTOPT)(fptr* OPTIONS, fint* VAL,
    277                                        char* KEYWORD, int klen)
     312
     313  if (retval) {
     314    return OKRetVal;
     315  }
     316  else {
     317    return NotOKRetVal;
     318  }
     319}
     320
     321fint F77_FUNC(ipaddintoption,IPADDINTOPTION)
     322(fptr* FProblem,
     323 char* KEYWORD,
     324 fint* VALUE,
     325 int klen)
    278326{
    279327  char* keyword;
     328  FUserData* fuser_data = (FUserData*) *FProblem;
     329  Int value = *VALUE;
     330  fint retval;
    280331
    281332  keyword = f2cstr(KEYWORD, klen);
    282333
    283   Ipopt_AddIntOption((OptionsPtr)*OPTIONS, keyword, *VAL);
     334  retval = AddIpoptIntOption(fuser_data->Problem, keyword, value);
    284335
    285336  free(keyword);
    286 }
     337
     338  if (retval) {
     339    return OKRetVal;
     340  }
     341  else {
     342    return NotOKRetVal;
     343  }
     344}
     345
     346fint F77_FUNC(ipopenoutputfile,IPOPENOUTPUTFILE)
     347(fptr* FProblem,
     348 char* FILENAME,
     349 fint* PRINTLEVEL,
     350 int flen)
     351{
     352  char* filename;
     353  FUserData* fuser_data = (FUserData*) *FProblem;
     354  Int printlevel = *PRINTLEVEL;
     355  fint retval;
     356
     357  filename = f2cstr(FILENAME, flen);
     358
     359  retval = OpenIpoptOutputFile(fuser_data->Problem, filename, printlevel);
     360
     361  free(filename);
     362
     363  if (retval) {
     364    return OKRetVal;
     365  }
     366  else {
     367    return NotOKRetVal;
     368  }
     369}
  • branches/dev/Interfaces/IpStdInterfaceTNLP.hpp

    r430 r433  
    1919namespace Ipopt
    2020{
     21  /** Declare excpetion that is thrown when invalid NLP data
     22   *  is provided */
     23  DECLARE_STD_EXCEPTION(INVALID_STDINTERFACE_NLP);
     24
    2125  /** Implementation of a TNLP for the Standard C interface.  The
    2226   *  standard C interface is exposed to the user as a single C
     
    2731  {
    2832  public:
    29     /**Declare excpetion that is thrown when invalid NLP data
    30      *  is provided */
    31     DECLARE_STD_EXCEPTION(INVALID_STDINTERFACE_NLP);
    32 
    3333    /**@name Constructors/Destructors */
    3434    //@{
  • branches/dev/Interfaces/IpTNLPAdapter.cpp

    r430 r433  
    7979
    8080    ASSERT_EXCEPTION(nlp_lower_bound_inf_ < nlp_upper_bound_inf_,
    81                      OptionsList::OPTION_OUT_OF_RANGE,
     81                     OPTION_INVALID,
    8282                     "Option \"nlp_lower_bound_inf\" must be smaller than \"nlp_upper_bound_inf\".");
    8383
  • branches/dev/Interfaces/Makefile.am

    r430 r433  
    1111includeipoptdir = $(includedir)/ipopt
    1212includeipopt_HEADERS = \
     13        IpAlgTypes.hpp \
    1314        IpIpoptApplication.hpp \
    14         IpAlgTypes.hpp \
    15         IpTNLP.hpp \
    16         IpStdCInterface.h
     15        IpReturnCodes.h \
     16        IpReturnCodes.inc \
     17        IpStdCInterface.h \
     18        IpTNLP.hpp
    1719
    1820noinst_LIBRARIES = libinterfaces.a
     
    2224        IpIpoptApplication.cpp IpIpoptApplication.hpp \
    2325        IpNLP.hpp \
     26        IpReturnCodes.h \
    2427        IpStdCInterface.cpp IpStdCInterface.h \
    2528        IpStdFInterface.c \
     
    3235        -I$(srcdir)/../LinAlg/TMatrices \
    3336        -I$(srcdir)/../Algorithm
     37
     38CFLAGS += -I$(srcdir)/../Common
    3439
    3540# Astyle stuff
  • branches/dev/Interfaces/Makefile.in

    r430 r433  
    122122CC = @CC@
    123123CCDEPMODE = @CCDEPMODE@
    124 CFLAGS = @CFLAGS@
     124CFLAGS = @CFLAGS@ -I$(srcdir)/../Common
    125125CPP = @CPP@
    126126CPPFLAGS = @CPPFLAGS@
     
    216216includeipoptdir = $(includedir)/ipopt
    217217includeipopt_HEADERS = \
     218        IpAlgTypes.hpp \
    218219        IpIpoptApplication.hpp \
    219         IpAlgTypes.hpp \
    220         IpTNLP.hpp \
    221         IpStdCInterface.h
     220        IpReturnCodes.h \
     221        IpReturnCodes.inc \
     222        IpStdCInterface.h \
     223        IpTNLP.hpp
    222224
    223225noinst_LIBRARIES = libinterfaces.a
     
    226228        IpIpoptApplication.cpp IpIpoptApplication.hpp \
    227229        IpNLP.hpp \
     230        IpReturnCodes.h \
    228231        IpStdCInterface.cpp IpStdCInterface.h \
    229232        IpStdFInterface.c \
Note: See TracChangeset for help on using the changeset viewer.