ALPS MPS Codes
Reference documentation.
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
ss_optimize< Matrix, SymmGroup, Storage > Class Template Reference

#include <ss_optimize.hpp>

Inheritance diagram for ss_optimize< Matrix, SymmGroup, Storage >:
optimizer_base< Matrix, SymmGroup, Storage >

Public Types

typedef optimizer_base< Matrix,
SymmGroup, Storage > 
base
 

Public Member Functions

 ss_optimize (MPS< Matrix, SymmGroup > &mps_, MPO< Matrix, SymmGroup > const &mpo_, BaseParameters &parms_, boost::function< bool()> stop_callback_, int initial_site_=0)
 
int to_site (const int L, const int i) const
 
void sweep (int sweep, OptimizeDirection d=Both)
 
results_collector const & iteration_results () const
 

Protected Member Functions

void boundary_left_step (MPO< Matrix, SymmGroup > const &mpo, int site)
 
void boundary_right_step (MPO< Matrix, SymmGroup > const &mpo, int site)
 
void init_left_right (MPO< Matrix, SymmGroup > const &mpo, int site)
 
double get_cutoff (int sweep) const
 
std::size_t get_Mmax (int sweep) const
 

Protected Attributes

results_collector iteration_results_
 
MPS< Matrix, SymmGroup > & mps
 
MPO< Matrix, SymmGroup > const & mpo
 
BaseParametersparms
 
boost::function< bool()> stop_callback
 
std::vector< Boundary
< typename
storage::constrained< Matrix >
::type, SymmGroup > > 
left_
 
std::vector< Boundary
< typename
storage::constrained< Matrix >
::type, SymmGroup > > 
right_
 
unsigned int northo
 
std::vector< std::vector
< block_matrix< typename
storage::constrained< Matrix >
::type, SymmGroup > > > 
ortho_left_
 
std::vector< std::vector
< block_matrix< typename
storage::constrained< Matrix >
::type, SymmGroup > > > 
ortho_right_
 
std::vector< MPS< Matrix,
SymmGroup > > 
ortho_mps
 

Detailed Description

template<class Matrix, class SymmGroup, class Storage>
class ss_optimize< Matrix, SymmGroup, Storage >

Definition at line 35 of file ss_optimize.hpp.

Member Typedef Documentation

template<class Matrix , class SymmGroup , class Storage >
typedef optimizer_base<Matrix, SymmGroup, Storage> ss_optimize< Matrix, SymmGroup, Storage >::base

Definition at line 39 of file ss_optimize.hpp.

Constructor & Destructor Documentation

template<class Matrix , class SymmGroup , class Storage >
ss_optimize< Matrix, SymmGroup, Storage >::ss_optimize ( MPS< Matrix, SymmGroup > &  mps_,
MPO< Matrix, SymmGroup > const &  mpo_,
BaseParameters parms_,
boost::function< bool()>  stop_callback_,
int  initial_site_ = 0 
)
inline

Definition at line 48 of file ss_optimize.hpp.

53  : base(mps_, mpo_, parms_, stop_callback_, to_site(mps_.length(), initial_site_))
54  , initial_site((initial_site_ < 0) ? 0 : initial_site_)
55  { }
optimizer_base< Matrix, SymmGroup, Storage > base
Definition: ss_optimize.hpp:39
size_t length() const
Definition: mps.h:58
int to_site(const int L, const int i) const
Definition: ss_optimize.hpp:57

Member Function Documentation

template<class Matrix , class SymmGroup , class Storage >
void optimizer_base< Matrix, SymmGroup, Storage >::boundary_left_step ( MPO< Matrix, SymmGroup > const &  mpo,
int  site 
)
inlineprotectedinherited

Definition at line 135 of file optimize.h.

136  {
137  left_[site+1] = contraction::overlap_mpo_left_step(mps[site], mps[site], left_[site], mpo[site]);
138  Storage::pin(left_[site+1]);
139 
140  for (int n = 0; n < northo; ++n)
141  ortho_left_[n][site+1] = contraction::overlap_left_step(mps[site], ortho_mps[n][site], ortho_left_[n][site]);
142  }
std::vector< Boundary< typename storage::constrained< Matrix >::type, SymmGroup > > left_
Definition: optimize.h:235
std::vector< std::vector< block_matrix< typename storage::constrained< Matrix >::type, SymmGroup > > > ortho_left_
Definition: optimize.h:239
static block_matrix< OtherMatrix, SymmGroup > overlap_left_step(MPSTensor< Matrix, SymmGroup > const &bra_tensor, MPSTensor< Matrix, SymmGroup > const &ket_tensor, block_matrix< OtherMatrix, SymmGroup > const &left, block_matrix< OtherMatrix, SymmGroup > *localop=NULL)
Definition: contractions.h:41
MPS< Matrix, SymmGroup > & mps
Definition: optimize.h:229
static Boundary< OtherMatrix, SymmGroup > overlap_mpo_left_step(MPSTensor< Matrix, SymmGroup > const &bra_tensor, MPSTensor< Matrix, SymmGroup > const &ket_tensor, Boundary< OtherMatrix, SymmGroup > const &left, MPOTensor< Matrix, SymmGroup > const &mpo)
Definition: contractions.h:340
unsigned int northo
Definition: optimize.h:238
std::vector< MPS< Matrix, SymmGroup > > ortho_mps
Definition: optimize.h:240
template<class Matrix , class SymmGroup , class Storage >
void optimizer_base< Matrix, SymmGroup, Storage >::boundary_right_step ( MPO< Matrix, SymmGroup > const &  mpo,
int  site 
)
inlineprotectedinherited

Definition at line 144 of file optimize.h.

145  {
146  right_[site] = contraction::overlap_mpo_right_step(mps[site], mps[site], right_[site+1], mpo[site]);
147  Storage::pin(right_[site]);
148 
149  for (int n = 0; n < northo; ++n)
150  ortho_right_[n][site] = contraction::overlap_right_step(mps[site], ortho_mps[n][site], ortho_right_[n][site+1]);
151  }
static block_matrix< OtherMatrix, SymmGroup > overlap_right_step(MPSTensor< Matrix, SymmGroup > const &bra_tensor, MPSTensor< Matrix, SymmGroup > const &ket_tensor, block_matrix< OtherMatrix, SymmGroup > const &right, block_matrix< OtherMatrix, SymmGroup > *localop=NULL)
Definition: contractions.h:71
static Boundary< OtherMatrix, SymmGroup > overlap_mpo_right_step(MPSTensor< Matrix, SymmGroup > const &bra_tensor, MPSTensor< Matrix, SymmGroup > const &ket_tensor, Boundary< OtherMatrix, SymmGroup > const &right, MPOTensor< Matrix, SymmGroup > const &mpo)
Definition: contractions.h:386
std::vector< std::vector< block_matrix< typename storage::constrained< Matrix >::type, SymmGroup > > > ortho_right_
Definition: optimize.h:239
MPS< Matrix, SymmGroup > & mps
Definition: optimize.h:229
unsigned int northo
Definition: optimize.h:238
std::vector< Boundary< typename storage::constrained< Matrix >::type, SymmGroup > > right_
Definition: optimize.h:235
std::vector< MPS< Matrix, SymmGroup > > ortho_mps
Definition: optimize.h:240
template<class Matrix , class SymmGroup , class Storage >
double optimizer_base< Matrix, SymmGroup, Storage >::get_cutoff ( int  sweep) const
inlineprotectedinherited

Definition at line 202 of file optimize.h.

203  {
204  double cutoff;
205  if (sweep >= parms.template get<int>("ngrowsweeps"))
206  cutoff = parms.template get<double>("truncation_final");
207  else
208  cutoff = log_interpolate(parms.template get<double>("truncation_initial"), parms.template get<double>("truncation_final"), parms.template get<int>("ngrowsweeps"), sweep);
209  return cutoff;
210  }
BaseParameters & parms
Definition: optimize.h:232
virtual void sweep(int sweep, OptimizeDirection d=Both)=0
double log_interpolate(double y0, double y1, int N, int i)
Definition: optimize.h:74
template<class Matrix , class SymmGroup , class Storage >
std::size_t optimizer_base< Matrix, SymmGroup, Storage >::get_Mmax ( int  sweep) const
inlineprotectedinherited

Definition at line 212 of file optimize.h.

213  {
214  std::size_t Mmax;
215  if (parms.is_set("sweep_bond_dimensions")) {
216  std::vector<std::size_t> ssizes = parms.template get<std::vector<std::size_t> >("sweep_bond_dimensions");
217  if (sweep >= ssizes.size())
218  Mmax = *ssizes.rbegin();
219  else
220  Mmax = ssizes[sweep];
221  } else
222  Mmax = parms.template get<std::size_t>("max_bond_dimension");
223  return Mmax;
224  }
BaseParameters & parms
Definition: optimize.h:232
bool is_set(std::string const &key) const
virtual void sweep(int sweep, OptimizeDirection d=Both)=0
template<class Matrix , class SymmGroup , class Storage >
void optimizer_base< Matrix, SymmGroup, Storage >::init_left_right ( MPO< Matrix, SymmGroup > const &  mpo,
int  site 
)
inlineprotectedinherited

Definition at line 153 of file optimize.h.

154  {
156  std::size_t L = mps.length();
157 
158  left_.resize(mpo.length()+1);
159  right_.resize(mpo.length()+1);
160 
161  ortho_left_.resize(northo);
162  ortho_right_.resize(northo);
163  for (int n = 0; n < northo; ++n) {
164  ortho_left_[n].resize(L+1);
165  ortho_right_[n].resize(L+1);
166 
167  ortho_left_[n][0] = mps.left_boundary()[0];
168  ortho_right_[n][L] = mps.right_boundary()[0];
169  }
170 
171  //Timer tlb("Init left boundaries"); tlb.begin();
172  Storage::drop(left_[0]);
173  left_[0] = mps.left_boundary();
174  Storage::pin(left_[0]);
175 
176  for (int i = 0; i < site; ++i) {
177  Storage::drop(left_[i+1]);
178  boundary_left_step(mpo, i);
179  Storage::evict(left_[i]);
180  }
181  Storage::evict(left_[site]);
182  //tlb.end();
183 
184  maquis::cout << "Boundaries are partially initialized...\n";
185 
186  //Timer trb("Init right boundaries"); trb.begin();
187  Storage::drop(right_[L]);
188  right_[L] = mps.right_boundary();
189  Storage::pin(right_[L]);
190 
191  for (int i = L-1; i >= site; --i) {
192  Storage::drop(right_[i]);
193  boundary_right_step(mpo, i);
194  Storage::evict(right_[i+1]);
195  }
196  Storage::evict(right_[site]);
197  //trb.end();
198 
199  maquis::cout << "Boundaries are fully initialized...\n";
200  }
std::vector< std::vector< int > > construct_placements(const MPO< Matrix, SymmGroup > &mpo)
Definition: placement.h:101
std::vector< Boundary< typename storage::constrained< Matrix >::type, SymmGroup > > left_
Definition: optimize.h:235
std::vector< std::vector< block_matrix< typename storage::constrained< Matrix >::type, SymmGroup > > > ortho_left_
Definition: optimize.h:239
std::vector< std::vector< block_matrix< typename storage::constrained< Matrix >::type, SymmGroup > > > ortho_right_
Definition: optimize.h:239
MPS< Matrix, SymmGroup > & mps
Definition: optimize.h:229
unsigned int northo
Definition: optimize.h:238
std::vector< Boundary< typename storage::constrained< Matrix >::type, SymmGroup > > right_
Definition: optimize.h:235
void boundary_right_step(MPO< Matrix, SymmGroup > const &mpo, int site)
Definition: optimize.h:144
void boundary_left_step(MPO< Matrix, SymmGroup > const &mpo, int site)
Definition: optimize.h:135
template<class Matrix , class SymmGroup , class Storage >
results_collector const& optimizer_base< Matrix, SymmGroup, Storage >::iteration_results ( ) const
inlineinherited

Definition at line 131 of file optimize.h.

131 { return iteration_results_; }
results_collector iteration_results_
Definition: optimize.h:227
template<class Matrix , class SymmGroup , class Storage >
void ss_optimize< Matrix, SymmGroup, Storage >::sweep ( int  sweep,
OptimizeDirection  d = Both 
)
inlinevirtual

Implements optimizer_base< Matrix, SymmGroup, Storage >.

Definition at line 64 of file ss_optimize.hpp.

65  {
66  boost::chrono::high_resolution_clock::time_point sweep_now = boost::chrono::high_resolution_clock::now();
67 
69 
70  std::size_t L = mps.length();
71 
72  int _site = 0, site = 0;
73  if (initial_site != -1) {
74  _site = initial_site;
75  site = to_site(L, _site);
76  }
77 
78 // if (parms["beta_mode"] && sweep == 0 && resume_at < L) {
79 // int site = (resume_at == -1) ? 0 : resume_at;
80 // mpo = zero_after(mpo_orig, site+2);
81 // mps.canonize(site);
82 // this->init_left_right(mpo, site);
83 // }
84 
85  Storage::prefetch(left_[site]);
86  Storage::prefetch(right_[site+1]);
87 
88 #ifndef NDEBUG
89  maquis::cout << mps.description() << std::endl;
90 #endif
91  for (; _site < 2*L; ++_site) {
92 
93  int lr = (_site < L) ? +1 : -1;
94  site = to_site(L, _site);
95 
96  if (lr == -1 && site == L-1) {
97  maquis::cout << "Syncing storage" << std::endl;
98  Storage::sync();
99  }
100 
101  maquis::cout << "Sweep " << sweep << ", optimizing site " << site << std::endl;
102 
103 // mps[site].make_left_paired();
104 
105  // MD: some changes needed to re-enable it.
106 // if (parms.["beta_mode"]) {
107 // if (sweep == 0 && lr == 1) {
108 // mpo = zero_after(mpo_orig, 0);
109 // if (site == 0)
110 // this->init_left_right(mpo, 0);
111 // } else if (sweep == 0 && lr == -1 && site == L-1) {
112 // mpo = mpo_orig;
113 // //this->init_left_right(mpo, site);
114 // }
115 // }
116 
117 
118  Storage::fetch(left_[site]);
119  Storage::fetch(right_[site+1]);
120 
121  if (lr == +1) Storage::prefetch(left_[site+1]);
122  else Storage::prefetch(right_[site]);
123 
124  assert( left_[site].reasonable() ); // in case something went wrong
125  assert( right_[site+1].reasonable() ); // in case something went wrong
126 
127 
128 // maquis::cout << "My size: " << std::endl;
129 // maquis::cout << " left_: " << utils::size_of(left_.begin(), left_.end())/1024.0/1024 << std::endl;
130 // maquis::cout << " right_: " << utils::size_of(right_.begin(), right_.end())/1024.0/1024 << std::endl;
131 // maquis::cout << " MPS: " << utils::size_of(mps.begin(), mps.end())/1024.0/1024 << std::endl;
132 // maquis::cout << " MPS[i]: " << utils::size_of(mps[site])/1024.0/1024 << std::endl;
133 
134  //SiteProblem<Matrix, SymmGroup> sp(mps[site], left_[site], right_[site+1], mpo[site]);
135 
136  boost::chrono::high_resolution_clock::time_point now, then;
137 
138  std::pair<double, MPSTensor<Matrix, SymmGroup> > res;
139  SiteProblem<Matrix, SymmGroup> sp(left_[site], right_[site+1], mpo[site]);
140 
141  /// Compute orthogonal vectors
142  std::vector<MPSTensor<Matrix, SymmGroup> > ortho_vecs(base::northo);
143  for (int n = 0; n < base::northo; ++n) {
144  ortho_vecs[n] = contraction::site_ortho_boundaries(mps[site], base::ortho_mps[n][site],
145  base::ortho_left_[n][site], base::ortho_right_[n][site+1]);
146  }
147 
148  if (d == Both ||
149  (d == LeftOnly && lr == -1) ||
150  (d == RightOnly && lr == +1))
151  {
152  if (parms["eigensolver"] == std::string("IETL")) {
153  BEGIN_TIMING("IETL")
154  res = solve_ietl_lanczos(sp, mps[site], parms);
155  END_TIMING("IETL")
156  } else if (parms["eigensolver"] == std::string("IETL_JCD")) {
157  BEGIN_TIMING("JCD")
158  res = solve_ietl_jcd(sp, mps[site], parms, ortho_vecs);
159  END_TIMING("JCD")
160  } else {
161  throw std::runtime_error("I don't know this eigensolver.");
162  }
163 
164  mps[site] = res.second;
165  }
166 
167 #ifndef NDEBUG
168  // Caution: this is an O(L) operation, so it really should be done only in debug mode
169  for (int n = 0; n < base::northo; ++n)
170  maquis::cout << "MPS overlap: " << overlap(mps, base::ortho_mps[n]) << std::endl;
171 #endif
172 
173  maquis::cout << "Energy " << lr << " " << res.first << std::endl;
174 // maquis::cout << "Energy check " << maquis::real(expval(mps, mpo)) << std::endl;
175 
176  iteration_results_["Energy"] << res.first;
177 
178  double alpha;
179  int ngs = parms.template get<int>("ngrowsweeps"), nms = parms.template get<int>("nmainsweeps");
180  if (sweep < ngs)
181  alpha = parms.template get<double>("alpha_initial");
182  else if (sweep < ngs + nms)
183  alpha = parms.template get<double>("alpha_main");
184  else
185  alpha = parms.template get<double>("alpha_final");
186 
187  double cutoff = this->get_cutoff(sweep);
188  std::size_t Mmax = this->get_Mmax(sweep);
189  truncation_results trunc;
190 
191  if (lr == +1) {
192  if (site < L-1) {
193  maquis::cout << "Growing, alpha = " << alpha << std::endl;
194  trunc = mps.grow_l2r_sweep(mpo[site], left_[site], right_[site+1],
195  site, alpha, cutoff, Mmax);
196  } else {
197  block_matrix<Matrix, SymmGroup> t = mps[site].normalize_left(DefaultSolver());
198  if (site < L-1)
199  mps[site+1].multiply_from_left(t);
200  }
201 
202 
203  Storage::drop(left_[site+1]); // left_[site+1] is outdated
204  this->boundary_left_step(mpo, site); // creating left_[site+1]
205  } else if (lr == -1) {
206  if (site > 0) {
207  maquis::cout << "Growing, alpha = " << alpha << std::endl;
208  // Invalid read occurs after this!\n
209  trunc = mps.grow_r2l_sweep(mpo[site], left_[site], right_[site+1],
210  site, alpha, cutoff, Mmax);
211  } else {
212  block_matrix<Matrix, SymmGroup> t = mps[site].normalize_right(DefaultSolver());
213  if (site > 0)
214  mps[site-1].multiply_from_right(t);
215  }
216 
217 
218  Storage::drop(right_[site]); // right_[site] is outdated
219  this->boundary_right_step(mpo, site); // creating right_[site]
220  }
221 
222  Storage::evict(left_[site]); // move to out of core currently used boundary
223  Storage::evict(right_[site+1]); // move to out of core currently used boundary
224 
225  iteration_results_["BondDimension"] << trunc.bond_dimension;
226  iteration_results_["TruncatedWeight"] << trunc.truncated_weight;
227  iteration_results_["SmallestEV"] << trunc.smallest_ev;
228 
229  boost::chrono::high_resolution_clock::time_point sweep_then = boost::chrono::high_resolution_clock::now();
230  double elapsed = boost::chrono::duration<double>(sweep_then - sweep_now).count();
231  maquis::cout << "Sweep has been running for " << elapsed << " seconds." << std::endl;
232 
233  if (stop_callback())
234  throw dmrg::time_limit(sweep, _site+1);
235  }
236  initial_site = -1;
237  }
std::size_t get_Mmax(int sweep) const
Definition: optimize.h:212
BaseParameters & parms
Definition: optimize.h:232
std::pair< double, MPSTensor< Matrix, SymmGroup > > solve_ietl_lanczos(SiteProblem< Matrix, SymmGroup > &sp, MPSTensor< Matrix, SymmGroup > const &initial, BaseParameters &params)
std::vector< Boundary< typename storage::constrained< Matrix >::type, SymmGroup > > left_
Definition: optimize.h:235
Definition: optimize.h:84
static MPSTensor< Matrix, SymmGroup > site_ortho_boundaries(MPSTensor< Matrix, SymmGroup > const &mps, MPSTensor< Matrix, SymmGroup > const &ortho_mps, block_matrix< OtherMatrix, SymmGroup > const &ortho_left, block_matrix< OtherMatrix, SymmGroup > const &ortho_right)
Definition: contractions.h:479
std::vector< std::vector< block_matrix< typename storage::constrained< Matrix >::type, SymmGroup > > > ortho_left_
Definition: optimize.h:239
results_collector iteration_results_
Definition: optimize.h:227
MPS< Matrix, SymmGroup >::scalar_type overlap(MPS< Matrix, SymmGroup > const &mps1, MPS< Matrix, SymmGroup > const &mps2)
Definition: mps_mpo_ops.h:136
void sweep(int sweep, OptimizeDirection d=Both)
Definition: ss_optimize.hpp:64
std::vector< std::vector< block_matrix< typename storage::constrained< Matrix >::type, SymmGroup > > > ortho_right_
Definition: optimize.h:239
std::pair< double, MPSTensor< Matrix, SymmGroup > > solve_ietl_jcd(SiteProblem< Matrix, SymmGroup > &sp, MPSTensor< Matrix, SymmGroup > const &initial, BaseParameters &params, std::vector< MPSTensor< Matrix, SymmGroup > > ortho_vecs=std::vector< MPSTensor< Matrix, SymmGroup > >())
boost::function< bool()> stop_callback
Definition: optimize.h:233
MPO< Matrix, SymmGroup > const & mpo
Definition: optimize.h:230
MPS< Matrix, SymmGroup > & mps
Definition: optimize.h:229
double get_cutoff(int sweep) const
Definition: optimize.h:202
unsigned int northo
Definition: optimize.h:238
int to_site(const int L, const int i) const
Definition: ss_optimize.hpp:57
#define BEGIN_TIMING(name)
#define END_TIMING(name)
std::vector< Boundary< typename storage::constrained< Matrix >::type, SymmGroup > > right_
Definition: optimize.h:235
void boundary_right_step(MPO< Matrix, SymmGroup > const &mpo, int site)
Definition: optimize.h:144
std::vector< MPS< Matrix, SymmGroup > > ortho_mps
Definition: optimize.h:240
void boundary_left_step(MPO< Matrix, SymmGroup > const &mpo, int site)
Definition: optimize.h:135
template<class Matrix , class SymmGroup , class Storage >
int ss_optimize< Matrix, SymmGroup, Storage >::to_site ( const int  L,
const int  i 
) const
inline

Definition at line 57 of file ss_optimize.hpp.

58  {
59  if (i < 0) return 0;
60  /// i, or (L-1) - (i - L)
61  return (i < L) ? i : 2*L - 1 - i;
62  }

Member Data Documentation

template<class Matrix , class SymmGroup , class Storage >
results_collector optimizer_base< Matrix, SymmGroup, Storage >::iteration_results_
protectedinherited

Definition at line 227 of file optimize.h.

template<class Matrix , class SymmGroup , class Storage >
std::vector<Boundary<typename storage::constrained<Matrix>::type, SymmGroup> > optimizer_base< Matrix, SymmGroup, Storage >::left_
protectedinherited

Definition at line 235 of file optimize.h.

template<class Matrix , class SymmGroup , class Storage >
MPO<Matrix, SymmGroup> const& optimizer_base< Matrix, SymmGroup, Storage >::mpo
protectedinherited

Definition at line 230 of file optimize.h.

template<class Matrix , class SymmGroup , class Storage >
MPS<Matrix, SymmGroup>& optimizer_base< Matrix, SymmGroup, Storage >::mps
protectedinherited

Definition at line 229 of file optimize.h.

template<class Matrix , class SymmGroup , class Storage >
unsigned int optimizer_base< Matrix, SymmGroup, Storage >::northo
protectedinherited

Definition at line 238 of file optimize.h.

template<class Matrix , class SymmGroup , class Storage >
std::vector< std::vector<block_matrix<typename storage::constrained<Matrix>::type, SymmGroup> > > optimizer_base< Matrix, SymmGroup, Storage >::ortho_left_
protectedinherited

Definition at line 239 of file optimize.h.

template<class Matrix , class SymmGroup , class Storage >
std::vector<MPS<Matrix, SymmGroup> > optimizer_base< Matrix, SymmGroup, Storage >::ortho_mps
protectedinherited

Definition at line 240 of file optimize.h.

template<class Matrix , class SymmGroup , class Storage >
std::vector< std::vector<block_matrix<typename storage::constrained<Matrix>::type, SymmGroup> > > optimizer_base< Matrix, SymmGroup, Storage >::ortho_right_
protectedinherited

Definition at line 239 of file optimize.h.

template<class Matrix , class SymmGroup , class Storage >
BaseParameters& optimizer_base< Matrix, SymmGroup, Storage >::parms
protectedinherited

Definition at line 232 of file optimize.h.

template<class Matrix , class SymmGroup , class Storage >
std::vector<Boundary<typename storage::constrained<Matrix>::type, SymmGroup> > optimizer_base< Matrix, SymmGroup, Storage >::right_
protectedinherited

Definition at line 235 of file optimize.h.

template<class Matrix , class SymmGroup , class Storage >
boost::function<bool ()> optimizer_base< Matrix, SymmGroup, Storage >::stop_callback
protectedinherited

Definition at line 233 of file optimize.h.


The documentation for this class was generated from the following file: