Changeset 430


Ignore:
Timestamp:
Aug 9, 2005 8:19:54 PM (14 years ago)
Author:
andreasw
Message:
  • Mayor reorganization of directory structure
  • removed dependency of lapack (for now)
  • make install installs header files to install Cpp example (still too many header files?)
Location:
branches/dev
Files:
13 added
7 deleted
82 edited
63 copied
28 moved

Legend:

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

    r425 r430  
    2222  DBG_SET_VERBOSITY(0);
    2323
    24   DefineIpoptType(AdaptiveMuUpdate);
     24  DefineOptionsRegistrar(AdaptiveMuUpdate);
    2525
    2626  AdaptiveMuUpdate::AdaptiveMuUpdate
  • branches/dev/Algorithm/IpAdaptiveMuUpdate.hpp

    r425 r430  
    1414#include "IpMuOracle.hpp"
    1515#include "IpFilter.hpp"
    16 #include "IpIpoptType.hpp"
    1716#include "IpQualityFunctionMuOracle.hpp"
    1817
     
    2019{
    2120
    22   DeclareIpoptType(AdaptiveMuUpdate);
     21  DeclareOptionsRegistrar(AdaptiveMuUpdate);
    2322
    2423  /** Non-monotone mu update.
  • branches/dev/Algorithm/IpAlgBuilder.cpp

    r425 r430  
    4343  DBG_SET_VERBOSITY(0);
    4444
    45   DefineIpoptType(AlgorithmBuilder);
     45  DefineOptionsRegistrar(AlgorithmBuilder);
    4646
    4747  void AlgorithmBuilder::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
  • branches/dev/Algorithm/IpAlgBuilder.hpp

    r310 r430  
    1010#define __IPALGBUILDER_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpIpoptAlg.hpp"
    1413
     
    1615{
    1716
    18   DeclareIpoptType(AlgorithmBuilder);
     17  DeclareOptionsRegistrar(AlgorithmBuilder);
    1918
    2019  /** Builder to create a complete IpoptAlg object.  This object
  • branches/dev/Algorithm/IpAlgStrategy.hpp

    r410 r430  
    1010#define __IPALGSTRATEGY_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpOptionsList.hpp"
    1413#include "IpJournalist.hpp"
  • branches/dev/Algorithm/IpAugRestoSystemSolver.hpp

    r428 r430  
    1010#define __IP_AUGRESTOSYSTEMSOLVER_HPP__
    1111
    12 #include "IpUtils.hpp"
    13 #include "IpSmartPtr.hpp"
    1412#include "IpAugSystemSolver.hpp"
    1513
  • branches/dev/Algorithm/IpAugSystemSolver.hpp

    r428 r430  
    1010#define __IP_AUGSYSTEMSOLVER_HPP__
    1111
    12 #include "IpUtils.hpp"
    13 #include "IpSmartPtr.hpp"
    1412#include "IpSymMatrix.hpp"
    1513#include "IpSymLinearSolver.hpp"
  • branches/dev/Algorithm/IpConvCheck.hpp

    r416 r430  
    1010#define __IPCONVCHECK_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpAlgStrategy.hpp"
    1413
  • branches/dev/Algorithm/IpDefaultIterateInitializer.cpp

    r422 r430  
    1313  DBG_SET_VERBOSITY(0);
    1414
    15   DefineIpoptType(DefaultIterateInitializer);
     15  DefineOptionsRegistrar(DefaultIterateInitializer);
    1616
    1717  DefaultIterateInitializer::DefaultIterateInitializer
     
    291291      new_x = ConstPtr(delta_x);
    292292      jnlst.Printf(J_DETAILED, J_INITIALIZATION, "Moved initial values of %s sufficiently inside the bounds.\n", name.c_str());
    293       jnlst.PrintVector(J_VECTOR, J_INITIALIZATION, "original vars", orig_x);
    294       jnlst.PrintVector(J_VECTOR, J_INITIALIZATION, "new vars", *new_x);
     293      orig_x.Print(jnlst, J_VECTOR, J_INITIALIZATION, "original vars");
     294      new_x->Print(jnlst, J_VECTOR, J_INITIALIZATION, "new vars");
    295295    }
    296296    else {
  • branches/dev/Algorithm/IpDefaultIterateInitializer.hpp

    r413 r430  
    1010#define __IPDEFAULTITERATEINITIALIZER_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpIterateInitializer.hpp"
    1413#include "IpEqMultCalculator.hpp"
     
    1716{
    1817
    19   DeclareIpoptType(DefaultIterateInitializer);
     18  DeclareOptionsRegistrar(DefaultIterateInitializer);
    2019
    2120  /** Class implementing the default initialization procedure (based
  • branches/dev/Algorithm/IpFilter.hpp

    r422 r430  
    1010#define __IPFILTER_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpJournalist.hpp"
     13#include "IpDebug.hpp"
    1414#include <list>
    1515#include <vector>
  • branches/dev/Algorithm/IpFilterLineSearch.cpp

    r422 r430  
    2525  DBG_SET_VERBOSITY(0);
    2626
    27   DefineIpoptType(FilterLineSearch);
     27  DefineOptionsRegistrar(FilterLineSearch);
    2828
    2929  FilterLineSearch::FilterLineSearch(const SmartPtr<RestorationPhase>& resto_phase,
     
    14391439                       "*** Accepted corrector for Iteration: %d\n",
    14401440                       IpData().iter_count());
    1441         Jnlst().PrintVector(J_MOREVECTOR, J_MAIN,
    1442                             "delta_corr", *delta_corr);
     1441        delta_corr->Print(Jnlst(), J_MOREVECTOR, J_MAIN, "delta_corr");
    14431442      }
    14441443    }
     
    15251524        IpData().Append_info_string("M");
    15261525        Jnlst().Printf(J_DETAILED, J_LINE_SEARCH, "Magic step with max-norm %.6e taken.\n", delta_s_magic->Amax());
    1527         Jnlst().PrintVector(J_MOREVECTOR, J_LINE_SEARCH,
    1528                             "delta_s_magic", *delta_s_magic);
     1526        delta_s_magic->Print(Jnlst(), J_MOREVECTOR, J_LINE_SEARCH,
     1527                             "delta_s_magic");
    15291528      }
    15301529
  • branches/dev/Algorithm/IpFilterLineSearch.hpp

    r416 r430  
    1010#define __IPFILTERLINESEARCH_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpFilter.hpp"
    1413#include "IpLineSearch.hpp"
    1514#include "IpRestoPhase.hpp"
    1615#include "IpPDSystemSolver.hpp"
    17 #include "IpIpoptType.hpp"
    1816#include "IpConvCheck.hpp"
    1917
     
    2119{
    2220
    23   DeclareIpoptType(FilterLineSearch);
     21  DeclareOptionsRegistrar(FilterLineSearch);
    2422
    2523  /** Filter line search.  This class implements the filter line
  • branches/dev/Algorithm/IpGradientScaling.cpp

    r425 r430  
    1919{
    2020
    21   DefineIpoptType(GradientScaling);
     21  DefineOptionsRegistrar(GradientScaling);
    2222
    2323  void GradientScaling::RegisterOptions(SmartPtr<RegisteredOptions>& roptions)
  • branches/dev/Algorithm/IpGradientScaling.hpp

    r425 r430  
    1212#include "IpNLPScaling.hpp"
    1313#include "IpNLP.hpp"
    14 #include "IpIpoptType.hpp"
    1514
    1615namespace Ipopt
    1716{
    1817
    19   DeclareIpoptType(GradientScaling);
     18  DeclareOptionsRegistrar(GradientScaling);
    2019
    2120  /** This class does problem scaling by setting the
  • branches/dev/Algorithm/IpIpoptAlg.cpp

    r416 r430  
    1515  DBG_SET_VERBOSITY(0);
    1616
    17   DefineIpoptType(IpoptAlgorithm);
     17  DefineOptionsRegistrar(IpoptAlgorithm);
    1818
    1919  IpoptAlgorithm::IpoptAlgorithm(const SmartPtr<PDSystemSolver>& pd_solver,
     
    273273                   "*** Step Calculated for Iteration: %d\n",
    274274                   IpData().iter_count());
    275     Jnlst().PrintVector(J_MOREVECTOR, J_MAIN, "delta", *IpData().delta());
     275    IpData().delta()->Print(Jnlst(), J_MOREVECTOR, J_MAIN, "delta");
    276276  }
    277277
     
    327327      }
    328328      if (Jnlst().ProduceOutput(J_VECTOR, J_MAIN)) {
    329         Jnlst().PrintVector(J_VECTOR, J_MAIN, "old_x_L", *IpNLP().x_L());
    330         Jnlst().PrintVector(J_VECTOR, J_MAIN, "old_x_U", *IpNLP().x_U());
    331         Jnlst().PrintVector(J_VECTOR, J_MAIN, "old_d_L", *IpNLP().d_L());
    332         Jnlst().PrintVector(J_VECTOR, J_MAIN, "old_d_U", *IpNLP().d_U());
     329        IpNLP().x_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "old_x_L");
     330        IpNLP().x_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "old_x_U");
     331        IpNLP().d_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "old_d_L");
     332        IpNLP().d_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "old_d_U");
    333333      }
    334334
     
    356356
    357357      if (Jnlst().ProduceOutput(J_VECTOR, J_MAIN)) {
    358         Jnlst().PrintVector(J_VECTOR, J_MAIN, "new_x_L", *IpNLP().x_L());
    359         Jnlst().PrintVector(J_VECTOR, J_MAIN, "new_x_U", *IpNLP().x_U());
    360         Jnlst().PrintVector(J_VECTOR, J_MAIN, "new_d_L", *IpNLP().d_L());
    361         Jnlst().PrintVector(J_VECTOR, J_MAIN, "new_d_U", *IpNLP().d_U());
     358        IpNLP().x_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "new_x_L");
     359        IpNLP().x_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "new_x_U");
     360        IpNLP().d_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "new_d_L");
     361        IpNLP().d_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "new_d_U");
    362362      }
    363363
  • branches/dev/Algorithm/IpIpoptAlg.hpp

    r387 r430  
    1010#define __IPIPOPTALG_HPP__
    1111
    12 #include "IpUtils.hpp"
    13 #include "IpSmartPtr.hpp"
    1412#include "IpIpoptNLP.hpp"
    1513#include "IpAlgStrategy.hpp"
     
    2119#include "IpIterateInitializer.hpp"
    2220#include "IpIterationOutput.hpp"
    23 #include "IpIpoptType.hpp"
    2421#include "IpAlgTypes.hpp"
    2522
     
    2724{
    2825
    29   DeclareIpoptType(IpoptAlgorithm);
     26  DeclareOptionsRegistrar(IpoptAlgorithm);
    3027
    3128  /** The main ipopt algorithm class.
  • branches/dev/Algorithm/IpIpoptCalculatedQuantities.cpp

    r422 r430  
    2020  DBG_SET_VERBOSITY(0);
    2121
    22   DefineIpoptType(IpoptCalculatedQuantities);
     22  DefineOptionsRegistrar(IpoptCalculatedQuantities);
    2323
    2424  IpoptCalculatedQuantities::IpoptCalculatedQuantities
  • branches/dev/Algorithm/IpIpoptCalculatedQuantities.hpp

    r414 r430  
    1010#define __IPIPOPTCALCULATEDQUANTITIES_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpIpoptNLP.hpp"
    1413#include "IpIpoptData.hpp"
     
    2423  };
    2524
    26   DeclareIpoptType(IpoptCalculatedQuantities);
     25  DeclareOptionsRegistrar(IpoptCalculatedQuantities);
    2726
    2827  /** Class for all IPOPT specific calculated quantities.
  • branches/dev/Algorithm/IpIpoptData.cpp

    r422 r430  
    1515  DBG_SET_VERBOSITY(0);
    1616
    17   DefineIpoptType(IpoptData);
     17  DefineOptionsRegistrar(IpoptData);
    1818
    1919  IpoptData::IpoptData()
  • branches/dev/Algorithm/IpIpoptData.hpp

    r422 r430  
    1010#define __IPIPOPTDATA_HPP__
    1111
    12 #include "IpUtils.hpp"
    13 #include "IpSmartPtr.hpp"
    14 #include "IpVector.hpp"
    1512#include "IpSymMatrix.hpp"
    16 #include "IpReferenced.hpp"
    1713#include "IpOptionsList.hpp"
    1814#include "IpIteratesVector.hpp"
    19 #include "IpIpoptType.hpp"
     15#include "IpRegOptions.hpp"
    2016
    2117namespace Ipopt
    2218{
    2319
    24   DeclareIpoptType(IpoptData);
     20  DeclareOptionsRegistrar(IpoptData);
    2521
    2622  /* Forward declaration */
  • branches/dev/Algorithm/IpIpoptNLP.hpp

    r414 r430  
    1010#define __IPIPOPTNLP_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpNLP.hpp"
    1413#include "IpJournalist.hpp"
    15 #include "IpReferenced.hpp"
    16 #include "IpException.hpp"
    1714#include "IpNLPScaling.hpp"
    1815
  • branches/dev/Algorithm/IpIterateInitializer.hpp

    r2 r430  
    1010#define __IPITERATEINITIALIZER_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpAlgStrategy.hpp"
    1413#include "IpIpoptNLP.hpp"
  • branches/dev/Algorithm/IpIterationOutput.hpp

    r2 r430  
    1010#define __IPITERATIONOUTPUT_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpAlgStrategy.hpp"
    1413#include "IpIpoptNLP.hpp"
  • branches/dev/Algorithm/IpLeastSquareMults.hpp

    r428 r430  
    1010#define __IPLEASTSQUAREMULTS_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpAugSystemSolver.hpp"
    1413#include "IpEqMultCalculator.hpp"
  • branches/dev/Algorithm/IpLineSearch.hpp

    r157 r430  
    1010#define __IPLINESEARCH_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpAlgStrategy.hpp"
    1413#include "IpIpoptCalculatedQuantities.hpp"
  • branches/dev/Algorithm/IpMonotoneMuUpdate.cpp

    r416 r430  
    2121  DBG_SET_VERBOSITY(0);
    2222
    23   DefineIpoptType(MonotoneMuUpdate);
     23  DefineOptionsRegistrar(MonotoneMuUpdate);
    2424
    2525  MonotoneMuUpdate::MonotoneMuUpdate(const SmartPtr<LineSearch>& linesearch)
  • branches/dev/Algorithm/IpMonotoneMuUpdate.hpp

    r416 r430  
    1212#include "IpMuUpdate.hpp"
    1313#include "IpLineSearch.hpp"
    14 #include "IpIpoptType.hpp"
    1514
    1615namespace Ipopt
    1716{
    1817
    19   DeclareIpoptType(MonotoneMuUpdate);
     18  DeclareOptionsRegistrar(MonotoneMuUpdate);
    2019
    2120  /** Monotone Mu Update. This class implements the standard monotone mu update
  • branches/dev/Algorithm/IpMuOracle.hpp

    r316 r430  
    1010#define __IPMUORACLE_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpAlgStrategy.hpp"
    1413
  • branches/dev/Algorithm/IpMuUpdate.hpp

    r375 r430  
    1010#define __IPMUUPDATE_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpAlgStrategy.hpp"
    1413
  • branches/dev/Algorithm/IpNLPScaling.cpp

    r425 r430  
    178178  }
    179179
    180   DefineIpoptType(StandardScalingBase);
     180  DefineOptionsRegistrar(StandardScalingBase);
    181181
    182182  void
     
    224224      Jnlst().Printf(J_VECTOR, J_MAIN, "objective scaling factor = %g\n", df_);
    225225      if (IsValid(dx_)) {
    226         Jnlst().PrintVector(J_VECTOR, J_MAIN, "x scaling vector", *dx_);
     226        dx_->Print(Jnlst(), J_VECTOR, J_MAIN, "x scaling vector");
    227227      }
    228228      else {
     
    230230      }
    231231      if (IsValid(dc)) {
    232         Jnlst().PrintVector(J_VECTOR, J_MAIN, "c scaling vector", *dc);
     232        dc->Print(Jnlst(), J_VECTOR, J_MAIN, "c scaling vector");
    233233      }
    234234      else {
     
    236236      }
    237237      if (IsValid(dd)) {
    238         Jnlst().PrintVector(J_VECTOR, J_MAIN, "d scaling vector", *dd);
     238        dd->Print(Jnlst(), J_VECTOR, J_MAIN, "d scaling vector");
    239239      }
    240240      else {
  • branches/dev/Algorithm/IpNLPScaling.hpp

    r425 r430  
    1010#define __IPNLPSCALING_HPP__
    1111
    12 #include "IpSmartPtr.hpp"
    13 #include "IpVector.hpp"
    14 #include "IpMatrix.hpp"
    1512#include "IpSymMatrix.hpp"
    1613#include "IpScaledMatrix.hpp"
    1714#include "IpSymScaledMatrix.hpp"
    1815#include "IpOptionsList.hpp"
    19 #include "IpIpoptType.hpp"
     16#include "IpRegOptions.hpp"
    2017
    2118namespace Ipopt
     
    219216  };
    220217
    221   DeclareIpoptType(StandardScalingBase);
     218  DeclareOptionsRegistrar(StandardScalingBase);
    222219
    223220  /** This is a base class for many standard scaling
  • branches/dev/Algorithm/IpOptErrorConvCheck.cpp

    r416 r430  
    1313  DBG_SET_VERBOSITY(0);
    1414
    15   DefineIpoptType(OptimalityErrorConvergenceCheck);
     15  DefineOptionsRegistrar(OptimalityErrorConvergenceCheck);
    1616
    1717  OptimalityErrorConvergenceCheck::OptimalityErrorConvergenceCheck()
  • branches/dev/Algorithm/IpOptErrorConvCheck.hpp

    r416 r430  
    1010#define __IPOPTERRORCONVCHECK_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpConvCheck.hpp"
    1413
     
    1615{
    1716
    18   DeclareIpoptType(OptimalityErrorConvergenceCheck);
     17  DeclareOptionsRegistrar(OptimalityErrorConvergenceCheck);
    1918
    2019  /** Brief Class Description.
  • branches/dev/Algorithm/IpOrigIpoptNLP.cpp

    r416 r430  
    1818  DBG_SET_VERBOSITY(0);
    1919
    20   DefineIpoptType(OrigIpoptNLP);
     20  DefineOptionsRegistrar(OrigIpoptNLP);
    2121
    2222  OrigIpoptNLP::OrigIpoptNLP(const SmartPtr<const Journalist>& jnlst,
  • branches/dev/Algorithm/IpOrigIpoptNLP.hpp

    r422 r430  
    1212#include "IpIpoptNLP.hpp"
    1313#include "IpException.hpp"
    14 #include "IpIpoptType.hpp"
    1514
    1615namespace Ipopt
    1716{
    1817
    19   DeclareIpoptType(OrigIpoptNLP);
     18  DeclareOptionsRegistrar(OrigIpoptNLP);
    2019
    2120  /** This class maps the traditional NLP into
  • branches/dev/Algorithm/IpOrigIterationOutput.cpp

    r414 r430  
    154154    }
    155155    if (Jnlst().ProduceOutput(J_VECTOR, J_MAIN)) {
    156       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_x", *IpData().curr()->x());
    157       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_s", *IpData().curr()->s());
    158 
    159       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_y_c", *IpData().curr()->y_c());
    160       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_y_d", *IpData().curr()->y_d());
    161 
    162       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_slack_x_L", *IpCq().curr_slack_x_L());
    163       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_slack_x_U", *IpCq().curr_slack_x_U());
    164 
    165       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_z_L", *IpData().curr()->z_L());
    166       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_z_U", *IpData().curr()->z_U());
    167 
    168       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_slack_s_L", *IpCq().curr_slack_s_L());
    169       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_slack_s_U", *IpCq().curr_slack_s_U());
    170 
    171       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_v_L", *IpData().curr()->v_L());
    172       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_v_U", *IpData().curr()->v_U());
     156      IpData().curr()->x()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_x");
     157      IpData().curr()->s()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_s");
     158
     159      IpData().curr()->y_c()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_y_c");
     160      IpData().curr()->y_d()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_y_d");
     161
     162      IpCq().curr_slack_x_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_slack_x_L");
     163      IpCq().curr_slack_x_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_slack_x_U");
     164      IpData().curr()->z_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_z_L");
     165      IpData().curr()->z_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_z_U");
     166
     167      IpCq().curr_slack_s_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_slack_s_L");
     168      IpCq().curr_slack_s_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_slack_s_U");
     169      IpData().curr()->v_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_v_L");
     170      IpData().curr()->v_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_v_U");
    173171    }
    174172    if (Jnlst().ProduceOutput(J_MOREVECTOR, J_MAIN)) {
    175       Jnlst().PrintVector(J_MOREVECTOR, J_MAIN, "curr_grad_lag_x", *IpCq().curr_grad_lag_x());
    176       Jnlst().PrintVector(J_MOREVECTOR, J_MAIN, "curr_grad_lag_s", *IpCq().curr_grad_lag_s());
     173      IpCq().curr_grad_lag_x()->Print(Jnlst(), J_MOREVECTOR, J_MAIN, "curr_grad_lag_x");
     174      IpCq().curr_grad_lag_s()->Print(Jnlst(), J_MOREVECTOR, J_MAIN, "curr_grad_lag_s");
    177175      if (IsValid(IpData().delta())) {
    178         Jnlst().PrintVector(J_MOREVECTOR, J_MAIN,
    179                             "delta_x", *IpData().delta()->x());
    180         Jnlst().PrintVector(J_MOREVECTOR, J_MAIN,
    181                             "delta_s", *IpData().delta()->s());
    182         Jnlst().PrintVector(J_MOREVECTOR, J_MAIN,
    183                             "delta_y_c", *IpData().delta()->y_c());
    184         Jnlst().PrintVector(J_MOREVECTOR, J_MAIN,
    185                             "delta_y_d", *IpData().delta()->y_d());
    186         Jnlst().PrintVector(J_MOREVECTOR, J_MAIN,
    187                             "delta_z_L", *IpData().delta()->z_L());
    188         Jnlst().PrintVector(J_MOREVECTOR, J_MAIN,
    189                             "delta_z_U", *IpData().delta()->z_U());
    190         Jnlst().PrintVector(J_MOREVECTOR, J_MAIN,
    191                             "delta_v_L", *IpData().delta()->v_L());
    192         Jnlst().PrintVector(J_MOREVECTOR, J_MAIN,
    193                             "delta_v_U", *IpData().delta()->v_U());
     176        IpData().delta()->Print(Jnlst(), J_MOREVECTOR, J_MAIN, "delta");
    194177      }
    195178    }
     
    207190    }
    208191    if (Jnlst().ProduceOutput(J_VECTOR, J_MAIN)) {
    209       Jnlst().PrintVector(J_VECTOR, J_MAIN, "grad_f", *IpCq().curr_grad_f());
    210       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_c", *IpCq().curr_c());
    211       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_d", *IpCq().curr_d());
    212       Jnlst().PrintVector(J_VECTOR, J_MAIN,
    213                           "curr_d - curr_s", *IpCq().curr_d_minus_s());
     192      IpCq().curr_grad_f()->Print(Jnlst(), J_VECTOR, J_MAIN, "grad_f");
     193      IpCq().curr_c()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_c");
     194      IpCq().curr_d()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_d");
     195      IpCq().curr_d_minus_s()->Print(Jnlst(), J_VECTOR, J_MAIN,
     196                                     "curr_d - curr_s");
    214197    }
    215198
    216199    if (Jnlst().ProduceOutput(J_MATRIX, J_MAIN)) {
    217       Jnlst().PrintMatrix(J_MATRIX, J_MAIN, "jac_c", *IpCq().curr_jac_c());
    218       Jnlst().PrintMatrix(J_MATRIX, J_MAIN, "jac_d", *IpCq().curr_jac_d());
    219       Jnlst().PrintMatrix(J_MATRIX, J_MAIN, "h", *IpCq().curr_exact_hessian());
     200      IpCq().curr_jac_c()->Print(Jnlst(), J_MATRIX, J_MAIN, "jac_c");
     201      IpCq().curr_jac_d()->Print(Jnlst(), J_MATRIX, J_MAIN, "jac_d");
     202      IpCq().curr_exact_hessian()->Print(Jnlst(), J_MATRIX, J_MAIN, "h");
    220203    }
    221204
  • branches/dev/Algorithm/IpPDFullSpaceSolver.cpp

    r428 r430  
    1515  DBG_SET_VERBOSITY(0);
    1616
    17   DefineIpoptType(PDFullSpaceSolver);
     17  DefineOptionsRegistrar(PDFullSpaceSolver);
    1818
    1919  PDFullSpaceSolver::PDFullSpaceSolver(AugSystemSolver& augSysSolver,
     
    611611
    612612    if (Jnlst().ProduceOutput(J_MOREVECTOR, J_LINEAR_ALGEBRA)) {
    613       Jnlst().PrintVector(J_MOREVECTOR, J_LINEAR_ALGEBRA,"resid_x ", *resid.x());
    614       Jnlst().PrintVector(J_MOREVECTOR, J_LINEAR_ALGEBRA,"resid_s ", *resid.s());
    615       Jnlst().PrintVector(J_MOREVECTOR, J_LINEAR_ALGEBRA,"resid_c ", *resid.y_c());
    616       Jnlst().PrintVector(J_MOREVECTOR, J_LINEAR_ALGEBRA,"resid_d ", *resid.y_d());
    617       Jnlst().PrintVector(J_MOREVECTOR, J_LINEAR_ALGEBRA,"resid_zL", *resid.z_L());
    618       Jnlst().PrintVector(J_MOREVECTOR, J_LINEAR_ALGEBRA,"resid_zU", *resid.z_U());
    619       Jnlst().PrintVector(J_MOREVECTOR, J_LINEAR_ALGEBRA,"resid_vL", *resid.v_L());
    620       Jnlst().PrintVector(J_MOREVECTOR, J_LINEAR_ALGEBRA,"resid_vU", *resid.v_U());
     613      resid.Print(Jnlst(), J_MOREVECTOR, J_LINEAR_ALGEBRA, "resid");
    621614    }
    622615
  • branches/dev/Algorithm/IpPDFullSpaceSolver.hpp

    r428 r430  
    1717{
    1818
    19   DeclareIpoptType(PDFullSpaceSolver);
     19  DeclareOptionsRegistrar(PDFullSpaceSolver);
    2020
    2121  /** This is the implemetation of the Primal-Dual System, using the
  • branches/dev/Algorithm/IpPDPerturbationHandler.cpp

    r428 r430  
    1313  DBG_SET_VERBOSITY(0);
    1414
    15   DefineIpoptType(PDPerturbationHandler);
     15  DefineOptionsRegistrar(PDPerturbationHandler);
    1616
    1717  PDPerturbationHandler::PDPerturbationHandler()
  • branches/dev/Algorithm/IpPDPerturbationHandler.hpp

    r428 r430  
    1111
    1212#include "IpAlgStrategy.hpp"
    13 #include "IpIpoptType.hpp"
    1413
    1514namespace Ipopt
    1615{
    1716
    18   DeclareIpoptType(PDPerturbationHandler);
     17  DeclareOptionsRegistrar(PDPerturbationHandler);
    1918
    2019  /** Class for handling the perturbation factors delta_x, delta_s,
  • branches/dev/Algorithm/IpProbingMuOracle.cpp

    r321 r430  
    2020  DBG_SET_VERBOSITY(0);
    2121
    22   DefineIpoptType(ProbingMuOracle);
     22  DefineOptionsRegistrar(ProbingMuOracle);
    2323
    2424  ProbingMuOracle::ProbingMuOracle(const SmartPtr<PDSystemSolver>& pd_solver)
  • branches/dev/Algorithm/IpProbingMuOracle.hpp

    r321 r430  
    1616{
    1717
    18   DeclareIpoptType(ProbingMuOracle);
     18  DeclareOptionsRegistrar(ProbingMuOracle);
    1919
    2020  /** Implementation of the probing strategy for computing the
  • branches/dev/Algorithm/IpQualityFunctionMuOracle.cpp

    r425 r430  
    2020  DBG_SET_VERBOSITY(0);
    2121
    22   DefineIpoptType(QualityFunctionMuOracle);
     22  DefineOptionsRegistrar(QualityFunctionMuOracle);
    2323
    2424  QualityFunctionMuOracle::QualityFunctionMuOracle(const SmartPtr<PDSystemSolver>& pd_solver)
  • branches/dev/Algorithm/IpQualityFunctionMuOracle.hpp

    r425 r430  
    1212#include "IpMuOracle.hpp"
    1313#include "IpPDSystemSolver.hpp"
    14 #include "IpIpoptType.hpp"
    1514#include "IpIpoptCalculatedQuantities.hpp"
    1615
     
    1817{
    1918
    20   DeclareIpoptType(QualityFunctionMuOracle);
     19  DeclareOptionsRegistrar(QualityFunctionMuOracle);
    2120
    2221  /** Implementation of the probing strategy for computing the
  • branches/dev/Algorithm/IpRestoFilterConvCheck.cpp

    r416 r430  
    1616  DBG_SET_VERBOSITY(0);
    1717
    18   DefineIpoptType(RestoFilterConvergenceCheck);
     18  DefineOptionsRegistrar(RestoFilterConvergenceCheck);
    1919
    2020  RestoFilterConvergenceCheck::RestoFilterConvergenceCheck()
  • branches/dev/Algorithm/IpRestoFilterConvCheck.hpp

    r373 r430  
    1010#define __IPRESTOFILTERCONVCHECK_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpOptErrorConvCheck.hpp"
    1413#include "IpFilterLineSearch.hpp"
    15 #include "IpIpoptType.hpp"
    1614
    1715namespace Ipopt
    1816{
    1917
    20   DeclareIpoptType(RestoFilterConvergenceCheck);
     18  DeclareOptionsRegistrar(RestoFilterConvergenceCheck);
    2119
    2220  /** Convergence check for the restoration phase as called by the
  • branches/dev/Algorithm/IpRestoIpoptNLP.cpp

    r422 r430  
    2323  DBG_SET_VERBOSITY(0);
    2424
    25   DefineIpoptType(RestoIpoptNLP);
     25  DefineOptionsRegistrar(RestoIpoptNLP);
    2626
    2727  RestoIpoptNLP::RestoIpoptNLP(IpoptNLP& orig_ip_nlp,
  • branches/dev/Algorithm/IpRestoIpoptNLP.hpp

    r422 r430  
    2323{
    2424
    25   DeclareIpoptType(RestoIpoptNLP);
     25  DeclareOptionsRegistrar(RestoIpoptNLP);
    2626
    2727  /** This class maps the traditional NLP into
  • branches/dev/Algorithm/IpRestoIterateInitializer.hpp

    r413 r430  
    1010#define __IPRESTOITERATEINITIALIZER_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpIterateInitializer.hpp"
    1413#include "IpEqMultCalculator.hpp"
    15 #include "IpIpoptType.hpp"
    1614
    1715namespace Ipopt
  • branches/dev/Algorithm/IpRestoIterationOutput.cpp

    r414 r430  
    198198    }
    199199    if (Jnlst().ProduceOutput(J_VECTOR, J_MAIN)) {
    200       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_x", *IpData().curr()->x());
    201       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_s", *IpData().curr()->s());
    202 
    203       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_y_c", *IpData().curr()->y_c());
    204       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_y_d", *IpData().curr()->y_d());
    205 
    206       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_slack_x_L", *IpCq().curr_slack_x_L());
    207       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_slack_x_U", *IpCq().curr_slack_x_U());
    208 
    209       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_z_L", *IpData().curr()->z_L());
    210       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_z_U", *IpData().curr()->z_U());
    211 
    212       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_slack_s_L", *IpCq().curr_slack_s_L());
    213       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_slack_s_U", *IpCq().curr_slack_s_U());
    214 
    215       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_v_L", *IpData().curr()->v_L());
    216       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_v_U", *IpData().curr()->v_U());
     200      IpData().curr()->x()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_x");
     201      IpData().curr()->s()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_s");
     202
     203      IpData().curr()->y_c()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_y_c");
     204      IpData().curr()->y_d()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_y_d");
     205
     206      IpCq().curr_slack_x_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_slack_x_L");
     207      IpCq().curr_slack_x_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_slack_x_U");
     208      IpData().curr()->z_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_z_L");
     209      IpData().curr()->z_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_z_U");
     210
     211      IpCq().curr_slack_s_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_slack_s_L");
     212      IpCq().curr_slack_s_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_slack_s_U");
     213      IpData().curr()->v_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_v_L");
     214      IpData().curr()->v_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_v_U");
    217215    }
    218216    if (Jnlst().ProduceOutput(J_MOREVECTOR, J_MAIN)) {
    219       Jnlst().PrintVector(J_MOREVECTOR, J_MAIN, "curr_grad_lag_x", *IpCq().curr_grad_lag_x());
    220       Jnlst().PrintVector(J_MOREVECTOR, J_MAIN, "curr_grad_lag_s", *IpCq().curr_grad_lag_s());
     217      IpCq().curr_grad_lag_x()->Print(Jnlst(), J_MOREVECTOR, J_MAIN, "curr_grad_lag_x");
     218      IpCq().curr_grad_lag_s()->Print(Jnlst(), J_MOREVECTOR, J_MAIN, "curr_grad_lag_s");
    221219      if (IsValid(IpData().delta())) {
    222         Jnlst().PrintVector(J_MOREVECTOR, J_MAIN,
    223                             "delta_x", *IpData().delta()->x());
    224         Jnlst().PrintVector(J_MOREVECTOR, J_MAIN,
    225                             "delta_s", *IpData().delta()->s());
    226         Jnlst().PrintVector(J_MOREVECTOR, J_MAIN,
    227                             "delta_y_c", *IpData().delta()->y_c());
    228         Jnlst().PrintVector(J_MOREVECTOR, J_MAIN,
    229                             "delta_y_d", *IpData().delta()->y_d());
    230         Jnlst().PrintVector(J_MOREVECTOR, J_MAIN,
    231                             "delta_z_L", *IpData().delta()->z_L());
    232         Jnlst().PrintVector(J_MOREVECTOR, J_MAIN,
    233                             "delta_z_U", *IpData().delta()->z_U());
    234         Jnlst().PrintVector(J_MOREVECTOR, J_MAIN,
    235                             "delta_v_L", *IpData().delta()->v_L());
    236         Jnlst().PrintVector(J_MOREVECTOR, J_MAIN,
    237                             "delta_v_U", *IpData().delta()->v_U());
     220        IpData().delta()->Print(Jnlst(), J_MOREVECTOR, J_MAIN, "delta");
    238221      }
    239222    }
     
    251234    }
    252235    if (Jnlst().ProduceOutput(J_VECTOR, J_MAIN)) {
    253       Jnlst().PrintVector(J_VECTOR, J_MAIN, "grad_f", *IpCq().curr_grad_f());
    254       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_c", *IpCq().curr_c());
    255       Jnlst().PrintVector(J_VECTOR, J_MAIN, "curr_d", *IpCq().curr_d());
    256       Jnlst().PrintVector(J_VECTOR, J_MAIN,
    257                           "curr_d - curr_s", *IpCq().curr_d_minus_s());
    258     }
     236      IpCq().curr_grad_f()->Print(Jnlst(), J_VECTOR, J_MAIN, "grad_f");
     237      IpCq().curr_c()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_c");
     238      IpCq().curr_d()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_d");
     239      IpCq().curr_d_minus_s()->Print(Jnlst(), J_VECTOR, J_MAIN,
     240                                     "curr_d - curr_s");
     241    }
     242
    259243    if (Jnlst().ProduceOutput(J_MATRIX, J_MAIN)) {
    260       Jnlst().PrintMatrix(J_MATRIX, J_MAIN, "jac_c", *IpCq().curr_jac_c());
    261       Jnlst().PrintMatrix(J_MATRIX, J_MAIN, "jac_d", *IpCq().curr_jac_d());
    262       Jnlst().PrintMatrix(J_MATRIX, J_MAIN, "h", *IpCq().curr_exact_hessian());
     244      IpCq().curr_jac_c()->Print(Jnlst(), J_MATRIX, J_MAIN, "jac_c");
     245      IpCq().curr_jac_d()->Print(Jnlst(), J_MATRIX, J_MAIN, "jac_d");
     246      IpCq().curr_exact_hessian()->Print(Jnlst(), J_MATRIX, J_MAIN, "h");
    263247    }
    264248
  • branches/dev/Algorithm/IpRestoMinC_1Nrm.cpp

    r416 r430  
    1616  DBG_SET_VERBOSITY(0);
    1717
    18   DefineIpoptType(MinC_1NrmRestorationPhase);
     18  DefineOptionsRegistrar(MinC_1NrmRestorationPhase);
    1919
    2020  MinC_1NrmRestorationPhase::MinC_1NrmRestorationPhase
     
    159159      }
    160160      if (Jnlst().ProduceOutput(J_VECTOR, J_LINE_SEARCH)) {
    161         Jnlst().PrintVector(J_VECTOR, J_LINE_SEARCH,
    162                             "x", *resto_ip_data->curr()->x());
    163         Jnlst().PrintVector(J_VECTOR, J_LINE_SEARCH,
    164                             "y_c", *resto_ip_data->curr()->y_c());
    165         Jnlst().PrintVector(J_VECTOR, J_LINE_SEARCH,
    166                             "y_d", *resto_ip_data->curr()->y_d());
    167         Jnlst().PrintVector(J_VECTOR, J_LINE_SEARCH,
    168                             "z_L", *resto_ip_data->curr()->z_L());
    169         Jnlst().PrintVector(J_VECTOR, J_LINE_SEARCH,
    170                             "z_U", *resto_ip_data->curr()->z_U());
    171         Jnlst().PrintVector(J_VECTOR, J_LINE_SEARCH,
    172                             "v_L", *resto_ip_data->curr()->v_L());
    173         Jnlst().PrintVector(J_VECTOR, J_LINE_SEARCH,
    174                             "v_U", *resto_ip_data->curr()->v_U());
     161        resto_ip_data->curr()->Print(Jnlst(), J_VECTOR, J_LINE_SEARCH, "curr");
    175162      }
    176163
  • branches/dev/Algorithm/IpRestoMinC_1Nrm.hpp

    r413 r430  
    1010#define __IPRESTOC_1NRM_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpRestoPhase.hpp"
    1413#include "IpIpoptAlg.hpp"
     
    1817{
    1918
    20   DeclareIpoptType(MinC_1NrmRestorationPhase);
     19  DeclareOptionsRegistrar(MinC_1NrmRestorationPhase);
    2120
    2221  /** Restoration Phase that minimizes the 1-norm of the constraint
  • branches/dev/Algorithm/IpRestoPhase.hpp

    r404 r430  
    1010#define __IPRESTOPHASE_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpAlgStrategy.hpp"
    1413#include "IpIpoptNLP.hpp"
  • branches/dev/Algorithm/IpRestoRestoPhase.hpp

    r191 r430  
    1010#define __IPRESTORESTOPHASE_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpRestoPhase.hpp"
    1413#include "IpIpoptAlg.hpp"
  • branches/dev/Algorithm/IpStdAugSystemSolver.cpp

    r428 r430  
    134134    augmented_rhs->SetComp(3, rhs_d);
    135135
    136     Jnlst().PrintMatrix(J_MATRIX, J_LINEAR_ALGEBRA, "KKT", *augmented_system_);
     136    augmented_system_->Print(Jnlst(), J_MATRIX, J_LINEAR_ALGEBRA, "KKT");
    137137    if (Jnlst().ProduceOutput(J_MOREMATRIX, J_LINEAR_ALGEBRA)) {
    138138      // ToDo: remove below here - for debug only
     
    155155      // ToDo: remove above here
    156156    }
    157     Jnlst().PrintVector(J_MOREVECTOR, J_LINEAR_ALGEBRA, "RHS", *augmented_rhs);
     157    augmented_rhs->Print(Jnlst(), J_MOREVECTOR, J_LINEAR_ALGEBRA, "RHS");
    158158
    159159    // Call the linear solver
     
    168168    if (retval==SYMSOLVER_SUCCESS) {
    169169      Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA, "Factorization successful.\n");
    170       Jnlst().PrintVector(J_MOREVECTOR, J_LINEAR_ALGEBRA, "SOL", *augmented_sol);
     170      augmented_sol->Print(Jnlst(), J_MOREVECTOR, J_LINEAR_ALGEBRA, "SOL");
    171171    }
    172172    else if (retval==SYMSOLVER_FATAL_ERROR) {
  • branches/dev/Algorithm/IpWarmStartIterateInitializer.cpp

    r414 r430  
    2222  DBG_SET_VERBOSITY(0);
    2323
    24   DefineIpoptType(WarmStartIterateInitializer);
     24  DefineOptionsRegistrar(WarmStartIterateInitializer);
    2525
    2626  WarmStartIterateInitializer::WarmStartIterateInitializer()
     
    7070    IpData().InitializeDataStructures(IpNLP(), true, true, true, true, true);
    7171
    72     Jnlst().PrintVector(J_VECTOR, J_INITIALIZATION, "user-provided x",
    73                         *IpData().curr()->x());
    74     Jnlst().PrintVector(J_VECTOR, J_INITIALIZATION, "user-provided y_c",
    75                         *IpData().curr()->y_c());
    76     Jnlst().PrintVector(J_VECTOR, J_INITIALIZATION, "user-provided y_d",
    77                         *IpData().curr()->y_d());
    78     Jnlst().PrintVector(J_VECTOR, J_INITIALIZATION, "user-provided z_L",
    79                         *IpData().curr()->z_L());
    80     Jnlst().PrintVector(J_VECTOR, J_INITIALIZATION, "user-provided z_U",
    81                         *IpData().curr()->z_U());
     72    IpData().curr()->x()->Print(Jnlst(), J_VECTOR, J_INITIALIZATION,
     73                                "user-provided x");
     74    IpData().curr()->y_c()->Print(Jnlst(), J_VECTOR, J_INITIALIZATION,
     75                                  "user-provided y_c");
     76    IpData().curr()->y_d()->Print(Jnlst(), J_VECTOR, J_INITIALIZATION,
     77                                  "user-provided y_d");
     78    IpData().curr()->z_L()->Print(Jnlst(), J_VECTOR, J_INITIALIZATION,
     79                                  "user-provided z_L");
     80    IpData().curr()->z_U()->Print(Jnlst(), J_VECTOR, J_INITIALIZATION,
     81                                  "user-provided z_U");
    8282    if (Jnlst().ProduceOutput(J_MOREVECTOR, J_INITIALIZATION)) {
    83       Jnlst().PrintVector(J_MOREVECTOR, J_INITIALIZATION, "d at user-provided x",
    84                           *IpCq().curr_d());
     83      IpCq().curr_d()->Print(Jnlst(), J_MOREVECTOR, J_INITIALIZATION,
     84                             "d at user-provided x");
    8585    }
    8686
     
    166166                        *IpData().curr()->v_U(), *IpNLP().Pd_U(),
    167167                        new_s, new_v_U);
    168       Jnlst().PrintVector(J_VECTOR, J_INITIALIZATION, "DELETEME new_s",
    169                           *new_s);
    170       Jnlst().PrintVector(J_VECTOR, J_INITIALIZATION, "DELETEME d_U",
    171                           *IpNLP().d_U());
    172       Jnlst().PrintVector(J_VECTOR, J_INITIALIZATION, "DELETEME new_v_U",
    173                           *new_v_U);
    174168
    175169      // Now submit the full modified point
     
    220214        *IpNLP().Pd_L(),
    221215        *IpNLP().Pd_U());
    222     Jnlst().PrintVector(J_VECTOR, J_INITIALIZATION, "DELETEME new_s cor",
    223                         *new_s);
    224216
    225217    // Push the multipliers
     
    255247    IpData().AcceptTrialPoint();
    256248
    257     Jnlst().PrintVector(J_VECTOR, J_INITIALIZATION, "initial x",
    258                         *IpData().curr()->x());
    259     Jnlst().PrintVector(J_VECTOR, J_INITIALIZATION, "initial s",
    260                         *IpData().curr()->s());
    261     Jnlst().PrintVector(J_VECTOR, J_INITIALIZATION, "initial y_c",
    262                         *IpData().curr()->y_c());
    263     Jnlst().PrintVector(J_VECTOR, J_INITIALIZATION, "initial y_d",
    264                         *IpData().curr()->y_d());
    265     Jnlst().PrintVector(J_VECTOR, J_INITIALIZATION, "initial z_L",
    266                         *IpData().curr()->z_L());
    267     Jnlst().PrintVector(J_VECTOR, J_INITIALIZATION, "initial z_U",
    268                         *IpData().curr()->z_U());
    269     Jnlst().PrintVector(J_VECTOR, J_INITIALIZATION, "initial v_L",
    270                         *IpData().curr()->v_L());
    271     Jnlst().PrintVector(J_VECTOR, J_INITIALIZATION, "initial v_U",
    272                         *IpData().curr()->v_U());
     249    IpData().curr()->x()->Print(Jnlst(), J_VECTOR, J_INITIALIZATION,
     250                                "initial x");
     251    IpData().curr()->s()->Print(Jnlst(), J_VECTOR, J_INITIALIZATION,
     252                                "initial s");
     253    IpData().curr()->y_c()->Print(Jnlst(), J_VECTOR, J_INITIALIZATION,
     254                                  "initial y_c");
     255    IpData().curr()->y_d()->Print(Jnlst(), J_VECTOR, J_INITIALIZATION,
     256                                  "initial y_d");
     257    IpData().curr()->z_L()->Print(Jnlst(), J_VECTOR, J_INITIALIZATION,
     258                                  "initial z_L");
     259    IpData().curr()->z_U()->Print(Jnlst(), J_VECTOR, J_INITIALIZATION,
     260                                  "initial z_U");
     261    IpData().curr()->v_L()->Print(Jnlst(), J_VECTOR, J_INITIALIZATION,
     262                                  "initial v_L");
     263    IpData().curr()->v_U()->Print(Jnlst(), J_VECTOR, J_INITIALIZATION,
     264                                  "initial v_U");
    273265    if (Jnlst().ProduceOutput(J_MOREVECTOR, J_INITIALIZATION)) {
    274       Jnlst().PrintVector(J_MOREVECTOR, J_INITIALIZATION, "initial slack_x_L",
    275                           *IpCq().curr_slack_x_L());
    276       Jnlst().PrintVector(J_MOREVECTOR, J_INITIALIZATION, "initial slack_x_U",
    277                           *IpCq().curr_slack_x_U());
    278       Jnlst().PrintVector(J_MOREVECTOR, J_INITIALIZATION, "initial slack_s_L",
    279                           *IpCq().curr_slack_s_L());
    280       Jnlst().PrintVector(J_MOREVECTOR, J_INITIALIZATION, "initial slack_s_U",
    281                           *IpCq().curr_slack_s_U());
     266      IpCq().curr_slack_x_L()->Print(Jnlst(), J_MOREVECTOR, J_INITIALIZATION,
     267                                     "initial slack_x_L");
     268      IpCq().curr_slack_x_U()->Print(Jnlst(), J_MOREVECTOR, J_INITIALIZATION,
     269                                     "initial slack_x_U");
     270      IpCq().curr_slack_s_L()->Print(Jnlst(), J_MOREVECTOR, J_INITIALIZATION,
     271                                     "initial slack_s_L");
     272      IpCq().curr_slack_s_U()->Print(Jnlst(), J_MOREVECTOR, J_INITIALIZATION,
     273                                     "initial slack_s_U");
    282274    }
    283275
     
    296288    SmartPtr<Vector> new_mults = curr_mults.MakeNewCopy();
    297289    adapt_to_target_mu(*new_slacks, *new_mults, warm_start_target_mu_);
    298     Jnlst().PrintVector(J_VECTOR, J_INITIALIZATION, "DELETEME new_slacks",
    299                         *new_slacks);
    300290    new_slacks->Axpy(-1, curr_slacks); // this is now correction step
    301291    SmartPtr<Vector> new_vars = curr_vars.MakeNew();
  • branches/dev/Algorithm/IpWarmStartIterateInitializer.hpp

    r390 r430  
    1010#define __IPWARMSTARTITERATEINITIALIZER_HPP__
    1111
    12 #include "IpUtils.hpp"
    1312#include "IpIterateInitializer.hpp"
    1413#include "IpEqMultCalculator.hpp"
    15 #include "IpIpoptType.hpp"
    1614
    1715namespace Ipopt
    1816{
    1917
    20   DeclareIpoptType(WarmStartIterateInitializer);
     18  DeclareOptionsRegistrar(WarmStartIterateInitializer);
    2119
    2220  /** Class implementing an initialization procedure for warm starts.
  • branches/dev/Algorithm/LinearSolvers/IpMa27TSolverInterface.cpp

    r428 r430  
    3939  DBG_SET_VERBOSITY(0);
    4040
    41   DefineIpoptType(Ma27TSolverInterface);
     41  DefineOptionsRegistrar(Ma27TSolverInterface);
    4242
    4343  Ma27TSolverInterface::Ma27TSolverInterface()
  • branches/dev/Algorithm/LinearSolvers/IpMa27TSolverInterface.hpp

    r428 r430  
    1111
    1212#include "IpSparseSymLinearSolverInterface.hpp"
    13 #include "IpIpoptType.hpp"
    1413
    1514namespace Ipopt
    1615{
    1716
    18   DeclareIpoptType(Ma27TSolverInterface);
     17  DeclareOptionsRegistrar(Ma27TSolverInterface);
    1918
    2019  /** Interface to the symmetric linear solver MA27, derived from
  • branches/dev/Algorithm/LinearSolvers/Makefile.am

    r428 r430  
    99AUTOMAKE_OPTIONS = foreign
    1010
    11 noinst_LIBRARIES = libpdfullspace.a
     11noinst_LIBRARIES = liblinsolvers.a
    1212
    13 libpdfullspace_a_SOURCES = \
    14         IpAugRestoSystemSolver.cpp IpAugRestoSystemSolver.hpp \
    15         IpAugSystemSolver.hpp \
    16         IpStdAugSystemSolver.hpp IpStdAugSystemSolver.cpp \
    17         IpLeastSquareMults.hpp IpLeastSquareMults.cpp \
    18         IpMc19TSymScalingMethod.hpp IpMc19TSymScalingMethod.cpp \
    19         IpPDFullSpaceSolver.cpp IpPDFullSpaceSolver.hpp \
    20         IpTripletHelper.hpp IpTripletHelper.cpp \
     13liblinsolvers_a_SOURCES = \
     14        IpMa27TSolverInterface.cpp IpMa27TSolverInterface.hpp \
     15        IpMc19TSymScalingMethod.cpp IpMc19TSymScalingMethod.hpp \
     16        IpSparseSymLinearSolverInterface.hpp \
    2117        IpSymLinearSolver.hpp \
    22         IpTSymScalingMethod.hpp \
    23         IpTSymLinearSolver.hpp \
    24         IpTSymLinearSolver.cpp \
    25         IpSparseSymLinearSolverInterface.hpp \
    26         IpMa27TSolverInterface.cpp IpMa27TSolverInterface.hpp \
    2718        IpTripletToCSRConverter.cpp IpTripletToCSRConverter.hpp \
    28         IpPDPerturbationHandler.cpp IpPDPerturbationHandler.hpp
     19        IpTSymLinearSolver.cpp IpTSymLinearSolver.hpp \
     20        IpTSymScalingMethod.hpp
    2921
    3022if HAVE_PARDISO
    31   libpdfullspace_a_SOURCES += \
     23  liblinsolvers_a_SOURCES += \
    3224        IpPardisoSolverInterface.cpp IpPardisoSolverInterface.hpp
    3325endif
    3426
    3527if HAVE_TAUCS
    36   libpdfullspace_a_SOURCES += \
     28  liblinsolvers_a_SOURCES += \
    3729        IpTAUCSSolverInterface.cpp IpTAUCSSolverInterface.hpp
    3830endif
     
    4032
    4133CXXFLAGS += -I$(srcdir)/../../Common \
    42         -I$(srcdir)/../../Interfaces \
    43         -I$(srcdir)/../../LinAlgImpl/Serial \
    44         -I$(srcdir)/../../Algorithm
     34        -I$(srcdir)/../../LinAlg \
     35        -I$(srcdir)/../../LinAlg/TMatrices \
     36        -I$(srcdir)/.. \
     37        -I$(srcdir)/../../Interfaces
    4538
    4639# Astyle stuff
    4740
    4841ASTYLE_FILES = \
    49         IpAugRestoSystemSolver.cppbak IpAugRestoSystemSolver.hppbak \
    50         IpAugSystemSolver.hppbak \
    51         IpStdAugSystemSolver.hppbak IpStdAugSystemSolver.cppbak \
    52         IpLeastSquareMults.hppbak IpLeastSquareMults.cppbak \
    53         IpMc19TSymScalingMethod.hppbak IpMc19TSymScalingMethod.cppbak \
    54         IpPDFullSpaceSolver.cppbak IpPDFullSpaceSolver.hppbak \
    55         IpTripletHelper.hppbak IpTripletHelper.cppbak \
     42        IpMa27TSolverInterface.cppbak IpMa27TSolverInterface.hppbak \
     43        IpMc19TSymScalingMethod.cppbak IpMc19TSymScalingMethod.hppbak \
     44        IpSparseSymLinearSolverInterface.hppbak \
    5645        IpSymLinearSolver.hppbak \
    57         IpTSymScalingMethod.hppbak \
    58         IpTSymLinearSolver.hppbak \
    59         IpTSymLinearSolver.cppbak \
    60         IpSparseSymLinearSolverInterface.hppbak \
    61         IpMa27TSolverInterface.cppbak IpMa27TSolverInterface.hppbak \
    6246        IpTripletToCSRConverter.cppbak IpTripletToCSRConverter.hppbak \
    63         IpPardisoSolverInterface.cppbak IpPardisoSolverInterface.hppbak \
    64         IpTAUCSSolverInterface.cppbak IpTAUCSSolverInterface.hppbak \
    65         IpPDPerturbationHandler.cppbak IpPDPerturbationHandler.hppbak
     47        IpTSymLinearSolver.cppbak IpTSymLinearSolver.hppbak \
     48        IpTSymScalingMethod.hppbak
     49        IpPardisoSolverInterface.cppbak IpPardisoSolverInterface.hppbak
     50        IpTAUCSSolverInterface.cppbak IpTAUCSSolverInterface.hppbak
     51
    6652
    6753ASTYLE = @ASTYLE@
  • branches/dev/Algorithm/LinearSolvers/Makefile.in

    r428 r430  
    2121# Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
    2222
    23 SOURCES = $(libpdfullspace_a_SOURCES)
     23SOURCES = $(liblinsolvers_a_SOURCES)
    2424
    2525srcdir = @srcdir@
     
    5050@HAVE_TAUCS_TRUE@       IpTAUCSSolverInterface.cpp IpTAUCSSolverInterface.hpp
    5151
    52 subdir = PDSystemImpl/PDFullSpace
     52subdir = Algorithm/LinearSolvers
    5353DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
    5454ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
     
    6060CONFIG_CLEAN_FILES =
    6161LIBRARIES = $(noinst_LIBRARIES)
    62 libpdfullspace_a_AR = $(AR) $(ARFLAGS)
    63 libpdfullspace_a_LIBADD =
    64 am__libpdfullspace_a_SOURCES_DIST = IpAugRestoSystemSolver.cpp \
    65         IpAugRestoSystemSolver.hpp IpAugSystemSolver.hpp \
    66         IpStdAugSystemSolver.hpp IpStdAugSystemSolver.cpp \
    67         IpLeastSquareMults.hpp IpLeastSquareMults.cpp \
    68         IpMc19TSymScalingMethod.hpp IpMc19TSymScalingMethod.cpp \
    69         IpPDFullSpaceSolver.cpp IpPDFullSpaceSolver.hpp \
    70         IpTripletHelper.hpp IpTripletHelper.cpp IpSymLinearSolver.hpp \
    71         IpTSymScalingMethod.hpp IpTSymLinearSolver.hpp \
    72         IpTSymLinearSolver.cpp IpSparseSymLinearSolverInterface.hpp \
    73         IpMa27TSolverInterface.cpp IpMa27TSolverInterface.hpp \
     62liblinsolvers_a_AR = $(AR) $(ARFLAGS)
     63liblinsolvers_a_LIBADD =
     64am__liblinsolvers_a_SOURCES_DIST = IpMa27TSolverInterface.cpp \
     65        IpMa27TSolverInterface.hpp IpMc19TSymScalingMethod.cpp \
     66        IpMc19TSymScalingMethod.hpp \
     67        IpSparseSymLinearSolverInterface.hpp IpSymLinearSolver.hpp \
    7468        IpTripletToCSRConverter.cpp IpTripletToCSRConverter.hpp \
    75         IpPDPerturbationHandler.cpp IpPDPerturbationHandler.hpp \
    76         IpPardisoSolverInterface.cpp IpPardisoSolverInterface.hpp \
    77         IpTAUCSSolverInterface.cpp IpTAUCSSolverInterface.hpp
     69        IpTSymLinearSolver.cpp IpTSymLinearSolver.hpp \
     70        IpTSymScalingMethod.hpp IpPardisoSolverInterface.cpp \
     71        IpPardisoSolverInterface.hpp IpTAUCSSolverInterface.cpp \
     72        IpTAUCSSolverInterface.hpp
    7873@HAVE_PARDISO_TRUE@am__objects_1 = IpPardisoSolverInterface.$(OBJEXT)
    7974@HAVE_TAUCS_TRUE@am__objects_2 = IpTAUCSSolverInterface.$(OBJEXT)
    80 am_libpdfullspace_a_OBJECTS = IpAugRestoSystemSolver.$(OBJEXT) \
    81         IpStdAugSystemSolver.$(OBJEXT) IpLeastSquareMults.$(OBJEXT) \
     75am_liblinsolvers_a_OBJECTS = IpMa27TSolverInterface.$(OBJEXT) \
    8276        IpMc19TSymScalingMethod.$(OBJEXT) \
    83         IpPDFullSpaceSolver.$(OBJEXT) IpTripletHelper.$(OBJEXT) \
    84         IpTSymLinearSolver.$(OBJEXT) IpMa27TSolverInterface.$(OBJEXT) \
    85         IpTripletToCSRConverter.$(OBJEXT) \
    86         IpPDPerturbationHandler.$(OBJEXT) $(am__objects_1) \
    87         $(am__objects_2)
    88 libpdfullspace_a_OBJECTS = $(am_libpdfullspace_a_OBJECTS)
     77        IpTripletToCSRConverter.$(OBJEXT) IpTSymLinearSolver.$(OBJEXT) \
     78        $(am__objects_1) $(am__objects_2)
     79liblinsolvers_a_OBJECTS = $(am_liblinsolvers_a_OBJECTS)
    8980DEFAULT_INCLUDES = -I. -I$(srcdir) -I$(top_builddir)/inc
    9081depcomp = $(SHELL) $(top_srcdir)/depcomp
     
    9990CCLD = $(CC)
    10091LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
    101 SOURCES = $(libpdfullspace_a_SOURCES)
    102 DIST_SOURCES = $(am__libpdfullspace_a_SOURCES_DIST)
     92SOURCES = $(liblinsolvers_a_SOURCES)
     93DIST_SOURCES = $(am__liblinsolvers_a_SOURCES_DIST)
    10394ETAGS = etags
    10495CTAGS = ctags
     
    132123BUILDHSL_FALSE = @BUILDHSL_FALSE@
    133124BUILDHSL_TRUE = @BUILDHSL_TRUE@
    134 BUILDLAPACKDIR_FALSE = @BUILDLAPACKDIR_FALSE@
    135 BUILDLAPACKDIR_TRUE = @BUILDLAPACKDIR_TRUE@
    136 BUILDLAPACK_FALSE = @BUILDLAPACK_FALSE@
    137 BUILDLAPACK_TRUE = @BUILDLAPACK_TRUE@
    138125BUILDMA27_FALSE = @BUILDMA27_FALSE@
    139126BUILDMA27_TRUE = @BUILDMA27_TRUE@
     
    148135CXXDEPMODE = @CXXDEPMODE@
    149136CXXFLAGS = @CXXFLAGS@ -I$(srcdir)/../../Common \
    150         -I$(srcdir)/../../Interfaces \
    151         -I$(srcdir)/../../LinAlgImpl/Serial \
    152         -I$(srcdir)/../../Algorithm
     137        -I$(srcdir)/../../LinAlg -I$(srcdir)/../../LinAlg/TMatrices \
     138        -I$(srcdir)/.. -I$(srcdir)/../../Interfaces
    153139CXXLIBS = @CXXLIBS@
    154140CYGPATH_W = @CYGPATH_W@
     
    236222target_alias = @target_alias@
    237223AUTOMAKE_OPTIONS = foreign
    238 noinst_LIBRARIES = libpdfullspace.a
    239 libpdfullspace_a_SOURCES = IpAugRestoSystemSolver.cpp \
    240         IpAugRestoSystemSolver.hpp IpAugSystemSolver.hpp \
    241         IpStdAugSystemSolver.hpp IpStdAugSystemSolver.cpp \
    242         IpLeastSquareMults.hpp IpLeastSquareMults.cpp \
    243         IpMc19TSymScalingMethod.hpp IpMc19TSymScalingMethod.cpp \
    244         IpPDFullSpaceSolver.cpp IpPDFullSpaceSolver.hpp \
    245         IpTripletHelper.hpp IpTripletHelper.cpp IpSymLinearSolver.hpp \
    246         IpTSymScalingMethod.hpp IpTSymLinearSolver.hpp \
    247         IpTSymLinearSolver.cpp IpSparseSymLinearSolverInterface.hpp \
    248         IpMa27TSolverInterface.cpp IpMa27TSolverInterface.hpp \
     224noinst_LIBRARIES = liblinsolvers.a
     225liblinsolvers_a_SOURCES = IpMa27TSolverInterface.cpp \
     226        IpMa27TSolverInterface.hpp IpMc19TSymScalingMethod.cpp \
     227        IpMc19TSymScalingMethod.hpp \
     228        IpSparseSymLinearSolverInterface.hpp IpSymLinearSolver.hpp \
    249229        IpTripletToCSRConverter.cpp IpTripletToCSRConverter.hpp \
    250         IpPDPerturbationHandler.cpp IpPDPerturbationHandler.hpp \
    251         $(am__append_1) $(am__append_2)
     230        IpTSymLinearSolver.cpp IpTSymLinearSolver.hpp \
     231        IpTSymScalingMethod.hpp $(am__append_1) $(am__append_2)
    252232
    253233# Astyle stuff
    254234ASTYLE_FILES = \
    255         IpAugRestoSystemSolver.cppbak IpAugRestoSystemSolver.hppbak \
    256         IpAugSystemSolver.hppbak \
    257         IpStdAugSystemSolver.hppbak IpStdAugSystemSolver.cppbak \
    258         IpLeastSquareMults.hppbak IpLeastSquareMults.cppbak \
    259         IpMc19TSymScalingMethod.hppbak IpMc19TSymScalingMethod.cppbak \
    260         IpPDFullSpaceSolver.cppbak IpPDFullSpaceSolver.hppbak \
    261         IpTripletHelper.hppbak IpTripletHelper.cppbak \
     235        IpMa27TSolverInterface.cppbak IpMa27TSolverInterface.hppbak \
     236        IpMc19TSymScalingMethod.cppbak IpMc19TSymScalingMethod.hppbak \
     237        IpSparseSymLinearSolverInterface.hppbak \
    262238        IpSymLinearSolver.hppbak \
    263         IpTSymScalingMethod.hppbak \
    264         IpTSymLinearSolver.hppbak \
    265         IpTSymLinearSolver.cppbak \
    266         IpSparseSymLinearSolverInterface.hppbak \
    267         IpMa27TSolverInterface.cppbak IpMa27TSolverInterface.hppbak \
    268239        IpTripletToCSRConverter.cppbak IpTripletToCSRConverter.hppbak \
    269         IpPardisoSolverInterface.cppbak IpPardisoSolverInterface.hppbak \
    270         IpTAUCSSolverInterface.cppbak IpTAUCSSolverInterface.hppbak \
    271         IpPDPerturbationHandler.cppbak IpPDPerturbationHandler.hppbak
     240        IpTSymLinearSolver.cppbak IpTSymLinearSolver.hppbak \
     241        IpTSymScalingMethod.hppbak
    272242
    273243CLEANFILES = $(ASTYLE_FILES)
     
    286256          esac; \
    287257        done; \
    288         echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign  PDSystemImpl/PDFullSpace/Makefile'; \
     258        echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign  Algorithm/LinearSolvers/Makefile'; \
    289259        cd $(top_srcdir) && \
    290           $(AUTOMAKE) --foreign  PDSystemImpl/PDFullSpace/Makefile
     260          $(AUTOMAKE) --foreign  Algorithm/LinearSolvers/Makefile
    291261.PRECIOUS: Makefile
    292262Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
     
    309279clean-noinstLIBRARIES:
    310280        -test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES)
    311 libpdfullspace.a: $(libpdfullspace_a_OBJECTS) $(libpdfullspace_a_DEPENDENCIES)
    312         -rm -f libpdfullspace.a
    313         $(libpdfullspace_a_AR) libpdfullspace.a $(libpdfullspace_a_OBJECTS) $(libpdfullspace_a_LIBADD)
    314         $(RANLIB) libpdfullspace.a
     281liblinsolvers.a: $(liblinsolvers_a_OBJECTS) $(liblinsolvers_a_DEPENDENCIES)
     282        -rm -f liblinsolvers.a
     283        $(liblinsolvers_a_AR) liblinsolvers.a $(liblinsolvers_a_OBJECTS) $(liblinsolvers_a_LIBADD)
     284        $(RANLIB) liblinsolvers.a
    315285
    316286mostlyclean-compile:
     
    320290        -rm -f *.tab.c
    321291
    322 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpAugRestoSystemSolver.Po@am__quote@
    323 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpLeastSquareMults.Po@am__quote@
    324292@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpMa27TSolverInterface.Po@am__quote@
    325293@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpMc19TSymScalingMethod.Po@am__quote@
    326 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpPDFullSpaceSolver.Po@am__quote@
    327 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpPDPerturbationHandler.Po@am__quote@
    328294@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpPardisoSolverInterface.Po@am__quote@
    329 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpStdAugSystemSolver.Po@am__quote@
    330295@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpTAUCSSolverInterface.Po@am__quote@
    331296@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpTSymLinearSolver.Po@am__quote@
    332 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpTripletHelper.Po@am__quote@
    333297@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpTripletToCSRConverter.Po@am__quote@
    334298
     
    512476        uninstall-am uninstall-info-am
    513477
     478        IpPardisoSolverInterface.cppbak IpPardisoSolverInterface.hppbak
     479        IpTAUCSSolverInterface.cppbak IpTAUCSSolverInterface.hppbak
    514480
    515481astyle: $(ASTYLE_FILES)
  • branches/dev/Algorithm/Makefile.am

    r378 r430  
    99AUTOMAKE_OPTIONS = foreign
    1010
     11SUBDIRS = LinearSolvers
     12
     13includeipoptdir = $(includedir)/ipopt
     14includeipopt_HEADERS = \
     15        IpIpoptCalculatedQuantities.hpp \
     16        IpIpoptData.hpp \
     17        IpIpoptNLP.hpp \
     18        IpIteratesVector.hpp \
     19        IpNLPScaling.hpp
     20
    1121noinst_LIBRARIES = libipoptalg.a
    1222
    1323libipoptalg_a_SOURCES = \
    14         IpAlgBuilder.hpp IpAlgBuilder.cpp \
     24        IpAdaptiveMuUpdate.cpp IpAdaptiveMuUpdate.hpp \
     25        IpAlgBuilder.cpp IpAlgBuilder.hpp \
    1526        IpAlgStrategy.hpp \
     27        IpAugRestoSystemSolver.cpp IpAugRestoSystemSolver.hpp \
     28        IpAugSystemSolver.hpp \
    1629        IpConvCheck.hpp \
    17         IpDefaultIterateInitializer.hpp IpDefaultIterateInitializer.cpp \
    18         IpWarmStartIterateInitializer.hpp IpWarmStartIterateInitializer.cpp \
     30        IpDefaultIterateInitializer.cpp IpDefaultIterateInitializer.hpp \
     31        IpEqMultCalculator.hpp \
    1932        IpFilter.cpp IpFilter.hpp \
    2033        IpFilterLineSearch.cpp IpFilterLineSearch.hpp \
    21         IpGradientScaling.hpp IpGradientScaling.cpp \
     34        IpGradientScaling.cpp IpGradientScaling.hpp \
    2235        IpIpoptAlg.cpp IpIpoptAlg.hpp \
    2336        IpIpoptCalculatedQuantities.cpp IpIpoptCalculatedQuantities.hpp \
    2437        IpIpoptData.cpp IpIpoptData.hpp \
    25         IpIpoptNLP.hpp  \
     38        IpIpoptNLP.hpp \
    2639        IpIterateInitializer.hpp \
    27         IpIteratesVector.hpp IpIteratesVector.cpp \
     40        IpIteratesVector.cpp IpIteratesVector.hpp \
    2841        IpIterationOutput.hpp \
     42        IpLeastSquareMults.cpp IpLeastSquareMults.hpp \
    2943        IpLineSearch.hpp \
    30         IpLoqoMuOracle.hpp IpLoqoMuOracle.cpp \
    31         IpMonotoneMuUpdate.hpp IpMonotoneMuUpdate.cpp \
     44        IpLoqoMuOracle.cpp IpLoqoMuOracle.hpp \
     45        IpMonotoneMuUpdate.cpp IpMonotoneMuUpdate.hpp \
    3246        IpMuOracle.hpp \
    3347        IpMuUpdate.hpp \
    34         IpAdaptiveMuUpdate.hpp IpAdaptiveMuUpdate.cpp \
    35         IpNLPScaling.hpp IpNLPScaling.cpp \
     48        IpNLPScaling.cpp IpNLPScaling.hpp \
    3649        IpOptErrorConvCheck.cpp IpOptErrorConvCheck.hpp \
    3750        IpOrigIpoptNLP.cpp IpOrigIpoptNLP.hpp \
    38         IpOrigIterationOutput.hpp IpOrigIterationOutput.cpp \
    39         IpProbingMuOracle.hpp IpProbingMuOracle.cpp \
    40         IpQualityFunctionMuOracle.hpp IpQualityFunctionMuOracle.cpp \
     51        IpOrigIterationOutput.cpp IpOrigIterationOutput.hpp \
     52        IpPDFullSpaceSolver.cpp IpPDFullSpaceSolver.hpp \
     53        IpPDPerturbationHandler.cpp IpPDPerturbationHandler.hpp \
     54        IpPDSystemSolver.hpp \
     55        IpProbingMuOracle.cpp IpProbingMuOracle.hpp \
     56        IpQualityFunctionMuOracle.cpp IpQualityFunctionMuOracle.hpp \
    4157        IpRestoFilterConvCheck.cpp IpRestoFilterConvCheck.hpp \
    42         IpRestoIpoptNLP.hpp IpRestoIpoptNLP.cpp \
    43         IpRestoIterateInitializer.hpp IpRestoIterateInitializer.cpp \
    44         IpRestoIterationOutput.hpp IpRestoIterationOutput.cpp \
     58        IpRestoIpoptNLP.cpp IpRestoIpoptNLP.hpp \
     59        IpRestoIterateInitializer.cpp IpRestoIterateInitializer.hpp \
     60        IpRestoIterationOutput.cpp IpRestoIterationOutput.hpp \
    4561        IpRestoMinC_1Nrm.cpp IpRestoMinC_1Nrm.hpp \
    4662        IpRestoPhase.hpp \
    47         IpRestoRestoPhase.hpp IpRestoRestoPhase.cpp \
    48         IpUserScaling.cpp IpUserScaling.hpp
     63        IpRestoRestoPhase.cpp IpRestoRestoPhase.hpp \
     64        IpStdAugSystemSolver.cpp IpStdAugSystemSolver.hpp \
     65        IpUserScaling.cpp IpUserScaling.hpp \
     66        IpWarmStartIterateInitializer.cpp IpWarmStartIterateInitializer.hpp
    4967
    50 CXXFLAGS += -I$(srcdir)/../Common
    51 CXXFLAGS += -I$(srcdir)/../Interfaces
    52 CXXFLAGS += -I$(srcdir)/../PDSystemImpl/PDFullSpace
    53 CXXFLAGS += -I$(srcdir)/../LinAlgImpl/Serial
     68CXXFLAGS += -I$(srcdir)/../Common \
     69        -I$(srcdir)/../LinAlg \
     70        -I$(srcdir)/../LinAlg/TMatrices \
     71        -I$(srcdir)/../Interfaces \
     72        -I$(srcdir)/LinearSolvers
    5473
    5574# Astyle stuff
    5675
    5776ASTYLE_FILES = \
    58         IpAlgBuilder.hppbak IpAlgBuilder.cppbak \
     77        IpAdaptiveMuUpdate.cppbak IpAdaptiveMuUpdate.hppbak \
     78        IpAlgBuilder.cppbak IpAlgBuilder.hppbak \
    5979        IpAlgStrategy.hppbak \
     80        IpAugRestoSystemSolver.cppbak IpAugRestoSystemSolver.hppbak \
     81        IpAugSystemSolver.hppbak \
    6082        IpConvCheck.hppbak \
    61         IpDefaultIterateInitializer.hppbak IpDefaultIterateInitializer.cppbak \
    62         IpWarmStartIterateInitializer.hppbak IpWarmStartIterateInitializer.cppbak \
     83        IpDefaultIterateInitializer.cppbak IpDefaultIterateInitializer.hppbak \
     84        IpEqMultCalculator.hppbak \
    6385        IpFilter.cppbak IpFilter.hppbak \
    6486        IpFilterLineSearch.cppbak IpFilterLineSearch.hppbak \
    65         IpGradientScaling.hppbak IpGradientScaling.cppbak \
     87        IpGradientScaling.cppbak IpGradientScaling.hppbak \
    6688        IpIpoptAlg.cppbak IpIpoptAlg.hppbak \
    6789        IpIpoptCalculatedQuantities.cppbak IpIpoptCalculatedQuantities.hppbak \
     
    6991        IpIpoptNLP.hppbak \
    7092        IpIterateInitializer.hppbak \
    71         IpIteratesVector.hppbak IpIteratesVector.cppbak \
     93        IpIteratesVector.cppbak IpIteratesVector.hppbak \
    7294        IpIterationOutput.hppbak \
     95        IpLeastSquareMults.cppbak IpLeastSquareMults.hppbak \
    7396        IpLineSearch.hppbak \
    74         IpLoqoMuOracle.hppbak IpLoqoMuOracle.cppbak \
    75         IpMonotoneMuUpdate.hppbak IpMonotoneMuUpdate.cppbak \
     97        IpLoqoMuOracle.cppbak IpLoqoMuOracle.hppbak \
     98        IpMonotoneMuUpdate.cppbak IpMonotoneMuUpdate.hppbak \
    7699        IpMuOracle.hppbak \
    77100        IpMuUpdate.hppbak \
    78         IpAdaptiveMuUpdate.hppbak IpAdaptiveMuUpdate.cppbak \
    79         IpNLPScaling.hppbak IpNLPScaling.cppbak \
     101        IpNLPScaling.cppbak IpNLPScaling.hppbak \
    80102        IpOptErrorConvCheck.cppbak IpOptErrorConvCheck.hppbak \
    81103        IpOrigIpoptNLP.cppbak IpOrigIpoptNLP.hppbak \
    82         IpOrigIterationOutput.hppbak IpOrigIterationOutput.cppbak \
    83         IpProbingMuOracle.hppbak IpProbingMuOracle.cppbak \
    84         IpQualityFunctionMuOracle.hppbak IpQualityFunctionMuOracle.cppbak \
     104        IpOrigIterationOutput.cppbak IpOrigIterationOutput.hppbak \
     105        IpPDFullSpaceSolver.cppbak IpPDFullSpaceSolver.hppbak \
     106        IpPDPerturbationHandler.cppbak IpPDPerturbationHandler.hppbak \
     107        IpPDSystemSolver.hppbak \
     108        IpProbingMuOracle.cppbak IpProbingMuOracle.hppbak \
     109        IpQualityFunctionMuOracle.cppbak IpQualityFunctionMuOracle.hppbak \
    85110        IpRestoFilterConvCheck.cppbak IpRestoFilterConvCheck.hppbak \
    86         IpRestoIpoptNLP.hppbak IpRestoIpoptNLP.cppbak \
    87         IpRestoIterateInitializer.hppbak IpRestoIterateInitializer.cppbak \
    88         IpRestoIterationOutput.hppbak IpRestoIterationOutput.cppbak \
     111        IpRestoIpoptNLP.cppbak IpRestoIpoptNLP.hppbak \
     112        IpRestoIterateInitializer.cppbak IpRestoIterateInitializer.hppbak \
     113        IpRestoIterationOutput.cppbak IpRestoIterationOutput.hppbak \
    89114        IpRestoMinC_1Nrm.cppbak IpRestoMinC_1Nrm.hppbak \
    90115        IpRestoPhase.hppbak \
    91         IpRestoRestoPhase.hppbak IpRestoRestoPhase.cppbak \
    92         IpUserScaling.cppbak IpUserScaling.hppbak
     116        IpRestoRestoPhase.cppbak IpRestoRestoPhase.hppbak \
     117        IpStdAugSystemSolver.cppbak IpStdAugSystemSolver.hppbak \
     118        IpUserScaling.cppbak IpUserScaling.hppbak \
     119        IpWarmStartIterateInitializer.cppbak IpWarmStartIterateInitializer.hppbak
    93120
    94121ASTYLE = @ASTYLE@
  • branches/dev/Algorithm/Makefile.in

    r382 r430  
    2020
    2121# Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
     22
    2223
    2324SOURCES = $(libipoptalg_a_SOURCES)
     
    4546build_triplet = @build@
    4647subdir = Algorithm
    47 DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
     48DIST_COMMON = $(includeipopt_HEADERS) $(srcdir)/Makefile.am \
     49        $(srcdir)/Makefile.in
    4850ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
    4951am__aclocal_m4_deps = $(top_srcdir)/configure.ac
     
    5658libipoptalg_a_AR = $(AR) $(ARFLAGS)
    5759libipoptalg_a_LIBADD =
    58 am_libipoptalg_a_OBJECTS = IpAlgBuilder.$(OBJEXT) \
    59         IpDefaultIterateInitializer.$(OBJEXT) \
    60         IpWarmStartIterateInitializer.$(OBJEXT) IpFilter.$(OBJEXT) \
     60am_libipoptalg_a_OBJECTS = IpAdaptiveMuUpdate.$(OBJEXT) \
     61        IpAlgBuilder.$(OBJEXT) IpAugRestoSystemSolver.$(OBJEXT) \
     62        IpDefaultIterateInitializer.$(OBJEXT) IpFilter.$(OBJEXT) \
    6163        IpFilterLineSearch.$(OBJEXT) IpGradientScaling.$(OBJEXT) \
    6264        IpIpoptAlg.$(OBJEXT) IpIpoptCalculatedQuantities.$(OBJEXT) \
    6365        IpIpoptData.$(OBJEXT) IpIteratesVector.$(OBJEXT) \
    64         IpLoqoMuOracle.$(OBJEXT) IpMonotoneMuUpdate.$(OBJEXT) \
    65         IpAdaptiveMuUpdate.$(OBJEXT) IpNLPScaling.$(OBJEXT) \
     66        IpLeastSquareMults.$(OBJEXT) IpLoqoMuOracle.$(OBJEXT) \
     67        IpMonotoneMuUpdate.$(OBJEXT) IpNLPScaling.$(OBJEXT) \
    6668        IpOptErrorConvCheck.$(OBJEXT) IpOrigIpoptNLP.$(OBJEXT) \
    67         IpOrigIterationOutput.$(OBJEXT) IpProbingMuOracle.$(OBJEXT) \
     69        IpOrigIterationOutput.$(OBJEXT) IpPDFullSpaceSolver.$(OBJEXT) \
     70        IpPDPerturbationHandler.$(OBJEXT) IpProbingMuOracle.$(OBJEXT) \
    6871        IpQualityFunctionMuOracle.$(OBJEXT) \
    6972        IpRestoFilterConvCheck.$(OBJEXT) IpRestoIpoptNLP.$(OBJEXT) \
    7073        IpRestoIterateInitializer.$(OBJEXT) \
    7174        IpRestoIterationOutput.$(OBJEXT) IpRestoMinC_1Nrm.$(OBJEXT) \
    72         IpRestoRestoPhase.$(OBJEXT) IpUserScaling.$(OBJEXT)
     75        IpRestoRestoPhase.$(OBJEXT) IpStdAugSystemSolver.$(OBJEXT) \
     76        IpUserScaling.$(OBJEXT) \
     77        IpWarmStartIterateInitializer.$(OBJEXT)
    7378libipoptalg_a_OBJECTS = $(am_libipoptalg_a_OBJECTS)
    7479DEFAULT_INCLUDES = -I. -I$(srcdir) -I$(top_builddir)/inc
     
    8691SOURCES = $(libipoptalg_a_SOURCES)
    8792DIST_SOURCES = $(libipoptalg_a_SOURCES)
     93RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \
     94        html-recursive info-recursive install-data-recursive \
     95        install-exec-recursive install-info-recursive \
     96        install-recursive installcheck-recursive installdirs-recursive \
     97        pdf-recursive ps-recursive uninstall-info-recursive \
     98        uninstall-recursive
     99am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
     100am__vpath_adj = case $$p in \
     101    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
     102    *) f=$$p;; \
     103  esac;
     104am__strip_dir = `echo $$p | sed -e 's|^.*/||'`;
     105am__installdirs = "$(DESTDIR)$(includeipoptdir)"
     106includeipoptHEADERS_INSTALL = $(INSTALL_HEADER)
     107HEADERS = $(includeipopt_HEADERS)
    88108ETAGS = etags
    89109CTAGS = ctags
     110DIST_SUBDIRS = $(SUBDIRS)
    90111DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
    91112ACLOCAL = @ACLOCAL@
     
    117138BUILDHSL_FALSE = @BUILDHSL_FALSE@
    118139BUILDHSL_TRUE = @BUILDHSL_TRUE@
    119 BUILDLAPACKDIR_FALSE = @BUILDLAPACKDIR_FALSE@
    120 BUILDLAPACKDIR_TRUE = @BUILDLAPACKDIR_TRUE@
    121 BUILDLAPACK_FALSE = @BUILDLAPACK_FALSE@
    122 BUILDLAPACK_TRUE = @BUILDLAPACK_TRUE@
    123140BUILDMA27_FALSE = @BUILDMA27_FALSE@
    124141BUILDMA27_TRUE = @BUILDMA27_TRUE@
     
    132149CXX = @CXX@
    133150CXXDEPMODE = @CXXDEPMODE@
    134 CXXFLAGS = @CXXFLAGS@ -I$(srcdir)/../Common -I$(srcdir)/../Interfaces \
    135         -I$(srcdir)/../PDSystemImpl/PDFullSpace \
    136         -I$(srcdir)/../LinAlgImpl/Serial
     151CXXFLAGS = @CXXFLAGS@ -I$(srcdir)/../Common -I$(srcdir)/../LinAlg \
     152        -I$(srcdir)/../LinAlg/TMatrices -I$(srcdir)/../Interfaces \
     153        -I$(srcdir)/LinearSolvers
    137154CXXLIBS = @CXXLIBS@
    138155CYGPATH_W = @CYGPATH_W@
     
    220237target_alias = @target_alias@
    221238AUTOMAKE_OPTIONS = foreign
     239SUBDIRS = LinearSolvers
     240includeipoptdir = $(includedir)/ipopt
     241includeipopt_HEADERS = \
     242        IpIpoptCalculatedQuantities.hpp \
     243        IpIpoptData.hpp \
     244        IpIpoptNLP.hpp \
     245        IpIteratesVector.hpp \
     246        IpNLPScaling.hpp
     247
    222248noinst_LIBRARIES = libipoptalg.a
    223249libipoptalg_a_SOURCES = \
    224         IpAlgBuilder.hpp IpAlgBuilder.cpp \
     250        IpAdaptiveMuUpdate.cpp IpAdaptiveMuUpdate.hpp \
     251        IpAlgBuilder.cpp IpAlgBuilder.hpp \
    225252        IpAlgStrategy.hpp \
     253        IpAugRestoSystemSolver.cpp IpAugRestoSystemSolver.hpp \
     254        IpAugSystemSolver.hpp \
    226255        IpConvCheck.hpp \
    227         IpDefaultIterateInitializer.hpp IpDefaultIterateInitializer.cpp \
    228         IpWarmStartIterateInitializer.hpp IpWarmStartIterateInitializer.cpp \
     256        IpDefaultIterateInitializer.cpp IpDefaultIterateInitializer.hpp \
     257        IpEqMultCalculator.hpp \
    229258        IpFilter.cpp IpFilter.hpp \
    230259        IpFilterLineSearch.cpp IpFilterLineSearch.hpp \
    231         IpGradientScaling.hpp IpGradientScaling.cpp \
     260        IpGradientScaling.cpp IpGradientScaling.hpp \
    232261        IpIpoptAlg.cpp IpIpoptAlg.hpp \
    233262        IpIpoptCalculatedQuantities.cpp IpIpoptCalculatedQuantities.hpp \
    234263        IpIpoptData.cpp IpIpoptData.hpp \
    235         IpIpoptNLP.hpp  \
     264        IpIpoptNLP.hpp \
    236265        IpIterateInitializer.hpp \
    237         IpIteratesVector.hpp IpIteratesVector.cpp \
     266        IpIteratesVector.cpp IpIteratesVector.hpp \
    238267        IpIterationOutput.hpp \
     268        IpLeastSquareMults.cpp IpLeastSquareMults.hpp \
    239269        IpLineSearch.hpp \
    240         IpLoqoMuOracle.hpp IpLoqoMuOracle.cpp \
    241         IpMonotoneMuUpdate.hpp IpMonotoneMuUpdate.cpp \
     270        IpLoqoMuOracle.cpp IpLoqoMuOracle.hpp \
     271        IpMonotoneMuUpdate.cpp IpMonotoneMuUpdate.hpp \
    242272        IpMuOracle.hpp \
    243273        IpMuUpdate.hpp \
    244         IpAdaptiveMuUpdate.hpp IpAdaptiveMuUpdate.cpp \
    245         IpNLPScaling.hpp IpNLPScaling.cpp \
     274        IpNLPScaling.cpp IpNLPScaling.hpp \
    246275        IpOptErrorConvCheck.cpp IpOptErrorConvCheck.hpp \
    247276        IpOrigIpoptNLP.cpp IpOrigIpoptNLP.hpp \
    248         IpOrigIterationOutput.hpp IpOrigIterationOutput.cpp \
    249         IpProbingMuOracle.hpp IpProbingMuOracle.cpp \
    250         IpQualityFunctionMuOracle.hpp IpQualityFunctionMuOracle.cpp \
     277        IpOrigIterationOutput.cpp IpOrigIterationOutput.hpp \
     278        IpPDFullSpaceSolver.cpp IpPDFullSpaceSolver.hpp \
     279        IpPDPerturbationHandler.cpp IpPDPerturbationHandler.hpp \
     280        IpPDSystemSolver.hpp \
     281        IpProbingMuOracle.cpp IpProbingMuOracle.hpp \
     282        IpQualityFunctionMuOracle.cpp IpQualityFunctionMuOracle.hpp \
    251283        IpRestoFilterConvCheck.cpp IpRestoFilterConvCheck.hpp \
    252         IpRestoIpoptNLP.hpp IpRestoIpoptNLP.cpp \
    253         IpRestoIterateInitializer.hpp IpRestoIterateInitializer.cpp \
    254         IpRestoIterationOutput.hpp IpRestoIterationOutput.cpp \
     284        IpRestoIpoptNLP.cpp IpRestoIpoptNLP.hpp \
     285        IpRestoIterateInitializer.cpp IpRestoIterateInitializer.hpp \
     286        IpRestoIterationOutput.cpp IpRestoIterationOutput.hpp \
    255287        IpRestoMinC_1Nrm.cpp IpRestoMinC_1Nrm.hpp \
    256288        IpRestoPhase.hpp \
    257         IpRestoRestoPhase.hpp IpRestoRestoPhase.cpp \
    258         IpUserScaling.cpp IpUserScaling.hpp
     289        IpRestoRestoPhase.cpp IpRestoRestoPhase.hpp \
     290        IpStdAugSystemSolver.cpp IpStdAugSystemSolver.hpp \
     291        IpUserScaling.cpp IpUserScaling.hpp \
     292        IpWarmStartIterateInitializer.cpp IpWarmStartIterateInitializer.hpp
    259293
    260294
    261295# Astyle stuff
    262296ASTYLE_FILES = \
    263         IpAlgBuilder.hppbak IpAlgBuilder.cppbak \
     297        IpAdaptiveMuUpdate.cppbak IpAdaptiveMuUpdate.hppbak \
     298        IpAlgBuilder.cppbak IpAlgBuilder.hppbak \
    264299        IpAlgStrategy.hppbak \
     300        IpAugRestoSystemSolver.cppbak IpAugRestoSystemSolver.hppbak \
     301        IpAugSystemSolver.hppbak \
    265302        IpConvCheck.hppbak \
    266         IpDefaultIterateInitializer.hppbak IpDefaultIterateInitializer.cppbak \
    267         IpWarmStartIterateInitializer.hppbak IpWarmStartIterateInitializer.cppbak \
     303        IpDefaultIterateInitializer.cppbak IpDefaultIterateInitializer.hppbak \
     304        IpEqMultCalculator.hppbak \
    268305        IpFilter.cppbak IpFilter.hppbak \
    269306        IpFilterLineSearch.cppbak IpFilterLineSearch.hppbak \
    270         IpGradientScaling.hppbak IpGradientScaling.cppbak \
     307        IpGradientScaling.cppbak IpGradientScaling.hppbak \
    271308        IpIpoptAlg.cppbak IpIpoptAlg.hppbak \
    272309        IpIpoptCalculatedQuantities.cppbak IpIpoptCalculatedQuantities.hppbak \
     
    274311        IpIpoptNLP.hppbak \
    275312        IpIterateInitializer.hppbak \
    276         IpIteratesVector.hppbak IpIteratesVector.cppbak \
     313        IpIteratesVector.cppbak IpIteratesVector.hppbak \
    277314        IpIterationOutput.hppbak \
     315        IpLeastSquareMults.cppbak IpLeastSquareMults.hppbak \
    278316        IpLineSearch.hppbak \
    279         IpLoqoMuOracle.hppbak IpLoqoMuOracle.cppbak \
    280         IpMonotoneMuUpdate.hppbak IpMonotoneMuUpdate.cppbak \
     317        IpLoqoMuOracle.cppbak IpLoqoMuOracle.hppbak \
     318        IpMonotoneMuUpdate.cppbak IpMonotoneMuUpdate.hppbak \
    281319        IpMuOracle.hppbak \
    282320        IpMuUpdate.hppbak \
    283         IpAdaptiveMuUpdate.hppbak IpAdaptiveMuUpdate.cppbak \
    284         IpNLPScaling.hppbak IpNLPScaling.cppbak \
     321        IpNLPScaling.cppbak IpNLPScaling.hppbak \
    285322        IpOptErrorConvCheck.cppbak IpOptErrorConvCheck.hppbak \
    286323        IpOrigIpoptNLP.cppbak IpOrigIpoptNLP.hppbak \
    287         IpOrigIterationOutput.hppbak IpOrigIterationOutput.cppbak \
    288         IpProbingMuOracle.hppbak IpProbingMuOracle.cppbak \
    289         IpQualityFunctionMuOracle.hppbak IpQualityFunctionMuOracle.cppbak \
     324        IpOrigIterationOutput.cppbak IpOrigIterationOutput.hppbak \
     325        IpPDFullSpaceSolver.cppbak IpPDFullSpaceSolver.hppbak \
     326        IpPDPerturbationHandler.cppbak IpPDPerturbationHandler.hppbak \
     327        IpPDSystemSolver.hppbak \
     328        IpProbingMuOracle.cppbak IpProbingMuOracle.hppbak \
     329        IpQualityFunctionMuOracle.cppbak IpQualityFunctionMuOracle.hppbak \
    290330        IpRestoFilterConvCheck.cppbak IpRestoFilterConvCheck.hppbak \
    291         IpRestoIpoptNLP.hppbak IpRestoIpoptNLP.cppbak \
    292         IpRestoIterateInitializer.hppbak IpRestoIterateInitializer.cppbak \
    293         IpRestoIterationOutput.hppbak IpRestoIterationOutput.cppbak \
     331        IpRestoIpoptNLP.cppbak IpRestoIpoptNLP.hppbak \
     332        IpRestoIterateInitializer.cppbak IpRestoIterateInitializer.hppbak \
     333        IpRestoIterationOutput.cppbak IpRestoIterationOutput.hppbak \
    294334        IpRestoMinC_1Nrm.cppbak IpRestoMinC_1Nrm.hppbak \
    295335        IpRestoPhase.hppbak \
    296         IpRestoRestoPhase.hppbak IpRestoRestoPhase.cppbak \
    297         IpUserScaling.cppbak IpUserScaling.hppbak
     336        IpRestoRestoPhase.cppbak IpRestoRestoPhase.hppbak \
     337        IpStdAugSystemSolver.cppbak IpStdAugSystemSolver.hppbak \
     338        IpUserScaling.cppbak IpUserScaling.hppbak \
     339        IpWarmStartIterateInitializer.cppbak IpWarmStartIterateInitializer.hppbak
    298340
    299341CLEANFILES = $(ASTYLE_FILES)
    300342SUFFIXES = .cppbak .hppbak
    301 all: all-am
     343all: all-recursive
    302344
    303345.SUFFIXES:
     
    348390@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpAdaptiveMuUpdate.Po@am__quote@
    349391@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpAlgBuilder.Po@am__quote@
     392@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpAugRestoSystemSolver.Po@am__quote@
    350393@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpDefaultIterateInitializer.Po@am__quote@
    351394@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpFilter.Po@am__quote@
     
    356399@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpIpoptData.Po@am__quote@
    357400@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpIteratesVector.Po@am__quote@
     401@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpLeastSquareMults.Po@am__quote@
    358402@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpLoqoMuOracle.Po@am__quote@
    359403@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpMonotoneMuUpdate.Po@am__quote@
     
    362406@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpOrigIpoptNLP.Po@am__quote@
    363407@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpOrigIterationOutput.Po@am__quote@
     408@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpPDFullSpaceSolver.Po@am__quote@
     409@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpPDPerturbationHandler.Po@am__quote@
    364410@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpProbingMuOracle.Po@am__quote@
    365411@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpQualityFunctionMuOracle.Po@am__quote@
     
    370416@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpRestoMinC_1Nrm.Po@am__quote@
    371417@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpRestoRestoPhase.Po@am__quote@
     418@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpStdAugSystemSolver.Po@am__quote@
    372419@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpUserScaling.Po@am__quote@
    373420@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpWarmStartIterateInitializer.Po@am__quote@
     
    387434@am__fastdepCXX_FALSE@  $(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
    388435uninstall-info-am:
     436install-includeipoptHEADERS: $(includeipopt_HEADERS)
     437        @$(NORMAL_INSTALL)
     438        test -z "$(includeipoptdir)" || $(mkdir_p) "$(DESTDIR)$(includeipoptdir)"
     439        @list='$(includeipopt_HEADERS)'; for p in $$list; do \
     440          if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
     441          f=$(am__strip_dir) \
     442          echo " $(includeipoptHEADERS_INSTALL) '$$d$$p' '$(DESTDIR)$(includeipoptdir)/$$f'"; \
     443          $(includeipoptHEADERS_INSTALL) "$$d$$p" "$(DESTDIR)$(includeipoptdir)/$$f"; \
     444        done
     445
     446uninstall-includeipoptHEADERS:
     447        @$(NORMAL_UNINSTALL)
     448        @list='$(includeipopt_HEADERS)'; for p in $$list; do \
     449          f=$(am__strip_dir) \
     450          echo " rm -f '$(DESTDIR)$(includeipoptdir)/$$f'"; \
     451          rm -f "$(DESTDIR)$(includeipoptdir)/$$f"; \
     452        done
     453
     454# This directory's subdirectories are mostly independent; you can cd
     455# into them and run `make' without going through this Makefile.
     456# To change the values of `make' variables: instead of editing Makefiles,
     457# (1) if the variable is set in `config.status', edit `config.status'
     458#     (which will cause the Makefiles to be regenerated when you run `make');
     459# (2) otherwise, pass the desired values on the `make' command line.
     460$(RECURSIVE_TARGETS):
     461        @failcom='exit 1'; \
     462        for f in x $$MAKEFLAGS; do \
     463          case $$f in \
     464            *=* | --[!k]*);; \
     465            *k*) failcom='fail=yes';; \
     466          esac; \
     467        done; \
     468        dot_seen=no; \
     469        target=`echo $@ | sed s/-recursive//`; \
     470        list='$(SUBDIRS)'; for subdir in $$list; do \
     471          echo "Making $$target in $$subdir"; \
     472          if test "$$subdir" = "."; then \
     473            dot_seen=yes; \
     474            local_target="$$target-am"; \
     475          else \
     476            local_target="$$target"; \
     477          fi; \
     478          (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
     479          || eval $$failcom; \
     480        done; \
     481        if test "$$dot_seen" = "no"; then \
     482          $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
     483        fi; test -z "$$fail"
     484
     485mostlyclean-recursive clean-recursive distclean-recursive \
     486maintainer-clean-recursive:
     487        @failcom='exit 1'; \
     488        for f in x $$MAKEFLAGS; do \
     489          case $$f in \
     490            *=* | --[!k]*);; \
     491            *k*) failcom='fail=yes';; \
     492          esac; \
     493        done; \
     494        dot_seen=no; \
     495        case "$@" in \
     496          distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
     497          *) list='$(SUBDIRS)' ;; \
     498        esac; \
     499        rev=''; for subdir in $$list; do \
     500          if test "$$subdir" = "."; then :; else \
     501            rev="$$subdir $$rev"; \
     502          fi; \
     503        done; \
     504        rev="$$rev ."; \
     505        target=`echo $@ | sed s/-recursive//`; \
     506        for subdir in $$rev; do \
     507          echo "Making $$target in $$subdir"; \
     508          if test "$$subdir" = "."; then \
     509            local_target="$$target-am"; \
     510          else \
     511            local_target="$$target"; \
     512          fi; \
     513          (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
     514          || eval $$failcom; \
     515        done && test -z "$$fail"
     516tags-recursive:
     517        list='$(SUBDIRS)'; for subdir in $$list; do \
     518          test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \
     519        done
     520ctags-recursive:
     521        list='$(SUBDIRS)'; for subdir in $$list; do \
     522          test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \
     523        done
    389524
    390525ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
     
    398533tags: TAGS
    399534
    400 TAGS: $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
     535TAGS: tags-recursive $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
    401536                $(TAGS_FILES) $(LISP)
    402537        tags=; \
    403538        here=`pwd`; \
     539        if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
     540          include_option=--etags-include; \
     541          empty_fix=.; \
     542        else \
     543          include_option=--include; \
     544          empty_fix=; \
     545        fi; \
     546        list='$(SUBDIRS)'; for subdir in $$list; do \
     547          if test "$$subdir" = .; then :; else \
     548            test ! -f $$subdir/TAGS || \
     549              tags="$$tags $$include_option=$$here/$$subdir/TAGS"; \
     550          fi; \
     551        done; \
    404552        list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
    405553        unique=`for i in $$list; do \
     
    414562        fi
    415563ctags: CTAGS
    416 CTAGS: $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
     564CTAGS: ctags-recursive $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
    417565                $(TAGS_FILES) $(LISP)
    418566        tags=; \
     
    463611          fi; \
    464612        done
     613        list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
     614          if test "$$subdir" = .; then :; else \
     615            test -d "$(distdir)/$$subdir" \
     616            || $(mkdir_p) "$(distdir)/$$subdir" \
     617            || exit 1; \
     618            distdir=`$(am__cd) $(distdir) && pwd`; \
     619            top_distdir=`$(am__cd) $(top_distdir) && pwd`; \
     620            (cd $$subdir && \
     621              $(MAKE) $(AM_MAKEFLAGS) \
     622                top_distdir="$$top_distdir" \
     623                distdir="$$distdir/$$subdir" \
     624                distdir) \
     625              || exit 1; \
     626          fi; \
     627        done
    465628check-am: all-am
    466 check: check-am
    467 all-am: Makefile $(LIBRARIES)
    468 installdirs:
    469 install: install-am
    470 install-exec: install-exec-am
    471 install-data: install-data-am
    472 uninstall: uninstall-am
     629check: check-recursive
     630all-am: Makefile $(LIBRARIES) $(HEADERS)
     631installdirs: installdirs-recursive
     632installdirs-am:
     633        for dir in "$(DESTDIR)$(includeipoptdir)"; do \
     634          test -z "$$dir" || $(mkdir_p) "$$dir"; \
     635        done
     636install: install-recursive
     637install-exec: install-exec-recursive
     638install-data: install-data-recursive
     639uninstall: uninstall-recursive
    473640
    474641install-am: all-am
    475642        @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
    476643
    477 installcheck: installcheck-am
     644installcheck: installcheck-recursive
    478645install-strip:
    479646        $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
     
    492659        @echo "This command is intended for maintainers to use"
    493660        @echo "it deletes files that may require special tools to rebuild."
    494 clean: clean-am
     661clean: clean-recursive
    495662
    496663clean-am: clean-generic clean-noinstLIBRARIES mostlyclean-am
    497664
    498 distclean: distclean-am
     665distclean: distclean-recursive
    499666        -rm -rf ./$(DEPDIR)
    500667        -rm -f Makefile
     
    502669        distclean-tags
    503670
    504 dvi: dvi-am
     671dvi: dvi-recursive
    505672
    506673dvi-am:
    507674
    508 html: html-am
    509 
    510 info: info-am
     675html: html-recursive
     676
     677info: info-recursive
    511678
    512679info-am:
    513680
    514 install-data-am:
     681install-data-am: install-includeipoptHEADERS
    515682
    516683install-exec-am:
    517684
    518 install-info: install-info-am
     685install-info: install-info-recursive
    519686
    520687install-man:
     
    522689installcheck-am:
    523690
    524 maintainer-clean: maintainer-clean-am
     691maintainer-clean: maintainer-clean-recursive
    525692        -rm -rf ./$(DEPDIR)
    526693        -rm -f Makefile
    527694maintainer-clean-am: distclean-am maintainer-clean-generic
    528695
    529 mostlyclean: mostlyclean-am
     696mostlyclean: mostlyclean-recursive
    530697
    531698mostlyclean-am: mostlyclean-compile mostlyclean-generic
    532699
    533 pdf: pdf-am
     700pdf: pdf-recursive
    534701
    535702pdf-am:
    536703
    537 ps: ps-am
     704ps: ps-recursive
    538705
    539706ps-am:
    540707
    541 uninstall-am: uninstall-info-am
    542 
    543 .PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
    544         clean-noinstLIBRARIES ctags distclean distclean-compile \
    545         distclean-generic distclean-tags distdir dvi dvi-am html \
    546         html-am info info-am install install-am install-data \
    547         install-data-am install-exec install-exec-am install-info \
    548         install-info-am install-man install-strip installcheck \
    549         installcheck-am installdirs maintainer-clean \
    550         maintainer-clean-generic mostlyclean mostlyclean-compile \
    551         mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
    552         uninstall-am uninstall-info-am
     708uninstall-am: uninstall-includeipoptHEADERS uninstall-info-am
     709
     710uninstall-info: uninstall-info-recursive
     711
     712.PHONY: $(RECURSIVE_TARGETS) CTAGS GTAGS all all-am check check-am \
     713        clean clean-generic clean-noinstLIBRARIES clean-recursive \
     714        ctags ctags-recursive distclean distclean-compile \
     715        distclean-generic distclean-recursive distclean-tags distdir \
     716        dvi dvi-am html html-am info info-am install install-am \
     717        install-data install-data-am install-exec install-exec-am \
     718        install-includeipoptHEADERS install-info install-info-am \
     719        install-man install-strip installcheck installcheck-am \
     720        installdirs installdirs-am maintainer-clean \
     721        maintainer-clean-generic maintainer-clean-recursive \
     722        mostlyclean mostlyclean-compile mostlyclean-generic \
     723        mostlyclean-recursive pdf pdf-am ps ps-am tags tags-recursive \
     724        uninstall uninstall-am uninstall-includeipoptHEADERS \
     725        uninstall-info-am
    553726
    554727
  • branches/dev/Apps/AmplSolver/AmplTNLP.cpp

    r422 r430  
    1717#include "IpSymTMatrix.hpp"
    1818#include "IpBlas.hpp"
    19 #include "IpInterfaceTypes.hpp"
    2019
    2120/* AMPL includes */
  • branches/dev/Apps/AmplSolver/Makefile.am

    r320 r430  
    1919
    2020IPLIBS = \
    21         ../../Apps/StdInterface/libstdinterface.a \
     21        ../../Interfaces/libinterfaces.a \
    2222        ../../Algorithm/libipoptalg.a \
    23         ../../LinAlgImpl/Serial/liblaserial.a \
    24         ../../PDSystemImpl/PDFullSpace/libpdfullspace.a \
    25         ../../Algorithm/libipoptalg.a \
     23        ../../Algorithm/LinearSolvers/liblinsolvers.a \
     24        ../../LinAlg/TMatrices/libtmatrices.a \
     25        ../../LinAlg/liblinalg.a \
    2626        ../../Common/libcommon.a \
    2727        libamplinterface.a \
    28         ../../PDSystemImpl/PDFullSpace/libpdfullspace.a \
    29         ../../Algorithm/libipoptalg.a \
    30         ../../Common/libcommon.a \
    31         ../../LinAlgImpl/Serial/liblaserial.a \
    3228        $(ASLLIB)
    3329
    3430ipopt_LDADD = $(IPLIBS)
    3531
    36 CXXFLAGS += -I$(srcdir)/../../Common
    37 CXXFLAGS += -I$(srcdir)/../../Interfaces
    38 CXXFLAGS += -I$(srcdir)/../../LinAlgImpl/Serial
    39 CXXFLAGS += -I$(srcdir)/../../Algorithm
    40 CXXFLAGS += -I$(srcdir)/../../PDSystemImpl/PDFullSpace
    41 CXXFLAGS += -I$(srcdir)/../../Apps/StdInterface
    42 CXXFLAGS += -I$(srcdir)/../../Apps/AmplSolver \
    43             -I$(srcdir)/../../OTHERS/ASL/ \
    44             -I$(srcdir)/../../OTHERS/ASL/solvers
     32CXXFLAGS += -I$(srcdir)/../../Common \
     33        -I$(srcdir)/../../LinAlg \
     34        -I$(srcdir)/../../LinAlg/TMatrices \
     35        -I$(srcdir)/../../Algorithm \
     36        -I$(srcdir)/../../Interfaces
     37
    4538CXXFLAGS += $(AMPL_CPPFLAGS)
    4639
  • branches/dev/Apps/AmplSolver/Makefile.in

    r382 r430  
    6666ipopt_OBJECTS = $(am_ipopt_OBJECTS)
    6767am__DEPENDENCIES_1 =
    68 am__DEPENDENCIES_2 = ../../Apps/StdInterface/libstdinterface.a \
     68am__DEPENDENCIES_2 = ../../Interfaces/libinterfaces.a \
    6969        ../../Algorithm/libipoptalg.a \
    70         ../../LinAlgImpl/Serial/liblaserial.a \
    71         ../../PDSystemImpl/PDFullSpace/libpdfullspace.a \
    72         ../../Algorithm/libipoptalg.a ../../Common/libcommon.a \
    73         libamplinterface.a \
    74         ../../PDSystemImpl/PDFullSpace/libpdfullspace.a \
    75         ../../Algorithm/libipoptalg.a ../../Common/libcommon.a \
    76         ../../LinAlgImpl/Serial/liblaserial.a $(am__DEPENDENCIES_1)
     70        ../../Algorithm/LinearSolvers/liblinsolvers.a \
     71        ../../LinAlg/TMatrices/libtmatrices.a ../../LinAlg/liblinalg.a \
     72        ../../Common/libcommon.a libamplinterface.a \
     73        $(am__DEPENDENCIES_1)
    7774ipopt_DEPENDENCIES = $(am__DEPENDENCIES_2)
    7875DEFAULT_INCLUDES = -I. -I$(srcdir) -I$(top_builddir)/inc
     
    121118BUILDHSL_FALSE = @BUILDHSL_FALSE@
    122119BUILDHSL_TRUE = @BUILDHSL_TRUE@
    123 BUILDLAPACKDIR_FALSE = @BUILDLAPACKDIR_FALSE@
    124 BUILDLAPACKDIR_TRUE = @BUILDLAPACKDIR_TRUE@
    125 BUILDLAPACK_FALSE = @BUILDLAPACK_FALSE@
    126 BUILDLAPACK_TRUE = @BUILDLAPACK_TRUE@
    127120BUILDMA27_FALSE = @BUILDMA27_FALSE@
    128121BUILDMA27_TRUE = @BUILDMA27_TRUE@
     
    137130CXXDEPMODE = @CXXDEPMODE@
    138131CXXFLAGS = @CXXFLAGS@ -I$(srcdir)/../../Common \
    139         -I$(srcdir)/../../Interfaces \
    140         -I$(srcdir)/../../LinAlgImpl/Serial \
    141         -I$(srcdir)/../../Algorithm \
    142         -I$(srcdir)/../../PDSystemImpl/PDFullSpace \
    143         -I$(srcdir)/../../Apps/StdInterface \
    144         -I$(srcdir)/../../Apps/AmplSolver \
    145         -I$(srcdir)/../../OTHERS/ASL/ \
    146         -I$(srcdir)/../../OTHERS/ASL/solvers $(AMPL_CPPFLAGS)
     132        -I$(srcdir)/../../LinAlg -I$(srcdir)/../../LinAlg/TMatrices \
     133        -I$(srcdir)/../../Algorithm -I$(srcdir)/../../Interfaces \
     134        $(AMPL_CPPFLAGS)
    147135CXXLIBS = @CXXLIBS@
    148136CYGPATH_W = @CYGPATH_W@
     
    238226
    239227IPLIBS = \
    240         ../../Apps/StdInterface/libstdinterface.a \
     228        ../../Interfaces/libinterfaces.a \
    241229        ../../Algorithm/libipoptalg.a \
    242         ../../LinAlgImpl/Serial/liblaserial.a \
    243         ../../PDSystemImpl/PDFullSpace/libpdfullspace.a \
    244         ../../Algorithm/libipoptalg.a \
     230        ../../Algorithm/LinearSolvers/liblinsolvers.a \
     231        ../../LinAlg/TMatrices/libtmatrices.a \
     232        ../../LinAlg/liblinalg.a \
    245233        ../../Common/libcommon.a \
    246234        libamplinterface.a \
    247         ../../PDSystemImpl/PDFullSpace/libpdfullspace.a \
    248         ../../Algorithm/libipoptalg.a \
    249         ../../Common/libcommon.a \
    250         ../../LinAlgImpl/Serial/liblaserial.a \
    251235        $(ASLLIB)
    252236
  • branches/dev/Apps/AmplSolver/ampl_ipopt.cpp

    r373 r430  
    77// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
    88
    9 #include "IpUtils.hpp"
    109#include "AmplTNLP.hpp"
    1110#include "IpIpoptApplication.hpp"
  • branches/dev/Apps/CUTErInterface/Makefile.in

    r382 r430  
    9494BUILDHSL_FALSE = @BUILDHSL_FALSE@
    9595BUILDHSL_TRUE = @BUILDHSL_TRUE@
    96 BUILDLAPACKDIR_FALSE = @BUILDLAPACKDIR_FALSE@
    97 BUILDLAPACKDIR_TRUE = @BUILDLAPACKDIR_TRUE@
    98 BUILDLAPACK_FALSE = @BUILDLAPACK_FALSE@
    99 BUILDLAPACK_TRUE = @BUILDLAPACK_TRUE@
    10096BUILDMA27_FALSE = @BUILDMA27_FALSE@
    10197BUILDMA27_TRUE = @BUILDMA27_TRUE@
  • branches/dev/Apps/CompositeInterface/CompositeNLP.cpp

    r224 r430  
    4141  }
    4242
    43   bool CompositeNLP::GetSpaces(SmartPtr<VectorSpace>& x_space,
    44                                SmartPtr<VectorSpace>& c_space,
    45                                SmartPtr<VectorSpace>& d_space,
    46                                SmartPtr<VectorSpace>& x_l_space,
    47                                SmartPtr<MatrixSpace>& px_l_space,
    48                                SmartPtr<VectorSpace>& x_u_space,
    49                                SmartPtr<MatrixSpace>& px_u_space,
    50                                SmartPtr<VectorSpace>& d_l_space,
    51                                SmartPtr<MatrixSpace>& pd_l_space,
    52                                SmartPtr<VectorSpace>& d_u_space,
    53                                SmartPtr<MatrixSpace>& pd_u_space,
    54                                SmartPtr<MatrixSpace>& Jac_c_space,
    55                                SmartPtr<MatrixSpace>& Jac_d_space,
    56                                SmartPtr<SymMatrixSpace>& Hess_lagrangian_space)
     43  bool CompositeNLP::GetSpaces(SmartPtr<const VectorSpace>& x_space,
     44                               SmartPtr<const VectorSpace>& c_space,
     45                               SmartPtr<const VectorSpace>& d_space,
     46                               SmartPtr<const VectorSpace>& x_l_space,
     47                               SmartPtr<const MatrixSpace>& px_l_space,
     48                               SmartPtr<const VectorSpace>& x_u_space,
     49                               SmartPtr<const MatrixSpace>& px_u_space,
     50                               SmartPtr<const VectorSpace>& d_l_space,
     51                               SmartPtr<const MatrixSpace>& pd_l_space,
     52                               SmartPtr<const VectorSpace>& d_u_space,
     53                               SmartPtr<const MatrixSpace>& pd_u_space,
     54                               SmartPtr<const MatrixSpace>& Jac_c_space,
     55                               SmartPtr<const MatrixSpace>& Jac_d_space,
     56                               SmartPtr<const SymMatrixSpace>& Hess_lagrangian_space)
    5757  {
    5858    Index n_nlps = nlps_.size();
     
    8484
    8585    // retrieve the necessary spaces from the individual NLPS
    86     std::vector<SmartPtr<VectorSpace> > x_spaces;
    87     std::vector<SmartPtr<VectorSpace> > c_spaces;
    88     std::vector<SmartPtr<VectorSpace> > d_spaces;
    89     std::vector<SmartPtr<VectorSpace> > x_l_spaces;
    90     std::vector<SmartPtr<MatrixSpace> > px_l_spaces;
    91     std::vector<SmartPtr<VectorSpace> > x_u_spaces;
    92     std::vector<SmartPtr<MatrixSpace> > px_u_spaces;
    93     std::vector<SmartPtr<VectorSpace> > d_l_spaces;
    94     std::vector<SmartPtr<MatrixSpace> > pd_l_spaces;
    95     std::vector<SmartPtr<VectorSpace> > d_u_spaces;
    96     std::vector<SmartPtr<MatrixSpace> > pd_u_spaces;
    97     std::vector<SmartPtr<MatrixSpace> > jac_c_spaces;
    98     std::vector<SmartPtr<MatrixSpace> > jac_d_spaces;
    99     std::vector<SmartPtr<SymMatrixSpace> > h_spaces;
     86    std::vector<SmartPtr<const VectorSpace> > x_spaces;
     87    std::vector<SmartPtr<const VectorSpace> > c_spaces;
     88    std::vector<SmartPtr<const VectorSpace> > d_spaces;
     89    std::vector<SmartPtr<const VectorSpace> > x_l_spaces;
     90    std::vector<SmartPtr<const MatrixSpace> > px_l_spaces;
     91    std::vector<SmartPtr<const VectorSpace> > x_u_spaces;
     92    std::vector<SmartPtr<const MatrixSpace> > px_u_spaces;
     93    std::vector<SmartPtr<const VectorSpace> > d_l_spaces;
     94    std::vector<SmartPtr<const MatrixSpace> > pd_l_spaces;
     95    std::vector<SmartPtr<const VectorSpace> > d_u_spaces;
     96    std::vector<SmartPtr<const MatrixSpace> > pd_u_spaces;
     97    std::vector<SmartPtr<const MatrixSpace> > jac_c_spaces;
     98    std::vector<SmartPtr<const MatrixSpace> > jac_d_spaces;
     99    std::vector<SmartPtr<const SymMatrixSpace> > h_spaces;
    100100    for (Index i=0; i<n_nlps; i++) {
    101101      DBG_ASSERT(IsValid(nlps_[i]));
     
    107107                       "The # of rows in the Jx_linking_eqns[i] must be the same as the number of rows in the Jq_linking_eqns[i]");
    108108
    109       SmartPtr<VectorSpace> x_space_i;
    110       SmartPtr<VectorSpace> c_space_i;
    111       SmartPtr<VectorSpace> d_space_i;
    112       SmartPtr<VectorSpace> x_l_space_i;
    113       SmartPtr<MatrixSpace> px_l_space_i;
    114       SmartPtr<VectorSpace> x_u_space_i;
    115       SmartPtr<MatrixSpace> px_u_space_i;
    116       SmartPtr<VectorSpace> d_l_space_i;
    117       SmartPtr<MatrixSpace> pd_l_space_i;
    118       SmartPtr<VectorSpace> d_u_space_i;
    119       SmartPtr<MatrixSpace> pd_u_space_i;
    120       SmartPtr<MatrixSpace> jac_c_space_i;
    121       SmartPtr<MatrixSpace> jac_d_space_i;
    122       SmartPtr<SymMatrixSpace> h_space_i;
     109      SmartPtr<const VectorSpace> x_space_i;
     110      SmartPtr<const VectorSpace> c_space_i;
     111      SmartPtr<const VectorSpace> d_space_i;
     112      SmartPtr<const VectorSpace> x_l_space_i;
     113      SmartPtr<const MatrixSpace> px_l_space_i;
     114      SmartPtr<const VectorSpace> x_u_space_i;
     115      SmartPtr<const MatrixSpace> px_u_space_i;
     116      SmartPtr<const VectorSpace> d_l_space_i;
     117      SmartPtr<const MatrixSpace> pd_l_space_i;
     118      SmartPtr<const VectorSpace> d_u_space_i;
     119      SmartPtr<const MatrixSpace> pd_u_space_i;
     120      SmartPtr<const MatrixSpace> jac_c_space_i;
     121      SmartPtr<const MatrixSpace> jac_d_space_i;
     122      SmartPtr<const SymMatrixSpace> h_space_i;
    123123
    124124      bool retvalue = nlps_[i]->GetSpaces(x_space_i,
     
    349349  }
    350350
    351   bool CompositeNLP::GetStartingPoint(Vector& x,
    352                                       bool need_x,
    353                                       Vector& y_c,
    354                                       bool need_y_c,
    355                                       Vector& y_d,
    356                                       bool need_y_d,
    357                                       Vector& z_L,
    358                                       bool need_z_L,
    359                                       Vector& z_U,
    360                                       bool need_z_U,
    361                                       Vector& v_L,
    362                                       bool need_v_L,
    363                                       Vector& v_U,
    364                                       bool need_v_U
    365                                      )
     351  bool CompositeNLP::GetStartingPoint(
     352    SmartPtr<Vector> x,
     353    bool need_x,
     354    SmartPtr<Vector> y_c,
     355    bool need_y_c,
     356    SmartPtr<Vector> y_d,
     357    bool need_y_d,
     358    SmartPtr<Vector> z_L,
     359    bool need_z_L,
     360    SmartPtr<Vector> z_U,
     361    bool need_z_U)
    366362  {
    367363
     
    371367    CompoundVector* cz_l = dynamic_cast<CompoundVector*>(&z_L);
    372368    CompoundVector* cz_u = dynamic_cast<CompoundVector*>(&z_U);
    373     CompoundVector* cv_l = dynamic_cast<CompoundVector*>(&v_L);
    374     CompoundVector* cv_u = dynamic_cast<CompoundVector*>(&v_U);
    375 
    376     DBG_ASSERT(cx && cy_c && cy_d && cz_l && cz_u && cv_l && cv_u);
     369
     370    DBG_ASSERT(cx && cy_c && cy_d && cz_l && cz_u);
    377371
    378372    Index n_nlps = nlps_.size();
     
    383377      SmartPtr<Vector> z_li = cz_l->GetCompNonConst(i);
    384378      SmartPtr<Vector> z_ui = cz_u->GetCompNonConst(i);
    385       SmartPtr<Vector> v_li = cv_l->GetCompNonConst(i);
    386       SmartPtr<Vector> v_ui = cv_u->GetCompNonConst(i);
    387 
    388       if (!nlps_[i]->GetStartingPoint(*xi, need_x,
    389                                       *y_ci, need_y_c, *y_di, need_y_d,
    390                                       *z_li, need_z_L, *z_ui, need_z_U,
    391                                       *v_li, need_v_L, *v_ui, need_v_U) ) {
     379
     380      if (!nlps_[i]->GetStartingPoint(xi, need_x,
     381                                      y_ci, need_y_c, y_di, need_y_d,
     382                                      z_li, need_z_L, z_ui, need_z_U) ) {
    392383        return false;
    393384      }
  • branches/dev/Apps/CompositeInterface/CompositeNLP.hpp

    r146 r430  
    4747    /** Method for creating the derived vector / matrix types
    4848     *  (Do not delete these, the ). */
    49     virtual bool GetSpaces(SmartPtr<VectorSpace>& x_space,
    50                            SmartPtr<VectorSpace>& c_space,
    51                            SmartPtr<VectorSpace>& d_space,
    52                            SmartPtr<VectorSpace>& x_l_space,
    53                            SmartPtr<MatrixSpace>& px_l_space,
    54                            SmartPtr<VectorSpace>& x_u_space,
    55                            SmartPtr<MatrixSpace>& px_u_space,
    56                            SmartPtr<VectorSpace>& d_l_space,
    57                            SmartPtr<MatrixSpace>& pd_l_space,
    58                            SmartPtr<VectorSpace>& d_u_space,
    59                            SmartPtr<MatrixSpace>& pd_u_space,
    60                            SmartPtr<MatrixSpace>& Jac_c_space,
    61                            SmartPtr<MatrixSpace>& Jac_d_space,
    62                            SmartPtr<SymMatrixSpace>& Hess_lagrangian_space);
     49    virtual bool GetSpaces(SmartPtr<const VectorSpace>& x_space,
     50                           SmartPtr<const VectorSpace>& c_space,
     51                           SmartPtr<const VectorSpace>& d_space,
     52                           SmartPtr<const VectorSpace>& x_l_space,
     53                           SmartPtr<const MatrixSpace>& px_l_space,
     54                           SmartPtr<const VectorSpace>& x_u_space,
     55                           SmartPtr<const MatrixSpace>& px_u_space,
     56                           SmartPtr<const VectorSpace>& d_l_space,
     57                           SmartPtr<const MatrixSpace>& pd_l_space,
     58                           SmartPtr<const VectorSpace>& d_u_space,
     59                           SmartPtr<const MatrixSpace>& pd_u_space,
     60                           SmartPtr<const MatrixSpace>& Jac_c_space,
     61                           SmartPtr<const MatrixSpace>& Jac_d_space,
     62                           SmartPtr<const SymMatrixSpace>& Hess_lagrangian_space);
    6363
    6464    /** Method for obtaining the bounds information */
     
    7575     *  for all the iterates. */
    7676    virtual bool GetStartingPoint(
    77       Vector& x,
     77      SmartPtr<Vector> x,
    7878      bool need_x,
    79       Vector& y_c,
     79      SmartPtr<Vector> y_c,
    8080      bool need_y_c,
    81       Vector& y_d,
     81      SmartPtr<Vector> y_d,
    8282      bool need_y_d,
    83       Vector& z_L,
     83      SmartPtr<Vector> z_L,
    8484      bool need_z_L,
    85       Vector& z_U,
    86       bool need_z_U,
    87       Vector& v_L,
    88       bool need_v_L,
    89       Vector& v_U,
    90       bool need_v_U
     85      SmartPtr<Vector> z_U,
     86      bool need_z_U
    9187    );
    9288    //@}
  • branches/dev/Apps/CompositeInterface/Makefile.am

    r320 r430  
    1313
    1414libcompositenlp_a_SOURCES = \
    15         CompositeNLP.hpp CompositeNLP.cpp
     15        CompositeNLP.cpp CompositeNLP.hpp
    1616
    1717composite_ampl_ipopt_SOURCES = \
    1818        comp_ampl_ipopt.cpp
    1919
    20 IPLIBS = ../../Algorithm/libipoptalg.a \
    21         ../../LinAlgImpl/Serial/liblaserial.a \
    22         ../../PDSystemImpl/PDFullSpace/libpdfullspace.a \
     20IPLIBS = \
     21        ../../Interfaces/libinterfaces.a \
     22        ../../Algorithm/libipoptalg.a \
     23        ../../Algorithm/LinearSolvers/liblinsolvers.a \
     24        ../../LinAlg/TMatrices/libtmatrices.a \
     25        ../../LinAlg/liblinalg.a \
    2326        ../../Common/libcommon.a \
    24         ../../Apps/AmplSolver/libamplinterface.a \
     27        ../AmplSolver/libamplinterface.a \
    2528        $(ASLLIB)
    2629
     
    2932
    3033
    31 CXXFLAGS += -I$(srcdir)/../../Common
    32 CXXFLAGS += -I$(srcdir)/../../Interfaces
    33 CXXFLAGS += -I$(srcdir)/../../LinAlgImpl/Serial
    34 CXXFLAGS += -I$(srcdir)/../../Algorithm
    35 CXXFLAGS += -I$(srcdir)/../../PDSystemImpl/PDFullSpace
    36 CXXFLAGS += -I$(srcdir)/../../Apps/AmplSolver \
    37             -I$(srcdir)/../../OTHERS/ASL/ \
    38             -I$(srcdir)/../../OTHERS/ASL/solvers
     34CXXFLAGS += -I$(srcdir)/../../Common \
     35        -I$(srcdir)/../../LinAlg \
     36        -I$(srcdir)/../../LinAlg/TMatrices \
     37        -I$(srcdir)/../../Algorithm \
     38        -I$(srcdir)/../../Interfaces \
     39        -I$(srcdir)/../AmplSolver
     40
     41#CXXFLAGS += -I$(srcdir)/../../Apps/AmplSolver \
     42#           -I$(srcdir)/../../OTHERS/ASL/ \
     43#           -I$(srcdir)/../../OTHERS/ASL/solvers
    3944CXXFLAGS += $(AMPL_CPPFLAGS)
    4045
     
    4247
    4348ASTYLE_FILES = \
    44         CompositeNLP.hppbak CompositeNLP.cppbak \
     49        CompositeNLP.cppbak CompositeNLP.hppbak \
    4550        comp_ampl_ipopt.cppbak
    4651
  • branches/dev/Apps/CompositeInterface/Makefile.in

    r382 r430  
    6666composite_ampl_ipopt_OBJECTS = $(am_composite_ampl_ipopt_OBJECTS)
    6767am__DEPENDENCIES_1 =
    68 am__DEPENDENCIES_2 = ../../Algorithm/libipoptalg.a \
    69         ../../LinAlgImpl/Serial/liblaserial.a \
    70         ../../PDSystemImpl/PDFullSpace/libpdfullspace.a \
    71         ../../Common/libcommon.a \
    72         ../../Apps/AmplSolver/libamplinterface.a $(am__DEPENDENCIES_1)
     68am__DEPENDENCIES_2 = ../../Interfaces/libinterfaces.a \
     69        ../../Algorithm/libipoptalg.a \
     70        ../../Algorithm/LinearSolvers/liblinsolvers.a \
     71        ../../LinAlg/TMatrices/libtmatrices.a ../../LinAlg/liblinalg.a \
     72        ../../Common/libcommon.a ../AmplSolver/libamplinterface.a \
     73        $(am__DEPENDENCIES_1)
    7374composite_ampl_ipopt_DEPENDENCIES = $(am__DEPENDENCIES_2) \
    7475        libcompositenlp.a
     
    119120BUILDHSL_FALSE = @BUILDHSL_FALSE@
    120121BUILDHSL_TRUE = @BUILDHSL_TRUE@
    121 BUILDLAPACKDIR_FALSE = @BUILDLAPACKDIR_FALSE@
    122 BUILDLAPACKDIR_TRUE = @BUILDLAPACKDIR_TRUE@
    123 BUILDLAPACK_FALSE = @BUILDLAPACK_FALSE@
    124 BUILDLAPACK_TRUE = @BUILDLAPACK_TRUE@
    125122BUILDMA27_FALSE = @BUILDMA27_FALSE@
    126123BUILDMA27_TRUE = @BUILDMA27_TRUE@
     
    134131CXX = @CXX@
    135132CXXDEPMODE = @CXXDEPMODE@
     133
     134#CXXFLAGS += -I$(srcdir)/../../Apps/AmplSolver \
     135#           -I$(srcdir)/../../OTHERS/ASL/ \
     136#           -I$(srcdir)/../../OTHERS/ASL/solvers
    136137CXXFLAGS = @CXXFLAGS@ -I$(srcdir)/../../Common \
    137         -I$(srcdir)/../../Interfaces \
    138         -I$(srcdir)/../../LinAlgImpl/Serial \
    139         -I$(srcdir)/../../Algorithm \
    140         -I$(srcdir)/../../PDSystemImpl/PDFullSpace \
    141         -I$(srcdir)/../../Apps/AmplSolver \
    142         -I$(srcdir)/../../OTHERS/ASL/ \
    143         -I$(srcdir)/../../OTHERS/ASL/solvers $(AMPL_CPPFLAGS)
     138        -I$(srcdir)/../../LinAlg -I$(srcdir)/../../LinAlg/TMatrices \
     139        -I$(srcdir)/../../Algorithm -I$(srcdir)/../../Interfaces \
     140        -I$(srcdir)/../AmplSolver $(AMPL_CPPFLAGS)
    144141CXXLIBS = @CXXLIBS@
    145142CYGPATH_W = @CYGPATH_W@
     
    229226noinst_LIBRARIES = libcompositenlp.a
    230227libcompositenlp_a_SOURCES = \
    231         CompositeNLP.hpp CompositeNLP.cpp
     228        CompositeNLP.cpp CompositeNLP.hpp
    232229
    233230composite_ampl_ipopt_SOURCES = \
    234231        comp_ampl_ipopt.cpp
    235232
    236 IPLIBS = ../../Algorithm/libipoptalg.a \
    237         ../../LinAlgImpl/Serial/liblaserial.a \
    238         ../../PDSystemImpl/PDFullSpace/libpdfullspace.a \
     233IPLIBS = \
     234        ../../Interfaces/libinterfaces.a \
     235        ../../Algorithm/libipoptalg.a \
     236        ../../Algorithm/LinearSolvers/liblinsolvers.a \
     237        ../../LinAlg/TMatrices/libtmatrices.a \
     238        ../../LinAlg/liblinalg.a \
    239239        ../../Common/libcommon.a \
    240         ../../Apps/AmplSolver/libamplinterface.a \
     240        ../AmplSolver/libamplinterface.a \
    241241        $(ASLLIB)
    242242
     
    247247# Astyle stuff
    248248ASTYLE_FILES = \
    249         CompositeNLP.hppbak CompositeNLP.cppbak \
     249        CompositeNLP.cppbak CompositeNLP.hppbak \
    250250        comp_ampl_ipopt.cppbak
    251251
  • branches/dev/Apps/CompositeInterface/comp_ampl_ipopt.cpp

    r224 r430  
    3636                         SmartPtr<VectorSpace>& q_space);
    3737
    38   int RunIpoptAlgorithm(const SmartPtr<Journalist> nonconst_jnlst, int argv, char**argc)
     38  int RunIpoptAlgorithm(const SmartPtr<const Journalist>& jnlst,
     39                        int argv, char**argc)
    3940  {
    40     SmartPtr<const Journalist> jnlst = ConstPtr(nonconst_jnlst);
    41 
    4241    jnlst->Printf(J_ERROR, J_MAIN, "\n\n\n*************************************************************\n");
    4342    jnlst->Printf(J_ERROR, J_MAIN, "*** Running Ipopt with AMPL Model ***************************\n");
     
    4645    // For test purposes, every ampl model must have 5 variables and the
    4746    // last variable in all of them is the linked variable
    48     Index nx = 5;
    4947    std::vector<SmartPtr<AmplTNLP> > ampl_nlps;
    5048    std::vector<SmartPtr<NLP> > nlps;
     
    6866      suffix_handlers.push_back(GetRawPtr(suffix_handler));
    6967
    70       SmartPtr<AmplTNLP> ampl_nlp_i = new AmplTNLP(nonconst_jnlst, argc_i, suffix_handler);
     68      SmartPtr<AmplTNLP> ampl_nlp_i = new AmplTNLP(jnlst, argc_i, suffix_handler);
    7169      ampl_nlps.push_back(GetRawPtr(ampl_nlp_i));
    7270
     
    8684                                         Jx_linking_eqns, Jq_linking_eqns);
    8785
    88     SmartPtr<IpoptNLP> ip_nlp = new OrigIpoptNLP(jnlst, nlp);
     86    SmartPtr<NLPScalingObject> nlp_scaling = new NoNLPScalingObject();
     87    SmartPtr<IpoptNLP> ip_nlp = new OrigIpoptNLP(jnlst, nlp, nlp_scaling);
    8988
    9089    // Create the IpoptData
     
    113112
    114113    // Run the algorithm
    115     IpoptAlgorithm::SolverReturn status = alg->Optimize();
     114    SolverReturn status = alg->Optimize();
    116115
    117116    int retval=-1;
    118117
    119     if (status == IpoptAlgorithm::SUCCESS) {
     118    if (status == SUCCESS) {
    120119      jnlst->Printf(J_SUMMARY, J_SOLUTION, "\n\nOptimal solution found! \n");
    121120      jnlst->Printf(J_SUMMARY, J_SOLUTION, "Optimal Objective Value = %.16E\n", ip_cq->curr_f());
    122121      jnlst->Printf(J_SUMMARY, J_SOLUTION, "Number of Iterations = %d\n", ip_data->iter_count());
    123       jnlst->PrintVector(J_VECTOR, J_SOLUTION, "x", *ip_data->curr_x());
    124       jnlst->PrintVector(J_VECTOR, J_SOLUTION, "y_c", *ip_data->curr_y_c());
    125       jnlst->PrintVector(J_VECTOR, J_SOLUTION, "y_d", *ip_data->curr_y_d());
    126       jnlst->PrintVector(J_VECTOR, J_SOLUTION, "z_L", *ip_data->curr_z_L());
    127       jnlst->PrintVector(J_VECTOR, J_SOLUTION, "z_U", *ip_data->curr_z_U());
    128       jnlst->PrintVector(J_VECTOR, J_SOLUTION, "v_L", *ip_data->curr_v_L());
    129       jnlst->PrintVector(J_VECTOR, J_SOLUTION, "v_U", *ip_data->curr_v_U());
     122      ip_data->curr()->Print(jnlst, J_VECTOR, J_SOLUTION, "sol");
    130123
    131124      retval = 0;
     
    151144  {
    152145    Index n_nlps = nlps.size();
    153     DBG_ASSERT(n_nlps == suffix_handlers.size());
     146    DBG_ASSERT(n_nlps == (Index)suffix_handlers.size());
    154147
    155148    // first, count the number of required q's
     
    255248# endif
    256249
    257   Journal* jrnl = jnlst->AddJournal("ConsoleStdOut", "stdout", J_SUMMARY);
     250  SmartPtr<Journal> jrnl =
     251    jnlst->AddFileJournal("ConsoleStdOut", "stdout", J_SUMMARY);
    258252  jrnl->SetPrintLevel(J_DBG, J_NONE);
    259253
    260   jrnl = jnlst->AddJournal("Debug", "debug.out", J_DETAILED);
     254  jrnl = jnlst->AddFileJournal("Debug", "debug.out", J_DETAILED);
    261255  jrnl->SetPrintLevel(J_DBG, J_ALL);
    262256
    263   jrnl = jnlst->AddJournal("All", "all.out", J_ALL);
     257  jrnl = jnlst->AddFileJournal("All", "all.out", J_ALL);
    264258
    265259  try {
     
    268262    //***
    269263
    270     retValue = Ipopt::RunIpoptAlgorithm(jnlst, argv, argc);
     264    retValue = Ipopt::RunIpoptAlgorithm(ConstPtr(jnlst), argv, argc);
    271265  }
    272266  catch(IpoptException& exc) {
  • branches/dev/Apps/Makefile.am

    r257 r430  
    99AUTOMAKE_OPTIONS = foreign
    1010
    11 SUBDIRS = StdInterface CUTErInterface
     11SUBDIRS = CUTErInterface
    1212
    1313if BUILDASLDIR
    1414  SUBDIRS += AmplSolver
    15 #  SUBDIRS += CompositeInterface
     15  SUBDIRS += CompositeInterface
    1616endif
  • branches/dev/Apps/Makefile.in

    r382 r430  
    4141POST_UNINSTALL = :
    4242build_triplet = @build@
    43 @BUILDASLDIR_TRUE@am__append_1 = AmplSolver
     43@BUILDASLDIR_TRUE@am__append_1 = AmplSolver CompositeInterface
    4444subdir = Apps
    4545DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
     
    6161ETAGS = etags
    6262CTAGS = ctags
    63 DIST_SUBDIRS = StdInterface CUTErInterface AmplSolver
     63DIST_SUBDIRS = CUTErInterface AmplSolver CompositeInterface
    6464DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
    6565ACLOCAL = @ACLOCAL@
     
    9191BUILDHSL_FALSE = @BUILDHSL_FALSE@
    9292BUILDHSL_TRUE = @BUILDHSL_TRUE@
    93 BUILDLAPACKDIR_FALSE = @BUILDLAPACKDIR_FALSE@
    94 BUILDLAPACKDIR_TRUE = @BUILDLAPACKDIR_TRUE@
    95 BUILDLAPACK_FALSE = @BUILDLAPACK_FALSE@
    96 BUILDLAPACK_TRUE = @BUILDLAPACK_TRUE@
    9793BUILDMA27_FALSE = @BUILDMA27_FALSE@
    9894BUILDMA27_TRUE = @BUILDMA27_TRUE@
     
    192188target_alias = @target_alias@
    193189AUTOMAKE_OPTIONS = foreign
    194 SUBDIRS = StdInterface CUTErInterface $(am__append_1)
     190SUBDIRS = CUTErInterface $(am__append_1)
    195191all: all-recursive
    196192
     
    490486        uninstall uninstall-am uninstall-info-am
    491487
    492 #  SUBDIRS += CompositeInterface
    493488# Tell versions [3.59,3.63) of GNU make to not export all variables.
    494489# Otherwise a system limit (for SysV at least) may be exceeded.
  • branches/dev/Common/IpDebug.cpp

    r422 r430  
    8686
    8787
    88   Index DebugJournalistWrapper::Verbosity()
    89   {
    90     return verbose_level_;
    91   }
    92 
    9388  void DebugJournalistWrapper::DebugPrintf(Index verbosity, const char* pformat, ...)
    9489  {
     
    107102  }
    108103
    109   void DebugJournalistWrapper::DebugPrintVector(const std::string& vec_name, const Vector& vec)
    110   {
    111     jrnl_->PrintVector(J_ERROR, J_DBG, vec_name, vec, indentation_level_*2, "# ");
    112   }
    113 
    114   void DebugJournalistWrapper::DebugPrintMatrix(const std::string& mat_name, const Matrix& mat)
    115   {
    116     jrnl_->PrintMatrix(J_ERROR, J_DBG, mat_name, mat, indentation_level_*2, "# ");
    117   }
    118 
    119 
    120 
    121104} // namespace Ipopt
    122105
  • branches/dev/Common/IpDebug.hpp

    r422 r430  
    1010#define __IPDEBUG_HPP__
    1111
    12 #include "config.h"
    1312#include "IpTypes.hpp"
    1413#ifdef OLD_C_HEADERS
     
    4039#else
    4140#include <string>
    42 //#include "IpVector.hpp"
    4341
    4442namespace Ipopt
    4543{
     44  // forward definition
     45  class Journalist;
    4646
    47   // forward declarations
    48   class Journalist;
    49   class Vector;
    50   class Matrix;
    51 
     47  /** Class that lives throughout the execution of a method or
     48  *  function for which debug output is to be generated.  The output
     49  *  is sent to the unique debug journalist that is set with
     50  *  SetJournalist at the beginning of program execution. */
    5251  class DebugJournalistWrapper
    5352  {
    5453  public:
     54    /** @name Constructors/Destructors. */
     55    //@{
    5556    DebugJournalistWrapper(std::string func_name, Index verbose_level);
    5657    DebugJournalistWrapper(std::string func_name, Index verbose_level,
    5758                           const void* const method_owner);
    5859    ~DebugJournalistWrapper();
     60    //@}
    5961
    60     Index Verbosity();
     62    /** @name accessor methods */
     63    //@{
     64    Index Verbosity()
     65    {
     66      return verbose_level_;
     67    }
     68    const Journalist* Jnlst()
     69    {
     70      return jrnl_;
     71    }
     72    Index IndentationLevel()
     73    {
     74      return indentation_level_;
     75    }
     76    //@}
    6177
     78    /** Printing */
    6279    void DebugPrintf(Index verbosity, const char* pformat, ...);
    6380
    64     void DebugPrintVector(const std::string& vec_name, const Vector& vec);
    65 
    66     void DebugPrintMatrix(const std::string& mat_name, const Matrix& mat);
    67 
     81    /* Method for initialization of the static GLOBAL journalist,
     82    * through with all debug printout is to be written.  This needs
     83    * to be set before any debug printout can be done. */
    6884    static void SetJournalist(Journalist* jrnl);
    6985
    7086  private:
     87    /**@name Default Compiler Generated Methods
     88    * (Hidden to avoid implicit creation/calling).
     89    * These methods are not implemented and
     90    * we do not want the compiler to implement
     91    * them for us, so we declare them private
     92    * and do not define them. This ensures that
     93    * they will not be implicitly created/called. */
     94    //@{
     95    /** default constructor */
     96    DebugJournalistWrapper();
     97
     98    /** copy contructor */
     99    DebugJournalistWrapper(const DebugJournalistWrapper&);
     100
     101    /** Overloaded Equals Operator */
     102    DebugJournalistWrapper& operator=(const DebugJournalistWrapper&);
     103    //@}
    71104
    72105    static Index indentation_level_;
     
    88121  dbg_jrnl.DebugPrintf __args;
    89122
    90 # define DBG_PRINT_VECTOR(__verbose_level, __vec_name, __vec) \
    91    if (dbg_jrnl.Verbosity() >= (__verbose_level)) { \
    92       dbg_jrnl.DebugPrintVector(__vec_name, __vec); \
    93    }
    94 
    95 # define DBG_PRINT_MATRIX(__verbose_level, __mat_name, __mat) \
    96    if (dbg_jrnl.Verbosity() >= (__verbose_level)) { \
    97       dbg_jrnl.DebugPrintMatrix(__mat_name, __mat); \
    98    }
    99 
    100123# define DBG_EXEC(__verbose_level, __cmd) \
    101124  if (dbg_jrnl.Verbosity() >= (__verbose_level)) { \
  • branches/dev/Common/IpJournalist.cpp

    r428 r430  
    88
    99#include "IpJournalist.hpp"
    10 #include "IpVector.hpp"
    11 #include "IpMatrix.hpp"
     10#include "IpDebug.hpp"
    1211#include <stdio.h>
    1312
     
    110109  }
    111110
    112   void Journalist::PrintVector(EJournalLevel level,
    113                                EJournalCategory category,
    114                                const std::string& name,
    115                                const Vector& vector,
    116                                Index indent,
    117                                const std::string prefix) const
    118   {
    119     // print the msg on every journal that accepts
    120     // the category and output level
    121     for (Index i=0; i<(Index)journals_.size(); i++) {
    122       if (journals_[i]->IsAccepted(category, level)) {
    123         // print the message
    124         journals_[i]->PrintVector(name, vector, indent, prefix);
    125       }
    126     }
    127   }
    128 
    129   void Journalist::PrintMatrix(EJournalLevel level,
    130                                EJournalCategory category,
    131                                const std::string& name,
    132                                const Matrix& matrix,
    133                                Index indent /*=0*/,
    134                                std::string prefix /*=""*/) const
    135   {
    136     // print the msg on every journal that accepts
    137     // the category and output level
    138     for (Index i=0; i<(Index)journals_.size(); i++) {
    139       if (journals_[i]->IsAccepted(category, level)) {
    140         // print the message
    141         journals_[i]->PrintMatrix(name, matrix, indent, prefix);
    142       }
    143     }
    144   }
     111  //   void Journalist::PrintVector(EJournalLevel level,
     112  //                                EJournalCategory category,
     113  //                                const std::string& name,
     114  //                                const Vector& vector,
     115  //                                Index indent,
     116  //                                const std::string prefix) const
     117  //   {
     118  //     // print the msg on every journal that accepts
     119  //     // the category and output level
     120  //     for (Index i=0; i<(Index)journals_.size(); i++) {
     121  //       if (journals_[i]->IsAccepted(category, level)) {
     122  //         // print the message
     123  //         journals_[i]->PrintVector(name, vector, indent, prefix);
     124  //       }
     125  //     }
     126  //   }
     127
     128  //   void Journalist::PrintMatrix(EJournalLevel level,
     129  //                                EJournalCategory category,
     130  //                                const std::string& name,
     131  //                                const Matrix& matrix,
     132  //                                Index indent /*=0*/,
     133  //                                std::string prefix /*=""*/) const
     134  //   {
     135  //     // print the msg on every journal that accepts
     136  //     // the category and output level
     137  //     for (Index i=0; i<(Index)journals_.size(); i++) {
     138  //       if (journals_[i]->IsAccepted(category, level)) {
     139  //         // print the message
     140  //         journals_[i]->PrintMatrix(name, matrix, indent, prefix);
     141  //       }
     142  //     }
     143  //   }
    145144
    146145  void Journalist::VPrintf(
     
    389388  }
    390389
    391   void FileJournal::PrintVectorImpl(const std::string name, const Vector& vector, Index indent, std::string prefix)
    392   {
    393     DBG_START_METH("Journal::PrintVector", 0);
    394     if (file_) {
    395       vector.Print(file_, name, indent, prefix);
    396       DBG_EXEC(0, fflush(file_));
    397     }
    398   }
    399 
    400   void FileJournal::PrintMatrixImpl(const std::string name, const Matrix& matrix, Index indent, std::string prefix)
    401   {
    402     DBG_START_METH("Journal::PrintMatrix", 0);
    403     if (file_) {
    404       matrix.Print(file_, name, indent, prefix);
    405       DBG_EXEC(0, fflush(file_));
    406     }
    407   }
     390  //   void FileJournal::PrintVectorImpl(const std::string name, const Vector& vector, Index indent, std::string prefix)
     391  //   {
     392  //     DBG_START_METH("Journal::PrintVector", 0);
     393  //     if (file_) {
     394  //       vector.Print(file_, name, indent, prefix);
     395  //       DBG_EXEC(0, fflush(file_));
     396  //     }
     397  //   }
     398
     399  //   void FileJournal::PrintMatrixImpl(const std::string name, const Matrix& matrix, Index indent, std::string prefix)
     400  //   {
     401  //     DBG_START_METH("Journal::PrintMatrix", 0);
     402  //     if (file_) {
     403  //       matrix.Print(file_, name, indent, prefix);
     404  //       DBG_EXEC(0, fflush(file_));
     405  //     }
     406  //   }
    408407
    409408  void FileJournal::FlushBufferImpl()
  • branches/dev/Common/IpJournalist.hpp

    r418 r430  
    2727  class Journal;
    2828  class FileJournal;
    29   class Matrix;
    30   class Vector;
    3129
    3230  /**@name Journalist Enumerations. */
     
    130128                        const char* format, ...) const;
    131129
    132     /** Method for printing a vector.  This calls the Vector print
    133     *  methods for each appropriate Journal.
    134     */
    135     void PrintVector(EJournalLevel level,
    136                      EJournalCategory category,
    137                      const std::string& name,
    138                      const Vector& vector,
    139                      Index indent=0,
    140                      std::string prefix="") const;
    141 
    142     /** Method for printing a matrix.  This calls the Matrix print
    143     *  methods for each appropriate Journal.
    144     */
    145     void PrintMatrix(EJournalLevel level,
    146                      EJournalCategory category,
    147                      const std::string& name,
    148                      const Matrix& matrix,
    149                      Index indent=0,
    150                      std::string prefix="") const;
     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;
    151149
    152150    /** Method to print a formatted string
     
    297295    }
    298296
    299     /** Print vector to the designated output location */
    300     void PrintVector(std::string name, const Vector& vector,
    301                      Index indent, std::string prefix)
    302     {
    303       PrintVectorImpl(name, vector, indent, prefix);
    304     }
    305 
    306     /** Print matrix to the designated output location */
    307     void PrintMatrix(const std::string name, const Matrix& matrix,
    308                      Index indent, std::string prefix)
    309     {
    310       PrintMatrixImpl(name, matrix, indent, prefix);
    311     }
     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    //     }
    312310
    313311    /** Flush output buffer.*/
     
    329327    virtual void PrintfImpl(const char* pformat, va_list ap)=0;
    330328
    331     /** Print vector to the designated output location */
    332     virtual void PrintVectorImpl(std::string name, const Vector& vector, Index indent, std::string prefix)=0;
    333 
    334     /** Print matrix to the designated output location */
    335     virtual void PrintMatrixImpl(const std::string name, const Matrix& matrix, Index indent, std::string prefix)=0;
     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;
    336334
    337335    /** Flush output buffer.*/
     
    399397    virtual void PrintfImpl(const char* pformat, va_list ap);
    400398
    401     /** Print vector to the designated output location */
    402     virtual void PrintVectorImpl(std::string name, const Vector& vector, Index indent, std::string prefix);
    403 
    404     /** Print matrix to the designated output location */
    405     virtual void PrintMatrixImpl(const std::string name, const Matrix& matrix, Index indent, std::string prefix);
     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);
    406404
    407405    /** Flush output buffer.*/
  • branches/dev/Common/IpOptionsList.cpp

    r342 r430  
    1919  void OptionsList::SetValue(const std::string& tag, const std::string& value)
    2020  {
    21     if (IsValid(reg_options_)) { 
     21    if (IsValid(reg_options_)) {
    2222      SmartPtr<const RegisteredOption> option = reg_options_->GetOption(tag);
    23      
    24       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);
     23
     24      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);
    2828      }
    2929
    3030      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_)) { option->OutputDescription(*jnlst_); }
    44         THROW_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE, msg);
     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);
    4547      }
    4648
    4749      if (!option->IsValidStringSetting(value)) {
    48         std::string msg = "Setting: " + value;
    49         msg += " is not a valid setting for Option: ";
    50         msg += tag;
    51         msg += ". Check the option documentation.";
    52         if (IsValid(jnlst_)) { option->OutputDescription(*jnlst_); }
    53         THROW_EXCEPTION(OPTION_OUT_OF_RANGE, msg);
     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);
    5458      }
    5559    }
     
    6468    sprintf(buffer, "%g", value);
    6569
    66     if (IsValid(reg_options_)) { 
     70    if (IsValid(reg_options_)) {
    6771      SmartPtr<const RegisteredOption> option = reg_options_->GetOption(tag);
    68      
    69       if (IsNull(option)) {
    70         std::string msg = "Tried to set Option: " + tag;
    71         msg += ". It is not a valid option. Please check the list of available options.";
    72         THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
     72
     73      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);
    7377      }
    7478
    7579      if (option->Type() != OT_Number) {
    76         std::string msg = "Tried to set Option: " + tag;
    77         msg += ". It is a valid option, but it is of type ";
    78         if (option->Type() == OT_String) {
    79           msg += " String";
    80         }
    81         else if (option->Type() == OT_Integer) {
    82           msg += " Integer";
    83         }
    84         else {
    85           msg += " Unknown";
    86         }
    87         msg += ", not of type Number. Please check the documentation for options.";
    88         if (IsValid(jnlst_)) { option->OutputDescription(*jnlst_); }
    89         THROW_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE, msg);
     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);
    9096      }
    9197
    9298      if (!option->IsValidNumberSetting(value)) {
    93         std::string msg = "Setting: ";
    94         msg += buffer;
    95         msg += " is not a valid setting for Option: ";
    96         msg += tag;
    97         msg += ". Check the option documentation.";
    98         if (IsValid(jnlst_)) { option->OutputDescription(*jnlst_); }
    99         THROW_EXCEPTION(OPTION_OUT_OF_RANGE, msg);
     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);
    100108      }
    101109    }
     
    110118    sprintf(buffer, "%d", value);
    111119
    112     if (IsValid(reg_options_)) { 
     120    if (IsValid(reg_options_)) {
    113121      SmartPtr<const RegisteredOption> option = reg_options_->GetOption(tag);
    114      
    115       if (IsNull(option)) {
    116         std::string msg = "Tried to set Option: " + tag;
    117         msg += ". It is not a valid option. Please check the list of available options.";
    118         THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
     122
     123      if (IsNull(option)) {
     124        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);
    119127      }
    120128
    121129      if (option->Type() != OT_Integer) {
    122         std::string msg = "Tried to set Option: " + tag;
    123         msg += ". It is a valid option, but it is of type ";
    124         if (option->Type() == OT_String) {
    125           msg += " String";
    126         }
    127         else if (option->Type() == OT_Number) {
    128           msg += " Number";
    129         }
    130         else {
    131           msg += " Unknown";
    132         }
    133         msg += ", not of type Integer. Please check the documentation for options.";
    134         if (IsValid(jnlst_)) { option->OutputDescription(*jnlst_); }
    135         THROW_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE, msg);
     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);
    136146      }
    137147
    138148      if (!option->IsValidIntegerSetting(value)) {
    139         std::string msg = "Setting: ";
    140         msg += buffer;
    141         msg += " is not a valid setting for Option: ";
    142         msg += tag;
    143         msg += ". Check the option documentation.";
    144         if (IsValid(jnlst_)) { option->OutputDescription(*jnlst_); }
    145         THROW_EXCEPTION(OPTION_OUT_OF_RANGE, msg);
     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);
    146158      }
    147159    }
     
    152164
    153165  bool OptionsList::GetValue(const std::string& tag, std::string& value,
    154                              const std::string& prefix) const
     166                             const std::string& prefix) const
    155167  {
    156168    SmartPtr<const RegisteredOption> option = NULL;
     
    161173      option = reg_options_->GetOption(tag);
    162174      if (IsNull(option)) {
    163         std::string msg = "IPOPT tried to get the value of Option: " + tag;
    164         msg += ". It is not a valid registered option.";
    165           THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
     175        std::string msg = "IPOPT tried to get the value of Option: " + tag;
     176        msg += ". It is not a valid registered option.";
     177        THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
    166178      }
    167179
    168180      if (option->Type() != OT_String) {
    169         std::string msg = "IPOPT tried to get the value of Option: " + tag;
    170         msg += ". It is a valid option, but it is of type ";
    171         if (option->Type() == OT_Integer) {
    172           msg += " Integer";
    173         }
    174         else if (option->Type() == OT_Number) {
    175           msg += " Number";
    176         }
    177         else {
    178           msg += " Unknown";
    179         }
    180         msg += ", not of type String. Please check the documentation for options.";
    181         if (IsValid(jnlst_)) { option->OutputDescription(*jnlst_); }
    182         THROW_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE, msg);
     181        std::string msg = "IPOPT tried to get the value of Option: " + tag;
     182        msg += ". It is a valid option, but it is of type ";
     183        if (option->Type() == OT_Integer) {
     184          msg += " Integer";
     185        }
     186        else if (option->Type() == OT_Number) {
     187          msg += " Number";
     188        }
     189        else {
     190          msg += " Unknown";
     191        }
     192        msg += ", not of type String. Please check the documentation for options.";
     193        if (IsValid(jnlst_)) {
     194          option->OutputDescription(*jnlst_);
     195        }
     196        THROW_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE, msg);
    183197      }
    184198
    185199      if (found) {
    186         value = option->MapStringSetting(value);
     200        value = option->MapStringSetting(value);
    187201      }
    188202      else {
    189         value = option->DefaultString();
     203        value = option->DefaultString();
    190204      }
    191205    }
     
    195209
    196210  bool OptionsList::GetEnumValue(const std::string& tag, Index& value,
    197                                 const std::string& prefix) const
     211                                const std::string& prefix) const
    198212  {
    199213    std::string str;
     
    205219      option = reg_options_->GetOption(tag);
    206220      if (IsNull(option)) {
    207         std::string msg = "IPOPT tried to get the value of Option: " + tag;
    208         msg += ". It is not a valid registered option.";
    209           THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
     221        std::string msg = "IPOPT tried to get the value of Option: " + tag;
     222        msg += ". It is not a valid registered option.";
     223        THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
    210224      }
    211225
    212226      if (option->Type() != OT_String) {
    213         std::string msg = "IPOPT tried to get the value of Option: " + tag;
    214         msg += ". It is a valid option, but it is of type ";
    215         if (option->Type() == OT_Integer) {
    216           msg += " Integer";
    217         }
    218         else if (option->Type() == OT_Number) {
    219           msg += " Number";
    220         }
    221         else {
    222           msg += " Unknown";
    223         }
    224         msg += ", not of type String. Please check the documentation for options.";
    225         if (IsValid(jnlst_)) { option->OutputDescription(*jnlst_); }
    226         THROW_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE, msg);
     227        std::string msg = "IPOPT tried to get the value of Option: " + tag;
     228        msg += ". It is a valid option, but it is of type ";
     229        if (option->Type() == OT_Integer) {
     230          msg += " Integer";
     231        }
     232        else if (option->Type() == OT_Number) {
     233          msg += " Number";
     234        }
     235        else {
     236          msg += " Unknown";
     237        }
     238        msg += ", not of type String. Please check the documentation for options.";
     239        if (IsValid(jnlst_)) {
     240          option->OutputDescription(*jnlst_);
     241        }
     242        THROW_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE, msg);
    227243      }
    228244
    229245      if (found) {
    230         value = option->MapStringSettingToEnum(str);
     246        value = option->MapStringSettingToEnum(str);
    231247      }
    232248      else {
    233         value = option->DefaultStringAsEnum();
     249        value = option->DefaultStringAsEnum();
    234250      }
    235251    }
     
    239255
    240256  bool OptionsList::GetBoolValue(const std::string& tag, bool& value,
    241                                 const std::string& prefix) const
     257                                const std::string& prefix) const
    242258  {
    243259    std::string str;
     
    258274
    259275  bool OptionsList::GetNumericValue(const std::string& tag, Number& value,
    260                                     const std::string& prefix) const
    261   { 
     276                                    const std::string& prefix) const
     277  {
    262278    SmartPtr<const RegisteredOption> option = NULL;
    263279
     
    265281      option = reg_options_->GetOption(tag);
    266282      if (IsNull(option)) {
    267         std::string msg = "IPOPT tried to get the value of Option: " + tag;
    268         msg += ". It is not a valid registered option.";
    269           THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
     283        std::string msg = "IPOPT tried to get the value of Option: " + tag;
     284        msg += ". It is not a valid registered option.";
     285        THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
    270286      }
    271287
    272288      if (option->Type() != OT_Number) {
    273         std::string msg = "IPOPT tried to get the value of Option: " + tag;
    274         msg += ". It is a valid option, but it is of type ";
    275         if (option->Type() == OT_Integer) {
    276           msg += " Integer";
    277         }
    278         else if (option->Type() == OT_String) {
    279           msg += " String";
    280         }
    281         else {
    282           msg += " Unknown";
    283         }
    284         msg += ", not of type Number. Please check the documentation for options.";
    285         if (IsValid(jnlst_)) { option->OutputDescription(*jnlst_); }
    286         THROW_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE, msg);
     289        std::string msg = "IPOPT tried to get the value of Option: " + tag;
     290        msg += ". It is a valid option, but it is of type ";
     291        if (option->Type() == OT_Integer) {
     292          msg += " Integer";
     293        }
     294        else if (option->Type() == OT_String) {
     295          msg += " String";
     296        }
     297        else {
     298          msg += " Unknown";
     299        }
     300        msg += ", not of type Number. Please check the documentation for options.";
     301        if (IsValid(jnlst_)) {
     302          option->OutputDescription(*jnlst_);
     303        }
     304        THROW_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE, msg);
    287305      }
    288306    }
     
    293311      Number retval = strtod(strvalue.c_str(), &p_end);
    294312      if (*p_end!='\0' && !isspace(*p_end)) {
    295         std::string msg = "Option \"" + tag +
    296           "\": Double value expected, but non-numeric value \"" +
    297           strvalue+"\" found.\n";
    298         THROW_EXCEPTION(OPTION_VALUE_IS_NONNUMERIC, msg);
     313        std::string msg = "Option \"" + tag +
     314                          "\": Double value expected, but non-numeric value \"" +
     315                          strvalue+"\" found.\n";
     316        THROW_EXCEPTION(OPTION_VALUE_IS_NONNUMERIC, msg);
    299317      }
    300318      value = retval;
     
    309327
    310328  bool OptionsList::GetIntegerValue(const std::string& tag, Index& value,
    311                                     const std::string& prefix) const
     329                                    const std::string& prefix) const
    312330  {
    313331    SmartPtr<const RegisteredOption> option = NULL;
     
    316334      option = reg_options_->GetOption(tag);
    317335      if (IsNull(option)) {
    318         std::string msg = "IPOPT tried to get the value of Option: " + tag;
    319         msg += ". It is not a valid registered option.";
    320           THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
     336        std::string msg = "IPOPT tried to get the value of Option: " + tag;
     337        msg += ". It is not a valid registered option.";
     338        THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
    321339      }
    322340
    323341      if (option->Type() != OT_Integer) {
    324         std::string msg = "IPOPT tried to get the value of Option: " + tag;
    325         msg += ". It is a valid option, but it is of type ";
    326         if (option->Type() == OT_Number) {
    327           msg += " Number";
    328         }
    329         else if (option->Type() == OT_String) {
    330           msg += " String";
    331         }
    332         else {
    333           msg += " Unknown";
    334         }
    335         msg += ", not of type Integer. Please check the documentation for options.";
    336         if (IsValid(jnlst_)) { option->OutputDescription(*jnlst_); }
    337         THROW_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE, msg);
     342        std::string msg = "IPOPT tried to get the value of Option: " + tag;
     343        msg += ". It is a valid option, but it is of type ";
     344        if (option->Type() == OT_Number) {
     345          msg += " Number";
     346        }
     347        else if (option->Type() == OT_String) {
     348          msg += " String";
     349        }
     350        else {
     351          msg += " Unknown";
     352        }
     353        msg += ", not of type Integer. Please check the documentation for options.";
     354        if (IsValid(jnlst_)) {
     355          option->OutputDescription(*jnlst_);
     356        }
     357        THROW_EXCEPTION(OPTION_VALUE_IS_INCORRECT_TYPE, msg);
    338358      }
    339359    }
     
    344364      Index retval = strtol(strvalue.c_str(), &p_end, 10);
    345365      if (*p_end!='\0' && !isspace(*p_end)) {
    346         std::string msg = "Option \"" + tag +
    347           "\": Integer value expected, but non-integer value \"" +
    348           strvalue+"\" found.\n";
    349         THROW_EXCEPTION(OPTION_VALUE_IS_NONINTEGER, msg);
     366        std::string msg = "Option \"" + tag +
     367                          "\": Integer value expected, but non-integer value \"" +
     368                          strvalue+"\" found.\n";
     369        THROW_EXCEPTION(OPTION_VALUE_IS_NONINTEGER, msg);
    350370      }
    351371      value = retval;
     
    376396    list += buffer;
    377397    for(std::map< std::string, OptionValue >::const_iterator p = options_.begin();
    378         p != options_.end();
    379         p++ )
    380       {
    381         sprintf(buffer, "%40s = %-20s %6d\n", p->first.c_str(),
    382                 p->second.Value().c_str(), p->second.Counter());
    383         list += buffer;
    384       }
     398        p != options_.end();
     399        p++ ) {
     400      sprintf(buffer, "%40s = %-20s %6d\n", p->first.c_str(),
     401              p->second.Value().c_str(), p->second.Counter());
     402      list += buffer;
     403    }
    385404  }
    386405
    387406  bool OptionsList::ReadFromFile(const Journalist& jnlst,
    388                                 FILE* fp)
     407                                FILE* fp)
    389408  {
    390409    DBG_ASSERT(fp);
     
    397416
    398417      if (!readnexttoken(fp, tag)) {
    399         // That's it - end of file reached.
    400         jnlst.Printf(J_DETAILED, J_MAIN,
    401                      "Finished reading options from file.\n");
    402         return true;
     418        // That's it - end of file reached.
     419        jnlst.Printf(J_DETAILED, J_MAIN,
     420                     "Finished reading options from file.\n");
     421        return true;
    403422      }
    404423
    405424      if (!readnexttoken(fp, value)) {
    406         // Can't read value for a given tag
    407         jnlst.Printf(J_ERROR, J_MAIN,
    408                      "Error reading value for tag %s from file.\n",
    409                      tag.c_str());
    410         return false;
     425        // Can't read value for a given tag
     426        jnlst.Printf(J_ERROR, J_MAIN,
     427                     "Error reading value for tag %s from file.\n",
     428                     tag.c_str());
     429        return false;
    411430      }
    412431
    413432      // Now add the value for the options list
    414433      jnlst.Printf(J_DETAILED, J_MAIN,
    415                    "Adding option \"%s\" with value \"%s\" to OptionsList.\n",
    416                    tag.c_str(), value.c_str());
     434                   "Adding option \"%s\" with value \"%s\" to OptionsList.\n",
     435                   tag.c_str(), value.c_str());
    417436
    418437      if (IsValid(reg_options_)) {
    419         SmartPtr<const RegisteredOption> option = reg_options_->GetOption(tag);
    420         if (IsNull(option)) {
    421           std::string msg = "Read Option: ";
    422           msg += tag;
    423           msg += ". It is not a valid option. Check the list of available options.";
    424           THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
    425         }
    426        
    427         if (option->Type() == OT_String) {
    428           SetValue(tag, value);
    429         }
    430         else if (option->Type() == OT_Number) {
    431           char* p_end;
    432           Number retval = strtod(value.c_str(), &p_end);
    433           if (*p_end!='\0' && !isspace(*p_end)) {
    434             std::string msg = "Option \"" + tag +
    435               "\": Double value expected, but non-numeric value \"" +
    436               value + "\" found.\n";
    437             THROW_EXCEPTION(OPTION_VALUE_IS_NONNUMERIC, msg);
    438           }
    439           SetNumericValue(tag, retval);
    440         }
    441         else if (option->Type() == OT_Integer) {
    442           char* p_end;
    443           Index retval = strtol(value.c_str(), &p_end, 10);
    444           if (*p_end!='\0' && !isspace(*p_end)) {
    445             std::string msg = "Option \"" + tag +
    446               "\": Integer value expected, but non-integer value \"" +
    447               value + "\" found.\n";
    448             if (IsValid(jnlst_)) { option->OutputDescription(*jnlst_); }
    449             THROW_EXCEPTION(OPTION_VALUE_IS_NONINTEGER, msg);
    450           }
    451           SetIntegerValue(tag, retval);
    452         }
    453         else {
    454           DBG_ASSERT(false && "Option Type: Unknown");
    455         }
     438        SmartPtr<const RegisteredOption> option = reg_options_->GetOption(tag);
     439        if (IsNull(option)) {
     440          std::string msg = "Read Option: ";
     441          msg += tag;
     442          msg += ". It is not a valid option. Check the list of available options.";
     443          THROW_EXCEPTION(OPTION_NOT_REGISTERED, msg);
     444        }
     445
     446        if (option->Type() == OT_String) {
     447          SetValue(tag, value);
     448        }
     449        else if (option->Type() == OT_Number) {
     450          char* p_end;
     451          Number retval = strtod(value.c_str(), &p_end);
     452          if (*p_end!='\0' && !isspace(*p_end)) {
     453            std::string msg = "Option \"" + tag +
     454                              "\": Double value expected, but non-numeric value \"" +
     455                              value + "\" found.\n";
     456            THROW_EXCEPTION(OPTION_VALUE_IS_NONNUMERIC, msg);
     457          }
     458          SetNumericValue(tag, retval);
     459        }
     460        else if (option->Type() == OT_Integer) {
     461          char* p_end;
     462          Index retval = strtol(value.c_str(), &p_end, 10);
     463          if (*p_end!='\0' && !isspace(*p_end)) {
     464            std::string msg = "Option \"" + tag +
     465                              "\": Integer value expected, but non-integer value \"" +
     466                              value + "\" found.\n";
     467            if (IsValid(jnlst_)) {
     468              option->OutputDescription(*jnlst_);
     469            }
     470            THROW_EXCEPTION(OPTION_VALUE_IS_NONINTEGER, msg);
     471          }
     472          SetIntegerValue(tag, retval);
     473        }
     474        else {
     475          DBG_ASSERT(false && "Option Type: Unknown");
     476        }
    456477      }
    457478      else {
    458         SetValue(tag, value);
     479        SetValue(tag, value);
    459480      }
    460481    }
     
    462483
    463484  bool OptionsList::find_tag(const std::string& tag,
    464                              const std::string& prefix,
    465                              std::string& value) const
     485                             const std::string& prefix,
     486                             std::string& value) const
    466487  {
    467488    bool found=false;
     
    471492      p = options_.find(lowercase(prefix+tag));
    472493      if (p != options_.end()) {
    473         found = true;
     494        found = true;
    474495      }
    475496    }
     
    478499      p = options_.find(lowercase(tag));
    479500      if (p != options_.end()) {
    480         found = true;
     501        found = true;
    481502      }
    482503    }
     
    497518    while (c!=EOF && (isspace(c) || c=='#') ) {
    498519      if (c=='#') {
    499         for (c=fgetc(fp);
    500              c!='\n' && c!=EOF;
    501              c=fgetc(fp));
     520        for (c=fgetc(fp);
     521             c!='\n' && c!=EOF;
     522             c=fgetc(fp))
     523          ;
    502524      }
    503525      c=fgetc(fp);
     
    510532    }
    511533
    512   return (c!=EOF);
     534    return (c!=EOF);
    513535  }
    514536
  • branches/dev/Common/IpReferenced.hpp

    r223 r430  
    1010#define __IPREFERENCED_HPP__
    1111
    12 #include "IpUtils.hpp"
    13 #include "IpDebug.hpp"
     12#include "IpTypes.hpp"
    1413#include <list>
     14
     15#ifdef IP_DEBUG
     16# ifdef OLD_C_HEADERS
     17#  include <assert.h>
     18# else
     19#  include <cassert>
     20# endif
     21#endif
    1522
    1623namespace Ipopt
     
    166173  {
    167174  public:
    168     ReferencedObject();
    169 
    170     virtual ~ReferencedObject();
     175    ReferencedObject()
     176      :
     177      reference_count_(0)
     178    {
     179    }
     180
     181    virtual ~ReferencedObject()
     182    {
     183#ifdef IP_DEBUG
     184      assert(reference_count_ == 0);
     185#endif
     186    }
    171187
    172188    Index ReferenceCount() const;
  • branches/dev/Common/IpRegOptions.cpp

    r425 r430  
    672672  }
    673673
     674  std::list<OptionsRegistrar*>& OptionsRegistrarsList()
     675  {
     676    static std::list<OptionsRegistrar*> options_infos;
     677    return options_infos;
     678  }
     679
    674680} // namespace Ipopt
  • branches/dev/Common/IpRegOptions.hpp

    r425 r430  
    563563  };
    564564
     565  ///////////////////////////////////////////////////////////////////////
     566  ///////////////////////////////////////////////////////////////////////
     567
     568  // Forward definition
     569  class OptionsRegistrar;
     570  std::list<OptionsRegistrar*>& OptionsRegistrarsList();
     571
     572  /** This class is for implementing the registration of options on a
     573   *  class by class basis.  It is primarily used so we have runtime
     574   *  access to each class.
     575   */
     576  class OptionsRegistrar
     577  {
     578  public:
     579    /** @name Constructors / Destructors */
     580    //@{
     581    /** Standard Constructor - takes in the class_name of the derived class */
     582    OptionsRegistrar(const char* class_name)
     583        : class_name_(class_name)
     584    {
     585      OptionsRegistrarsList().push_back(this);
     586    }
     587
     588    /** Standard destructor */
     589    virtual ~OptionsRegistrar()
     590    {}
     591    //@}
     592
     593    /** Standard Access Methods */
     594    //@{
     595    std::string ClassName()
     596    {
     597      return class_name_;
     598    }
     599    //@}
     600
     601    /** Static methods to interact with ALL class type infos */
     602    //@{
     603    /** Register all the options */
     604    static void RegisterAllOptions(SmartPtr<RegisteredOptions> reg_options);
     605    //@}
     606
     607  protected:
     608    /** Methods to be overridded by derived classes */
     609    //@{
     610    /** Override this method in derived TypeInfo classs to register options */
     611    virtual void RegisterOptionsImpl(SmartPtr<RegisteredOptions> reg_options)=0;
     612    //@}
     613
     614  private:
     615    /** store the type name */
     616    std::string class_name_;
     617
     618    /** keep a static list of all OptionsRegistrar's */
     619    //  static std::list<OptionsRegistrar*> ipopt_type_infos_;
     620
     621  };
     622
     623  inline
     624  void OptionsRegistrar::RegisterAllOptions(SmartPtr<RegisteredOptions> reg_options)
     625  {
     626    std::list<OptionsRegistrar*>::iterator i;
     627    for (i=OptionsRegistrarsList().begin(); i != OptionsRegistrarsList().end(); i++) {
     628      (*i)->RegisterOptionsImpl(reg_options);
     629    }
     630  }
     631
     632
     633  //extern std::list<OptionsRegistrar*> OptionsRegistrar::ipopt_type_infos_;
     634
     635
     636  ////////////////////////////////////////////////////////////
     637  // Below is what needs to be added for each IpoptType
     638  // but I think this can be macro'ed
     639  ///////////////////////////////////////////////////////////
     640
     641#define DeclareOptionsRegistrar(__class_name__) \
     642class __class_name__ ## OptionsRegistrar : public OptionsRegistrar \
     643 { \
     644  public: \
     645   __class_name__ ## OptionsRegistrar() \
     646     : OptionsRegistrar(# __class_name__) { } \
     647    \
     648   __class_name__ ## OptionsRegistrar* KeepCompilerFromOptimizing(); \
     649  protected: \
     650   virtual void RegisterOptionsImpl(SmartPtr<RegisteredOptions> reg_options); \
     651 };
     652
     653#define DefineOptionsRegistrar(__class_name__) \
     654  void __class_name__ ## OptionsRegistrar::RegisterOptionsImpl(SmartPtr<RegisteredOptions> reg_options) \
     655   { \
     656     reg_options->SetRegisteringClass(# __class_name__ ); \
     657     __class_name__::RegisterOptions(reg_options); \
     658     reg_options->SetRegisteringClass("Unknown Class"); \
     659   } \
     660 \
     661__class_name__ ## OptionsRegistrar _ ## __class_name__ ## OptionsRegistrar_; \
     662 \
     663__class_name__ ## OptionsRegistrar* \
     664__class_name__ ## OptionsRegistrar::KeepCompilerFromOptimizing() \
     665   { return &_ ## __class_name__ ## OptionsRegistrar_; }
     666
     667
    565668} // namespace Ipopt
    566669
  • branches/dev/Common/IpSmartPtr.hpp

    r359 r430  
    1111
    1212#include "IpReferenced.hpp"
    13 #include "IpDebug.hpp"
    1413
    1514//#define IP_DEBUG_SMARTPTR
     15#ifdef IP_DEBUG_SMARTPTR
     16# include "IpDebug.hpp"
     17#endif
    1618
    1719namespace Ipopt
     
    435437
    436438    // cannot deref a null pointer
    437     DBG_ASSERT(ptr_);
     439#ifdef IP_DEBUG
     440    assert(ptr_);
     441#endif
    438442
    439443    return ptr_;
     
    449453
    450454    // cannot dereference a null pointer
    451     DBG_ASSERT(ptr_);
     455#ifdef IP_DEBUG
     456    assert(ptr_);
     457#endif
    452458
    453459    return *ptr_;
     
    584590  bool IsNull(const SmartPtr<U>& smart_ptr)
    585591  {
     592#ifdef IP_DEBUG_SMARTPTR
    586593    DBG_START_FUN(
    587594      "bool IsNull(const SmartPtr<T>& smart_ptr)",
    588595      0);
     596#endif
    589597
    590598    return (smart_ptr.ptr_ == NULL);
  • branches/dev/Common/IpTypes.hpp

    r387 r430  
    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.
     
    1414namespace Ipopt
    1515{
    16 
     16  /** Type of all numbers */
    1717  typedef double Number;
     18  /** Type of all indices of vectors, matrices etc */
    1819  typedef int Index;
     20  /** Type of default integer */
    1921  typedef int Int;
    2022
     
    2224
    2325// external to the Ipopt namespace
     26/** Type of Fortran integer translated into C */
    2427typedef int ipfint;
    2528
  • branches/dev/Common/Makefile.am

    r334 r430  
    99AUTOMAKE_OPTIONS = foreign
    1010
     11includeipoptdir = $(includedir)/ipopt
     12includeipopt_HEADERS = \
     13        IpCachedResults.hpp \
     14        IpDebug.hpp \
     15        IpException.hpp \
     16        IpJournalist.hpp \
     17        IpObserver.hpp \
     18        IpOptionsList.hpp \
     19        IpReferenced.hpp \
     20        IpRegOptions.hpp \
     21        IpSmartPtr.hpp \
     22        IpTaggedObject.hpp \
     23        IpUtils.hpp
     24
    1125noinst_LIBRARIES = libcommon.a
    1226
    1327libcommon_a_SOURCES = \
    1428        IpCachedResults.hpp \
    15         IpCompoundMatrix.cpp IpCompoundMatrix.hpp \
    16         IpCompoundSymMatrix.cpp IpCompoundSymMatrix.hpp \
    17         IpCompoundVector.cpp IpCompoundVector.hpp \
    1829        IpDebug.cpp IpDebug.hpp \
    19         IpDiagMatrix.cpp IpDiagMatrix.hpp \
    2030        IpException.hpp \
    21         IpIdentityMatrix.cpp IpIdentityMatrix.hpp \
    22         IpIpoptType.hpp IpIpoptType.cpp \
    2331        IpJournalist.cpp IpJournalist.hpp \
    24         IpMatrix.cpp \
    2532        IpObserver.cpp IpObserver.hpp \
    2633        IpOptionsList.cpp IpOptionsList.hpp \
    2734        IpRegOptions.cpp IpRegOptions.hpp \
    28         IpReferenced.cpp IpReferenced.hpp \
    29         IpScaledMatrix.cpp IpScaledMatrix.hpp \
     35        IpReferenced.hpp \
    3036        IpSmartPtr.hpp \
    31         IpSumMatrix.cpp IpSumMatrix.hpp \
    32         IpSumSymMatrix.cpp IpSumSymMatrix.hpp \
    33         IpSymMatrix.cpp \
    34         IpSymScaledMatrix.cpp IpSymScaledMatrix.hpp \
    3537        IpTaggedObject.cpp IpTaggedObject.hpp \
    3638        IpTypes.hpp \
    37         IpUtils.hpp \
    38         IpVector.cpp \
    39         IpZeroMatrix.cpp IpZeroMatrix.hpp
    40 
    41 CXXFLAGS += -I$(srcdir)/../Interfaces
     39        IpUtils.hpp
    4240
    4341# Astyle stuff
     
    4543ASTYLE_FILES = \
    4644        IpCachedResults.hppbak \
    47         IpCompoundMatrix.cppbak IpCompoundMatrix.hppbak \
    48         IpCompoundSymMatrix.cppbak IpCompoundSymMatrix.hppbak \
    49         IpCompoundVector.cppbak IpCompoundVector.hppbak \
    50         IpDebug.cppbak IpDebug.hppbak \
    51         IpDiagMatrix.cppbak IpDiagMatrix.hppbak \
     45        IpDebug.cpp IpDebug.hppbak \
    5246        IpException.hppbak \
    53         IpIdentityMatrix.cppbak IpIdentityMatrix.hppbak \
    54         IpIpoptType.hppbak IpIpoptType.cppbak \
    5547        IpJournalist.cppbak IpJournalist.hppbak \
    56         IpMatrix.cppbak \
    5748        IpObserver.cppbak IpObserver.hppbak \
    58         IpOptionsList.hppbak \
     49        IpOptionsList.cppbak IpOptionsList.hppbak \
    5950        IpRegOptions.cppbak IpRegOptions.hppbak \
    60         IpReferenced.cppbak IpReferenced.hppbak \
    61         IpScaledMatrix.cppbak IpScaledMatrix.hppbak \
     51        IpReferenced.hppbak \
    6252        IpSmartPtr.hppbak \
    63         IpSumMatrix.cppbak IpSumMatrix.hppbak \
    64         IpSumSymMatrix.cppbak IpSumSymMatrix.hppbak \
    65         IpSymMatrix.cppbak \
    66         IpSymScaledMatrix.cppbak IpSymScaledMatrix.hppbak \
    6753        IpTaggedObject.cppbak IpTaggedObject.hppbak \
    6854        IpTypes.hppbak \
    69         IpUtils.hppbak \
    70         IpVector.cppbak \
    71         IpZeroMatrix.cppbak IpZeroMatrix.hppbak
     55        IpUtils.hppbak
    7256
    7357ASTYLE = @ASTYLE@
     
    7761
    7862SUFFIXES = .cppbak .hppbak
     63
     64install-exec-local:
     65        echo "#ifndef __IPCONFIG__" >bla
     66        echo "#define __IPCONFIG__" >>bla
     67        cat ../inc/config.h >> bla
     68        echo "#endif" >>bla
     69        sed -s 's/#include "config.h"//' <$(srcdir)/IpTypes.hpp >> bla
     70        $(install_sh_DATA) bla $(includeipoptdir)/IpTypes.hpp
     71        rm bla
     72
     73uninstall-local:
     74        rm -f $(includeipoptdir)/IpTypes.hpp
    7975
    8076astyle: $(ASTYLE_FILES)
  • branches/dev/Common/Makefile.in

    r382 r430  
    2020
    2121# Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
     22
    2223
    2324SOURCES = $(libcommon_a_SOURCES)
     
    4546build_triplet = @build@
    4647subdir = Common
    47 DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
     48DIST_COMMON = $(includeipopt_HEADERS) $(srcdir)/Makefile.am \
     49        $(srcdir)/Makefile.in
    4850ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
    4951am__aclocal_m4_deps = $(top_srcdir)/configure.ac
     
    5658libcommon_a_AR = $(AR) $(ARFLAGS)
    5759libcommon_a_LIBADD =
    58 am_libcommon_a_OBJECTS = IpCompoundMatrix.$(OBJEXT) \
    59         IpCompoundSymMatrix.$(OBJEXT) IpCompoundVector.$(OBJEXT) \
    60         IpDebug.$(OBJEXT) IpDiagMatrix.$(OBJEXT) \
    61         IpIdentityMatrix.$(OBJEXT) IpIpoptType.$(OBJEXT) \
    62         IpJournalist.$(OBJEXT) IpMatrix.$(OBJEXT) IpObserver.$(OBJEXT) \
    63         IpOptionsList.$(OBJEXT) IpRegOptions.$(OBJEXT) \
    64         IpReferenced.$(OBJEXT) IpScaledMatrix.$(OBJEXT) \
    65         IpSumMatrix.$(OBJEXT) IpSumSymMatrix.$(OBJEXT) \
    66         IpSymMatrix.$(OBJEXT) IpSymScaledMatrix.$(OBJEXT) \
    67         IpTaggedObject.$(OBJEXT) IpVector.$(OBJEXT) \
    68         IpZeroMatrix.$(OBJEXT)
     60am_libcommon_a_OBJECTS = IpDebug.$(OBJEXT) IpJournalist.$(OBJEXT) \
     61        IpObserver.$(OBJEXT) IpOptionsList.$(OBJEXT) \
     62        IpRegOptions.$(OBJEXT) IpTaggedObject.$(OBJEXT)
    6963libcommon_a_OBJECTS = $(am_libcommon_a_OBJECTS)
    7064DEFAULT_INCLUDES = -I. -I$(srcdir) -I$(top_builddir)/inc
     
    8276SOURCES = $(libcommon_a_SOURCES)
    8377DIST_SOURCES = $(libcommon_a_SOURCES)
     78am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
     79am__vpath_adj = case $$p in \
     80    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
     81    *) f=$$p;; \
     82  esac;
     83am__strip_dir = `echo $$p | sed -e 's|^.*/||'`;
     84am__installdirs = "$(DESTDIR)$(includeipoptdir)"
     85includeipoptHEADERS_INSTALL = $(INSTALL_HEADER)
     86HEADERS = $(includeipopt_HEADERS)
    8487ETAGS = etags
    8588CTAGS = ctags
     
    113116BUILDHSL_FALSE = @BUILDHSL_FALSE@
    114117BUILDHSL_TRUE = @BUILDHSL_TRUE@
    115 BUILDLAPACKDIR_FALSE = @BUILDLAPACKDIR_FALSE@
    116 BUILDLAPACKDIR_TRUE = @BUILDLAPACKDIR_TRUE@
    117 BUILDLAPACK_FALSE = @BUILDLAPACK_FALSE@
    118 BUILDLAPACK_TRUE = @BUILDLAPACK_TRUE@
    119118BUILDMA27_FALSE = @BUILDMA27_FALSE@
    120119BUILDMA27_TRUE = @BUILDMA27_TRUE@
     
    128127CXX = @CXX@
    129128CXXDEPMODE = @CXXDEPMODE@
    130 CXXFLAGS = @CXXFLAGS@ -I$(srcdir)/../Interfaces
     129CXXFLAGS = @CXXFLAGS@
    131130CXXLIBS = @CXXLIBS@
    132131CYGPATH_W = @CYGPATH_W@
     
    214213target_alias = @target_alias@
    215214AUTOMAKE_OPTIONS = foreign
     215includeipoptdir = $(includedir)/ipopt
     216includeipopt_HEADERS = \
     217        IpCachedResults.hpp \
     218        IpDebug.hpp \
     219        IpException.hpp \
     220        IpJournalist.hpp \
     221        IpObserver.hpp \
     222        IpOptionsList.hpp \
     223        IpReferenced.hpp \
     224        IpRegOptions.hpp \
     225        IpSmartPtr.hpp \
     226        IpTaggedObject.hpp \
     227        IpUtils.hpp
     228
    216229noinst_LIBRARIES = libcommon.a
    217230libcommon_a_SOURCES = \
    218231        IpCachedResults.hpp \
    219         IpCompoundMatrix.cpp IpCompoundMatrix.hpp \
    220         IpCompoundSymMatrix.cpp IpCompoundSymMatrix.hpp \
    221         IpCompoundVector.cpp IpCompoundVector.hpp \
    222232        IpDebug.cpp IpDebug.hpp \
    223         IpDiagMatrix.cpp IpDiagMatrix.hpp \
    224233        IpException.hpp \
    225         IpIdentityMatrix.cpp IpIdentityMatrix.hpp \
    226         IpIpoptType.hpp IpIpoptType.cpp \
    227234        IpJournalist.cpp IpJournalist.hpp \
    228         IpMatrix.cpp \
    229235        IpObserver.cpp IpObserver.hpp \
    230236        IpOptionsList.cpp IpOptionsList.hpp \
    231237        IpRegOptions.cpp IpRegOptions.hpp \
    232         IpReferenced.cpp IpReferenced.hpp \
    233         IpScaledMatrix.cpp IpScaledMatrix.hpp \
     238        IpReferenced.hpp \
    234239        IpSmartPtr.hpp \
    235         IpSumMatrix.cpp IpSumMatrix.hpp \
    236         IpSumSymMatrix.cpp IpSumSymMatrix.hpp \
    237         IpSymMatrix.cpp \
    238         IpSymScaledMatrix.cpp IpSymScaledMatrix.hpp \
    239240        IpTaggedObject.cpp IpTaggedObject.hpp \
    240241        IpTypes.hpp \
    241         IpUtils.hpp \
    242         IpVector.cpp \
    243         IpZeroMatrix.cpp IpZeroMatrix.hpp
     242        IpUtils.hpp
    244243
    245244
     
    247246ASTYLE_FILES = \
    248247        IpCachedResults.hppbak \
    249         IpCompoundMatrix.cppbak IpCompoundMatrix.hppbak \
    250         IpCompoundSymMatrix.cppbak IpCompoundSymMatrix.hppbak \
    251         IpCompoundVector.cppbak IpCompoundVector.hppbak \
    252         IpDebug.cppbak IpDebug.hppbak \
    253         IpDiagMatrix.cppbak IpDiagMatrix.hppbak \
     248        IpDebug.cpp IpDebug.hppbak \
    254249        IpException.hppbak \
    255         IpIdentityMatrix.cppbak IpIdentityMatrix.hppbak \
    256         IpIpoptType.hppbak IpIpoptType.cppbak \
    257250        IpJournalist.cppbak IpJournalist.hppbak \
    258         IpMatrix.cppbak \
    259251        IpObserver.cppbak IpObserver.hppbak \
    260         IpOptionsList.hppbak \
     252        IpOptionsList.cppbak IpOptionsList.hppbak \
    261253        IpRegOptions.cppbak IpRegOptions.hppbak \
    262         IpReferenced.cppbak IpReferenced.hppbak \
    263         IpScaledMatrix.cppbak IpScaledMatrix.hppbak \
     254        IpReferenced.hppbak \
    264255        IpSmartPtr.hppbak \
    265         IpSumMatrix.cppbak IpSumMatrix.hppbak \
    266         IpSumSymMatrix.cppbak IpSumSymMatrix.hppbak \
    267         IpSymMatrix.cppbak \
    268         IpSymScaledMatrix.cppbak IpSymScaledMatrix.hppbak \
    269256        IpTaggedObject.cppbak IpTaggedObject.hppbak \
    270257        IpTypes.hppbak \
    271         IpUtils.hppbak \
    272         IpVector.cppbak \
    273         IpZeroMatrix.cppbak IpZeroMatrix.hppbak
     258        IpUtils.hppbak
    274259
    275260CLEANFILES = $(ASTYLE_FILES)
     
    322307        -rm -f *.tab.c
    323308
    324 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpCompoundMatrix.Po@am__quote@
    325 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpCompoundSymMatrix.Po@am__quote@
    326 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpCompoundVector.Po@am__quote@
    327309@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpDebug.Po@am__quote@
    328 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpDiagMatrix.Po@am__quote@
    329 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpIdentityMatrix.Po@am__quote@
    330 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpIpoptType.Po@am__quote@
    331310@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpJournalist.Po@am__quote@
    332 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpMatrix.Po@am__quote@
    333311@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpObserver.Po@am__quote@
    334312@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpOptionsList.Po@am__quote@
    335 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpReferenced.Po@am__quote@
    336313@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpRegOptions.Po@am__quote@
    337 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpScaledMatrix.Po@am__quote@
    338 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpSumMatrix.Po@am__quote@
    339 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpSumSymMatrix.Po@am__quote@
    340 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpSymMatrix.Po@am__quote@
    341 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpSymScaledMatrix.Po@am__quote@
    342314@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpTaggedObject.Po@am__quote@
    343 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpVector.Po@am__quote@
    344 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/IpZeroMatrix.Po@am__quote@
    345315
    346316.cpp.o:
     
    358328@am__fastdepCXX_FALSE@  $(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
    359329uninstall-info-am:
     330install-includeipoptHEADERS: $(includeipopt_HEADERS)
     331        @$(NORMAL_INSTALL)
     332        test -z "$(includeipoptdir)" || $(mkdir_p) "$(DESTDIR)$(includeipoptdir)"
     333        @list='$(includeipopt_HEADERS)'; for p in $$list; do \
     334          if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
     335          f=$(am__strip_dir) \
     336          echo " $(includeipoptHEADERS_INSTALL) '$$d$$p' '$(DESTDIR)$(includeipoptdir)/$$f'"; \
     337          $(includeipoptHEADERS_INSTALL) "$$d$$p" "$(DESTDIR)$(includeipoptdir)/$$f"; \
     338        done
     339
     340uninstall-includeipoptHEADERS:
     341        @$(NORMAL_UNINSTALL)
     342        @list='$(includeipopt_HEADERS)'; for p in $$list; do \
     343          f=$(am__strip_dir) \
     344          echo " rm -f '$(DESTDIR)$(includeipoptdir)/$$f'"; \
     345          rm -f "$(DESTDIR)$(includeipoptdir)/$$f"; \
     346        done
    360347
    361348ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
     
    436423check-am: all-am
    437424check: check-am
    438 all-am: Makefile $(LIBRARIES)
     425all-am: Makefile $(LIBRARIES) $(HEADERS)
    439426installdirs:
     427        for dir in "$(DESTDIR)$(includeipoptdir)"; do \
     428          test -z "$$dir" || $(mkdir_p) "$$dir"; \
     429        done
    440430install: install-am
    441431install-exec: install-exec-am
     
    483473info-am:
    484474
    485 install-data-am:
    486 
    487 install-exec-am:
     475install-data-am: install-includeipoptHEADERS
     476
     477install-exec-am: install-exec-local
    488478
    489479install-info: install-info-am
     
    510500ps-am:
    511501
    512 uninstall-am: uninstall-info-am
     502uninstall-am: uninstall-includeipoptHEADERS uninstall-info-am \
     503        uninstall-local
    513504
    514505.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
     
    516507        distclean-generic distclean-tags distdir dvi dvi-am html \
    517508        html-am info info-am install install-am install-data \
    518         install-data-am install-exec install-exec-am install-info \
     509        install-data-am install-exec install-exec-am \
     510        install-exec-local install-includeipoptHEADERS install-info \
    519511        install-info-am install-man install-strip installcheck \
    520512        installcheck-am installdirs maintainer-clean \
    521513        maintainer-clean-generic mostlyclean mostlyclean-compile \
    522514        mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
    523         uninstall-am uninstall-info-am
    524 
     515        uninstall-am uninstall-includeipoptHEADERS uninstall-info-am \
     516        uninstall-local
     517
     518
     519install-exec-local:
     520        echo "#ifndef __IPCONFIG__" >bla
     521        echo "#define __IPCONFIG__" >>bla
     522        cat ../inc/config.h >> bla
     523        echo "#endif" >>bla
     524        sed -s 's/#include "config.h"//' <$(srcdir)/IpTypes.hpp >> bla
     525        $(install_sh_DATA) bla $(includeipoptdir)/IpTypes.hpp
     526        rm bla
     527
     528uninstall-local:
     529        rm -f $(includeipoptdir)/IpTypes.hpp
    525530
    526531astyle: $(ASTYLE_FILES)
  • branches/dev/Examples/Cpp_example/Makefile.in

    r194 r430  
    1414
    1515# Directory with libipopt.a
     16IPOPTINCDIR = @includedir@/ipopt
    1617IPOPTLIBDIR = @libdir@
    1718exec_prefix = @exec_prefix@
     
    2526IPOPTSRCROOTDIR = $(SRCDIR)/../..
    2627IPOPTINSTALLROOTDIR = @prefix@
    27 INCL =  -I$(IPOPTSRCROOTDIR)/Interfaces \
    28         -I$(IPOPTSRCROOTDIR)/Apps/StdInterface \
    29         -I$(IPOPTSRCROOTDIR)/Common \
    30         -I$(IPOPTSRCROOTDIR)/Algorithm \
    31         -I$(IPOPTINSTALLROOTDIR)/inc
     28INCL =  -I$(IPOPTINCDIR)
    3229
    3330# CHANGEME: This should be the name of your executable
  • branches/dev/Examples/Cpp_example/MyNLP.hpp

    r419 r430  
    1111
    1212#include "IpTNLP.hpp"
    13 #include "IpUtils.hpp"
    1413
    1514using namespace Ipopt;
  • branches/dev/Extern/ASL/INSTALL.ASL

    • Property svn:executable deleted
  • branches/dev/Extern/ASL/Makefile.in

    r428 r430  
    3939POST_UNINSTALL = :
    4040build_triplet = @build@
    41 subdir = OTHERS/ASL
     41subdir = Extern/ASL
    4242DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
    4343ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
     
    7979BUILDHSL_FALSE = @BUILDHSL_FALSE@
    8080BUILDHSL_TRUE = @BUILDHSL_TRUE@
    81 BUILDLAPACKDIR_FALSE = @BUILDLAPACKDIR_FALSE@
    82 BUILDLAPACKDIR_TRUE = @BUILDLAPACKDIR_TRUE@
    83 BUILDLAPACK_FALSE = @BUILDLAPACK_FALSE@
    84 BUILDLAPACK_TRUE = @BUILDLAPACK_TRUE@
    8581BUILDMA27_FALSE = @BUILDMA27_FALSE@
    8682BUILDMA27_TRUE = @BUILDMA27_TRUE@
     
    195191          esac; \
    196192        done; \
    197         echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign  OTHERS/ASL/Makefile'; \
     193        echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign  Extern/ASL/Makefile'; \
    198194        cd $(top_srcdir) && \
    199           $(AUTOMAKE) --foreign  OTHERS/ASL/Makefile
     195          $(AUTOMAKE) --foreign  Extern/ASL/Makefile
    200196.PRECIOUS: Makefile
    201197Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
  • branches/dev/Extern/HSL/INSTALL.HSL

    • Property svn:executable deleted
  • branches/dev/Extern/HSL/Makefile.in

    r428 r430  
    4444@BUILDMA27_TRUE@am__append_1 = ma27ad.f
    4545@BUILDMC19_TRUE@am__append_2 = mc19ad.f
    46 subdir = OTHERS/HSL
     46subdir = Extern/HSL
    4747DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
    4848ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
     
    9898BUILDHSL_FALSE = @BUILDHSL_FALSE@
    9999BUILDHSL_TRUE = @BUILDHSL_TRUE@
    100 BUILDLAPACKDIR_FALSE = @BUILDLAPACKDIR_FALSE@
    101 BUILDLAPACKDIR_TRUE = @BUILDLAPACKDIR_TRUE@
    102 BUILDLAPACK_FALSE = @BUILDLAPACK_FALSE@
    103 BUILDLAPACK_TRUE = @BUILDLAPACK_TRUE@
    104100BUILDMA27_FALSE = @BUILDMA27_FALSE@
    105101BUILDMA27_TRUE = @BUILDMA27_TRUE@
     
    215211          esac; \
    216212        done; \
    217         echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign  OTHERS/HSL/Makefile'; \
     213        echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign  Extern/HSL/Makefile'; \
    218214        cd $(top_srcdir) && \
    219           $(AUTOMAKE) --foreign  OTHERS/HSL/Makefile
     215          $(AUTOMAKE) --foreign  Extern/HSL/Makefile
    220216.PRECIOUS: Makefile
    221217Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
  • branches/dev/Extern/Makefile.am

    r428 r430  
    1313endif
    1414
    15 if BUILDLAPACKDIR
    16   SUBDIRS += lapack
    17 endif
    18 
    1915if BUILDHSLDIR
    2016  SUBDIRS += HSL
  • branches/dev/Extern/Makefile.in

    r428 r430  
    4040build_triplet = @build@
    4141@BUILDBLASDIR_TRUE@am__append_1 = blas
    42 @BUILDLAPACKDIR_TRUE@am__append_2 = lapack
    43 @BUILDHSLDIR_TRUE@am__append_3 = HSL
    44 @BUILDASLDIR_TRUE@am__append_4 = ASL
    45 subdir = OTHERS
     42@BUILDHSLDIR_TRUE@am__append_2 = HSL
     43@BUILDASLDIR_TRUE@am__append_3 = ASL
     44subdir = Extern
    4645DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
    4746ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
     
    6261ETAGS = etags
    6362CTAGS = ctags
    64 DIST_SUBDIRS = blas lapack HSL ASL
     63DIST_SUBDIRS = blas HSL ASL
    6564DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
    6665ACLOCAL = @ACLOCAL@
     
    9291BUILDHSL_FALSE = @BUILDHSL_FALSE@
    9392BUILDHSL_TRUE = @BUILDHSL_TRUE@
    94 BUILDLAPACKDIR_FALSE = @BUILDLAPACKDIR_FALSE@
    95 BUILDLAPACKDIR_TRUE = @BUILDLAPACKDIR_TRUE@
    96 BUILDLAPACK_FALSE = @BUILDLAPACK_FALSE@
    97 BUILDLAPACK_TRUE = @BUILDLAPACK_TRUE@
    9893BUILDMA27_FALSE = @BUILDMA27_FALSE@
    9994BUILDMA27_TRUE = @BUILDMA27_TRUE@
     
    193188target_alias = @target_alias@
    194189AUTOMAKE_OPTIONS = foreign
    195 SUBDIRS = $(am__append_1) $(am__append_2) $(am__append_3) \
    196         $(am__append_4)
     190SUBDIRS = $(am__append_1) $(am__append_2) $(am__append_3)
    197191all: all-recursive
    198192
     
    207201          esac; \
    208202        done; \
    209         echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign  OTHERS/Makefile'; \
     203        echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign  Extern/Makefile'; \
    210204        cd $(top_srcdir) && \
    211           $(AUTOMAKE) --foreign  OTHERS/Makefile
     205          $(AUTOMAKE) --foreign  Extern/Makefile
    212206.PRECIOUS: Makefile
    213207Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
  • branches/dev/Extern/blas/INSTALL.BLAS

    • Property svn:executable deleted
  • branches/dev/Extern/blas/Makefile.in

    r428 r430  
    8080@BUILDBLAS_TRUE@        xerbla.f
    8181
    82 subdir = OTHERS/blas
     82subdir = Extern/blas
    8383DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
    8484ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
     
    148148BUILDHSL_FALSE = @BUILDHSL_FALSE@
    149149BUILDHSL_TRUE = @BUILDHSL_TRUE@
    150 BUILDLAPACKDIR_FALSE = @BUILDLAPACKDIR_FALSE@
    151 BUILDLAPACKDIR_TRUE = @BUILDLAPACKDIR_TRUE@
    152 BUILDLAPACK_FALSE = @BUILDLAPACK_FALSE@
    153 BUILDLAPACK_TRUE = @BUILDLAPACK_TRUE@
    154150BUILDMA27_FALSE = @BUILDMA27_FALSE@
    155151BUILDMA27_TRUE = @BUILDMA27_TRUE@
     
    265261          esac; \
    266262        done; \
    267         echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign  OTHERS/blas/Makefile'; \
     263        echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign  Extern/blas/Makefile'; \
    268264        cd $(top_srcdir) && \
    269           $(AUTOMAKE) --foreign  OTHERS/blas/Makefile
     265          $(AUTOMAKE) --foreign  Extern/blas/Makefile
    270266.PRECIOUS: Makefile
    271267Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
  • branches/dev/Interfaces/IpIpoptApplication.cpp

    r428 r430  
    1414#include "IpIpoptCalculatedQuantities.hpp"
    1515#include "IpAlgBuilder.hpp"
    16 #include "IpIpoptType.hpp"
    1716#include "IpUserScaling.hpp"
    1817#include "IpGradientScaling.hpp"
     
    2221  DBG_SET_VERBOSITY(0);
    2322
    24   DefineIpoptType(IpoptApplication);
     23  DefineOptionsRegistrar(IpoptApplication);
    2524
    2625  IpoptApplication::IpoptApplication(bool read_params_dat, bool create_console_out)
     
    4645    }
    4746
    48 
    4947    // Register the valid options
    5048    SmartPtr<RegisteredOptions> reg_options = new RegisteredOptions();
    51     IpoptTypeInfo::RegisterAllOptions(reg_options);
     49    OptionsRegistrar::RegisterAllOptions(reg_options);
    5250
    5351    options_->SetJournalist(jnlst_);
     
    276274                     "Overall NLP error.......: %24.16e  %24.16e\n\n", ip_cq->curr_nlp_error(), ip_cq->unscaled_curr_nlp_error());
    277275
    278       jnlst_->PrintVector(J_VECTOR, J_SOLUTION, "x", *ip_data->curr()->x());
    279       jnlst_->PrintVector(J_VECTOR, J_SOLUTION, "y_c", *ip_data->curr()->y_c());
    280       jnlst_->PrintVector(J_VECTOR, J_SOLUTION, "y_d", *ip_data->curr()->y_d());
    281       jnlst_->PrintVector(J_VECTOR, J_SOLUTION, "z_L", *ip_data->curr()->z_L());
    282       jnlst_->PrintVector(J_VECTOR, J_SOLUTION, "z_U", *ip_data->curr()->z_U());
    283       jnlst_->PrintVector(J_VECTOR, J_SOLUTION, "v_L", *ip_data->curr()->v_L());
    284       jnlst_->PrintVector(J_VECTOR, J_SOLUTION, "v_U", *ip_data->curr()->v_U());
    285 
     276      ip_data->curr()->x()->Print(*jnlst_, J_VECTOR, J_SOLUTION, "x");
     277      ip_data->curr()->y_c()->Print(*jnlst_, J_VECTOR, J_SOLUTION, "y_c");
     278      ip_data->curr()->y_d()->Print(*jnlst_, J_VECTOR, J_SOLUTION, "y_d");
     279      ip_data->curr()->z_L()->Print(*jnlst_, J_VECTOR, J_SOLUTION, "z_L");
     280      ip_data->curr()->z_U()->Print(*jnlst_, J_VECTOR, J_SOLUTION, "z_U");
     281      ip_data->curr()->v_L()->Print(*jnlst_, J_VECTOR, J_SOLUTION, "v_L");
     282      ip_data->curr()->v_U()->Print(*jnlst_, J_VECTOR, J_SOLUTION, "v_U");
    286283
    287284      jnlst_->Printf(J_SUMMARY, J_STATISTICS,
  • branches/dev/Interfaces/IpIpoptApplication.hpp

    r428 r430  
    1010#define __IPIPOPTAPPLICATION_HPP__
    1111
    12 #include "IpReferenced.hpp"
    13 #include "IpSmartPtr.hpp"
    1412#include "IpJournalist.hpp"
    15 #include "IpIpoptType.hpp"
    1613#include "IpTNLP.hpp"
    17 #include "IpNLP.hpp"
    18 #include "IpInterfaceTypes.hpp"
     14#include "IpRegOptions.hpp"
     15#include "IpOptionsList.hpp"
    1916
    2017namespace Ipopt
    2118{
     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  };
    2234
    23   DeclareIpoptType(IpoptApplication);
     35  DeclareOptionsRegistrar(IpoptApplication);
    2436
    2537  /* forward declarations */
    2638  class IpoptData;
    2739  class IpoptCalculatedQuantities;
     40  class NLP;
    2841
    2942  /** This is the main application class for making calls
     
    4255
    4356    /** Solve a problem that inherits from TNLP
    44      *   use this method when you want access to ip_data nad ip_cq after the solve
     57     *   use this method when you want access to ip_data and ip_cq after the solve
    4558     */
    4659    ApplicationReturnStatus OptimizeTNLP(const SmartPtr<TNLP>& nlp,
     
    5265
    5366    /** Solve a problem that inherits from NLP
    54      *   use this method when you want access to ip_data nad ip_cq after the solve
     67     *   use this method when you want access to ip_data and ip_cq after the solve
    5568     */
    5669    ApplicationReturnStatus OptimizeNLP(const SmartPtr<NLP>& nlp,
     
    7285      return options_;
    7386    }
    74     //@}
    75 
    76     /**@name Methods to set the options for the application */
    77     //@{
    7887    //@}
    7988
  • branches/dev/Interfaces/IpTNLPAdapter.cpp

    r428 r430  
    1414  DBG_SET_VERBOSITY(0);
    1515
    16   DefineIpoptType(TNLPAdapter);
     16  DefineOptionsRegistrar(TNLPAdapter);
    1717
    1818  TNLPAdapter::TNLPAdapter(const SmartPtr<TNLP> tnlp)
  • branches/dev/Interfaces/IpTNLPAdapter.hpp

    r428 r430  
    1616#include "IpGenTMatrix.hpp"
    1717#include "IpSymTMatrix.hpp"
    18 #include "IpIpoptType.hpp"
     18#include "IpRegOptions.hpp"
    1919namespace Ipopt
    2020{
    2121
    22   DeclareIpoptType(TNLPAdapter);
     22  DeclareOptionsRegistrar(TNLPAdapter);
    2323
    2424  /** This class Adapts the TNLP interface so it looks like an NLP interface.
  • branches/dev/LinAlg/IpCompoundMatrix.cpp

    r428 r430  
    361361  }
    362362
    363   void CompoundMatrix::PrintImpl(FILE* fp, std::string name, Index indent, std::string prefix) const
    364   {
    365     fprintf(fp, "\n");
    366     for (Index ind=0; ind<indent; ind++) {
    367       fprintf(fp, " ");
    368     }
    369     fprintf(fp, "%sCompoundMatrix \"%s\" with %d row and %d columns components:\n",
    370             prefix.c_str(), name.c_str(), NComps_Rows(), NComps_Cols());
     363  void CompoundMatrix::PrintImpl(const Journalist& jnlst,
     364                                 EJournalLevel level,
     365                                 EJournalCategory category,
     366                                 const std::string& name,
     367                                 Index indent,
     368                                 const std::string& prefix) const
     369  {
     370    jnlst.Printf(level, category, "\n");
     371    jnlst.PrintfIndented(level, category, indent,
     372                         "%sCompoundMatrix \"%s\" with %d row and %d columns components:\n",
     373                         prefix.c_str(), name.c_str(),
     374                         NComps_Rows(), NComps_Cols());
    371375    for (Index irow = 0; irow < NComps_Rows(); irow++ ) {
    372376      for (Index jcol = 0; jcol < NComps_Cols(); jcol++ ) {
    373         for (Index ind=0; ind<indent; ind++) {
    374           fprintf(fp, " ");
    375         }
    376         fprintf(fp, "%sComponent for row %d and column %d:\n", prefix.c_str(), irow, jcol);
     377        jnlst.PrintfIndented(level, category, indent,
     378                             "%sComponent for row %d and column %d:\n",
     379                             prefix.c_str(), irow, jcol);
    377380        if (ConstComp(irow, jcol)) {
     381          DBG_ASSERT(name.size()<200);
    378382          char buffer[256];
    379           sprintf(buffer, "%s[%d][%d]", name.c_str(), irow, jcol);
     383          sprintf(buffer, "%s[%2d][%2d]", name.c_str(), irow, jcol);
    380384          std::string term_name = buffer;
    381           ConstComp(irow, jcol)->Print(fp, term_name, indent+1, prefix);
     385          ConstComp(irow, jcol)->Print(&jnlst, level, category, term_name,
     386                                       indent+1, prefix);
    382387        }
    383388        else {
    384           for (Index ind=0; ind<indent; ind++) {
    385             fprintf(fp, " ");
    386           }
    387           fprintf(fp, "%sComponent has not been set.\n", prefix.c_str());
     389          jnlst.PrintfIndented(level, category, indent,
     390                               "%sComponent has not been set.\n",
     391                               prefix.c_str());
    388392        }
    389393      }
  • branches/dev/LinAlg/IpCompoundMatrix.hpp

    r428 r430  
    105105                                    const Vector& D, Vector& X) const;
    106106
    107     virtual void PrintImpl(FILE* fp, std::string name, Index indent, std::string prefix) const;
     107    virtual void PrintImpl(const Journalist& jnlst,
     108                           EJournalLevel level,
     109                           EJournalCategory category,
     110                           const std::string& name,
     111