ALPS MPS Codes
Reference documentation.
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
alps_detail.hpp
Go to the documentation of this file.
1 /*****************************************************************************
2  *
3  * ALPS MPS DMRG Project
4  *
5  * Copyright (C) 2013 Institute for Theoretical Physics, ETH Zurich
6  * 2011-2012 by Bela Bauer <bauerb@phys.ethz.ch>
7  * Michele Dolfi <dolfim@phys.ethz.ch>
8  * Timothee Ewart <timothee.ewart@gmail.com>
9  * Alexandr Kosenkov <alex.kosenkov@gmail.com>
10  *
11  * This software is part of the ALPS Applications, published under the ALPS
12  * Application License; you can use, redistribute it and/or modify it under
13  * the terms of the license, either version 1 or (at your option) any later
14  * version.
15  *
16  * You should have received a copy of the ALPS Application License along with
17  * the ALPS Applications; see the file LICENSE.txt. If not, the license is also
18  * available from http://alps.comp-phys.org/.
19  *
20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22  * FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
23  * SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
24  * FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
25  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
26  * DEALINGS IN THE SOFTWARE.
27  *
28  *****************************************************************************/
29 
30 #ifndef MAQUIS_BLOCK_MATRIX_DEATAIL_ALPS_MATRIX_DETAIL_HPP
31 #define MAQUIS_BLOCK_MATRIX_DEATAIL_ALPS_MATRIX_DETAIL_HPP
32 
33 template<class T, class SymmGroup>
34 class block_matrix;
35 
36 namespace maquis { namespace dmrg { namespace detail {
37 
38  template<class InputIterator, class OutputIterator, class T>
39  void iterator_axpy(InputIterator in1, InputIterator in2,
40  OutputIterator out1, T val)
41  {
42  std::transform(in1, in2, out1, out1, boost::lambda::_1*val+boost::lambda::_2);
43  }
44 
45  inline void iterator_axpy(double const * in1, double const * in2,
46  double * out1, double val)
47  {
48  fortran_int_t one = 1, diff = in2-in1;
49 #if defined(BIND_FORTRAN_LOWERCASE) || defined(__xlC__)
50  daxpy(&diff, &val, in1, &one, out1, &one);
51 #else
52  daxpy_(&diff, &val, in1, &one, out1, &one);
53 #endif
54  }
55 
56  inline void iterator_axpy(std::complex<double> const * in1, std::complex<double> const * in2,
57  std::complex<double> * out1, double val)
58  {
59  throw std::runtime_error("Not implemented.");
60  }
61 
62  //template <typename T, class A>
63  //void op_kron(alps::numeric::matrix<T,A>& out, const alps::numeric::matrix<T,A>& in, const alps::numeric::matrix<T,A>& alfa,
64  template <class Matrix1, class Matrix2>
65  void op_kron(Matrix2& out, const Matrix1& in, const Matrix1& alfa,
66  size_t out_y_offset, size_t out_x_offset,
67  size_t ldim1, size_t ldim2,
68  size_t rdim1, size_t rdim2)
69  {
70  for(int l1 = 0; l1 < ldim1; ++l1)
71  for(int r1 = 0; r1 < rdim1; ++r1)
72  for(int l2 = 0; l2 < ldim2; ++l2)
73  for(int r2 = 0; r2 < rdim2; ++r2)
74  out(out_y_offset + l1*ldim2 + l2, out_x_offset + r1*rdim2 + r2) =
75  in(l2, r2)*alfa(l1, r1);
76  }
77 
78  template <typename T, class A>
80  size_t in_left_offset, size_t in_phys_offset,
81  size_t out_left_offset, size_t out_right_offset,
82  size_t sdim1, size_t sdim2, size_t ldim, size_t rdim)
83  {
84  for(size_t ss1 = 0; ss1 < sdim1; ++ss1)
85  for(size_t ss2 = 0; ss2 < sdim2; ++ss2)
86  {
87  size_t ss_out = in_phys_offset + ss1*sdim2 + ss2;
88  for(size_t rr = 0; rr < rdim; ++rr)
89  for(size_t ll = 0; ll < ldim; ++ll)
90  out(out_left_offset + ss1*ldim + ll, out_right_offset + ss2*rdim + rr) =
91  in(in_left_offset + ss_out*ldim + ll, rr);
92  }
93  }
94 
95  template <typename T, class A>
97  size_t in_left_offset, size_t in_right_offset,
98  size_t out_left_offset, size_t out_phys_offset,
99  size_t sdim1, size_t sdim2, size_t ldim, size_t rdim)
100  {
101  for(size_t ss1 = 0; ss1 < sdim1; ++ss1)
102  for(size_t ss2 = 0; ss2 < sdim2; ++ss2)
103  {
104  size_t ss_out = out_phys_offset + ss1*sdim2 + ss2;
105  for(size_t rr = 0; rr < rdim; ++rr)
106  for(size_t ll = 0; ll < ldim; ++ll)
107  out(out_left_offset + ss_out*ldim + ll, rr) =
108  in(in_left_offset + ss1*ldim+ll, in_right_offset + ss2*rdim+rr);
109  }
110  }
111 
112  template <typename T, class A1, class A2>
114  size_t left_offset, size_t right_offset,
115  size_t sdim, size_t ldim, size_t rdim)
116  {
117  for (size_t ss = 0; ss < sdim; ++ss)
118  for (size_t rr = 0; rr < rdim; ++rr)
119  for(size_t ll = 0; ll < ldim; ++ll)
120  left(left_offset + ss*ldim+ll, rr) =
121  right(ll, right_offset + ss*rdim+rr);
122  // memcpy(&left(left_offset + ss*ldim, rr),
123  // &right(0, right_offset + ss*rdim+rr),
124  // sizeof(T) * ldim);
125  }
126 
127  template <typename T, class A1, class A2>
129  size_t left_offset, size_t right_offset,
130  size_t sdim, size_t ldim, size_t rdim)
131  {
132  for (size_t ss = 0; ss < sdim; ++ss)
133  for (size_t rr = 0; rr < rdim; ++rr)
134  for (size_t ll = 0; ll < ldim; ++ll)
135  right(ll, right_offset + ss*rdim+rr) = left(left_offset + ss*ldim+ll, rr);
136  }
137 
138  template <typename T1, class A1,
139  typename T2, class A2,
140  typename T3, class A3>
142  size_t out_offset, size_t in_offset,
143  size_t sdim1, size_t sdim2, size_t ldim, size_t rdim, T2 alfa_scale)
144  {
145  for(size_t rr = 0; rr < rdim; ++rr) {
146  for(size_t ss1 = 0; ss1 < sdim1; ++ss1) {
147  for(size_t ss2 = 0; ss2 < sdim2; ++ss2) {
148  T3 alfa_t = alfa(ss1, ss2) * alfa_scale;
149  iterator_axpy(&in(0, in_offset + ss1*rdim + rr),
150  &in(0, in_offset + ss1*rdim + rr) + ldim, // bugbug
151  &out(out_offset + ss2*ldim, rr),
152  alfa_t);
153  }
154  }
155  }
156  }
157 
158  template <typename T1, class A1,
159  typename T2, class A2,
160  typename T3, class A3>
162  size_t out_offset, size_t in_offset,
163  size_t sdim1, size_t sdim2, size_t ldim, size_t rdim, T2 alfa_scale)
164  {
165  for(size_t ss1 = 0; ss1 < sdim1; ++ss1)
166  for(size_t ss2 = 0; ss2 < sdim2; ++ss2) {
167  T3 alfa_t = alfa(ss1, ss2) * alfa_scale;
168  for(size_t rr = 0; rr < rdim; ++rr)
169  for(size_t ll = 0; ll < ldim; ++ll) {
170  out(ll, out_offset + ss2*rdim+rr) += in(ll + in_offset + ss1*ldim, rr) * alfa_t;
171  }
172  }
173  }
174 
175  template <typename T1, class A1,
176  typename T2, class A2,
177  typename T3, class A3>
179  size_t out_y_offset, size_t out_x_offset,
180  size_t in_y_offset, size_t in_x_offset,
181  size_t alfa_y_offset, size_t alfa_x_offset,
182  size_t ldim, size_t rdim,
183  size_t lpdim, size_t rpdim,
184  size_t ilpdim, size_t irpdim)
185  {
186  for(size_t ll = 0; ll < ldim; ++ll)
187  for(size_t rr = 0; rr < rdim; ++rr)
188  for(size_t lp = 0; lp < lpdim; ++lp)
189  for(size_t rp = 0; rp < rpdim; ++rp)
190  for(size_t ilp = 0; ilp < ilpdim; ++ilp)
191  for(size_t irp = 0; irp < irpdim; ++irp)
192  out(out_y_offset + lp*ldim + ll, out_x_offset + rp*rdim + rr) +=
193  in(in_y_offset + ilp*ldim + ll, in_x_offset + irp*rdim + rr) *
194  alfa(alfa_y_offset + ilp*irpdim + irp, alfa_x_offset + lp*rpdim + rp);
195  }
196 
197  template<class T, class SymmGroup>
198  std::vector<double> bond_renyi_entropies(const block_matrix<alps::numeric::diagonal_matrix<T>, SymmGroup>& set){
199  std::vector<double> ret;
200  for(std::size_t k = 0; k < set.n_blocks(); ++k){
201  for (typename alps::numeric::diagonal_matrix<T>::const_diagonal_iterator it = diagonal(set[k]).first;
202  it != diagonal(set[k]).second; ++it)
203  {
204  double a = std::abs(*it);
205  if (a > 1e-10)
206  ret.push_back(a*a);
207  }
208  }
209  return ret;
210  }
211 
212  template <typename T, class A>
214  // memset((void*)&M(0,0),1,num_rows(M)*num_cols(M)*sizeof(T));
215  for_each(elements(M).first,elements(M).second, boost::lambda::_1 = 1); // boost::lambda ^^' because iterable matrix concept
216  }
217 
218 } } } // namespace maquis::dmrg::detail
219 
220 #endif // MAQUIS_BLOCK_MATRIX_DEATAIL_ALPS_MATRIX_DETAIL_HPP
void reshape_l2r(const alps::numeric::matrix< T, A1 > &left, alps::numeric::matrix< T, A2 > &right, size_t left_offset, size_t right_offset, size_t sdim, size_t ldim, size_t rdim)
void mwt(alps::numeric::matrix< T1, A1 > &out, const alps::numeric::matrix< T2, A2 > &in, const alps::numeric::matrix< T3, A3 > &alfa, size_t out_y_offset, size_t out_x_offset, size_t in_y_offset, size_t in_x_offset, size_t alfa_y_offset, size_t alfa_x_offset, size_t ldim, size_t rdim, size_t lpdim, size_t rpdim, size_t ilpdim, size_t irpdim)
std::vector< double > bond_renyi_entropies(const block_matrix< alps::numeric::diagonal_matrix< T >, SymmGroup > &set)
void reshape_l2b(alps::numeric::matrix< T, A > &out, const alps::numeric::matrix< T, A > &in, size_t in_left_offset, size_t in_phys_offset, size_t out_left_offset, size_t out_right_offset, size_t sdim1, size_t sdim2, size_t ldim, size_t rdim)
Definition: alps_detail.hpp:79
void lb_tensor_mpo(alps::numeric::matrix< T1, A1 > &out, const alps::numeric::matrix< T2, A2 > &in, const alps::numeric::matrix< T3, A3 > &alfa, size_t out_offset, size_t in_offset, size_t sdim1, size_t sdim2, size_t ldim, size_t rdim, T2 alfa_scale)
void rb_tensor_mpo(alps::numeric::matrix< T1, A1 > &out, const alps::numeric::matrix< T2, A2 > &in, const alps::numeric::matrix< T3, A3 > &alfa, size_t out_offset, size_t in_offset, size_t sdim1, size_t sdim2, size_t ldim, size_t rdim, T2 alfa_scale)
void left_right_boundary_init(alps::numeric::matrix< T, A > &M)
void op_kron(Matrix2 &out, const Matrix1 &in, const Matrix1 &alfa, size_t out_y_offset, size_t out_x_offset, size_t ldim1, size_t ldim2, size_t rdim1, size_t rdim2)
Definition: alps_detail.hpp:65
void reshape_b2l(alps::numeric::matrix< T, A > &out, const alps::numeric::matrix< T, A > &in, size_t in_left_offset, size_t in_right_offset, size_t out_left_offset, size_t out_phys_offset, size_t sdim1, size_t sdim2, size_t ldim, size_t rdim)
Definition: alps_detail.hpp:96
void reshape_r2l(alps::numeric::matrix< T, A1 > &left, const alps::numeric::matrix< T, A2 > &right, size_t left_offset, size_t right_offset, size_t sdim, size_t ldim, size_t rdim)
void iterator_axpy(InputIterator in1, InputIterator in2, OutputIterator out1, T val)
Definition: alps_detail.hpp:39