cvm.h

Go to the documentation of this file.

//                  CVM Class Library
//                  http://cvmlib.com
//
//          Copyright Sergei Nikolaev 1992-2014
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)
#ifndef _CVM_H
#define _CVM_H

// 5.7 ILP64 support
#if defined (CVM_ILP64)
    typedef long long int tint; 
#   define TINT_ZERO (0LL)
#   define TINT_ONE  (1LL)
#   define CVM_TINT_FORMAT "%lld"
#else
    typedef int tint;           
#   define TINT_ZERO (0)
#   define TINT_ONE  (1)
#   define CVM_TINT_FORMAT "%d"
#endif

// 5.7 0-based indexing
#if defined (CVM_ZERO_BASED)
#   define CVM0 TINT_ZERO 
#else
#   define CVM0 TINT_ONE  
#endif

#if !defined (CVM_NO_MT)        // as of 5.7 it's by default
#   define CVM_MT
#   if !defined (_PTHREADS)
#       define _PTHREADS
#   endif
#endif

// MSVC++ 6.0 and higher settings
#if defined (_MSC_VER)
#   pragma once
#   define WIN32_LEAN_AND_MEAN        // Exclude rarely-used stuff from Windows headers
#   ifndef _WIN32_WINNT
#       define _WIN32_WINNT 0x500     // at least Win2000 is required for InitializeCriticalSectionAndSpinCount
#   endif
#   include <windows.h>
#   include <process.h>
// 6.0 TR1 dependency added
#   include <memory>

#   if (_MSC_VER < 1400)
#       error "Please use stable version 5.2 for older MSVC compilers"
#   endif
#   if (_MSC_VER >= 1700)             // since VC11 aka MS Visual Studio 2012
#       define CVM_STD_MUTEX
#       include <mutex>
#       include <thread>
#   endif
#   if (_MSC_VER >= 1800)             // since VC12 aka MS Visual Studio 2013
#       define CVM_USE_VARIADIC_TEMPLATES
#       define CVM_USE_INITIALIZER_LISTS
#       define CVM_USE_DELEGATING_CONSTRUCTORS

#       include <initializer_list>
#   endif
#   if (!defined(__INTEL_COMPILER) || !defined(_WIN64)) && !defined(CVM_ACML) && !(_MSC_VER >= 1500 && defined(_WIN64))
#       define CVM_PASS_STRING_LENGTH_TO_FTN_SUBROUTINES
#   endif
#   if defined(CVM_ACML)
#       define CVM_COMPLEX_NUMBER_RETURNED
#   endif
//#   if (_MSC_VER <= 1800)
#       define noexcept throw()
//#   endif
#   pragma warning(disable:4290)
#   if defined (CVM_FLOAT)
#       pragma warning(disable:4244)
#   endif
#   if defined (SRC_EXPORTS) && !defined (CVM_EXPORTS)
#       define CVM_EXPORTS
#   endif
#   include <unordered_map>
#   define CVM_BLOCKS_MAP std::unordered_map
#   ifdef CVM_STATIC
#       define CVM_API
#   else
#       ifdef CVM_EXPORTS
#           define CVM_API __declspec(dllexport)
#       else
#           define CVM_API __declspec(dllimport)
#       endif
#   endif

#   include <limits>
typedef __int64 CVM_LONGEST_INT; 

#   if defined(_WIN64)
typedef unsigned long long CVM_PTR_WRAPPER;
#   else
#       if defined (CVM_ILP64)
#           error "CVM_ILP64 is incompatible with 32 bit mode"
#       endif
typedef unsigned long CVM_PTR_WRAPPER;
#   endif

#   define CVM_VSNPRINTF vsnprintf_s
#   define CVM_VSNPRINTF_S_DEFINED
#   define CVM_STRCPY_S_DEFINED

// GCC settings
#elif defined (__GNUC__)
#   if defined (__MINGW32__)
#       define WIN32_LEAN_AND_MEAN
#       include <windows.h>
#       include <process.h>

#       define CVM_USE_CRITICAL_SECTION_NOT_MUTEX

#   else
#       ifdef __stdcall
#           undef __stdcall
#       endif
#       define __stdcall
#       include <semaphore.h>       // Unix
#   endif

// 8.0 - since 4.7.0 we use new std::mutex features
#   if !defined(__INTEL_COMPILER) && !defined (__MINGW32__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 7)
#       define CVM_USE_DELEGATING_CONSTRUCTORS
#       define CVM_USE_USER_LITERALS
#       define CVM_STD_MUTEX
#       include <mutex>
#       include <thread>
#   else
#       define override
#   endif

// 8.1 - more C++11 features, see also http://gcc.gnu.org/projects/cxx0x.html
#   if !defined (__MINGW32__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4)
#       define CVM_USE_VARIADIC_TEMPLATES
#       define CVM_USE_INITIALIZER_LISTS
#       include <initializer_list>
#   endif

// 6.0 TR1 dependency added
#   include <memory>

#   define CVM_API
#   define CVM_STDEXT stdext
#   define CVM_BLOCKS_MAP std::map

typedef long long CVM_LONGEST_INT;

#   if defined(__AMD64__) || defined(_WIN64) || defined(__x86_64__)
typedef unsigned long long CVM_PTR_WRAPPER;
#   else
#       if defined (CVM_ILP64)
#           error "CVM_ILP64 is incompatible with 32 bit mode"
#       endif
typedef unsigned long CVM_PTR_WRAPPER;
#   endif

#   define CVM_VSNPRINTF vsnprintf

// 5.7 - looking for memset
#   include <string.h>
// gcc 4.6.1 fix for ptrdiff_t
#   include <cstddef>

//clang -dM -E -x c /dev/null
#   if defined(__clang__) && __clang_major__ <= 5
#       define CVM_NO_DEFAULT_RANDOM_ENGINE_SUPPORTED 1
#   endif
#   if defined(__clang__) && __clang_major__ >= 5
#       define CVM_USE_VARIADIC_TEMPLATES
#       define CVM_USE_INITIALIZER_LISTS
#       define CVM_USE_USER_LITERALS
#       define CVM_USE_DELEGATING_CONSTRUCTORS
#   endif

#else
#   error "Unsupported compiler"
#endif

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <math.h>
#include <float.h>
#include <time.h>
#include <iostream>
#include <list>
#include <map>
#include <string>
#include <limits>

// fix for missing __builtin_clog functions
#if defined (__INTEL_COMPILER)
#   if defined (_GLIBCXX_USE_C99_COMPLEX)
#       undef _GLIBCXX_USE_C99_COMPLEX
#       define _GLIBCXX_USE_C99_COMPLEX 0
#   endif
#endif

#include <complex>
#include <algorithm>
#include <exception>
#include <utility>
#include <new>

#if !defined(CVM_NO_DEFAULT_RANDOM_ENGINE_SUPPORTED)
#   include <random>
#endif

#if defined (STLPORT)
#   define CVM_USES_STLPORT
#endif

#if defined (_DEBUG) || defined (DEBUG)
#   define CVM_DEBUG
#   include <assert.h>
#   define CVM_ASSERT(p,n) _cvm_assert(p,n);
#else
#   define CVM_ASSERT(p,n)
#endif

#define CVM_OK                           0  
#define CVM_OUTOFMEMORY                  1  
#define CVM_WRONGSIZE                    5  
#define CVM_SIZESMISMATCH                6  
#define CVM_WRONGMKLARG                  7  
#define CVM_WRONGMKLARG2                 8  
#define CVM_SINGULARMATRIX               9  
#define CVM_NOTPOSITIVEDEFINITE          10 
#define CVM_WRONGCHOLESKYFACTOR          11 
#define CVM_WRONGBUNCHKAUFMANFACTOR      12 
#define CVM_NOTPOSITIVEDIAG              13 
#define CVM_CONVERGENCE_ERROR            14 
#define CVM_DIVISIONBYZERO               15 
#define CVM_SEMAPHOREERROR               16 
#define CVM_READ_ONLY_ACCESS             17 
#define CVM_SUBMATRIXACCESSERROR         18 
#define CVM_SUBMATRIXNOTAVAILABLE        19 
#define CVM_MATRIXNOTSYMMETRIC           20 
#define CVM_MATRIXNOTHERMITIAN           21 
#define CVM_BREAKS_HERMITIANITY          22 
#define CVM_METHODNOTAVAILABLE           23 
#define CVM_NOTIMPLEMENTED               24 
#define CVM_CANT_RESIZE_SHARED_MEM       25 
#define CVM_NOT_CONJUGATED               26 
// 8.1
#define CVM_WRONGSIZE_LT                 27 
#define CVM_WRONGSIZE_LE                 28 
#define CVM_INDEX_GT                     29 
#define CVM_INDEX_GE                     30 
#define CVM_OUTOFRANGE_LTGT              31 
#define CVM_OUTOFRANGE_LTGE              32 
#define CVM_OUTOFRANGE_LTGE1             33 
#define CVM_OUTOFRANGE_LTGE2             34 
#define CVM_SIZESMISMATCH_GT             35 
#define CVM_SIZESMISMATCH_LT             36 

#define CVM_THE_LAST_ERROR_CODE          37 
#define CVM_MATRIX_ELEMENT_SEPARATOR     " "
#define CVM_EOL                          std::endl

typedef unsigned char tbyte; 

#ifdef CVM_NO_NAMESPACE
#   define CVM_NAMESPACE_BEG
#   define CVM_NAMESPACE_END
#else
#   define CVM_NAMESPACE_BEG namespace cvm {
#   define CVM_NAMESPACE_END }
#endif


CVM_NAMESPACE_BEG

template<typename T>
class ArrayDeleter {
public:
    void operator () (T* d) const {
        if (d != nullptr) {
            ::delete[] d;
        }
    }
};

template<typename TR, typename T>  class basic_array;
template<typename TR, typename TC> class Matrix;
template<typename TR, typename TC> class SqMatrix;
template<typename TR, typename TC> class BandMatrix;
template<typename TR>              class basic_rvector;
template<typename TR>              class basic_rmatrix;
template<typename TR>              class basic_srmatrix;
template<typename TR, typename TC> class basic_cvector;
template<typename TR, typename TC> class basic_cmatrix;
template<typename TR, typename TC> class basic_scmatrix;
template<typename TR>              class basic_srbmatrix;
template<typename TR, typename TC> class basic_scbmatrix;
template<typename TR>              class basic_srsmatrix;
template<typename TR, typename TC> class basic_schmatrix;
template<typename T,  typename TR> class type_proxy;

class ErrMessages
{
    // message string maps
    typedef std::map<int, std::string, std::less<int> > map_Msg;
    typedef map_Msg::iterator                           itr_Msg;
    typedef map_Msg::const_iterator                     citr_Msg;
    typedef std::pair<int, std::string>                 pair_Msg;

private:
    std::string msUnknown;
    map_Msg mmMsg;
    CVM_API ErrMessages();

public:
    CVM_API const std::string& _get(int nException);
    CVM_API bool _add(int nNewCause, const char* szNewMessage);

    static CVM_API ErrMessages& ErrMessagesInstance();
    ~ErrMessages() { }
};


class cvmexception : public std::exception
{
protected:
    int mnCause; 
    mutable char mszMsg[256]; 

    virtual const char* _get_message(int nCause) const {
        return ErrMessages::ErrMessagesInstance()._get(nCause).c_str();
    }

public:
    cvmexception()
      : mnCause(CVM_OK)
    {
        mszMsg[0] = '\0';
    }

    CVM_API explicit cvmexception(int nCause, ...); // TODO

    CVM_API cvmexception(const cvmexception& e);

    virtual ~cvmexception() throw() { }

    int cause() const {
        return mnCause;
    }

    const char* what() const throw() override {
        return mszMsg;
    }

    static int getNextCause() {
        return CVM_THE_LAST_ERROR_CODE;
    }

    static bool add(int nNewCause, const char* szNewMessage) {
        return ErrMessages::ErrMessagesInstance()._add(nNewCause, szNewMessage);
    }
};

template<typename T>
CVM_API void __copy(tint nSize, const T* pFrom, tint nFromIncr, T* pTo, tint nToIncr);
template<typename T>
CVM_API void __swap(tint nSize, T* p1, tint n1Incr, T* p2, tint n2Incr);

template<typename TC, typename TR>
CVM_API TR _real(const TC& mT);
template<typename TC, typename TR>
CVM_API TR _imag(const TC& mT);

template<typename TR>
CVM_API TR __dot(const TR* pDm, tint mnSize, tint mnIncr, const TR* pd, tint nIncr);
template<typename TC>
CVM_API TC __dotu(const TC* pDm, tint mnSize, tint mnIncr, const TC* pd, tint nIncr);
template<typename TC>
CVM_API TC __dotc(const TC* pDm, tint mnSize, tint mnIncr, const TC* pd, tint nIncr);

template<typename TR, typename TC>
CVM_API TR __norm(const TC* pd, tint nSize, tint nIncr);

template<typename TC>
CVM_API tint __idamax(const TC* pd, tint nSize, tint nIncr);
template<typename TC>
CVM_API tint __idamin(const TC* pd, tint nSize, tint nIncr);

template<typename TC>
CVM_API void __add(TC* pDm, tint mnSize, tint mnIncr, const TC* pv, tint nIncr);
template<typename TC>
CVM_API void __subtract(TC* pDm, tint mnSize, tint mnIncr, const TC* pv, tint nIncr);
template<typename TR, typename TC>
CVM_API void __scal(TC* pDm, tint mnSize, tint mnIncr, TR dScal);
template<typename TC>
CVM_API void __conj(TC* pDm, tint mnSize, tint mnIncr);

template<typename TR, typename TC>
CVM_API void __copy_real(TC* pDm, tint mnSize, tint mnIncr, const TR* pRe, tint nReIncr);
template<typename TR, typename TC>
CVM_API void __copy_imag(TC* pDm, tint mnSize, tint mnIncr, const TR* pRe, tint nReIncr);
template<typename TR, typename TC>
CVM_API void __copy2(TC* pDm, tint mnSize, tint mnIncr, const TR* pRe, const TR* pIm, tint nReIncr = 1, tint nImIncr = 1);

template<typename TC, typename TM, typename TV>
CVM_API void __gemv(bool bLeft, const TM& m, TC dAlpha, const TV& v, TC dBeta, TV& vRes);
template<typename TC, typename TM, typename TV>
CVM_API void __gbmv(bool bLeft, const TM& m, TC dAlpha, const TV& v, TC dBeta, TV& vRes);
template<typename TR, typename TM, typename TV>
CVM_API void __symv(const TM& m, TR dAlpha, const TV& v, TR dBeta, TV& vRes);
template<typename TC, typename TM, typename TV>
CVM_API void __shmv(const TM& m, TC dAlpha, const TV& v, TC dBeta, TV& vRes);
template<typename TC, typename TM>
CVM_API void __gemm(const TM& ml, bool bTrans1, const TM& mr, bool bTrans2, TC dAlpha, TM& mRes, TC dBeta);
template<typename TR, typename TSM, typename TM>
CVM_API void __symm(bool bLeft, const TSM& ml, const TM& mr, TR dAlpha, TM& mRes, TR dBeta);
template<typename TC, typename TSM, typename TM>
CVM_API void __hemm(bool bLeft, const TSM& ml, const TM& mr, TC dAlpha, TM& mRes, TC dBeta);

template<typename TC, typename TV>
CVM_API void __polynom(TC* pDm, tint ldP, tint mnM, const TC* pd, tint ldA, const TV& v);
template<typename T>
CVM_API void __inv(T& m, const T& mArg) throw(cvmexception);
template<typename T, typename TR>
CVM_API void __exp(T& m, const T& mArg, TR tol) throw(cvmexception);
template<typename T, typename TR>
CVM_API void __exp_symm(T& m, const T& mArg, TR tol) throw(cvmexception);
template<typename TR, typename TC, typename TRM>
CVM_API void __solve(const TRM& m, tint nrhs, const TC* pB, tint ldB, TC* pX, tint ldX, TR& dErr,
                     const TC* pLU, const tint* pPivots, int transp_mode) throw(cvmexception);
template<typename TC, typename TM, typename TSM>
CVM_API void __svd(TC* pd, tint nSize, tint nIncr, const TM& mArg, TSM* mU, TSM* mVH) throw(cvmexception);
template<typename TR, typename TM, typename TX>
CVM_API void __pinv(TX& mX, const TM& mArg, TR threshold) throw(cvmexception);
template<typename TV, typename TSM, typename TSCM>
CVM_API void __eig(TV& vRes, const TSM& mArg, TSCM* mEigVect, bool bRightVect) throw(cvmexception);
template<typename TR, typename TM>
CVM_API void __cond_num(const TM& mArg, TR& dCondNum) throw(cvmexception);
template<typename TM>
void __low_up(TM& m, tint* nPivots) throw(cvmexception);

template<typename TR>
CVM_API void __randomize(TR* pDm, tint mnSize, tint mnIncr, TR dFrom, TR dTo);
template<typename TC, typename TR>
CVM_API void __randomize_real(TC* pDm, tint mnSize, tint mnIncr, TR dFrom, TR dTo);
template<typename TC, typename TR>
CVM_API void __randomize_imag(TC* pDm, tint mnSize, tint mnIncr, TR dFrom, TR dTo);

template<typename TR, typename TM, typename TV>
CVM_API void __ger(TM& m, const TV& vCol, const TV& vRow, TR dAlpha);
template<typename TC, typename TM, typename TV>
CVM_API void __geru(TM& m, const TV& vCol, const TV& vRow, TC cAlpha);
template<typename TC, typename TM, typename TV>
CVM_API void __gerc(TM& m, const TV& vCol, const TV& vRow, TC cAlpha);

template<typename TC, typename TSM>
CVM_API void __syrk(bool bTransp, TC alpha, tint k, const TC* pA, tint ldA, TC beta, TSM& m);
template<typename TC, typename TSM>
CVM_API void __syr2k(bool bTransp, TC alpha, tint k, const TC* pA, tint ldA, const TC* pB, tint ldB, TC beta, TSM& m);
template<typename TR, typename TC, typename TSM>
CVM_API void __herk(bool bTransp, TR alpha, tint k, const TC* pA, tint ldA, TR beta, TSM& m);
template<typename TR, typename TC, typename TSM>
CVM_API void __her2k(bool bTransp, TC alpha, tint k, const TC* pA, tint ldA, const TC* pB, tint ldB, TR beta, TSM& m);

template<typename TM>
CVM_API tint __cholesky(TM& m);
template<typename TM>
CVM_API void __bunch_kaufman(TM& m, tint* nPivots) throw(cvmexception);
template<typename TR, typename TM, typename TV>
CVM_API void __poequ(const TM& m, TV& vScalings, TR& dCond, TR& dMax);

template<typename TM, typename TSM>
CVM_API void __qre(const TM& mA, TM& mQ, TSM& mR) throw(cvmexception);
template<typename TM, typename TSM>
CVM_API void __qrf(const TM& mA, TSM& mQ, TM& mR) throw(cvmexception);
template<typename TM, typename TSM>
CVM_API void __rqe(const TM& mA, TSM& mR, TM& mQ) throw(cvmexception);
template<typename TM, typename TSM>
CVM_API void __rqf(const TM& mA, TM& mR, TSM& mQ) throw(cvmexception);

template<typename TM, typename TSM>
CVM_API void __lqe(const TM& mA, TSM& mL, TM& mQ) throw(cvmexception);
template<typename TM, typename TSM>
CVM_API void __lqf(const TM& mA, TM& mL, TSM& mQ) throw(cvmexception);
template<typename TM, typename TSM>
CVM_API void __qle(const TM& mA, TM& mQ, TSM& mL) throw(cvmexception);
template<typename TM, typename TSM>
CVM_API void __qlf(const TM& mA, TSM& mQ, TM& mL) throw(cvmexception);

// Linear Least Squares problems
template<typename TM, typename TV>
CVM_API void __gels(bool transpose, TM& mA, const TM& mB, TM& mX, TV& vErr) throw(cvmexception);
template<typename TR, typename TM>
CVM_API void __gelsy(TM& mA, const TM& mB, TM& mX, TR tol, tint& rank) throw(cvmexception);
template<typename TR, typename TV, typename TM>
CVM_API void __gelss(TM& mA, const TM& mB, TM& mX, TR rcond, TV& vSV, tint& rank) throw(cvmexception);
template<typename TR, typename TV, typename TM>
CVM_API void __gelsd(TM& mA, const TM& mB, TM& mX, TR rcond, TV& vSV, tint& rank) throw(cvmexception);

// 8.1 Generalized Eigenvalue Problem
template<typename TSRM, typename TSCM, typename TRV, typename TCV>
CVM_API void __ggev(TSRM& mA, TSRM& mB, TCV& vAlpha, TRV& vBeta,
                    TSCM* mEigVectLeft, TSCM* mEigVectRight) throw (cvmexception);


template<typename T>
inline const T& _cvm_min(const T& x, const T& y) {
    return x < y ? x : y;
}

template<typename T>
inline const T& _cvm_max(const T& x, const T& y) {
    return x > y ? x : y;
}

template<class TR>
inline const TR* __get_real_p(const std::complex<TR>* c)
{
#if defined (CVM_USES_STLPORT)
    return &c->_M_re;
#else
    return reinterpret_cast<const TR*>(c);
#endif
}

template<class TR>
inline const TR* __get_imag_p(const std::complex<TR>* c)
{
#if defined (CVM_USES_STLPORT)
    return &c->_M_im;
#else
    return reinterpret_cast<const TR*>(c) + 1;
#endif
}

template<class TR>
inline TR* __get_real_p(std::complex<TR>* c)
{
#if defined (CVM_USES_STLPORT)
    return &c->_M_re;
#else
    return reinterpret_cast<TR*>(c);
#endif
}

template<class TR>
inline TR* __get_imag_p(std::complex<TR>* c)
{
#if defined (CVM_USES_STLPORT)
    return &c->_M_im;
#else
    return reinterpret_cast<TR*>(c) + 1;
#endif
}

template<class TR> inline const TR* __get_real_p(const TR* d) { return d; }
template<class TR> inline const TR* __get_imag_p(const TR* d) { return d; }
template<class TR> inline       TR* __get_real_p(TR* d) { return d; }
template<class TR> inline       TR* __get_imag_p(TR* d) { return d; }

class Chars
{
protected:
    static char mchars[15];

public:
    static const char* pT() {return mchars;}
    static const char* pN() {return mchars + 1;}
    static const char* pU() {return mchars + 2;}
    static const char* pL() {return mchars + 3;}
    static const char* pP() {return mchars + 4;}
    static const char* pQ() {return mchars + 5;}
    static const char* pB() {return mchars + 6;}
    static const char* pE() {return mchars + 7;}
    static const char* pR() {return mchars + 8;}
    static const char* pA() {return mchars + 9;}
    static const char* pS() {return mchars + 10;}
    static const char* pV() {return mchars + 11;}
    static const char* pO() {return mchars + 12;}
    static const char* pI() {return mchars + 13;}
    static const char* pC() {return mchars + 14;}
};

template<class TR>
inline TR basic_cvmMachMin() {
    static const TR _min = (std::numeric_limits<TR>::min)();
    return _min;
}

template<class TR>
inline TR basic_cvmMachSp() {
    static const TR _eps = (std::numeric_limits<TR>::epsilon)();
    return _eps;
}

template<typename TR>
inline TR basic_cvmMachMax() {
    static const TR _max((std::numeric_limits<TR>::max)());
    return _max;
}

template<typename TR>
inline TR basic_cvmLogMachMax() {
    static const TR _log_max(::log(basic_cvmMachMax<TR>()));
    return _log_max;
}

// range and index checkers
template<typename T>
void _check_negative(int err_code, T val) throw(cvmexception)
{
    static T zero = T(0);
    if (val < zero) {
        throw cvmexception(err_code, val);
    }
}

template<typename T>
void _check_positive(int err_code, T val) throw(cvmexception)
{
    static T zero = T(0);
    if (val > zero) {
        throw cvmexception(err_code, val);
    }
}

template<typename T>
void _check_positive(int err_code, T val, const char* func,  const char* file,  int line) throw(cvmexception)
{
    static T zero = T(0);
    if (val > zero) {
        throw cvmexception(err_code, func, file, line);
    }
}

template<typename T>
void _check_lt(int err_code, T idx, T limit) throw(cvmexception)
{
    if (idx < limit) {
        throw cvmexception(err_code, idx, limit);
    }
}

template<typename T>
void _check_le(int err_code, T idx, T limit) throw(cvmexception)
{
    if (idx <= limit) {
        throw cvmexception(err_code, idx, limit);
    }
}

template<typename T>
void _check_ge(int err_code, T idx, T limit) throw(cvmexception)
{
    if (idx >= limit) {
        throw cvmexception(err_code, idx, limit);
    }
}

template<typename T>
void _check_gt(int err_code, T idx, T limit) throw(cvmexception)
{
    if (idx > limit) {
        throw cvmexception(err_code, idx, limit);
    }
}

template<typename T>
void _check_ne(int err_code, T idx, T limit) throw(cvmexception)
{
    if (idx != limit) {
        throw cvmexception(err_code, idx, limit);
    }
}

template<typename T>
void _check_lt_gt(int err_code, T idx, T low_limit, T up_limit) throw(cvmexception)
{
    if (idx < low_limit || idx > up_limit) {
        throw cvmexception(err_code, idx, low_limit, up_limit);
    }
}

template<typename T>
void _check_lt_ge(int err_code, T idx, T low_limit, T up_limit) throw(cvmexception)
{
    if (idx < low_limit || idx >= up_limit) {
        throw cvmexception(err_code, idx, low_limit, up_limit);
    }
}


#ifdef CVM_USE_POOL_MANAGER

class CVM_API MemoryBlocks
{
    struct BlockProperty
    {
        size_t mnSize;
        tint mnRefCount;
        BlockProperty(size_t nSize, tint nRefCount) : mnSize(nSize), mnRefCount(nRefCount) { }
    };

    typedef std::map<tbyte*, BlockProperty, std::less<tbyte*> > map_Blocks;     
    typedef map_Blocks::iterator itr_Blocks;

    typedef std::multimap<size_t, tbyte*> map_FreeBs;                           
    typedef map_FreeBs::iterator itr_FreeBs;

    typedef std::map<tbyte*, itr_FreeBs, std::less<tbyte*> > map_FreeIt;        
    typedef map_FreeIt::iterator itr_FreeIt;

    map_FreeBs mFreeBs;                                                         
    map_FreeIt mFreeIt;                                                         

    map_Blocks mBlocks;                                                         


public:
    void    AddBlock(tbyte* pBlock, size_t nBytes, bool bOccupied);
    tbyte*  GetFreeBlock(size_t nBytes);
    void    AddPair(tbyte* pBlock, size_t nBytes, size_t nRest);
#ifdef CVM_DEBUG
    void    Assert(const void* pvBlock, size_t nBytes);
#endif
    void    AddNew(tbyte* pBlock, size_t nBytes);                               
    tbyte*  AddRef(const tbyte* pBlock);
    tint    FreeBlock(tbyte* pBlock);
};


class CVM_API MemoryPool
{
    typedef std::list<tbyte*> list_blocks;

    struct DeletePtr {
        template<class T>
        void operator () (T* p) const {
            ::delete[] p;
        }
    };

    list_blocks  mOutBlocks;                                                    
    MemoryBlocks mMemoryBlocks;                                                 

public:
    MemoryPool();
    ~MemoryPool();

    tbyte* Malloc(size_t nBytes) throw(cvmexception);
    tbyte* AddRef(const tbyte* pd);                                             
    tint   Free(tbyte*& pToFree) throw(cvmexception);                           

#ifdef CVM_DEBUG
    void Assert(const void* pvBlock, size_t nBytes) {                           
        mMemoryBlocks.Assert(pvBlock, nBytes);
    }
#endif
    void Clear();                                                               
};

CVM_API tbyte* _cvmMalloc(size_t nBytes) throw(cvmexception);
CVM_API tbyte* _cvmAddRef(const tbyte* pd);
CVM_API tint   _cvmFree(tbyte*& pd);

template<typename T>
inline T* cvmMalloc(size_t nEls) throw(cvmexception) {
    return reinterpret_cast<T*>(_cvmMalloc(nEls * sizeof(T)));
}

template<typename T>
inline T* cvmAddRef(const T* pd) {
    return reinterpret_cast<T*>(_cvmAddRef(reinterpret_cast<const tbyte*>(pd)));
}

template<typename T>
inline tint cvmFree(T*& pd) {
    return _cvmFree(reinterpret_cast<tbyte*&>(pd));
}

#else  // CVM_USE_POOL_MANAGER

template<typename T>
inline T* cvmMalloc(tint nEls) throw(cvmexception)
{
    _check_lt(CVM_WRONGSIZE_LT, nEls, TINT_ZERO);
    return nEls > 0 ? ::new T[nEls] : nullptr;
}

template<typename T>
inline tint cvmFree(T*& pd)
{
    if (pd != nullptr) {
        ::delete[] pd;
        pd = nullptr;
    }
    return 0;
}

#endif  // !CVM_USE_POOL_MANAGER

CVM_API void cvmExit();

template<typename T>
inline void cvmZeroMemory(T* p, tint nEls) {
    memset(p, 0, nEls * sizeof(T));
}

CVM_API void _cvm_assert(const void* pvBlock, size_t nBytes);

inline float _abs(const float& v) {
    return static_cast<float>(fabs(v));
}

inline double _abs(const double& v) {
    return fabs(v);
}

inline long double _abs(const long double& v) {
    return fabs(v);
}

inline float _abs(const std::complex<float>& v) {
    return static_cast<float>(sqrt(v.real() * v.real() + v.imag() * v.imag()));
}

inline double _abs(const std::complex<double>& v) {
    return sqrt(v.real() * v.real() + v.imag() * v.imag());
}

inline long double _abs(const std::complex<long double>& v) {
    return sqrt(v.real() * v.real() + v.imag() * v.imag());
}

inline tint _abs(const tint& v) {
    return v < 0 ? -v : v;
}

inline float _sqrt(const float& v) {
    return static_cast<float>(sqrt(v));
}

inline double _sqrt(const double& v) {
    return sqrt(v);
}

inline std::complex<float> _conjugate(const std::complex<float>& v) {
    return std::complex<float>(v.real(), -v.imag());
}

inline std::complex<double> _conjugate(const std::complex<double>& v) {
    return std::complex<double>(v.real(), -v.imag());
}

template<typename TR>
inline bool _conjugated(const std::complex<TR>& v1, const std::complex<TR>& v2, TR tol)
{
    return _abs(v1.real() - v2.real()) <= tol &&
           _abs(v1.imag() + v2.imag()) <= tol;
}


template<typename T, typename TR>
inline std::ostream& operator << (std::ostream& os, const type_proxy<T,TR>& mOut)
{
#if defined (_MSC_VER) && !defined (CVM_USES_STLPORT)
    os.imbue(std::locale::empty());
#endif
    os << static_cast<T>(mOut);
    return os;
}

template<typename T, typename TR>
inline std::istream& operator >> (std::istream& is, type_proxy<T,TR>& v)
{
#if defined (_MSC_VER) && !defined (CVM_USES_STLPORT)
    is.imbue(std::locale::empty());
#endif
    T t;
    is >> t;
    v = t;
    return is;
}

template<typename TR, typename TC>
std::istream& operator >> (std::istream& is, basic_array<TR,TC>& aIn)
{
#if !defined (CVM_USES_STLPORT) && defined (_MSC_VER)
    is.imbue(std::locale::empty());
#endif
    const tint nSize = aIn.size() * aIn.incr();
    CVM_ASSERT(aIn.get(), ((aIn.size() - 1) * aIn.incr() + 1) * sizeof(TC))
    for (tint i = 0; i < nSize && is.good(); i += aIn.incr()) {
        is >> aIn.get()[i];
    }
    return is;
}

template<typename TR, typename TC>
std::ostream& operator << (std::ostream& os, const basic_array<TR,TC>& aOut)
{
#if !defined (CVM_USES_STLPORT) && defined (_MSC_VER)
    os.imbue(std::locale::empty());
#endif
    const tint nSize = aOut.size() * aOut.incr();
    CVM_ASSERT(aOut.get(), ((aOut.size() - 1) * aOut.incr() + 1) * sizeof(TC))
    for (tint i = 0; i < nSize && os.good(); i += aOut.incr()) {
        os << aOut.get()[i] << CVM_MATRIX_ELEMENT_SEPARATOR;
    }
    os << CVM_EOL;
    return os;
}

template<typename TR, typename TC>
std::istream& operator >> (std::istream& is, Matrix<TR,TC>& mIn)
{
#if defined (_MSC_VER) && !defined (CVM_USES_STLPORT)
    is.imbue(std::locale::empty());
#endif
    TC v;
    for (tint i = 0; i < mIn.msize(); ++i) {
        for (tint j = 0; j < mIn.nsize() && is.good(); ++j) {
            is >> v;
            mIn._ij_proxy_val(i, j) = v;
        }
    }
    return is;
}

template<typename TR, typename TC>
std::ostream& operator << (std::ostream& os, const Matrix<TR,TC>& mOut)
{
#if defined (_MSC_VER) && !defined (CVM_USES_STLPORT)
    os.imbue(std::locale::empty());
#endif
    for (tint i = 0; i < mOut.msize(); ++i) {
        for (tint j = 0; j < mOut.nsize() && os.good(); ++j) {
            os << mOut._ij_val(i, j) << CVM_MATRIX_ELEMENT_SEPARATOR;
        }
        os << CVM_EOL;
    }
    return os;
}

template<typename TR, typename TC, typename RM, typename RBM>
inline void _copy_b_matrix(RM& m, RBM& mb, bool bLeftToRight)
{
    const tint nM = mb.msize();
    const tint nN = mb.nsize();
    const tint nKL = mb.lsize();
    const tint nKU = mb.usize();
    const tint nCol = 1 + nKL + nKU;
    tint nS, nShiftL, nShiftR;
    TC* pL;
    TC* pR;

    for (tint i = 0; i < nN; ++i) {
        nS = nCol;
        nShiftL = 0;
        nShiftR = 0;
        if (i < nKU) {
            nShiftR = nKU - i;
            nS -= nShiftR;
        } else {
            nShiftL = i - nKU;
        }
        if (nN - i <= nKL) {
            nS -= nKL + 1 - (nN - i);
        }

        pL = m.get() + i * nM + nShiftL;
        pR = mb._pb() + i * nCol + nShiftR;

        __copy<TC>(nS,
                   bLeftToRight ? pL : pR,
                   1,
                   bLeftToRight ? pR : pL,
                   1);
    }
}

// pd = p1 + p2
template<typename TR, typename TC>
inline void _sum(TC* pd, tint nSize, tint nIncr,
                 const TC* p1, tint nIncr1, const TC* p2, tint nIncr2)
{
    if (pd == p1) {
        if (pd == p2) {
            static const TR two(2.);
            __scal<TR,TC>(pd, nSize, nIncr, two);
        } else {
            __add<TC>(pd, nSize, nIncr, p2, nIncr2);
        }
    } else {
        if (pd == p2) {
            __add<TC>(pd, nSize, nIncr, p1, nIncr1);
        } else {
            __copy<TC>(nSize, p1, nIncr1, pd, nIncr);
            __add<TC>(pd, nSize, nIncr, p2, nIncr2);
        }
    }
}

// pd = p1 - p2
template<typename TR, typename TC>
inline void _diff(TC* pd, tint nSize, tint nIncr,
                  const TC* p1, tint nIncr1, const TC* p2, tint nIncr2)
{
    if (pd == p1) {
        if (pd == p2) {
            static const TR zero(0.);
            __scal<TR,TC>(pd, nSize, nIncr, zero);
        } else {
            __subtract<TC>(pd, nSize, nIncr, p2, nIncr2);
        }
    } else {
        if (pd == p2) {
            static const TR mone(-1.);
            __subtract<TC>(pd, nSize, nIncr, p1, nIncr1);
            __scal<TR,TC>(pd, nSize, nIncr, mone);
        } else {
            __copy<TC>(nSize, p1, nIncr1, pd, nIncr);
            __subtract<TC>(pd, nSize, nIncr, p2, nIncr2);
        }
    }
}

// pDm = pDm + pd
template<typename TR, typename TC>
inline void _incr(TC* pDm, tint mnSize, tint mnIncr, const TC* pd, tint nIncr)
{
    if (pDm == pd) {
        static const TR two(2.);
        __scal<TR,TC>(pDm, mnSize, mnIncr, two);
    } else {
        __add<TC>(pDm, mnSize, mnIncr, pd, nIncr);
    }
}

// pDm = pDm - pd
template<typename TR, typename TC>
inline void _decr(TC* pDm, tint mnSize, tint mnIncr, const TC* pd, tint nIncr)
{
    if (pDm == pd) {
        static const TR zero(0.);
        __scal<TR,TC>(pDm, mnSize, mnIncr, zero);
    } else {
        __subtract<TC>(pDm, mnSize, mnIncr, pd, nIncr);
    }
}

// fills real part
template<typename TR, typename TC>
void _set_real(TC* pDm, tint mnSize, tint mnIncr, TR d)
{
    const tint nIncr2 = 2 * mnIncr;
    const tint nSize = mnSize * nIncr2;
    TR* pd = __get_real_p<TR>(pDm);
    for (tint i = 0; i < nSize; i += nIncr2) {
        CVM_ASSERT(pd, (i + 1) * sizeof(TR))
        pd[i] = d;
    }
}

// fills imaginary part
template<typename TR, typename TC>
void _set_imag(TC* pDm, tint mnSize, tint mnIncr, TR d)
{
    const tint nIncr2 = 2 * mnIncr;
    const tint nSize = mnSize * nIncr2;
    TR* pd = __get_imag_p<TR>(pDm);
    for (tint i = 0; i < nSize; i += nIncr2) {
        CVM_ASSERT(pd, (i + 1) * sizeof(TR))
        pd[i] = d;
    }
}


template<typename T, typename TR>
class type_proxy
{
protected:
    T& mT; 
    bool mbReadOnly; 

public:
    type_proxy(T& ref, bool read_only)
      : mT(ref),
        mbReadOnly(read_only)
    {
    }

    type_proxy(const T& ref, bool read_only = true)
      : mT(const_cast<T&>(ref)),
        mbReadOnly(read_only)
    {
    }

    type_proxy(const type_proxy& p)
      : mT(p.mT),
        mbReadOnly(p.mbReadOnly)
    {
    }

    operator T() const {
        return mT;
    }

/*
    doesn't work - masks the operator above
    operator const T& () const
    {
        return mT;
    }

    operator T& ()
    {
        if (mbReadOnly) throw cvmexception (CVM_READ_ONLY_ACCESS);
        return mT;
    }
*/

    T val() const {
        return mT;
    }

    T& get() throw(cvmexception) {
        if (mbReadOnly) throw cvmexception(CVM_READ_ONLY_ACCESS);
        return mT;
    }

    const T& get() const {
        return mT;
    }

    type_proxy& operator = (const type_proxy& p)
    {
        mT = p.mT;
        mbReadOnly = p.mbReadOnly;
        return *this;
    }

    type_proxy& operator = (const T& v) throw(cvmexception)
    {
        if (mbReadOnly) throw cvmexception(CVM_READ_ONLY_ACCESS);
        mT = v;
        return *this;
    }

    T* operator &() throw(cvmexception)
    {
        if (mbReadOnly) throw cvmexception(CVM_READ_ONLY_ACCESS);
        return &mT;
    }

    const T* operator &() const {
        return &mT;
    }

    template<typename U>
    T& operator += (const U& u) throw(cvmexception)
    {
        if (mbReadOnly) throw cvmexception(CVM_READ_ONLY_ACCESS);
        mT += T(u);
        return mT;
    }

    template<typename U>
    T& operator -= (const U& u) throw(cvmexception)
    {
        if (mbReadOnly) throw cvmexception(CVM_READ_ONLY_ACCESS);
        mT -= T(u);
        return mT;
    }

    template<typename U>
    T& operator *= (const U& u) throw(cvmexception)
    {
        if (mbReadOnly) throw cvmexception(CVM_READ_ONLY_ACCESS);
        mT *= T(u);
        return mT;
    }

    template<typename U>
    T& operator /= (const U& u) throw(cvmexception)
    {
        if (mbReadOnly) throw cvmexception(CVM_READ_ONLY_ACCESS);
        mT /= T(u);
        return mT;
    }

    template<typename U>
    T operator + (const U& u) const {
        return mT + T(u);
    }

    template<typename U>
    T operator - (const U& u) const {
        return mT - T(u);
    }

    template<typename U>
    T operator * (const U& u) const {
        return mT * T(u);
    }

    template<typename U>
    T operator / (const U& u) const {
        return mT / T(u);
    }

    T operator + (const type_proxy<T,TR>& u) const {
        return mT + u.mT;
    }

    T operator - (const type_proxy<T,TR>& u) const {
        return mT - u.mT;
    }

    T operator * (const type_proxy<T,TR>& u) const {
        return mT * u.mT;
    }

    T operator / (const type_proxy<T,TR>& u) const {
        return mT / u.mT;
    }

    T operator - () const {
        return -mT;
    }

    TR real() const {
        return _real<T,TR>(mT);
    }

    TR imag() const {
        return _imag<T,TR>(mT);
    }
};

template<typename T, typename TR>
inline std::complex<TR> operator + (const std::complex<TR>& u, const type_proxy<T,TR>& p) {
    return u + p.val();
}

template<typename T, typename TR>
inline std::complex<TR> operator - (const std::complex<TR>& u, const type_proxy<T,TR>& p) {
    return u - p.val();
}

template<typename T, typename TR>
inline std::complex<TR> operator * (const std::complex<TR>& u, const type_proxy<T,TR>& p) {
    return u * p.val();
}

template<typename T, typename TR>
inline std::complex<TR> operator / (const std::complex<TR>& u, const type_proxy<T,TR>& p) {
    return u / p.val();
}

template<typename U, typename T, typename TR>
inline T operator + (U u, const type_proxy<T,TR>& p) {
    return T(u) + p.val();
}

template<typename U, typename T, typename TR>
inline T operator - (U u, const type_proxy<T,TR>& p) {
    return T(u) - p.val();
}

template<typename U, typename T, typename TR>
inline T operator * (U u, const type_proxy<T,TR>& p) {
    return T(u) * p.val();
}

template<typename U, typename T, typename TR>
inline T operator / (U u, const type_proxy<T,TR>& p) {
    return T(u) / p.val();
}


template<typename T>
class Randomizer
{
    T mMax; 
#if !defined(CVM_NO_DEFAULT_RANDOM_ENGINE_SUPPORTED)
    std::random_device mre; 
    std::uniform_int_distribution<int> mDist; 
#endif

    Randomizer() noexcept
#if defined(CVM_NO_DEFAULT_RANDOM_ENGINE_SUPPORTED)
        : mMax(static_cast<T>(RAND_MAX))
    {
        srand(static_cast<unsigned int>(time(nullptr)));
    }
#else
        : mMax(static_cast<T>((std::numeric_limits<int>::max)())),
          mre(),
          mDist(0, (std::numeric_limits<int>::max)())
    {
    }
#endif

    T _get(T dFrom, T dTo) noexcept
    {
        const T dMin = _cvm_min<T>(dFrom, dTo);
        const T dMax = _cvm_max<T>(dFrom, dTo);
#if defined(CVM_NO_DEFAULT_RANDOM_ENGINE_SUPPORTED)
        unsigned int nr = static_cast<unsigned int>(rand());
        return dMin + static_cast<T>(nr) * (dMax - dMin) / mMax;
#else
        return dMin + static_cast<T>(mDist(mre)) * (dMax - dMin) / mMax;
#endif
    }

public:
    ~Randomizer() noexcept
    {
    }

    static T get(T dFrom, T dTo) noexcept
    {
        static Randomizer r;
        return r._get(dFrom, dTo);
    }
};


template<typename TR, typename TC>
class basic_array
{
protected:
    tint msz; 
    tint mincr; 

#ifdef CVM_USE_POOL_MANAGER
    TC* mpd; 
#else
    std::shared_ptr<TC> mp; 
    TC* mpf; 
#endif

public:
    typedef TC value_type; 
    typedef value_type* pointer; 
    typedef value_type* iterator; 
    typedef const value_type* const_iterator; 
    typedef const value_type* const_pointer; 
    typedef value_type& reference; 
    typedef const value_type& const_reference; 
    typedef size_t size_type; 
    typedef ptrdiff_t difference_type; 
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator; 
    typedef std::reverse_iterator<iterator> reverse_iterator; 

    basic_array()
      : msz(0),
        mincr(0),
#ifdef CVM_USE_POOL_MANAGER
        mpd(nullptr)
#else
        mp(),
        mpf(nullptr)
#endif
    {
    }

    explicit basic_array(tint nSize, bool bZeroMemory = true)
      : msz(nSize), mincr(1),
#ifdef CVM_USE_POOL_MANAGER
        mpd(cvmMalloc<TC>(static_cast<size_t>(msz)))
#else
        mp(cvmMalloc<TC>(msz), ArrayDeleter<TC>()),
        mpf(nullptr)
#endif
    {
        CVM_ASSERT(this->get(), msz * sizeof(TC))
        if (bZeroMemory) cvmZeroMemory<TC>(this->get(), msz);
    }

    basic_array(TC* pd, tint nSize, tint nIncr = 1)
      : msz(nSize), mincr(nIncr),
#ifdef CVM_USE_POOL_MANAGER
        mpd(cvmAddRef<TC>(pd))
#else
        mp(),
        mpf(pd)
#endif
    {
        _check_le(CVM_WRONGSIZE_LE, msz, TINT_ZERO);
        CVM_ASSERT(this->get(), msz * sizeof(TC))
    }

    basic_array(const TC* pd, tint nSize, tint nIncr = 1)
      : msz(nSize), mincr(1),
#ifdef CVM_USE_POOL_MANAGER
        mpd(cvmMalloc<TC>(static_cast<size_t>(msz)))
#else
        mp(cvmMalloc<TC>(msz), ArrayDeleter<TC>()),
        mpf(nullptr)
#endif
    {
        _check_le(CVM_WRONGSIZE_LE, msz, TINT_ZERO);
        CVM_ASSERT(this->get(), msz * sizeof(TC))
        __copy<TC>(msz, pd, nIncr, this->get(), this->incr());
    }

    basic_array(const TC* begin, const TC* end)
      : msz(tint(end - begin)), mincr(1),
#ifdef CVM_USE_POOL_MANAGER
        mpd(cvmMalloc<TC>(static_cast<size_t>(msz)))
#else
        mp(cvmMalloc<TC>(msz), ArrayDeleter<TC>()),
        mpf(nullptr)
#endif
    {
        CVM_ASSERT(this->get(), msz * sizeof(TC))
        __copy<TC>(msz, begin, 1, this->get(), this->incr());
    }

    basic_array(const basic_array& a)
      : msz(a.msz), mincr(1),
#ifdef CVM_USE_POOL_MANAGER
        mpd(cvmMalloc<TC>(msz))
#else
        mp(cvmMalloc<TC>(msz), ArrayDeleter<TC>()),
        mpf(nullptr)
#endif
    {
        this->_assign(a.get(), a.incr());
        CVM_ASSERT(this->get(), msz * sizeof(TC))
    }

    basic_array(basic_array&& a) noexcept
      : msz(a.msz), mincr(a.mincr),
#ifdef CVM_USE_POOL_MANAGER
        mpd(nullptr)
#else
        mp(),
        mpf(nullptr)
#endif
    {
        _move(std::move(a));
        CVM_ASSERT(this->get(), msz * sizeof(TC))
    }

    basic_array& operator = (const basic_array& a) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, a.size(), this->size());
        this->_assign(a.get(), a.incr());
        return *this;
    }

    basic_array& operator = (basic_array&& a) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, a.size(), this->size());
        _move(std::move(a));
        CVM_ASSERT(this->get(), msz * sizeof(TC))
        return *this;
    }

    virtual ~basic_array()
    {
#ifdef CVM_USE_POOL_MANAGER
        cvmFree<TC>(mpd);
#endif
    }

    tint size() const {
        return msz;
    }

    TC* get()
    {
#ifdef CVM_USE_POOL_MANAGER
        return this->mpd;
#else
        // if foreign pointer is set, this is it, shared one otherwise
        return this->mpf == nullptr ? this->mp.get() : this->mpf;
#endif
    }

    const TC* get() const
    {
#ifdef CVM_USE_POOL_MANAGER
        return this->mpd;
#else
        // if foreign pointer is set, this is it, shared one otherwise
        return this->mpf == nullptr ? this->mp.get() : this->mpf;
#endif
    }

    operator TC* () {
        return this->get();
    }

    operator const TC* () const {
        return this->get();
    }

    TC& operator () (tint n) throw(cvmexception) {
        return this->at(static_cast<size_type>(n - CVM0));
    }

    TC operator () (tint n) const throw(cvmexception) {
        return this->at(static_cast<size_type>(n - CVM0));
    }

    TC& operator [] (tint n) throw(cvmexception) {
        return this->at(static_cast<size_type>(n - CVM0));
    }

    TC operator [] (tint n) const throw(cvmexception) {
        return this->at(static_cast<size_type>(n - CVM0));
    }

    basic_array& assign(const TC* p)
    {
        this->_assign(p, 1);
        return *this;
    }

    basic_array& set(TC x)
    {
        this->_set(x);
        return *this;
    }

    basic_array& resize(tint nNewSize) throw(cvmexception)
    {
        this->_resize(nNewSize);
        return *this;
    }


    tint incr() const {
        return mincr;
    }

    tint indofmax() const {
        return this->_indofmax();
    }

    tint indofmin() const {
        return this->_indofmin();
    }

    virtual TR norm() const {
        return __norm<TR,TC>(this->get(), this->size(), this->incr());
    }

    virtual TR norminf() const
    {
        CVM_ASSERT(this->get(), ((this->_indofmax() - CVM0) * this->incr() + CVM0) * sizeof(TC))
        return _abs(this->get()[(this->_indofmax() - CVM0) * this->incr()]);
    }

    virtual TR norm1() const
    {
        TR dNorm(0);
        const tint nSize = this->size() * this->incr();
        for (tint i = 0; i < nSize; i += this->incr()) {
            dNorm += _abs(this->get()[i]);
        }
        return dNorm;
    }

    virtual TR norm2() const
    {
        return this->norm();
    }

    const tint* _pincr() const {
        return &this->mincr;
    }

    const tint* _psize() const {
        return &this->msz;
    }

    // this = this / d for real only
    void _div(TR d) throw(cvmexception)
    {
        static const TR one(1.);
        if (_abs(d) <= basic_cvmMachMin<TR>()) {
            throw cvmexception(CVM_DIVISIONBYZERO);
        }
        this->_scalr(one / d);
    }

    // "native pointer": to be redefined in classes with non-traditional storage, like band matrices etc.
    virtual TC* _pd() {
        return this->get();
    }

    // "native pointer": to be redefined in classes with non-traditional storage, like band matrices etc.
    virtual const TC* _pd() const {
        return this->get();
    }

    iterator       begin()        { return this->get();}
    const_iterator begin() const  { return this->get();}
    iterator       end()          { return this->get() + this->size();}
    const_iterator end()   const  { return this->get() + this->size();}

    reverse_iterator rbegin()             { return reverse_iterator(end());}
    const_reverse_iterator rbegin() const { return const_reverse_iterator(end());}
    reverse_iterator rend()               { return reverse_iterator(begin());}
    const_reverse_iterator rend()   const { return const_reverse_iterator(begin());}

    size_type max_size() const    { return size_type(-1) / sizeof(TC);}
    size_type capacity() const    { return static_cast<size_type>(this->size());}
    bool empty() const            { return this->size() > 0;}

    reference front()             { return *begin();}
    const_reference front() const { return *begin();}
    reference back()              { return *(end() - 1);}
    const_reference back()  const { return *(end() - 1);}

//    deprecated since 5.4.2 due to its incosistency with STL counterpart
//
//    void reserve (size_type n) throw (cvmexception)
//    {
//        this->_resize(tint(n));
//    }

    void assign(size_type n, const TC& val) throw(cvmexception)
    {
        _check_gt(CVM_INDEX_GT, n, static_cast<size_type>(this->size()));
        CVM_ASSERT(this->get(), this->size() * sizeof(TC))
        for (tint i = 0; i < (tint)n; ++i) {
            this->get()[i] = val;
        }
    }

    void assign(const_iterator begin, const_iterator end) throw(cvmexception)
    {
        const tint n = end - begin;
        _check_gt(CVM_INDEX_GT, n, this->size());
        CVM_ASSERT(this->get(), this->size() * sizeof(TC))
        for (tint i = 0; i < n; ++i) {
            this->get()[i] = *(begin + i);
        }
    }

    void clear() {
        this->_resize(0);
    }

    void swap(basic_array& v) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v.size(), this->size());
        __swap<TC>(this->size(), this->get(), this->incr(), v.get(), v.incr());
    }

    reference at(size_type n) throw(cvmexception)
    {
        _check_ge(CVM_INDEX_GE, n, static_cast<size_type>(this->size()));
        CVM_ASSERT(this->get(), (n + 1) * sizeof(TC))
        return this->get()[n * this->incr()];
    }

    const_reference at(size_type n) const throw(cvmexception)
    {
        _check_ge(CVM_INDEX_GE, n, static_cast<size_type>(this->size()));
        CVM_ASSERT(this->get(), (n + 1) * sizeof(TC))
        return this->get()[n * this->incr()];
    }

    void push_back(const TC& x) throw(cvmexception)
    {
        this->_resize(this->size() + 1);
        this->get()[this->size() - 1] = x;
    }

    void pop_back() throw(cvmexception) {
        if (this->size() > 0) this->_resize(this->size() - 1);
    }

    iterator insert(iterator position, const TC& x) throw(cvmexception)
    {
        const tint n = tint(position - this->begin());
        _check_lt_gt(CVM_OUTOFRANGE_LTGT, n, TINT_ZERO, this->size());
        CVM_ASSERT(this->get(), this->size() * sizeof(TC))
        this->_resize(this->size() + 1);
        for (tint i = this->size() - 1; i > n; --i) {
            this->get()[i] = this->get()[i - 1];
        }
        this->get()[n] = x;
        return iterator(this->get() + n);
    }

    iterator erase(iterator position) throw(cvmexception)
    {
        const tint n = tint(position - this->begin());
        _check_lt_gt(CVM_OUTOFRANGE_LTGT, n, TINT_ZERO, this->size());

        CVM_ASSERT(this->get(), this->size() * sizeof(TC))
        for (tint i = n; i < this->size() - 1; ++i) {
            this->get()[i] = this->get()[i + 1];
        }
        if (this->size() > 0) this->_resize(this->size() - 1);
        return iterator(this->get() + n);
    }

protected:
    // internal protected constructor to be used in Matrix
    basic_array(tint sz, tint incr) noexcept
      : msz(sz), mincr(incr),
#ifdef CVM_USE_POOL_MANAGER
        mpd(nullptr)
#else
        mp(),
        mpf(nullptr)
#endif
    {
    }

    void _move(basic_array&& a) noexcept
    {
#ifdef CVM_USE_POOL_MANAGER
        mpd = a.mpd;
        a.mpd = nullptr;
#else
        if (a.mpf == nullptr) {
            if (mpf == nullptr) {
                mp = std::move(a.mp);
                a.msz = 0;
            } else {
                // *this has foreign array inside, no place to move to
                // so, this is the case where we don't even touch a, just copy its content
                this->_assign(a.mp.get(), a.incr());
            }
        } else {
            // ... and here we can't rely on foreign poiter life cycle, thus copying
            this->_resize(a.size());
            this->_assign(a.mpf, a.incr());
            //a.mpf = nullptr;
            //a.msz = 0;
        }
#endif
    }

    // compares array elements
    bool _equals(const basic_array& a) const
    {
        bool bRes = false;
        if (this->size() == a.size()) {
            bRes = true;
            if (this->get() != a.get()) {
                for (tint i = 0; i < this->size(); ++i) {
                    if (_abs(this->get()[i * this->incr()] - a.get()[i * a.incr()]) > basic_cvmMachMin<TR>()) {
                        bRes = false;
                        break;
                    }
                }
            }
        }
        return bRes;
    }

    // array normalizing
    void _normalize()
    {
        const TR dNorm = this->norm();
        if (dNorm > basic_cvmMachMin<TR>()) {
            static const TR one(1.);
            this->_scalr(one / dNorm);
        }
    }

    // this = a (no matter what)
    void _replace(const basic_array& a) throw(cvmexception)
    {
#ifdef CVM_USE_POOL_MANAGER
        cvmFree<TC>(this->mpd);
        this->mpd = cvmMalloc<TC>(a.size());
#else
        this->mp.reset(cvmMalloc<TC>(a.size()), ArrayDeleter<TC>());
        this->mpf = nullptr;
#endif
        this->msz = a.size();
        this->mincr = 1;
        CVM_ASSERT(this->get(), ((this->size() - 1) * this->incr() + 1) * sizeof(TC))
    }

    void _resize(tint nNewSize) throw(cvmexception)
    {
        _check_lt(CVM_WRONGSIZE_LT, nNewSize, TINT_ZERO);
        const bool is_empty = this->_is_empty();
        if (nNewSize != this->size() || is_empty) {
            TC* pd = cvmMalloc<TC>(nNewSize);
            if (nNewSize > this->size()) cvmZeroMemory<TC>(pd, nNewSize);
            const tint nMinSize = _cvm_min<tint>(nNewSize, this->size());
            if (nMinSize > 0 && !is_empty) {
                __copy<TC>(nMinSize, this->get(), this->incr(), pd, 1);
            }
#ifdef CVM_USE_POOL_MANAGER
            cvmFree<TC>(this->mpd);
            this->mpd = pd;
#else
            this->mp.reset(pd, ArrayDeleter<TC>());
            this->mpf = nullptr;
#endif
            this->msz = nNewSize;
            this->mincr = 1;
            CVM_ASSERT(this->get(), ((this->size() - 1) * this->incr() + 1) * sizeof(TC))
        }
    }

    bool _is_empty() const
    {
#ifdef CVM_USE_POOL_MANAGER
            return this->mpd == nullptr;
#else
            return this->mpf == nullptr && this->mp.get() == nullptr;
#endif
    }

    // virtual methods
    virtual void _scalr(TR d) {
        __scal<TR,TC>(this->get(), this->size(), this->incr(), d);
    }

    // index of max module, undefined for matrices, CVM0-based
    virtual tint _indofmax() const {
        return __idamax<TC>(this->get(), this->size(), this->incr());
    }

    // index of min module, undefined for matrices, CVM0-based
    virtual tint _indofmin() const {
        return __idamin<TC>(this->get(), this->size(), this->incr());
    }

    // fills the content
    virtual void _set(TC d)
    {
        CVM_ASSERT(this->get(), ((this->size() - 1) * this->incr() + 1) * sizeof(TC))
        const tint nSize = this->size() * this->incr();
        for (tint i = 0; i < nSize; i += this->incr()) {
            this->get()[i] = d;
        }
    }

    virtual void _assign(const TC* pd, tint nIncr)
    {
        if (this->get() != pd) {
            __copy<TC>(this->size(), pd, nIncr, this->get(), this->incr());
        }
    }

    virtual void _assign_shifted(TC* pDshifted, const TC* pd, tint nSize, tint nIncr, tint)
    {
        if (pDshifted != pd) {
            __copy<TC>(nSize, pd, nIncr, pDshifted, this->incr());
        }
    }

    friend std::istream& operator >> <> (std::istream& is, basic_array& aIn);

    friend std::ostream& operator << <> (std::ostream& os, const basic_array& aOut);
};


template<typename TR>
class basic_rvector : public basic_array<TR,TR>
{
    typedef std::complex<TR> TC; 
    typedef basic_array<TR,TR> BaseArray; 

public:
    basic_rvector()
    {
    }

    explicit basic_rvector(tint nSize)
      : BaseArray(nSize)
    {
    }

#if defined(CVM_USE_INITIALIZER_LISTS)

    basic_rvector(std::initializer_list<TR> list)
      : BaseArray(static_cast<tint>(list.size()))
    {
        tint i = 0;
        TR* p = this->mp.get();
        for (auto it = list.begin(); it != list.end(); ++it) {
            p[i++] = *it;
        }
    }
#endif

    basic_rvector(tint nSize, TR d)
      : BaseArray(nSize, false)
    {
        this->_set(d);
    }

    basic_rvector(TR* pd, tint nSize, tint nIncr = 1)
      : BaseArray(pd, nSize, nIncr)
    {
    }

    basic_rvector(const TR* pd, tint nSize, tint nIncr = 1)
      : BaseArray(pd, nSize, nIncr)
    {
    }


    basic_rvector(const basic_rvector& v)
      : BaseArray(v.size(), false)
    {
        __copy<TR>(this->size(), v, v.incr(), this->get(), this->incr());
    }

    basic_rvector(basic_rvector&& a) noexcept
      : BaseArray(std::move(a))
    {
    }

    basic_rvector& operator = (const basic_rvector& v) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v.size(), this->size());
        this->_assign(v, v.incr());
        return *this;
    }

    basic_rvector& operator = (basic_rvector&& a) throw(cvmexception)
    {
        // size check is in BasicArray
        BaseArray::operator = (std::move(a));
        return *this;
    }

    basic_rvector& assign(const TR* pd, tint nIncr = 1)
    {
        this->_assign(pd, nIncr);
        return *this;
    }

    basic_rvector& assign(tint n, const TR* pd, tint nIncr = 1)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, n, CVM0, this->size() + CVM0);
        n -= CVM0;
        this->_assign_shifted(this->get() + this->incr() * n, pd, this->size() - n, nIncr, 0);
        return *this;
    }

    basic_rvector& assign(tint n, const TR* pd, tint nSize, tint nIncr)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, n, CVM0, this->size() + CVM0);
        n -= CVM0;
        this->_assign_shifted(this->get() + this->incr() * n, pd, _cvm_min<tint>(nSize, this->size() - n), nIncr, 0);
        return *this;
    }

    basic_rvector& assign(tint n, const basic_rvector& v) throw(cvmexception)
    {
        _check_gt(CVM_SIZESMISMATCH_GT, v.size() + n, this->size());
        return assign(n, v, v.size(), v.incr());
    }

    basic_rvector& set(TR d)
    {
        this->_set(d);
        return *this;
    }

    basic_rvector& resize(tint nNewSize) throw(cvmexception)
    {
        this->_resize(nNewSize);
        return *this;
    }

    bool operator == (const basic_rvector& v) const {
        return this->_equals(v);
    }

    bool operator != (const basic_rvector& v) const {
        return !(this->operator == (v));
    }

    basic_rvector& operator << (const basic_rvector& v) throw(cvmexception)
    {
        this->_replace(v);
        __copy<TR>(this->size(), v.get(), v.incr(), this->get(), this->incr());
        return *this;
    }

    basic_rvector operator + (const basic_rvector& v) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v.size(), this->size());
        basic_rvector vSum(*this);
        __add<TR>(vSum.get(), vSum.size(), vSum.incr(), v._pd(), v.incr());
        return vSum;
    }

    basic_rvector operator - (const basic_rvector& v) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v.size(), this->size());
        basic_rvector vDiff(*this);
        __subtract<TR>(vDiff.get(), vDiff.size(), vDiff.incr(), v._pd(), v.incr());
        return vDiff;
    }

    basic_rvector& sum(const basic_rvector& v1, const basic_rvector& v2) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v1.size(), this->size());
        _check_ne(CVM_SIZESMISMATCH, v2.size(), this->size());
        _sum<TR,TR>(this->get(), this->size(), this->incr(), v1, v1.incr(), v2, v2.incr());
        return *this;
    }

    basic_rvector& diff(const basic_rvector& v1, const basic_rvector& v2) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v1.size(), this->size());
        _check_ne(CVM_SIZESMISMATCH, v2.size(), this->size());
        _diff<TR,TR>(this->get(), this->size(), this->incr(), v1, v1.incr(), v2, v2.incr());
        return *this;
    }

    basic_rvector& operator += (const basic_rvector& v) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v.size(), this->size());
        _incr<TR,TR>(this->get(), this->size(), this->incr(), v, v.incr());
        return *this;
    }

    basic_rvector& operator -= (const basic_rvector& v) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v.size(), this->size());
        _decr<TR,TR>(this->get(), this->size(), this->incr(), v, v.incr());
        return *this;
    }

    basic_rvector operator - () const throw(cvmexception)
    {
        static const TR mone(-1.);
        basic_rvector vRes(*this);
        vRes._scalr(mone);
        return vRes;
    }

    basic_rvector operator * (TR dMult) const throw(cvmexception)
    {
        basic_rvector vRes(*this);
        vRes._scalr(dMult);
        return vRes;
    }

    basic_rvector operator / (TR dDiv) const throw(cvmexception)
    {
        basic_rvector vRes(*this);
        vRes._div(dDiv);
        return vRes;
    }

    basic_rvector& operator *= (TR dMult)
    {
        this->_scalr(dMult);
        return *this;
    }

    basic_rvector& operator /= (TR dDiv) throw(cvmexception)
    {
        this->_div(dDiv);
        return *this;
    }

    basic_rvector& normalize()
    {
        this->_normalize();
        return *this;
    }

    TR operator * (const basic_rvector& v) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v.size(), this->size());
        return __dot<TR>(this->get(), this->size(), this->incr(), v.get(), v.incr());
    }

    basic_rvector operator * (const basic_rmatrix<TR>& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, m.msize(), this->size());
        basic_rvector vRes(m.nsize());
        m._multiply(vRes, *this, true);
        return vRes;
    }

    basic_rvector& mult(const basic_rvector& v, const basic_rmatrix<TR>& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, m.nsize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, m.msize(), v.size());
        m._multiply(*this, v, true);
        return *this;
    }

    basic_rvector& mult(const basic_rmatrix<TR>& m, const basic_rvector& v) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, m.msize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, m.nsize(), v.size());
        m._multiply(*this, v, false);
        return *this;
    }

    basic_rmatrix<TR> rank1update(const basic_rvector& v) const
    {
        basic_rmatrix<TR> mRes(this->size(), v.size());
        static const TR one(1.);
        __ger<TR,basic_rmatrix<TR>, basic_rvector>(mRes, *this, v, one);
        return mRes;
    }

    basic_rvector& solve(const basic_srmatrix<TR>& mA, const basic_rvector& vB, TR& dErr) throw(cvmexception) {
        return _solve_helper(mA, vB, dErr, 0);
    }

// 6.1: transpose added
    basic_rvector& solve_tran(const basic_srmatrix<TR>& mA, const basic_rvector& vB, TR& dErr) throw(cvmexception) {
        return _solve_helper(mA, vB, dErr, 1);
    }

    basic_rvector& solve(const basic_srmatrix<TR>& mA, const basic_rvector& vB) throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve(mA, vB, dErr);
    }

// 6.1: transpose added
    basic_rvector& solve_tran(const basic_srmatrix<TR>& mA, const basic_rvector& vB) throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_tran(mA, vB, dErr);
    }

// 6.1: MATLAB-style operator B/A returning solution of X*A=B equation
    basic_rvector operator / (const basic_srmatrix<TR>& mA) const throw(cvmexception) {
        return _operator_solve_helper(mA, 1);
    }

    // 6.1: similar to operator / this one returns solution of A*X=B equation
    basic_rvector operator % (const basic_srmatrix<TR>& mA) const throw(cvmexception) {
        return _operator_solve_helper(mA, 0);
    }

    basic_rvector& solve_lu(const basic_srmatrix<TR>& mA, const basic_srmatrix<TR>& mLU, const tint* pPivots,
                            const basic_rvector& vB, TR& dErr) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, mA.msize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, mA.msize(), vB.size());
        _check_ne(CVM_SIZESMISMATCH, mA.msize(), mLU.msize());
        mA._solve(vB, *this, dErr, mLU, pPivots, 0);
        return *this;
    }

    basic_rvector& solve_lu(const basic_srmatrix<TR>& mA, const basic_srmatrix<TR>& mLU, const tint* pPivots,
                            const basic_rvector& vB) throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_lu(mA, mLU, pPivots, vB, dErr);
    }

    basic_rvector& gels(bool transpose, const basic_rmatrix<TR>& mA, const basic_rvector& vB,
                        TR& dErr) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, vB.size(), transpose ? mA.nsize() : mA.msize());
        _check_ne(CVM_SIZESMISMATCH, this->size(), transpose ? mA.msize() : mA.nsize());
        basic_rmatrix<TR> mA2(mA); // this algorithm overrides A
        basic_rmatrix<TR> mB(vB, vB.size(), 1);
        basic_rmatrix<TR> mX;
        basic_rvector vErr(1);
        __gels(transpose, mA2, mB, mX, vErr);
        dErr = vErr(CVM0);
        *this = mX(CVM0);
        return *this;
    }

    basic_rvector& gelsy(const basic_rmatrix<TR>& mA, const basic_rvector& vB, tint& rank,
                         TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, vB.size(), mA.msize());
        _check_ne(CVM_SIZESMISMATCH, this->size(), mA.nsize());
        basic_rmatrix<TR> mA2(mA); // this algorithm overrides A
        basic_rmatrix<TR> mB(vB, vB.size(), 1);
        basic_rmatrix<TR> mX;
        __gelsy(mA2, mB, mX, tol, rank);
        *this = mX(CVM0);
        return *this;
    }

    basic_rvector& gelss(const basic_rmatrix<TR>& mA, const basic_rvector& vB, basic_rvector<TR>& sv,
                         tint& rank, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        _gels_sd(true, mA, vB, sv, rank, tol);
        return *this;
    }

    basic_rvector& gelsd(const basic_rmatrix<TR>& mA, const basic_rvector& vB, basic_rvector<TR>& sv,
                         tint& rank, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        _gels_sd(false, mA, vB, sv, rank, tol);
        return *this;
    }

    basic_rvector& svd(const basic_rmatrix<TR>& mA) throw(cvmexception)
    {
        mA._svd(*this, nullptr, nullptr);
        return *this;
    }

    basic_rvector& svd(const basic_cmatrix<TR,TC>& mA) throw(cvmexception)
    {
        mA._svd(*this, nullptr, nullptr);
        return *this;
    }

    basic_rvector& svd(const basic_rmatrix<TR>& mA, basic_srmatrix<TR>& mU,
                       basic_srmatrix<TR>& mVH) throw(cvmexception)
    {
        mA._svd(*this, &mU, &mVH);
        return *this;
    }

    basic_rvector& svd(const basic_cmatrix<TR,TC>& mA, basic_scmatrix<TR,TC>& mU,
                       basic_scmatrix<TR,TC>& mVH) throw(cvmexception)
    {
        mA._svd(*this, &mU, &mVH);
        return *this;
    }

// we don't use _eig here since this is the special case - symmetric matrix
    basic_rvector& eig(const basic_srsmatrix<TR>& mA) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->size(), mA.nsize());
        __eig<basic_rvector, basic_srsmatrix<TR>, basic_srmatrix<TR> >(*this, mA, nullptr, true);
        return *this;
    }

    basic_rvector& eig(const basic_srsmatrix<TR>& mA, basic_srmatrix<TR>& mEigVect) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->size(), mA.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->size(), mEigVect.nsize());
        __eig<basic_rvector, basic_srsmatrix<TR>, basic_srmatrix<TR> >(*this, mA, &mEigVect, true);
        return *this;
    }

// we don't use _eig here since this is the special case - hermitian matrix
    basic_rvector& eig(const basic_schmatrix<TR,TC>& mA) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->size(), mA.nsize());
        __eig<basic_rvector, basic_schmatrix<TR,TC>, basic_scmatrix<TR,TC> >(*this, mA, nullptr, true);
        return *this;
    }

    basic_rvector& eig(const basic_schmatrix<TR,TC>& mA, basic_scmatrix<TR,TC>& mEigVect) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->size(), mA.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->size(), mEigVect.nsize());
        __eig<basic_rvector, basic_schmatrix<TR,TC>, basic_scmatrix<TR,TC> >(*this, mA, &mEigVect, true);
        return *this;
    }

// ?gemv routines perform a matrix-vector operation defined as
// this = alpha*m*v + beta * this,
    basic_rvector& gemv(bool bLeft, const basic_rmatrix<TR>& m, TR dAlpha, const basic_rvector& v, TR dBeta) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->size(), bLeft ? m.nsize() : m.msize());
        _check_ne(CVM_SIZESMISMATCH, v.size(), bLeft ? m.msize() : m.nsize());
        m._gemv(bLeft, dAlpha, v, dBeta, *this);
        return *this;
    }

    basic_rvector& gbmv(bool bLeft, const basic_srbmatrix<TR>& m, TR dAlpha, const basic_rvector& v, TR dBeta) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->size(), bLeft ? m.nsize() : m.msize());
        _check_ne(CVM_SIZESMISMATCH, v.size(), bLeft ? m.msize() : m.nsize());
        m._gbmv(bLeft, dAlpha, v, dBeta, *this);
        return *this;
    }

    basic_rvector& randomize(TR dFrom, TR dTo)
    {
        __randomize<TR>(this->get(), this->size(), this->incr(), dFrom, dTo);
        return *this;
    }

private:
    basic_rvector& _solve_helper(const basic_srmatrix<TR>& mA, const basic_rvector& vB,
                                 TR& dErr, int transp_mode) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->size(), mA.msize());
        _check_ne(CVM_SIZESMISMATCH, vB.size(), mA.msize());
        mA._solve(vB, *this, dErr, nullptr, nullptr, transp_mode);
        return *this;
    }

    basic_rvector _operator_solve_helper(const basic_srmatrix<TR>& mA, int transp_mode) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->size(), mA.msize());
        static TR dErr(0.);
        basic_rvector vX(this->size());
        mA._solve(*this, vX, dErr, nullptr, nullptr, transp_mode);
        return vX;
    }

    // helper for svd and divide&conquer methods
    void _gels_sd(bool svd, const basic_rmatrix<TR>& mA, const basic_rvector& vB,
                  basic_rvector<TR>& sv, tint& rank, TR tol) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->size(), mA.nsize());
        _check_ne(CVM_SIZESMISMATCH, vB.size(), mA.msize());
        _check_ne(CVM_SIZESMISMATCH, sv.size(), _cvm_min<tint>(mA.msize(), mA.nsize()));
        basic_rmatrix<TR> mA2(mA); // this algorithm overrides A
        basic_rmatrix<TR> mB(vB, vB.size(), 1);
        basic_rmatrix<TR> mX;
        basic_rvector<TR> sv1(sv.size()); // to ensure that incr=1
        if (svd) {
            __gelss(mA2, mB, mX, tol, sv1, rank);
        } else {
            __gelsd(mA2, mB, mX, tol, sv1, rank);
        }
        sv = sv1;
        *this = mX(CVM0);
    }
};


template<typename TR, typename TC>
class basic_cvector : public basic_array<TR,TC>
{
    typedef basic_array<TR,TC> BaseArray; 

public:
    basic_cvector()
    {
    }

    explicit basic_cvector(tint nSize)
      : BaseArray(nSize)
    {
    }

#if defined(CVM_USE_INITIALIZER_LISTS)

    basic_cvector(std::initializer_list<TC> list)
      : BaseArray(static_cast<tint>(list.size()))
    {
        tint i = 0;
        TC* p = this->mp.get();
        for (auto it = list.begin(); it != list.end(); ++it) {
            p[i++] = *it;
        }
    }
#endif

    basic_cvector(tint nSize, TC c)
      : BaseArray(nSize, false)
    {
        this->_set(c);
    }

    basic_cvector(TC* pd, tint nSize, tint nIncr = 1)
      : BaseArray(pd, nSize, nIncr)
    {
    }

    basic_cvector(const TC* pd, tint nSize, tint nIncr = 1)
      : BaseArray(pd, nSize, nIncr)
    {
    }

    basic_cvector(const basic_cvector& v)
      : BaseArray(v.size(), false)
    {
        __copy<TC>(this->size(), v, v.incr(), this->get(), this->incr());
    }

    basic_cvector(basic_cvector&& a) noexcept
      : BaseArray(std::move(a))
    {
    }

    basic_cvector(const TR* pRe, const TR* pIm, tint nSize, tint nIncrRe = 1, tint nIncrIm = 1)
      : BaseArray(nSize, pRe == nullptr || pIm == nullptr)
    {
        __copy2<TR,TC>(this->get(), this->size(), this->incr(), pRe, pIm, nIncrRe, nIncrIm);
    }

    basic_cvector(const basic_rvector<TR>& vRe, const basic_rvector<TR>& vIm)
      : BaseArray(vRe.size(), false)
    {
        _check_ne(CVM_SIZESMISMATCH, vRe.size(), vIm.size());
        __copy2<TR,TC>(this->get(), this->size(), this->incr(), vRe, vIm, vRe.incr(), vIm.incr());
    }

    basic_cvector(const TR* pA, tint nSize, bool bRealPart = true, tint nIncr = 1)
      : BaseArray(nSize)
    {
        if (bRealPart) __copy2<TR,TC>(this->get(), this->size(), this->incr(), pA, nullptr, nIncr, 0);
        else __copy2<TR,TC>(this->get(), this->size(), this->incr(), nullptr, pA, 0, nIncr);
    }

    explicit basic_cvector(const basic_rvector<TR>& v, bool bRealPart = true)
      : BaseArray(v.size())
    {
        if (bRealPart) __copy2<TR,TC>(this->get(), this->size(), this->incr(), v, nullptr, v.incr(), 0);
        else __copy2<TR,TC>(this->get(), this->size(), this->incr(), nullptr, v, 0, v.incr());
    }

    basic_rvector<TR> real() {
        return basic_rvector<TR>(__get_real_p<TR>(this->get()), this->size(), this->incr() * 2);
    }

    basic_rvector<TR> imag() {
        return basic_rvector<TR>(__get_imag_p<TR>(this->get()), this->size(), this->incr() * 2);
    }

    basic_cvector& operator = (const basic_cvector& v) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->size(), v.size());
        this->_assign(v, v.incr());
        return *this;
    }

    basic_cvector& operator = (basic_cvector&& a) throw(cvmexception)
    {
        // size check is in BasicArray
        BaseArray::operator = (std::move(a));
        return *this;
    }

    basic_cvector& assign(const TC* pd, tint nIncr = 1)
    {
        this->_assign(pd, nIncr);
        return *this;
    }

    basic_cvector& assign(tint n, const TC* pd, tint nIncr = 1)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, n, CVM0, this->size() + CVM0);
        n -= CVM0;
        this->_assign_shifted(this->get() + this->incr() * n, pd, this->size() - n, nIncr, 0);
        return *this;
    }

    basic_cvector& assign(tint n, const TC* pd, tint nSize, tint nIncr)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, n, CVM0, this->size() + CVM0);
        n -= CVM0;
        this->_assign_shifted(this->get() + this->incr() * n, pd, _cvm_min<tint>(nSize, this->size() - n), nIncr, 0);
        return *this;
    }

    basic_cvector& assign(tint n, const basic_cvector& v) throw(cvmexception)
    {
        _check_gt(CVM_SIZESMISMATCH_GT, v.size() + n, this->size());
        return assign(n, v, v.size(), v.incr());
    }

    basic_cvector& set(TC c)
    {
        this->_set(c);
        return *this;
    }

    basic_cvector& assign_real(const basic_rvector<TR>& vRe) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, vRe.size(), this->size());
        __copy_real<TR,TC>(this->get(), this->size(), this->incr(), vRe, vRe.incr());
        return *this;
    }

    basic_cvector& assign_imag(const basic_rvector<TR>& vIm) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, vIm.size(), this->size());
        __copy_imag<TR,TC>(this->get(), this->size(), this->incr(), vIm, vIm.incr());
        return *this;
    }

    basic_cvector& set_real(TR d)
    {
        this->_set_real_number(d);
        return *this;
    }

    basic_cvector& set_imag(TR d)
    {
        this->_set_imag_number(d);
        return *this;
    }

    basic_cvector& resize(tint nNewSize) throw(cvmexception)
    {
        this->_resize(nNewSize);
        return *this;
    }

    bool operator == (const basic_cvector& v) const {
        return this->_equals(v);
    }

    bool operator != (const basic_cvector& v) const {
        return !(this->operator == (v));
    }

    basic_cvector& operator << (const basic_cvector& v) throw(cvmexception)
    {
        this->_replace(v);
        __copy<TC>(this->size(), v.get(), v.incr(), this->get(), this->incr());
        return *this;
    }

    basic_cvector operator + (const basic_cvector& v) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v.size(), this->size());
        basic_cvector vSum(*this);
        __add<TC>(vSum.get(), vSum.size(), vSum.incr(), v._pd(), v.incr());
        return vSum;
    }

    basic_cvector operator - (const basic_cvector& v) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v.size(), this->size());
        basic_cvector vDiff(*this);
        __subtract<TC>(vDiff.get(), vDiff.size(), vDiff.incr(), v._pd(), v.incr());
        return vDiff;
    }

    basic_cvector& sum(const basic_cvector& v1, const basic_cvector& v2) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v1.size(), this->size());
        _check_ne(CVM_SIZESMISMATCH, v2.size(), this->size());
        _sum<TR,TC>(this->get(), this->size(), this->incr(), v1, v1.incr(), v2, v2.incr());
        return *this;
    }

    basic_cvector& diff(const basic_cvector& v1, const basic_cvector& v2) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v1.size(), this->size());
        _check_ne(CVM_SIZESMISMATCH, v2.size(), this->size());
        _diff<TR,TC>(this->get(), this->size(), this->incr(), v1, v1.incr(), v2, v2.incr());
        return *this;
    }

    basic_cvector& operator += (const basic_cvector& v) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v.size(), this->size());
        _incr<TR,TC>(this->get(), this->size(), this->incr(), v, v.incr());
        return *this;
    }

    basic_cvector& operator -= (const basic_cvector& v) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v.size(), this->size());
        _decr<TR,TC>(this->get(), this->size(), this->incr(), v, v.incr());
        return *this;
    }

    basic_cvector operator - () const throw(cvmexception)
    {
        static const TR mone(-1.);
        basic_cvector vRes(*this);
        vRes._scalr(mone);
        return vRes;
    }

    basic_cvector operator * (TR dMult) const
    {
        basic_cvector vRes(*this);
        vRes._scalr(dMult);
        return vRes;
    }

    basic_cvector operator / (TR dDiv) const throw(cvmexception)
    {
        basic_cvector vRes(*this);
        vRes._div(dDiv);
        return vRes;
    }

    basic_cvector operator * (TC cMult) const
    {
        basic_cvector vRes(*this);
        vRes._scalc(cMult);
        return vRes;
    }

    basic_cvector operator / (TC cDiv) const throw(cvmexception)
    {
        basic_cvector vRes(*this);
        vRes._div(cDiv);
        return vRes;
    }

    basic_cvector& operator *= (TR dMult)
    {
        this->_scalr(dMult);
        return *this;
    }

    basic_cvector& operator /= (TR dDiv)
    {
        this->_div(dDiv);
        return *this;
    }

    basic_cvector& operator *= (TC cMult)
    {
        this->_scalc(cMult);
        return *this;
    }

    basic_cvector& operator /= (TC cDiv)
    {
        this->_div(cDiv);
        return *this;
    }

    basic_cvector& normalize()
    {
        this->_normalize();
        return *this;
    }

    basic_cvector operator ~() const throw(cvmexception)
    {
        basic_cvector vRes(*this);
        __conj<TC>(vRes.get(), vRes.size(), vRes.incr());
        return vRes;
    }

    basic_cvector& conj(const basic_cvector& v) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v.size(), this->size());
        this->_assign(v, v.incr());
        __conj<TC>(this->get(), this->size(), this->incr());
        return *this;
    }

    basic_cvector& conj()
    {
        __conj<TC>(this->get(), this->size(), this->incr());
        return *this;
    }

    TC operator * (const basic_cvector& v) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v.size(), this->size());
        return __dotu<TC>(this->get(), this->size(), this->incr(), v.get(), v.incr());
    }

    TC operator % (const basic_cvector& v) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v.size(), this->size());
        return __dotc<TC>(this->get(), this->size(), this->incr(), v.get(), v.incr());
    }

    basic_cvector operator * (const basic_cmatrix<TR,TC>& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, m.msize(), this->size());
        basic_cvector vRes(m.nsize());
        m._multiply(vRes, *this, true);
        return vRes;
    }

    basic_cvector& mult(const basic_cvector& v, const basic_cmatrix<TR,TC>& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, m.nsize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, m.msize(), v.size());
        m._multiply(*this, v, true);
        return *this;
    }

    basic_cvector& mult(const basic_cmatrix<TR,TC>& m, const basic_cvector& v) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, m.msize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, v.size(), m.nsize());
        m._multiply(*this, v, false);
        return *this;
    }

    basic_cmatrix<TR,TC> rank1update_u(const basic_cvector& v) const
    {
        basic_cmatrix<TR,TC> mRes(this->size(), v.size());
        static const TC one(1., 0.);
        __geru<TC, basic_cmatrix<TR,TC>, basic_cvector>(mRes, *this, v, one);
        return mRes;
    }

    basic_cmatrix<TR,TC> rank1update_c(const basic_cvector& v) const
    {
        basic_cmatrix<TR,TC> mRes(this->size(), v.size());
        static const TC one(1., 0.);
        __gerc<TC, basic_cmatrix<TR,TC>, basic_cvector>(mRes, *this, v, one);
        return mRes;
    }

    basic_cvector& solve(const basic_scmatrix<TR,TC>& mA, const basic_cvector& vB, TR& dErr) throw(cvmexception) {
        return _solve_helper(mA, vB, dErr, 0);
    }

// 6.1: transpose added
    basic_cvector& solve_tran(const basic_scmatrix<TR,TC>& mA, const basic_cvector& vB, TR& dErr) throw(cvmexception) {
        return _solve_helper(mA, vB, dErr, 1);
    }

// 6.1: conjugate added
    basic_cvector& solve_conj(const basic_scmatrix<TR,TC>& mA, const basic_cvector& vB, TR& dErr) throw(cvmexception) {
        return _solve_helper(mA, vB, dErr, 2);
    }

    basic_cvector& solve(const basic_scmatrix<TR,TC>& mA, const basic_cvector& vB) throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve(mA, vB, dErr);
    }

// 6.1: transpose added
    basic_cvector& solve_tran(const basic_scmatrix<TR,TC>& mA, const basic_cvector& vB) throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_tran(mA, vB, dErr);
    }

// 6.1: conjugate added
    basic_cvector& solve_conj(const basic_scmatrix<TR,TC>& mA, const basic_cvector& vB) throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_conj(mA, vB, dErr);
    }

// 6.1: MATLAB-style operator B/A returning solution of X*A=B equation
    basic_cvector operator / (const basic_scmatrix<TR,TC>& mA) const throw(cvmexception) {
        return _operator_solve_helper(mA, 1);
    }

// 6.1: similar to operator / this one returns solution of A*X=B equation
    basic_cvector operator % (const basic_scmatrix<TR,TC>& mA) const throw(cvmexception) {
        return _operator_solve_helper(mA, 0);
    }

    basic_cvector& solve_lu(const basic_scmatrix<TR,TC>& mA, const basic_scmatrix<TR,TC>& mLU, const tint* pPivots,
                            const basic_cvector& vB, TR& dErr) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, mA.msize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, vB.size(), mA.msize());
        _check_ne(CVM_SIZESMISMATCH, mLU.msize(), mA.msize());
        mA._solve(vB, *this, dErr, mLU, pPivots, 0);
        return *this;
    }

    basic_cvector& solve_lu(const basic_scmatrix<TR,TC>& mA, const basic_scmatrix<TR,TC>& mLU, const tint* pPivots,
                            const basic_cvector& vB) throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_lu(mA, mLU, pPivots, vB, dErr);
    }

    basic_cvector& gels(bool conjugate, const basic_cmatrix<TR,TC>& mA, const basic_cvector& vB,
                        TC& cErr) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, vB.size(), conjugate ? mA.nsize() : mA.msize());
        _check_ne(CVM_SIZESMISMATCH, this->size(), conjugate ? mA.msize() : mA.nsize());
        basic_cmatrix<TR,TC> mA2(mA); // this algorithm overrides A
        basic_cmatrix<TR,TC> mB(vB, vB.size(), 1);
        basic_cmatrix<TR,TC> mX;
        basic_cvector vErr(1);
        __gels(conjugate, mA2, mB, mX, vErr);
        cErr = vErr(CVM0);
        *this = mX(CVM0);
        return *this;
    }

    basic_cvector& gelsy(const basic_cmatrix<TR,TC>& mA, const basic_cvector& vB, tint& rank,
                         TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, vB.size(), mA.msize());
        _check_ne(CVM_SIZESMISMATCH, this->size(), mA.nsize());
        basic_cmatrix<TR,TC> mA2(mA); // this algorithm overrides A
        basic_cmatrix<TR,TC> mB(vB, vB.size(), 1);
        basic_cmatrix<TR,TC> mX;
        __gelsy(mA2, mB, mX, tol, rank);
        *this = mX(CVM0);
        return *this;
    }

    basic_cvector& gelss(const basic_cmatrix<TR,TC>& mA, const basic_cvector& vB, basic_rvector<TR>& sv,
                         tint& rank, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        _gels_sd(true, mA, vB, sv, rank, tol);
        return *this;
    }

    basic_cvector& gelsd(const basic_cmatrix<TR,TC>& mA, const basic_cvector& vB, basic_rvector<TR>& sv,
                         tint& rank, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        _gels_sd(false, mA, vB, sv, rank, tol);
        return *this;
    }

    basic_cvector& eig(const basic_srmatrix<TR>& mA) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, mA.nsize(), this->size());
        mA._eig(*this, nullptr, true);
        return *this;
    }

    basic_cvector& eig(const basic_srmatrix<TR>& mA, basic_scmatrix<TR,TC>& mEigVect, bool bRightVect = true) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, mA.nsize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, mEigVect.nsize(), this->size());
        mA._eig(*this, &mEigVect, bRightVect);
        return *this;
    }

    basic_cvector& eig(const basic_scmatrix<TR,TC>& mA) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, mA.nsize(), this->size());
        mA._eig(*this, nullptr, true);
        return *this;
    }

    basic_cvector& eig(const basic_scmatrix<TR,TC>& mA, basic_scmatrix<TR,TC>& mEigVect, bool bRightVect = true) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, mA.nsize(), this->size());
        mA._eig(*this, &mEigVect, bRightVect);
        return *this;
    }

    basic_cvector& geneig(const basic_srmatrix<TR>& mA, const basic_srmatrix<TR>& mB, basic_rvector<TR>& vBeta) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, mA.nsize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, mB.nsize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, vBeta.size(), this->size());
        basic_srmatrix<TR> ma(mA);  // overriden below. also, we need to care about band ones
        basic_srmatrix<TR> mb(mB);
        __ggev<basic_srmatrix<TR>, basic_scmatrix<TR,TC>, basic_rvector<TR>, basic_cvector>(ma, mb, *this, vBeta, nullptr, nullptr);
        return *this;
    }

    basic_cvector& geneig(const basic_srmatrix<TR>& mA, const basic_srmatrix<TR>& mB, basic_rvector<TR>& vBeta,
        basic_scmatrix<TR,TC>& mEigVectLeft, basic_scmatrix<TR,TC>& mEigVectRight) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, mA.nsize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, mB.nsize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, vBeta.size(), this->size());
        _check_ne(CVM_SIZESMISMATCH, mEigVectLeft.nsize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, mEigVectRight.nsize(), this->size());
        basic_srmatrix<TR> ma(mA);  // overriden below. also, we need to care about band ones
        basic_srmatrix<TR> mb(mB);
        __ggev(ma, mb, *this, vBeta, &mEigVectLeft, &mEigVectRight);
        return *this;
    }

    basic_cvector& geneig(const basic_srmatrix<TR>& mA, const basic_srmatrix<TR>& mB, basic_rvector<TR>& vBeta,
        basic_scmatrix<TR,TC>& mEigVect, bool bRightVect = true) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, mA.nsize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, mB.nsize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, vBeta.size(), this->size());
        _check_ne(CVM_SIZESMISMATCH, mEigVect.nsize(), this->size());
        basic_srmatrix<TR> ma(mA);  // overriden below. also, we need to care about band ones
        basic_srmatrix<TR> mb(mB);
        __ggev(ma, mb, *this, vBeta, bRightVect ? nullptr : &mEigVect, bRightVect ? &mEigVect : nullptr);
        return *this;
    }

    basic_cvector& geneig(const basic_scmatrix<TR,TC>& mA, const basic_scmatrix<TR,TC>& mB, basic_cvector& vBeta) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, mA.nsize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, mB.nsize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, vBeta.size(), this->size());
        basic_scmatrix<TR,TC> ma(mA);  // overriden below. also, we need to care about band ones
        basic_scmatrix<TR,TC> mb(mB);
        __ggev<basic_scmatrix<TR,TC>, basic_scmatrix<TR,TC>, basic_cvector, basic_cvector>(ma, mb, *this, vBeta, nullptr, nullptr);
        return *this;
    }

    basic_cvector& geneig(const basic_scmatrix<TR,TC>& mA, const basic_scmatrix<TR,TC>& mB, basic_cvector& vBeta,
        basic_scmatrix<TR,TC>& mEigVectLeft, basic_scmatrix<TR,TC>& mEigVectRight) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, mA.nsize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, mB.nsize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, vBeta.size(), this->size());
        _check_ne(CVM_SIZESMISMATCH, mEigVectLeft.nsize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, mEigVectRight.nsize(), this->size());
        basic_scmatrix<TR,TC> ma(mA);  // overriden below. also, we need to care about band ones
        basic_scmatrix<TR,TC> mb(mB);
        __ggev(ma, mb, *this, vBeta, &mEigVectLeft, &mEigVectRight);
        return *this;
    }

    basic_cvector& geneig(const basic_scmatrix<TR,TC>& mA, const basic_scmatrix<TR,TC>& mB, basic_cvector& vBeta,
        basic_scmatrix<TR,TC>& mEigVect, bool bRightVect = true) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, mA.nsize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, mB.nsize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, vBeta.size(), this->size());
        _check_ne(CVM_SIZESMISMATCH, mEigVect.nsize(), this->size());
        basic_scmatrix<TR,TC> ma(mA);  // overriden below. also, we need to care about band ones
        basic_scmatrix<TR,TC> mb(mB);
        __ggev(ma, mb, *this, vBeta, bRightVect ? nullptr : &mEigVect, bRightVect ? &mEigVect : nullptr);
        return *this;
    }

    basic_cvector& gemv(bool bLeft, const basic_cmatrix<TR,TC>& m, TC dAlpha, const basic_cvector& v, TC dBeta) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v.size(), bLeft ? m.msize() : m.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->size(), bLeft ? m.nsize() : m.msize());
        m._gemv(bLeft, dAlpha, v, dBeta, *this);
        return *this;
    }

    basic_cvector& gbmv(bool bLeft, const basic_scbmatrix<TR,TC>& m, TC dAlpha, const basic_cvector& v, TC dBeta) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, v.size(), bLeft ? m.msize() : m.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->size(), bLeft ? m.nsize() : m.msize());
        m._gbmv(bLeft, dAlpha, v, dBeta, *this);
        return *this;
    }

    basic_cvector& randomize_real(TR dFrom, TR dTo)
    {
        __randomize_real<TC, TR>(this->get(), this->size(), this->incr(), dFrom, dTo);
        return *this;
    }

    basic_cvector& randomize_imag(TR dFrom, TR dTo)
    {
        __randomize_imag<TC, TR>(this->get(), this->size(), this->incr(), dFrom, dTo);
        return *this;
    }

protected:
    void _div(TC d) throw(cvmexception)
    {
        if (_abs(d) <= basic_cvmMachMin<TR>()) {
            throw cvmexception(CVM_DIVISIONBYZERO);
        }
        static const TC one(1., 0.);
        this->_scalc(one / d);
    }

    void _scalc(TC d)
    {
        __scal<TC, TC>(this->get(), this->size(), this->incr(), d);
    }

    void _set_real_number(TR d)
    {
        _set_real<TR,TC>(this->get(), this->size(), this->incr(), d);
    }

    void _set_imag_number(TR d)
    {
        _set_imag<TR,TC>(this->get(), this->size(), this->incr(), d);
    }

private:
    basic_cvector& _solve_helper(const basic_scmatrix<TR,TC>& mA, const basic_cvector& vB,
                                 TR& dErr, int transp_mode) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, mA.msize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, mA.msize(), vB.size());
        mA._solve(vB, *this, dErr, nullptr, nullptr, transp_mode);
        return *this;
    }

    basic_cvector _operator_solve_helper(const basic_scmatrix<TR,TC>& mA, int transp_mode) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, mA.msize(), this->size());
        static TR dErr(0.);
        basic_cvector vX(this->size());
        mA._solve(*this, vX, dErr, nullptr, nullptr, transp_mode);
        return vX;
    }

    // helper for svd and divide&conquer methods
    void _gels_sd(bool svd, const basic_cmatrix<TR,TC>& mA, const basic_cvector& vB,
                  basic_rvector<TR>& sv, tint& rank, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, mA.nsize(), this->size());
        _check_ne(CVM_SIZESMISMATCH, mA.msize(), vB.size());
        _check_ne(CVM_SIZESMISMATCH, sv.size(), _cvm_min<tint>(mA.msize(), mA.nsize()));
        basic_cmatrix<TR,TC> mA2(mA); // this algorithm overrides A
        basic_cmatrix<TR,TC> mB(vB, vB.size(), 1);
        basic_cmatrix<TR,TC> mX;
        basic_rvector<TR> sv1(sv.size()); // to ensure that incr=1
        if (svd) {
            __gelss(mA2, mB, mX, tol, sv1, rank);
        } else {
            __gelsd(mA2, mB, mX, tol, sv1, rank);
        }
        sv = sv1;
        *this = mX(CVM0);
    }
};

template<typename TR, typename TC>
class Matrix : public basic_array<TR,TC>
{
    typedef basic_array<TR,TC> BaseArray;

protected:
    tint mm;   
    tint mn;   
    tint mld;  

    Matrix()
      : mm(0),
        mn(0),
        mld(0)
    {
    }

    Matrix(tint nM, tint nN, tint nLD, bool bZeroMemory)
      : BaseArray(nLD * nN, bZeroMemory),
        mm(nM),
        mn(nN),
        mld(nLD)
    {
    }

    Matrix(TC* pd, tint nM, tint nN, tint nLD, tint nSize)
      : BaseArray(pd, nSize, 1),
        mm(nM),
        mn(nN),
        mld(nLD)
    {
    }

    Matrix(const TC* pd, tint nM, tint nN, tint nLD, tint nSize)
      : BaseArray(pd, nSize, 1),
        mm(nM),
        mn(nN),
        mld(nLD)
    {
    }

    Matrix(const BaseArray& v, bool bBeColumn)
      : BaseArray(v.size()),
        mm(bBeColumn ? v.size() : 1),
        mn(bBeColumn ? 1 : v.size()),
        mld(mm)
    {
        __copy<TC>(this->size(), v, v.incr(), this->get(), this->incr());
    }

    Matrix(Matrix&& m) noexcept
#if defined(CVM_USE_DELEGATING_CONSTRUCTORS)
        : Matrix(m.size(), m.incr(), m.msize(), m.nsize(), m.ld())
#else
        : BaseArray(m.size(), m.incr()),
        mm(m.msize()),
        mn(m.nsize()),
        mld(m.ld())
#endif
    {
        _mmove(std::move(m));
    }

    Matrix& operator = (Matrix&& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, m.msize(), this->msize());
        _check_ne(CVM_SIZESMISMATCH, m.nsize(), this->nsize());
        _mmove(std::move(m));
        return *this;
    }

public:
    tint msize() const {
        return mm;
    }

    tint nsize() const {
        return mn;
    }

    tint ld() const {
        return mld;
    }

    tint rowofmax() const {
        return (this->_indofmax() - CVM0) % mm + CVM0;
    }

    tint rowofmin() const {
        return (this->_indofmin() - CVM0) % mm + CVM0;
    }

    tint colofmax() const {
        return (this->_indofmax() - CVM0) / mm + CVM0;
    }

    tint colofmin() const {
        return (this->_indofmin() - CVM0) / mm + CVM0;
    }

    TR norm1() const override
    {
        tint i, j, k;
        TR  rSum, rNorm(0.);

        for (j = 0; j < this->nsize(); ++j) {
            rSum = TR(0.);

            k = j * this->ld();
            for (i = 0; i < this->msize(); ++i) {
                CVM_ASSERT(this->get(), (k + i + 1) * sizeof(TC))
                rSum += _abs(this->get()[k + i]);
            }

            if (rSum > rNorm) {
                rNorm = rSum;
            }
        }
        return rNorm;
    }

    TR norminf() const override
    {
        tint i, j;
        TR  rSum, rNorm(0.);

        for (i = 0; i < this->msize(); ++i) {
            rSum = TR(0.);

            for (j = 0; j < this->nsize(); ++j) {
                CVM_ASSERT(this->get(), (j * this->ld() + i + 1) * sizeof(TC))
                rSum += _abs(this->get()[j * this->ld() + i]);
            }

            if (rSum > rNorm) {
                rNorm = rSum;
            }
        }
        return rNorm;
    }

    const tint* _pm() const {
        return &mm;
    }

    const tint* _pn() const {
        return &mn;
    }

    const tint* _pld() const {
        return &mld;
    }

    TC* _sub_pointer_nocheck(tint row, tint col) {
        return this->_pd() + ((col - CVM0) * this->ld() + row - CVM0);
    }

    TC* _sub_pointer(tint row, tint col, tint height, tint width) throw(cvmexception)
    {
        _check_lt(CVM_SIZESMISMATCH_LT, row, CVM0);
        _check_lt(CVM_SIZESMISMATCH_LT, col, CVM0);
        _check_lt(CVM_SIZESMISMATCH_LT, height, CVM0);
        _check_lt(CVM_SIZESMISMATCH_LT, width, CVM0);
        _check_gt(CVM_SIZESMISMATCH_GT, row + height, this->msize() + CVM0);
        _check_gt(CVM_SIZESMISMATCH_GT, col + width, this->nsize() + CVM0);
        return _sub_pointer_nocheck(row, col);
    }

    virtual tint _ldm() const {
        return this->ld();
    }

    virtual const tint* _pldm() const {
        return this->_pld();
    }

    virtual bool _continuous() const {
        return this->msize() == this->ld();
    }

    void _check_ld() const
    {
        if (!this->_continuous()) {
            throw cvmexception(CVM_SUBMATRIXACCESSERROR);
        }
    }

    void _scalr(TR d) override
    {
        if (this->_continuous()) {
            __scal<TR,TC>(this->get(), this->size(), this->incr(), d);
        } else for (tint i = 0; i < this->nsize(); ++i) {
            __scal<TR,TC>(this->get() + this->ld() * i, this->msize(), this->incr(), d);
        }
    }

protected:
    Matrix(tint size, tint incr, tint msize, tint nsize, tint ld) noexcept
      : BaseArray(size, incr),
        mm(msize),
        mn(nsize),
        mld(ld)
    {
    }

    // move semantics implementation for matrices
    void _mmove(Matrix&& m) noexcept
    {
        // no size checks here
#ifdef CVM_USE_POOL_MANAGER
        mpd = m.mpd;
        m.mpd = nullptr;
#else
        if (m.mpf == nullptr) {
            if (this->mpf == nullptr && this->_continuous() && m._continuous()) {
                this->mp = std::move(m.mp);
                m.msz = m.mm = m.mn = m.mld = 0;
            } else {
                // *this has foreign array inside or not continuous; no place to move to
                // i.e. this is the case where we don't even touch m, just copy its content
                this->_massign(m);
            }
        } else {
            // ... and here we can't rely on foreign poiter life cycle, thus copying
            this->_resize2(m.msize(), m.nsize());
            this->_massign(m);
        }
#endif
    }

    void _diag_helper(tint nDiag, tint& nShift, tint& nSize) const throw(cvmexception)
    {
        if (nDiag >= 0) {
            _check_ge(CVM_INDEX_GE, nDiag, this->nsize());
            nShift = nDiag * this->ld();
            nSize = this->nsize() > this->msize() ? (nDiag > this->nsize() - this->msize() ? this->nsize() - nDiag : this->msize()) :
                                                                                             this->nsize() - nDiag;
        } else {
            nShift = -nDiag;
            _check_ge(CVM_INDEX_GE, nShift, this->msize());
            nSize = this->msize() > this->nsize() ? (nShift > this->msize() - this->nsize() ? this->msize() - nShift : this->nsize()) :
                                                                                              this->msize() - nShift;
        }
    }

    tint _indofmax() const override
    {
        this->_check_ld();
        return __idamax<TC>(this->get(), this->size(), this->incr());
    }

    tint _indofmin() const override
    {
        this->_check_ld();
        return __idamin<TC>(this->get(), this->size(), this->incr());
    }

    void _assign(const TC* pd, tint nIncr) override
    {
        if (this->get() != pd) {
            if (this->_continuous()) {
                __copy<TC>(this->size(), pd, nIncr, this->get(), this->incr());
            } else for (tint i = 0; i < this->nsize(); ++i) {
                __copy<TC>(this->msize(), pd + this->msize() * i * nIncr, nIncr, this->get() + this->ld() * i, this->incr());
            }
        }
    }

    void _assign_shifted(TC* pDshifted, const TC* pd, tint nRows, tint nCols, tint nLD) override   // reusing nSise and nIncr parameter
    {
        if (pDshifted != pd) {
            for (tint i = 0; i < nCols; ++i) {
                __copy<TC>(nRows, pd + nLD * i, 1, pDshifted + this->ld() * i, this->incr());
            }
        }
    }

    void _set(TC d) override
    {
        CVM_ASSERT(this->get(), this->size() * sizeof(TC))
        tint i, j, k;
        for (j = 0; j < this->nsize(); ++j) {
            k = j * this->ld();
            for (i = 0; i < this->msize(); ++i) {
                this->get()[k + i] = d;
            }
        }
    }

    virtual void _massign(const Matrix& m)
    {
        if (this->get() != m.get()) {
            if (this->_continuous() && m._continuous()) {
                __copy<TC>(this->size(), m._pd(), m.incr(), this->get(), this->incr());
            } else {
                const TC* p = m._pd();
                const tint nLD = m._ldm();
                for (tint i = 0; i < this->nsize(); ++i) {
                    __copy<TC>(this->msize(), p + nLD * i, m.incr(), this->get() + this->ld() * i, this->incr());
                }
            }
        }
    }

    virtual void _resize2(tint nNewM, tint nNewN) throw(cvmexception)
    {
        _check_lt(CVM_WRONGSIZE_LT, nNewM, TINT_ZERO);
        _check_lt(CVM_WRONGSIZE_LT, nNewN, TINT_ZERO);
        const bool is_empty = this->_is_empty();
        if (nNewM != this->msize() || nNewN != this->nsize() || is_empty) {
            if (!is_empty) {
                this->_check_ld();
            }
            const tint nNewSize = nNewM * nNewN;
            TC* pd = cvmMalloc<TC>(nNewSize);
            cvmZeroMemory<TC>(pd, nNewSize);
            const tint nMinM = _cvm_min<tint>(nNewM, this->msize());
            const tint nMinN = _cvm_min<tint>(nNewN, this->nsize());
            if (nNewSize > 0 && !is_empty) {
                for (tint i = 0; i < nMinN; ++i) {
                    __copy<TC>(nMinM, this->get() + i * this->msize(), this->incr(), pd + i * nNewM, 1);
                }
            }
#ifdef CVM_USE_POOL_MANAGER
            cvmFree<TC>(this->mpd);
            this->mpd = pd;
#else
            this->mp.reset(pd, ArrayDeleter<TC>());
            this->mpf = nullptr;
#endif
            this->msz = nNewSize;
            CVM_ASSERT(this->get(), this->size() * sizeof(TC))
            this->mm    = nNewM;
            this->mn    = nNewN;
            this->mld   = nNewM;
            this->mincr = 1;
        }
    }

    virtual tint _ld_for_replace() const {
        return this->mld;
    }

    virtual tint _size_for_replace() const {
        return this->size();
    }

    void _replace(const Matrix& m) throw(cvmexception)
    {
        // submatrix replacement is obviously not possible
        this->_check_ld();
#ifdef CVM_USE_POOL_MANAGER
        cvmFree<TC>(this->mpd);
        this->msz = m._size_for_replace();
        this->mpd = cvmMalloc<TC>(this->size());
#else
        this->msz = m._size_for_replace();
        this->mp.reset(cvmMalloc<TC>(this->size()), ArrayDeleter<TC>());
        this->mpf = nullptr;
#endif
        this->mincr = 1;
        CVM_ASSERT(this->get(), (this->size() * sizeof(TC)))
           this->mm  = m.msize();
        this->mn  = m.nsize();
        this->mld = m._ld_for_replace();
    }

    void _transp_m(const Matrix& m)
    {
        tint i;
        if (this->msize() > this->nsize()) for (i = 0; i < this->nsize(); ++i) {
            __copy<TC>(m.nsize(), m.get() + i, m.ld(), this->get() + i * this->ld(), 1);
        }
        else for (i = 0; i < this->msize(); ++i) {
            __copy<TC>(m.msize(), m.get() + i * m.ld(), 1, this->get() + i, this->ld());
        }
    }

    virtual type_proxy<TC, TR> _ij_proxy_val(tint i, tint j) {                      // always zero based
        CVM_ASSERT(this->get(), (this->ld() * j + i + 1) * sizeof(TC))
        return type_proxy<TC, TR>(this->get()[this->ld() * j + i], false);
    }

    virtual TC _ij_val(tint i, tint j) const {                                     // always zero based
        CVM_ASSERT(this->get(), (this->ld() * j + 1) * sizeof(TC))
        return this->get()[this->ld() * j + i];
    }

    virtual void _swap_rows(tint n1, tint n2) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, n1, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, n2, CVM0, this->msize() + CVM0);
        if (n1 != n2) {
            __swap<TC>(this->nsize(), this->get() + n1 - CVM0, this->ld(), this->get() + n2 - CVM0, this->ld());
        }
    }

    virtual void _swap_cols(tint n1, tint n2) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, n1, CVM0, this->nsize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, n2, CVM0, this->nsize() + CVM0);
        if (n1 != n2) {
            __swap<TC>(this->msize(), this->get() + (n1 - CVM0) * this->ld(), 1, this->get() + (n2 - CVM0) * this->ld(), 1);
        }
    }

    virtual const TC* _pp(const Matrix& m) const {
        return m._pd();
    }

    // matrix cleaning (we ALWAYS have mincr = 1 for matrices)
    virtual void _vanish()
    {
        CVM_ASSERT(this->get(), this->size() * sizeof(TC))
        if (this->_continuous()) {
            memset(this->get(), 0, this->size() * sizeof(TC));
        } else for (tint i = 0; i < this->nsize(); ++i) {
            memset(this->get() + this->ld() * i, 0, this->msize() * sizeof(TC));
        }
    }

    void _msum(const Matrix& m1, const Matrix& m2)
    {
        if (this->_continuous() && m1._continuous() && m2._continuous()) {
            _sum<TR,TC>(this->get(), this->size(), this->incr(), _pp(m1), m1.incr(), _pp(m2), m2.incr());
        } else for (tint i = 0; i < this->nsize(); ++i) {
            _sum<TR,TC>(this->get() + this->ld() * i, this->msize(), this->incr(), _pp(m1) + m1._ldm() * i, m1.incr(), _pp(m2) + m2._ldm() * i, m2.incr());
        }
    }

    void _mdiff(const Matrix& m1, const Matrix& m2)
    {
        if (this->_continuous() && m1._continuous() && m2._continuous()) {
            _diff<TR,TC>(this->get(), this->size(), this->incr(), _pp(m1), m1.incr(), _pp(m2), m2.incr());
        } else for (tint i = 0; i < this->nsize(); ++i) {
            _diff<TR,TC>(this->get() + this->ld() * i, this->msize(), this->incr(), _pp(m1) + m1._ldm() * i, m1.incr(), _pp(m2) + m2._ldm() * i, m2.incr());
        }
    }

    void _mincr(const Matrix& m)
    {
        if (this->_continuous() && m._continuous()) {
            _incr<TR,TC>(this->get(), this->size(), this->incr(), _pp(m), m.incr());
        } else for (tint i = 0; i < this->nsize(); ++i) {
            _incr<TR,TC>(this->get() + this->ld() * i, this->msize(), this->incr(), _pp(m) + m._ldm() * i, m.incr());
        }
    }

    void _mdecr(const Matrix& m)
    {
        if (this->_continuous() && m._continuous()) {
            _decr<TR,TC>(this->get(), this->size(), this->incr(), _pp(m), m.incr());
        } else for (tint i = 0; i < this->nsize(); ++i) {
            _decr<TR,TC>(this->get() + this->ld() * i, this->msize(), this->incr(), _pp(m) + m._ldm() * i, m.incr());
        }
    }

    public:
    friend std::ostream& operator << <> (std::ostream& os, const Matrix<TR,TC>& mOut);
    friend std::istream& operator >> <> (std::istream& is, Matrix<TR,TC>& mIn);
};


template<typename TR, typename TC>
class SqMatrix
{
    typedef Matrix<TR,TC> BaseMatrix;

protected:
    SqMatrix()
    {
    }

    virtual ~SqMatrix()
    {
    }

    virtual tint _size() const = 0;
    virtual tint _msize() const = 0;
    virtual tint _nsize() const = 0;
    virtual tint _ld() const = 0;

    // it's the same as get, but let's keep get not virtual for performance sake
    virtual const TC* _pv() const = 0;
    virtual       TC* _pv() = 0;

    // it differs from Matrix::_transp_m because in this case we can do it in-place.
    void _sq_transp()
    {
        const tint mm = this->_msize();
        const tint mld = this->_ld();
        TC* pd = this->_pv();
        if (mm > 1) {
            const tint nM1 = mld + 1, nM1m = mld - 1, nM2m = mm - 1;
            tint i = 1, j = 1, m;
            for (;;) {
                m = mm - i;
                __swap<TC>(m, pd + j, 1, pd + j + nM1m, mld);
                if (i >= nM2m) {
                    break;
                }
                ++i;
                j += nM1;
            }
        }
    }

    // plus identity
    void _sq_plus_plus()
    {
        TC* pd = this->_pv();
        static const TC one(1.);
        const tint nSize = this->_size();
        const tint nNext = this->_msize() + 1;
        CVM_ASSERT(pd, nSize * sizeof(TC))
        for (tint i = 0; i < nSize; i += nNext) {
            pd[i] += one;
        }
    }

    // minus identity
    void _sq_minus_minus()
    {
        TC* pd = this->_pv();
        static const TC one(1.);
        const tint nSize = this->_size();
        const tint nNext = this->_msize() + 1;
        CVM_ASSERT(pd, nSize * sizeof(TC))
        for (tint i = 0; i < nSize; i += nNext) {
            pd[i] -= one;
        }
    }

public:
    void _clean_low_triangle()
    {
        const tint mm = this->_msize();
        const tint mld = this->_ld();
        TC* pd = this->_pv();
        tint n = 1;
        static const TR zero(0.);
        for (tint i = 1; i < mm; ++i) {
            __scal<TR,TC>(pd + n, mm - i, 1, zero);   // column by column
            n += mld + 1;
        }
    }
};

template<typename TR>
class basic_rmatrix : public Matrix<TR,TR>
{
    typedef std::complex<TR> TC;           
    typedef basic_array<TR,TR> BaseArray; 
    typedef Matrix<TR,TR> BaseMatrix;     
    typedef basic_rvector<TR> RVector;     

    friend class basic_rvector<TR>; // _multiply

public:
    basic_rmatrix()
    {
    }

    basic_rmatrix(tint nM, tint nN)
      : BaseMatrix(nM, nN, nM, true)
    {
    }

    basic_rmatrix(TR* pd, tint nM, tint nN)
      : BaseMatrix(pd, nM, nN, nM, nM * nN)
    {
    }

    basic_rmatrix(const TR* pd, tint nM, tint nN)
      : BaseMatrix(pd, nM, nN, nM, nM * nN)
    {
    }

    basic_rmatrix(const basic_rmatrix& m)
      : BaseMatrix(m.msize(), m.nsize(), m.msize(), false)
    {
        this->_massign(m);
    }

    basic_rmatrix(basic_rmatrix&& m) noexcept
       : BaseMatrix(std::move(m))
    {
    }

    explicit basic_rmatrix(const RVector& v, bool bBeColumn = true)
      : BaseMatrix(v, bBeColumn)
    {
    }

    basic_rmatrix(basic_rmatrix& m, tint nRow, tint nCol, tint nHeight, tint nWidth)
      : BaseMatrix(m._sub_pointer(nRow, nCol, nHeight, nWidth), nHeight, nWidth, m.ld(), nHeight * nWidth)
    {
        m._check_submatrix();
    }

    type_proxy<TR,TR> operator () (tint nRow, tint nCol) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        return this->_ij_proxy_val(nRow - CVM0, nCol - CVM0);
    }

    TR operator () (tint nRow, tint nCol) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        return this->_ij_val(nRow - CVM0, nCol - CVM0);
    }

    RVector operator () (tint nCol) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nCol, CVM0, this->nsize() + CVM0);
        return this->_col(nCol - CVM0);
    }

    RVector operator [] (tint nRow) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nRow, CVM0, this->msize() + CVM0);
        return this->_row(nRow - CVM0);
    }

    const RVector operator () (tint nCol) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nCol, CVM0, this->nsize() + CVM0);
        return this->_col(nCol - CVM0);
    }

    const RVector operator [] (tint nRow) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nRow, CVM0, this->msize() + CVM0);
        return this->_row(nRow - CVM0);
    }

    RVector diag(tint nDiag) throw(cvmexception) {
        return this->_diag(nDiag);
    }

    const RVector diag(tint nDiag) const throw(cvmexception) {
        return this->_diag(nDiag);
    }

    basic_rmatrix& operator = (const basic_rmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.nsize());
        this->_massign(m);
        return *this;
    }

    basic_rmatrix& operator = (basic_rmatrix&& m) throw(cvmexception)
    {
        // size check is in BaseMatrix
        BaseMatrix::operator = (std::move(m));
        return *this;
    }

    basic_rmatrix& assign(const RVector& v) throw(cvmexception)
    {
        _check_gt(CVM_SIZESMISMATCH_GT, this->size(), v.size());
        this->_assign(v, v.incr());
        return *this;
    }

    basic_rmatrix& assign(const TR* pd)
    {
        this->_assign(pd, 1);
        return *this;
    }

    basic_rmatrix& assign(tint nRow, tint nCol, const basic_rmatrix& m) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        _check_gt(CVM_SIZESMISMATCH_GT, m.msize() + nRow - CVM0, this->msize());
        _check_gt(CVM_SIZESMISMATCH_GT, m.nsize() + nCol - CVM0, this->nsize());
        this->_assign_shifted(this->_sub_pointer_nocheck(nRow, nCol), m._pd(), m.msize(), m.nsize(), m.ld());
        return *this;
    }

    basic_rmatrix& set(TR d)
    {
        this->_set(d);
        return *this;
    }

    basic_rmatrix& resize(tint nNewM, tint nNewN) throw(cvmexception)
    {
        this->_resize2(nNewM, nNewN);
        return *this;
    }

    bool operator == (const basic_rmatrix& m) const {
        return this->msize() == m.msize() && this->nsize() == m.nsize() && this->_mequals(m);
    }

    bool operator != (const basic_rmatrix& m) const {
        return !operator == (m);
    }

    basic_rmatrix& operator << (const basic_rmatrix& m) throw(cvmexception)
    {
        this->_replace(m);
        this->_massign(m);
        return *this;
    }

    basic_rmatrix operator + (const basic_rmatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.nsize());
        basic_rmatrix mSum(*this);
        mSum._mincr(m);
        return mSum;
    }

    basic_rmatrix operator - (const basic_rmatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.nsize());
        basic_rmatrix mDiff(*this);
        mDiff._mdecr(m);
        return mDiff;
    }

    basic_rmatrix& sum(const basic_rmatrix& m1, const basic_rmatrix& m2) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m1.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m2.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m2.nsize());
        this->_msum(m1, m2);
        return *this;
    }

    basic_rmatrix& diff(const basic_rmatrix& m1, const basic_rmatrix& m2) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m1.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m2.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m2.nsize());
        this->_mdiff(m1, m2);
        return *this;
    }

    basic_rmatrix& operator += (const basic_rmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.nsize());
        this->_mincr(m);
        return *this;
    }

    basic_rmatrix& operator -= (const basic_rmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.nsize());
        this->_mdecr(m);
        return *this;
    }

    basic_rmatrix operator - () const {
        static const TR mone(-1.);
        basic_rmatrix mRes(*this);
        mRes._scalr(mone);
        return mRes;
    }

    basic_rmatrix operator * (TR dMult) const {
        basic_rmatrix mRes(*this);
        mRes._scalr(dMult);
        return mRes;
    }

    basic_rmatrix operator / (TR dDiv) const throw(cvmexception)
    {
        basic_rmatrix mRes(*this);
        mRes._div(dDiv);
        return mRes;
    }

    basic_rmatrix& operator *= (TR dMult)
    {
        this->_scalr(dMult);
        return *this;
    }

    basic_rmatrix& operator /= (TR dDiv) throw(cvmexception)
    {
        this->_div(dDiv);
        return *this;
    }

    basic_rmatrix& normalize()
    {
        this->_normalize();
        return *this;
    }

    basic_rmatrix operator ~() const throw(cvmexception)
    {
        basic_rmatrix mRes(this->nsize(), this->msize());
        mRes._transp_m(*this);
        return mRes;
    }

    basic_rmatrix& transpose(const basic_rmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.msize());
        if (this->get() == m.get()) {
            basic_rmatrix mTmp(m);
            this->_transp_m(mTmp);
        } else {
            this->_transp_m(m);
        }
        return *this;
    }

    basic_rmatrix& transpose() throw(cvmexception)
    {
        basic_rmatrix mTmp(*this);
        this->_resize2(this->nsize(), this->msize());
        this->_transp_m(mTmp);
        return *this;
    }

    RVector operator * (const RVector& v) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), v.size());
        RVector vRes(this->msize());
        this->_multiply(vRes, v, false);
        return vRes;
    }

    basic_rmatrix operator * (const basic_rmatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.msize());
        basic_rmatrix mRes(this->msize(), m.nsize());
        mRes.mult(*this, m);
        return mRes;
    }

    basic_rmatrix& mult(const basic_rmatrix& m1, const basic_rmatrix& m2) throw(cvmexception)
    {
        this->_mult(m1, m2);
        return *this;
    }

    basic_rmatrix& rank1update(const RVector& vCol, const RVector& vRow) throw(cvmexception)
    {
        static const TR one(1.);
        this->_check_rank1update();
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vCol.size());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), vRow.size());
        this->_vanish();
        __ger<TR,basic_rmatrix, RVector>(*this, vCol, vRow, one);
        return *this;
    }

    basic_rmatrix& swap_rows(tint n1, tint n2) throw(cvmexception)
    {
        this->_swap_rows(n1, n2);
        return *this;
    }

    basic_rmatrix& swap_cols(tint n1, tint n2) throw(cvmexception)
    {
        this->_swap_cols(n1, n2);
        return *this;
    }

    basic_rmatrix& solve(const basic_srmatrix<TR>& mA, const basic_rmatrix& mB, TR& dErr) throw(cvmexception) {
        return _solve_helper(mA, mB, dErr, 0);
    }

// 6.1: transpose added
    basic_rmatrix& solve_tran(const basic_srmatrix<TR>& mA, const basic_rmatrix& mB, TR& dErr) throw(cvmexception) {
        return _solve_helper(mA, mB, dErr, 1);
    }

    basic_rmatrix& solve(const basic_srmatrix<TR>& mA, const basic_rmatrix& mB) throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve(mA, mB, dErr);
    }

// 6.1: transpose added
    basic_rmatrix& solve_tran(const basic_srmatrix<TR>& mA, const basic_rmatrix& mB) throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_tran(mA, mB, dErr);
    }

    basic_rmatrix& solve_lu(const basic_srmatrix<TR>& mA, const basic_srmatrix<TR>& mLU, const tint* pPivots,
                            const basic_rmatrix& mB, TR& dErr) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mA.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mB.nsize());
        _check_ne(CVM_SIZESMISMATCH, mA.msize(), mB.msize());
        _check_ne(CVM_SIZESMISMATCH, mA.msize(), mLU.msize());
        mA._solve(mB, *this, dErr, mLU, pPivots, 0);
        return *this;
    }

    basic_rmatrix& solve_lu(const basic_srmatrix<TR>& mA, const basic_srmatrix<TR>& mLU, const tint* pPivots,
                            const basic_rmatrix& mB) throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_lu(mA, mLU, pPivots, mB, dErr);
    }

    RVector svd() const throw(cvmexception)
    {
        RVector vRes(_cvm_min<tint>(this->msize(), this->nsize()));
        this->_svd(vRes, nullptr, nullptr);
        return vRes;
    }

    RVector svd(basic_srmatrix<TR>& mU, basic_srmatrix<TR>& mVH) const throw(cvmexception)
    {
        RVector vRes(_cvm_min<tint>(this->msize(), this->nsize()));
        this->_svd(vRes, &mU, &mVH);
        return vRes;
    }

    basic_rmatrix pinv(TR threshold = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        basic_rmatrix mAx(this->nsize(), this->msize());
        this->_pinv(mAx, threshold);
        return mAx;
    }

    basic_rmatrix& pinv(const basic_rmatrix& mA, TR threshold = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mA.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mA.nsize());
        mA._pinv(*this, threshold);
        return *this;
    }

    basic_rmatrix gels(bool transpose, const basic_rmatrix& mB, basic_rvector<TR>& vErr) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, mB.nsize(), vErr.size());
        _check_ne(CVM_SIZESMISMATCH, mB.msize(), transpose ? this->nsize() : this->msize());
        basic_rmatrix mA(*this); // this algorithm overrides A
        basic_rmatrix mX;
        __gels(transpose, mA, mB, mX, vErr);
        return mX;
    }

    basic_rmatrix& gels(bool transpose, const basic_rmatrix& mA, const basic_rmatrix& mB,
                        basic_rvector<TR>& vErr) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mB.nsize());
        _check_ne(CVM_SIZESMISMATCH, mB.nsize(), vErr.size());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), transpose ? mA.msize() : mA.nsize());
        _check_ne(CVM_SIZESMISMATCH, mB.msize(), transpose ? mA.nsize() : mA.msize());
        basic_rmatrix mA2(mA); // this algorithm overrides A
        __gels(transpose, mA2, mB, *this, vErr);
        return *this;
    }

    basic_rvector<TR> gels(bool transpose, const basic_rvector<TR>& vB, TR& dErr) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, vB.size(), transpose ? this->nsize() : this->msize());
        basic_rmatrix mA(*this); // this algorithm overrides A
        basic_rmatrix mB(vB, vB.size(), 1);
        basic_rmatrix mX;
        basic_rvector<TR> vErr(1);
        __gels(transpose, mA, mB, mX, vErr);
        dErr = vErr(CVM0);
        const TR* pResult = mX;
        return basic_rvector<TR>(pResult, mX.msize());
    }

    basic_rmatrix gelsy(const basic_rmatrix& mB, tint& rank,
                        TR tol = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mB.msize());
        basic_rmatrix mA(*this); // this algorithm overrides A
        basic_rmatrix mX;
        __gelsy(mA, mB, mX, tol, rank);
        return mX;
    }

    basic_rmatrix& gelsy(const basic_rmatrix& mA, const basic_rmatrix& mB,
                         tint& rank, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mA.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mB.nsize());
        _check_ne(CVM_SIZESMISMATCH, mA.msize(), mB.msize());
        basic_rmatrix mA2(mA); // this algorithm overrides A
        __gelsy(mA2, mB, *this, tol, rank);
        return *this;
    }

    basic_rvector<TR> gelsy(const basic_rvector<TR>& vB, tint& rank,
                            TR tol = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vB.size());
        basic_rmatrix mA(*this); // this algorithm overrides A
        basic_rmatrix mB(vB, vB.size(), 1);
        basic_rmatrix mX;
        __gelsy(mA, mB, mX, tol, rank);
        const TR* pResult = mX;
        return basic_rvector<TR>(pResult, mX.msize());
    }

    basic_rmatrix gelss(const basic_rmatrix& mB, basic_rvector<TR>& sv, tint& rank,
                        TR tol = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        return _gels_sd(true, mB, sv, rank, tol);
    }

    basic_rmatrix& gelss(const basic_rmatrix& mA, const basic_rmatrix& mB, basic_rvector<TR>& sv,
                         tint& rank, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        _gels_sd(true, mA, mB, sv, rank, tol);
        return *this;
    }

    basic_rvector<TR> gelss(const basic_rvector<TR>& vB, basic_rvector<TR>& sv,
                            tint& rank, TR tol = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        return _gels_sd(true, vB, sv, rank, tol);
    }

    basic_rmatrix gelsd(const basic_rmatrix& mB, basic_rvector<TR>& sv, tint& rank,
                        TR tol = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        return _gels_sd(false, mB, sv, rank, tol);
    }

    basic_rmatrix& gelsd(const basic_rmatrix& mA, const basic_rmatrix& mB, basic_rvector<TR>& sv,
                         tint& rank, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        _gels_sd(false, mA, mB, sv, rank, tol);
        return *this;
    }

    basic_rvector<TR> gelsd(const basic_rvector<TR>& vB, basic_rvector<TR>& sv,
                            tint& rank, TR tol = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        return _gels_sd(false, vB, sv, rank, tol);
    }

    tint rank(TR tol = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        tint nRank = 0;
        RVector vS(_cvm_min<tint>(this->msize(), this->nsize()));
        this->_svd(vS, nullptr, nullptr);
        vS.normalize();
        for (; nRank < vS.size(); ++nRank) {
            if (vS[nRank * this->incr() + CVM0] < tol) break;
        }
        return nRank;
    }

// QR factorization
// Case 1: "economy" mode, A is (m x n) and Q is (m x n) and R is (n x n)
    void qr(basic_rmatrix<TR>& mQ, basic_srmatrix<TR>& mR) const throw(cvmexception) {
        this->_qr_rs(mQ, mR);
    }

// Case 2: full mode, A is (m x n) and Q is (m x m) and R is (m x n)
    void qr(basic_srmatrix<TR>& mQ, basic_rmatrix<TR>& mR) const throw(cvmexception) {
        this->_qr_sr(mQ, mR);
    }

// LQ factorization
// Case 1: "economy" mode, A is (m x n) and L is (m x m) and Q is (m x n)
    void lq(basic_srmatrix<TR>& mL, basic_rmatrix<TR>& mQ) const throw(cvmexception) {
        this->_lq_sr(mL, mQ);
    }

// Case 2: full mode, A is (m x n) and L is (m x n) and Q is (n x n)
    void lq(basic_rmatrix<TR>& mL, basic_srmatrix<TR>& mQ) const throw(cvmexception) {
        this->_lq_rs(mL, mQ);
    }

// RQ factorization
// Case 1: "economy" mode, A is (m x n) and R is (m x m) and Q is (m x n)
    void rq(basic_srmatrix<TR>& mR, basic_rmatrix<TR>& mQ) const throw(cvmexception) {
        this->_rq_sr(mR, mQ);
    }

// Case 2: full mode, A is (m x n) and R is (m x n) and Q is (n x n)
    void rq(basic_rmatrix<TR>& mR, basic_srmatrix<TR>& mQ) const throw(cvmexception) {
        this->_rq_rs(mR, mQ);
    }

// QL factorization
// Case 1: "economy" mode, A is (m x n) and Q is (m x n) and L is (n x n)
    void ql(basic_rmatrix<TR>& mQ, basic_srmatrix<TR>& mL) const throw(cvmexception) {
        this->_ql_rs(mQ, mL);
    }

// Case 2: full mode, A is (m x n) and Q is (m x m) and L is (m x n)
    void ql(basic_srmatrix<TR>& mQ, basic_rmatrix<TR>& mL) const throw(cvmexception) {
        this->_ql_sr(mQ, mL);
    }

// this += alpha * v_col * v_row (rank-1 update)
    basic_rmatrix& ger(TR alpha, const RVector& vCol, const RVector& vRow) throw(cvmexception)
    {
        this->_check_ger();
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vCol.size());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), vRow.size());
        __ger<TR,basic_rmatrix, RVector>(*this, vCol, vRow, alpha);
        return *this;
    }

// this = alpha * m1 * m2 + beta * this
    basic_rmatrix& gemm(const basic_rmatrix& m1, bool bTrans1, const basic_rmatrix& m2,
                        bool bTrans2, TR dAlpha, TR dBeta) throw(cvmexception)
    {
        this->_check_gemm();
        _check_ne(CVM_SIZESMISMATCH, this->msize(), bTrans1 ? m1.nsize() : m1.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), bTrans2 ? m2.msize() : m2.nsize());
        _check_ne(CVM_SIZESMISMATCH, bTrans1 ? m1.msize() : m1.nsize(), bTrans2 ? m2.nsize() : m2.msize());
        this->_gemm(bTrans1, m1, bTrans2, m2, dAlpha, dBeta);
        return *this;
    }

// this = alpha*a*b + beta*this or this = alpha*b*a + beta*this  where a is symmetric
    basic_rmatrix& symm(bool bLeft, const basic_srsmatrix<TR>& ms, const basic_rmatrix& m,
                        TR dAlpha, TR dBeta) throw(cvmexception)
    {
        this->_check_symm();
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.nsize());
        _check_ne(CVM_SIZESMISMATCH, bLeft ? this->msize() : this->nsize(), ms.msize());
        this->_symm(bLeft, ms, m, dAlpha, dBeta);
        return *this;
    }

    basic_rmatrix& vanish()
    {
        this->_vanish();
        return *this;
    }

    basic_rmatrix& randomize(TR dFrom, TR dTo)
    {
        this->_randomize(dFrom, dTo);
        return *this;
    }

    // 2-norm (maximum singular value)
    TR norm2() const override
    {
        RVector vS(_cvm_min<tint>(this->msize(), this->nsize()));
        this->_svd(vS, nullptr, nullptr);
        return vS[CVM0];
    }

    // ?gemm routines perform a matrix-matrix operation with general matrices. The operation is defined as
    // c := alpha*op(a)*op(b) + beta*c,
    // where: op(x) is one of op(x) = x or op(x) = x' or op(x) = conjg(x'),
    void _gemm(bool bTrans1, const basic_rmatrix& m1, bool bTrans2, const basic_rmatrix& m2, TR dAlpha, TR dBeta) throw(cvmexception) {     // this = m1 * m2
        basic_rmatrix mTmp1, mTmp2;
        const TR* pD1 = m1.get();
        const TR* pD2 = m2.get();
        if (this->get() == pD1) mTmp1 << m1;
        if (this->get() == pD2) mTmp2 << m2;
        __gemm<TR,basic_rmatrix>(this->get() == pD1 ? mTmp1 : m1, bTrans1, this->get() == pD2 ? mTmp2 : m2,
                                  bTrans2, dAlpha, *this, dBeta);
    }

    // this = alpha*a*b + beta*this or this = alpha*b*a + beta*this  where a is symmetric
    void _symm(bool bLeft, const basic_srsmatrix<TR>& ms, const basic_rmatrix& m, TR dAlpha, TR dBeta) throw(cvmexception)
    {
        basic_rmatrix mTmp;
        basic_srsmatrix<TR> msTmp;
        const TR* pD1 = ms.get();
        const TR* pD2 = m._pd();
        if (this->get() == pD1) msTmp << ms;
        if (this->get() == pD2) mTmp << m;
        __symm<TR,basic_srsmatrix<TR>, basic_rmatrix>(bLeft, this->get() == pD1 ? msTmp : ms,
                                                       this->get() == pD2 ? mTmp : m, dAlpha, *this, dBeta);
    }

    // singular values in decreasing order
    virtual void _svd(RVector& vRes, basic_srmatrix<TR>* pmU, basic_srmatrix<TR>* pmVH) const throw(cvmexception)
    {
        if (pmU != nullptr && pmVH != nullptr) {
            _check_ne(CVM_SIZESMISMATCH, this->msize(), pmU->msize());
            _check_ne(CVM_SIZESMISMATCH, this->nsize(), pmVH->msize());
        }
        __svd<TR,basic_rmatrix, basic_srmatrix<TR> >(vRes, vRes.size(), vRes.incr(), *this, pmU, pmVH);
    }

    virtual void _pinv(basic_rmatrix& mX, TR threshold) const throw(cvmexception) {
        __pinv<TR,basic_rmatrix, basic_rmatrix>(mX, *this, threshold);
    }

    virtual void _check_submatrix() const {
    }

protected:
    // protected constructors for inherited stuff
    basic_rmatrix(tint nM, tint nN, tint nLD, bool bZeroMemory)
      : BaseMatrix(nM, nN, nLD, bZeroMemory)
    {
    }

    basic_rmatrix(tint size, tint incr, tint msize, tint nsize, tint ld)
      : BaseMatrix(size, incr, msize, nsize, ld)
    {
    }

    // non-const version shares memory
    basic_rmatrix(TR* pd, tint nM, tint nN, tint nLD, tint nSize)
      : BaseMatrix(pd, nM, nN, nLD, nSize)
    {
    }

    // const version makes a copy
    basic_rmatrix(const TR* pd, tint nM, tint nN, tint nLD, tint nSize)
      : BaseMatrix(pd, nM, nN, nLD, nSize)
    {
    }

    // returns diagonal which IS l-value (shares memory)
    // 0 - main, negative - low, positive - up
    virtual RVector _diag(tint nDiag) throw(cvmexception)
    {
        tint nShift = 0;
        tint nSize = 0;
        this->_diag_helper(nDiag, nShift, nSize);
        return RVector(this->get() + nShift, nSize, this->ld() + 1);
    }

    // returns diagonal which IS NOT l-value (creates a copy)
    // 0 - main, negative - low, positive - up
    virtual const RVector _diag(tint nDiag) const throw(cvmexception)
    {
        tint nShift = 0;
        tint nSize = 0;
        this->_diag_helper(nDiag, nShift, nSize);
        return RVector(this->get() + nShift, nSize, this->ld() + 1);
    }

    // compares matrix elements (equal sizes assumed)
    bool _mequals(const basic_rmatrix& m) const {
        return ((*this) - m).norminf() <= basic_cvmMachMin<TR>();
    }

    // ?gemv routines perform a matrix-vector operation defined as
    // vRes = alpha*m*v + beta * vRes or vRes = alpha*v'*m + beta * vRes
    // not virtual since __gemv calls all virtual methods inside
    void _gemv(bool bLeft, TR dAlpha, const RVector& v, TR dBeta, RVector& vRes) const
{
        RVector vTmp;
        basic_rmatrix mTmp;
        const TR* pDv = v;
        if (vRes.get() == pDv) vTmp << v;
        if (vRes.get() == this->get()) mTmp << *this;
        __gemv<TR,basic_rmatrix, RVector>(bLeft, vRes.get() == this->get() ? mTmp : *this, dAlpha,
                                           vRes.get() == pDv ? vTmp : v, dBeta, vRes);
    }

    // 0-based, returns l-value sharing memory
    virtual RVector _row(tint m) {
        return RVector(this->get() + m, this->nsize(), this->ld());
    }

    // 0-based, returns NOT l-value (copies memory)
    // looks like cut-n-paste, but it's not
    virtual const RVector _row(tint m) const {
        return RVector(this->get() + m, this->nsize(), this->ld());
    }

    // 0-based, returns l-value sharing memory
    virtual RVector _col(tint n) {
        return RVector(this->get() + this->ld() * n, this->msize());
    }

    // 0-based, returns NOT l-value (copies memory)
    // looks like cut-n-paste, but it's not
    virtual const RVector _col(tint n) const {
        return RVector(this->get() + this->ld() * n, this->msize());
    }

    virtual void _mult(const basic_rmatrix& m1, const basic_rmatrix& m2) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m2.nsize());
        _check_ne(CVM_SIZESMISMATCH, m1.nsize(), m2.msize());
        static const TR zero = TR(0.);
        static const TR one = TR(1.);
        this->_gemm(false, m1, false, m2, one, zero);
    }

    virtual void _multiply(RVector& vRes, const RVector& v, bool bLeft) const
    {
        static const TR zero = TR(0.);
        static const TR one = TR(1.);
        this->_gemv(bLeft, one, v, zero, vRes);
    }

    virtual void _randomize(TR dFrom, TR dTo)
    {
        if (this->_continuous()) {
            __randomize<TR>(this->get(), this->size(), this->incr(), dFrom, dTo);
        } else for (tint i = 0; i < this->nsize(); ++i) {
            __randomize<TR>(this->get() + this->ld() * i, this->msize(), this->incr(), dFrom, dTo);
        }
    }

    // QR factorization
    // Case 1: "economy" mode, A is (m x n) and Q is (m x n) and R is (n x n)
    void _qr_rs(basic_rmatrix<TR>& mQ, basic_srmatrix<TR>& mR) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mQ.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mR.msize());
        __qre<basic_rmatrix, basic_srmatrix<TR> >(*this, mQ, mR);
    }

    // Case 2: full mode, A is (m x n) and Q is (m x m) and R is (m x n)
    void _qr_sr(basic_srmatrix<TR>& mQ, basic_rmatrix<TR>& mR) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mR.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mR.nsize());
        __qrf<basic_rmatrix, basic_srmatrix<TR> >(*this, mQ, mR);
    }

    // RQ factorization
    // Case 1: "economy" mode, A is (m x n) and R is (m x m) and Q is (m x n)
    void _rq_sr(basic_srmatrix<TR>& mR, basic_rmatrix<TR>& mQ) const throw(cvmexception)
    {
        _check_gt(CVM_SIZESMISMATCH_GT, this->msize(), this->nsize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mQ.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mR.msize());
        __rqe<basic_rmatrix, basic_srmatrix<TR> >(*this, mR, mQ);
    }

    // Case 2: full mode, A is (m x n) and R is (m x n) and Q is (n x n)
    void _rq_rs(basic_rmatrix<TR>& mR, basic_srmatrix<TR>& mQ) const throw(cvmexception)
    {
        _check_gt(CVM_SIZESMISMATCH_GT, this->msize(), this->nsize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mQ.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mR.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mR.nsize());
        __rqf<basic_rmatrix, basic_srmatrix<TR> >(*this, mR, mQ);
    }

    // LQ factorization
    // Case 1: "economy" mode, A is (m x n) and L is (m x m) and Q is (m x n)
    void _lq_sr(basic_srmatrix<TR>& mL, basic_rmatrix<TR>& mQ) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mL.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mQ.nsize());
        __lqe<basic_rmatrix, basic_srmatrix<TR> >(*this, mL, mQ);
    }

    // Case 2: full mode, A is (m x n) and L is (m x n) and Q is (n x n)
    void _lq_rs(basic_rmatrix<TR>& mL, basic_srmatrix<TR>& mQ) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mL.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mL.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mQ.nsize());
        __lqf<basic_rmatrix, basic_srmatrix<TR> >(*this, mL, mQ);
    }

    // QL factorization
    // Case 1: "economy" mode, A is (m x n) and Q is (m x n) and L is (n x n)
    void _ql_rs(basic_rmatrix<TR>& mQ, basic_srmatrix<TR>& mL) const throw(cvmexception)
    {
        _check_lt(CVM_SIZESMISMATCH_LT, this->msize(), this->nsize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mQ.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mL.msize());
        __qle<basic_rmatrix, basic_srmatrix<TR> >(*this, mQ, mL);
    }

    // Case 2: full mode, A is (m x n) and Q is (m x m) and L is (m x n)
    void _ql_sr(basic_srmatrix<TR>& mQ, basic_rmatrix<TR>& mL) const throw(cvmexception)
    {
        _check_lt(CVM_SIZESMISMATCH_LT, this->msize(), this->nsize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mL.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mL.nsize());
        __qlf<basic_rmatrix, basic_srmatrix<TR> >(*this, mQ, mL);
    }

    virtual void _check_ger() { }
    virtual void _check_rank1update() { }
    virtual void _check_gemm() { }
    virtual void _check_symm() { }

private:
    basic_rmatrix& _solve_helper(const basic_srmatrix<TR>& mA, const basic_rmatrix& mB,
                                 TR& dErr, int transp_mode) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mA.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mB.nsize());
        _check_ne(CVM_SIZESMISMATCH, mA.msize(), mB.msize());
        mA._solve(mB, *this, dErr, nullptr, nullptr, transp_mode);
        return *this;
    }

    // helper for svd and divide&conquer methods
    basic_rmatrix _gels_sd(bool svd, const basic_rmatrix& mB, basic_rvector<TR>& sv,
                           tint& rank, TR tol) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mB.msize());
        _check_ne(CVM_SIZESMISMATCH, sv.size(), _cvm_min<tint>(this->msize(), this->nsize()));
        basic_rmatrix mA(*this); // this algorithm overrides A
        basic_rmatrix mX;
        basic_rvector<TR> sv1(sv.size()); // to ensure that incr=1
        if (svd) {
            __gelss(mA, mB, mX, tol, sv1, rank);
        } else {
            __gelsd(mA, mB, mX, tol, sv1, rank);
        }
        sv = sv1;
        return mX;
    }

    void _gels_sd(bool svd, const basic_rmatrix& mA, const basic_rmatrix& mB, basic_rvector<TR>& sv,
                  tint& rank, TR tol) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mA.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mB.nsize());
        _check_ne(CVM_SIZESMISMATCH, mA.msize(), mB.msize());
        _check_ne(CVM_SIZESMISMATCH, sv.size(), _cvm_min<tint>(mA.msize(), mA.nsize()));
        basic_rmatrix mA2(mA); // this algorithm overrides A
        basic_rvector<TR> sv1(sv.size()); // to ensure that incr=1
        if (svd) {
            __gelss(mA2, mB, *this, tol, sv1, rank);
        } else {
            __gelsd(mA2, mB, *this, tol, sv1, rank);
        }
        sv = sv1;
    }

    basic_rvector<TR> _gels_sd(bool svd, const basic_rvector<TR>& vB, basic_rvector<TR>& sv,
                               tint& rank, TR tol) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vB.size());
        _check_ne(CVM_SIZESMISMATCH, _cvm_min<tint>(this->msize(), this->nsize()), sv.size());
        basic_rmatrix mA(*this); // this algorithm overrides A
        basic_rmatrix mB(vB, vB.size(), 1);
        basic_rmatrix mX;
        basic_rvector<TR> sv1(sv.size()); // to ensure that incr=1
        if (svd) {
            __gelss(mA, mB, mX, tol, sv1, rank);
        } else {
            __gelsd(mA, mB, mX, tol, sv1, rank);
        }
        sv = sv1;
        const TR* pResult = mX;
        return basic_rvector<TR>(pResult, mX.msize());
    }
};


template<typename TR>
class basic_srmatrix : public basic_rmatrix<TR>, public SqMatrix<TR,TR>
{
    typedef std::complex<TR> TC;            
    typedef basic_rvector<TR> RVector;      
    typedef basic_cvector<TR,TC> CVector;  
    typedef basic_array<TR,TR> BaseArray;  
    typedef Matrix<TR,TR> BaseMatrix;      
    typedef SqMatrix<TR,TR> BaseSqMatrix;  
    typedef basic_rmatrix<TR> BaseRMatrix;  

public:
    basic_srmatrix()
    {
    }

    explicit basic_srmatrix(tint nDim)
      : BaseRMatrix(nDim, nDim)
    {
    }

    basic_srmatrix(TR* pd, tint nDim)
      : BaseRMatrix(pd, nDim, nDim)
    {
    }

    basic_srmatrix(const TR* pd, tint nDim)
      : BaseRMatrix(pd, nDim, nDim)
    {
    }

    basic_srmatrix(const basic_srmatrix& m)
      : BaseRMatrix(m.msize(), m.nsize(), m.msize(), false), BaseSqMatrix()
    {
        this->_massign(m);
    }

    basic_srmatrix(basic_srmatrix&& m) noexcept
       : BaseRMatrix(std::move(m))
    {
    }

    basic_srmatrix(const BaseRMatrix& m)
      : BaseRMatrix(m.msize(), m.nsize(), m.msize(), false)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), this->nsize());
        this->_massign(m);
    }

    explicit basic_srmatrix(const RVector& v)
      : BaseRMatrix(v.size(), v.size(), v.size(), true)
    {
        __copy<TR>(this->msize(), v, v.incr(), this->get(), this->msize() + 1);
    }

    basic_srmatrix(BaseRMatrix& m, tint nRow, tint nCol, tint nDim)
      : BaseRMatrix(m, nRow, nCol, nDim, nDim)
    {
        m._check_submatrix();
    }

    type_proxy<TR,TR> operator () (tint nRow, tint nCol) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        return this->_ij_proxy_val(nRow - CVM0, nCol - CVM0);
    }

    TR operator () (tint nRow, tint nCol) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        return this->_ij_val(nRow - CVM0, nCol - CVM0);
    }

    // returns column which IS l-value
    RVector operator () (tint nCol) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nCol, CVM0, this->nsize() + CVM0);
        return this->_col(nCol - CVM0);
    }

    // returns column which is NOT l-value
    const RVector operator () (tint nCol) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nCol, CVM0, this->nsize() + CVM0);
        return this->_col(nCol - CVM0);
    }

    // returns row which IS l-value
    RVector operator [] (tint nRow) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nRow, CVM0, this->msize() + CVM0);
        return this->_row(nRow - CVM0);
    }

    // returns row which is NOT l-value
    const RVector operator [] (tint nRow) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nRow, CVM0, this->msize() + CVM0);
        return this->_row(nRow - CVM0);
    }

    basic_srmatrix& operator = (const basic_srmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        this->_massign(m);
        return *this;
    }

    basic_srmatrix& operator = (basic_srmatrix&& m) throw(cvmexception)
    {
        // size check is in BaseRMatrix
        BaseRMatrix::operator = (std::move(m));
        return *this;
    }

    // assigns vector
    basic_srmatrix& assign(const RVector& v) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->size(), v.size());
        this->_assign(v, v.incr());
        return *this;
    }

    // assigns external array (nIncr = 1)
    basic_srmatrix& assign(const TR* pd)
    {
        this->_assign(pd, 1);
        return *this;
    }

    basic_srmatrix& assign(tint nRow, tint nCol, const BaseRMatrix& m) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        _check_gt(CVM_SIZESMISMATCH_GT, m.msize() + nRow - CVM0, this->msize());
        _check_gt(CVM_SIZESMISMATCH_GT, m.nsize() + nCol - CVM0, this->nsize());
        this->_assign_shifted(this->_sub_pointer_nocheck(nRow, nCol), m._pd(), m.msize(), m.nsize(), m.ld());
        return *this;
    }

    // fills the content
    basic_srmatrix& set(TR d)
    {
        this->_set(d);
        return *this;
    }

    basic_srmatrix& resize(tint nNewDim) throw(cvmexception)
    {
        this->_resize2(nNewDim, nNewDim);
        return *this;
    }

    basic_srmatrix& operator << (const basic_srmatrix& m) throw(cvmexception)
    {
        this->_replace(m);
        this->_massign(m);
        return *this;
    }

    basic_srmatrix operator + (const basic_srmatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        basic_srmatrix mSum(*this);
        mSum._mincr(m);
        return mSum;
    }

    basic_srmatrix operator - (const basic_srmatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        basic_srmatrix mDiff(*this);
        mDiff._mdecr(m);
        return mDiff;
    }

    basic_srmatrix& sum(const basic_srmatrix& m1, const basic_srmatrix& m2) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m2.msize());
        this->_msum(m1, m2);
        return *this;
    }

    basic_srmatrix& diff(const basic_srmatrix& m1, const basic_srmatrix& m2) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m2.msize());
        this->_mdiff(m1, m2);
        return *this;
    }

    basic_srmatrix& operator += (const basic_srmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        this->_mincr(m);
        return *this;
    }

    basic_srmatrix& operator -= (const basic_srmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        this->_mdecr(m);
        return *this;
    }

    basic_srmatrix operator - () const
    {
        static const TR mone(-1.);
        basic_srmatrix mRes(*this);
        mRes._scalr(mone);
        return mRes;
    }

    basic_srmatrix& operator ++ ()
    {
        this->_plus_plus();
        return *this;
    }

    basic_srmatrix operator ++ (int)
    {
        this->_plus_plus();
        return *this;
    }

    basic_srmatrix& operator -- ()
    {
        this->_minus_minus();
        return *this;
    }

    basic_srmatrix operator -- (int)
    {
        this->_minus_minus();
        return *this;
    }

    basic_srmatrix operator * (TR dMult) const
    {
        basic_srmatrix mRes(*this);
        mRes._scalr(dMult);
        return mRes;
    }

    basic_srmatrix operator / (TR dDiv) const throw(cvmexception)
    {
        basic_srmatrix mRes(*this);
        mRes._div(dDiv);
        return mRes;
    }

    basic_srmatrix& operator *= (TR dMult)
    {
        this->_scalr(dMult);
        return *this;
    }

    basic_srmatrix& operator /= (TR dDiv)
    {
        this->_div(dDiv);
        return *this;
    }

    basic_srmatrix& normalize()
    {
        this->_normalize();
        return *this;
    }

    basic_srmatrix operator ~() const throw(cvmexception)
    {
        basic_srmatrix mRes(*this);
        return mRes.transpose();
    }

    basic_srmatrix& transpose(const basic_srmatrix& m) throw(cvmexception)
    {
        (*this) = m;
        return this->transpose();
    }

    basic_srmatrix& transpose()
    {
        this->_transp();
        return *this;
    }

    RVector operator * (const RVector& v) const throw(cvmexception) {
        return this->BaseRMatrix::operator * (v);
    }

// special exclusion since matrix product is not commutative
    BaseRMatrix operator * (const BaseRMatrix& m) const throw(cvmexception) {
        return this->BaseRMatrix::operator * (m);
    }

    basic_srmatrix operator * (const basic_srmatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        basic_srmatrix mRes(this->msize());
        mRes.mult(*this, m);
        return mRes;
    }

    basic_srmatrix& operator *= (const basic_srmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        const basic_srmatrix mTmp(*this);
        this->mult(mTmp, m);
        return *this;
    }

    basic_srmatrix& swap_rows(tint n1, tint n2) throw(cvmexception)
    {
        this->_swap_rows(n1, n2);
        return *this;
    }

    basic_srmatrix& swap_cols(tint n1, tint n2) throw(cvmexception)
    {
        this->_swap_cols(n1, n2);
        return *this;
    }

// linear solvers Ax=b. Also return solution flavor.
    RVector solve(const RVector& vB, TR& dErr) const throw(cvmexception) {
        return _solve_helper(vB, dErr, 0);
    }

// 6.1: transpose added
    RVector solve_tran(const RVector& vB, TR& dErr) const throw(cvmexception) {
        return _solve_helper(vB, dErr, 1);
    }

    RVector solve(const RVector& vB) const throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve(vB, dErr);
    }

// 6.1: transpose added
    RVector solve_tran(const RVector& vB) const throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_tran(vB, dErr);
    }

    BaseRMatrix solve(const BaseRMatrix& mB, TR& dErr) const throw(cvmexception) {
        return _solve_helper(mB, dErr, 0);
    }

// 6.1: transpose added
    BaseRMatrix solve_tran(const BaseRMatrix& mB, TR& dErr) const throw(cvmexception) {
        return _solve_helper(mB, dErr, 1);
    }

    BaseRMatrix solve(const BaseRMatrix& mB) const throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve(mB, dErr);
    }

// 6.1: transpose added
    BaseRMatrix solve_tran(const BaseRMatrix& mB) const throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_tran(mB, dErr);
    }

// 6.1: reversed MATLAB-style operator B/A returning solution of X*A=B equation
    RVector operator % (const RVector& vB) const throw(cvmexception) {
        return vB / (*this);
    }

// 6.1: reversed vector operator % returns solution of A*X=B equation
    RVector operator / (const RVector& vB) const throw(cvmexception) {
        return vB % (*this);
    }

    RVector solve_lu(const basic_srmatrix& mLU, const tint* pPivots, const RVector& vB, TR& dErr) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vB.size());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mLU.msize());
        RVector vX(this->msize());
        this->_solve(vB, vX, dErr, mLU, pPivots, 0);
        return vX;
    }

    RVector solve_lu(const basic_srmatrix& mLU, const tint* pPivots, const RVector& vB) const throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_lu(mLU, pPivots, vB, dErr);
    }

    BaseRMatrix solve_lu(const basic_srmatrix& mLU, const tint* pPivots, const BaseRMatrix& mB, TR& dErr) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mB.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mLU.msize());
        BaseRMatrix mX(mB.msize(), mB.nsize());
        this->_solve(mB, mX, dErr, mLU, pPivots, 0);
        return mX;
    }

    BaseRMatrix solve_lu(const basic_srmatrix& mLU, const tint* pPivots, const BaseRMatrix& mB) const throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_lu(mLU, pPivots, mB, dErr);
    }

    TR det() const throw(cvmexception) {
        return this->_det();
    }

    basic_srmatrix& low_up(const basic_srmatrix& m, tint* nPivots) throw(cvmexception)
    {
        (*this) = m;
        this->_low_up(nPivots);
        return *this;
    }

    basic_srmatrix low_up(tint* nPivots) const throw(cvmexception)
    {
        basic_srmatrix mRes(*this);
        mRes._low_up(nPivots);
        return mRes;
    }

    TR cond() const throw(cvmexception)
    {
        TR dCondNum(0.);
        __cond_num<TR,basic_srmatrix>(*this, dCondNum); // universal method, no need to virtualize
        return dCondNum;
    }

    basic_srmatrix& inv(const basic_srmatrix& m) throw(cvmexception)
    {
        __inv<basic_srmatrix>(*this, m); // overridden in srsmatrix, no need to virtualize
        return *this;
    }

    basic_srmatrix inv() const throw(cvmexception)
    {
        basic_srmatrix mRes(this->msize());
        __inv<basic_srmatrix>(mRes, *this); // overridden in srsmatrix, no need to virtualize
        return mRes;
    }

    basic_srmatrix& exp(const basic_srmatrix& m, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        __exp<basic_srmatrix, TR>(*this, m, tol); // uses universal code inside - no need to virtualize
        return *this;
    }

    basic_srmatrix exp(TR tol = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        basic_srmatrix mRes(this->msize());
        __exp<basic_srmatrix, TR>(mRes, *this, tol);
        return mRes;
    }

// this = v(1)*I + v(2)*m + v(3)*m^2 + ... + v(N)*m^(N-1)
    basic_srmatrix& polynom(const basic_srmatrix& m, const RVector& v) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        RVector v1;
        if (v.incr() > 1) v1 << v;   // to make sure incr = 1
        __polynom<TR,RVector>(this->get(), this->ld(), this->msize(), m._pd(), m._ldm(), v.incr() > 1 ? v1 : v);
        return *this;
    }

    // returns v(1)*I + v(2)*this + v(3)*this^2 + ... + v(N)*this^(N-1)
    basic_srmatrix polynom(const RVector& v) const
    {
        basic_srmatrix mRes(this->msize());
        RVector v1;
        if (v.incr() > 1) v1 << v;   // to make sure incr = 1
        __polynom<TR,RVector>(mRes.get(), mRes.ld(), this->msize(), this->get(), this->ld(), v.incr() > 1 ? v1 : v);
        return mRes;
    }

    CVector eig(basic_scmatrix<TR,TC>& mEigVect, bool bRightVect = true) const throw(cvmexception) {
        CVector vEig(this->msize());
        this->_eig(vEig, &mEigVect, bRightVect);
        return vEig;
    }

    CVector eig() const throw(cvmexception) {
        CVector vEig(this->msize());
        this->_eig(vEig, nullptr, true);
        return vEig;
    }

    basic_srmatrix& cholesky(const basic_srsmatrix<TR>& m) throw(cvmexception)
    {
        this->_check_cholesky();  // doesn't work for band matrices
        *this = m;
        tint nOutInfo = __cholesky<basic_srmatrix>(*this);
        _check_negative(CVM_WRONGMKLARG, nOutInfo);
        _check_positive(CVM_NOTPOSITIVEDEFINITE, nOutInfo);
        this->_clean_low_triangle();
        return *this;
    }

    basic_srmatrix& bunch_kaufman(const basic_srsmatrix<TR>& m, tint* nPivots) throw(cvmexception)
    {
        this->_check_bunch_kaufman();  // doesn't work for band matrices
        *this = m;
        __bunch_kaufman<basic_srmatrix>(*this, nPivots);
        return *this;
    }

    void qr(basic_srmatrix<TR>& mQ, basic_srmatrix<TR>& mR) const throw(cvmexception) {
        this->_qr_ss(mQ, mR);
    }

    void lq(basic_srmatrix<TR>& mL, basic_srmatrix<TR>& mQ) const throw(cvmexception) {
        this->_lq_ss(mL, mQ);
    }

    void ql(basic_srmatrix<TR>& mQ, basic_srmatrix<TR>& mL) const throw(cvmexception) {
        this->_ql_ss(mQ, mL);
    }

    void rq(basic_srmatrix<TR>& mR, basic_srmatrix<TR>& mQ) const throw(cvmexception) {
        this->_rq_ss(mR, mQ);
    }

    basic_srmatrix& identity()
    {
        this->_vanish();
        this->_plus_plus();
        return *this;
    }

    basic_srmatrix& vanish()
    {
        this->_vanish();
        return *this;
    }

    basic_srmatrix& randomize(TR dFrom, TR dTo)
    {
        this->_randomize(dFrom, dTo);
        return *this;
    }

    virtual void _eig(CVector& vEig, basic_scmatrix<TR,TC>* mEigVect, bool bRightVect) const throw(cvmexception)
    {
        __eig<CVector, basic_srmatrix, basic_scmatrix<TR,TC> >(vEig, *this, mEigVect, bRightVect);
    }

    virtual void _solve(const RVector& vB, RVector& vX,
                        TR& dErr, const TR* pLU, const tint* pPivots, int transp_mode) const throw(cvmexception)
    {
        vX = vB;
        RVector vB1;
        RVector vX1;
        if (vB.incr() > 1) vB1 << vB;   // to make sure incr = 1
        if (vX.incr() > 1) vX1 << vX;
        __solve<TR,TR, basic_srmatrix>(*this, 1, vB.incr() > 1 ? vB1 : vB, vB.size(),
                                        vX.incr() > 1 ? vX1 : vX, vX.size(), dErr, pLU, pPivots, transp_mode);
        if (vX.incr() > 1) vX = vX1;
    }

    virtual void _solve(const BaseRMatrix& mB, BaseRMatrix& mX,
                        TR& dErr, const TR* pLU, const tint* pPivots, int transp_mode) const throw(cvmexception)
    {
        mX = mB;
        __solve<TR,TR, basic_srmatrix>(*this, mB.nsize(), mB, mB.ld(), mX, mX.ld(), dErr, pLU, pPivots, transp_mode);
    }

    const TR* _pv() const override {return this->get();}
    TR*       _pv()       override {return this->get();}

protected:
    // protected constructors for inherited stuff
    basic_srmatrix(tint nDim, tint nLD, bool bZeroMemory)
      : BaseRMatrix(nDim, nDim, nLD, bZeroMemory)
    {
    }

    basic_srmatrix(tint size, tint incr, tint msize, tint nsize, tint ld)
      : BaseRMatrix(size, incr, msize, nsize, ld)
    {
    }

    // non-const version shares memory
    basic_srmatrix(TR* pd, tint nDim, tint nLD, tint nSize)
      : BaseRMatrix(pd, nDim, nDim, nLD, nSize)
    {
    }

    // const version makes a copy
    basic_srmatrix(const TR* pd, tint nDim, tint nLD, tint nSize)
      : BaseRMatrix(pd, nDim, nDim, nLD, nSize)
    {
    }

    tint _size() const override {return this->size();}
    tint _msize() const override {return this->msize();}
    tint _nsize() const override {return this->nsize();}
    tint _ld() const override {return this->ld();}

    // returns diagonal which IS l-value (shares memory)
    // 0 - main, negative - low, positive - up
    RVector _diag(tint nDiag) throw(cvmexception) override
    {
        const tint nD = _abs(nDiag);
        _check_ge(CVM_INDEX_GE, nD, this->msize());
        return RVector(this->get() + (nDiag > 0 ? nDiag * this->ld() : nD), this->msize() - nD, this->ld() + 1);
    }

    // returns diagonal which is NOT l-value (creates a copy)
    // 0 - main, negative - low, positive - up
    const RVector _diag(tint nDiag) const throw(cvmexception) override
    {
        const tint nD = _abs(nDiag);
        _check_ge(CVM_INDEX_GE, nD, this->msize());
        return RVector(this->get() + (nDiag > 0 ? nDiag * this->ld() : nD), this->msize() - nD, this->ld() + 1);
    }

    // returns main diagonal of low_up factorization
    virtual RVector _low_up_diag(basic_array<tint,tint>& naPivots) const throw(cvmexception)
    {
        // let temp matrix be const to get a copy of its main diagonal
        const basic_srmatrix lu = this->low_up(naPivots);
        return lu.diag(0);
    }

    virtual void _transp() {
        this->_sq_transp();
    }

    virtual void _plus_plus() {
        this->_sq_plus_plus();
    }

    virtual void _minus_minus() {
        this->_sq_minus_minus();
    }

    virtual TR _det() const throw(cvmexception)
    {
        TR dDet(0.);
        switch (this->msize()) {
        case 0:
            break;
        case 1:
            dDet = this->_ij_val(0, 0);
            break;
        case 2:
            dDet = this->_ij_val(0, 0) * this->_ij_val(1, 1) -
               this->_ij_val(1, 0) * this->_ij_val(0, 1);
            break;
        default:
            try {
                static const TR one(1.);
                basic_array<tint,tint> naPivots(this->msize());
                RVector vUpDiag = this->_low_up_diag(naPivots);

                dDet = one;
                for (tint i = CVM0; i <= this->msize() - (1 - CVM0); ++i) {
                    dDet *= vUpDiag[i];
                    if (i + (1 - CVM0) != naPivots[i]) {
                        dDet = -dDet;
                    }
                }
            }
            catch (const cvmexception& e) {
                if (e.cause() != CVM_SINGULARMATRIX) throw e;
            }
            break;
        }
        return dDet;
    }

    virtual void _low_up(tint* nPivots) throw(cvmexception) {
        __low_up<basic_srmatrix>(*this, nPivots);
    }

    // QR - "economy" mode here
    void _qr_ss(basic_srmatrix<TR>& mQ, basic_srmatrix<TR>& mR) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mR.msize());
        __qre<basic_rmatrix<TR>, basic_srmatrix<TR> >(*this, mQ, mR);
    }

    // RQ - "economy" mode here
    void _rq_ss(basic_srmatrix<TR>& mR, basic_srmatrix<TR>& mQ) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mR.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        __rqe<basic_rmatrix<TR>, basic_srmatrix<TR> >(*this, mR, mQ);
    }

    // LQ - "economy" mode here
    void _lq_ss(basic_srmatrix<TR>& mL, basic_srmatrix<TR>& mQ) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mL.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        __lqe<basic_rmatrix<TR>, basic_srmatrix<TR> >(*this, mL, mQ);
    }

    // QL - "economy" mode here
    void _ql_ss(basic_srmatrix<TR>& mQ, basic_srmatrix<TR>& mL) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mL.msize());
        __qle<basic_rmatrix<TR>, basic_srmatrix<TR> >(*this, mQ, mL);
    }

    virtual void _check_cholesky() { }
    virtual void _check_bunch_kaufman() { }

private:
    RVector _solve_helper(const RVector& vB, TR& dErr, int transp_mode) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vB.size());
        RVector vX(this->msize());
        this->_solve(vB, vX, dErr, nullptr, nullptr, transp_mode);
        return vX;
    }

    BaseRMatrix _solve_helper(const BaseRMatrix& mB, TR& dErr, int transp_mode) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mB.msize());
        BaseRMatrix mX(mB.msize(), mB.nsize());
        this->_solve(mB, mX, dErr, nullptr, nullptr, transp_mode);
        return mX;
    }
};


template<typename TR, typename TC>
class basic_cmatrix : public Matrix<TR,TC>
{
    typedef basic_rvector<TR> RVector;       
    typedef basic_cvector<TR,TC> CVector;   
    typedef basic_array<TR,TC> BaseArray;   
    typedef Matrix<TR,TC> BaseMatrix;       

    friend class basic_cvector<TR,TC>;      // for _multiply

public:
    basic_cmatrix()
    {
    }

    basic_cmatrix(tint nM, tint nN)
      : BaseMatrix(nM, nN, nM, true)
    {
    }

    basic_cmatrix(TC* pd, tint nM, tint nN)
      : BaseMatrix(pd, nM, nN, nM, nM * nN)
    {
    }

    basic_cmatrix(const TC* pd, tint nM, tint nN)
      : BaseMatrix(pd, nM, nN, nM, nM * nN)
    {
    }

    basic_cmatrix(const basic_cmatrix& m)
      : BaseMatrix(m.msize(), m.nsize(), m.msize(), false)
    {
        this->_massign(m);
    }

    basic_cmatrix(basic_cmatrix&& m) noexcept
       : BaseMatrix(std::move(m))
    {
    }

    explicit basic_cmatrix(const CVector& v, bool bBeColumn = true)
      : BaseMatrix(v, bBeColumn)
    {
    }

    explicit basic_cmatrix(const basic_rmatrix<TR>& m, bool bRealPart = true)
      : BaseMatrix(m.msize(), m.nsize(), m.msize(), true)
    {
        if (bRealPart) {
            __copy2<TR,TC>(this->get(), this->size(), this->incr(), m._pd(), nullptr);
        }
        else {
            __copy2<TR,TC>(this->get(), this->size(), this->incr(), nullptr, m._pd());
        }
    }

    basic_cmatrix(const TR* pRe, const TR* pIm, tint nM, tint nN)
      : BaseMatrix(nM, nN, nM, true)
    {
        __copy2<TR,TC>(this->get(), this->size(), this->incr(), pRe, pIm, 1, 1);
    }

    basic_cmatrix(const basic_rmatrix<TR>& mRe, const basic_rmatrix<TR>& mIm)
      : BaseMatrix(mRe.msize(), mRe.nsize(), mRe.msize(), false)
    {
        _check_ne(CVM_SIZESMISMATCH, mRe.msize(), mIm.msize());
        _check_ne(CVM_SIZESMISMATCH, mRe.nsize(), mIm.nsize());
        _check_ne(CVM_SIZESMISMATCH, mRe.ld(), mIm.ld());
        __copy2<TR,TC>(this->get(), this->size(), this->incr(), mRe, mIm, mRe.incr(), mIm.incr());
    }

    basic_cmatrix(basic_cmatrix& m, tint nRow, tint nCol, tint nHeight, tint nWidth)
      : BaseMatrix(m._sub_pointer(nRow, nCol, nHeight, nWidth), nHeight, nWidth, m.ld(), nHeight * nWidth)
    {
        m._check_submatrix();
    }

    type_proxy<TC, TR> operator () (tint nRow, tint nCol) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        return this->_ij_proxy_val(nRow - CVM0, nCol - CVM0);
    }

    TC operator () (tint nRow, tint nCol) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        return this->_ij_val(nRow - CVM0, nCol - CVM0);
    }

    CVector operator () (tint nCol) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nCol, CVM0, this->nsize() + CVM0);
        return this->_col(nCol - CVM0);
    }

    CVector operator [] (tint nRow) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nRow, CVM0, this->msize() + CVM0);
        return this->_row(nRow - CVM0);
    }

    const CVector operator () (tint nCol) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nCol, CVM0, this->nsize() + CVM0);
        return this->_col(nCol - CVM0);
    }

    const CVector operator [] (tint nRow) const throw(cvmexception) {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nRow, CVM0, this->msize() + CVM0);
        return this->_row(nRow - CVM0);
    }

    CVector diag(tint nDiag) throw(cvmexception) {
        return this->_diag(nDiag);
    }

    const CVector diag(tint nDiag) const throw(cvmexception) {
        return this->_diag(nDiag);
    }

    const basic_rmatrix<TR> real() const
    {
        basic_rmatrix<TR> mRet(this->msize(), this->nsize());
        __copy<TR>(this->size(), __get_real_p<TR>(this->get()), this->incr() * 2, mRet, mRet.incr());
        return mRet;
    }

    const basic_rmatrix<TR> imag() const
    {
        basic_rmatrix<TR> mRet(this->msize(), this->nsize());
        __copy<TR>(this->size(), __get_imag_p<TR>(this->get()), this->incr() * 2, mRet, mRet.incr());
        return mRet;
    }

    basic_cmatrix& operator = (const basic_cmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.nsize());
        this->_massign(m);
        return *this;
    }

    basic_cmatrix& operator = (basic_cmatrix&& m) throw(cvmexception)
    {
        // size check is in BaseMatrix
        BaseMatrix::operator = (std::move(m));
        return *this;
    }

    basic_cmatrix& assign(const CVector& v) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->size(), v.size());
        this->_assign(v, v.incr());
        return *this;
    }

    basic_cmatrix& assign(const TC* pd)
    {
        this->_assign(pd, 1);
        return *this;
    }

    basic_cmatrix& assign(tint nRow, tint nCol, const basic_cmatrix& m) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        _check_gt(CVM_SIZESMISMATCH_GT, m.msize() + nRow - CVM0, this->msize());
        _check_gt(CVM_SIZESMISMATCH_GT, m.nsize() + nCol - CVM0, this->nsize());
        this->_assign_shifted(this->_sub_pointer_nocheck(nRow, nCol), m._pd(), m.msize(), m.nsize(), m.ld());
        return *this;
    }

    basic_cmatrix& set(TC c)
    {
        this->_set(c);
        return *this;
    }

    basic_cmatrix& assign_real(const basic_rmatrix<TR>& mRe) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mRe.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mRe.nsize());
        __copy_real<TR,TC>(this->get(), this->size(), this->incr(), mRe._pd(), mRe.incr());
        return *this;
    }

    basic_cmatrix& assign_imag(const basic_rmatrix<TR>& mIm) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mIm.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mIm.nsize());
        __copy_imag<TR,TC>(this->get(), this->size(), this->incr(), mIm._pd(), mIm.incr());
        return *this;
    }

    basic_cmatrix& set_real(TR d)
    {
        this->_set_real_number(d);
        return *this;
    }

    basic_cmatrix& set_imag(TR d)
    {
        this->_set_imag_number(d);
        return *this;
    }

    basic_cmatrix& resize(tint nNewM, tint nNewN) throw(cvmexception)
    {
        this->_resize2(nNewM, nNewN);
        return *this;
    }

    bool operator == (const basic_cmatrix& m) const {
        return this->msize() == m.msize() && this->nsize() == m.nsize() && this->_mequals(m);
    }

    bool operator != (const basic_cmatrix& m) const {
        return !operator == (m);
    }

    basic_cmatrix& operator << (const basic_cmatrix& m) throw(cvmexception)
    {
        this->_replace(m);
        this->_massign(m);
        return *this;
    }

    basic_cmatrix operator + (const basic_cmatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.nsize());
        basic_cmatrix mSum(*this);
        mSum._mincr(m);
        return mSum;
    }

    basic_cmatrix operator - (const basic_cmatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.nsize());
        basic_cmatrix mDiff(*this);
        mDiff._mdecr(m);
        return mDiff;
    }

    basic_cmatrix& sum(const basic_cmatrix& m1, const basic_cmatrix& m2) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m1.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m2.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m2.nsize());
        this->_msum(m1, m2);
        return *this;
    }

    basic_cmatrix& diff(const basic_cmatrix& m1, const basic_cmatrix& m2) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m1.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m2.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m2.nsize());
        this->_mdiff(m1, m2);
        return *this;
    }

    basic_cmatrix& operator += (const basic_cmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.nsize());
        this->_mincr(m);
        return *this;
    }

    basic_cmatrix& operator -= (const basic_cmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.nsize());
        this->_mdecr(m);
        return *this;
    }

    basic_cmatrix operator - () const
    {
        static const TR mone(-1.);
        basic_cmatrix mRes(*this);
        mRes._scalr(mone);
        return mRes;
    }

    basic_cmatrix operator * (TR dMult) const
    {
        basic_cmatrix mRes(*this);
        mRes._scalr(dMult);
        return mRes;
    }

    basic_cmatrix operator / (TR dDiv) const throw(cvmexception)
    {
        basic_cmatrix mRes(*this);
        mRes._div(dDiv);
        return mRes;
    }

    basic_cmatrix operator * (TC cMult) const
    {
        basic_cmatrix mRes(*this);
        mRes._scalc(cMult);
        return mRes;
    }

    basic_cmatrix operator / (TC cDiv) const throw(cvmexception)
    {
        basic_cmatrix mRes(*this);
        mRes._div(cDiv);
        return mRes;
    }

    basic_cmatrix& operator *= (TR dMult)
    {
        this->_scalr(dMult);
        return *this;
    }

    basic_cmatrix& operator /= (TR dDiv)
    {
        this->_div(dDiv);
        return *this;
    }

    basic_cmatrix& operator *= (TC cMult)
    {
        this->_scalc(cMult);
        return *this;
    }

    basic_cmatrix& operator /= (TC cDiv)
    {
        this->_div(cDiv);
        return *this;
    }

    basic_cmatrix& normalize()
    {
        this->_normalize();
        return *this;
    }

    basic_cmatrix operator !() const throw(cvmexception)
    {
        basic_cmatrix mRes(this->nsize(), this->msize());
        mRes._transp_m(*this);
        return mRes;
    }

    basic_cmatrix operator ~() const throw(cvmexception)
    {
        basic_cmatrix mRes(this->nsize(), this->msize());
        mRes._transp_m(*this);
        __conj<TC>(mRes.get(), mRes.size(), mRes.incr());
        return mRes;
    }

    basic_cmatrix& transpose(const basic_cmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.msize());
        if (this->get() == m.get()) {
            basic_cmatrix mTmp(m);
            this->_transp_m(mTmp);
        } else {
            this->_transp_m(m);
        }
        return *this;
    }

    basic_cmatrix& conj(const basic_cmatrix& m) throw(cvmexception)
    {
        this->transpose(m);
        __conj<TC>(this->get(), this->size(), this->incr());
        return *this;
    }

    basic_cmatrix& transpose() throw(cvmexception)
    {
        basic_cmatrix mTmp(*this);
        this->_resize2(this->nsize(), this->msize());
        this->_transp_m(mTmp);
        return *this;
    }

    basic_cmatrix& conj() throw(cvmexception)
    {
        this->transpose();
        __conj<TC>(this->get(), this->size(), this->incr());
        return *this;
    }

    CVector operator * (const CVector& v) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), v.size());
        CVector vRes(this->msize());
        this->_multiply(vRes, v, false);
        return vRes;
    }

    basic_cmatrix operator * (const basic_cmatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.msize());
        basic_cmatrix mRes(this->msize(), m.nsize());
        mRes.mult(*this, m);
        return mRes;
    }

    basic_cmatrix& mult(const basic_cmatrix& m1, const basic_cmatrix& m2) throw(cvmexception)
    {
        this->_mult(m1, m2);
        return *this;
    }

    basic_cmatrix& rank1update_u(const CVector& vCol, const CVector& vRow) throw(cvmexception)
    {
        static const TC one(1., 0.);
        this->_check_rank1update_u();
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vCol.size());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), vRow.size());
        this->_vanish();
        __geru<TC, basic_cmatrix, CVector>(*this, vCol, vRow, one);
        return *this;
    }

    basic_cmatrix& rank1update_c(const CVector& vCol, const CVector& vRow) throw(cvmexception)
    {
        static const TC one(1., 0.);
        this->_check_rank1update_c();
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vCol.size());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), vRow.size());
        this->_vanish();
        __gerc<TC, basic_cmatrix, CVector>(*this, vCol, vRow, one);
        return *this;
    }

    basic_cmatrix& swap_rows(tint n1, tint n2) throw(cvmexception)
    {
        this->_swap_rows(n1, n2);
        return *this;
    }

    basic_cmatrix& swap_cols(tint n1, tint n2) throw(cvmexception)
    {
        this->_swap_cols(n1, n2);
        return *this;
    }

    basic_cmatrix& solve(const basic_scmatrix<TR,TC>& mA, const basic_cmatrix& mB, TR& dErr) throw(cvmexception) {
        return _solve_helper(mA, mB, dErr, 0);
    }

// 6.1: transpose added
    basic_cmatrix& solve_tran(const basic_scmatrix<TR,TC>& mA, const basic_cmatrix& mB, TR& dErr) throw(cvmexception) {
        return _solve_helper(mA, mB, dErr, 1);
    }

// 6.1: conjugate added
    basic_cmatrix& solve_conj(const basic_scmatrix<TR,TC>& mA, const basic_cmatrix& mB, TR& dErr) throw(cvmexception) {
        return _solve_helper(mA, mB, dErr, 2);
    }

    basic_cmatrix& solve(const basic_scmatrix<TR,TC>& mA, const basic_cmatrix& mB) throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve(mA, mB, dErr);
    }

// 6.1: transpose added
    basic_cmatrix& solve_tran(const basic_scmatrix<TR,TC>& mA, const basic_cmatrix& mB) throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_tran(mA, mB, dErr);
    }

// 6.1: conjugate added
    basic_cmatrix& solve_conj(const basic_scmatrix<TR,TC>& mA, const basic_cmatrix& mB) throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_conj(mA, mB, dErr);
    }

    basic_cmatrix& solve_lu(const basic_scmatrix<TR,TC>& mA, const basic_scmatrix<TR,TC>& mLU, const tint* pPivots,
                            const basic_cmatrix& mB, TR& dErr) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mA.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mB.nsize());
        _check_ne(CVM_SIZESMISMATCH, mA.msize(), mB.msize());
        _check_ne(CVM_SIZESMISMATCH, mA.msize(), mLU.msize());
        mA._solve(mB, *this, dErr, mLU, pPivots, 0);
        return *this;
    }

    basic_cmatrix& solve_lu(const basic_scmatrix<TR,TC>& mA, const basic_scmatrix<TR,TC>& mLU, const tint* pPivots,
                            const basic_cmatrix& mB) throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_lu(mA, mLU, pPivots, mB, dErr);
    }

    RVector svd() const throw(cvmexception)
    {
        RVector vRes(_cvm_min<tint>(this->msize(), this->nsize()));
        this->_svd(vRes, nullptr, nullptr);
        return vRes;
    }

    RVector svd(basic_scmatrix<TR,TC>& mU, basic_scmatrix<TR,TC>& mVH) const throw(cvmexception)
    {
        RVector vRes(_cvm_min<tint>(this->msize(), this->nsize()));
        this->_svd(vRes, &mU, &mVH);
        return vRes;
    }

    basic_cmatrix pinv(TR threshold = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        basic_cmatrix mAx(this->nsize(), this->msize());
        this->_pinv(mAx, threshold);
        return mAx;
    }

    basic_cmatrix& pinv(const basic_cmatrix& mA, TR threshold = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mA.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mA.msize());
        mA._pinv(*this, threshold);
        return *this;
    }

    basic_cmatrix gels(bool conjugate, const basic_cmatrix& mB, basic_cvector<TR,TC>& vErr) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, vErr.size(), mB.nsize());
        _check_ne(CVM_SIZESMISMATCH, conjugate ? this->nsize() : this->msize(), mB.msize());
        basic_cmatrix mA(*this); // this algorithm overrides A
        basic_cmatrix mX;
        __gels(conjugate, mA, mB, mX, vErr);
        return mX;
    }

    basic_cmatrix& gels(bool conjugate, const basic_cmatrix& mA, const basic_cmatrix& mB,
                        basic_cvector<TR,TC>& vErr) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mB.nsize());
        _check_ne(CVM_SIZESMISMATCH, mB.nsize(), vErr.size());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), conjugate ? mA.msize() : mA.nsize());
        _check_ne(CVM_SIZESMISMATCH, mB.msize(), conjugate ? mA.nsize() : mA.msize());
        basic_cmatrix mA2(mA); // this algorithm overrides A
        __gels(conjugate, mA2, mB, *this, vErr);
        return *this;
    }

    basic_cvector<TR,TC> gels(bool conjugate, const basic_cvector<TR,TC>& vB, TC& dErr) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, conjugate ? this->nsize() : this->msize(), vB.size());
        basic_cmatrix mA(*this); // this algorithm overrides A
        basic_cmatrix mB(vB, vB.size(), 1);
        basic_cmatrix mX;
        basic_cvector<TR,TC> vErr(1);
        __gels(conjugate, mA, mB, mX, vErr);
        dErr = vErr(CVM0);
        const TC* pResult = mX;
        return basic_cvector<TR,TC>(pResult, mX.msize());
    }

    basic_cmatrix gelsy(const basic_cmatrix& mB, tint& rank,
                        TR tol = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mB.msize());
        basic_cmatrix mA(*this); // this algorithm overrides A
        basic_cmatrix mX;
        __gelsy(mA, mB, mX, tol, rank);
        return mX;
    }

    basic_cmatrix& gelsy(const basic_cmatrix& mA, const basic_cmatrix& mB,
                         tint& rank, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mA.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mB.nsize());
        _check_ne(CVM_SIZESMISMATCH, mA.msize(), mB.msize());
        basic_cmatrix mA2(mA); // this algorithm overrides A
        __gelsy(mA2, mB, *this, tol, rank);
        return *this;
    }

    basic_cvector<TR,TC> gelsy(const basic_cvector<TR,TC>& vB, tint& rank,
                                TR tol = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vB.size());
        basic_cmatrix mA(*this); // this algorithm overrides A
        basic_cmatrix mB(vB, vB.size(), 1);
        basic_cmatrix mX;
        __gelsy(mA, mB, mX, tol, rank);
        const TC* pResult = mX;
        return basic_cvector<TR,TC>(pResult, mX.msize());
    }

    basic_cmatrix gelss(const basic_cmatrix& mB, basic_rvector<TR>& sv, tint& rank,
                        TR tol = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        return _gels_sd(true, mB, sv, rank, tol);
    }

    basic_cmatrix& gelss(const basic_cmatrix& mA, const basic_cmatrix& mB, basic_rvector<TR>& sv,
                         tint& rank, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        _gels_sd(true, mA, mB, sv, rank, tol);
        return *this;
    }

    basic_cvector<TR,TC> gelss(const basic_cvector<TR,TC>& vB, basic_rvector<TR>& sv,
                                tint& rank, TR tol = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        return _gels_sd(true, vB, sv, rank, tol);
    }

    basic_cmatrix gelsd(const basic_cmatrix& mB, basic_rvector<TR>& sv, tint& rank,
                        TR tol = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        return _gels_sd(false, mB, sv, rank, tol);
    }

    basic_cmatrix& gelsd(const basic_cmatrix& mA, const basic_cmatrix& mB, basic_rvector<TR>& sv,
                         tint& rank, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        _gels_sd(false, mA, mB, sv, rank, tol);
        return *this;
    }

    basic_cvector<TR,TC> gelsd(const basic_cvector<TR,TC>& vB, basic_rvector<TR>& sv,
                                tint& rank, TR tol = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        return _gels_sd(false, vB, sv, rank, tol);
    }

    tint rank(TR tol = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        tint nRank = 0;
        RVector vS(_cvm_min<tint>(this->msize(), this->nsize()));
        this->_svd(vS, nullptr, nullptr);
        vS.normalize();
        for (; nRank < vS.size(); ++nRank) {
            if (vS[nRank * this->incr() + CVM0] < tol) break;
        }
        return nRank;
    }

// QR factorization
// Case 1: "economy" mode, A is (m x n) and Q is (m x n) and R is (n x n)
    void qr(basic_cmatrix<TR,TC>& mQ, basic_scmatrix<TR,TC>& mR) const throw(cvmexception) {
        this->_qr_rs(mQ, mR);
    }

// Case 2: full mode, A is (m x n) and Q is (m x m) and R is (m x n)
    void qr(basic_scmatrix<TR,TC>& mQ, basic_cmatrix<TR,TC>& mR) const throw(cvmexception) {
        this->_qr_sr(mQ, mR);
    }

// LQ factorization
// Case 1: "economy" mode, A is (m x n) and L is (m x m) and Q is (m x n)
    void lq(basic_scmatrix<TR,TC>& mL, basic_cmatrix<TR,TC>& mQ) const throw(cvmexception) {
        this->_lq_sr(mL, mQ);
    }

// Case 2: full mode, A is (m x n) and L is (m x n) and Q is (n x n)
    void lq(basic_cmatrix<TR,TC>& mL, basic_scmatrix<TR,TC>& mQ) const throw(cvmexception) {
        this->_lq_rs(mL, mQ);
    }

// RQ factorization
// Case 1: "ecomomy" mode, A is (m x n) and R is (m x m) and Q is (m x n)
    void rq(basic_scmatrix<TR,TC>& mR, basic_cmatrix<TR,TC>& mQ) const throw(cvmexception) {
        this->_rq_sr(mR, mQ);
    }

// Case 2: full mode, A is (m x n) and R is (m x n) and Q is (n x n)
    void rq(basic_cmatrix<TR,TC>& mR, basic_scmatrix<TR,TC>& mQ) const throw(cvmexception) {
        this->_rq_rs(mR, mQ);
    }

// QL factorization
// Case 1: "ecomomy" mode, A is (m x n) and Q is (m x n) and L is (n x n)
    void ql(basic_cmatrix<TR,TC>& mQ, basic_scmatrix<TR,TC>& mL) const throw(cvmexception) {
        this->_ql_rs(mQ, mL);
    }

// Case 2: full mode, A is (m x n) and Q is (m x m) and L is (m x n)
    void ql(basic_scmatrix<TR,TC>& mQ, basic_cmatrix<TR,TC>& mL) const throw(cvmexception) {
        this->_ql_sr(mQ, mL);
    }

// this += alpha * v_col * v_row (unconjugated)
    basic_cmatrix& geru(TC alpha, const CVector& vCol, const CVector& vRow) throw(cvmexception)
    {
        this->_check_geru();
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vCol.size());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), vRow.size());
        __geru<TC, basic_cmatrix, CVector>(*this, vCol, vRow, alpha);
        return *this;
    }

// this += alpha * v_col * v_row (conjugated)
    basic_cmatrix& gerc(TC alpha, const CVector& vCol, const CVector& vRow) throw(cvmexception)
    {
        this->_check_gerc();
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vCol.size());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), vRow.size());
        __gerc<TC, basic_cmatrix, CVector>(*this, vCol, vRow, alpha);
        return *this;
    }

// this = alpha * m1 * m2 + beta * this
    basic_cmatrix& gemm(const basic_cmatrix& m1, bool bConj1, const basic_cmatrix& m2,
                        bool bConj2, TC cAlpha, TC cBeta) throw(cvmexception)
    {
        this->_check_gemm();
        _check_ne(CVM_SIZESMISMATCH, this->msize(), bConj1 ? m1.nsize() : m1.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), bConj2 ? m2.msize() : m2.nsize());
        _check_ne(CVM_SIZESMISMATCH, bConj1 ? m1.msize() : m1.nsize(), bConj2 ? m2.nsize() : m2.msize());
        this->_gemm(bConj1, m1, bConj2, m2, cAlpha, cBeta);
        return *this;
    }

// this = alpha*a*b + beta*this of this = alpha*b*a + beta*this  where a is hermitian
    basic_cmatrix& hemm(bool bLeft, const basic_schmatrix<TR,TC>& ms, const basic_cmatrix& m,
                        TC cAlpha, TC cBeta) throw(cvmexception)
    {
        this->_check_hemm();
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.nsize());
        _check_ne(CVM_SIZESMISMATCH, bLeft ? this->msize() : this->nsize(), ms.msize());
        this->_hemm(bLeft, ms, m, cAlpha, cBeta);
        return *this;
    }

    basic_cmatrix& vanish()
    {
        this->_vanish();
        return *this;
    }

    basic_cmatrix& randomize_real(TR dFrom, TR dTo)
    {
        this->_randomize_real(dFrom, dTo);
        return *this;
    }

    basic_cmatrix& randomize_imag(TR dFrom, TR dTo)
    {
        this->_randomize_imag(dFrom, dTo);
        return *this;
    }

    // 2-norm (maximum singular value)
    TR norm2() const override
    {
        RVector vS(_cvm_min<tint>(this->msize(), this->nsize()));
        this->_svd(vS, nullptr, nullptr);
        return vS[CVM0];
    }

    void _div(TC d) throw(cvmexception)
    {
        if (_abs(d) <= basic_cvmMachMin<TR>()) {
            throw cvmexception(CVM_DIVISIONBYZERO);
        }
        static const TC one(1., 0.);
        this->_scalc(one / d);
    }

    // ?gemm routines perform a matrix-matrix operation with general matrices. The operation is defined as
    // c := alpha*op(a)*op(b) + beta*c,
    // where: op(x) is one of op(x) = x or op(x) = x' or op(x) = conjg(x'),
    void _gemm(bool bTrans1, const basic_cmatrix& m1, bool bTrans2, const basic_cmatrix& m2, TC dAlpha, TC dBeta) throw(cvmexception)
    {
        basic_cmatrix mTmp1, mTmp2;
        const TC* pD1 = m1.get();
        const TC* pD2 = m2.get();
        if (this->get() == pD1) mTmp1 << m1;
        if (this->get() == pD2) mTmp2 << m2;
        __gemm<TC, basic_cmatrix>(this->get() == pD1 ? mTmp1 : m1, bTrans1,
                                  this->get() == pD2 ? mTmp2 : m2, bTrans2, dAlpha, *this, dBeta);
    }

    // this = alpha*a*b + beta*this or this = alpha*b*a + beta*this  where a is hermitian
    void _hemm(bool bLeft, const basic_schmatrix<TR,TC>& ms, const basic_cmatrix& m, TC dAlpha, TC dBeta) throw(cvmexception)
    {
        basic_cmatrix mTmp;
        basic_schmatrix<TR,TC> msTmp;
        const TC* pD1 = ms.get();
        const TC* pD2 = m._pd();
        if (this->get() == pD1) msTmp << ms;
        if (this->get() == pD2) mTmp << m;
        __hemm<TC, basic_schmatrix<TR,TC>, basic_cmatrix>(bLeft, this->get() == pD1 ? msTmp : ms,
                                                           this->get() == pD2 ? mTmp : m, dAlpha, *this, dBeta);
    }

    // singular values in decreasing order
    virtual void _svd(RVector& vRes, basic_scmatrix<TR,TC>* pmU, basic_scmatrix<TR,TC>* pmVH) const throw(cvmexception)
    {
        if (pmU != nullptr && pmVH != nullptr) {
            _check_ne(CVM_SIZESMISMATCH, this->msize(), pmU->msize());
            _check_ne(CVM_SIZESMISMATCH, this->nsize(), pmVH->msize());
        }
        __svd<TR,basic_cmatrix, basic_scmatrix<TR,TC> >(vRes, vRes.size(), vRes.incr(), *this, pmU, pmVH);
    }

    virtual void _pinv(basic_cmatrix& mX, TR threshold) const throw(cvmexception) {
        __pinv<TR,basic_cmatrix, basic_cmatrix>(mX, *this, threshold);
    }

    virtual void _check_submatrix() const {
    }

    virtual void _scalc(TC d)
    {
        if (this->_continuous()) {
            __scal<TC, TC>(this->get(), this->size(), this->incr(), d);
        } else for (tint i = 0; i < this->nsize(); ++i) {
            __scal<TC, TC>(this->get() + this->ld() * i, this->msize(), this->incr(), d);
        }
    }

protected:
    // protected constructors for inherited stuff
    basic_cmatrix(tint nM, tint nN, tint nLD, bool bZeroMemory)
      : BaseMatrix(nM, nN, nLD, bZeroMemory)
    {
    }

    basic_cmatrix(tint size, tint incr, tint msize, tint nsize, tint ld)
      : BaseMatrix(size, incr, msize, nsize, ld)
    {
    }

    // non-const version shares memory
    basic_cmatrix(TC* pd, tint nM, tint nN, tint nLD, tint nSize)
      : BaseMatrix(pd, nM, nN, nLD, nSize)
    {
    }

    // const version makes a copy
    basic_cmatrix(const TC* pd, tint nM, tint nN, tint nLD, tint nSize)
      : BaseMatrix(pd, nM, nN, nLD, nSize)
    {
    }

    virtual CVector _diag(tint nDiag) throw(cvmexception)
    {
        tint nShift = 0;
        tint nSize = 0;
        this->_diag_helper(nDiag, nShift, nSize);
        return CVector(this->get() + nShift, nSize, this->ld() + 1);
    }

    virtual const CVector _diag(tint nDiag) const throw(cvmexception)
    {
        tint nShift = 0;
        tint nSize = 0;
        this->_diag_helper(nDiag, nShift, nSize);
        return CVector(this->get() + nShift, nSize, this->ld() + 1);
    }

    // compares matrix elements (equal sizes assumed)
    bool _mequals(const basic_cmatrix& m) const
    {
        return ((*this) - m).norminf() <= basic_cvmMachMin<TR>();
    }

    // ?gemv routines perform a matrix-vector operation defined as
    // vRes = alpha*m*v + beta * vRes or vRes = alpha*v'*m + beta * vRes
    // not virtual since __gemv calls all virtual methods inside
    void _gemv(bool bLeft, TC dAlpha, const CVector& v, TC dBeta, CVector& vRes) const
    {
        CVector vTmp;
        basic_cmatrix mTmp;
        const TC* pDv = v;
        if (vRes.get() == pDv) vTmp << v;
        if (vRes.get() == this->get()) mTmp << *this;
        __gemv<TC, basic_cmatrix, CVector>(bLeft, vRes.get() == this->get() ? mTmp : *this, dAlpha,
                                           vRes.get() == pDv ? vTmp : v, dBeta, vRes);
    }

    // 0-based, returns an l-value sharing memory
    virtual CVector _row(tint m) {
        return CVector(this->get() + m, this->nsize(), this->ld());
    }

    // 0-based, returns not an l-value (copy)
    virtual const CVector _row(tint m) const {
        return CVector(this->get() + m, this->nsize(), this->ld());
    }

    // 0-based, returns an l-value sharing memory
    virtual CVector _col(tint n) {
        return CVector(this->get() + this->ld() * n, this->msize());
    }

    // 0-based, returns not an l-value (copy)
    virtual const CVector _col(tint n) const {
        return CVector(this->get() + this->ld() * n, this->msize());
    }

    virtual void _mult(const basic_cmatrix& m1, const basic_cmatrix& m2) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m2.nsize());
        _check_ne(CVM_SIZESMISMATCH, m1.nsize(), m2.msize());
        static const TR zero = TR(0.);
        static const TR one = TR(1.);
        this->_gemm(false, m1, false, m2, one, zero);
    }

    virtual void _multiply(CVector& vRes, const CVector& v, bool bLeft) const
    {
        static const TR zero = TR(0.);
        static const TR one = TR(1.);
        this->_gemv(bLeft, one, v, zero, vRes);
    }

    void _set_real_number(TR d)
    {
        if (this->_continuous()) {
            _set_real<TR,TC>(this->get(), this->size(), this->incr(), d);
        } else for (tint i = 0; i < this->nsize(); ++i) {
            _set_real<TR,TC>(this->get() + this->ld() * i, this->msize(), this->incr(), d);
        }
    }

    virtual void _set_imag_number(TR d)
    {
        if (this->_continuous()) {
            _set_imag<TR,TC>(this->get(), this->size(), this->incr(), d);
        } else for (tint i = 0; i < this->nsize(); ++i) {
            _set_imag<TR,TC>(this->get() + this->ld() * i, this->msize(), this->incr(), d);
        }
    }

    virtual void _randomize_real(TR dFrom, TR dTo)
    {
        if (this->_continuous()) {
            __randomize_real<TC, TR>(this->get(), this->size(), this->incr(), dFrom, dTo);
        } else for (tint i = 0; i < this->nsize(); ++i) {
            __randomize_real<TC, TR>(this->get() + this->ld() * i, this->msize(), this->incr(), dFrom, dTo);
        }
    }

    virtual void _randomize_imag(TR dFrom, TR dTo)
    {
        if (this->_continuous()) {
            __randomize_imag<TC, TR>(this->get(), this->size(), this->incr(), dFrom, dTo);
        } else for (tint i = 0; i < this->nsize(); ++i) {
            __randomize_imag<TC, TR>(this->get() + this->ld() * i, this->msize(), this->incr(), dFrom, dTo);
        }
    }

    // QR factorization
    // Case 1: "economy" mode, A is (m x n) and Q is (m x n) and R is (n x n)
    void _qr_rs(basic_cmatrix<TR,TC>& mQ, basic_scmatrix<TR,TC>& mR) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mQ.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mR.msize());
        __qre<basic_cmatrix, basic_scmatrix<TR,TC> >(*this, mQ, mR);
    }

    // Case 2: full mode, A is (m x n) and Q is (m x m) and R is (m x n)
    void _qr_sr(basic_scmatrix<TR,TC>& mQ, basic_cmatrix<TR,TC>& mR) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mR.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mR.nsize());
        __qrf<basic_cmatrix, basic_scmatrix<TR,TC> >(*this, mQ, mR);
    }

    // RQ factorization
    // Case 1: "economy" mode, A is (m x n) and R is (m x m) and Q is (m x n)
    void _rq_sr(basic_scmatrix<TR,TC>& mR, basic_cmatrix<TR,TC>& mQ) const throw(cvmexception)
    {
        _check_gt(CVM_SIZESMISMATCH_GT, this->msize(), this->nsize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mQ.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mR.msize());
        __rqe<basic_cmatrix, basic_scmatrix<TR,TC> >(*this, mR, mQ);
    }

    // Case 2: full mode, A is (m x n) and R is (m x n) and Q is (n x n)
    void _rq_rs(basic_cmatrix<TR,TC>& mR, basic_scmatrix<TR,TC>& mQ) const throw(cvmexception)
    {
        _check_gt(CVM_SIZESMISMATCH_GT, this->msize(), this->nsize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mR.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mQ.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mR.nsize());
        __rqf<basic_cmatrix, basic_scmatrix<TR,TC> >(*this, mR, mQ);
    }

    // LQ factorization
    // Case 1: "economy" mode, A is (m x n) and L is (m x m) and Q is (m x n)
    void _lq_sr(basic_scmatrix<TR,TC>& mL, basic_cmatrix<TR,TC>& mQ) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mL.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mQ.nsize());
        __lqe<basic_cmatrix, basic_scmatrix<TR,TC> >(*this, mL, mQ);
    }

    // Case 2: full mode, A is (m x n) and L is (m x n) and Q is (n x n)
    void _lq_rs(basic_cmatrix<TR,TC>& mL, basic_scmatrix<TR,TC>& mQ) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mL.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mL.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mQ.nsize());
        __lqf<basic_cmatrix, basic_scmatrix<TR,TC> >(*this, mL, mQ);
    }

    // QL factorization
    // Case 1: "economy" mode, A is (m x n) and Q is (m x n) and L is (n x n)
    void _ql_rs(basic_cmatrix<TR,TC>& mQ, basic_scmatrix<TR,TC>& mL) const throw(cvmexception)
    {
        _check_lt(CVM_SIZESMISMATCH_LT, this->msize(), this->nsize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mQ.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mL.msize());
        __qle<basic_cmatrix, basic_scmatrix<TR,TC> >(*this, mQ, mL);
    }

    // Case 2: full mode, A is (m x n) and Q is (m x m) and L is (m x n)
    void _ql_sr(basic_scmatrix<TR,TC>& mQ, basic_cmatrix<TR,TC>& mL) const throw(cvmexception)
    {
        _check_lt(CVM_SIZESMISMATCH_LT, this->msize(), this->nsize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mL.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mL.nsize());
        __qlf<basic_cmatrix, basic_scmatrix<TR,TC> >(*this, mQ, mL);
    }

    virtual void _check_geru() { }
    virtual void _check_gerc() { }
    virtual void _check_rank1update_u() { }
    virtual void _check_rank1update_c() { }
    virtual void _check_gemm() { }
    virtual void _check_hemm() { }

private:
    basic_cmatrix& _solve_helper(const basic_scmatrix<TR,TC>& mA, const basic_cmatrix& mB,
                                 TR& dErr, int transp_mode) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mA.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mB.nsize());
        _check_ne(CVM_SIZESMISMATCH, mA.msize(), mB.msize());
        mA._solve(mB, *this, dErr, nullptr, nullptr, transp_mode);
        return *this;
    }

    // helper for svd and divide&conquer methods
    basic_cmatrix _gels_sd(bool svd, const basic_cmatrix& mB, basic_rvector<TR>& sv,
                           tint& rank, TR tol) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mB.msize());
        _check_ne(CVM_SIZESMISMATCH, _cvm_min<tint>(this->msize(), this->nsize()), sv.size());
        basic_cmatrix mA(*this); // this algorithm overrides A
        basic_cmatrix mX;
        basic_rvector<TR> sv1(sv.size()); // to ensure that incr=1
        if (svd) {
            __gelss(mA, mB, mX, tol, sv1, rank);
        } else {
            __gelsd(mA, mB, mX, tol, sv1, rank);
        }
        sv = sv1;
        return mX;
    }

    void _gels_sd(bool svd, const basic_cmatrix& mA, const basic_cmatrix& mB, basic_rvector<TR>& sv,
                  tint& rank, TR tol) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mA.nsize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mB.nsize());
        _check_ne(CVM_SIZESMISMATCH, mA.msize(), mB.msize());
        _check_ne(CVM_SIZESMISMATCH, _cvm_min<tint>(mA.msize(), mA.nsize()), sv.size());
        basic_cmatrix mA2(mA); // this algorithm overrides A
        basic_rvector<TR> sv1(sv.size()); // to ensure that incr=1
        if (svd) {
            __gelss(mA2, mB, *this, tol, sv1, rank);
        } else {
            __gelsd(mA2, mB, *this, tol, sv1, rank);
        }
        sv = sv1;
    }

    basic_cvector<TR,TC> _gels_sd(bool svd, const basic_cvector<TR,TC>& vB, basic_rvector<TR>& sv,
                                   tint& rank, TR tol) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vB.size());
        _check_ne(CVM_SIZESMISMATCH, _cvm_min<tint>(this->msize(), this->nsize()), sv.size());
        basic_cmatrix mA(*this); // this algorithm overrides A
        basic_cmatrix mB(vB, vB.size(), 1);
        basic_cmatrix mX;
        basic_rvector<TR> sv1(sv.size()); // to ensure that incr=1
        if (svd) {
            __gelss(mA, mB, mX, tol, sv1, rank);
        } else {
            __gelsd(mA, mB, mX, tol, sv1, rank);
        }
        sv = sv1;
        const TC* pResult = mX;
        return basic_cvector<TR,TC>(pResult, mX.msize());
    }
};


template<typename TR, typename TC>
class basic_scmatrix : public basic_cmatrix<TR,TC>, public SqMatrix<TR,TC>
{
    typedef basic_cvector<TR,TC> CVector;       
    typedef basic_array<TR,TC> BaseArray;       
    typedef Matrix<TR,TC> BaseMatrix;           
    typedef SqMatrix<TR,TC> BaseSqMatrix;       
    typedef basic_cmatrix<TR,TC> BaseCMatrix;   

public:
    basic_scmatrix()
    {
    }

    explicit basic_scmatrix(tint nDim)
      : BaseCMatrix(nDim, nDim)
    {
    }

    basic_scmatrix(TC* pd, tint nDim)
      : BaseCMatrix(pd, nDim, nDim)
    {
    }

    basic_scmatrix(const TC* pd, tint nDim)
      : BaseCMatrix(pd, nDim, nDim)
    {
    }

    basic_scmatrix(const basic_scmatrix& m)
      : BaseCMatrix(m.msize(), m.nsize(), m.msize(), false), BaseSqMatrix()
    {
        this->_massign(m);
    }

    basic_scmatrix(basic_scmatrix&& m) noexcept
       : BaseCMatrix(std::move(m))
    {
    }

    basic_scmatrix(const BaseCMatrix& m)
      : BaseCMatrix(m.msize(), m.nsize(), m.msize(), false)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), this->nsize());
        this->_massign(m);
    }

    explicit basic_scmatrix(const CVector& v)
      : BaseCMatrix(v.size(), v.size(), v.size(), true)
    {
        __copy<TC>(this->msize(), v, v.incr(), this->get(), this->msize() + 1);
    }

    explicit basic_scmatrix(const basic_srmatrix<TR>& m, bool bRealPart = true)
      : BaseCMatrix(m.msize(), m.msize(), m.msize(), true)
    {
        if (bRealPart) {
            __copy2<TR,TC>(this->get(), this->size(), this->incr(), m._pd(), nullptr);
        }
        else {
            __copy2<TR,TC>(this->get(), this->size(), this->incr(), nullptr, m._pd());
        }
    }

    basic_scmatrix(const TR* pRe, const TR* pIm, tint nDim)
      : BaseCMatrix(pRe, pIm, nDim, nDim)
    {
    }

    basic_scmatrix(const basic_srmatrix<TR>& mRe, const basic_srmatrix<TR>& mIm)
      : BaseCMatrix(mRe.msize(), mRe.nsize(), mRe.msize(), false)
    {
        _check_ne(CVM_SIZESMISMATCH, mRe.msize(), mIm.msize());
        _check_ne(CVM_SIZESMISMATCH, mRe.nsize(), mIm.nsize());
        __copy2<TR,TC>(this->get(), this->size(), this->incr(), mRe, mIm, mRe.incr(), mIm.incr());
    }

    basic_scmatrix(BaseCMatrix& m, tint nRow, tint nCol, tint nDim)
      : BaseCMatrix(m, nRow, nCol, nDim, nDim)
    {
        m._check_submatrix();
    }

    type_proxy<TC, TR> operator () (tint nRow, tint nCol) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        return this->_ij_proxy_val(nRow - CVM0, nCol - CVM0);
    }

    TC operator () (tint nRow, tint nCol) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        return this->_ij_val(nRow - CVM0, nCol - CVM0);
    }

    // returns column which is l-value
    CVector operator () (tint nCol) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nCol, CVM0, this->nsize() + CVM0);
        return this->_col(nCol - CVM0);
    }

    // returns column which is NOT l-value
    const CVector operator () (tint nCol) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nCol, CVM0, this->nsize() + CVM0);
        return this->_col(nCol - CVM0);
    }

    // returns row which is l-value
    CVector operator [] (tint nRow) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nRow, CVM0, this->msize() + CVM0);
        return this->_row(nRow - CVM0);
    }

    // returns row which is NOT l-value
    const CVector operator [] (tint nRow) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nRow, CVM0, this->msize() + CVM0);
        return this->_row(nRow - CVM0);
    }

    // real part
    const basic_srmatrix<TR> real() const
    {
        basic_srmatrix<TR> mRet(this->msize());
        __copy<TR>(this->size(), __get_real_p<TR>(this->get()), this->incr() * 2, mRet, mRet.incr());
        return mRet;
    }

    // imaginary part
    const basic_srmatrix<TR> imag() const
    {
        basic_srmatrix<TR> mRet(this->msize());
        __copy<TR>(this->size(), __get_imag_p<TR>(this->get()), this->incr() * 2, mRet, mRet.incr());
        return mRet;
    }

    basic_scmatrix& operator = (const basic_scmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        this->_massign(m);
        return *this;
    }

    basic_scmatrix& operator = (basic_scmatrix&& m) throw(cvmexception)
    {
        // size check is in BaseCMatrix
        BaseCMatrix::operator = (std::move(m));
        return *this;
    }

    // assigns vector
    basic_scmatrix& assign(const CVector& v) throw(cvmexception)
    {
        _check_gt(CVM_SIZESMISMATCH_GT, this->size(), v.size());
        this->_assign(v, v.incr());
        return *this;
    }

    // assigns external array (nIncr = 1)
    basic_scmatrix& assign(const TC* pd)
    {
        this->_assign(pd, 1);
        return *this;
    }

    basic_scmatrix& assign(tint nRow, tint nCol, const BaseCMatrix& m) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        _check_gt(CVM_SIZESMISMATCH_GT, m.msize() + nRow - CVM0, this->msize());
        _check_gt(CVM_SIZESMISMATCH_GT, m.nsize() + nCol - CVM0, this->nsize());
        this->_assign_shifted(this->_sub_pointer_nocheck(nRow, nCol), m._pd(), m.msize(), m.nsize(), m.ld());
        return *this;
    }

    // fills the content
    basic_scmatrix& set(TC c)
    {
        this->_set(c);
        return *this;
    }

    basic_scmatrix& assign_real(const basic_srmatrix<TR>& mRe) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mRe.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mRe.nsize());
        __copy_real<TR,TC>(this->get(), this->size(), this->incr(), mRe._pd(), mRe.incr());
        return *this;
    }

    basic_scmatrix& assign_imag(const basic_srmatrix<TR>& mIm) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mIm.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mIm.nsize());
        __copy_imag<TR,TC>(this->get(), this->size(), this->incr(), mIm._pd(), mIm.incr());
        return *this;
    }

    // fills real part
    basic_scmatrix& set_real(TR d)
    {
        this->_set_real_number(d);
        return *this;
    }

    // fills imaginary part
    basic_scmatrix& set_imag(TR d)
    {
        this->_set_imag_number(d);
        return *this;
    }

    basic_scmatrix& resize(tint nNewDim) throw(cvmexception)
    {
        this->_resize2(nNewDim, nNewDim);
        return *this;
    }

    basic_scmatrix& operator << (const basic_scmatrix& m) throw(cvmexception)
    {
        this->_replace(m);
        this->_massign(m);
        return *this;
    }

    basic_scmatrix operator + (const basic_scmatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        basic_scmatrix mSum(*this);
        mSum._mincr(m);
        return mSum;
    }

    basic_scmatrix operator - (const basic_scmatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        basic_scmatrix mDiff(*this);
        mDiff._mdecr(m);
        return mDiff;
    }

    basic_scmatrix& sum(const basic_scmatrix& m1, const basic_scmatrix& m2) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m2.msize());
        this->_msum(m1, m2);
        return *this;
    }

    basic_scmatrix& diff(const basic_scmatrix& m1, const basic_scmatrix& m2) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m2.msize());
        this->_mdiff(m1, m2);
        return *this;
    }

    basic_scmatrix& operator += (const basic_scmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        this->_mincr(m);
        return *this;
    }

    basic_scmatrix& operator -= (const basic_scmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        this->_mdecr(m);
        return *this;
    }

    basic_scmatrix operator - () const
    {
        static const TR mone(-1.);
        basic_scmatrix mRes(*this);
        mRes._scalr(mone);
        return mRes;
    }

    basic_scmatrix& operator ++ ()
    {
        this->_plus_plus();
        return *this;
    }

    basic_scmatrix operator ++ (int)
    {
        this->_plus_plus();
        return *this;
    }

    basic_scmatrix& operator -- ()
    {
        this->_minus_minus();
        return *this;
    }

    basic_scmatrix operator -- (int)
    {
        this->_minus_minus();
        return *this;
    }

    basic_scmatrix operator * (TR dMult) const
    {
        basic_scmatrix mRes(*this);
        mRes._scalr(dMult);
        return mRes;
    }

    basic_scmatrix operator / (TR dDiv) const throw(cvmexception)
    {
        basic_scmatrix mRes(*this);
        mRes._div(dDiv);
        return mRes;
    }

    basic_scmatrix operator * (TC cMult) const
    {
        basic_scmatrix mRes(*this);
        mRes._scalc(cMult);
        return mRes;
    }

    basic_scmatrix operator / (TC cDiv) const throw(cvmexception)
    {
        basic_scmatrix mRes(*this);
        mRes._div(cDiv);
        return mRes;
    }

    basic_scmatrix& operator *= (TR dMult)
    {
        this->_scalr(dMult);
        return *this;
    }

    basic_scmatrix& operator /= (TR dDiv)
    {
        this->_div(dDiv);
        return *this;
    }

    basic_scmatrix& operator *= (TC cMult)
    {
        this->_scalc(cMult);
        return *this;
    }

    basic_scmatrix& operator /= (TC cDiv)
    {
        this->_div(cDiv);
        return *this;
    }

    basic_scmatrix& normalize()
    {
        this->_normalize();
        return *this;
    }

// 6.1: transposed (not conjugated) matrix
    basic_scmatrix operator !() const throw(cvmexception)
    {
        basic_scmatrix mRes(*this);
        return mRes.transpose();
    }

    basic_scmatrix operator ~() const throw(cvmexception)
    {
        basic_scmatrix mRes(*this);
        return mRes.conj();
    }

// 6.1: this = transposed (not conjugated) (m)
    basic_scmatrix& transpose(const basic_scmatrix& m) throw(cvmexception)
    {
        (*this) = m;
        return this->transpose();
    }

    basic_scmatrix& conj(const basic_scmatrix& m) throw(cvmexception)
    {
        (*this) = m;
        return this->conj();
    }

// 6.1: this = transposed (not conjugate) (this)
    basic_scmatrix& transpose() throw(cvmexception)
    {
        this->_transp();
        return *this;
    }

    basic_scmatrix& conj() throw(cvmexception)
    {
        this->_conj();
        return *this;
    }

    CVector operator * (const CVector& v) const throw(cvmexception) {
        return this->BaseCMatrix::operator * (v);
    }

// special exclusion since matrix product is not commutative
    BaseCMatrix operator * (const BaseCMatrix& m) const throw(cvmexception) {
        return this->BaseCMatrix::operator * (m);
    }

    basic_scmatrix operator * (const basic_scmatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        basic_scmatrix mRes(this->msize());
        mRes.mult(*this, m);
        return mRes;
    }

    basic_scmatrix& operator *= (const basic_scmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        const basic_scmatrix mTmp(*this);
        this->mult(mTmp, m);
        return *this;
    }

    basic_scmatrix& swap_rows(tint n1, tint n2) throw(cvmexception)
    {
        this->_swap_rows(n1, n2);
        return *this;
    }

    basic_scmatrix& swap_cols(tint n1, tint n2) throw(cvmexception)
    {
        this->_swap_cols(n1, n2);
        return *this;
    }

// linear solvers
    CVector solve(const CVector& vB, TR& dErr) const throw(cvmexception) {
        return _solve_helper(vB, dErr, 0);
    }

// 6.1: transpose added
    CVector solve_tran(const CVector& vB, TR& dErr) const throw(cvmexception) {
        return _solve_helper(vB, dErr, 1);
    }

// 6.1: conjugate added
    CVector solve_conj(const CVector& vB, TR& dErr) const throw(cvmexception) {
        return _solve_helper(vB, dErr, 2);
    }

    CVector solve(const CVector& vB) const throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve(vB, dErr);
    }

// 6.1: transpose added
    CVector solve_tran(const CVector& vB) const throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_tran(vB, dErr);
    }

// 6.1: conjugate added
    CVector solve_conj(const CVector& vB) const throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_conj(vB, dErr);
    }

    BaseCMatrix solve(const BaseCMatrix& mB, TR& dErr) const throw(cvmexception) {
        return _solve_helper(mB, dErr, 0);
    }

// 6.1: transpose added
    BaseCMatrix solve_tran(const BaseCMatrix& mB, TR& dErr) const throw(cvmexception) {
        return _solve_helper(mB, dErr, 1);
    }

// 6.1: conjugate added
    BaseCMatrix solve_conj(const BaseCMatrix& mB, TR& dErr) const throw(cvmexception) {
        return _solve_helper(mB, dErr, 2);
    }

    BaseCMatrix solve(const BaseCMatrix& mB) const throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve(mB, dErr);
    }

// 6.1: transpose added
    BaseCMatrix solve_tran(const BaseCMatrix& mB) const throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_tran(mB, dErr);
    }

// 6.1: conjugate added
    BaseCMatrix solve_conj(const BaseCMatrix& mB) const throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_conj(mB, dErr);
    }

// 6.1: reversed MATLAB-style operator B/A returning solution of X*A=B equation
    CVector operator % (const CVector& vB) const throw(cvmexception) {
        return vB / (*this);
    }

// 6.1: reversed vector operator % returns solution of A*X=B equation
    CVector operator / (const CVector& vB) const throw(cvmexception) {
        return vB % (*this);
    }

    CVector solve_lu(const basic_scmatrix& mLU, const tint* pPivots,
                     const CVector& vB, TR& dErr) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vB.size());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mLU.msize());
        CVector vX(this->msize());
        this->_solve(vB, vX, dErr, mLU, pPivots, 0);
        return vX;
    }

    CVector solve_lu(const basic_scmatrix& mLU, const tint* pPivots, const CVector& vB) const throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_lu(mLU, pPivots, vB, dErr);
    }

    BaseCMatrix solve_lu(const basic_scmatrix& mLU, const tint* pPivots,
                         const BaseCMatrix& mB, TR& dErr) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mB.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mLU.msize());
        BaseCMatrix mX(mB.msize(), mB.nsize());
        this->_solve(mB, mX, dErr, mLU, pPivots, 0);
        return mX;
    }

    BaseCMatrix solve_lu(const basic_scmatrix& mLU, const tint* pPivots, const BaseCMatrix& mB) const throw(cvmexception)
    {
        static TR dErr(0.);
        return this->solve_lu(mLU, pPivots, mB, dErr);
    }

    TC det() const throw(cvmexception) {
        return this->_det();
    }

    basic_scmatrix& low_up(const basic_scmatrix& m, tint* nPivots) throw(cvmexception)
    {
        (*this) = m;
        this->_low_up(nPivots);
        return *this;
    }

    basic_scmatrix low_up(tint* nPivots) const throw(cvmexception)
    {
        basic_scmatrix mRes(*this);
        mRes._low_up(nPivots);
        return mRes;
    }

    TR cond() const throw(cvmexception)
    {
        TR dCondNum(0.);
        __cond_num<TR,basic_scmatrix>(*this, dCondNum); // universal method, no need to virtualize
        return dCondNum;
    }

    basic_scmatrix& inv(const basic_scmatrix& m) throw(cvmexception)
    {
        __inv<basic_scmatrix>(*this, m);
        return *this;
    }

    basic_scmatrix inv() const throw(cvmexception)
    {
        basic_scmatrix mRes(this->msize());
        __inv<basic_scmatrix>(mRes, *this);
        return mRes;
    }

    basic_scmatrix& exp(const basic_scmatrix& m, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        __exp<basic_scmatrix, TR>(*this, m, tol);
        return *this;
    }

    basic_scmatrix exp(TR tol = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        basic_scmatrix mRes(this->msize());
        __exp<basic_scmatrix, TR>(mRes, *this, tol);
        return mRes;
    }

// this = v(1)*I + v(2)*m + v(3)*m^2 + ... + v(N)*m^(N-1)
    basic_scmatrix& polynom(const basic_scmatrix& m, const CVector& v) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        CVector v1;
        if (v.incr() > 1) v1 << v;   // to make sure incr = 1
        __polynom<TC, CVector>(this->get(), this->ld(), this->msize(), m._pd(), m._ldm(), v.incr() > 1 ? v1 : v);
        return *this;
    }

// returns v(1)*I + v(2)*this + v(3)*this^2 + ... + v(N)*this^(N-1)
    basic_scmatrix polynom(const CVector& v) const
    {
        basic_scmatrix mRes(this->msize());
        CVector v1;
        if (v.incr() > 1) v1 << v;   // to make sure incr = 1
        __polynom<TC, CVector>(mRes.get(), mRes.ld(), this->msize(), this->get(), this->ld(), v.incr() > 1 ? v1 : v);
        return mRes;
    }

    CVector eig(basic_scmatrix& mEigVect, bool bRightVect = true) const throw(cvmexception)
    {
        CVector vEig(this->msize());
        this->_eig(vEig, &mEigVect, bRightVect);
        return vEig;
    }

    CVector eig() const throw(cvmexception)
    {
        CVector vEig(this->msize());
        this->_eig(vEig, nullptr, false);
        return vEig;
    }

    basic_scmatrix& cholesky(const basic_schmatrix<TR,TC>& m) throw(cvmexception)
    {
        this->_check_cholesky();  // doesn't work for band matrices
        *this = m;
        tint nOutInfo = __cholesky<basic_scmatrix>(*this);
        _check_negative(CVM_WRONGMKLARG, nOutInfo);
        _check_positive(CVM_NOTPOSITIVEDEFINITE, nOutInfo);
        this->_clean_low_triangle();
        return *this;
    }

    basic_scmatrix& bunch_kaufman(const basic_schmatrix<TR,TC>& m, tint* nPivots) throw(cvmexception)
    {
        this->_check_bunch_kaufman();  // doesn't work for band matrices
        *this = m;
        __bunch_kaufman<basic_scmatrix>(*this, nPivots);
        return *this;
    }

    void qr(basic_scmatrix<TR,TC>& mQ, basic_scmatrix<TR,TC>& mR) const throw(cvmexception) {
        this->_qr_ss(mQ, mR);
    }

    void lq(basic_scmatrix<TR,TC>& mL, basic_scmatrix<TR,TC>& mQ) const throw(cvmexception) {
        this->_lq_ss(mL, mQ);
    }

    void ql(basic_scmatrix<TR,TC>& mQ, basic_scmatrix<TR,TC>& mL) const throw(cvmexception) {
        this->_ql_ss(mQ, mL);
    }

    void rq(basic_scmatrix<TR,TC>& mR, basic_scmatrix<TR,TC>& mQ) const throw(cvmexception) {
        this->_rq_ss(mR, mQ);
    }

    basic_scmatrix& identity()
    {
        this->_vanish();
        this->_plus_plus();
        return *this;
    }

    basic_scmatrix& vanish()
    {
        this->_vanish();
        return *this;
    }

    basic_scmatrix& randomize_real(TR dFrom, TR dTo)
    {
        this->_randomize_real(dFrom, dTo);
        return *this;
    }

    basic_scmatrix& randomize_imag(TR dFrom, TR dTo)
    {
        this->_randomize_imag(dFrom, dTo);
        return *this;
    }

    virtual void _eig(CVector& vEig, basic_scmatrix<TR,TC>* mEigVect, bool bRightVect) const throw(cvmexception)
    {
        __eig<CVector, basic_scmatrix, basic_scmatrix>(vEig, *this, mEigVect, bRightVect);
    }

    virtual void _solve(const CVector& vB, CVector& vX,
                        TR& dErr, const TC* pLU, const tint* pPivots, int transp_mode) const throw(cvmexception)
    {
        vX = vB;
        CVector vB1;
        CVector vX1;
        if (vB.incr() > 1) vB1 << vB;   // to make sure incr = 1
        if (vX.incr() > 1) vX1 << vX;
        __solve<TR,TC, basic_scmatrix>(*this, 1, vB.incr() > 1 ? vB1 : vB, vB.size(), vX.incr() > 1 ? vX1 : vX, vX.size(),
                                        dErr, pLU, pPivots, transp_mode);
        if (vX.incr() > 1) vX = vX1;
    }

    virtual void _solve(const BaseCMatrix& mB, BaseCMatrix& mX,
                        TR& dErr, const TC* pLU, const tint* pPivots, int transp_mode) const throw(cvmexception)
    {
        mX = mB;
        __solve<TR,TC, basic_scmatrix>(*this, mB.nsize(), mB, mB.ld(), mX, mX.ld(), dErr, pLU, pPivots, transp_mode);
    }

    virtual const TC* _pv() const override {return this->get(); }
    virtual TC*       _pv()       override {return this->get(); }

protected:
    // protected constructors for inherited stuff
    basic_scmatrix(tint nDim, tint nLD, bool bZeroMemory)
      : BaseCMatrix(nDim, nDim, nLD, bZeroMemory)
    {
    }

    basic_scmatrix(tint size, tint incr, tint msize, tint nsize, tint ld)
      : BaseCMatrix(size, incr, msize, nsize, ld)
    {
    }

    // non-const version shares memory
    basic_scmatrix(TC* pd, tint nDim, tint nLD, tint nSize)
      : BaseCMatrix(pd, nDim, nDim, nLD, nSize)
    {
    }

    // const version makes a copy
    basic_scmatrix(const TC* pd, tint nDim, tint nLD, tint nSize)
      : BaseCMatrix(pd, nDim, nDim, nLD, nSize)
    {
    }

    tint _size() const override {return this->size();}
    tint _msize() const override {return this->msize();}
    tint _nsize() const override {return this->nsize();}
    tint _ld() const override {return this->ld();}

    // returns diagonal which IS l-value (shares memory)
    // 0 - main, negative - low, positive - up
    CVector _diag(tint nDiag) throw(cvmexception) override
    {
        const tint nD = _abs(nDiag);
        _check_ge(CVM_INDEX_GE, nD, this->msize());
        return CVector(this->get() + (nDiag > 0 ? nDiag * this->ld() : nD), this->msize() - nD, this->ld() + 1);
    }

    // returns diagonal which IS NOT l-value (creates a copy)
    // 0 - main, negative - low, positive - up
    const CVector _diag(tint nDiag) const throw(cvmexception) override
    {
        const tint nD = _abs(nDiag);
        _check_ge(CVM_INDEX_GE, nD, this->msize());
        return CVector(this->get() + (nDiag > 0 ? nDiag * this->ld() : nD), this->msize() - nD, this->ld() + 1);
    }

    // returns main diagonal of low_up factorization
    virtual CVector _low_up_diag(basic_array<tint,tint>& naPivots) const throw(cvmexception)
    {
        // let temp matrix be const to get a copy of its main diagonal
        const basic_scmatrix lu = this->low_up(naPivots);
        return lu.diag(0);
    }

    virtual void _transp() {
        this->_sq_transp();
    }

    // 6.1: it's reused in scb, overridden in sch
    virtual void _conj()
    {
        this->_transp();
        __conj<TC>(this->get(), this->size(), this->incr());
    }

    virtual void _plus_plus() {
        this->_sq_plus_plus();
    }

    virtual void _minus_minus() {
        this->_sq_minus_minus();
    }

    virtual TC _det() const throw(cvmexception)
    {
        TC cDet(0.);
        switch (this->msize()) {
        case 0:
            break;
        case 1:
            cDet = this->_ij_val(0, 0);
            break;
        case 2:
            cDet = this->_ij_val(0, 0) * this->_ij_val(1, 1) -
               this->_ij_val(1, 0) * this->_ij_val(0, 1);
            break;
        default:
            try {
                static const TC one(1., 0.);
                basic_array<tint,tint> naPivots(this->msize());
                CVector vUpDiag = this->_low_up_diag(naPivots);

                cDet = one;
                for (tint i = CVM0; i <= this->msize() - (1 - CVM0); ++i) {
                    cDet *= vUpDiag[i];
                    if (i + (1 - CVM0) != naPivots[i]) {
                        cDet = -cDet;
                    }
                }
            }
            catch (const cvmexception& e) {
                if (e.cause() != CVM_SINGULARMATRIX) throw e;
            }
            break;
        }
        return cDet;
    }

    virtual void _low_up(tint* nPivots) throw(cvmexception) {
        __low_up<basic_scmatrix>(*this, nPivots);
    }

    // QR - "economy" mode
    void _qr_ss(basic_scmatrix<TR,TC>& mQ, basic_scmatrix<TR,TC>& mR) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mR.msize());
        __qre<basic_cmatrix<TR,TC>, basic_scmatrix<TR,TC> >(*this, mQ, mR);
    }

    // RQ - "economy" mode
    void _rq_ss(basic_scmatrix<TR,TC>& mR, basic_scmatrix<TR,TC>& mQ) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mR.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        __rqe<basic_cmatrix<TR,TC>, basic_scmatrix<TR,TC> >(*this, mR, mQ);
    }

    // LQ - "economy" mode
    void _lq_ss(basic_scmatrix<TR,TC>& mL, basic_scmatrix<TR,TC>& mQ) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mL.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        __lqe<basic_cmatrix<TR,TC>, basic_scmatrix<TR,TC> >(*this, mL, mQ);
    }

    // QL - "economy" mode
    void _ql_ss(basic_scmatrix<TR,TC>& mQ, basic_scmatrix<TR,TC>& mL) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mQ.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mL.msize());
        __qle<basic_cmatrix<TR,TC>, basic_scmatrix<TR,TC> >(*this, mQ, mL);
    }

    virtual void _check_cholesky() { }
    virtual void _check_bunch_kaufman() { }

private:
    CVector _solve_helper(const CVector& vB, TR& dErr, int transp_mode) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vB.size());
        CVector vX(this->msize());
        this->_solve(vB, vX, dErr, nullptr, nullptr, transp_mode);
        return vX;
    }

    BaseCMatrix _solve_helper(const BaseCMatrix& mB, TR& dErr, int transp_mode) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mB.msize());
        BaseCMatrix mX(mB.msize(), mB.nsize());
        this->_solve(mB, mX, dErr, nullptr, nullptr, transp_mode);
        return mX;
    }
};


template<typename TR, typename TC>
class BandMatrix
{
protected:
    tint mkl; 
    tint mku; 

    BandMatrix()
      : mkl(0),
        mku(0)
    {
    }

    BandMatrix(tint nKL, tint nKU)
      : mkl(nKL),
        mku(nKU)
    {
    }

    virtual ~BandMatrix()
    {
    }

    virtual tint _size() const = 0;
    virtual tint _msize() const = 0;
    virtual tint _nsize() const = 0;
    virtual tint _ld() const = 0;
    virtual void _set_p(TC* pf) = 0;
    virtual void _set(TC* pf, tint nSize, tint nM, tint nN, tint nIncr, tint nLD) = 0;

    // it's the same as get, but let's keep get not virtual for performance sake
    virtual const TC* _pb() const = 0;
    virtual       TC* _pb() = 0;

#ifdef CVM_USE_POOL_MANAGER
    void _bresize(tint nNewM) throw(cvmexception)
#else
    void _bresize(std::shared_ptr<TC>& mp, tint nNewM)throw (cvmexception)
#endif
    {
        const tint mm = this->_msize();
        const tint nSize = this->_size();
        if (nNewM != mm) {
            _check_lt(CVM_WRONGSIZE_LT, nNewM, TINT_ZERO);
            const tint nNewSize = nNewM * (1 + this->lsize() + this->usize());
            TC* pd = cvmMalloc<TC>(nNewSize);
            if (nNewSize > nSize) cvmZeroMemory<TC>(pd, nNewSize);
            const tint nMinSize = _cvm_min<tint>(nSize, nNewSize);
            if (nMinSize > 0) {
                __copy<TC>(nMinSize, this->_pb(), 1, pd, 1);
                CVM_ASSERT(pd, nNewSize * sizeof(TC))
            }
#ifdef CVM_USE_POOL_MANAGER
            TC* pB = this->_pb();
            cvmFree<TC>(pB);
            this->_set(pd, nNewSize, nNewM, nNewM, 1, nNewSize > 0 ? 1 + this->lsize() + this->usize() : 0);
#else
            mp.reset(pd, ArrayDeleter<TC>());
            this->_set(nullptr, nNewSize, nNewM, nNewM, 1, nNewSize > 0 ? 1 + this->lsize() + this->usize() : 0);
#endif
        }
    }

    void _check_dimensions() const throw(cvmexception)
    {
        _check_lt(CVM_WRONGSIZE_LT, this->lsize(), TINT_ZERO);
        _check_lt(CVM_WRONGSIZE_LT, this->usize(), TINT_ZERO);
    }

    void _check_dimensions(const BandMatrix& m) const throw(cvmexception) {
        _check_ne(CVM_SIZESMISMATCH, this->_msize(), m._msize());
        _check_ne(CVM_SIZESMISMATCH, this->lsize(), m.lsize());
        _check_ne(CVM_SIZESMISMATCH, this->usize(), m.usize());
    }

    bool _bcontinuous() const {
        return this->_msize() == 0 || this->_ld() == 1 + this->lsize() + this->usize();
    }

    // m is a band matrix here
    void _mbassign(const Matrix<TR,TC>& m)
    {
        TC* pd = _pb();
        if (pd != m.get()) {
            __copy<TC>(this->_size(), m, m.incr(), pd, 1);
        }
    }

    // fills the content, doesn't touch head and tail
    void _b_for_each(TC d, bool bRandom, bool bReal, TR dFrom, TR dTo)
    {
        tint i, jc, ju, jl;
        const tint nCol = 1 + this->lsize() + this->usize();
        TC* pB = _pb();
        const tint mn = this->_nsize();
        for (tint j = 0; j < mn; ++j) {
            jc = j * nCol;
            ju = this->usize() - j;
            jl = ju + mn;
            for (i = 0; i < nCol; ++i) {
                if (i >= ju && i < jl) {
                    CVM_ASSERT(pB, (jc + i + 1) * sizeof(TC))
                    if (bRandom) {
                        TR* pd = bReal ? __get_real_p<TR>(pB + (jc + i)) : __get_imag_p<TR>(pB + (jc + i));
                        *pd = Randomizer<TR>::get(dFrom, dTo);
                    } else {
                        pB[jc + i] = d;
                    }
                }
            }
        }
    }

    // fills the content, doesn't touch head and tail
    void _bset(TC d)
    {
        static const TR zero = TR(0.);
        this->_b_for_each(d, false, false, zero, zero);
    }

    // fills the content, doesn't touch head and tail
    void _b_randomize(bool bReal, TR dFrom, TR dTo)
    {
        static const TC zero(0.);
        this->_b_for_each(zero, true, bReal, dFrom, dTo);
    }

    // 1-norm
    TR _bnorm1() const
    {
        tint i, j;
        tint nLen   = 0;
        tint nShift = 0;
        TR  rNorm  = TR(0.);
        TR  rSum;
        const tint mn = this->_nsize();
        basic_array<TR,TC> rv(this->_msize());

        for (j = 0; j < mn; ++j) {
            rSum = TR(0.);
            this->_get_col(j, rv, 1, &nLen, &nShift);

            nLen += nShift;
            for (i = nShift + 1; i <= nLen; ++i) {
                rSum += _abs(rv[i - (1 - CVM0)]);
            }

            if (rSum > rNorm) {
                rNorm = rSum;
            }
        }
        return rNorm;
    }

    // infinity-norm
    TR _bnorminf() const
    {
        tint i, j;
        tint nLen = 0;
        tint nShift = 0;
        TR  rNorm = TR(0.);
        TR  rSum;
        const tint mm = this->_msize();
        basic_array<TR,TC> rv(this->_nsize());

        for (i = 0; i < mm; ++i) {
            rSum = TR(0.);
            this->_get_row(i, rv, 1, &nLen, &nShift);

            nLen += nShift;
            for (j = nShift + 1; j <= nLen; ++j) {
                rSum += _abs(rv[j - (1 - CVM0)]);
            }

            if (rSum > rNorm) {
                rNorm = rSum;
            }
        }
        return rNorm;
    }

    void _bvanish() {
        this->_bset(TC(0.));
    }

    // zero based
    type_proxy<TC, TR> _b_ij_proxy_val(tint i, tint j)
    {
        static const TC zero = TC(0.);
        TC* pd = _pb();
        const tint nA = j - this->usize();
        CVM_ASSERT(pd, (i + j * (1 + this->lsize() + this->usize()) - nA + 1) * sizeof(TC))
        return(nA < 0 || i >= nA) && i <= this->lsize() + j ? type_proxy<TC, TR>(pd[i + j * (1 + this->lsize() + this->usize()) - nA], false) :
                                                              type_proxy<TC, TR>(zero, true);
    }

    // zero based
    TC _b_ij_val(tint i, tint j) const
    {
        static const TC zero = TC(0.);
        const TC* pd = _pb();
        const tint nA = j - this->usize();
        CVM_ASSERT(pd, (i + j * (1 + this->lsize() + this->usize()) - nA + 1) * sizeof(TC))
        return(nA < 0 || i >= nA) && i <= this->lsize() + j ? pd[i + j * (1 + this->lsize() + this->usize()) - nA] : zero;
    }

    void _get_col(tint i, TC* pCol, tint nIncr, tint* pnLen = nullptr, tint* pnShift = nullptr) const
    {
        const TC* pd = _pb();
        const tint mm = this->_msize();
        const tint mn = this->_nsize();
        const tint nCol = 1 + this->lsize() + this->usize();
        tint nS         = nCol;
        tint nShiftSrc  = 0;
        tint nShiftDest = 0;

        if (i > this->usize()) {
            nShiftDest = i - this->usize();
        } else {
            nShiftSrc = this->usize() - i;
            nS -= nShiftSrc;
        }

        if (mm - i <= this->lsize()) {
            nS -= this->lsize() + 1 - (mn - i);
        }

        __copy<TC>(nS,
                   pd + i * nCol + nShiftSrc,
                   1,
                   pCol + nShiftDest,
                   nIncr);

        if (pnLen) *pnLen = nS;
        if (pnShift) *pnShift = nShiftDest;
    }

    void _get_row(tint i, TC* pCol, tint nIncr, tint* pnLen = nullptr, tint* pnShift = nullptr) const
    {
        const TC* pd = _pb();
        const tint mm = this->_msize();
        const tint mn = this->_nsize();
        const tint nCol = this->lsize() + this->usize();
        tint nS         = mn;
        tint nShiftSrc  = i + this->usize();
        tint nShiftDest = 0;

        if (i > this->lsize()) {
            nShiftDest = i - this->lsize();
            nShiftSrc += nShiftDest * nCol;
            nS -= nShiftDest;
        }
        if (mn - i > this->usize()) {
            nS -= (mm - i) - this->usize() - 1;
        }

        __copy<TC>(nS,
                   pd + nShiftSrc,
                   nCol,
                   pCol + nShiftDest,
                   nIncr);

        if (pnLen) *pnLen = nS;
        if (pnShift) *pnShift = nShiftDest;
    }

// matrix replacement, no assignment
#ifdef CVM_USE_POOL_MANAGER
    void _btransp() throw(cvmexception)
#else
    void _btransp(std::shared_ptr<TC>& mp)throw (cvmexception)
#endif
    {
        TC* mpd = _pb();
        const tint mn = this->_nsize();
        if (this->lsize() > 0 || this->usize() > 0) {
            const tint nLU  = this->lsize() + this->usize();
            const tint nCol = 1 + nLU;
            const tint nEls = nCol * mn;
            tint nS, nShiftSrc;
            TC* pL;
            TC* pR;
            TC* pd = cvmMalloc<TC>(nEls);
            cvmZeroMemory(pd, nEls);

            for (tint i = 0; i < mn; ++i) {
                nS = nCol;
                nShiftSrc = 0;

                if (i < this->usize()) {
                    nShiftSrc = this->usize() - i;
                    nS -= nShiftSrc;
                }
                if (mn - i <= this->lsize()) {
                    nS -= this->lsize() + 1 - (mn - i);
                }

                pL = mpd + i * nCol + nShiftSrc;
                pR = pd + (i > this->usize() ? (i - this->usize() + 1) * nCol - 1 : this->lsize() + i);

                __copy<TC>(nS, pL, 1, pR, nLU);
            }
            std::swap(mkl, mku);
#ifdef CVM_USE_POOL_MANAGER
            cvmFree<TC>(mpd);
            this->_set_p(pd);
#else
            mp.reset(pd, ArrayDeleter<TC>());
            this->_set_p(nullptr);
#endif
        }
    }

    void _b_plus_plus()
    {
        TC* pd = _pb();
        static const TC one(1.);
        const tint mn = this->_nsize();
        const tint nNext = 1 + this->lsize() + this->usize();
        const tint nSize = nNext * mn;
        CVM_ASSERT(pd, nSize * sizeof(TC))
        for (tint i = this->usize(); i < nSize; i += nNext) {
            pd[i] += one;
        }
    }

    void _b_minus_minus()
    {
        TC* pd = _pb();
        static const TC one(1.);
        const tint mn = this->_nsize();
        const tint nNext = 1 + this->lsize() + this->usize();
        const tint nSize = nNext * mn;
        CVM_ASSERT(pd, nSize * sizeof(TC))
        for (tint i = this->usize(); i < nSize; i += nNext) {
            pd[i] -= one;
        }
    }

    // matrix replacement, no assignment
#ifdef CVM_USE_POOL_MANAGER
    void _b_replace(const BandMatrix& m) throw(cvmexception)
#else
    void _b_replace(std::shared_ptr<TC>& mp, const BandMatrix& m) throw(cvmexception)
#endif
    {
#ifdef CVM_USE_POOL_MANAGER
        TC* pB = _pb();
        cvmFree<TC>(pB);
#endif
        tint nSize = m._size();
        TC* pd = cvmMalloc<TC>(nSize);
        CVM_ASSERT(pd, (nSize * sizeof(TC)))
        mkl = m.lsize();
        mku = m.usize();
#ifdef CVM_USE_POOL_MANAGER
        this->_set(pd, nSize, m._msize(), m._nsize(), 1, m._ld());
#else
        mp.reset(pd, ArrayDeleter<TC>());
        this->_set(nullptr, nSize, m._msize(), m._nsize(), 1, m._ld());
#endif
    }

#ifdef CVM_USE_POOL_MANAGER
    void _resize_lu(tint nNewKL, tint nNewKU) throw(cvmexception)
#else
    void _resize_lu(std::shared_ptr<TC>& mp, tint nNewKL, tint nNewKU) throw(cvmexception)
#endif
    {
        if (nNewKL != this->lsize() || nNewKU != this->usize()) {
            if (this->lsize() < 0) throw cvmexception(CVM_WRONGSIZE, this->lsize());
            if (this->usize() < 0) throw cvmexception(CVM_WRONGSIZE, this->usize());
            TC* pB = _pb();
            const tint mm = this->_msize();
            const tint mn = this->_nsize();
            const tint nOldLD = 1 + this->lsize() + this->usize();
            const tint nNewLD = 1 + nNewKL + nNewKU;
            const tint nMinKL = _cvm_min<tint>(this->lsize(), nNewKL);
            const tint nMinKU = _cvm_min<tint>(this->usize(), nNewKU);
            const tint nNewSize = mn * (1 + nNewKL + nNewKU);
            TC* pd = cvmMalloc<TC>(nNewSize);
            CVM_ASSERT(pd, nNewSize * sizeof(TC))
            cvmZeroMemory<TC>(pd, nNewSize);
            for (tint i = -nMinKU; i <= nMinKL; ++i) {
                __copy<TC>(mn, pB + (this->usize() + i), nOldLD, pd + (nNewKU + i), nNewLD);
            }
            mkl = nNewKL;
            mku = nNewKU;
#ifdef CVM_USE_POOL_MANAGER
            cvmFree<TC>(pB);
            this->_set(pd, nNewSize, mm, mn, 1, nNewLD);
#else
            mp.reset(pd, ArrayDeleter<TC>());
            this->_set(nullptr, nNewSize, mm, mn, 1, nNewLD);
#endif
        }
    }

public:
    tint lsize() const {
        return mkl;
    }

    tint usize() const {
        return mku;
    }

    const tint* _pl() const {
        return&mkl;
    }

    const tint* _pu() const {
        return&mku;
    }
};


template<typename TR>
class basic_srbmatrix : public basic_srmatrix<TR>, public BandMatrix<TR,TR>
{
    typedef std::complex<TR> TC;                
    typedef basic_rvector<TR> RVector;          
    typedef basic_cvector<TR,TC> CVector;      
    typedef basic_array<TR,TR> BaseArray;      
    typedef Matrix<TR,TR> BaseMatrix;          
    typedef basic_rmatrix<TR> BaseRMatrix;      
    typedef basic_srmatrix<TR> BaseSRMatrix;    
    typedef BandMatrix<TR,TR> BaseBandMatrix;  

    friend class basic_scbmatrix<TR,TC>;  // basic_scbmatrix constructor

protected:
    mutable BaseSRMatrix mSM;   

public:
    basic_srbmatrix()
      : mSM()
    {
    }

    explicit basic_srbmatrix(tint nDim)
      : BaseSRMatrix(nDim, 1, true),
        BaseBandMatrix(0, 0)
    {
    }

    basic_srbmatrix(tint nDim, tint nKL, tint nKU)
      : BaseSRMatrix(nDim, 1 + nKL + nKU, true),
        BaseBandMatrix(nKL, nKU), mSM()
    {
        this->_check_dimensions();
    }

    basic_srbmatrix(TR* pd, tint nDim, tint nKL, tint nKU)
      : BaseSRMatrix(pd, nDim, 1 + nKL + nKU, nDim * (1 + nKL + nKU)),
        BaseBandMatrix(nKL, nKU), mSM()
    {
        this->_check_dimensions();
    }

    basic_srbmatrix(const TR* pd, tint nDim, tint nKL, tint nKU)
      : BaseSRMatrix(pd, nDim, 1 + nKL + nKU, nDim * (1 + nKL + nKU)),
        BaseBandMatrix(nKL, nKU), mSM()
    {
        this->_check_dimensions();
    }

    basic_srbmatrix(const basic_srbmatrix& m)
      : BaseSRMatrix(m.msize(), 1 + m.lsize() + m.usize(), false),
        BaseBandMatrix(m.lsize(), m.usize()), mSM()
    {
        this->_massign(m);
    }

    basic_srbmatrix(basic_srbmatrix&& m) noexcept
      : BaseSRMatrix(m.size(), m.incr(), m.msize(), m.nsize(), m.ld()),
        BaseBandMatrix(m.lsize(), m.usize()), mSM()
    {
        this->_mmove(std::move(m));
    }

    basic_srbmatrix(const BaseRMatrix& m, tint nKL, tint nKU)
      : BaseSRMatrix(m.msize(), 1 + nKL + nKU, false), BaseBandMatrix(nKL, nKU), mSM()
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), this->nsize());
        this->_check_dimensions();
        _copy_b_matrix<TR,TR, BaseRMatrix, basic_srbmatrix>(const_cast<BaseRMatrix&>(m), *this, true);
    }

    explicit basic_srbmatrix(const RVector& v)
      : BaseSRMatrix(v.size(), 1, false),
        BaseBandMatrix(0, 0)
    {
        __copy<TR>(this->msize(), v, v.incr(), this->get(), 1);
    }

    type_proxy<TR,TR> operator () (tint nRow, tint nCol) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        return this->_ij_proxy_val(nRow - CVM0, nCol - CVM0);
    }

    TR operator () (tint nRow, tint nCol) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        return this->_ij_val(nRow - CVM0, nCol - CVM0);
    }

    // returns column which CAN NOT be l-value
    const RVector operator () (tint nCol) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nCol, CVM0, this->nsize() + CVM0);
        return this->_col(nCol - CVM0);
    }

    // returns row which CAN NOT be l-value
    const RVector operator [] (tint nRow) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nRow, CVM0, this->msize() + CVM0);
        return this->_row(nRow - CVM0);
    }

    basic_srbmatrix& operator = (const basic_srbmatrix& m) throw(cvmexception)
    {
        this->_check_dimensions(m);
        this->_massign(m);
        return *this;
    }

    basic_srbmatrix& operator = (basic_srbmatrix&& m) throw(cvmexception)
    {
        this->_check_dimensions(m);
        BaseSRMatrix::operator = (std::move(m));
        return *this;
    }

    // assigns vector
    basic_srbmatrix& assign(const RVector& v) throw(cvmexception)
    {
        _check_gt(CVM_SIZESMISMATCH_GT, this->size(), v.size());
        this->_assign(v, v.incr());
        return *this;
    }

    // assigns external array (nIncr = 1)
    basic_srbmatrix& assign(const TR* pd)
    {
        this->_assign(pd, 1);
        return *this;
    }

    // fills the content
    basic_srbmatrix& set(TR d)
    {
        this->_set(d);
        return *this;
    }

    basic_srbmatrix& resize(tint nNewDim) throw(cvmexception)
    {
        this->_resize2(nNewDim, nNewDim);
        return *this;
    }

    basic_srbmatrix& resize_lu(tint nNewKL, tint nNewKU) throw(cvmexception)
    {
#ifdef CVM_USE_POOL_MANAGER
        this->_resize_lu(nNewKL, nNewKU);
#else
        this->_resize_lu(this->mp, nNewKL, nNewKU);
#endif
        return *this;
    }

    bool operator == (const basic_srbmatrix& m) const
    {
        return this->msize() == m.msize() && this->nsize() == m.nsize() &&
            this->lsize() == m.lsize() && this->usize() == m.usize() &&
            this->_mequals(m);
    }

    bool operator != (const basic_srbmatrix& m) const {
        return !(this->operator == (m));
    }

    basic_srbmatrix& operator << (const basic_srbmatrix& m) throw(cvmexception)
    {
        this->_check_ld(); // submatrix replacement is obviously not possible
#ifdef CVM_USE_POOL_MANAGER
        this->_b_replace(m);
#else
        this->_b_replace(this->mp, m);
#endif
        this->_massign(m);
        return *this;
    }

    basic_srbmatrix operator + (const basic_srbmatrix& m) const throw(cvmexception)
    {
        this->_check_dimensions(m);
        basic_srbmatrix mSum(*this);
        mSum._mincr(m);
        return mSum;
    }

    basic_srbmatrix operator - (const basic_srbmatrix& m) const throw(cvmexception)
    {
        this->_check_dimensions(m);
        basic_srbmatrix mDiff(*this);
        mDiff._mdecr(m);
        return mDiff;
    }

    basic_srbmatrix& sum(const basic_srbmatrix& m1, const basic_srbmatrix& m2) throw(cvmexception)
    {
        this->_check_dimensions(m1);
        this->_check_dimensions(m2);
        this->_msum(m1, m2);
        return *this;
    }

    basic_srbmatrix& diff(const basic_srbmatrix& m1, const basic_srbmatrix& m2) throw(cvmexception)
    {
        this->_check_dimensions(m1);
        this->_check_dimensions(m2);
        this->_mdiff(m1, m2);
        return *this;
    }

    basic_srbmatrix& operator += (const basic_srbmatrix& m) throw(cvmexception)
    {
        this->_check_dimensions(m);
        this->_mincr(m);
        return *this;
    }

    basic_srbmatrix& operator -= (const basic_srbmatrix& m) throw(cvmexception)
    {
        this->_check_dimensions(m);
        this->_mdecr(m);
        return *this;
    }

    basic_srbmatrix operator - () const
    {
        static const TR mone(-1.);
        basic_srbmatrix mRes(*this);
        mRes._scalr(mone);
        return mRes;
    }

    basic_srbmatrix& operator ++ ()
    {
        this->_plus_plus();
        return *this;
    }

    basic_srbmatrix operator ++ (int)
    {
        this->_plus_plus();
        return *this;
    }

    basic_srbmatrix& operator -- ()
    {
        this->_minus_minus();
        return *this;
    }

    basic_srbmatrix operator -- (int)
    {
        this->_minus_minus();
        return *this;
    }

    basic_srbmatrix operator * (TR dMult) const
    {
        basic_srbmatrix mRes(*this);
        mRes._scalr(dMult);
        return mRes;
    }

    basic_srbmatrix operator / (TR dDiv) const throw(cvmexception)
    {
        basic_srbmatrix mRes(*this);
        mRes._div(dDiv);
        return mRes;
    }

    basic_srbmatrix& operator *= (TR dMult)
    {
        this->_scalr(dMult);
        return *this;
    }

    basic_srbmatrix& operator /= (TR dDiv) throw(cvmexception)
    {
        this->_div(dDiv);
        return *this;
    }

    basic_srbmatrix& normalize()
    {
        this->_normalize();
        return *this;
    }

    // transposed Matrix
    basic_srbmatrix operator ~() const throw(cvmexception)
    {
        basic_srbmatrix mRes(*this);
        return mRes.transpose();
    }

    basic_srbmatrix& transpose(const basic_srbmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        _check_ne(CVM_SIZESMISMATCH, this->lsize(), m.usize());
        _check_ne(CVM_SIZESMISMATCH, this->usize(), m.lsize());
        *this << ~m;
        return *this;
    }

    basic_srbmatrix& transpose() throw(cvmexception)
    {
        this->_transp();
        return *this;
    }

    RVector operator * (const RVector& v) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), v.size());
        RVector vRes(this->msize());
        this->_multiply(vRes, v, false);
        return vRes;
    }

    // special exclusion since matrix product is not commutative
    BaseRMatrix operator * (const BaseRMatrix& m) const throw(cvmexception)
    {
        _bake_SM();
        return mSM * m;
    }

    BaseSRMatrix operator * (const BaseSRMatrix& m) const throw(cvmexception)
    {
        _bake_SM();
        return mSM * m;
    }

    basic_srbmatrix operator * (const basic_srbmatrix& m) const throw(cvmexception)
    {
        _bake_SM();
        m._bake_SM();
        return basic_srbmatrix(mSM * m.mSM,
                               _cvm_min<tint>(this->msize() - 1, this->lsize() + m.lsize()),
                               _cvm_min<tint>(this->msize() - 1, this->usize() + m.usize()));
    }

    // 6.1: reversed vector operator % returns solution of A*X=B equation
    // overridden to mask out operator / (TR)
    RVector operator / (const RVector& v) const throw(cvmexception) {
        return v % (*this);
    }

    basic_srbmatrix& low_up(const basic_srbmatrix& m, tint* nPivots) throw(cvmexception)
    {
        (*this) = m;
        this->_low_up(nPivots);
        return *this;
    }

    basic_srbmatrix low_up(tint* nPivots) const throw(cvmexception)
    {
        basic_srbmatrix mRes(*this);
        mRes._low_up(nPivots);
        return mRes;
    }

    basic_srbmatrix& identity()
    {
        this->_vanish();
        this->_plus_plus();
        return *this;
    }

    basic_srbmatrix& vanish()
    {
        this->_vanish();
        return *this;
    }

    basic_srbmatrix& randomize(TR dFrom, TR dTo)
    {
        this->_b_randomize(true, dFrom, dTo);
        return *this;
    }

    // Euclid norm - band matrices require special care because of tails
    TR norm() const override
    {
        TR dNorm = TR(0.), d;
        tint i;

        for (i = 0; i <= this->lsize(); ++i) {
            // non-const version shares mamory, it's faster
            d = const_cast<basic_srbmatrix*>(this)->diag(-i).norm();
            dNorm += d * d;
        }
        for (i = 1; i <= this->usize(); ++i) {
            // non-const version shares mamory, it's faster
            d = const_cast<basic_srbmatrix*>(this)->diag(i).norm();
            dNorm += d * d;
        }

        return _sqrt(dNorm);
    }

    TR norm1() const override
    {
        return this->_bnorm1();
    }

    TR norminf() const override
    {
        return this->_bnorminf();
    }

    // ATTENTION!!! This is not a good idea to use the following function. It's provided for
    // overriding of basic_rmatrix<TR>::mult only
    // this = m1 * m2
    basic_srbmatrix& mult(const BaseRMatrix& m1, const BaseRMatrix& m2) throw(cvmexception)
    {
        this->_mult(m1, m2);
        return *this;
    }

    // redefinition of basic_array's function
    TR* _pd() override
    {
#ifdef CVM_DEBUG
        // it's abnormal to call this function, this is pointer to copy, not to an object.
        // only const version is allowed
        assert(false);
#endif
        _bake_SM();
        return mSM._pd();
    }

    // redefinition of basic_array's function
    const TR* _pd() const override
    {
        _bake_SM();
        return mSM._pd();
    }

    // singular values in decreasing order
    void _svd(RVector& vRes, BaseSRMatrix* pmU, BaseSRMatrix* pmVH) const throw(cvmexception) override
    {
        if (pmU != nullptr && pmVH != nullptr) {
            _check_ne(CVM_SIZESMISMATCH, this->msize(), pmU->msize());
            _check_ne(CVM_SIZESMISMATCH, this->nsize(), pmVH->msize());
        }
        __svd<TR,basic_srbmatrix, BaseSRMatrix>(vRes, vRes.size(), vRes.incr(), *this, pmU, pmVH);
    }

    void _pinv(BaseRMatrix& mX, TR threshold) const throw(cvmexception) override {
        __pinv<TR,basic_srbmatrix, BaseRMatrix>(mX, *this, threshold);
    }

    void _eig(CVector& vEig, basic_scmatrix<TR,TC>* mEigVect, bool bRightVect) const throw(cvmexception) override
    {
        _bake_SM();
        mSM._eig(vEig, mEigVect, bRightVect);
    }

    void _solve(const RVector& vB, RVector& vX,
                TR& dErr, const TR* pLU, const tint* pPivots, int transp_mode) const throw(cvmexception) override
    {
        vX = vB;
        RVector vB1;
        RVector vX1;
        if (vB.incr() > 1) vB1 << vB; // to make sure incr = 1
        if (vX.incr() > 1) vX1 << vX;
        __solve<TR,TR, basic_srbmatrix>(*this, 1, vB.incr() > 1 ? vB1 : vB, vB.size(),
                                         vX.incr() > 1 ? vX1 : vX, vX.size(), dErr, pLU, pPivots, transp_mode);
        if (vX.incr() > 1) vX = vX1;
    }

    void _solve(const BaseRMatrix& mB, BaseRMatrix& mX, TR& dErr,
                const TR* pLU, const tint* pPivots, int transp_mode) const throw(cvmexception) override
    {
        mX = mB;
        __solve<TR,TR, basic_srbmatrix>(*this, mB.nsize(), mB, mB.ld(), mX, mX.ld(), dErr, pLU, pPivots, transp_mode);
    }

    // ?gbmv routines perform a matrix-vector operation defined as
    // vRes = alpha*m*v + beta * vRes or vRes = alpha*v'*m + beta * vRes
    // not virtual since __gbmv calls all virtual methods inside
    void _gbmv(bool bLeft, TR dAlpha, const RVector& v, TR dBeta, RVector& vRes) const
    {
        RVector vTmp;
        basic_srbmatrix mTmp;
        const TR* pDv = v;
        if (vRes.get() == pDv) vTmp << v;
        if (vRes.get() == this->get()) mTmp << *this;
        __gbmv<TR,basic_srbmatrix, RVector>(bLeft, vRes.get() == this->get() ? mTmp : *this, dAlpha,
                                             vRes.get() == pDv ? vTmp : v, dBeta, vRes);
    }

    void _check_submatrix() const throw(cvmexception) override {
        throw cvmexception(CVM_SUBMATRIXNOTAVAILABLE, "srbmatrix");
    }

    const TR* _pb() const override {
        return this->get();
    }

    TR* _pb() override {
        return this->get();
    }

protected:
    void _bake_SM() const
    {
        mSM.resize(this->msize());
        mSM.vanish();
        _copy_b_matrix<TR,TR, BaseSRMatrix, basic_srbmatrix>(mSM, *const_cast<basic_srbmatrix*>(this), false);
    }

    tint _size() const override {return this->size(); }
    tint _msize() const override {return this->msize(); }
    tint _nsize() const override {return this->nsize(); }
    tint _ld() const override {return this->ld(); }

    void _set_p(TR* pf) override
    {
#ifdef CVM_USE_POOL_MANAGER
        this->mpd = pf;
#else
        this->mpf = pf;
#endif
    }

    void _set(TR* pf, tint nSize, tint nM, tint nN, tint nIncr, tint nLD) override
    {
#ifdef CVM_USE_POOL_MANAGER
        this->mpd = pf;
#else
        this->mpf = pf;
#endif
        this->msz = nSize;
        this->mm = nM;
        this->mn = nN;
        this->mincr = nIncr;
        this->mld = nLD;
    }

    // for _msum _mdiff etc.
    const TR* _pp(const BaseMatrix& m) const override {
        return m.get();
    }

    tint _ldm() const override {
        return this->mm;
    }

    const tint* _pldm() const override {
        return &this->mm;
    }

    // 0-based, returns an l-value sharing memory
    RVector _row(tint m) override
    {
        RVector vRet(this->msize());
        this->_get_row(m, vRet, vRet.incr());
        return vRet;
    }

    // 0-based, returns not an l-value (copy)
    // looks like cut-n-paste, but it's not
    const RVector _row(tint m) const override
    {
        RVector vRet(this->msize());
        this->_get_row(m, vRet, vRet.incr());
        return vRet;
    }

    // 0-based, returns an l-value sharing memory
    RVector _col(tint n) override
    {
        RVector vRet(this->msize());
        this->_get_col(n, vRet, vRet.incr());
        return vRet;
    }

    // 0-based, returns not an l-value (copy)
    // looks like cut-n-paste, but it's not
    const RVector _col(tint n) const override
    {
        RVector vRet(this->msize());
        this->_get_col(n, vRet, vRet.incr());
        return vRet;
    }

    RVector _diag(tint nDiag) throw(cvmexception) override
    {
        const tint nD = _abs(nDiag);
        if (nDiag < 0) {
            _check_gt(CVM_INDEX_GT, nD, this->lsize());
        }
        else {
            _check_gt(CVM_INDEX_GT, nDiag, this->usize());
        }
        const tint nLU = this->lsize() + this->usize();
        return RVector(this->get() + this->usize() + (nDiag < 0 ? nD : nD * nLU), this->msize() - nD, nLU + 1);
    }

    const RVector _diag(tint nDiag) const throw(cvmexception) override
    {
        const tint nD = _abs(nDiag);
        if (nDiag < 0) {
            _check_gt(CVM_INDEX_GT, nD, this->lsize());
        }
        else {
            _check_gt(CVM_INDEX_GT, nDiag, this->usize());
        }
        const tint nLU = this->lsize() + this->usize();
        return RVector(this->get() + this->usize() + (nDiag < 0 ? nD : nD * nLU), this->msize() - nD, nLU + 1);
    }

    void _swap_rows(tint, tint) throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "swap_rows", "srbmatrix");}
    void _swap_cols(tint, tint) throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "swap_cols", "srbmatrix");}
    void _check_ger()           throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "ger", "srbmatrix");}
    void _check_rank1update()   throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "rank1update", "srbmatrix");}
    void _check_gemm()          throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "gemm", "srbmatrix");}
    void _check_symm()          throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "symm", "srbmatrix");}
    void _check_cholesky()      throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "cholesky", "srbmatrix");}
    void _check_bunch_kaufman() throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "bunch_kaufman", "srbmatrix");}

    void _resize2(tint nNewM, tint) throw(cvmexception) override
    {
#ifdef CVM_USE_POOL_MANAGER
        this->_bresize(nNewM);
#else
        this->_bresize(this->mp, nNewM);
#endif
    }

    bool _continuous() const override {
        return this->_bcontinuous();
    }

    void _massign(const BaseMatrix& m) override {
        this->_mbassign(m);
    }

    void _set(TR d) override {
        this->_bset(d);
    }

    void _vanish() override {
        this->_bvanish();
    }

    // zero based
    type_proxy<TR,TR> _ij_proxy_val(tint i, tint j) override {
        return this->_b_ij_proxy_val(i, j);
    }

    // zero based
    TR _ij_val(tint i, tint j) const override {
        return this->_b_ij_val(i, j);
    }

    void _transp() throw(cvmexception) override
    {
#ifdef CVM_USE_POOL_MANAGER
        this->_btransp();
#else
        this->_btransp(this->mp);
#endif
    }

    void _plus_plus() override {
        this->_b_plus_plus();
    }

    void _minus_minus() override {
        this->_b_minus_minus();
    }

    tint _indofmax() const override
    {
        this->_check_ld();
        _bake_SM();
        return mSM.indofmax();
    }

    tint _indofmin() const override
    {
        this->_check_ld();
        _bake_SM();
        return mSM.indofmin();
    }

    // returns main diagonal of low_up factorization
    RVector _low_up_diag(basic_array<tint,tint>& naPivots) const throw(cvmexception) override
    {
        // let temp matrix be const to get a copy of its main diagonal
        const basic_srbmatrix lu = this->low_up(naPivots);
        return lu.diag(0);
    }

    void _scalr(TR d) override {
        __scal<TR,TR>(this->get(), this->size(), this->incr(), d); // zero tails are supposed here
    }

    void _mult(const BaseRMatrix& m1, const BaseRMatrix& m2) throw(cvmexception) override
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m2.nsize());
        _check_ne(CVM_SIZESMISMATCH, m1.nsize(), m2.msize());
        BaseSRMatrix mR(this->msize());
        mR.mult(m1, m2);
#ifdef CVM_USE_POOL_MANAGER
        this->_resize_lu(this->msize() - 1, this->msize() - 1);
#else
        this->_resize_lu(this->mp, this->msize() - 1, this->msize() - 1);
#endif
        _copy_b_matrix<TR,TR, BaseSRMatrix, basic_srbmatrix>(const_cast<BaseSRMatrix&>(mR), *this, true);
    }

    void _multiply(RVector& vRes, const RVector& v, bool bLeft) const override
    {
        static const TR zero(0.);
        static const TR one(1.);
        this->_gbmv(bLeft, one, v, zero, vRes);
    }

    void _randomize(TR dFrom, TR dTo) override {
        __randomize<TR>(this->get(), this->size(), this->incr(), dFrom, dTo);
    }

    void _low_up(tint* nPivots) throw(cvmexception) override {
        __low_up<basic_srbmatrix>(*this, nPivots);
    }

    tint _ld_for_replace() const override {
        return this->mm;
    }

    tint _size_for_replace() const override {
        return this->mm * this->mn;
    }
};


template<typename TR, typename TC>
class basic_scbmatrix : public basic_scmatrix<TR,TC>, public BandMatrix<TR,TC>
{
    typedef basic_cvector<TR,TC> CVector;       
    typedef basic_array<TR,TC> BaseArray;       
    typedef Matrix<TR,TC> BaseMatrix;           
    typedef basic_cmatrix<TR,TC> BaseCMatrix;   
    typedef basic_scmatrix<TR,TC> BaseSCMatrix; 
    typedef BandMatrix<TR,TC> BaseBandMatrix;   

protected:
    mutable BaseSCMatrix mSM;   

public:
    basic_scbmatrix()
      : mSM()
    {
    }

    explicit basic_scbmatrix(tint nDim)
      : BaseSCMatrix(nDim, 1, true),
        BaseBandMatrix(0, 0)
    {
    }

    basic_scbmatrix(tint nDim, tint nKL, tint nKU)
      : BaseSCMatrix(nDim, 1 + nKL + nKU, true),
        BaseBandMatrix(nKL, nKU), mSM()
    {
        this->_check_dimensions();
    }

    basic_scbmatrix(TC* pd, tint nDim, tint nKL, tint nKU)
      : BaseSCMatrix(pd, nDim, 1 + nKL + nKU, nDim * (1 + nKL + nKU)),
        BaseBandMatrix(nKL, nKU), mSM()
    {
        this->_check_dimensions();
    }

    basic_scbmatrix(const TC* pd, tint nDim, tint nKL, tint nKU)
      : BaseSCMatrix(pd, nDim, 1 + nKL + nKU, nDim * (1 + nKL + nKU)),
        BaseBandMatrix(nKL, nKU), mSM()
    {
        this->_check_dimensions();
    }

    basic_scbmatrix(const basic_scbmatrix& m)
      : BaseSCMatrix(m.msize(), 1 + m.lsize() + m.usize(), false),
        BaseBandMatrix(m.lsize(), m.usize()), mSM()
    {
        this->_massign(m);
    }

    basic_scbmatrix(basic_scbmatrix&& m) noexcept
      : BaseSCMatrix(m.size(), m.incr(), m.msize(), m.nsize(), m.ld()),
        BaseBandMatrix(m.lsize(), m.usize()), mSM()
    {
        this->_mmove(std::move(m));
    }

    basic_scbmatrix(const BaseCMatrix& m, tint nKL, tint nKU)
      : BaseSCMatrix(m.msize(), 1 + nKL + nKU, false),
        BaseBandMatrix(nKL, nKU), mSM()
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), this->nsize());
        this->_check_dimensions();
        _copy_b_matrix<TR,TC, BaseCMatrix, basic_scbmatrix>(const_cast<BaseCMatrix&>(m), *this, true);
    }

    explicit basic_scbmatrix(const CVector& v)
      : BaseSCMatrix(v.size(), 1, false),
        BaseBandMatrix(0, 0)
    {
        __copy<TC>(this->msize(), v, v.incr(), this->get(), 1);
    }

    explicit basic_scbmatrix(const basic_srbmatrix<TR>& m, bool bRealPart = true)
      : BaseSCMatrix(m.msize(), m.ld(), true),
        BaseBandMatrix(m.lsize(), m.usize()),
        mSM()
    {
        if (bRealPart) {
            __copy2<TR,TC>(this->get(), this->size(), this->incr(), m.get(), nullptr);
        }
        else {
            __copy2<TR,TC>(this->get(), this->size(), this->incr(), nullptr, m.get());
        }
    }

    basic_scbmatrix(const basic_srbmatrix<TR>& mRe, const basic_srbmatrix<TR>& mIm)
      : BaseSCMatrix(mRe.msize(), mRe.ld(), false),
        BaseBandMatrix(mRe.lsize(), mRe.usize()),
        mSM()
    {
        _check_ne(CVM_SIZESMISMATCH, mRe.msize(), mIm.msize());
        _check_ne(CVM_SIZESMISMATCH, mRe.nsize(), mIm.nsize());
        _check_ne(CVM_SIZESMISMATCH, mRe.lsize(), mIm.lsize());
        _check_ne(CVM_SIZESMISMATCH, mRe.usize(), mIm.usize());
        __copy2<TR,TC>(this->get(), this->size(), this->incr(), mRe, mIm, mRe.incr(), mIm.incr());
    }

    type_proxy<TC, TR> operator () (tint nRow, tint nCol) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        return this->_ij_proxy_val(nRow - CVM0, nCol - CVM0);
    }

    TC operator () (tint nRow, tint nCol) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        return this->_ij_val(nRow - CVM0, nCol - CVM0);
    }

    // returns column which CAN NOT be l-value
    const CVector operator () (tint nCol) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nCol, CVM0, this->nsize() + CVM0);
        return this->_col(nCol - CVM0);
    }

    // returns row which CAN NOT be l-value
    const CVector operator [] (tint nRow) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nRow, CVM0, this->msize() + CVM0);
        return this->_row(nRow - CVM0);
    }

    // real part
    const basic_srbmatrix<TR> real() const
    {
        basic_srbmatrix<TR> mRet(this->msize(), this->lsize(), this->usize());
        __copy<TR>(this->size(), __get_real_p<TR>(this->get()), this->incr() * 2, mRet, mRet.incr());
        return mRet;
    }

    // imaginary part
    const basic_srbmatrix<TR> imag() const
    {
        basic_srbmatrix<TR> mRet(this->msize(), this->lsize(), this->usize());
        __copy<TR>(this->size(), __get_imag_p<TR>(this->get()), this->incr() * 2, mRet, mRet.incr());
        return mRet;
    }

    basic_scbmatrix& operator = (const basic_scbmatrix& m) throw(cvmexception)
    {
        this->_check_dimensions(m);
        this->_massign(m);
        return *this;
    }

    basic_scbmatrix& operator = (basic_scbmatrix&& m) throw(cvmexception)
    {
        this->_check_dimensions(m);
        BaseSCMatrix::operator = (std::move(m));
        return *this;
    }

    // assigns vector
    basic_scbmatrix& assign(const CVector& v) throw(cvmexception)
    {
        _check_gt(CVM_SIZESMISMATCH_GT, this->size(), v.size());
        this->_assign(v, v.incr());
        return *this;
    }

    // assigns a external array (nIncr = 1)
    basic_scbmatrix& assign(const TC* pd)
    {
        this->_assign(pd, 1);
        return *this;
    }

    basic_scbmatrix& set(TC c)
    {
        this->_set(c);
        return *this;
    }

    basic_scbmatrix& assign_real(const basic_srbmatrix<TR>& mRe) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mRe.msize());
        _check_ne(CVM_SIZESMISMATCH, this->lsize(), mRe.lsize());
        _check_ne(CVM_SIZESMISMATCH, this->usize(), mRe.usize());
        __copy_real<TR,TC>(this->get(), this->size(), this->incr(), mRe, mRe.incr());
        return *this;
    }

    basic_scbmatrix& assign_imag(const basic_srbmatrix<TR>& mIm) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mIm.msize());
        _check_ne(CVM_SIZESMISMATCH, this->lsize(), mIm.lsize());
        _check_ne(CVM_SIZESMISMATCH, this->usize(), mIm.usize());
        __copy_imag<TR,TC>(this->get(), this->size(), this->incr(), mIm, mIm.incr());
        return *this;
    }

    // fills real part
    basic_scbmatrix& set_real(TR d)
    {
        this->_set_real_number(d);
        return *this;
    }

    // fills imaginary part
    basic_scbmatrix& set_imag(TR d)
    {
        this->_set_imag_number(d);
        return *this;
    }

    basic_scbmatrix& resize(tint nNewDim) throw(cvmexception)
    {
        this->_resize2(nNewDim, nNewDim);
        return *this;
    }

    basic_scbmatrix& resize_lu(tint nNewKL, tint nNewKU) throw(cvmexception)
    {
#ifdef CVM_USE_POOL_MANAGER
        this->_resize_lu(nNewKL, nNewKU);
#else
        this->_resize_lu(this->mp, nNewKL, nNewKU);
#endif
        return *this;
    }

    bool operator == (const basic_scbmatrix& m) const
    {
        return this->msize() == m.msize() && this->nsize() == m.nsize() &&
               this->lsize() == m.lsize() && this->usize() == m.usize() && this->_mequals(m);
    }

    bool operator != (const basic_scbmatrix& m) const {
        return !(this->operator == (m));
    }

    basic_scbmatrix& operator << (const basic_scbmatrix& m) throw(cvmexception)
    {
        this->_check_ld(); // submatrix replacement is obviously not possible
#ifdef CVM_USE_POOL_MANAGER
        this->_b_replace(m);
#else
        this->_b_replace(this->mp, m);
#endif
        this->_massign(m);
        return *this;
    }

    basic_scbmatrix operator + (const basic_scbmatrix& m) const throw(cvmexception)
    {
        this->_check_dimensions(m);
        basic_scbmatrix mSum(*this);
        mSum._mincr(m);
        return mSum;
    }

    basic_scbmatrix operator - (const basic_scbmatrix& m) const throw(cvmexception)
    {
        this->_check_dimensions(m);
        basic_scbmatrix mDiff(*this);
        mDiff._mdecr(m);
        return mDiff;
    }

    basic_scbmatrix& sum(const basic_scbmatrix& m1, const basic_scbmatrix& m2) throw(cvmexception)
    {
        this->_check_dimensions(m1);
        this->_check_dimensions(m2);
        this->_msum(m1, m2);
        return *this;
    }

    basic_scbmatrix& diff(const basic_scbmatrix& m1, const basic_scbmatrix& m2) throw(cvmexception)
    {
        this->_check_dimensions(m1);
        this->_check_dimensions(m2);
        this->_mdiff(m1, m2);
        return *this;
    }

    basic_scbmatrix& operator += (const basic_scbmatrix& m) throw(cvmexception)
    {
        this->_check_dimensions(m);
        this->_mincr(m);
        return *this;
    }

    basic_scbmatrix& operator -= (const basic_scbmatrix& m) throw(cvmexception)
    {
        this->_check_dimensions(m);
        this->_mdecr(m);
        return *this;
    }

    basic_scbmatrix operator - () const
    {
        static const TR mone(-1.);
        basic_scbmatrix mRes(*this);
        mRes._scalr(mone);
        return mRes;
    }

    // plus identity, prefix
    basic_scbmatrix& operator ++ ()
    {
        this->_plus_plus();
        return *this;
    }

    // plus identity, postfix
    basic_scbmatrix operator ++ (int)
    {
        this->_plus_plus();
        return *this;
    }

    // minus identity, prefix
    basic_scbmatrix& operator -- ()
    {
        this->_minus_minus();
        return *this;
    }

    // minus identity, postfix
    basic_scbmatrix operator -- (int)
    {
        this->_minus_minus();
        return *this;
    }

    basic_scbmatrix operator * (TR dMult) const
    {
        basic_scbmatrix mRes(*this);
        mRes._scalr(dMult);
        return mRes;
    }

    basic_scbmatrix operator / (TR dDiv) const throw(cvmexception)
    {
        basic_scbmatrix mRes(*this);
        mRes._div(dDiv);
        return mRes;
    }

    basic_scbmatrix operator * (TC cMult) const
    {
        basic_scbmatrix mRes(*this);
        mRes._scalc(cMult);
        return mRes;
    }

    basic_scbmatrix operator / (TC cDiv) const throw(cvmexception)
    {
        basic_scbmatrix mRes(*this);
        mRes._div(cDiv);
        return mRes;
    }

    basic_scbmatrix& operator *= (TR dMult)
    {
        this->_scalr(dMult);
        return *this;
    }

    basic_scbmatrix& operator /= (TR dDiv)
    {
        this->_div(dDiv);
        return *this;
    }

    basic_scbmatrix& operator *= (TC cMult)
    {
        this->_scalc(cMult);
        return *this;
    }

    basic_scbmatrix& operator /= (TC cDiv) throw(cvmexception)
    {
        this->_div(cDiv);
        return *this;
    }

    basic_scbmatrix& normalize()
    {
        this->_normalize();
        return *this;
    }

    // 6.1: transposed (not conjugated) matrix
    basic_scbmatrix operator !() const throw(cvmexception)
    {
        basic_scbmatrix mRes(*this);
        return mRes.transpose();
    }

    // hermitian conjugated matrix
    basic_scbmatrix operator ~() const throw(cvmexception)
    {
        basic_scbmatrix mRes(*this);
        return mRes.conj();
    }

// 6.1: transposed (not conjugated) matrix
    basic_scbmatrix& transpose(const basic_scbmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        _check_ne(CVM_SIZESMISMATCH, this->lsize(), m.usize());
        _check_ne(CVM_SIZESMISMATCH, this->usize(), m.lsize());
        *this << !m;
        return *this;
    }

    basic_scbmatrix& conj(const basic_scbmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        _check_ne(CVM_SIZESMISMATCH, this->lsize(), m.usize());
        _check_ne(CVM_SIZESMISMATCH, this->usize(), m.lsize());
        *this << ~m;
        return *this;
    }

    // 6.1: transposed (not conjugated) matrix
    basic_scbmatrix& transpose() throw(cvmexception)
    {
        this->_transp();
        return *this;
    }

    basic_scbmatrix& conj() throw(cvmexception)
    {
        this->_conj();
        return *this;
    }

    CVector operator * (const CVector& v) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), v.size());
        CVector vRes(this->msize());
        this->_multiply(vRes, v, false);
        return vRes;
    }

    // special exclusion since matrix product is not commutative
    BaseCMatrix operator * (const BaseCMatrix& m) const throw(cvmexception)
    {
        _bake_SM();
        return mSM * m;
    }

    BaseSCMatrix operator * (const BaseSCMatrix& m) const throw(cvmexception)
    {
        _bake_SM();
        return mSM * m;
    }

    basic_scbmatrix operator * (const basic_scbmatrix& m) const throw(cvmexception)
    {
        _bake_SM();
        m._bake_SM();
        return basic_scbmatrix(mSM * m.mSM,
                               _cvm_min<tint>(this->msize() - 1, this->lsize() + m.lsize()),
                               _cvm_min<tint>(this->msize() - 1, this->usize() + m.usize()));
    }

    // 6.1: reversed vector operator % returns solution of A*X=B equation
    // overridden to mask out operator / (TC)
    CVector operator / (const CVector& v) const throw(cvmexception) {
        return v % (*this);
    }

    basic_scbmatrix& low_up(const basic_scbmatrix& m, tint* nPivots) throw(cvmexception)
    {
        *this = m;
        this->_low_up(nPivots);
        return *this;
    }

    basic_scbmatrix low_up(tint* nPivots) const throw(cvmexception)
    {
        basic_scbmatrix mRes(*this);
        mRes._low_up(nPivots);
        return mRes;
    }

    basic_scbmatrix& identity()
    {
        this->_vanish();
        this->_plus_plus();
        return *this;
    }

    basic_scbmatrix& vanish()
    {
        this->_vanish();
        return *this;
    }

    basic_scbmatrix& randomize_real(TR dFrom, TR dTo)
    {
        this->_b_randomize(true, dFrom, dTo);
        return *this;
    }

    basic_scbmatrix& randomize_imag(TR dFrom, TR dTo)
    {
        this->_b_randomize(false, dFrom, dTo);
        return *this;
    }

    // Euclid norm - band matrices require special care because of tails
    TR norm() const override
    {
        TR dNorm = TR(0.), d;
        tint i;
        for (i = 0; i <= this->lsize(); ++i) {
            // non-const version shares mamory, it's faster
            d = const_cast<basic_scbmatrix*>(this)->diag(-i).norm();
            dNorm += d * d;
        }
        for (i = 1; i <= this->usize(); ++i) {
            // non-const version shares mamory, it's faster
            d = const_cast<basic_scbmatrix*>(this)->diag(i).norm();
            dNorm += d * d;
        }
        return _sqrt(dNorm);
    }

    TR norm1() const override {
        return this->_bnorm1();
    }

    TR norminf() const override {
        return this->_bnorminf();
    }

    // ATTENTION!!! This is not a good idea to use the following function. It's provided for
    // overriding of basic_rmatrix<TR>::mult only
    basic_scbmatrix& mult(const BaseCMatrix& m1, const BaseCMatrix& m2) throw(cvmexception)
    {
        this->_mult(m1, m2);
        return *this;
    }

    // redefinition of basic_array's function
    TC* _pd() override
    {
#ifdef CVM_DEBUG
        // it's abnormal to call this function, this is pointer to copy, not to an object. only const version is allowed
        assert(false);
#endif
        _bake_SM();
        return mSM._pd();
    }

    // redefinition of basic_array's function
    const TC* _pd() const override
    {
        _bake_SM();
        return mSM._pd();
    }

    // singular values in decreasing order
    void _svd(basic_rvector<TR>& vRes, BaseSCMatrix* pmU, BaseSCMatrix* pmVH) const throw(cvmexception) override
    {
        if (pmU != nullptr && pmVH != nullptr) {
            _check_ne(CVM_SIZESMISMATCH, this->msize(), pmU->msize());
            _check_ne(CVM_SIZESMISMATCH, this->nsize(), pmVH->msize());
        }
        __svd<TR,basic_scbmatrix, BaseSCMatrix>(vRes, vRes.size(), vRes.incr(), *this, pmU, pmVH);
    }

    void _pinv(BaseCMatrix& mX, TR threshold) const throw(cvmexception) override {
        __pinv<TR,basic_scbmatrix, BaseCMatrix>(mX, *this, threshold);
    }

    void _eig(CVector& vEig, basic_scmatrix<TR,TC>* mEigVect, bool bRightVect) const throw(cvmexception) override
    {
        _bake_SM();
        mSM._eig(vEig, mEigVect, bRightVect);
    }

    void _solve(const CVector& vB, CVector& vX,
                TR& dErr, const TC* pLU, const tint* pPivots, int transp_mode) const throw(cvmexception) override
    {
        vX = vB;
        CVector vB1;
        CVector vX1;
        if (vB.incr() > 1) vB1 << vB; // to make sure incr = 1
        if (vX.incr() > 1) vX1 << vX;
        __solve<TR,TC, basic_scbmatrix>(*this, 1, vB.incr() > 1 ? vB1 : vB, vB.size(), vX.incr() > 1 ? vX1 : vX, vX.size(),
                                         dErr, pLU, pPivots, transp_mode);
        if (vX.incr() > 1) vX = vX1;
    }

    void _solve(const BaseCMatrix& mB, BaseCMatrix& mX,
                TR& dErr, const TC* pLU, const tint* pPivots, int transp_mode) const throw(cvmexception) override
    {
        mX = mB;
        __solve<TR,TC, basic_scbmatrix>(*this, mB.nsize(), mB, mB.ld(), mX, mX.ld(), dErr, pLU, pPivots, transp_mode);
    }

    // ?gbmv routines perform a matrix-vector operation defined as
    // vRes = alpha*m*v + beta * vRes or vRes = alpha*v'*m + beta * vRes
    // not virtual since __gbmv calls all virtual methods inside
    void _gbmv(bool bLeft, TC dAlpha, const CVector& v, TC dBeta, CVector& vRes) const
    {
        CVector vTmp;
        basic_scbmatrix mTmp;
        const TC* pDv = v;
        if (vRes.get() == pDv) vTmp << v;
        if (vRes.get() == this->get()) mTmp << *this;
        __gbmv<TC, basic_scbmatrix, CVector>(bLeft, vRes.get() == this->get() ? mTmp : *this, dAlpha,
                                             vRes.get() == pDv ? vTmp : v, dBeta, vRes);
    }

    void _check_submatrix() const throw(cvmexception) override {
        throw cvmexception(CVM_SUBMATRIXNOTAVAILABLE, "scbmatrix");
    }

    const TC* _pb() const override {
        return this->get();
    }

    TC* _pb() override {
        return this->get();
    }

protected:
    void _bake_SM() const
    {
        mSM.resize(this->msize());
        mSM.vanish();
        _copy_b_matrix<TR,TC, BaseSCMatrix, basic_scbmatrix>(mSM, *const_cast<basic_scbmatrix*>(this), false);
    }

    tint _size() const override {return this->size(); }
    tint _msize() const override {return this->msize(); }
    tint _nsize() const override {return this->nsize(); }
    tint _ld() const override {return this->ld(); }

    void _set_p(TC* pf) override
    {
#ifdef CVM_USE_POOL_MANAGER
        this->mpd = pf;
#else
        this->mpf = pf;
#endif
    }

    void _set(TC* pf, tint nSize, tint nM, tint nN, tint nIncr, tint nLD) override
    {
#ifdef CVM_USE_POOL_MANAGER
        this->mpd = pf;
#else
        this->mpf = pf;
#endif
        this->msz = nSize;
        this->mm = nM;
        this->mn = nN;
        this->mincr = nIncr;
        this->mld = nLD;
    }

    const TC* _pp(const BaseMatrix& m) const override { // for _msum _mdiff etc.
        return m.get();
    }

    tint _ldm() const override {
        return this->mm;
    }

    const tint* _pldm() const override {
        return &this->mm;
    }

    // 0-based, returns an l-value sharing memory
    CVector _row(tint m) override
    {
        CVector vRet(this->msize());
        this->_get_row(m, vRet, vRet.incr());
        return vRet;
    }

    // 0-based, returns not an l-value (copy)
    // looks like cut-n-paste, but it's not
    const CVector _row(tint m) const override
    {
        CVector vRet(this->msize());
        this->_get_row(m, vRet, vRet.incr());
        return vRet;
    }

    // 0-based, returns an l-value sharing memory
    CVector _col(tint n) override
    {
        CVector vRet(this->msize());
        this->_get_col(n, vRet, vRet.incr());
        return vRet;
    }

    // 0-based, returns not an l-value (copy)
    // looks like cut-n-paste, but it's not
    const CVector _col(tint n) const override
    {
        CVector vRet(this->msize());
        this->_get_col(n, vRet, vRet.incr());
        return vRet;
    }

    CVector _diag(tint nDiag) throw(cvmexception) override
    {
        const tint nD = _abs(nDiag);
        if (nDiag < 0) {
            _check_gt(CVM_INDEX_GT, nD, this->lsize());
        }
        else {
            _check_gt(CVM_INDEX_GT, nDiag, this->usize());
        }
        const tint nLU = this->lsize() + this->usize();
        return CVector(this->get() + this->usize() + (nDiag < 0 ? nD : nD * nLU), this->msize() - nD, nLU + 1);
    }

    const CVector _diag(tint nDiag) const throw(cvmexception) override
    {
        const tint nD = _abs(nDiag);
        if (nDiag < 0) {
            _check_gt(CVM_INDEX_GT, nD, this->lsize());
        }
        else {
            _check_gt(CVM_INDEX_GT, nDiag, this->usize());
        }
        const tint nLU = this->lsize() + this->usize();
        return CVector(this->get() + this->usize() + (nDiag < 0 ? nD : nD * nLU), this->msize() - nD, nLU + 1);
    }

    void _resize2(tint nNewM, tint) throw(cvmexception) override
    {
#ifdef CVM_USE_POOL_MANAGER
        this->_bresize(nNewM);
#else
        this->_bresize(this->mp, nNewM);
#endif
    }

    bool _continuous() const override
    {
        return this->_bcontinuous();
    }

    void _massign(const BaseMatrix& m) override {
        this->_mbassign(m);
    }

    void _set(TC d) override {
        this->_bset(d);
    }

    void _vanish() override {
        this->_bvanish();
    }

    // zero based
    type_proxy<TC, TR> _ij_proxy_val(tint i, tint j) override {
        return this->_b_ij_proxy_val(i, j);
    }

    // zero based
    TC _ij_val(tint i, tint j) const override {
        return this->_b_ij_val(i, j);
    }

    void _transp() throw(cvmexception) override
    {
#ifdef CVM_USE_POOL_MANAGER
        this->_btransp();
#else
        this->_btransp(this->mp);
#endif
    }

    void _plus_plus() override {
        this->_b_plus_plus();
    }

    void _minus_minus() override {
        this->_b_minus_minus();
    }

    tint _indofmax() const override
    {
        this->_check_ld();
        _bake_SM();
        return mSM.indofmax();
    }

    tint _indofmin() const override
    {
        this->_check_ld();
        _bake_SM();
        return mSM.indofmin();
    }

    CVector _low_up_diag(basic_array<tint,tint>& naPivots) const throw(cvmexception) override
    {
        // let temp matrix be const to get a copy of its main diagonal
        const basic_scbmatrix lu = this->low_up(naPivots);
        return lu.diag(0);
    }

    void _scalr(TR d) override {
        __scal<TR,TC>(this->get(), this->size(), this->incr(), d);     // zero tails are supposed here
    }

    void _scalc(TC d) override {
        __scal<TC, TC>(this->get(), this->size(), this->incr(), d);     // zero tails are supposed here
    }

    void _mult(const BaseCMatrix& m1, const BaseCMatrix& m2) throw(cvmexception) override
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m2.nsize());
        _check_ne(CVM_SIZESMISMATCH, m1.nsize(), m2.msize());
        BaseSCMatrix mR(this->msize());
        mR.mult(m1, m2);
#ifdef CVM_USE_POOL_MANAGER
        this->_resize_lu(this->msize() - 1, this->msize() - 1);
#else
        this->_resize_lu(this->mp, this->msize() - 1, this->msize() - 1);
#endif
        _copy_b_matrix<TR,TC, BaseSCMatrix, basic_scbmatrix>(const_cast<BaseSCMatrix&>(mR), *this, true);
    }

    void _multiply(CVector& vRes, const CVector& v, bool bLeft) const override
    {
        static const TC zero(0., 0.);
        static const TC one(1., 0.);
        this->_gbmv(bLeft, one, v, zero, vRes);
    }

    void _low_up(tint* nPivots) throw(cvmexception) override {
        __low_up<basic_scbmatrix>(*this, nPivots);
    }

    tint _ld_for_replace() const override {
        return this->mm;
    }

    tint _size_for_replace() const override {
        return this->mm * this->mn;
    }

    void _swap_rows(tint, tint) throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "swap_rows", "scbmatrix");}
    void _swap_cols(tint, tint) throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "swap_cols", "scbmatrix");}
    void _check_geru()          throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "geru", "scbmatrix");}
    void _check_gerc()          throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "gerc", "scbmatrix");}
    void _check_rank1update_u() throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "rank1update_u", "scbmatrix");}
    void _check_rank1update_c() throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "rank1update_c", "scbmatrix");}
    void _check_gemm()          throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "gemm", "scbmatrix");}
    void _check_hemm()          throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "hemm", "scbmatrix");}
    void _check_cholesky()      throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "cholesky", "scbmatrix");}
    void _check_bunch_kaufman() throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "bunch_kaufman", "scbmatrix");}
};


template<typename TR>
class basic_srsmatrix : public basic_srmatrix<TR>
{
    typedef basic_rvector<TR> RVector;       
    typedef basic_array<TR,TR> BaseArray;   
    typedef Matrix<TR,TR> BaseMatrix;       
    typedef SqMatrix<TR,TR> BaseSqMatrix;   
    typedef basic_rmatrix<TR> BaseRMatrix;   
    typedef basic_srmatrix<TR> BaseSRMatrix; 

public:
    basic_srsmatrix()
    {
    }

    explicit basic_srsmatrix(tint nDim)
      : BaseSRMatrix(nDim)
    {
    }

    basic_srsmatrix(TR* pd, tint nDim, TR tol = basic_cvmMachSp<TR>())
      : BaseSRMatrix(pd, nDim, nDim, nDim * nDim)
    {
        this->_check_symmetric(tol);
    }

    basic_srsmatrix(const TR* pd, tint nDim, TR tol = basic_cvmMachSp<TR>())
      : BaseSRMatrix(pd, nDim, nDim, nDim * nDim)
    {
        this->_check_symmetric(tol);
    }

    basic_srsmatrix(const basic_srsmatrix& m)
      : BaseSRMatrix(m.msize(), m.msize(), false)
    {
        this->_massign(m);
    }

    basic_srsmatrix(basic_srsmatrix&& m) noexcept
       : BaseSRMatrix(std::move(m))
    {
    }

    explicit basic_srsmatrix(const BaseRMatrix& m, TR tol = basic_cvmMachSp<TR>())
      : BaseSRMatrix(m.msize(), m.nsize(), false)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), this->nsize());
        this->_massign(m);
        this->_check_symmetric(tol);
    }

    explicit basic_srsmatrix(const RVector& v)
      : BaseSRMatrix(v)
    {
    }

    basic_srsmatrix(basic_srsmatrix& m, tint nRowCol, tint nDim)
      : BaseSRMatrix(m._sub_pointer(nRowCol, nRowCol, nDim, nDim), nDim, m.ld(), nDim * nDim)
    {
    }

    TR operator () (tint nRow, tint nCol) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        return this->_ij_val(nRow - CVM0, nCol - CVM0);
    }

    // returns column which is NOT l-value
    const RVector operator () (tint nCol) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nCol, CVM0, this->nsize() + CVM0);
        return this->_col(nCol - CVM0);
    }

    // returns row which is NOT l-value
    const RVector operator [] (tint nRow) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nRow, CVM0, this->msize() + CVM0);
        return this->_row(nRow - CVM0);
    }

    // returns diagonal which is NOT l-value (since it could break symmetricity)
    // 0 - main, negative - low, positive - up
    const RVector diag(tint nDiag) const throw(cvmexception) {
        return this->_diag(nDiag);
    }

    basic_srsmatrix& operator = (const basic_srsmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        this->_massign(m);
        return *this;
    }

    basic_srsmatrix& operator = (basic_srsmatrix&& m) throw(cvmexception)
    {
        // size check is in BaseSRMatrix
        BaseSRMatrix::operator = (std::move(m));
        return *this;
    }

    basic_srsmatrix& assign(const RVector& v, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        _check_gt(CVM_SIZESMISMATCH_GT, this->size(), v.size());
        this->_assign(v, v.incr());
        this->_check_symmetric(tol);
        return *this;
    }

    basic_srsmatrix& assign(const TR* pd, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        this->_assign(pd, 1);
        this->_check_symmetric(tol);
        return *this;
    }

    basic_srsmatrix& assign(tint nRowCol, const basic_srsmatrix& m) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nRowCol, CVM0, this->msize() + CVM0);
        _check_gt(CVM_SIZESMISMATCH_GT, m.msize() + nRowCol - CVM0, this->msize());
        this->_assign_shifted(this->_sub_pointer_nocheck(nRowCol, nRowCol), m._pd(), m.msize(), m.nsize(), m.ld());
        return *this;
    }

    basic_srsmatrix& set(TR d)
    {
        this->_set(d);
        return *this;
    }

    basic_srsmatrix& set(tint nRow, tint nCol, TR d)
    {
        this->_set_at(nRow - CVM0, nCol - CVM0, d);
        return *this;
    }

    basic_srsmatrix& set_diag(tint nDiag, const RVector& vDiag) throw(cvmexception)
    {
        this->_diag(nDiag) = vDiag;
        if (nDiag != 0) {
            this->_diag(-nDiag) = vDiag;
        }
        return *this;
    }

    basic_srsmatrix& resize(tint nNewDim) throw(cvmexception)
    {
        this->_resize2(nNewDim, nNewDim);
        return *this;
    }

    bool operator == (const basic_srsmatrix& m) const {
        return this->msize() == m.msize() && this->nsize() == m.nsize() && this->_mequals(m);
    }

    bool operator != (const basic_srsmatrix& m) const {
        return !(this->operator == (m));
    }

    basic_srsmatrix& operator << (const basic_srsmatrix& m) throw(cvmexception)
    {
        this->_replace(m);
        this->_massign(m);
        return *this;
    }

    basic_srsmatrix operator + (const basic_srsmatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        basic_srsmatrix mSum(*this);
        mSum._mincr(m);
        return mSum;
    }

    basic_srsmatrix operator - (const basic_srsmatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        basic_srsmatrix mDiff(*this);
        mDiff._mdecr(m);
        return mDiff;
    }

    basic_srsmatrix& sum(const basic_srsmatrix& m1, const basic_srsmatrix& m2) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m2.msize());
        this->_msum(m1, m2);
        return *this;
    }

    basic_srsmatrix& diff(const basic_srsmatrix& m1, const basic_srsmatrix& m2) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m2.msize());
        this->_mdiff(m1, m2);
        return *this;
    }

    basic_srsmatrix& operator += (const basic_srsmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        this->_mincr(m);
        return *this;
    }

    basic_srsmatrix& operator -= (const basic_srsmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        this->_mdecr(m);
        return *this;
    }

    basic_srsmatrix operator - () const
    {
        static const TR mone(-1.);
        basic_srsmatrix mRes(*this);
        mRes._scalr(mone);
        return mRes;
    }

    // plus identity, prefix
    basic_srsmatrix& operator ++ ()
    {
        this->_plus_plus();
        return *this;
    }

    // plus identity, postfix
    basic_srsmatrix operator ++ (int)
    {
        this->_plus_plus();
        return *this;
    }

    // minus identity, prefix
    basic_srsmatrix& operator -- ()
    {
        this->_minus_minus();
        return *this;
    }

    // minus identity, postfix
    basic_srsmatrix operator -- (int)
    {
        this->_minus_minus();
        return *this;
    }

    basic_srsmatrix operator * (TR dMult) const
    {
        basic_srsmatrix mRes(*this);
        mRes._scalr(dMult);
        return mRes;
    }

    basic_srsmatrix operator / (TR dDiv) const throw(cvmexception)
    {
        basic_srsmatrix mRes(*this);
        mRes._div(dDiv);
        return mRes;
    }

    basic_srsmatrix& operator *= (TR dMult)
    {
        this->_scalr(dMult);
        return *this;
    }

    basic_srsmatrix& operator /= (TR dDiv) throw(cvmexception)
    {
        this->_div(dDiv);
        return *this;
    }

    basic_srsmatrix& normalize()
    {
        this->_normalize();
        return *this;
    }

    basic_srsmatrix operator ~() const {
        return *this;
    }

    basic_srsmatrix& transpose(const basic_srsmatrix& m) throw(cvmexception)
    {
        (*this) = m;
        return *this;
    }

    basic_srsmatrix& transpose() {
        return *this;
    }

    RVector operator * (const RVector& v) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), v.size());
        RVector vRes(this->msize());
        this->_multiply(vRes, v, false);
        return vRes;
    }

    // special exclusion since matrix product is not commutative
    BaseRMatrix operator * (const BaseRMatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.msize());
        static const TR zero = TR(0.);
        static const TR one = TR(1.);
        BaseRMatrix mRes(m.msize(), m.nsize());
        mRes._symm(true, *this, m, one, zero);
        return mRes;
    }

    BaseSRMatrix operator * (const BaseSRMatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.msize());
        static const TR zero = TR(0.);
        static const TR one = TR(1.);
        BaseSRMatrix mRes(this->msize());
        mRes._symm(true, *this, m, one, zero);
        return mRes;
    }

    // 6.1: reversed vector operator % returns solution of A*X=B equation
    // overridden to mask out operator / (TR)
    RVector operator / (const RVector& v) const throw(cvmexception) {
        return v % (*this);
    }

    // this = alpha*v*v' + beta*this
    basic_srsmatrix& syrk(TR alpha, const RVector& v, TR beta) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), v.size());
        RVector vc(v);   // has to guarantee incr to be 1
        __syrk<TR,basic_srsmatrix>(false, alpha, 1, vc, vc.size(), beta, *this);
        this->_flip();
        return *this;
    }

// this = alpha*a*a' + beta*this or this = alpha*a'*a + beta*this
    basic_srsmatrix& syrk(bool bTransp, TR alpha, const BaseRMatrix& m, TR beta) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), bTransp ? m.nsize() : m.msize());
        __syrk<TR,basic_srsmatrix>(bTransp, alpha, bTransp ? m.msize() : m.nsize(), m, m.ld(), beta, *this);
        this->_flip();
        return *this;
    }

// this = alpha*v1*v2' + alpha*v2*v1' + beta*this
    basic_srsmatrix& syr2k(TR alpha, const RVector& v1, const RVector& v2, TR beta) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), v1.size());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), v2.size());
        RVector v1c(v1); // has to guarantee incr to be 1
        RVector v2c(v2);
        __syr2k<TR,basic_srsmatrix>(false, alpha, 1, v1c, v1c.size(), v2c, v2c.size(), beta, *this);
        this->_flip();
        return *this;
    }

// this = alpha*a*b' + alpha*b*a' + beta*this or this = alpha*a'*b + alpha*b'*a + beta*this
    basic_srsmatrix& syr2k(bool bTransp, TR alpha, const BaseRMatrix& m1, const BaseRMatrix& m2, TR beta) throw(cvmexception)
    {
        if (bTransp) {
            _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.nsize());
            _check_ne(CVM_SIZESMISMATCH, this->msize(), m2.nsize());
            _check_ne(CVM_SIZESMISMATCH, m1.msize(), m2.msize());
        } else {
            _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.msize());
            _check_ne(CVM_SIZESMISMATCH, this->msize(), m2.msize());
            _check_ne(CVM_SIZESMISMATCH, m1.nsize(), m2.nsize());
        }
        __syr2k<TR,basic_srsmatrix>(bTransp, alpha, bTransp ? m1.msize() : m1.nsize(), m1, m1.ld(), m2, m2.ld(), beta, *this);
        this->_flip();
        return *this;
    }

    basic_srsmatrix& inv(const basic_srsmatrix& m) throw(cvmexception)
    {
        __inv<basic_srsmatrix>(*this, m);
        return *this;
    }

    basic_srsmatrix inv() const throw(cvmexception)
    {
        basic_srsmatrix mRes(this->msize());
        __inv<basic_srsmatrix>(mRes, *this);
        return mRes;
    }

    basic_srsmatrix& exp(const basic_srsmatrix& m, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        __exp_symm<basic_srsmatrix, TR>(*this, m, tol);
        return *this;
    }

    basic_srsmatrix exp(TR tol = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        basic_srsmatrix msRes(this->msize());
        __exp_symm<basic_srsmatrix, TR>(msRes, *this, tol);
        return msRes;
    }

// this = v(1)*I + v(2)*m + v(3)*m^2 + ... + v(N)*m^(N-1)
    basic_srsmatrix& polynom(const basic_srsmatrix& m, const RVector& v) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        RVector v1;
        if (v.incr() > 1) v1 << v;   // to make sure incr = 1
        __polynom<TR,RVector>(this->get(), this->ld(), this->msize(), m._pd(), m._ldm(), v.incr() > 1 ? v1 : v);
        return *this;
    }

// returns v(1)*I + v(2)*this + v(3)*this^2 + ... + v(N)*this^(N-1)
    basic_srsmatrix polynom(const RVector& v) const
    {
        basic_srsmatrix msRes(this->msize());
        RVector v1;
        if (v.incr() > 1) v1 << v;   // to make sure incr = 1
        __polynom<TR,RVector>(msRes, msRes.ld(), this->msize(), this->get(), this->ld(), v.incr() > 1 ? v1 : v);
        return msRes;
    }

    RVector eig(BaseSRMatrix& mEigVect) const throw(cvmexception)
    {
        RVector vEig(this->msize());
        __eig<RVector, basic_srsmatrix, BaseSRMatrix>(vEig, *this, &mEigVect, true);
        return vEig;
    }

    RVector eig() const throw(cvmexception)
    {
        RVector vEig(this->msize());
        __eig<RVector, basic_srsmatrix, BaseSRMatrix>(vEig, *this, nullptr, true);
        return vEig;
    }

    BaseSRMatrix cholesky() const throw(cvmexception)
    {
        BaseSRMatrix mRes(*this);
        tint nOutInfo = __cholesky<BaseSRMatrix>(mRes);
        _check_negative(CVM_WRONGMKLARG, nOutInfo);
        _check_positive(CVM_NOTPOSITIVEDEFINITE, nOutInfo);
        mRes._clean_low_triangle();
        return mRes;
    }

    BaseSRMatrix bunch_kaufman(tint* nPivots) const throw(cvmexception)
    {
        BaseSRMatrix mRes(*this);
        __bunch_kaufman<BaseSRMatrix>(mRes, nPivots);
        return mRes;
    }

    basic_srsmatrix& identity()
    {
        this->_vanish();
        this->_plus_plus();
        return *this;
    }

    basic_srsmatrix& vanish()
    {
        this->_vanish();
        return *this;
    }

    basic_srsmatrix& randomize(TR dFrom, TR dTo)
    {
        this->_randomize(dFrom, dTo);
        return *this;
    }

    // infinity-norm - the same as 1-norm for symmetric matrices
    TR norminf() const override {
        return this->norm1();
    }

    bool is_positive_definite() const
    {
        static const TR zero = TR(0.);
        const TR* pd = this->_pv();
        const tint nSize = this->_size();
        const tint nNext = this->_msize() + 1;
        CVM_ASSERT(pd, nSize * sizeof(TR))
        for (tint i = 0; i < nSize; i += nNext) {
            if (pd[i] <= zero) {
                return false;
            }
        }
        return true;
    }

    bool equilibrate(RVector& vScalings, RVector& vB) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vB.size());
        bool bRes = this->_equilibrate(vScalings);
        if (bRes) {
            for (tint i = CVM0; i < this->msize() + CVM0; ++i) {
                vB[i] *= vScalings[i];
            }
        }
        return bRes;
    }

    bool equilibrate(RVector& vScalings, BaseRMatrix& mB) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mB.msize());
        bool bRes = this->_equilibrate(vScalings);
        if (bRes) {
            for (tint j = CVM0; j < mB.nsize() + CVM0; ++j) {
                for (tint i = CVM0; i < this->msize() + CVM0; ++i) {
                    mB(i, j) *= vScalings[i];
                }
            }
        }
        return bRes;
    }

    // special care for symmetric matrices
    basic_srsmatrix& _factorize(const basic_srsmatrix& m, tint* nPivots, bool& bPositiveDefinite) throw(cvmexception)
    {
        (*this) = m;
        tint nOutInfo = __cholesky<BaseSRMatrix>(*this);
        _check_negative(CVM_WRONGMKLARG, nOutInfo);
        if (nOutInfo > 0) {
            (*this) = m;
            __bunch_kaufman<BaseSRMatrix>(*this, nPivots);
            bPositiveDefinite = false;
        } else {
            bPositiveDefinite = true;
        }
        return *this;
    }

    // makes lower triangle to be equal to upper one
    void _flip()
    {
        if (this->msize() > 1) {
            const tint nM1 = this->ld() + 1, nM1m = this->ld() - 1, nM2m = this->msize() - 1;
            tint i = 1, j = 1, m;
            for (;;) {
                m = this->msize() - i;
                __copy<TR>(m, this->get() + j + nM1m, this->ld(), this->get() + j, 1);
                if (i >= nM2m) {
                    break;
                }
                i++;
                j += nM1;
            }
        }
    }

    // redefinition of basic_array's function
    TR* _pd() override
    {
        return this->get();
    }

    // redefinition of basic_array's function
    const TR* _pd() const override {
        return this->get();
    }

    void _check_submatrix() const throw(cvmexception) override {
        throw cvmexception(CVM_SUBMATRIXNOTAVAILABLE, "srsmatrix");
    }

protected:
    const TR* _pp(const BaseMatrix& m) const override {  // for _msum _mdiff etc.
        return m.get();
    }

    void _check_ger()           throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "ger", "srsmatrix");}
    void _check_rank1update()   throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "rank1update", "srsmatrix");}
    void _check_gemm()          throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "gemm", "srsmatrix");}
    void _swap_rows(tint, tint) throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "swap_rows", "srsmatrix");}
    void _swap_cols(tint, tint) throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "swap_cols", "srsmatrix");}

    // we do nothing here - it's symmetric
    void _transp() override {
    }

    // returns main diagonal of low_up factorization
    // this call is useless for symmetric matrices. this call would mean serious CVM internal error
    RVector _low_up_diag(basic_array<tint,tint>&) const throw(cvmexception) override {
        throw cvmexception(CVM_NOTIMPLEMENTED, "_low_up_diag");
    }

    void _scalr(TR d) override {
        __scal<TR,TR>(this->get(), this->size(), this->incr(), d); // zero tails are supposed here
    }

    void _multiply(RVector& vRes, const RVector& v, bool) const override
    {
        RVector vTmp;
        basic_srsmatrix mTmp;
        static const TR zero = TR(0.);
        static const TR one = TR(1.);
        const TR* pDm = this->get();
        const TR* pDv = v;
        if (vRes.get() == pDv) vTmp << v;
        if (vRes.get() == pDm) mTmp << *this;
        __symv<TR,basic_srsmatrix, RVector>(vRes.get() == pDm ? mTmp : *this, one,
                                             vRes.get() == pDv ? vTmp : v, zero, vRes);
    }

    void _randomize(TR dFrom, TR dTo) override
    {
        this->BaseSRMatrix::_randomize(dFrom, dTo);
        this->_flip();
    }

    void _solve(const RVector& vB, RVector& vX,
                TR& dErr, const TR* pLU, const tint* pPivots, int transp_mode) const throw(cvmexception) override
    {
        // 6.1: fix for non-positive definite solutions
        if (!this->is_positive_definite()) {
            BaseSRMatrix::_solve(vB, vX, dErr, pLU, pPivots, transp_mode);
            return;
        }
        RVector vB1(vB); // to make sure incr = 1 and equilibrate
        RVector vScalings(this->msize());
        basic_srsmatrix m(*this);
        const bool bEquilibrated = m.equilibrate(vScalings, vB1);
        RVector vX1(vB1);
        __solve<TR,TR, basic_srsmatrix>(m, 1, vB1, vB1.size(), vX1, vX1.size(), dErr, pLU, pPivots, 0); // no transpose
        if (bEquilibrated) {
            for (tint i = 1; i <= this->msize(); ++i) {
                vX[i] = vX1[i] * vScalings[i];
            }
        } else {
            vX = vX1;
        }
    }

    void _solve(const BaseRMatrix& mB, BaseRMatrix& mX,
                TR& dErr, const TR* pLU, const tint* pPivots, int transp_mode) const throw(cvmexception) override
    {
        // 6.1: fix for non-positive definite solutions
        if (!this->is_positive_definite()) {
            BaseSRMatrix::_solve(mB, mX, dErr, pLU, pPivots, transp_mode);
            return;
        }
        BaseRMatrix mB1(mB); // to equilibrate
        RVector vScalings(this->msize());
        basic_srsmatrix m(*this);
        const bool bEquilibrated = m.equilibrate(vScalings, mB1);
        mX = mB1;
        __solve<TR,TR, basic_srsmatrix>(m, mB.nsize(), mB, mB.ld(), mX, mX.ld(), dErr, pLU, pPivots, 0); // no transpose
        if (bEquilibrated) {
            for (tint j = 1; j <= mX.nsize(); ++j) {
                for (tint i = 1; i <= this->msize(); ++i) {
                    mX(i, j) *= vScalings[i];
                }
            }
        }
    }

    // matrix determinant
    TR _det() const throw(cvmexception) override
    {
        TR dDet = TR(0.);
        switch (this->msize()) {
        case 0:
            break;
        case 1:
            dDet = this->_ij_val(0, 0);
            break;
        case 2:
            dDet = this->_ij_val(0, 0) * this->_ij_val(1, 1) -
               this->_ij_val(1, 0) * this->_ij_val(0, 1);
            break;
        default:
            try {
                static const TR one(1.);
                bool bPositiveDefinite = false;
                basic_srsmatrix m(this->msize());
                basic_array<tint,tint> nPivots(this->msize());
                m._factorize(*this, nPivots, bPositiveDefinite);

                tint i;
                dDet = one;
                if (bPositiveDefinite) {
                    const RVector vUpDiag = m.diag(0);
                    for (i = 1; i <= this->msize(); ++i) {
                        dDet *= vUpDiag[i] * vUpDiag[i];    //here we use Cholesky factorization
                    }
                } else {
                    const RVector vEig = this->eig();
                    for (i = 1; i <= this->msize(); ++i) {
                        dDet *= vEig[i];  //here we use eigenvalues. probably there is a better way.
                    }
                }
            }
            catch (const cvmexception& e) {
                if (e.cause() != CVM_WRONGBUNCHKAUFMANFACTOR) throw e;
            }
            break;
        }
        return dDet;
    }

    // matrix equilibration helper
    bool _equilibrate(RVector& vScalings) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vScalings.size());
        bool bRes = false;
        TR dCond(0.);
        TR dMax  = TR();
        static const TR sp = basic_cvmMachSp<TR>();
        static const TR sp_inv = TR(1.) / sp;

        __poequ<TR,basic_srsmatrix, RVector>(*this, vScalings, dCond, dMax);

        if (dCond < TR(0.1) || _abs(dMax) <= sp || _abs(dMax) >= sp_inv) {
            bRes = true;
            for (tint i = 0; i < this->msize(); ++i) {
                for (tint j = i; j < this->msize(); ++j) {
                    this->get()[this->ld() * j + i] *= vScalings[i + CVM0] * vScalings[j + CVM0];
                }
            }
        }
        return bRes;
    }

    // sets both elements to keep matrix symmetric, checks ranges
    // zero based
    void _set_at(tint nRow, tint nCol, TR val) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, TINT_ZERO, this->msize());
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, TINT_ZERO, this->nsize());
        this->get()[this->ld() * nCol + nRow] = val;
        if (nRow != nCol) {
            this->get()[this->ld() * nRow + nCol] = val;
        }
    }

    void _check_symmetric(TR tol) const throw(cvmexception)
    {
        for (tint j = 0; j < this->nsize(); ++j) {
            for (tint i = 0; i < this->msize(); ++i) {
                if (i != j && _abs(this->get()[this->ld() * j + i] - this->get()[this->ld() * i + j]) > tol) {
                    throw cvmexception(CVM_MATRIXNOTSYMMETRIC);
                }
            }
        }
    }
};


template<typename TR, typename TC>
class basic_schmatrix : public basic_scmatrix<TR,TC>
{
    typedef basic_rvector<TR> RVector;          
    typedef basic_cvector<TR,TC> CVector;       
    typedef Matrix<TR,TC> BaseMatrix;           
    typedef basic_cmatrix<TR,TC> BaseCMatrix;   
    typedef basic_scmatrix<TR,TC> BaseSCMatrix; 

public:
    basic_schmatrix()
    {
    }

    explicit basic_schmatrix(tint nDim)
      : BaseSCMatrix(nDim)
    {
    }

    basic_schmatrix(TC* pd, tint nDim, TR tol = basic_cvmMachSp<TR>())
      : BaseSCMatrix(pd, nDim, nDim, nDim * nDim)
    {
        this->_check_hermitian(tol);
    }

    basic_schmatrix(const TC* pd, tint nDim, TR tol = basic_cvmMachSp<TR>())
      : BaseSCMatrix(pd, nDim, nDim, nDim * nDim)
    {
        this->_check_hermitian(tol);
    }

    basic_schmatrix(const basic_schmatrix& m)
      : BaseSCMatrix(m.msize(), m.msize(), false)
    {
        this->_massign(m);
    }

    basic_schmatrix(basic_schmatrix&& m) noexcept
       : BaseSCMatrix(std::move(m))
    {
    }

    explicit basic_schmatrix(const BaseCMatrix& m, TR tol = basic_cvmMachSp<TR>())
      : BaseSCMatrix(m.msize(), m.nsize(), false)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), this->nsize());
        this->_massign(m);
        this->_check_hermitian(tol);
    }

    explicit basic_schmatrix(const RVector& v)
      : BaseSCMatrix(v.size(), v.size(), true)
    {
        __copy2<TR,TC>(this->get(), v.size(), this->ld() + 1, v._pd(), nullptr, v.incr());
    }

    explicit basic_schmatrix(const basic_srsmatrix<TR>& m)
      : BaseSCMatrix(m.msize(), m.msize(), true)
    {
        __copy2<TR,TC>(this->get(), this->size(), this->incr(), m._pd(), nullptr);
    }

    basic_schmatrix(const TR* pRe, const TR* pIm, tint nDim, TR tol = basic_cvmMachSp<TR>())
      : BaseSCMatrix(pRe, pIm, nDim)
    {
        this->_check_hermitian(tol);
    }

    basic_schmatrix(const basic_srmatrix<TR>& mRe, const basic_srmatrix<TR>& mIm, TR tol = basic_cvmMachSp<TR>())
      : BaseSCMatrix(mRe, mIm)
    {
        this->_check_hermitian(tol);
    }

    basic_schmatrix(basic_schmatrix& m, tint nRowCol, tint nDim)
      : BaseSCMatrix(m._sub_pointer(nRowCol, nRowCol, nDim, nDim), nDim, m.ld(), nDim * nDim)
    {
    }

    TC operator () (tint nRow, tint nCol) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        return this->_ij_val(nRow - CVM0, nCol - CVM0);
    }

    // returns column which is NOT l-value
    const CVector operator () (tint nCol) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nCol, CVM0, this->nsize() + CVM0);
        return this->_col(nCol - CVM0);
    }

    // returns row which is NOT l-value
    const CVector operator [] (tint nRow) const throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nRow, CVM0, this->msize() + CVM0);
        return this->_row(nRow - CVM0);
    }

    // returns diagonal which IS NOT l-value
    // 0 - main, negative - low, positive - up
    const CVector diag(tint nDiag) const throw(cvmexception) {
        return this->_diag(nDiag);
    }

    // real part (symmetric)
    const basic_srsmatrix<TR> real() const
    {
        basic_srsmatrix<TR> mRet(this->msize());
        __copy<TR>(this->size(), __get_real_p<TR>(this->get()), this->incr() * 2, mRet, mRet.incr());
        return mRet;
    }

    // imaginary part (NOT symmetric)
    const basic_srmatrix<TR> imag() const
    {
        basic_srmatrix<TR> mRet(this->msize());
        __copy<TR>(this->size(), __get_imag_p<TR>(this->get()), this->incr() * 2, mRet, mRet.incr());
        return mRet;
    }

    basic_schmatrix& operator = (const basic_schmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        this->_massign(m);
        return *this;
    }

    basic_schmatrix& operator = (basic_schmatrix&& m) throw(cvmexception)
    {
        // size check is in BaseSCMatrix
        BaseSCMatrix::operator = (std::move(m));
        return *this;
    }

    basic_schmatrix& assign(const CVector& v, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        _check_gt(CVM_SIZESMISMATCH_GT, this->size(), v.size());
        this->_assign(v, v.incr());
        this->_check_hermitian(tol);
        return *this;
    }

    basic_schmatrix& assign(const TC* pd, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        this->_assign(pd, 1);
        this->_check_hermitian(tol);
        return *this;
    }

    basic_schmatrix& assign(tint nRowCol, const basic_schmatrix& m) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE, nRowCol, CVM0, this->msize() + CVM0);
        _check_gt(CVM_SIZESMISMATCH_GT, m.msize() + nRowCol - CVM0, this->msize());
        this->_assign_shifted(this->_sub_pointer_nocheck(nRowCol, nRowCol), m._pd(), m.msize(), m.nsize(), m.ld());
        return *this;
    }

    basic_schmatrix& set(tint nRow, tint nCol, TC c) throw(cvmexception)
    {
        this->_set_at(nRow - CVM0, nCol - CVM0, c);
        return *this;
    }

    basic_schmatrix& set_diag(tint nDiag, const CVector& vDiag) throw(cvmexception)
    {
        if (nDiag == 0) throw cvmexception(CVM_BREAKS_HERMITIANITY, "set_main_diag");
        const tint nD = _abs(nDiag);
        const tint nSize = vDiag.size();
        _check_ne(CVM_SIZESMISMATCH, this->msize() - nD, nSize);
        const tint nShift = nDiag * this->ld();
        const tint nIncr = this->ld() + 1;
        TC* pD1 = this->get() + (nDiag > 0 ? nShift : nD);
        TC* pD2 = this->get() + (nDiag > 0 ? nD : nShift);
        __copy<TC>(nSize, vDiag, vDiag.incr(), pD1, nIncr);
        __copy<TC>(nSize, vDiag, vDiag.incr(), pD2, nIncr);
        __conj<TC>(pD2, nSize, nIncr);
        return *this;
    }

    basic_schmatrix& set_main_diag(const RVector& vDiag) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vDiag.size());
        __copy_real<TR,TC>(this->get(), this->msize(), this->ld() + 1, vDiag, vDiag.incr());
        return *this;
    }

    basic_schmatrix& assign_real(const basic_srsmatrix<TR>& mRe) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mRe.msize());
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), mRe.nsize());
        __copy_real<TR,TC>(this->get(), this->size(), this->incr(), mRe._pd(), mRe.incr());
        return *this;
    }

    // fills real part
    basic_schmatrix& set_real(TR d)
    {
        this->_set_real_number(d);
        return *this;
    }

    basic_schmatrix& resize(tint nNewDim) throw(cvmexception)
    {
        this->_resize2(nNewDim, nNewDim);
        return *this;
    }

    bool operator == (const basic_schmatrix& m) const {
        return this->msize() == m.msize() && this->nsize() == m.nsize() && this->_mequals(m);
    }

    bool operator != (const basic_schmatrix& m) const {
        return !(this->operator == (m));
    }

    basic_schmatrix& operator << (const basic_schmatrix& m) throw(cvmexception)
    {
        this->_replace(m);
        this->_massign(m);
        return *this;
    }

    basic_schmatrix operator + (const basic_schmatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        basic_schmatrix mSum(*this);
        mSum._mincr(m);
        return mSum;
    }

    basic_schmatrix operator - (const basic_schmatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        basic_schmatrix mDiff(*this);
        mDiff._mdecr(m);
        return mDiff;
    }

    basic_schmatrix& sum(const basic_schmatrix& m1, const basic_schmatrix& m2) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m2.msize());
        this->_msum(m1, m2);
        return *this;
    }

    basic_schmatrix& diff(const basic_schmatrix& m1, const basic_schmatrix& m2) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.msize());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m2.msize());
        this->_mdiff(m1, m2);
        return *this;
    }

    basic_schmatrix& operator += (const basic_schmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        this->_mincr(m);
        return *this;
    }

    basic_schmatrix& operator -= (const basic_schmatrix& m) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        this->_mdecr(m);
        return *this;
    }

    basic_schmatrix operator - () const
    {
        static const TR mone(-1.);
        basic_schmatrix mRes(*this);
        mRes._scalr(mone);
        return mRes;
    }

    // plus identity, prefix
    basic_schmatrix& operator ++ ()
    {
        this->_plus_plus();
        return *this;
    }

    // plus identity, postfix
    basic_schmatrix operator ++ (int)
    {
        this->_plus_plus();
        return *this;
    }

    // minus identity, prefix
    basic_schmatrix& operator -- ()
    {
        this->_minus_minus();
        return *this;
    }

    // minus identity, postfix
    basic_schmatrix operator -- (int)
    {
        this->_minus_minus();
        return *this;
    }

    basic_schmatrix operator * (TR dMult) const
    {
        basic_schmatrix mRes(*this);
        mRes._scalr(dMult);
        return mRes;
    }

    basic_schmatrix operator / (TR dDiv) const throw(cvmexception)
    {
        basic_schmatrix mRes(*this);
        mRes._div(dDiv);
        return mRes;
    }

    BaseSCMatrix operator * (TC cMult) const
    {
        BaseSCMatrix mRes(*this);
        mRes._scalc(cMult);
        return mRes;
    }

    BaseSCMatrix operator / (TC cDiv) const throw(cvmexception)
    {
        BaseSCMatrix mRes(*this);
        mRes._div(cDiv);
        return mRes;
    }

    basic_schmatrix& operator *= (TR dMult)
    {
        this->_scalr(dMult);
        return *this;
    }

    basic_schmatrix& operator /= (TR dDiv) throw(cvmexception)
    {
        this->_div(dDiv);
        return *this;
    }

    // array normalizing
    basic_schmatrix& normalize()
    {
        this->_normalize();
        return *this;
    }

// 6.1: transposed (not conjugated) matrix
    basic_schmatrix operator !() const throw(cvmexception)
    {
        basic_schmatrix mRes(*this);
        return mRes.transpose();
    }

    basic_schmatrix operator ~() const {
        return *this;
    }

    basic_schmatrix& transpose(const basic_schmatrix& m) throw(cvmexception)
    {
        (*this) = m;
        return this->transpose();
    }

    basic_schmatrix& conj(const basic_schmatrix& m) throw(cvmexception)
    {
        (*this) = m;
        return *this;
    }

// 6.1: transposed (not conjugated) matrix
    basic_schmatrix& transpose() throw(cvmexception)
    {
        this->_transp();
        return *this;
    }

    basic_schmatrix& conj() {
        return *this;
    }

    CVector operator * (const CVector& v) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), v.size());
        CVector vRes(this->msize());
        this->_multiply(vRes, v, false);
        return vRes;
    }

    // special exclusion since matrix product is not commutative
    BaseCMatrix operator * (const BaseCMatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.msize());
        static const TR zero = TR(0.);
        static const TR one = TR(1.);
        BaseCMatrix mRes(m.msize(), m.nsize());
        mRes._hemm(true, *this, m, one, zero);
        return mRes;
    }

    BaseSCMatrix operator * (const BaseSCMatrix& m) const throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->nsize(), m.msize());
        static const TR zero = TR(0.);
        static const TR one = TR(1.);
        BaseSCMatrix mRes(this->msize());
        mRes._hemm(true, *this, m, one, zero);
        return mRes;
    }

    // 6.1: reversed vector operator % returns solution of A*X=B equation
    // overridden to mask out operator / (TC)
    CVector operator / (const CVector& v) const throw(cvmexception) {
        return v % (*this);
    }

// this = alpha*v*v' + beta*this
    basic_schmatrix& herk(TR alpha, const CVector& v, TR beta) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), v.size());
        CVector vc(v);   // has to guarantee incr to be 1
        __herk<TR,TC, basic_schmatrix>(false, alpha, 1, vc, vc.size(), beta, *this);
        this->_flip();
        return *this;
    }

// this = alpha*a*a' + beta*this or this = alpha*a'*a + beta*this
    basic_schmatrix& herk(bool bTransp, TR alpha, const BaseCMatrix& m, TR beta) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), bTransp ? m.nsize() : m.msize());
        __herk<TR,TC, basic_schmatrix>(bTransp, alpha, bTransp ? m.msize() : m.nsize(), m, m.ld(), beta, *this);
        this->_flip();
        return *this;
    }

// this = alpha*v1*v2' + alpha*v2*v1' + beta*this
    basic_schmatrix& her2k(TC alpha, const CVector& v1, const CVector& v2, TR beta) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), v1.size());
        _check_ne(CVM_SIZESMISMATCH, this->msize(), v2.size());
        CVector v1c(v1);   // has to guarantee incr to be 1
        CVector v2c(v2);
        __her2k<TR,TC, basic_schmatrix>(false, alpha, 1, v1c, v1c.size(), v2c, v2c.size(), beta, *this);
        this->_flip();
        return *this;
    }

// this = alpha*a*b' + alpha*b*a' + beta*this or this = alpha*a'*b + alpha*b'*a + beta*this
    basic_schmatrix& her2k(bool bTransp, TC alpha, const BaseCMatrix& m1, const BaseCMatrix& m2, TR beta) throw(cvmexception)
    {
        if (bTransp) {
            _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.nsize());
            _check_ne(CVM_SIZESMISMATCH, this->msize(), m2.nsize());
            _check_ne(CVM_SIZESMISMATCH, m1.msize(), m2.msize());
        } else {
            _check_ne(CVM_SIZESMISMATCH, this->msize(), m1.msize());
            _check_ne(CVM_SIZESMISMATCH, this->msize(), m2.msize());
            _check_ne(CVM_SIZESMISMATCH, m1.nsize(), m2.nsize());
        }
        __her2k<TR,TC, basic_schmatrix>(bTransp, alpha, bTransp ? m1.msize() : m1.nsize(), m1, m1.ld(), m2, m2.ld(), beta, *this);
        this->_flip();
        return *this;
    }

    basic_schmatrix& inv(const basic_schmatrix& m) throw(cvmexception)
    {
        __inv<basic_schmatrix>(*this, m);
        return *this;
    }

    basic_schmatrix inv() const throw(cvmexception)
    {
        basic_schmatrix mRes(this->msize());
        __inv<basic_schmatrix>(mRes, *this);
        return mRes;
    }

    basic_schmatrix& exp(const basic_schmatrix& m, TR tol = basic_cvmMachSp<TR>()) throw(cvmexception)
    {
        __exp_symm<basic_schmatrix, TR>(*this, m, tol);
        return *this;
    }

    basic_schmatrix exp(TR tol = basic_cvmMachSp<TR>()) const throw(cvmexception)
    {
        basic_schmatrix msRes(this->msize());
        __exp_symm<basic_schmatrix, TR>(msRes, *this, tol);
        return msRes;
    }

// this = v(1)*I + v(2)*m + v(3)*m^2 + ... + v(N)*m^(N-1)
    basic_schmatrix& polynom(const basic_schmatrix& m, const RVector& v) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), m.msize());
        CVector vc(v);
        __polynom<TC, CVector>(this->get(), this->ld(), this->msize(), m._pd(), m._ldm(), vc);
        return *this;
    }

// returns v(1)*I + v(2)*this + v(3)*this^2 + ... + v(N)*this^(N-1)
    basic_schmatrix polynom(const RVector& v) const
    {
        basic_schmatrix msRes(this->msize());
        CVector vc(v);
        __polynom<TC, CVector>(msRes, msRes.ld(), this->msize(), this->get(), this->ld(), vc);
        return msRes;
    }

    RVector eig(BaseSCMatrix& mEigVect) const throw(cvmexception)
    {
        RVector vEig(this->msize());
        // we don't use _eig here since this is the special case - hermitian matrix
        __eig<RVector, basic_schmatrix, BaseSCMatrix>(vEig, *this, &mEigVect, true);
        return vEig;
    }

    RVector eig() const throw(cvmexception)
    {
        RVector vEig(this->msize());
        // we don't use _eig here since this is the special case - hermitian matrix
        __eig<RVector, basic_schmatrix, BaseSCMatrix>(vEig, *this, nullptr, true);
        return vEig;
    }

    BaseSCMatrix cholesky() const throw(cvmexception)
    {
        BaseSCMatrix mRes(*this);
        tint nOutInfo = __cholesky<BaseSCMatrix>(mRes);
        _check_negative(CVM_WRONGMKLARG, nOutInfo);
        _check_positive(CVM_NOTPOSITIVEDEFINITE, nOutInfo);
        mRes._clean_low_triangle();
        return mRes;
    }

    BaseSCMatrix bunch_kaufman(tint* nPivots) const throw(cvmexception)
    {
        BaseSCMatrix mRes(*this);
        __bunch_kaufman<BaseSCMatrix>(mRes, nPivots);
        return mRes;
    }

    basic_schmatrix& identity()
    {
        this->_vanish();
        this->_plus_plus();
        return *this;
    }

    basic_schmatrix& vanish()
    {
        this->_vanish();
        return *this;
    }

    basic_schmatrix& randomize_real(TR dFrom, TR dTo)
    {
        this->_randomize_real(dFrom, dTo);
        return *this;
    }

    basic_schmatrix& randomize_imag(TR dFrom, TR dTo)
    {
        this->_randomize_imag(dFrom, dTo);
        return *this;
    }

    // infinity-norm - the same as 1-norm for symmetric matrices
    TR norminf() const override
    {
        return this->norm1();
    }

    bool is_positive_definite() const
    {
        static const TR zero = TR(0.);
        const TC* pd = this->_pv();
        const tint nSize = this->_size();
        const tint nNext = this->_msize() + 1;
        CVM_ASSERT(pd, nSize * sizeof(TC))
        for (tint i = 0; i < nSize; i += nNext) {
            if (pd[i].real() <= zero) { // real numbers on main diagonal
                return false;
            }
        }
        return true;
    }

    bool equilibrate(basic_rvector<TR>& vScalings, CVector& vB) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vB.size());
        bool bRes = this->_equilibrate(vScalings);
        if (bRes) {
            for (tint i = CVM0; i < this->msize() + CVM0; ++i) {
                vB[i] *= vScalings[i];
            }
        }
        return bRes;
    }

    bool equilibrate(basic_rvector<TR>& vScalings, BaseCMatrix& mB) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), mB.msize());
        bool bRes = this->_equilibrate(vScalings);
        if (bRes) {
            for (tint j = CVM0; j <= mB.nsize() + CVM0; ++j) {
                for (tint i = CVM0; i <= this->msize() + CVM0; ++i) {
                    mB(i, j) *= vScalings[i];
                }
            }
        }
        return bRes;
    }

    // special care for symmetric matrices
    basic_schmatrix& _factorize(const basic_schmatrix& m, tint* nPivots, bool& bPositiveDefinite) throw(cvmexception)
    {
        (*this) = m;
        tint nOutInfo = __cholesky<BaseSCMatrix>(*this);
        _check_negative(CVM_WRONGMKLARG, nOutInfo);
        if (nOutInfo > 0) {
            (*this) = m;
            __bunch_kaufman<BaseSCMatrix>(*this, nPivots);
            bPositiveDefinite = false;
        } else {
            bPositiveDefinite = true;
        }
        return *this;
    }

    // makes lower triangle to be equal to conjugated upper one
    void _flip()
    {
        if (this->msize() > 1) {
            const tint nM1 = this->ld() + 1, nM1m = this->ld() - 1, nM2m = this->msize() - 1;
            tint i = 1, j = 1, m;
            for (;;) {
                m = this->msize() - i;
                __copy<TC>(m, this->get() + j + nM1m, this->ld(), this->get() + j, 1);
                __conj<TC>(this->get() + j, m, 1);
                if (i >= nM2m) break;
                ++i;
                j += nM1;
            }
        }
    }

    // redefinition of basic_array's function
    TC* _pd() override {
        return this->get();
    }

    // redefinition of basic_array's function
    const TC* _pd() const override {
        return this->get();
    }

    void _check_submatrix() const throw(cvmexception) override {
        throw cvmexception(CVM_SUBMATRIXNOTAVAILABLE, "schmatrix");
    }

protected:
    const TC* _pp(const BaseMatrix& m) const override {  // for _msum _mdiff etc.
        return m.get();
    }

    // not applicable - see below
    basic_schmatrix& set(TC z) throw(cvmexception)
    {
        this->_set(z);
        return *this;
    }

    void _set(TC) throw(cvmexception) override {
        throw cvmexception(CVM_BREAKS_HERMITIANITY, "set_real");
    }

    void _randomize_real(TR dFrom, TR dTo) override
    {
        this->BaseSCMatrix::_randomize_real(dFrom, dTo);
        this->_flip();
        this->_make_main_diag_real();
    }

    void _randomize_imag(TR dFrom, TR dTo) override
    {
        this->BaseSCMatrix::_randomize_imag(dFrom, dTo);
        this->_flip();
        this->_make_main_diag_real();
    }

    void _transp() override {
        this->_sq_transp();
    }

    //6.1: unlike transp, this one does nothing for hermitian matrices
    void _conj() override {
    }

    // returns main diagonal of low_up factorization
    CVector _low_up_diag(basic_array<tint,tint>&) const throw(cvmexception) override
    {
        // well, this stuff is useless for symmetric matrices. this call would mean serious CVM internal error
        throw cvmexception(CVM_NOTIMPLEMENTED, "_low_up_diag");
    }

    void _scalr(TR d) override {
        __scal<TR,TC>(this->get(), this->size(), this->incr(), d);
    }

    void _scalc(TC d) override {
        __scal<TC, TC>(this->get(), this->size(), this->incr(), d);
    }

    void _multiply(CVector& vRes, const CVector& v, bool bLeft) const override
    {
        // 6.1 fix for left-sided multiplication
        if (bLeft) {
            BaseCMatrix::_multiply(vRes, v, bLeft);
        } else {
            CVector vTmp;
            basic_schmatrix mTmp;
            static const TR zero = TR(0.);
            static const TR one = TR(1.);
            const TC* pDm = this->get();
            const TC* pDv = v;
            if (vRes.get() == pDv) vTmp << v;
            if (vRes.get() == pDm) mTmp << *this;
            __shmv<TC, basic_schmatrix, CVector>(vRes.get() == pDm ? mTmp : *this, one,
                                                 vRes.get() == pDv ? vTmp : v, zero, vRes);
        }
    }

    // sets both elements to keep matrix hermitian, checks ranges
    // zero based
    void _set_at(tint nRow, tint nCol, TC val) throw(cvmexception)
    {
        _check_lt_ge(CVM_OUTOFRANGE_LTGE1, nRow, CVM0, this->msize() + CVM0);
        _check_lt_ge(CVM_OUTOFRANGE_LTGE2, nCol, CVM0, this->nsize() + CVM0);
        if (nRow == nCol && _abs(val.imag()) > basic_cvmMachMin<TR>()) { // only reals on main diagonal
            throw cvmexception(CVM_BREAKS_HERMITIANITY, "real number");
        }
        this->get()[this->ld() * nCol + nRow] = val;
        if (nRow != nCol) {
            this->get()[this->ld() * nRow + nCol] = _conjugate(val);
        }
    }

    void _check_hermitian(TR tol) const throw(cvmexception)
    {
        TR discr;
        TC c1, c2;
        for (tint j = 0; j < this->nsize(); ++j) {
            for (tint i = 0; i < this->msize(); ++i) {
                if (i == j) {
                    discr = _abs(this->get()[this->ld() * j + i].imag());
                    if (discr > tol) { // real numbers on main diagonal
                        throw cvmexception(CVM_MATRIXNOTHERMITIAN, discr, tol);
                    }
                    continue;
                }
                c1 = this->get()[this->ld() * j + i];
                c2 = this->get()[this->ld() * i + j];
                if (!_conjugated<TR>(c1, c2, tol)) {
                    throw cvmexception(CVM_NOT_CONJUGATED, c1.real(), c1.imag(), c2.real(), c2.imag(), tol);
                }
            }
        }
    }

    void _solve(const CVector& vB, CVector& vX, TR& dErr,
                const TC* pLU, const tint* pPivots, int transp_mode) const throw(cvmexception) override
    {
        // 6.1: fix for non-positive definite solutions (we also need to call base version for transposed mode)
        if (transp_mode == 1 || !this->is_positive_definite()) {
            BaseSCMatrix::_solve(vB, vX, dErr, pLU, pPivots, transp_mode);
            return;
        }
        CVector vB1(vB);    // to make sure incr = 1 and equilibrate
        basic_rvector<TR> vScalings(this->msize());
        basic_schmatrix m(*this);
        const bool bEquilibrated = m.equilibrate(vScalings, vB1);
        CVector vX1(vB1);   // to make sure incr = 1
        __solve<TR,TC, basic_schmatrix>(m, 1, vB1, vB1.size(), vX1, vX1.size(), dErr, pLU, pPivots, 0); // no transpose

        if (bEquilibrated) {
            for (tint i = CVM0; i <= this->msize() - (1 - CVM0); ++i) {
                vX[i] = vX1[i] * vScalings[i];
            }
        } else {
            vX = vX1;
        }
    }

    void _solve(const BaseCMatrix& mB, BaseCMatrix& mX, TR& dErr,
                const TC* pLU, const tint* pPivots, int transp_mode) const throw(cvmexception) override
    {
        // 6.1: fix for non-positive definite solutions (we also need to call base version for transposed mode)
        if (transp_mode == 1 || !this->is_positive_definite()) {
            BaseSCMatrix::_solve(mB, mX, dErr, pLU, pPivots, transp_mode);
            return;
        }
        BaseCMatrix mB1(mB);    // to equilibrate
        basic_rvector<TR> vScalings(this->msize());
        basic_schmatrix m(*this);
        const bool bEquilibrated = m.equilibrate(vScalings, mB1);
        mX = mB1;
        __solve<TR,TC, basic_schmatrix>(m, mB.nsize(), mB, mB.ld(), mX, mX.ld(), dErr, pLU, pPivots, 0); // no transpose
        if (bEquilibrated) {
            for (tint j = CVM0; j < mX.nsize() + CVM0; ++j) {
                for (tint i = CVM0; i < this->msize() + CVM0; ++i) {
                    mX(i, j) *= vScalings[i];
                }
            }
        }
    }

    // matrix determinant
    TC _det() const throw(cvmexception) override
    {
        TC dDet = TC(0.);
        switch (this->msize()) {
        case 0:
            break;
        case 1:
            dDet = this->_ij_val(0, 0);
            break;
        case 2:
            dDet = this->_ij_val(0, 0) * this->_ij_val(1, 1) -
               this->_ij_val(1, 0) * this->_ij_val(0, 1);
            break;
        default:
            try {
                static const TC one(1., 0.);
                bool bPositiveDefinite = false;
                basic_schmatrix m(this->msize());
                basic_array<tint,tint> nPivots(this->msize());
                m._factorize(*this, nPivots, bPositiveDefinite);

                tint i;
                dDet = one;
                if (bPositiveDefinite) {
                    const CVector vUpDiag = m.diag(0);
                    for (i = CVM0; i < this->msize() + CVM0; ++i) {
                        dDet *= vUpDiag[i] * vUpDiag[i]; // here we use Cholesky factorization
                    }
                } else {
                    const basic_rvector<TR> vEig = this->eig();
                    for (i = CVM0; i < this->msize() + CVM0; ++i) {
                        dDet *= vEig[i]; // here we use eigenvalues. probably there is a better way.
                    }
                }
            }
            catch (const cvmexception& e) {
                if (e.cause() != CVM_WRONGBUNCHKAUFMANFACTOR) throw e;
            }
            break;
        }
        return dDet;
    }

    // matrix equilibration helper
    bool _equilibrate(basic_rvector<TR>& vScalings) throw(cvmexception)
    {
        _check_ne(CVM_SIZESMISMATCH, this->msize(), vScalings.size());
        bool bRes = false;
        TR dCond = TR();
        TR dMax  = TR();
        static const TR sp = basic_cvmMachSp<TR>();
        static const TR sp_inv = TR(1.) / sp;

        __poequ<TR,basic_schmatrix, basic_rvector<TR> >(*this, vScalings, dCond, dMax);

        if (dCond < TR(0.1) || _abs(dMax) <= sp || _abs(dMax) >= sp_inv) {
            bRes = true;
            for (tint i = 0; i < this->msize(); ++i) {
                for (tint j = i; j < this->msize(); ++j) {
                    this->get()[this->ld() * j + i] *= vScalings[i + CVM0] * vScalings[j + CVM0];
                }
            }
        }
        return bRes;
    }

    void _make_main_diag_real()
    {
        static const TR zero = TR(0.);
        __scal<TR,TR>(__get_imag_p<TR>(this->get()), this->msize(), (this->ld() + 1) * 2, zero);
    }

    void _check_gerc()          throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "gerc", "schmatrix");}
    void _check_geru()          throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "geru", "schmatrix");}
    void _check_rank1update_c() throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "rank1update_c", "schmatrix");}
    void _check_rank1update_u() throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "rank1update_u", "schmatrix");}
    void _check_gemm()          throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "gemm", "schmatrix");}
    void _swap_rows(tint, tint) throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "swap_rows", "schmatrix");}
    void _swap_cols(tint, tint) throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "swap_cols", "schmatrix");}
    void _set_imag_number(TR)   throw(cvmexception) override { throw cvmexception(CVM_METHODNOTAVAILABLE, "set_imag", "schmatrix");}
};


template<typename TR>
inline basic_rvector<TR> operator * (TR d, const basic_rvector<TR>& v) {
    return v * d;
}
template<typename TR>
inline basic_rmatrix<TR> operator * (TR d, const basic_rmatrix<TR>& m) {
    return m * d;
}
template<typename TR>
inline basic_srmatrix<TR> operator * (TR d, const basic_srmatrix<TR>& m) {
    return m * d;
}
template<typename TR>
inline basic_srbmatrix<TR> operator * (TR d, const basic_srbmatrix<TR>& m) {
    return m * d;
}
template<typename TR>
inline basic_srsmatrix<TR> operator * (TR d, const basic_srsmatrix<TR>& m) {
    return m * d;
}

template<typename TR, typename TC>
inline basic_cvector<TR,TC> operator * (TR d, const basic_cvector<TR,TC>& v) {
    return v * d;
}
template<typename TR, typename TC>
inline basic_cmatrix<TR,TC> operator * (TR d, const basic_cmatrix<TR,TC>& m) {
    return m * d;
}
template<typename TR, typename TC>
inline basic_scmatrix<TR,TC> operator * (TR d, const basic_scmatrix<TR,TC>& m) {
    return m * d;
}
template<typename TR, typename TC>
inline basic_scbmatrix<TR,TC> operator * (TR d, const basic_scbmatrix<TR,TC>& m) {
    return m * d;
}
template<typename TR, typename TC>
inline basic_schmatrix<TR,TC> operator * (TR d, const basic_schmatrix<TR,TC>& m) {
    return m * d;
}

template<typename TR, typename TC>
inline basic_cvector<TR,TC> operator * (std::complex<TR> c, const basic_cvector<TR,TC>& v) {
    return v * c;
}
template<typename TR, typename TC>
inline basic_cmatrix<TR,TC> operator * (std::complex<TR> c, const basic_cmatrix<TR,TC>& m) {
    return m * c;
}
template<typename TR, typename TC>
inline basic_scmatrix<TR,TC> operator * (std::complex<TR> c, const basic_scmatrix<TR,TC>& m) {
    return m * c;
}
template<typename TR, typename TC>
inline basic_scbmatrix<TR,TC> operator * (std::complex<TR> c, const basic_scbmatrix<TR,TC>& m) {
    return m * c;
}
template<typename TR, typename TC>
inline basic_scmatrix<TR,TC> operator * (std::complex<TR> c, const basic_schmatrix<TR,TC>& m) {
    return m * c;
}

template<typename TR>
inline basic_rvector<TR> operator * (CVM_LONGEST_INT d, const basic_rvector<TR>& v) {
    return v * static_cast<TR>(d);
}
template<typename TR>
inline basic_rmatrix<TR> operator * (CVM_LONGEST_INT d, const basic_rmatrix<TR>& m) {
    return m * static_cast<TR>(d);
}
template<typename TR>
inline basic_srmatrix<TR> operator * (CVM_LONGEST_INT d, const basic_srmatrix<TR>& m) {
    return m * static_cast<TR>(d);
}
template<typename TR>
inline basic_srbmatrix<TR> operator * (CVM_LONGEST_INT d, const basic_srbmatrix<TR>& m) {
    return m * static_cast<TR>(d);
}
template<typename TR>
inline basic_srsmatrix<TR> operator * (CVM_LONGEST_INT d, const basic_srsmatrix<TR>& m) {
    return m * static_cast<TR>(d);
}

template<typename TR, typename TC>
inline basic_cvector<TR,TC> operator * (CVM_LONGEST_INT d, const basic_cvector<TR,TC>& v) {
    return v * static_cast<TR>(d);
}
template<typename TR, typename TC>
inline basic_cmatrix<TR,TC> operator * (CVM_LONGEST_INT d, const basic_cmatrix<TR,TC>& m) {
    return m * static_cast<TR>(d);
}
template<typename TR, typename TC>
inline basic_scmatrix<TR,TC> operator * (CVM_LONGEST_INT d, const basic_scmatrix<TR,TC>& m) {
    return m * static_cast<TR>(d);
}
template<typename TR, typename TC>
inline basic_scbmatrix<TR,TC> operator * (CVM_LONGEST_INT d, const basic_scbmatrix<TR,TC>& m) {
    return m * static_cast<TR>(d);
}
template<typename TR, typename TC>
inline basic_schmatrix<TR,TC> operator * (CVM_LONGEST_INT d, const basic_schmatrix<TR,TC>& m) {
    return m * static_cast<TR>(d);
}


#if defined (CVM_FLOAT)
typedef float  treal; 
#else
typedef double treal; 
#endif

typedef std::complex<treal> tcomplex; 

typedef basic_array<tint,tint>           iarray;     
typedef basic_rvector<treal>             rvector;    
typedef basic_rmatrix<treal>             rmatrix;    
typedef basic_srmatrix<treal>            srmatrix;   
typedef basic_cvector<treal, tcomplex>   cvector;    
typedef basic_cmatrix<treal, tcomplex>   cmatrix;    
typedef basic_scmatrix<treal, tcomplex>  scmatrix;   
typedef basic_srbmatrix<treal>           srbmatrix;  
typedef basic_scbmatrix<treal, tcomplex> scbmatrix;  
typedef basic_srsmatrix<treal>           srsmatrix;  
typedef basic_schmatrix<treal, tcomplex> schmatrix;  


template<typename TR>
inline const basic_srmatrix<TR> basic_eye_real(tint nM)
{
    basic_srmatrix<TR> mI(nM);
    ++mI;
    return mI;
}
template<typename TR, typename TC>
inline const basic_scmatrix<TR,TC> basic_eye_complex(tint nM)
{
    basic_scmatrix<TR,TC> mI(nM);
    ++mI;
    return mI;
}

inline const srmatrix eye_real(tint nM) {
    return basic_eye_real<treal>(nM);
}
inline const scmatrix eye_complex(tint nM) {
    return basic_eye_complex<treal, tcomplex>(nM);
}

inline treal cvmMachMin() {
    return basic_cvmMachMin<treal>();
}

inline treal cvmMachSp() {
    return basic_cvmMachSp<treal>();
}


#if !defined (CVM_STD_MUTEX)

class CriticalSection
{
#if defined (CVM_MT)
private:
    bool mbOK;

#if defined (WIN32) || defined (_WIN32)
#if defined (CVM_USE_CRITICAL_SECTION_NOT_MUTEX)
    ::CRITICAL_SECTION mCriticalSection;
#else
    HANDLE mMutex;
#endif
#else                                                       // POSIX Threads library assumed
    pthread_mutex_t mMutex;
    pthread_mutexattr_t mMutexAttr;
#endif
#endif

public:
    CriticalSection();
    ~CriticalSection();

    void enter()
#if defined (CVM_MT)
    throw(cvmexception)
#endif
          ;
    void leave()
#if defined (CVM_MT)
    throw(cvmexception)
#endif
          ;
};

class Lock
{
    CriticalSection& mcs;
public:
    Lock(CriticalSection& cs) : mcs(cs) {
        mcs.enter();
    }
    ~Lock() {
        mcs.leave();
    }
private:
    Lock& operator = (const Lock&) {
        return *this;
    }
};
#endif



#if defined(CVM_USE_USER_LITERALS)

constexpr std::complex<treal> operator "" _i(long double im)
{
    return { 0., static_cast<treal>(im) };
}

constexpr std::complex<treal> operator "" _i(unsigned long long int im)
{
    return { 0., static_cast<treal>(im) };
}

template<typename T, typename TR>
inline std::complex<TR> operator + (T re, const std::complex<TR>& c) {
    return { static_cast<TR>(re) + c.real(), c.imag() };
}

template<typename T, typename TR>
inline std::complex<TR> operator - (T re, const std::complex<TR>& c) {
    return { static_cast<TR>(re) - c.real(), - c.imag() };
}

template<typename T, typename TR>
inline std::complex<TR> operator + (const std::complex<TR>& c, const T& re) {
    return { c.real() + static_cast<TR>(re), c.imag() };
}

template<typename T, typename TR>
inline std::complex<TR> operator - (const std::complex<TR>& c, const T& re) {
    return { c.real() - static_cast<TR>(re), c.imag() };
}

#endif


CVM_NAMESPACE_END


#if !defined (_MSC_VER)
#   define XERBLA xerbla_
#endif

extern "C"
{
    void __stdcall XERBLA(const char* szSubName,
#if defined (CVM_PASS_STRING_LENGTH_TO_FTN_SUBROUTINES)
                          const tint nLen,
#endif
                          const tint* pnParam) throw(cvm::cvmexception);
}

#endif                  // _CVM_H