source: branches/dev/Algorithm/IpOrigIterationOutput.cpp @ 567

Last change on this file since 567 was 567, checked in by andreasw, 15 years ago

adapted for Portland compilers

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 10.5 KB
Line 
1// Copyright (C) 2004, 2005 International Business Machines and others.
2// All Rights Reserved.
3// This code is published under the Common Public License.
4//
5// $Id: IpOrigIterationOutput.cpp 567 2005-11-01 23:27:11Z andreasw $
6//
7// Authors:  Carl Laird, Andreas Waechter              IBM    2004-09-23
8
9#include "IpOrigIterationOutput.hpp"
10
11#ifdef HAVE_CMATH
12# include <cmath>
13#else
14# ifdef HAVE_MATH_H
15#  include <math.h>
16# else
17#  error "don't have header file for math"
18# endif
19#endif
20
21namespace Ipopt
22{
23  OrigIterationOutput::OrigIterationOutput()
24  {}
25
26  OrigIterationOutput::~OrigIterationOutput()
27  {}
28
29  void
30  OrigIterationOutput::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
31  {
32    std::string prev_cat = roptions->RegisteringCategory();
33    roptions->SetRegisteringCategory("Output");
34    roptions->AddStringOption2(
35      "print_info_string",
36      "Enables printing of additional info string at end of iteration output.",
37      "no",
38      "no", "don't print string",
39      "yes", "print string at end of each iteration output",
40      "This string contains some insider information about the current iteration.");
41    roptions->SetRegisteringCategory(prev_cat);
42  }
43
44  bool OrigIterationOutput::InitializeImpl(const OptionsList& options,
45      const std::string& prefix)
46  {
47    options.GetBoolValue("print_info_string", print_info_string_, prefix);
48
49    return true;
50  }
51
52  void OrigIterationOutput::WriteOutput()
53  {
54    //////////////////////////////////////////////////////////////////////
55    //         First print the summary line for the iteration           //
56    //////////////////////////////////////////////////////////////////////
57
58    Index iter = IpData().iter_count();
59    std::string header =
60      "iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls\n";
61    Jnlst().Printf(J_DETAILED, J_MAIN,
62                   "\n\n**************************************************\n");
63    Jnlst().Printf(J_DETAILED, J_MAIN,
64                   "*** Summary of Iteration: %d:", IpData().iter_count());
65    Jnlst().Printf(J_DETAILED, J_MAIN,
66                   "\n**************************************************\n\n");
67    if (iter%10 == 0 && !IpData().info_skip_output()) {
68      // output the header
69      Jnlst().Printf(J_ITERSUMMARY, J_MAIN, header.c_str());
70    }
71    else {
72      Jnlst().Printf(J_DETAILED, J_MAIN, header.c_str());
73    }
74    Number inf_pr = IpCq().curr_primal_infeasibility(NORM_MAX);
75    Number inf_du = IpCq().curr_dual_infeasibility(NORM_MAX);
76    Number mu = IpData().curr_mu();
77    Number dnrm;
78    if (IsValid(IpData().delta()) && IsValid(IpData().delta()->x()) && IsValid(IpData().delta()->s())) {
79      dnrm = Max(IpData().delta()->x()->Amax(), IpData().delta()->s()->Amax());
80    }
81    else {
82      // This is the first iteration - no search direction has been
83      // computed yet.
84      dnrm = 0.;
85    }
86    Number unscaled_f = IpCq().unscaled_curr_f();
87
88    // Retrieve some information set in the different parts of the algorithm
89    char info_iter=' ';
90    Number alpha_primal = IpData().info_alpha_primal();
91    char alpha_primal_char = IpData().info_alpha_primal_char();
92    Number alpha_dual = IpData().info_alpha_dual();
93    Number regu_x = IpData().info_regu_x();
94    char regu_x_buf[8];
95    char dashes[]="   - ";
96    char *regu_x_ptr;
97    if (regu_x==.0) {
98      regu_x_ptr = dashes;
99    }
100    else {
101      sprintf(regu_x_buf, "%5.1f", log10(regu_x));
102      regu_x_ptr = regu_x_buf;
103    }
104    Index ls_count = IpData().info_ls_count();
105    const std::string info_string = IpData().info_string();
106
107    if (!IpData().info_skip_output()) {
108      Jnlst().Printf(J_ITERSUMMARY, J_MAIN,
109                     "%4d%c%14.7e %7.2e %7.2e %5.1f %7.2e %5s %7.2e %7.2e%c%3d",
110                     iter, info_iter, unscaled_f, inf_pr, inf_du, log10(mu), dnrm, regu_x_ptr,
111                     alpha_dual, alpha_primal, alpha_primal_char,
112                     ls_count);
113      if (print_info_string_) {
114        Jnlst().Printf(J_ITERSUMMARY, J_MAIN, " %s", info_string.c_str());
115      }
116      else {
117        Jnlst().Printf(J_DETAILED, J_MAIN, " %s", info_string.c_str());
118      }
119      Jnlst().Printf(J_ITERSUMMARY, J_MAIN, "\n");
120    }
121
122
123    //////////////////////////////////////////////////////////////////////
124    //           Now if desired more detail on the iterates             //
125    //////////////////////////////////////////////////////////////////////
126
127    if (Jnlst().ProduceOutput(J_DETAILED, J_MAIN)) {
128      Jnlst().Printf(J_DETAILED, J_MAIN,
129                     "\n**************************************************\n");
130      Jnlst().Printf(J_DETAILED, J_MAIN,
131                     "*** Beginning Iteration %d from the following point:",
132                     IpData().iter_count());
133      Jnlst().Printf(J_DETAILED, J_MAIN,
134                     "\n**************************************************\n\n");
135
136      Jnlst().Printf(J_DETAILED, J_MAIN,
137                     "Current barrier parameter mu = %21.16e\n", IpData().curr_mu());
138      Jnlst().Printf(J_DETAILED, J_MAIN,
139                     "Current fraction-to-the-boundary parameter tau = %21.16e\n\n",
140                     IpData().curr_tau());
141      Jnlst().Printf(J_DETAILED, J_MAIN,
142                     "||curr_x||_inf   = %.16e\n", IpData().curr()->x()->Amax());
143      Jnlst().Printf(J_DETAILED, J_MAIN,
144                     "||curr_s||_inf   = %.16e\n", IpData().curr()->s()->Amax());
145      Jnlst().Printf(J_DETAILED, J_MAIN,
146                     "||curr_y_c||_inf = %.16e\n", IpData().curr()->y_c()->Amax());
147      Jnlst().Printf(J_DETAILED, J_MAIN,
148                     "||curr_y_d||_inf = %.16e\n", IpData().curr()->y_d()->Amax());
149      Jnlst().Printf(J_DETAILED, J_MAIN,
150                     "||curr_z_L||_inf = %.16e\n", IpData().curr()->z_L()->Amax());
151      Jnlst().Printf(J_DETAILED, J_MAIN,
152                     "||curr_z_U||_inf = %.16e\n", IpData().curr()->z_U()->Amax());
153      Jnlst().Printf(J_DETAILED, J_MAIN,
154                     "||curr_v_L||_inf = %.16e\n", IpData().curr()->v_L()->Amax());
155      Jnlst().Printf(J_DETAILED, J_MAIN,
156                     "||curr_v_U||_inf = %.16e\n", IpData().curr()->v_U()->Amax());
157    }
158    if (Jnlst().ProduceOutput(J_MOREDETAILED, J_MAIN)) {
159      if (IsValid(IpData().delta())) {
160        Jnlst().Printf(J_MOREDETAILED, J_MAIN,
161                       "\n||delta_x||_inf   = %.16e\n", IpData().delta()->x()->Amax());
162        Jnlst().Printf(J_MOREDETAILED, J_MAIN,
163                       "||delta_s||_inf   = %.16e\n", IpData().delta()->s()->Amax());
164        Jnlst().Printf(J_MOREDETAILED, J_MAIN,
165                       "||delta_y_c||_inf = %.16e\n", IpData().delta()->y_c()->Amax());
166        Jnlst().Printf(J_MOREDETAILED, J_MAIN,
167                       "||delta_y_d||_inf = %.16e\n", IpData().delta()->y_d()->Amax());
168        Jnlst().Printf(J_MOREDETAILED, J_MAIN,
169                       "||delta_z_L||_inf = %.16e\n", IpData().delta()->z_L()->Amax());
170        Jnlst().Printf(J_MOREDETAILED, J_MAIN,
171                       "||delta_z_U||_inf = %.16e\n", IpData().delta()->z_U()->Amax());
172        Jnlst().Printf(J_MOREDETAILED, J_MAIN,
173                       "||delta_v_L||_inf = %.16e\n", IpData().delta()->v_L()->Amax());
174        Jnlst().Printf(J_MOREDETAILED, J_MAIN,
175                       "||delta_v_U||_inf = %.16e\n", IpData().delta()->v_U()->Amax());
176      }
177      else {
178        Jnlst().Printf(J_MOREDETAILED, J_MAIN,
179                       "\nNo search direction has been computed yet.\n");
180      }
181    }
182    if (Jnlst().ProduceOutput(J_VECTOR, J_MAIN)) {
183      IpData().curr()->x()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_x");
184      IpData().curr()->s()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_s");
185
186      IpData().curr()->y_c()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_y_c");
187      IpData().curr()->y_d()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_y_d");
188
189      IpCq().curr_slack_x_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_slack_x_L");
190      IpCq().curr_slack_x_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_slack_x_U");
191      IpData().curr()->z_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_z_L");
192      IpData().curr()->z_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_z_U");
193
194      IpCq().curr_slack_s_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_slack_s_L");
195      IpCq().curr_slack_s_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_slack_s_U");
196      IpData().curr()->v_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_v_L");
197      IpData().curr()->v_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_v_U");
198    }
199    if (Jnlst().ProduceOutput(J_MOREVECTOR, J_MAIN)) {
200      IpCq().curr_grad_lag_x()->Print(Jnlst(), J_MOREVECTOR, J_MAIN, "curr_grad_lag_x");
201      IpCq().curr_grad_lag_s()->Print(Jnlst(), J_MOREVECTOR, J_MAIN, "curr_grad_lag_s");
202      if (IsValid(IpData().delta())) {
203        IpData().delta()->Print(Jnlst(), J_MOREVECTOR, J_MAIN, "delta");
204      }
205    }
206
207    if (Jnlst().ProduceOutput(J_DETAILED, J_MAIN)) {
208      Jnlst().Printf(J_DETAILED, J_MAIN,
209                     "\n\n***Current NLP Values for Iteration %d:\n",
210                     IpData().iter_count());
211      Jnlst().Printf(J_DETAILED, J_MAIN, "\n                                   (scaled)                 (unscaled)\n");
212      Jnlst().Printf(J_DETAILED, J_MAIN, "Objective...............: %24.16e  %24.16e\n", IpCq().curr_f(), IpCq().unscaled_curr_f());
213      Jnlst().Printf(J_DETAILED, J_MAIN, "Dual infeasibility......: %24.16e  %24.16e\n", IpCq().curr_dual_infeasibility(NORM_MAX), IpCq().unscaled_curr_dual_infeasibility(NORM_MAX));
214      Jnlst().Printf(J_DETAILED, J_MAIN, "Constraint violation....: %24.16e  %24.16e\n", IpCq().curr_nlp_constraint_violation(NORM_MAX), IpCq().unscaled_curr_nlp_constraint_violation(NORM_MAX));
215      Jnlst().Printf(J_DETAILED, J_MAIN, "Complementarity.........: %24.16e  %24.16e\n", IpCq().curr_complementarity(0., NORM_MAX), IpCq().unscaled_curr_complementarity(0., NORM_MAX));
216      Jnlst().Printf(J_DETAILED, J_MAIN, "Overall NLP error.......: %24.16e  %24.16e\n\n", IpCq().curr_nlp_error(), IpCq().unscaled_curr_nlp_error());
217    }
218    if (Jnlst().ProduceOutput(J_VECTOR, J_MAIN)) {
219      IpCq().curr_grad_f()->Print(Jnlst(), J_VECTOR, J_MAIN, "grad_f");
220      IpCq().curr_c()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_c");
221      IpCq().curr_d()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_d");
222      IpCq().curr_d_minus_s()->Print(Jnlst(), J_VECTOR, J_MAIN,
223                                     "curr_d - curr_s");
224    }
225
226    if (Jnlst().ProduceOutput(J_MATRIX, J_MAIN)) {
227      IpCq().curr_jac_c()->Print(Jnlst(), J_MATRIX, J_MAIN, "jac_c");
228      IpCq().curr_jac_d()->Print(Jnlst(), J_MATRIX, J_MAIN, "jac_d");
229      IpCq().curr_exact_hessian()->Print(Jnlst(), J_MATRIX, J_MAIN, "h");
230    }
231
232    Jnlst().Printf(J_DETAILED, J_MAIN, "\n\n");
233
234  }
235
236} // namespace Ipopt
Note: See TracBrowser for help on using the repository browser.