operator=() [1/2]

template<typename T >

herm_matrix< T > & cntr::herm_matrix< T >::operator=

(

const herm_matrix< T > &

g

)

Definition at line 187 of file cntr_herm_matrix_impl.hpp.

                                                              {
    if (this == &g)
        return *this;
    sig_ = g.sig_;
    if (nt_ != g.nt_ || ntau_ != g.ntau_ || size1_ != g.size1_) {
        delete[] les_;
        delete[] ret_;
        delete[] tv_;
        delete[] mat_;
        nt_ = g.nt_;
        ntau_ = g.ntau_;
        size1_ = g.size1_;
        size2_ = g.size1_;
        element_size_ = size1_ * size1_;
        if (size1_ > 0) {
            mat_ = new cplx[(ntau_ + 1) * element_size_];
        } else {
            mat_ = 0;
        }
        if (size1_ > 0 && nt_ >= 0) {
            les_ = new cplx[((nt_ + 1) * (nt_ + 2)) / 2 * element_size_];
            ret_ = new cplx[((nt_ + 1) * (nt_ + 2)) / 2 * element_size_];
            tv_ = new cplx[(nt_ + 1) * (ntau_ + 1) * element_size_];
        } else {
            les_ = 0;
            ret_ = 0;
            tv_ = 0;
        }
    }
    if (size1_ > 0) {
        memcpy(mat_, g.mat_, sizeof(cplx) * (ntau_ + 1) * element_size_);
        if (nt_ >= 0) {
            memcpy(les_, g.les_, sizeof(cplx) * ((nt_ + 1) * (nt_ + 2)) / 2 *
                                     element_size_);
            memcpy(ret_, g.ret_, sizeof(cplx) * ((nt_ + 1) * (nt_ + 2)) / 2 *
                                     element_size_);
            memcpy(tv_, g.tv_,
                   sizeof(cplx) * (nt_ + 1) * (ntau_ + 1) * element_size_);
        }
    }
    return *this;
}