27 #ifndef CONTRACTIONS_H
28 #define CONTRACTIONS_H
39 template<
class Matrix,
class OtherMatrix,
class SymmGroup>
47 throw std::runtime_error(
"Not implemented!");
69 template<
class Matrix,
class OtherMatrix,
class SymmGroup>
77 throw std::runtime_error(
"Not implemented!");
96 template<
class Matrix,
class OtherMatrix,
class SymmGroup>
112 typedef typename SymmGroup::charge charge;
113 typedef std::size_t size_t;
116 col_proxy col_b2 = mpo.
column(b2);
117 for (
typename col_proxy::const_iterator col_it = col_b2.begin(); col_it != col_b2.end(); ++col_it) {
118 index_type b1 = col_it.index();
131 for (
size_t r = 0; r < right_i.
size(); ++r)
133 charge out_r_charge = right_i[r].first;
135 size_t r_size = right_i[r].second;
137 if (!out_left_i.
has(out_l_charge))
continue;
139 size_t o = ret.
find_block(out_l_charge, out_r_charge);
141 o = ret.
insert_block(Matrix(1,1), out_l_charge, out_r_charge);
145 for (
size_t w_block = 0; w_block < W.
n_blocks(); ++w_block)
147 charge phys_c1 = W.
left_basis()[w_block].first;
151 size_t t_block = T.
right_basis().position(in_r_charge);
154 charge in_l_charge = T.
left_basis()[t_block].first;
156 size_t in_right_offset = in_right_pb(phys_c1, out_r_charge);
157 size_t out_left_offset = out_left_pb(phys_c2, in_l_charge);
159 size_t phys_s1 = W.
left_basis()[w_block].second;
161 Matrix
const & wblock = W[w_block];
162 Matrix
const & iblock = T[t_block];
163 Matrix & oblock = ret[o];
166 out_left_offset, in_right_offset,
167 phys_s1, phys_s2, T.
left_basis()[t_block].second, r_size, access.
scale);
174 template<
class Matrix,
class OtherMatrix,
class SymmGroup>
191 typedef typename SymmGroup::charge charge;
192 typedef std::size_t size_t;
196 row_proxy row_b1 = mpo.
row(b1);
197 for (
typename row_proxy::const_iterator row_it = row_b1.begin(); row_it != row_b1.end(); ++row_it) {
198 index_type b2 = row_it.index();
211 for (
size_t l = 0; l < left_i.
size(); ++l)
213 charge out_l_charge = left_i[l].first;
214 size_t l_size = left_i[l].second;
217 if (!out_right_i.
has(out_r_charge))
continue;
219 size_t o = ret.
find_block(out_l_charge, out_r_charge);
221 o = ret.
insert_block(Matrix(1,1), out_l_charge, out_r_charge);
225 for (
size_t w_block = 0; w_block < W.
n_blocks(); ++w_block)
227 charge phys_c1 = W.
left_basis()[w_block].first;
231 size_t t_block = T.
left_basis().position(in_l_charge);
232 if (t_block == T.
left_basis().size())
continue;
234 charge in_r_charge = T.
right_basis()[t_block].first;
235 assert(right_i.
has(in_r_charge));
237 size_t in_left_offset = in_left_pb(phys_c1, out_l_charge);
238 size_t out_right_offset = out_right_pb(phys_c2, in_r_charge);
239 size_t phys_s1 = W.
left_basis()[w_block].second;
241 const Matrix & wblock = W[w_block];
242 const Matrix & iblock = T[t_block];
243 Matrix & oblock = ret[o];
246 out_right_offset, in_left_offset,
258 template<
class Matrix,
class OtherMatrix,
class SymmGroup>
265 typedef typename SymmGroup::charge charge;
266 typedef std::size_t size_t;
272 std::vector<block_matrix<Matrix, SymmGroup> > t(left.
aux_dim());
273 size_t loop_max = left.
aux_dim();
280 out_left_i = physical_i * left_i;
283 boost::lambda::bind(
static_cast<charge(*)(charge, charge)
>(
SymmGroup::fuse),
284 -boost::lambda::_1, boost::lambda::_2));
291 parallel_for(l, std::size_t b2 = 0; b2 < loop_max; ++b2) {
292 ret[b2] =
lbtm_kernel(b2, left, t, mpo, physical_i, right_i, out_left_i, in_right_pb, out_left_pb);
298 template<
class Matrix,
class OtherMatrix,
class SymmGroup>
305 typedef typename SymmGroup::charge charge;
306 typedef std::size_t size_t;
312 std::vector<block_matrix<Matrix, SymmGroup> > t(right.
aux_dim());
313 size_t loop_max = right.
aux_dim();
320 out_right_i =
adjoin(physical_i) * right_i;
324 boost::lambda::bind(
static_cast<charge(*)(charge, charge)
>(
SymmGroup::fuse),
325 -boost::lambda::_1, boost::lambda::_2));
331 parallel_for(l, std::size_t b1 = 0; b1 < loop_max; ++b1) {
332 ret[b1] =
rbtm_kernel(b1, right, t, mpo, physical_i, left_i, right_i, out_right_i, in_left_pb, out_right_pb);
338 template<
class Matrix,
class OtherMatrix,
class SymmGroup>
345 typedef typename SymmGroup::charge charge;
347 std::vector<block_matrix<Matrix, SymmGroup> > t(left.
aux_dim());
352 std::size_t loop_max = left.
aux_dim();
364 boost::lambda::bind(
static_cast<charge(*)(charge, charge)
>(
SymmGroup::fuse),
365 -boost::lambda::_1, boost::lambda::_2));
371 std::size_t loop_max = mpo.
col_dim();
375 parallel_for(, std::size_t b2 = 0; b2 < loop_max; ++b2) {
377 tmp =
lbtm_kernel(b2, left, t, mpo, ket_tensor.
site_dim(), right_i, out_left_i, in_right_pb, out_left_pb);
384 template<
class Matrix,
class OtherMatrix,
class SymmGroup>
391 typedef typename SymmGroup::charge charge;
393 std::vector<block_matrix<Matrix, SymmGroup> > t(right.
aux_dim());
398 std::size_t loop_max = right.
aux_dim();
410 boost::lambda::bind(
static_cast<charge(*)(charge, charge)
>(
SymmGroup::fuse),
411 -boost::lambda::_1, boost::lambda::_2));
416 std::size_t loop_max = mpo.
row_dim();
420 parallel_for(, std::size_t b1 = 0; b1 < loop_max; ++b1) {
422 tmp =
rbtm_kernel(b1, right, t, mpo, ket_tensor.
site_dim(), left_i, right_i, out_right_i, in_left_pb, out_right_pb);
429 template<
class Matrix,
class OtherMatrix,
class SymmGroup>
436 typedef typename SymmGroup::charge charge;
442 std::vector<block_matrix<Matrix, SymmGroup> > t(left.
aux_dim());
443 std::size_t loop_max = left.
aux_dim();
450 & left_i = ket_tensor.
row_dim(),
451 & right_i = ket_tensor.
col_dim(),
452 out_left_i = physical_i * left_i;
455 boost::lambda::bind(
static_cast<charge(*)(charge, charge)
>(
SymmGroup::fuse),
456 -boost::lambda::_1, boost::lambda::_2));
460 parallel_for(, std::size_t b2 = 0; b2 < loop_max; ++b2) {
463 right_i, out_left_i, in_right_pb, out_left_pb);
465 gemm(contr_column, right[b2], tmp);
469 for (std::size_t k = 0; k < tmp.
n_blocks(); ++k)
477 template<
class Matrix,
class OtherMatrix,
class SymmGroup>
486 gemm(ortho_left, ortho_mps.
data(), t);
505 template<
class Matrix,
class OtherMatrix,
class SymmGroup>
511 double alpha,
double cutoff, std::size_t Mmax)
520 for (std::size_t b = 0; b < half_dm.aux_dim(); ++b)
527 for (std::size_t k = 0; k < tdm.
n_blocks(); ++k) {
543 return std::make_pair(ret, trunc);
546 template<
class Matrix,
class SymmGroup>
562 template<
class Matrix,
class OtherMatrix,
class SymmGroup>
568 double alpha,
double cutoff, std::size_t Mmax)
577 for (std::size_t b = 0; b < half_dm.aux_dim(); ++b)
583 for (std::size_t k = 0; k < tdm.
n_blocks(); ++k) {
600 return std::make_pair(ret, trunc);
603 template<
class Matrix,
class SymmGroup>
620 template<
class Matrix,
class SymmGroup>
628 typedef typename SymmGroup::charge charge;
636 boost::lambda::bind(
static_cast<charge(*)(charge, charge)
>(
SymmGroup::fuse),
637 -boost::lambda::_1, boost::lambda::_2));
640 for (
size_t ls = 0; ls < left_i.size(); ++ls)
641 for (
size_t rs = 0; rs < right_i.
size(); ++rs)
642 for (
size_t lps = 0; lps < phys_i.
size(); ++lps)
643 for (
size_t rps = 0; rps < phys_i.
size(); ++rps)
644 for (
size_t ilps = 0; ilps < phys_i.
size(); ++ilps)
645 for (
size_t irps = 0; irps < phys_i.
size(); ++irps)
647 charge lc = left_i[ls].first, rc = right_i[rs].first;
648 charge lpc = phys_i[lps].first, rpc = phys_i[rps].first;
649 charge ilpc = phys_i[ilps].first, irpc = phys_i[irps].first;
657 if (left_out_charge != right_out_charge)
659 if (left_vec_charge != right_vec_charge)
661 if (! vec.
has_block(left_vec_charge, right_vec_charge) )
666 if (! ret.
has_block(left_out_charge, right_out_charge))
668 left_out_charge, right_out_charge);
672 assert( op.
has_block(both_charge, both_charge) );
675 vec(left_vec_charge, right_vec_charge),
676 op(both_charge, both_charge),
677 left_pb(lpc, lc), right_pb(rpc, rc),
678 left_pb(ilpc, lc), right_pb(irpc, rc),
679 phys_pb(ilpc, irpc), phys_pb(lpc, rpc),
680 left_i[ls].second, right_i[rs].second,
681 phys_i[lps].second, phys_i[rps].second,
682 phys_i[ilps].second, phys_i[irps].second);
688 template<
class Matrix,
class SymmGroup>
692 typedef typename SymmGroup::charge charge;
706 for (
size_t ls = 0; ls < left_i.
size(); ++ls)
707 for (
size_t rs = 0; rs < right_i.
size(); ++rs)
708 for (
size_t s1 = 0; s1 < phys_i.
size(); ++s1)
709 for (
size_t s2 = 0; s2 < phys_i.
size(); ++s2) {
711 charge lc = left_i[ls].first, rc = right_i[rs].first;
712 charge s1c = phys_i[s1].first, s2c = phys_i[s2].first;
720 charge right_vec_charge = rc;
722 if (! vec.
has_block(left_vec_charge, right_vec_charge) )
725 if (! out_left_i.
has(lc))
726 out_left_i.
insert(left_i[ls]);
731 if (! ret_vec.
has_block(left_out_charge, right_out_charge) )
732 ret_vec.
insert_block(
new Matrix(left_pb.
size(s2c, lc), right_i[rs].second, 0), left_out_charge, right_out_charge);
734 Matrix & oblock = ret_vec(left_out_charge, right_out_charge);
735 Matrix
const & iblock = vec(left_vec_charge, right_vec_charge);
736 Matrix
const & op_block = op(s1c, s2c);
738 size_t i_l_offset = left_pb(s1c, lc);
739 size_t i_r_offset = 0;
740 size_t l_offset = left_pb(s2c, lc);
742 size_t i_op_offset = 0;
743 size_t op_offset = 0;
745 for (
size_t ss1 = 0; ss1 < phys_i[s1].second; ++ss1) {
746 for (
size_t ss2 = 0; ss2 < phys_i[s2].second; ++ss2) {
747 size_t o_l_start = l_offset + ss2*left_i[ls].second;
748 size_t o_r_start = r_offset;
750 size_t i_l_start = i_l_offset + ss1*left_i[ls].second;
751 size_t i_r_start = i_r_offset;
753 typename Matrix::value_type
const & op_val = op_block(i_op_offset + ss1, op_offset + ss2);
756 for (
size_t rr = 0; rr < right_i[rs].second; ++rr) {
757 for (
size_t ll = 0; ll < left_i[ls].second; ++ll) {
758 oblock(o_l_start+ll, o_r_start+rr) += iblock(i_l_start+ll, i_r_start+rr) * op_val;
767 assert( ret.reasonable() );
772 template<
class Matrix,
class SymmGroup>
777 typedef typename SymmGroup::charge charge;
791 for (
size_t ls = 0; ls < left_i.
size(); ++ls)
792 for (
size_t rs = 0; rs < right_i.
size(); ++rs)
793 for (
size_t s1 = 0; s1 < phys_i.
size(); ++s1)
794 for (
size_t s2 = 0; s2 < phys_i.
size(); ++s2) {
796 charge lc = left_i[ls].first, rc = right_i[rs].first;
797 charge s1c = phys_i[s1].first, s2c = phys_i[s2].first;
800 charge right_vec_charge = rc;
802 charge right_out_charge = right_vec_charge;
804 if (! vec.
has_block(left_vec_charge, right_vec_charge) )
808 if (! ret_vec.
has_block(left_out_charge, right_out_charge) )
809 ret_vec.
insert_block(
new Matrix(left_pb.
size(s2c, lc), right_i[rs].second, 0), left_out_charge, right_out_charge);
811 Matrix & oblock = ret_vec(left_out_charge, right_out_charge);
812 Matrix
const & iblock = vec(left_vec_charge, right_vec_charge);
813 Matrix
const & op_block = op(s1c, s2c);
815 size_t i_l_offset = left_pb(s1c, lc);
816 size_t i_r_offset = 0;
817 size_t l_offset = left_pb(s2c, lc);
819 size_t i_op_offset = 0;
820 size_t op_offset = 0;
822 for (
size_t ll = 0; ll < left_i[ls].second; ++ll)
823 for (
size_t rr = 0; rr < right_i[rs].second; ++rr)
824 for (
size_t ss1 = 0; ss1 < phys_i[s1].second; ++ss1)
825 for (
size_t ss2 = 0; ss2 < phys_i[s2].second; ++ss2) {
827 oblock(l_offset + ss2*left_i[ls].second + ll,
829 iblock(i_l_offset + ss1*left_i[ls].second + ll,
831 op_block(i_op_offset + ss1,
834 oblock(l_offset + ss2*left_i[ls].second + ll,
836 iblock(i_l_offset + ss1*left_i[ls].second + ll,
838 op_block(i_op_offset + ss1,
849 template<
class Matrix,
class SymmGroup>
854 typedef typename SymmGroup::charge charge;
874 for (
size_t ls = 0; ls < left_i.
size(); ++ls)
875 for (
size_t rs = 0; rs < right_i.
size(); ++rs)
876 for (
size_t s1 = 0; s1 < phys_i.
size(); ++s1)
877 for (
size_t s2 = 0; s2 < phys_i.
size(); ++s2) {
879 charge lc = left_i[ls].first, rc = right_i[rs].first;
880 charge s1c = phys_i[s1].first, s2c = phys_i[s2].first;
884 charge right_charge = rc;
886 if (! ket_vec.
has_block(left_ket_charge, right_charge) )
888 if (! bra_vec.
has_block(left_bra_charge, right_charge) )
891 ret.
insert_block(
new Matrix(phys_i[s1].second, phys_i[s2].second, 0), s1c, s2c);
893 Matrix & oblock = ret(s1c, s2c);
894 Matrix
const & ket_block = ket_vec(left_ket_charge, right_charge);
895 Matrix
const & bra_block = bra_vec(left_bra_charge, right_charge);
897 size_t l_ket_offset = left_pb(s1c, lc);
898 size_t l_bra_offset = left_pb(s2c, lc);
900 for (
size_t ll = 0; ll < left_i[ls].second; ++ll)
901 for (
size_t rr = 0; rr < right_i[rs].second; ++rr)
902 for (
size_t ss1 = 0; ss1 < phys_i[s1].second; ++ss1)
903 for (
size_t ss2 = 0; ss2 < phys_i[s2].second; ++ss2) {
906 utils::conj(bra_block(l_bra_offset + ss2*left_i[ls].second + ll, rr)) *
907 ket_block(l_ket_offset + ss1*left_i[ls].second + ll, rr);
914 template<
class Matrix,
class SymmGroup>
919 typedef typename SymmGroup::charge charge;
static Boundary< Matrix, SymmGroup > right_boundary_tensor_mpo(MPSTensor< Matrix, SymmGroup > mps, Boundary< OtherMatrix, SymmGroup > const &right, MPOTensor< Matrix, SymmGroup > const &mpo, Index< SymmGroup > const *in_low=NULL)
void make_left_paired() const
static MPSTensor< Matrix, SymmGroup > predict_lanczos_l2r_sweep(MPSTensor< Matrix, SymmGroup > B, MPSTensor< Matrix, SymmGroup > const &psi, MPSTensor< Matrix, SymmGroup > const &A)
Index< SymmGroup > const & col_dim() const
block_matrix< Matrix, SymmGroup > reshape_left_to_physleft(Index< SymmGroup > physical_i, Index< SymmGroup > left_i, Index< SymmGroup > right_i, block_matrix< Matrix, SymmGroup > const &m1)
void make_right_paired() const
index_type row_dim() const
size_type n_blocks() const
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)
static MPSTensor< Matrix, SymmGroup > local_op(MPSTensor< Matrix, SymmGroup > const &mps, block_matrix< Matrix, SymmGroup > const &op)
void gemm_trim_left(block_matrix< Matrix1, SymmGroup > const &A, block_matrix< Matrix2, SymmGroup > const &B, block_matrix< Matrix3, SymmGroup > &C)
void reshape_right_to_left_new(Index< SymmGroup > physical_i, Index< SymmGroup > left_i, Index< SymmGroup > right_i, block_matrix< OtherMatrix, SymmGroup > const &m1, block_matrix< Matrix, SymmGroup > &m2)
void match_and_add_block(Matrix const &, charge, charge)
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)
size_t size(charge pc) const
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)
static MPSTensor< Matrix, SymmGroup > site_hamil2(MPSTensor< Matrix, SymmGroup > ket_tensor, Boundary< OtherMatrix, SymmGroup > const &left, Boundary< OtherMatrix, SymmGroup > const &right, MPOTensor< Matrix, SymmGroup > const &mpo)
static block_matrix< Matrix, SymmGroup > density_matrix_2(MPSTensor< Matrix, SymmGroup > const &bra_tensor, MPSTensor< Matrix, SymmGroup > const &ket_tensor)
size_type insert_block(Matrix const &, charge, charge)
std::size_t size_of_block(charge c) const
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)
row_proxy row(index_type row_i) const
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)
Index< SymmGroup > const & row_dim() const
static block_matrix< Matrix, SymmGroup > density_matrix(MPSTensor< Matrix, SymmGroup > const &bra_tensor, MPSTensor< Matrix, SymmGroup > const &ket_tensor)
block_matrix< Matrix, SymmGroup > adjoint(block_matrix< Matrix, SymmGroup > m)
static block_matrix< Matrix, SymmGroup > lbtm_kernel(size_t b2, Boundary< OtherMatrix, SymmGroup > const &left, std::vector< block_matrix< Matrix, SymmGroup > > const &left_mult_mps, MPOTensor< Matrix, SymmGroup > const &mpo, Index< SymmGroup > const &physical_i, Index< SymmGroup > const &right_i, Index< SymmGroup > const &out_left_i, ProductBasis< SymmGroup > const &in_right_pb, ProductBasis< SymmGroup > const &out_left_pb)
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)
void resize_block(charge r, charge c, size_type new_r, size_type new_c, bool pretend=false)
void multiply_from_left(block_matrix< Matrix, SymmGroup > const &)
include one of the Index class definitions
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)
MPOTensor_detail::const_term_descriptor< Matrix, SymmGroup > at(index_type left_index, index_type right_index) const
block_matrix< Matrix, SymmGroup > adjoin(block_matrix< Matrix, SymmGroup > const &m)
static std::pair< MPSTensor< Matrix, SymmGroup >, truncation_results > predict_new_state_l2r_sweep(MPSTensor< Matrix, SymmGroup > const &mps, MPOTensor< Matrix, SymmGroup > const &mpo, Boundary< OtherMatrix, SymmGroup > const &left, Boundary< OtherMatrix, SymmGroup > const &right, double alpha, double cutoff, std::size_t Mmax)
Index< SymmGroup > phys_i
void replace_left_paired(block_matrix< Matrix, SymmGroup > const &, Indicator=Unorm)
static Boundary< Matrix, SymmGroup > left_boundary_tensor_mpo(MPSTensor< Matrix, SymmGroup > mps, Boundary< OtherMatrix, SymmGroup > const &left, MPOTensor< Matrix, SymmGroup > const &mpo, Index< SymmGroup > const *in_low=NULL)
static block_matrix< Matrix, SymmGroup > multiply_with_twosite(block_matrix< Matrix, SymmGroup > const &vec, block_matrix< Matrix, SymmGroup > const &op, Index< SymmGroup > const &left_i, Index< SymmGroup > const &right_i, Index< SymmGroup > const &phys_i)
bool weak_equal(Index< SymmGroup > const &a, Index< SymmGroup > const &b)
truncation_results heev_truncate(block_matrix< Matrix, SymmGroup > const &M, block_matrix< Matrix, SymmGroup > &evecs, block_matrix< DiagMatrix, SymmGroup > &evals, double cutoff, std::size_t Mmax, bool verbose=true)
#define parallel_for(constraint,...)
declaration of the MPSTensor class
bool has_block(charge r, charge c) const
block_matrix< Matrix, SymmGroup > conjugate(block_matrix< Matrix, SymmGroup > m)
static MPSTensor< Matrix, SymmGroup > multiply_with_op(MPSTensor< Matrix, SymmGroup > const &mps, block_matrix< Matrix, SymmGroup > const &op)
static std::pair< MPSTensor< Matrix, SymmGroup >, truncation_results > predict_new_state_r2l_sweep(MPSTensor< Matrix, SymmGroup > const &mps, MPOTensor< Matrix, SymmGroup > const &mpo, Boundary< OtherMatrix, SymmGroup > const &left, Boundary< OtherMatrix, SymmGroup > const &right, double alpha, double cutoff, std::size_t Mmax)
declaration of MPOTensor object
Index< SymmGroup > const & right_basis() const
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)
void multiply_from_right(block_matrix< Matrix, SymmGroup > const &)
std::size_t aux_dim() const
Index< SymmGroup > const & site_dim() const
static block_matrix< Matrix, SymmGroup > rbtm_kernel(size_t b1, Boundary< OtherMatrix, SymmGroup > const &right, std::vector< block_matrix< Matrix, SymmGroup > > const &right_mult_mps, MPOTensor< Matrix, SymmGroup > const &mpo, Index< SymmGroup > const &physical_i, Index< SymmGroup > const &left_i, Index< SymmGroup > const &right_i, Index< SymmGroup > const &out_right_i, ProductBasis< SymmGroup > const &in_left_pb, ProductBasis< SymmGroup > const &out_right_pb)
Index< SymmGroup > left_i
void reshape_left_to_right_new(Index< SymmGroup > physical_i, Index< SymmGroup > left_i, Index< SymmGroup > right_i, block_matrix< OtherMatrix, SymmGroup > const &m1, block_matrix< Matrix, SymmGroup > &m2)
col_proxy column(index_type col_i) const
std::size_t insert(std::pair< charge, std::size_t > const &x)
functions to reshape the representation of data in MPSTensor
void gemm(block_matrix< Matrix1, SymmGroup > const &A, block_matrix< Matrix2, SymmGroup > const &B, block_matrix< Matrix3, SymmGroup > &C)
size_type find_block(charge r, charge c) const
boost::numeric::ublas::matrix_column< const CSCMatrix > col_proxy
Index< SymmGroup > right_i
block_matrix< typename maquis::traits::transpose_view< Matrix >::type, SymmGroup > transpose(block_matrix< Matrix, SymmGroup > const &m)
void gemm_trim_right(block_matrix< Matrix1, SymmGroup > const &A, block_matrix< Matrix2, SymmGroup > const &B, block_matrix< Matrix3, SymmGroup > &C)
static MPSTensor< Matrix, SymmGroup > predict_lanczos_r2l_sweep(MPSTensor< Matrix, SymmGroup > B, MPSTensor< Matrix, SymmGroup > const &psi, MPSTensor< Matrix, SymmGroup > const &A)
Index< SymmGroup > const & left_basis() const
index_type col_dim() const
block_matrix< Matrix, SymmGroup > & data()
void replace_right_paired(block_matrix< Matrix, SymmGroup > const &, Indicator=Unorm)
Index< SymmGroup > common_subset(Index< SymmGroup > &a, Index< SymmGroup > &b)
void reshape_and_pad_left(Index< SymmGroup > physical_i, Index< SymmGroup > in_left_i, Index< SymmGroup > in_right_i, Index< SymmGroup > out_left_i, Index< SymmGroup > out_right_i, block_matrix< Matrix, SymmGroup > const &m1, block_matrix< Matrix, SymmGroup > &m2)
T fuse(const A &ind, T d)
Fuse indices n[i] into one p = n[i] d^i.